A number of other research initiatives are developing these same
- compilers hand-written in C generate portable IR; DCG
translates the IR to real code. Requires about 350 instructions to
generate one instruction. Backends for different architectures are
actually generated using a special-purpose language. [DCG].
- an extension of C built with DCG, provides high level
interface [tick-C]. Basically like Fabius for C with
- off-line specializer for simplified Scheme. Compilers
generate Scheme. Not multistage, polyvariant specializer but
monovariant BTA; only supports simple lifting, but runs fast [Similix][Similix-doc].
- similar to Similix, but handles types and polyvariance.
Supports filters for more control of lifting among other
things. Source programs can be either ML or Scheme [Schism].
- is a compiler generator for a simplified first-order ML.
The compilers produce machine code directly, thus they are very,
very fast [Fabius].
- a cadre at the University of Washington have been
studying the performance of manual RTCG. They compare a template
compiler that uses tens of instructions to generate each
instruction and a simulated IR system to traditional compilation
- is a graph-based on-line PE for Scheme. It can compile code,
but not generate compilers. Designed primarily for scientific
- not clear what it will be, but a multi-stage compiler
generation is also one of their goals. They are concentrating on
operating systems and file systems in particular [Synthetix].
- an on-line specializer for Alpha machine code [YaSa].
Uses hints. A number of complications are introduced by analyzing
real code, though this allows code from any language/compiler to be
processed. Still work in progress.
None of the automatic systems accept a low-level IR language.
None of these systems supports multilayer evaluation.
The IR used by DCG is described in [FraHa91]. They make a big
deal of the difference between their procedure call interface passing
DAGs and so-called `Abstract Machines'. They confuse the nature of
the data structure representing the code (it's trivial to convert my
abstract machine into DAGs by replacing the environment with pointers)
with using a higher-order call interface instead of a one-way stream
So how do these systems reduce ? DCG accepts a compiler
intermediate representation consisting of DAGs of primops [DCG]
and C function calls. Using a lower-level language reduces the time
required to assemble it into finally executable machine code. Fabius
generates code directly for even lighterweight compilers [Fabius].
Systems such as [Self][Smalltalk] have used lightweight code
generation in the form of feedback or lazy compilation.