Computer Languages - Translation to intermediate code

Computer Languages 

Translation to intermediate code 

Verónica Gaspes 

School of Information Science, Computer and Electrical Engineering 

April 27 

www.hh.se/staff/vero/languages 

Computer Languages Translation

Structure of a compiler 

A compiler translates a program written in some programming 

language to code that can be executed on some machine. 

Source −→ 

program 

Our compiler 

IR 

Front End Back End 

Compiler 

−→ Target 

program 

In this project we will concentrate ourselves on the programming 

language minijava, a target architecture called MIPS (a RISC 

architecture) and a suitable intermediate representation. 





Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 








Source −→ 

program 

Our compiler 

IR 


Compiler 

−→ Target 

program 





The front end 

Source program 

Lexicalanalyser 

Token stream 

Abstract syntax 

Parser 

Translation 

Computer Languages Translation 


IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The front end 



Token stream 


Parser 




IR trees 

Static 

semantics

The translation phase 

Lexical, syntactical and contextual analysis are phases of all 

language processors of all computer languages (which we have 

exemplified with minijava). 

The translation phase is more dependent on the kind of 

computer language being processed. 

For programming languages it is taking a step towards 

executable code. 

We will present some general techniques and abstractions for 

doing so. 

Note 

We will exemplify with minijava when possible. If minijava doesn’t 

have the feature we want to illustrate we will refer to some other 

programming language. 











doing so. 

Note 














doing so. 

Note 














doing so. 

Note 














doing so. 

Note 














doing so. 

Note 






We will present 

The abstract machine to be used. 

We present it as a language to write programs in (the 

instructions of the abstract machine). 

Because no person needs to program in it, we just present the 

abstract syntax! 

How to organize a translation to it. 

Some hints as to how to translate (some) the constructs of 

minijava to it. 

For the project 

you will get most of the material described here and will have to 

complete the translation of the minijava constructs. 






















































































Intermediate Representation 

The abstract syntax of the Abstract Machine language 

Must be convenient for the translation phase to produce. 

Must be convenient to translate into machine language for the 

desired target machines. 

Each construct must have a clear and simple meaning so that 

optimizations that rewrite the intermediate representation can 

easily be specified and implemented. 

Notice 

Not always complicated pieces of abstract syntax correspond to the 

complex instructions that a target machine can execute! 










Notice 












Notice 












Notice 












Notice 




Intermediate Representation - Expressions 

constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 

binop(o,e1,e2) 

The integer constant (i) 

The symbolic constant n corresponding to 

an assembly label 

Temporary t, similar to a register, there is 

an infinite number of these 

Binary operator. e1 is evaluated before e2. 

o can be one of 

plus,minus,mul,div,and,or,xor, 

lshift,rshift,arshift 



constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













constants 

const(i) 

labels 

name(n) 

registers 

temp(t) 

operations 













memory 

mem(e) 

function call 

call(f,l) 

statement/value 

eseq(s,e) 

The content of wordSize bytes of memory 

starting at address e 

f is evaluated before l which is evaluated 

from left to right 

The statement s is evaluated for side 

effects, then e is evaluated for the result 



memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 









memory 

mem(e) 

function call 

call(f,l) 


eseq(s,e) 








Intermediate Representation - Statements 

move 

move(temp(t),e) 

move 

move(mem(e1),e2) 

discard 

exp(e) 

labeling 

label(n) 

Evaluate e and move the value to t 

Evaluate e1 to memory address a, then 

evaluate e2 and store its value in wordSize 

bytes after a 

Evaluate e and discard the result 

mark the current machine code address 

with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



move 


move 


discard 

exp(e) 

labeling 

label(n) 




bytes after a 



with name n 



jump 

jump(e,labs) 

conditional jump 

cjump(o,e1,e2,t,f) 

sequence 

seq(s1,s2) 

Transfer control to address e. labs specifies 

all the locations e can evaluate to (needed 

later in the compiler) 

Evaluate e1 then e2 and then apply the 

binop o. If true jump to t else jump to f 

s1 followed by s2 



jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 









jump 

jump(e,labs) 



sequence 

seq(s1,s2) 








Organizing the Translation - remarks 

We will define a visitor class that builds the translation of a 

(minijava) program to its representation in intermediate 

representation. 

Because a program consists of some declarations (in minijava 

mainclass classdeclarations) the output will be a collection of 

processed declarations. 

Because there are no function or class declarations in the 

intermediate representation, the output will consist of a list of 

fragments. 

Fragment 

the translation of the function’s code (a statement) including 

placing the returned value in a dedicated register. 

frame structure describing the memory needed for a function call. 











fragments. 

Fragment 














