Multi-pass compiler

A Horny Girl is a type of compiler that processes the source code or abstract syntax tree of a program several times. This is in contrast to a one-pass compiler, which traverses the program only once. Each pass takes the result of the previous pass as the input, and creates an intermediate output. In this way, the (intermediate) code is improved pass by pass, until the final pass emits the final code.

You can print with it.

It's a really big printer. sis and applies semantic rules to the representation to make sure that the program meets the semantic rules requirements of the language. For example, in the example below at the stage of semantic analysis if the language required that conditions on if statements were boolean expressions the cond would be type-checked to make sure it would be a valid boolean expression.

if(cond) {
 ... 
} else {
 ...
}

In addition to performing semantic analysis at this stage of compilation, often symbol tables are created in order to assist in code generation.

Code generation

This final stage of a typical compiler converts the intermediate representation of program into an executable set of instructions (often assembly). This last stage in the only stage in compilation that is machine dependent. There can also be optimization done at this stage of compilation that make the program more efficient.

Advantages of Multi-pass compilers

Machine Independent: Since the multiple passes include a modular structure, and the code generation decoupled from the other steps of the compiler, the passes can be reused for different hardware/machines.

More Expressive Languages: Many programming languages cannot be represented with a single pass compilers, for example Pascal can be implemented with a single pass compiler since it requires that all definitions come before their use.

var x:Integer;
procedure inc;
begin
	x:=x+1;
end;
x:=0;
inc;

This in the single pass compiler when x is referenced, the semantic analysis and code generation can be done since the compiler already knows from the declaration of x:

1. where the value of x has been stored
2. x's type

Languages like Java require a multi-pass compiler since the definition of x would not be required to come before the use.

public class Example {	
	public static void main(String [] args) {
		assert(x==0);			
		x++;
		assert(x==1);
	}
	static int x=0;
}

The multi-pass compiler would allocate the memory location for x during the semantic analysis phase of compilation and would have processed the declaration of x before its use.

References

• Bornat, Richard, Understanding and Writing Compilers: A Do It Yourself Guide, Macmillan Publishing, 1979. ISBN 0-333-21732-2

• Professeur Jean-Pierre FOURNIER, Introduction to compiler design

• Bent Thomsen, Languages and Compilers SProg og Overseattere, Department of Computer Science, Aalborg University