Compiler: Encyclopedia II - Compiler - Types of compilers

Compiler - Types of compilers

Compiler - Native versus cross compiler

Most compilers are classified as either native compilers or cross compilers.

A compiler may produce binary output intended to run on the same type of computer and operating system ("platform") as the compiler itself runs on. This is sometimes called a native-code compiler. Alternatively, it might produce binary output designed to run on a different platform. This is known as a cross compiler. Cross compilers are very useful when bringing up a new hardware platform for the first time (see bootstrapping). Cross compilers are also necessary when developing software for microcontroller systems that have barely enough storage for the final machine code, much less a compiler. Compilers which are capable of producing both native and foreign binary output may be called either a cross compiler or a native compiler depending on a specific use, although it would be more correct to classify them as a cross compilers.

Interpreters are never classified as native or cross compilers, because they do not output a binary representation of their input code.

Virtual machine (VM) compilers are typically not classified as either native or cross compilers. However, if need be, they can be classified as one or the other, especially in the less usual cases where a compiler is running inside the same VM (making it a native compiler), or where a compiler is capable of producing an output for several different platforms, including a VM (making it a cross compiler).

Compiler - One-pass versus multi-pass compilers

All compilers are either one-pass or multi-pass.

• One-pass compilers, like early compilers for the Pascal programming language.
  • The compilation is done in one pass over the program source, hence the compilation is completed very quickly.
• Multi-pass compilers, like 2-pass compilers or 3-pass compilers
  • The compilation is done step by step. Each step uses the result of the previous step and creates another intermediate result. This can improve final performance at the cost of compilation speed.

While the typical multi-pass compiler outputs machine code from its final pass, there are several other types:

• A "source-to-source compiler" is a type of compiler that takes a high level language as its input and outputs a high level language. For example, an automatic parallelizing compiler will frequently take in a high level language program as an input and then transform the code and annotate it with parallel code annotations (e.g. OpenMP) or language constructs (e.g. Fortran's DOALL statements).
• Stage compiler that compiles to assembly language of a theoretical machine, like some Prolog implementations
  • This Prolog machine is also known as the Warren Abstract Machine (or WAM). Byte-code compilers for Java, Python (and many more) are also a subtype of this.
• Just-in-time compiler, used by Smalltalk and Java systems, and also by Microsoft .Net's Common Intermediate Language (CIL)
  • Applications are delivered in bytecode, which is compiled to native machine code just prior to execution.

Adapted from the Wikipedia article "Types of compilers", under the G.N U Free Docmentation License. Please also see http://en.wikipedia.org/wiki