CSCE 531 Compiler Construction Ch.7: Code Generation

1
CSCE 531Compiler ConstructionCh.7 Code
Generation

• Spring 2008
• Marco Valtorta
• mgv_at_cse.sc.edu

2
Acknowledgment

• The slides are based on the textbook and other
  sources, including slides from Bent Thomsens
  course at the University of Aalborg in Denmark
  and several other fine textbooks
• The three main other compiler textbooks I
  considered are
• Aho, Alfred V., Monica S. Lam, Ravi Sethi, and
  Jeffrey D. Ullman. Compilers Principles,
  Techniques, Tools, 2nd ed. Addison-Welsey,
  2007. (The dragon book)
• Appel, Andrew W. Modern Compiler Implementation
  in Java, 2nd ed. Cambridge, 2002. (Editions in
  ML and C also available the tiger books)
• Grune, Dick, Henri E. Bal, Ceriel J.H. Jacobs,
  and Koen G. Langendoen. Modern Compiler Design.
  Wiley, 2000

3
What This Lecture is About
A compiler translates a program from a high-level
language into an equivalent program in a
low-level language.
Triangle Program
Compile
TAM Program
Run
Result
4
Programming Language specification

• A Language specification has (at least) three
  parts
• Syntax of the language usually formal EBNF
• Contextual constraints
• scope rules (often written in English, but can be
  formal)
• type rules (formal or informal)
• Semantics
• defined by the implementation
• informal descriptions in English
• formal using operational, axiomatic, or
  denotational semantics

5
The Phases of a Compiler
Source Program
Syntax Analysis
Error Reports
Abstract Syntax Tree
Contextual Analysis
Error Reports
Decorated Abstract Syntax Tree
Code Generation
Chapter 7
Object Code
6
Multi Pass Compiler
A multi pass compiler makes several passes over
the program. The output of a preceding phase is
stored in a data structure and used by subsequent
phases.
Dependency diagram of a typical Multi Pass
Compiler
Compiler Driver
Chapter 7
calls
calls
calls
Syntactic Analyzer
Contextual Analyzer
Code Generator
7
Issues in Code Generation

• Code Selection
• Deciding which sequence of target machine
  instructions will be used to implement each
  phrase in the source language.
• Storage Allocation
• Deciding the storage address for each variable in
  the source program. (static allocation, stack
  allocation etc.)
• Register Allocation (for register-based machines)
• How to use registers efficiently to store
  intermediate results.

