Announcements. Project 2: released due this sunday! Midterm date is now set: check newsgroup / website. Chapter 7: Translation to IR

Transcription

1 Announcements Project 2: released due this sunday! Midterm date is now set: check newsgroup / website. 1

2 Translation to Intermediate Code (Chapter 7) This stage converts an AST into an intermediate representation. Last stage of semantic analysis : the IR can be thought of as representation of the meaning of the program in more low-level terms (without committing to a specific target machine). 2

3 Translation to Intermediate Code (Chapter 7) It is also possible to go directly to target assembly code. Q: Why use intermediate representation? 3

4 Why Use IR? More portable compiler architecture Java ML Pascal C C++ IR Sparc MIPS PowerPC x86 4

5 Why Use IR? Better separation of concerns: Frontend not complicated with details of target architecture Backend not complicated with details of the language semantics. 5

6 Design of a good IR What do we seek from a good IR? convenient to produce by semantic analysis phase convenient to translate to machine language (for all desired architectures) clear and simple meaning so that optimizing transformations can be specified and implemented easily. 6

7 IR Trees Exp ::= CONST( int ) NAME( Label ) TEMP( Temp ) BINOP( Op, Exp, Exp) MEM(Exp) CALL( Exp fun, List<Exp> args) ESEQ( Stm, Exp ) Stm ::= MOVE(Exp dst, Exp src) EXP(Exp) JUMP(Label) CJUMP(RelOp, Exp, Exp, Label thn, Label els) SEQ( Stm, Stm) LABEL( Label ) Op ::= PLUS, MINUS, MUL, DIV, AND, OR, LSHIFT,... RelOp ::= EQ, NE, LT, GT, LE, GE, ULT, ULE,... 7

8 Translation to IR Relatively Straightforward but many cases: Trouble is a kind of combinatorial explosion: different kinds of expressions / statements x different kinds of usage context. To emit good code we may need to generate different code for an expression / statement based on its usage context. Examples on next slides 8

9 Translation to IR Example: assignment expression in C/Java (but not MiniJava) Exercise: draw an IRTree for the expression x = x + 1 9

