compilers

The issue is that most compilers with precise GC---AOT or otherwise---are built around that assumption from the very beginning.

GCC, clang, and other real-world compilers usually generate Control Flow Graphs (CFGs) at the output stage, not ASTs.

Anyway, the issue with JVMs is that they don't have predictable performance, not that the compilers can't be ported.

AOT compilers certainly have that (or at least, enough of it to get the job done).

OCaml and Haskell are two examples of languages with non-JIT AOT compilers (ocamlopt and ghc, respectively) that do precise GC.

The role involves leading our language and compiler implementation efforts, building optimizing compilers to generate efficient code across HPC hardware.

One would have to implement generics, then spend several programmer-years tuning the compiler over various programs, compilers are complex machines.

Even worse are mixtures of signed and unsigned operands in expressions; luckily, C compilers tend to have reasonably decent warnings about that.

Generally, compilers aren't very good at compiling code that isn't idiomatic for the language.

The Intel TPM is a secret plan to take away compilers from general public.

However, it is such a common idiom that GCC and other compilers explicitly allow using unions to get around the strict aliasing rules, so long as the access is always performed through the union.

And most importantly, the final binaries you get with Delphi are indistinguishable (size, speed) from those produced by C/C++ compilers, if not better sometimes.

Compilers are now starting to do all manner of nasty optimizations on undefined behavior.