We use a stack based machine. This is not an
issue for us
8
Code Generation
Source Program
Target program
let var n integer var c charin begin c
n n1end
PUSH 2LOADL 38STORE 1SBLOAD 0LOADL 1CALL
addSTORE 0SBPOP 2HALT
Source and target program must be semantically
equivalent
Semantic specification of the source language is
structured in terms of phrases in the SL
expressions, commands, etc. gt Code generation
follows the same inductive structure.
Q Can you see the connection with denotational
semantics?
9
Inductive Code Generation
Inductive means code generation for a big
structure is defined in terms of putting together
chunks of code that correspond to the
sub-structures.
Example Sequential Command code generation
Semantic specification The sequential command C1
C2 is executed as follows first C1 is executed
then C2 is executed. Code generation
function execute Command -gt Instruction execut
e C1 C2 execute C1 execute C2
instructions for C1
instructions for C1 C2
instructions for C2
10
Inductive Code Generation
Example Assignment command code generation
Code generation function execute I E
evaluate E STORE address I
instructions for E yield value for E on top of
the stack
instruction to store result into variable
These pictures of the code layout for a
particular source language construct are called
code templates. Inductive means A code template
specifies the object code to which a phrase is
translated, in terms of the object code to which
its subphrases are translated.
11
Inductive Code Generation
Example code generation for a larger phrase in
terms of its subphrases
LOAD f LOAD n CALL mult STORE f
execute f fn
execute f fn n n-1
LOAD n CALL pred STORE n
execute n n-1
12
Specifying Code Generation with Code Templates
For each phrase class P in the abstract syntax
of the source language Define code function fP
P -gt Instruction that translate each phrase in
class P to object code.
We specify the function fP by code templates.
Typically they look like
fP QR fQ Q fR R
note A phrase class typically corresponds to a
non-terminal of the abstract syntax. This in
turn corresponds to an abstract class in the Java
classes that implement the AST nodes. (for
example Expression, Command, Declaration)
13
Specifying Code Generation with Code Templates
Example Code templates specification for Mini
Triangle
RECAP The mini triangle AST
Program Command Program Command
V-name Expression AssignCmd let
Declaration in Command LetCmd ... Expression
Integer-Literal IntegerExp
V-name VnameExp Operator
Expression UnaryExp Expression Op
Expression BinaryExp Declaration
... V-name Identifier SimpleVName
14
Specifying Code Generation with Code Templates
The code generation functions for Mini Triangle
Phrase Class Function Effect of the generated
code
Run program P then halt. Starting and finishing
with empty stack Execute Command C. May update
variables but does not shrink or grow the
stack. Evaluate E, net result is pushing the
value of E on the stack. Push value of constant
or variable on the stack. Pop value from stack
and store in variable V Elaborate declaration,
make space on the stack for constants and
variables in the decl.
Program Command Expres- sion V-name V-name Decl
a-ration
run P execute C evaluate E fetch V assign
V elaborate D
15
Code Generation with Code Templates
The code generation functions for Mini Triangle
Programs
run C execute C HALT
Commands
execute V E evaluate E assign
V execute I ( E ) evaluate E CALL
p where p is address of the routine named I
16
Code Generation with Code Templates
Commands
execute C1 C2 execute C1 execute
C2 execute if E then C1 else C2 evaluate
E JUMPIF(0) g execute C1 JUMP h g execute
C2 h
17
Code Generation with Code Templates
Commands
execute while E do C JUMP h g execute
C h evaluateE JUMPIF(1) g
18
Code Generation with Code Templates
Repeat Command code template
execute repeat C until E g execute
C h evaluateE JUMPIF(0) g execute let D
in C elaborateD execute C POP(0) s if
sgt0 where s amount of storage allocated by D
C
E
19
Code Generation with Code Templates
Expressions
evaluate IL note IL is an integer
literal LOADL v where v the integer value of
IL evaluate V note V is variable
name fetchV evaluate O E note O is a
unary operator evaluateE CALL p where p
address of routine for O evaluate E1 O E2
note O is a binary operator evaluateE1 eval
uateE2 CALL p where p address of routine for
O
20
Code Generation with Code Templates
Variables note Mini triangle only needs
static allocation (Q why is that? )
fetch V LOAD dSB where d address of V
relative to SB assign V STORE dSB where
d address of V relative to SB
21
Code Generation with Code Templates
Declarations
elaborate const I E evaluateE elaborat
e var I T PUSH s where s size of
T elaborate D1 D2 elaborate
D1 elaborate D2
THE END these are all the code templates for
Mini Triangle. Now lets put them to use in an
example.
22
Example of Mini Triangle Code Generation
execute while igt0 do ii2 JUMP h g LOAD
i LOADL 2 CALL add STORE i h LOAD i LOADL
0 CALL gt JUMPIF(1) g
evaluate i2
execute ii2
evaluate igt0
Note Picture shows a few steps but not all
23
Special Case Code Templates
There are often several ways to generate code for
an expression, command, etc. The templates we
defined work, but sometimes we can get more
efficient code for special cases gt special case
code templates.
Example
evaluate i1 LOAD i LOADL 1 CALL add
evaluate i1 LOAD i CALL succ
more efficient code for the special case 1
what we get with the general code templates
24
Special Case Code Templates
Example some special case code template for
1, -1,
evaluate E 1 evaluate E CALL succ
evaluate 1 E evaluate E CALL succ
evaluate E - 1 evaluate E CALL pred
A special-case code template is one that is
applicable to phrase of a special form. Such
phrases are also covered by a more general form.
25
Special Case Code Templates
Example Inlining known constants.
execute let const n7 var iInteger
in inn LOADL 7 PUSH 1 LOAD
n LOAD n CALL mult STORE i POP(0) 2
elaborate const n7
elaborate var iInteger
execute inn
This is how the code looks like with no special
case templates
26
Special Case Code Templates
Example Inlining known constants.
Special case templates for inlining literals.
elaborate const I IL no code
fetch I special case if I is a known literal
constant LOADL v where v is the known value of I
execute let const n7 var iInteger in inn
PUSH 1 LOADL 7 LOADL 7 CALL mult STORE
i POP(0) 1
27
Code Generation Algorithm
The code templates specify how code is to be
generated gt determines code generation
algorithm. Generating code traversal of the AST
emitting instructions one by one. The code
templates determine the order of the traversal
and the instructions to be emitted.
We will now look at how to implement a Mini
Triangle code generator in Java.
28
Representation of Object Program Instructions
public class Instruction public byte op //
op-code 0..15 public byte r // register field
(0..15) public byte n // length field
(0..255) public short d // operand f.
(-32767..32767) public static final byte //
op-codes LOADop 0, LOADAop 1, ... public
static final byte // register numbers CBr 0,
CTr 1, SBr 4, STr 5, public
Instruction(byte op,byte n, byte
r,short d) ...
29
Representation of Object Program Emitting Code
public class Encoder private Instruction
code new Instruction1024 private short
nextInstrAddr 0 private void emit(byte
op,byte n, byte r,short d)
codenextInstrAddrnew
Instruction( op,n,r,d) ... lots of other
stuff in here of course ...
30
Developing a Code Generator Visitor
31
Developing a Code Generator Visitor
For variables we have two distinct code
generation functions fetch and assign. gt Not
implemented as visitor methods but as separate
methods. public void encodeFetch(Vname name)
... as specified by fetch template ... public
void encodeAssign(Vname name) ... as
specified by assign template ...
32
Developing a Code Generator Visitor
public class Encoder implements Visitor
... / Generating code for entire Program
/ public Object visitProgram(Program
prog, Object arg ) prog.C.visit(th
is,arg) emit a halt instruction return
null
33
Developing a Code Generator Visitor
RECAP
execute V E evaluate E assign V
/ Generating code for commands / public Object
visitAssignCommand( AssignCommand
com,Object arg) com.E.visit(this,arg) encode
Assign(com.V) return null
34
Developing a Code Generator Visitor
execute I ( E ) evaluate E CALL p where p
is address of the routine named I
public Object visitCallCommand( CallCommand
com,Object arg) com.E.visit(this,arg) short
p address of primitive routine for name
com.I emit(Instruction.CALLop,
Instruction.SBr, Instruction.PBr,
p) return null
35
Developing a Code Generator Visitor
execute C1 C2 executeC1 executeC2
public Object visitSequentialCommand( Sequent
ialCommand com,Object arg) com.C1.visit(this,a
rg) com.C2.visit(this,arg) return null
LetCommand, IfCommand, WhileCommand gt later. -
LetCommand is more complex memory allocation and
addresses - IfCommand and WhileCommand
complications with jumps
36
Developing a Code Generator Visitor
evaluate IL LOADL v where v is the
integer value of IL
/ Expressions / public Object
visitIntegerExpression ( IntegerExpression
expr,Object arg) short v valuation(expr.IL.s
pelling) emit(Instruction.LOADLop, 0, 0,
v) return null public short
valuation(String s) ... convert string to
integer value ...
37
Developing a Code Generator Visitor
evaluate E1 O E2 evaluate E1 evaluate
E2 CALL p where p is the address of routine
for O
public Object visitBinaryExpression
( BinaryExpression expr,Object arg)
expr.E1.visit(this,arg) expr.E2.visit(this,arg
) short p address for expr.O
operation emit(Instruction.CALLop,
Instruction.SBr, Instruction.PBr,
p) return null
Remaining expression visitors are developed in a
similar way.
38
Controls Structures
We have yet to discuss generation for IfCommand
and WhileCommand
execute while E do C JUMP h g execute
C h evaluateE JUMPIF(1) g
A complication is the generation of the correct
addresses for the jump instructions.
We can determine the address of the instructions
by incrementing a counter while emitting
instructions.
Backwards jumps are easy but forward jumps are
harder. Q why?
39
Control Structures
Backwards jumps are easy The address of the
target has already been generated and is
known Forward jumps are harder When the jump is
generated the target is not yet generated so its
address is not (yet) known. There is a solution
which is known as backpatching 1) Emit jump with
dummy address (e.g. simply 0). 2) Remember the
address where the jump instruction occurred. 3)
When the target label is reached, go back and
patch the jump instruction.
40
Backpatching Example
public Object WhileCommand ( WhileCommand
com,Object arg) short j nextInstrAddr emit
(Instruction.JUMPop, 0,
Instruction.CBr,0) short g nextInstrAddr com
.C.visit(this,arg) short h nextInstrAddr cod
ej.d h com.E.visit(this,arg) emit(Instruc
tion.JUMPIFop, 1, Instruction.CBr,g) ret
urn null
dummy address
backpatch
execute while E do C JUMP h g execute
C h evaluateE JUMPIF(1) g
41
Constants and Variables
We have not yet discussed generation of
LetCommand. This is the place in MiniTriangle
where declarations are.
execute let D in C elaborateD execute
C POP(0) s if sgt0 where s amount of
storage allocated by D
fetch V LOAD dSB where d address of V
relative to SB assign V STORE dSB where
d address of V relative to SB
42
Constants and Variables
Example
Accessing known values and known addresses
let const b 10 var iInteger in i
ib
PUSH 1 LOAD 4SB LOADL 10 CALL mult STORE 4SB
elaborateconst var
execute iib
43
Constants and Variables
Example
Accessing an unknown value.
Not all constants have values known (at compile
time).
let var xInteger in let const y 365
x in putint(y)
Depends on variable x value not known at compile
time.
When visiting declarations the code generator
must decide whether to represent constants in
memory or as a literal value gt We have to
remember the address or the value somehow.
44
Constants and Variables
Example
Accessing an unknown value.
let var xInteger in let const y 365
x in putint(y)
PUSH 1 LOADL 365 LOAD 4SB CALL add STORE
5SB LOAD 5SB CALL putint
elaboratevar xInteger
elaborateconst y 365 x
execute putint(y)
45
Constants and Variables
Entity descriptions When the code generator
visits a declaration 1) it decides whether to
represent it as a known value or a
known address 2) if its an address then
emit code to reserve space. 3) make an entity
description an object that describes the
variable or constant its value or address, its
size. 4) put a link in the AST that points to
the entity description
Example and picture on next slide
46
Constants and Variables
let const b 10 var iInteger in i ib
RECAP Applied occurrences of Identifiers point
to their declaration
LetCommand
SequentialDeclaration
ConstDecl
VarDecl
Int.Exp
Ident
Ident
Ident
Ident
Ident
10
b
i
i
i
b
known value size 1 value 10
known address address 4 size 1
47
Constants and Variables
let var xInteger in let const y 365 x in
putint(y)
LetCommand
Note There are also unknown addresses. More
about these later.
Q When do unknown addresses occur?
known address address 4 size 1
unknown value address 5 size 1
48
Static Storage Allocation
Example 1 Global variables
Tam Address a 0SB b 1SB c 2SB d 3SB
let var a Integer var b Boolean var
c Integer var d Integer in ...
Note In this example all globals have the same
size 1. This is not always the case.
49
Static Storage Allocation
Example 2 Static allocation with nested blocks
overlays
Tam Address a 0SB b 1SB c 2SB d
1SB
let var a Integer in begin ... let var b
Boolean var c Integer in begin ...
end ... let var d Integer in begin ...
end ... end
Same address!
Q Why can b and d share thesame address?
50
Static Storage Allocation In the Code Generator
Entity Descriptions
public abstract class RuntimeEntity public
short size ... public class KnownValue
extends RuntimeEntity public short
value ... public class UnknownValue extends
RuntimeEntity public short address ... publ
ic class KnownAddress extends RuntimeEntity
public short address ...
51
Static Storage Allocation In the Code Generator
Entity Descriptions
public abstract class AST public RuntimeEntity
entity // mostly used for Decls ...
Note This is an addition to the AST class and
requires recompilation of a lot of code if added
late in the compiler implementation, but there
seems to be no way around it!
52
Static Storage Allocation In the Code Generator
public Object visit...Command( ...Command com,
Object arg) short gs shortValueOf(arg)
generate code as specified by executecom
return null public Object visit...Expression(
...Expression expr, Object arg) short gs
shortValueOf(arg) generate code as specified
by evaluatecom return new Short(size of expr
result) public Object visit...Declaration(
...Declaration dec, Object arg) short gs
shortValueOf(arg) generate code as specified
by evaluatecom return new Short(amount of
extra allocated by dec)
53
Static Storage Allocation In the Code Generator
The visitor is started
public void encode(Program prog)
prog.visit(this, new Short(0))
Amount of global storage already allocated.
Initially 0
54
Static Storage Allocation In the Code Generator
Some concrete examples of visit methods
elaborate var I T PUSH s where s
size of T
public Object visitVarDeclaration(
VarDeclaration decl, Object arg) short gs
shortValueOf(arg) short s
shortValueOf(decl.T.visit(this, null))
decl.entity new KnownAddress(s, gs)
emit(Instruction.PUSHop, 0, 0, s) return new
Short(s)
Remember the address/size of the variable
55
Static Storage Allocation In the Code Generator
elaborate D1 D2 elaborate D1 elaborate
D2
public Object visitSequentialDeclaration(
SequentialDeclaration decl, Object arg)
short gs shortValueOf(arg) short s1
shortValueOf(decl.D1.visit(this,arg)) short
s2 shortValueOf(decl.D2.visit(this, new
Short(gss1))) return new Short(s1s2)
56
Static Storage Allocation In the Code Generator
execute let D in C elaborateD execute
C POP(0) s if sgt0 where s amount of
storage allocated by D
public Object visitLetCommand( LetCommand com,
Object arg) short gs shortValueOf(arg)
short s shortValueOf(com.D.visit(this,arg))
com.C.visit(this,new Short(gss)) if (s gt 0)
emit(Instruction.POPop,0,0,s) return null
57
Static Storage Allocation In the Code Generator
fetch I special case if I is a known literal
constant LOADL v where v is the known value of
I fetch V LOAD dSB where d address of
V relative to SB
public void encodeFetch(Vname name, short s)
RuntimeEntity ent VName.I.decl.entity if
(ent instanceof KnownValue) short v
((KnownValue)ent).value emit(Instruction.LO
ADLop, 0, 0, v) else short d
(entity instanceof UnknownValue)
? ((UnknownValue)ent).address
((KnownAddress)ent).address
emit(Instruction.LOADop, 0, Instruction.SBr, d)