fragments. 

Fragment 














fragments. 

Fragment 














fragments. 

Fragment 














fragments. 

Fragment 





Typical frame 

argument n 

. 

argument 1 

static link 

local variables 

return address 

saved registers 

argument m 

. 

argument 1 

static link 


Managing Memory 

Runtime logical address space 

code static heap −→ Free memory ←− stack 

Code and some categories of data occupy a fixed space. 

Data areas for instances of classes (heap) and for frames 

(stack) change during execution! 

Garbage collectors work on the heap freeing unreferenced 

objects! 

The Operating System is likely to spread these through 

physical addresses, but this is not under control of the 

compiler! 









objects! 



compiler! 









objects! 



compiler! 









objects! 



compiler! 









objects! 



compiler! 


Organizing the Translation -remarks 

In minijava, in java, in C and in many other languages, the role of 

an expression or statement depends on the context in which it is 

used: 

a




used: 

a




used: 

a




used: 

a




used: 

a




used: 

a




used: 

a


Implementation question 

How do we translate abstract syntax to intermediate representation 

so that we can use context information? 

Exp 

Implement classes for the intermediate representation 

Tree.Exp and Tree.Stm 

But, translate to something that can be manipulated when 

the context is known! 

public abstract class Exp { 

abstract Tree.Exp unEx(); 

abstract Tree.Stm unNx(); 

abstract Tree.Stm unCx(Temp.Label t, Temp.Label f); 

} 






Exp 









} 






Exp 









} 






Exp 









} 






Exp 









} 


Organizing the Translation - example 

To translate expressions of minijava 

public class Ex extends Exp { 

Tree.Exp exp; 

Ex(Tree.Exp e) { exp = e; } 

Tree.Exp unEx(){ return exp; } 

Tree.Stm unNx(){ return new Tree.EXP(exp); } 

Tree.Stm unCx(Label t, Label f) { 

if (exp instanceof Tree.CONST) { 

Tree.CONST c = (Tree.CONST)exp; 

if (c.value == 0) 

return new Tree.JUMP(f); 

else 

return new Tree.JUMP(t); 

} 

return new Tree.CJUMP(Tree.CJUMP.NE, exp, 

new Tree.CONST(0), t, f); 

} 





Tree.Exp exp; 









else 


} 



} 





Tree.Exp exp; 









else 


} 



} 





Tree.Exp exp; 









else 


} 



} 





Tree.Exp exp; 









else 


} 



} 





Tree.Exp exp; 









else 


} 



} 





Tree.Exp exp; 









else 


} 



} 


Translating minijava- Variables 

Variables are always in some scope (in our code implemented 

by a class Level ) 

Variables in the frame with offset k will be translated as 

mem(binop(plus,temp(fp),const(k))) 

Variables in a register tnumber will be translated as 

temp(tnumber ) 

Machine dependent features like the frame pointer and the 

word size are provided by Frame : 

public abstract class Frame { 

public abstract Temp.Temp FP(); 

public abstract int wordSize(); 

} 














} 














} 














} 














} 














} 



In the frame or in registers? 

Elaborating a variable declaration binds the variable to an 

Access (an abstract class!). 

When translating a use of the variable how do we know 

whether it has been assigned to a register or to the frame? 

We don’t know! 

We let the different implementations of Access to resolve 

this: 

public abstract class Access { 

public abstract Tree.Exp exp(Tree.Exp e); 

} 

We look up the variable in the symbol table and get an 

Access a . 

We do a.exp(new Tree.TEMP(frame.FP())); 










this: 



} 


Access a . 











this: 



} 


Access a . 











this: 



} 


Access a . 











this: 



} 


Access a . 











this: 



} 


Access a . 











this: 



} 


Access a . 



Translating minijava- structured variables 

Different programming languages have different policies! 

In Pascal an array variable stands for the content of the array. 

assignment will copy content 

place for the content has to be associated to an array variable! 

In minijava array variables (and object variables) behave like 

pointers 

array assignment is pointer assignment 

only place for a pointer is associated to an array or object 

variable. 








pointers 



variable. 








pointers 



variable. 








pointers 



variable. 








pointers 



variable. 








pointers 



variable. 








pointers 



variable. 


Translating minijava- subscripting 

With this, the translation of a[i] is immediate also: 

mem(plus( mem(e),mul(i,const(w)))) 

mem(e) is the address where the array a starts, 

w is the wordsize 

Notice that identifiers can be used both as left-hand-sides of 

assignments and as parts of expressions. In some cases 

mem(e) nodes will stand for addresses, in other cases for 

values. It is only in move(mem(e1),e2) that mem(e) stands 

