: Compiler Design

Size: px

Start display at page:

Download ": Compiler Design"

Donna Fox
5 years ago
Views:

1 : Compiler Design 7.2 Assignment statement 7.3 Condi2onal statement 7.4 Loops 7.5 Method invoca2on Thomas R. Gross Computer Science Department ETH Zurich, Switzerland

2 Outline 7.1 Access to operands 7.2 Assignment statement 7.3 CondiGonal statement 7.4 Loops 7.5 Method invocagon 2

3 7.2 Assignment statement CompilaGon of assignment statement topic of homework #1 Back then: numerous restricgons Only local int variables supported Now: remove restricgons Some aspects delayed 2ll 7.5 (Method invoca2on) 3

4 Extending the code generator Deal with other data types New: array elements New: fields of instances Idea: preserve overall IR design Introduce trees to specify operand access 4

6 New IR nodes ARRAY Specifies array element Requires name of array and Tree for index expression FIELD Could include subtree to compute address As discussed earlier 7

7 Other restricgons Did not handle statements that required more registers than available Virtual registers postpone dealing with this aspect Could break a tree that requires more than R registers into separate trees Introduce temporary variables to hold intermediate results 8

8 Outline 7.1 Access to operands 7.2 Assignment statement 7.3 CondiGonal statement 7.4 Loops 7.5 Method invocagon 9

9 7.3 CondiGonal statement JavaLi allow two kinds of condigonal statements 1. if- then if (expression) { <body> } 2. if- then- else if (expression) { <body> } else { <body> } 10

10 1. if- then if (expression) { <then-part> } Invoke code generator on expression Code to decide if then- part is executed Invoke code generator on then- part 2. if- then- else if (expression) { <then-part> } else { <else-part> } Invoke code generator on expression Code to decide if then- part is executed Invoke code generator on then- part Code to skip around else- part 12 Invoke code generator on else- part

11 JavaLi allows only simple expressions Only one comparison Only limited subset of operators Expression format > < = <operand 1> { } <operand 2> 14

12 Code outline Eval expression Eval expression Test Test Branch Branch Then- part d Then- part d Else- part d con2nue con2nue 16

13 Outline 7.1 Access to operands 7.2 Assignment statement 7.3 CondiGonal statement 7.4 Loops 7.5 Method invocagon 18

14 7.4 Loops JavaLi has only one looping construct while (expression) { } <loop-body> Can translate all other kinds of looping contructs into while- loops 19

15 TranslaGon similar to condigonal statement Same rules for expression while- loop while (expression) { <loop-body> } Invoke code generator on expression Code to decide if loop- body is executed Invoke code generator on loop- body Code to jump back to start of loop 20

16 Code outline Eval expression Test Branch Body d Uncond. branch con2nue 21

17 Expression must be evaluated for every iteragon Simple scheme Straighcorward to implement Close to condi2onal statement One uncondigonal branch for each iteragon 22

18 Code outline 2 Idea: eliminate uncondigonal branch at the end of each loop body Move loop congnuagon test to the end of the loop 23

19 Code outline 2 Uncond. branch Body d Eval expression Test Branch con2nue 24

20 Possible performance improvement Reduced number of uncondi2onal branches Based on the guess that the loop body is executed Processor implementa2on may prefetch / pre- execute uncondi2onal branches Other opgons exist 25

21 Other loop constructs Take a sheet of paper and sketch how you could translate a for loop for (int i = low; i < high; i ++) { } <body> Show a figure that outlines the code (similar to slides shown during the lecture) 26

22 Init loop counter Code outline Eval expression Test Branch Body d Update loop counter Uncond. branch con2nue 28

23 Outline 7.1 Access to operands 7.2 Assignment statement 7.3 CondiGonal statement 7.4 Loops 7.5 Method invocagon 29

24 7.5 Method invocagon Finding the correct body of code Covered earlier Storage for method- local variables Passing of parameters (arguments) Handling the return value 30

26 Calling convengon control flow in foo control flow in bar congnue return 34