58
Stack Allocation, Procedures and Functions
Now we will consider 1) how procedures and
functions are compiled 2) how to modify code
generator to compute addresses when we use
a stack allocation model (instead of static
allocation)
59
RECAP TAM Frame Layout Summary

Arguments for current procedure they were put
here by the caller.
arguments
LB
dynamic link static link return address
Link data
local variables and intermediate results
Local data, grows and shrinks during execution.
ST
60
RECAP Accessing Global Local Variables
Example Compute the addresses of the variables
in this program
Var Size Address
let var a array 3 of Integer var b
Boolean var c Char proc Y()
let var d Integer var e ...
in ... proc Z() let var f
Integer in begin ... Y() ... end in
begin ... Y() ... Z() end
0SB 3SB 4SB
a b c d e f
3 1 1
2LB 3LB
1 ?
2LB
1
61
RECAP TAM addressing schemas overview
We now have a complete picture of the different
kinds of addresses that are used for accessing
variables and formal parameters stored on the
stack.
Type of variable Global Local Parameter Non-lo
cal, 1 level up Non-local, 2 levels up ...
Load instruction
LOAD offsetSB LOAD offsetLB LOAD
-offsetLB LOAD offsetL1 LOAD offsetL2
62
How To Characterize Addresses now?
When we have a static allocation model only, an
address can be characterized by a single positive
integer (i.e. the offset from SB)
Now we generalize this to stack allocation (for
nested procedures) Q How do we characterize an
address for a variable/constant now?
A We need two numbers. - nesting level
- offset (similar to static allocation)
Q How do we compute the addresses to use in an
instruction that loads or stores a value from/to
a variable?
63
How To Characterize Addresses
Example Compute the addresses of the variables
in this program
Var Size Addr Accessing
let var a array 3 of Integer var b
Boolean proc foo() let var d
Integer var e ... proc
bar() let var f Integer
in ...bar body... in ...foo body...
in ... global code ...
a b d e f
3 1
0SB 3SB
1 ?
0LB
1
accessing e from foo body gt accessing e from bar
body gt
1LB 1L1
64
New Fetch / Assign Code Templates
fetch I LOADL(s) dr
s Size of the type of I
d from address of I is (d, l)
r determined by l and cl (current level)
How to determine r
l 0 gt r SB l cl gt r
LB otherwise gt r L(cl-l)
65
How To Modify The Code Generator
An info structure to pass as argument in the
visitor (instead of gs)
public class Frame public byte level
public short size
Before it was sufficient to pass the current size
(gs) of the global frame since without procedures
all storage is allocated at level 0. With
subprograms we need to know the current level and
the size of the frame.
66
How To Modify The Code Generator
Different kind of address in entity descriptors
public class EntityAddress public byte
level public short displacement
public class UnknownValue extends RuntimeEntity
public EntityAddress address ... public
class KnownAddress extends RuntimeEntity
public EntityAddress address ...
67
How To Modify The Code Generator
Changes to code generator (visitor)
Example
public Object visitVarDeclaration(
VarDeclaration decl, Object arg) Frame frame
(Frame)arg short s shortValueOf(decl.T.vi
sit(this,null)) decl.entity new
KnownAddress(s,frame) emit(Instruction.PUSHop,
0, 0, s) return new Short(s)
etc.
Q When will the level of a frame be changed? Q
When will the size be changed?
68
Change of frame level and size