10 Translation to IR Exercise 2: Assume the translator is compositional (i.e. it builds up IR for non-leaf AST nodes by generating IR snippets for its children recursively and then glueing these together. Use the code from exercise 1 to build IR trees for these two program fragments while (x<10) {...do stuff.. x = x+1; y = x = x+1; Could you do better? How? 10

11 Translation to IR Example 2: Boolean expressions and if-then-else. Consider these two boolean expressions (assume x is an int local variable and flag is a boolean local variable) Exercise 1: x < 5 flag Draw an IRExp tree that represents each of these. 11

12 Translation to IR Example 2: Boolean expressions and if-then-else. Exercise 2: Consider the following MiniJava statement if (E) T else F //statement //statement Assume you already generated IR code for E, T and F. Show the IRTree for the if (use symbols E, T, F as placeholder for their respective IR code). 12

13 Translation to IR Example 2: Boolean expressions and if-then-else. Exercise 3: Now put together the information from Exercise 1 and two to draw the IRTree for if (x<5) T else F if (flag) T else F Could you do better? How? 13

14 Context Dependent Translation To generate nice code, we need to be able to generate different code for some expressions depending on how they are used. We distinguish three kinds of usage contexts for an exp E contexts that need an explicit value: x = E f(e) return E contexts that discard the expression value: E; contexts that use E's value as a branching condition. if (E)... else... E &&... 14

15 Context Dependent Translation Instead of returning an actual IRExp (or IRStm) our translator returns an object that knows how to create good code for these three different kinds of contexts): public abstract class TRExp { /** * The expression is used in a context where an explicit result * value is required. */ abstract IRExp unex(); /** * The expression is used in a context that discards the value * (good compilation strategy may avoid producing it). */ abstract IRStm unnx(); /** * The expression is used as the condition for a CJUMP. */ abstract IRStm uncx(label iftrue, Label iffalse); 15

16 Example: Context dependent Assign Exp public TRExp visit(assign n) { final Access var = currentenv.lookup(n.name); TRExp val = n.value.accept(this); final IRStm stm = IR.MOVE( var.exp(frame.fp()), val.unex()); return new TRExp() { IRExp unex() { return ESEQ(stm, var.exp(frame.fp())); IRStm unnx() { return stm; IRStm uncx(label iftrue, Label iffalse) {... ; 16

17 The Ex class Many AST nodes naturally translate to expression that produce an explicit value. To use them as a statement we must discard that value. To use them as a branch condition we must generate an actual branch with a test of the expression's value. 17

18 The Ex class public class Ex extends TRExp { private final IRExp exp; public Ex(IRExp exp) { this.exp = IRStm uncx(label t, Label f) { return CJUMP(RelOp.NE, exp, CONST(0), t, IRExp unex() { return IRStm unnx() { return EXP(exp); 18

19 The Nx class Many AST nodes naturally translate to an IRStm that produces no value. It should be illegal to use them in a context that wants a value (including as a branc condition). If your type checker works, then the uncx and unex cases are illegal and needn't have a real implementation. 19

20 public class Nx extends TRExp { private final IRStm stm; public Nx(IRStm stm) { this.stm = stm; The Nx class public IRStm uncx(label iftrue, Label iffalse) { throw new Error("Bug in type checker?"); public IRExp unex() { throw new Error("Bug in type checker?"); public IRStm unnx() { return stm; 20

21 The Cx class Some AST expressions most naturally translate to a CJUMP (e.g. comparing numbers with < can only be done with a CJUMP!) We can convert them into an expression that returns an explicit value by using that branch to store an explicit value (typically 0 for false, and 1 for true). 21

22 The Cx class import static minijava.irtree.ir.*; public abstract class Cx extends TRExp { abstract IRStm uncx(label iftrue, Label iffalse); IRExp unex() { Label t = new Label(); Label f = new Label(); TEMP r = TEMP(new Temp()); return ESEQ( SEQ( MOVE(r, TRUE), uncx(t,f), LABEL(f), MOVE(r, FALSE), LABEL(t)), r); IRStm unnx() { Label end = new Label(); return SEQ( uncx(end, end), LABEL(end) ); 22

23 Next Now that we have seen the IR tree model that we are using and... the scaffolding we use to generate code for different types of expression contexts... Let's look at a series of specific language constructs and think about how to generate IR code for them. 23

24 1) Simple (Local) Variables Example: int f(int p) { int x; x = 4; return x + p; Problem: The layout of activation records is dependent on the target architecture. => address computations for local variables and formal parameters are dependent on target architecture. Q: How can we write our IR code generator to generate the right addressing calculations, without making the translator implementation specific to an architecture. 24

25 The Frame Class Problem: The layout of activation records is dependent on the target architecture. => address computations for local variables and formal parameters are dependent on target architecture. Q: How can we write our IR code generator to generate the right addressing calculations, without making the translator implementation specific to one architecture. 25

26 The Frame Class Frame Abstract class X86Frame PPCFrame MIPSFrame... Frame class has abstract methods to create an object to keep track of the current frame's layout. allocate variables / formals in the frame special temporaries (the FP and RV) other target architecture specific stuff. Designed to hide details such as frame layout and whether locals/formals are in registers or in the frame. 26

27 The Frame Class public abstract class Frame extends DefaultIndentable { /** Create a new frame for a the target architecture and * allocate space for the formal parameters according to the * target architecture's calling conventions. */ public abstract Frame newframe(label name, List<Boolean> formalsescape); /**A label that points to the beginning of the function's code.*/ public abstract Label getlabel(); /** fetch a list of abstract representations of the addresses of * the formal parameters.*/ public abstract List<Access> getformals(); /** Allocate space for a local variable in this frame.*/ public abstract Access alloclocal(boolean escapes); /** Frame pointer (e.g. a temp mapped to %ebp on x86) */ public abstract Temp FP(); /** Return value (e.g. a temp mapped to %eax on x86) */ public abstract Temp RV();... 27

28 The Access Class /** * An instance of this class represents a place to store a local, temp * or parameter. * * It may be a register or memory address relative to the current * stack frame. * * This class is abstract for two reasons. * * First, there are concrete subclasses * for the different cases (at least two: one for register and one for * inframe). * * Second, each architecture can provide its own concrete * implementations. */ public abstract class Access { /** * Translate into intermediate representation (returns an IRExp * that can be used either as an L-value or an R-value */ public abstract IRExp exp(temp fp); 28

29 package minijava.ir.frame.x86; import static minijava.ir.tree.ir.*; class InFrame extends Access { private int offset; InFrame(int offset) {... The Access public IRExp exp(temp fp) { return MEM(PLUS(TEMP(fp), offset)); class InReg extends Access { private Temp name; InReg(Temp name) {... Note: these classes are not public IRExp exp(temp frameptr) { return TEMP(name); 29

30 X86Frame Implementation Formals: always allocated as InFrame (recall our exercise with the gcc assembly code for exact details about the offset computations) Locals: allocated as InFrame when escapes is true. allocated as InReg when escapes is false. for MiniJava escapes is always false. Since the Frame stuff is supposed to be reusable for other programming languages, we should implement the escapes = true case however. Running out of Registers (i.e. Temps)? don't worry now, this phase assumes infinite # of Temps => worry later: Register Allocation phase. 30

31 2) Array Variables Two different styles of array variables (in different languages) Example: (PASCAL) var a : array [1..10] of integer begin... b := a; // copies contents of array a -> b end Example: (C) int a[10], *b;... b = a; // copies address of array a[0] -> b 31

32 2) Array Variables MiniJava has pointer arrays. (So an array variable is always a pointer to some (dynamically allocated) array. Example: (MiniJava) int[] a, b; a = new int[10]; b = new int[10]; b = a; // copies pointer to an array from a -> b // (The original b array becomes garbage) // a and b now both point to the same array. 32

33 2) Array Variables in MiniJava How to represent MiniJava arrays? How to compute IR code for array subscripting expressions? Example: (MiniJava) int[] a, b; int i; int i; a = new int[10]; b = new int[a.length];... i = 0 while (i < a.length) { a[i] = b[i]; i = i+1; Let's figure this out together 33

34 2) Pascal Style (Static) Arrays? How to represent Pascal arrays? How to compute IR code for array subscripting expressions? Example: (Pascal) var a : array [10..15] of integer; var i : integer;... a[i] = 20;... 34

35 3) Records / Structs How to represent Pascal style records (or C style structs)? How to compute IR code for accessing fields of a record. Example: (Pascal) type Point = record x : integer; y : integer; end; type Line = record st : Point en : Point end; var p : Point; var l : Line; p1.x := 10; p1.y := 20; l.st := p1; l.en := p1; l.en.x = l.st.x+10;... 35

36 3) Records / Structs How to represent Pascal style records (or C style structs)? How to compute IR code for accessing fields of a record. Example: (Pascal) type Point = record x : integer; y : integer; end; type Line = record st : Point en : Point end; var p : Point; var l : Line; p1.x := 10; p1.y := 20; l.st := p1; l.en := p1; l.en.x = l.st.x+10;... 36

37 4) && (lazy and) Examples (Java): if (x<5 && x>=0)... flag = x<5 && x>=0 flag = a && b if (a && b)... if (x!=null && x.isempty())... 37

38 Examples (Java): int x; int fac; x = 10; fac = 1; while (x>0) { fac = fac * x; x--; 5) while loops Other loops are similar (can convert to while loops!) Note: comments in the book about for loop would make more sense for Pascal style for loops: for i := low to high do... 38

39 These are easy... 6) (static) function calls We have an IR code to represent function calls directly. f(<a>,<b>,<c>) => CALL( NAME(f_label),list(<a>,<b>,<c>)) In MiniJava sans inheritance, methods are just like static functions. <r>.f(<a>,<b>,<c>) =>??? What about static links? What about MiniJava with inheritance? 39

40 7) Strings (and other big literals ) HL languages usually allow the inclusion of String literals inside of expressions. Example: System.out.println( Hello World ); How does this work? What kind of IR is generated? Where is this String stored? Note: This kind of idea also applies to other big literals (or even small ones). E.g. array constants in Java or quoted lists in Scheme. Q: What about mutation operations on these data? 40

41 Example: (MiniJava) 8) variable declarations int foo(int p1, boolean p2) { int x; boolean b;... Example: (Java) (allows nested scopes and init expressions) int x = 0; int y = x+20; { int z;

42 Example: (MiniJava) class Foo { 9) Procedure / Method decls int foo(int p1, boolean p2) { int x; boolean b;... Only body compiled into IR. Also: a ProcedureFragment is created and stored in a global list of fragments. Q: Besides the IR of the body, what else do we expect to find in the final assembly code? Can we produce all of this now? 42

43 10) Classes & Objects (sans inheritance) Example: (MiniJava) class Vehicle { int position; int gas; int move(int x) { position = position + x ; return position; int fill(int add) { gas = gas + add; return gas;... new Vehicle()... 43