27 Calling convengon The calling convengon decides which steps/acgons of method invocagon/return are Done by the caller Done by the callee and how any data transfer is implemented Where the data are stored Data includes return address and return value May have to include type casts Usually defined for all compilers/sokware developers on a given operagng system Ensures interoperability 35

28 Calling convengon Stack principal data structure Control stack Set up by run- Gme system Supported by instruc2ons and/or resources (registers) on some systems Ac?va?on record keeps informagon on method invocagons that are currently acgve (or live ) Also known as frame 36

29 AcGons Consider this method invoca?on. // in some method foo B bref; int val = bref.bar(y1,y2,, yn); List all the steps that are necessary to implement the call and its return (on a sheet of paper). 37

30 AcGons (related to method invocagon) IdenGfy target IdenGfy stargng address of callee Handle parameters Evaluate yi Cast as necessary Put into loca2on where it can be found Push onto stack Place into register Leave somewhere else Save registers Find space for temporaries 38

31 AcGons (related to method invocagon) Determine and store return address Find space for return value Set up acgvagon record for callee Link to ac2va2on record of caller ( control link ) Transfer control to callee 39

32 Callling convengon Some of these steps Must be done by caller Must be done by callee Method that was invoked Can be done by either one Must: either for correctness or for performance 40

33 AcGons (related to method return) Transfer control to caller/return address Deliver return value Remove acgvagon record for callee Reclaim any temporary storage Switch to ac2va2on record of caller 41

34 Temp k... Temp 0 Simple acgvagon record stackpointer Local m Local 0 old SP old FP Return address target (parameter y0) parameter y1 parameter yn Return value framepointer 43

35 Comments Sufficient for JavaLi Will not work for varargs Methods with a variable number of arguments (actuals) Parameters are found on the stack Actuals: posi2ve offset from frame pointer Offset recorded in symbol table Locals are found on the stack Nega2ve offset from frame pointer Offset recorded in symbol table Temporary region can grow w/o limit Temporaries can be accessed via frame pointer 44

36 Symbol table Must complete symbol table prior to code generagon local 0-4 local 1-8 parameter parameter return value + 24 this (implicit parameter)

37 Parameter passing (Recall) JavaLi passes all arguments by value. Not the address of a variable is passed but its value. The value of a reference can be used to read/write the object the reference refers to But the reference cannot be changed At call site (of bref.bar(y1, y2,, yn) ) Evaluate yn, push onto stack Evaluate yn- 1, yn- 2, y1, y0 Could be an expression, i.e. bref.bar(y1, a b,, yn) May require cast 46

38 Actual- formal correspondence Other languages are based on (or include) different models Language spec should specify model Here we look at the compiler s side Call- by- value Call- by- reference Call- by- result Call- by- name 47

39 7.5.1 Call- by- value The only opgon in Java (and JavaLi) Easy to understand Look at method in isola2on With references risk of aliasing Easy to implement Caller knows how to evaluate actuals Callee uses a parameter like a local ini2alized by caller PotenGally inefficient Pass an array/an object by value? May require copy (2me consuming) Language restricts call- by- value to word- size en22es (ints, references) 49

40 7.5.2 Call- by- reference Caller passes address to callee Could be address of a field. an object. a local variable. an array element Indicate with keyword or symbol if a parameter is passed by reference Call- by- value usually supported as well Each parameter can be handled differently void foo (ref type x) { } foo(ref y) // call site 50

41 Caller must evaluate address of parameter(s) Pass address from caller to callee Can usually use space that holds parameter, other arrangements possible if space requirements known Callee de- references actual to get value at address or to update storage locagon at the address Two steps: Get address Use address 51

42 Discussion Advantages of call- by- reference Disadvantages of call- by- reference 52

43 Discussion Advantages of call- by- reference Callee can modify variables in caller s scope Efficient passing of large objects/arrays [Maybe] restrict callee access to caller s objects Disadvantages of call- by- reference Callee can modify variables in caller s scope May be able to access any loca2on Bug in callee may have global effect Aliasing the norm 54

44 Disadvantages (congnued) Possible overhead and/or difficulges in opgmizagon void foo (ref int x, ref int y) { int z; x = x + z ; y = z + 1 ; = x... ; } One extra step for each access Cannot assume that x is unchanged Must prohibit calls like foo(k m, ref x) 55