• In the visitor/encoding method for translating a
  procedure body, the frame level must be
  incremented by one and the frame size set to 3
  (space for link data)
• Frame outerFrame
• Frame localFrame new Frame(outerFrame.level
  1, 3)
• The encoder starts at frame level 0 and with no
  storage allocated
• public void encoder(Program prog)
• Frame globalFrame new Frame(0,0)
• prog.visit(this, globalFrame)

69
Procedures and Functions
We extend Mini Triangle with procedures
Declaration ... proc Identifier ( )
Command Command ... Identifier ( )
First , we will only consider global procedures
(with no arguments).
70
Code Template Global Procedure
elaborate proc I () C JUMP g e execute
C RETURN(0) 0 g
C
execute I () CALL(SB) e
71
Code Template Global Procedure
Example
let var n Integer proc double() n
n2 in begin n 9 double() end
var n Integer
0 PUSH 1 1 JUMP 7 2 LOAD 0SB 3 LOADL 2 4 CA
LL mult 5 STORE 0SB 6 RETURN(0) 0 7 LOADL 9 8
STORE 0SB 9 CALL(SB) 2 10POP(0) 1 11HALT
proc double() n n2
n n2
n 9
double()
72
Procedures and Functions
We extend Mini Triangle with functions
Declaration ... func Identifier ( )
TypeDenoter Expression Expressio
n ... Identifier ( )
First , we will only consider global functions
(with no arguments).
This is all pretty much the same as procedures
(except for the RETURN)
73
Code Template Global Function
elaborate func I () T E JUMP g e
evaluate E RETURN(s) 0 g
C
where s is the size of T
evaluate I () CALL(SB) e
74
Nested Procedures and Functions
Again, this is all pretty much the same except
for static links. When calling a (nested)
procedure we must tell the CALL where to find the
static link. Revised code template
e from address of I is (d, l)
execute I () CALL(r) e
r determined by l and cl (current level)
evaluate I () CALL(r) e
75
Procedures and Functions Parameters
We extend Mini Triangle with ...
Declaration ... proc Identifier
(Formal) TypeDenoter
Expression Expression ... Identifier
(Actual) Formal Identifier TypeDenoter
var Identifier TypeDenoter Actual
Expression var VName
76
Procedures and Functions Parameters
Parameters are pushed right before calling a
proc/func. They are addressed like locals, but
with negative offsets (in TAM).
let proc double(var nInteger) n
n2 in ...

