A Catalog of Research Compiler Infrastructures and Tools

Pin is a dynamic instrumentation tool. From the website:

Pin is a tool for the dynamic instrumentation of programs. It supports Linux binary executables for Intel (R) Xscale (R), IA-32, IA-32E (64 bit x86), and Itanium (R) processors. It also allow instrumentation of Windows programs on IA-32 and Intel (R) 64 processors

Pin was designed to provide functionality similar to the popular ATOM toolkit for Compaq’s Tru64 Unix on Alpha, i.e. arbitrary code (written in C or C++) can be injected at arbitrary places in the executable. Unlike Atom, Pin does not instrument an executable statically by rewriting it, but rather adds the code dynamically while the executable is running. This also makes it possible to attach Pin to an already running process.

Pin provides a rich API that abstracts away the underlying instruction set idiosyncrasies and allows context information such as register contents to be passed to the injected code as parameters. Pin automatically saves and restores the registers that are overwritten by the injected code so the application continues to work. Limited access to symbol and debug information is available as well.

Thanks to Marco van de Voort for a pointer to Free Pascal. Marco points out that the development version of Free Pascal supports a variety of dialects of Pascal, has a modular code generator and linker, and supports multiple backends.

SableVM is a free/Free spec-compliant and extensible JVM. It includes a JIT for PPC, SPARC and x86, but runs on several more architectures. It supports several different interpreter dispatch models (switched, threaded, inlined) and has an efficient runtime system. It is implemented in C with extensive use of M4 macros.

ERCO is a Java-to-native compiler developed by the Laboratory for Software Technologies at ETH Zürich. From the web site:

The ETH Research COmpiler (ERCO) is a research Java byte-code to native compiler that is used in several projects in our group as for teaching in advanced compiler classes. We translate the Java bytecode to an internal representation in static single assignment form on which we perform several analyses and some optimizations. The backend generates native object file for the Intel IA-32 platform which are then linked to the Java runtime system provided by the GCJ project.

Judging from the comments on the web page, ERCO is at a fairly early stage of development as of this writing.

Machine SUIF is “a flexible, extensible, and usable infrastructure for constructing compiler back ends.” Most notably, Machine SUIF provides a way to generate code for x86, IA-64, or Alpha from SUIF code, as well as “libraries for control- and data-flow analysis, and passes for register allocation, instruction scheduling, scalar optimization, and code layout.” The optimizations supplied by Machine SUIF are implemented on top of a substrate-independent API — therefore, one can use Machine SUIF optimizations in other compiler infrastructures by re-implementing an API. Furthermore, target-specific information to be used by low-level optimizations is supplied by dynamically-linked libraries, allowing the possibility of portable low-level optimization code.

Manoj Plakal points out that I have not mentioned GCC. GCC, of course, has frontends for many languages, including C, C++, Objective-C, Java, Fortran, Pascal, and Ada; and backends for nearly every computer architecture ever created as well as a great many that weren’t. It has a reputation for being difficult to use for research, but that hasn’t stopped many people from doing so.

Feel free to TrackBack this entry if you’re using GCC for programming languages research, or if you have tips for using GCC for programming languages research.

C–– is a “portable assembly language” — a target language for compiler backends that can compile into native code on several platforms. It is implemented in OCaml and appears sufficiently general to handle a wide range of language features: for example, all values are untyped strings of bits, multiple return values are possible, and tail call optimization is readily available. C–– also supports a run-time interface, so that one may use implementations of support code that are most suitable for a given language.

There are code generators for x86, PPC, IA-64, SPARC, MIPS, ARM, and Alpha. According to the web page, as of July 2003, the x86 backend is reasonably mature, whereas the rest are under development.

Thanks to Kent Hunter for the pointer.

MLRISC is a configurable compiler back-end that supports generating code for Alpha, PA-RISC, Sparc, x86, PowerPC, MIPS, and TI C6x processors. The MLRISC intermediate representation, target instruction set, flowgraph, and optimization suite are all parameterizable, so that a front-end can specialize each to produce the most suitable backend for a given language. The system is implemented in ML and is used by several compilers, including:

• Standard ML of New Jersey
• Church
• LGIC (a compiler for CHILL)
• The Moby Language
• MLRISC was also used in an early implementation of the C–– portable assembly language.

Thanks to Kent Hunter for the pointer.

Joeq is a virtual machine that can execute, analyze, and optimize Java class files, x86 ELF object (.o) files, and files in the SUIF intermediate representation. It is implemented in Java, and runs both in a hosted mode (on another JVM) and self-hosted (compiling itself).