45 7.5.3 Call- by- result Call- by- result is a combinagon of call- by- value (inside the callee) and call- by- reference (upon reaching the end of the callee) Callee copies the local value of a parameter (value inside the callee) back to the caller void foo(result int x) Parameter x is like a local variable inigalized by caller Effect of call obtained by inspecgng x aker return 56

46 void bar (result int x, result int y) { int a, b; x = x + 1; a = 2; y = y 1; b = 4; x = x + a; } // somewhere int k = 1; int m = 2; bar (k, m) // k == 4, m == 1 58

47 Discussion void foo(result int x) Callee needs address of x To store result at the end Implement passing of parameter(s) like call- by- reference Cannot allow foo( a b) Do we need a return statement? Yes: indica2on that parameters have meaningful value(s) No: Value(s) copied back to caller in any case 59

48 ImplementaGon void foo(result int x) Access to x inside method foo different from call- by- reference 60

49 ImplementaGon void foo(result int x) Access to x inside method foo different from call- by- reference Callee cannot modify caller s context Need to create a temporary, inigalize temporary with parameter value Upon return copy value from temporary to caller 61

50 ImplementaGon void bar (result int x, result int y) Use temporary (say xt, yt) Body of bar: xt = x; yt = y; xt = xt + 1; a = 2; yt = yt 1; b = 4; xt = xt + a; x = xt; y = yt; 62

51 Final result depends on order of copying results Consider int k = 1; bar (k, k) // k == 4 or k == 0 Should be decided by language reference manual either from y1 yn or yn y1 63

52 Discussion Advantages of call- by- result Mul2ple return values for a func2on Disadvantages of call- by- result Implementa2on overhead Aliasing makes programs difficult to understand 65

53 7.5.4 Call- by- name Idea: textual subsgtugon of the formal parameter by the actual parameter Hand- off a variable to callee Example void foo (name int x, name int k) { } k = 2; x = 5; k = 3; x = 1; 66

54 Example (congnued) // call site int [] A = new int[10]; int j; foo (A [j * 2], j) With call- by- name, the call means foo (A [j * 2], j) 67

55 Example (congnued) // call site int [] A = new int[10]; int j; foo (A [j * 2], j) With call- by- name, the call means foo (A [j * 2], j) ExecuGon k = 2; j = 2; x = 5; A[j*2] = 5; // A[4] k = 3; j = 3; x = 1; A[j*2] = 1; // A[6] 68

56 Discussion Who wants that? How does the compiler implement call- by- name? 70

57 OpGon 1: interpreter Use just- in- Gme compiler Invoke compiler at each call site, for each invocagon Compiler automagcally captures actual parameters 71

58 OpGon 2: stub generagon Ahead- of- Gme compiler produces (for each call- by- name parameter) a stub that generates the address of the parameter Callee invokes stub to access a call- by- name parameter For each parameter P i the stub EP i yields the address 72

59 Example, congnued foo (A [j * 2], j) EP 2 Get address of j Put address into loca2on L 2 Con2nue as in call- by- reference EP 1 Get address of j Get value, compute 2, put value into temporary loca2on T Get address of A[T] Put address into loca2on L 1 Con2nue as in call- by- reference 73

60 Discussion Difficult to implement In ahead- of- 2me framework PotenGally expensive execugon Many indirec2ons Frequent compila2ons (in just- in- 2me framework) Destroys modularity Cannot deduce effect of method foo by inspec2ng body of foo 74

61 Comparison (Not really JavaLi) No need to implement But you should know concepts Example Global variables Could be in an instance int j; int [] B = new int[2]; 75

62 x is passed by void quest( int x){ j = 0; x = x + 2; B[j] = 10; j = 1; x = x + 2; } void main() { B[0] = 1; B[1] = 1; j = 0; value reference result name quest(b[j]); } 76

Compiler Design Spring 2017

Compiler Design Spring 2017 7.5 Method invocation Dr. Zoltán Majó Compiler Group Java HotSpot Virtual Machine Oracle Corporation 1 Admin issues There will be a recitation session today In CAB G 11 @ 15:15