arguments
UnknownAddress
LB
dynamic link static link return addres
address (1,-1)
local variables and intermediate results
ST
77
Code Templates Parameters
elaborate proc I(FP) C JUMP g e execute
C RETURN(0) d g
where d is the size of FP
execute I (AP) passArgument AP CALL(r)
e passArgument E evaluate E passArgument
var V fetchAddress V
Where (l,e) address of routine bound to I, Cl
current routine level R display-register(cl,l)
78
Code Templates Parameters
An UnknownAddress extra case for fetch and
assign
fetch V if V bound to unknown address
LOAD dr where (d,l) address where the
LOADI(s) unknown address will be stored at
runtime. s is the size of the type of
V assign V LOAD dr STOREI(s) where d
address where the unknown address will be
stored a runtime.
79
Runtime Entities Overview
Known
Unknown
const lucky 888
const foo x 10
Value Address Routine
address (level,offset) the address where value
will be stored
value 888
var counter Integer
A var parameter
address (level,offset) of the address where the
pointer will be stored.
address (level,offset) of the variable.
proc double() ...
A procedure or function parameter. address
(level,offset) address where closure object will
be stored.
address (level,offset) of the routine (label e
in template)
80
Code generation summary

• Create code templates inductively
• There may be special case templates generating
  equivalent, but more efficient code
• Use visitors pattern to walk the AST recursively
  emitting code as you go along
• Back patching is needed for forward jumps
• It is necessary to keep track of frame level and
  allocated space
• Thats it folks!
• At least for MiniTriangle on TAM