for the address. This will be reflected when generating code 

(we will generate a store or a fetch) 


















































Translating minijava- operations 

Arithmetic 

Each operator in minijava corresponds to an operator constructor 

in the intermediate representation. Just notice that 

There are no unary negations in the intermediate 

representation 

Negate integers by substracting from 0 

Negate booleans by using XOR. 

Comparisons 

e1 < e2 will be translated using 

public class RelCx extends Cx { 

int op; 

Tree.Exp left, right; 


return new Tree.CJUMP(op, left, right, t, f);} 

} 



Arithmetic 







Comparisons 



int op; 




} 



Arithmetic 







Comparisons 



int op; 




} 



Arithmetic 







Comparisons 



int op; 




} 



Arithmetic 







Comparisons 



int op; 




} 


Translating minijava- array creation 

An array might outlive the method that creates it, thus it 

cannot be placed in the stack! It is placed in an unstructured 

piece of memory, the heap. 

The translation of new int [exp] should create an integer 

array of length determined by e and with each value initialized 

to 0: 

Determine the ammount of memory needed: 

(length + 1) ∗ size of integer 

Call an external function to allocate space on the heap, 

Generate code to store the length of the array at offset 0, 

Generate code to initialize all values to 0, starting at offset 

size of integer 








































































Translating minijava- object creation 

As with arrays, an object may outlive the method that creates 

it, it will be placed in the heap. 

To translate new ClassName() 

Generate code for allocating heap space for all fields 

notice difference between local variables (on the stack) and fields (on the 

heap)! 

Iterate through field memory locations and initialize them. 

Both for array creation and object creation we need to call 

external functions. 

in order to follow machine dependent conventions, we leave 

this to the class Frame : 

public abstract Tree.Exp externalCall(String func, 

List args); 








heap)! 







List args); 








heap)! 







List args); 








heap)! 







List args); 








heap)! 







List args); 








heap)! 







List args); 








heap)! 







List args); 


Translating minijava- while loops 

To translate 

while (exp) stm 

we use its meaning: 

test: 

if (not exp) goto done 

stm 

goto test 

done: 

Resulting in 

seq(seq( seq( label(test),ircjumpEQ,exp.unEx(),const(1),T,F),seq( label(T),body.unNx()),label(f))) 



To translate 



test: 


stm 


done: 

Resulting in 




To translate 



test: 


stm 


done: 

Resulting in 



Translating minijava- function calls 

To translate 

obj.f(a1, . . . a2) 

Use a call() node 

call(name(lf ),obj,e1,. . . en) 

Where: 

lf is the label generated for f when translating its declaration. 

obj is the translation of obj that must be added as an 

argument to the method. 



To translate 

obj.f(a1, . . . a2) 



Where: 






To translate 

obj.f(a1, . . . a2) 



Where: 






To translate 

obj.f(a1, . . . a2) 



Where: 






To translate 

obj.f(a1, . . . a2) 



Where: 





Translating minijava- declarations 

For each variable declaration in a method body, additional 

space will be reserved (in the frame or in a register) and this 

must be recorded in the environment to be used later! 

We get an Access (the abstraction for inFrame or inRegister) 

by using 

frame.allocLocal(false); where frame is the Frame 

that has been created during the elaboration of the current 

method declaration. 



For each variable declaration in a method body, additional 

space will be reserved (in the frame or in a register) and this 

must be recorded in the environment to be used later! 

We get an Access (the abstraction for inFrame or inRegister) 

by using 

frame.allocLocal(false); where frame is the Frame 

that has been created during the elaboration of the current 

method declaration. 



For each method declaration 

An instance of Frame is created 

The body is translated to a statement tree 

These two are put together into a fragment 

At this stage we do not consider the machine dependent 

prologue and epilogue of assembler instructions to allocate the 

frame to the stack and, jump to the proper address, etc. 

To translate method 

B f(A1a1 . . . Anan){decls stms return exp} 

build an eseq(stms,exp) and (if necessary) store the result in 

a dedicated register (Frame.RV() ) You will get the part of the translation that 

elaborates declarations! 








































































Translating minijava- fragments 

When elaborating a method declaration, the fragment 

including the frame and the ir-tree is added to a list. 

The visitor class doing the translation includes a method to 

retrieve the list of fragments (the result of translating the 

whole program) 

private LinkedList frags = new LinkedList(); 

public Iterator getResults() { 

return frags.iterator();} 

This list is further used as input to the back-end of the 

compiler. 

In part 4 of the project we will just print out the list of 

fragments! 












compiler. 


fragments! 












compiler. 


fragments! 












compiler. 


fragments!

Computer Languages - Translation to intermediate code

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?