1. Chap. 4, Intermediate Code Generation

2. Compilation in a Nutshell 1
Source code
(character stream)
if (b == 0) a = b;
Lexical analysis
Token stream if ( b == ) a = b ;
Parsing if == = ;
Abstract syntax tree
(AST) b a b if
Semantic Analysis
boolean
int == = ;
Decorated AST
int b
int 0
int a
lvalue
int b

3. Compilation in a Nutshell 2if
boolean
int == = ;
int b
int 0
int a
lvalue
int b
Intermediate Code Generation
CJUMP ==
MEM
CONST
MOVE
NOP
Optimization +
MEM
MEM fp 8 + + fp 4 fp 8
CJUMP ==
Code generation CX
CONST
MOVE
NOP
CMP CX, 0
CMOVZ DX,CX DX CX

4. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Procedure Translation

5. Role of Intermediate Code
Closer to target language.
simplifies code generation.
Machine-independent.
simplifies retargeting of the compiler.
Allows a variety of optimizations to be implemented in a machine-independent way.
Many compilers use several different intermediate representations.

6. Different Kinds of IRs
Graphical IRs: the program structure is represented as a graph (or tree) structure.
Example: parse trees, syntax trees, DAGs.
Linear IRs: the program is represented as a list of instructions for some virtual machine.
Example: three-address code.
Hybrid IRs: combines elements of graphical and linear IRs.

7. Graphical IRs 1: Parse Trees
A parse tree is a tree representation of a derivation during parsing.
Constructing a parse tree:
The root is the start symbol S of the grammar.
Given a parse tree for  X , if the next derivation step is  X    1…n  then the parse tree is obtained as:

8. Graphical IRs 2: Abstract Syntax Trees (AST)
A syntax tree shows the structure of a program by abstracting away irrelevant details from a parse tree.
Each node represents a computation to be performed;
The children of the node represents what that computation is performed on.

9. Graphical IRs 3: Directed Acyclic Graphs (DAGs)
A DAG is a contraction of an AST that avoids duplication of nodes.
reduces compiler memory requirements;
exposes redundancies.
E.g.: for the expression (x+y)*(x+y), we have:
AST: DAG:

10. Linear IR 1: Three Address Code
Instructions are of the form ‘x = y op z,’ where x, y, z are variables, constants, or “temporaries”.
At most one operator allowed on RHS, so no ‘built-up” expressions.

11. Three Address Code: Example
Source:
if ( x + y*z > x*y + z)
a = 0;
Three Address Code:
t1 = y*z
t2 = x+t // x + y*z
t3 = x*y
t4 = t3+z // x*y + z
if (t2  t4) goto L
a = 0 L:

12. An Example Intermediate Instruction Set
Procedure call/return:
param x, k (x is the kth param)
retval x
call p
enter p
leave p
return
retrieve x
Type Conversion:
x = cvt_A_to_B y (A, B base types) e.g.: cvt_int_to_float
Miscellaneous
label L
Assignment:
x = y op z (op binary)
x = op y (op unary);
x = y
Jumps:
if ( x op y ) goto L (L a label);
goto L
Pointer and indexed assignments:
x = y[ z ]
y[ z ] = x
x = &y
x = *y
*y = x.

13. Three Representations of Instructions
Three representations of instructions in a data structure
Quadruples
Triples
Indirect triples

14. Quadruples Quadruple (quad): four fields Exceptions:
op, arg1, arg2, result
Exceptions:
Unary operators: no arg2
Param: no arg2 and result
Conditional and unconditional jumps: put the target label in result

15. Quadruples for a=c*b+c*b
op arg1 arg2 result
(1) * c b T1
(2) * c b T2
(3) + T1 T2 a

16. Quadruples for a:=(b+c)*e+(b+c)/f

17. Triple Triple : three fields op arg1 arg2 (14) uminus c (15) * b (16)
(17)
(18) +
(19)
assign a

18. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Procedure Translation

19. SDD for Expression Translation
The synthesized attribute S.code represents the three-address code for non-terminal S。
Each non-terminal E has two attributes：
E.place represents the place to store E’s value。
E.code represents the three-address code for non-terminal E。
Function newtemp returns a different temp variable, such as T1,T2,…, for each call.

20. Three-address Code Generation SDD for Expression Translation
Production Semantic Rules
S→id:=E S.code:=E.code || gen(id.place ‘:=’ E.place)
E→E1+E2 E.place:=newtemp;
E.code:=E1.code || E2.code ||
gen(E.place ‘:=’ E1.place ‘+’ E2.place)
E→E1*E2 E.place:=newtemp;
gen(E.place ‘:=’ E1.place ‘*’ E2.place)
E→-E1 E.place:=newtemp;
E.code:=E1.code ||
gen(E.place ‘:=’ ‘uminus’ E1.place)
E→ (E1) E.place:=E1.place;
E.code:=E1.code
E→id E.place:=id.place;
E.code=‘ ’

21. Three-address Code Generation SDT for Expression Translation
S→id:=E S.code:=E.code || gen(id.place ‘:=’ E.place)
E→E1+E2 E.place:=newtemp;
E.code:=E1.code || E2.code ||gen(E.place ‘:=’ E1.place ‘+’ E2.place)
E→E1*E2 E.place:=newtemp;
E.code:=E1.code || E2.code || gen(E.place ‘:=’ E1.place ‘*’ E2.place)
Three-address Code Generation SDT for Expression Translation
S→id:=E { p:=lookup(id.name);
if pnil then
emit(p ‘:=’ E.place)
else error }
E→E1+E2 { E.place:=newtemp;
emit(E.place ‘:=’ E1.place ‘+’ E2.place)}
E→E1*E2 { E.place:=newtemp;
emit(E.place ‘:=’ E 1.place ‘*’ E 2.place)}

22. Three-address Code Generation SDT for Expression Translation
E→-E E.place:=newtemp;
E.code:=E1.code || gen(E.place ‘:=’ ‘uminus’ E1.place)
E→ (E1) E.place:=E1.place;
E.code:=E1.code
E→id E.place:=id.place;
E.code=‘ ’
Three-address Code Generation SDT for Expression Translation
E→-E1 { E.place:=newtemp;
emit(E.place‘:=’ ‘uminus’E 1.place)}
E→(E1) { E.place:=E1.place}
E→id { p:=lookup(id.name);
if pnil then
E.place:=p
else error }

23. a:=(b+c)*e+(b+c)/f

24. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Procedure Translation

25. Addressing Array Elements
A: array[1..2, 1..3]
Column major
A[1, 1], A[2, 1], A[1, 2], A[2, 2], A[1, 3], A[2, 3]
Row major
A[1, 1], A[1, 2], A[1, 3], A[2, 1], A[2, 2], A[2, 3]
A[i1, i2] address:
base + ( (i1  low1)  n2 + (i2  low2 ) )  w
=( (i1  n2 ) + i2 )  w +
(base  ( (low1  n2 ) + low2 )  w)

26. Addressing Array Elements
For an array A[low, low+n-1] with n elements
A[i] begins at: base + (i-low)*w
For k-dimensional arrays,
lowi is the lower-bound of i-th dimension,
((…i1 n2+i2)n3+i3)…)nk+ik)×w +
base-((…((low1 n2+low2)n3+low3)…)nk+lowk)×w
VARPART
CONSPART

27. Array Element Processing Grammar
L → id [ Elist ] | id
Elist→Elist,E | E
To facilitate processing, We rewrite the grammar as
L→Elist ] | id
Elist→Elist, E | id [ E

28. New attributes and functions
Elist.array ： Symbol table entry of id
Elist.ndim ：number of dimensions.
Elist.place ：a temporary variable to store the value calculated from the index expression.
limit(array，j) ：return the length of the j-th dimension.

29. Each non-terminal L has two attribute values
L.place：
Symbol table entry of L if L is a simple variable
CONSPART value if L is a indexed variable
L.offset ：
Null if L is a simple variable
VARPART value if L is a indexed variable

30. (1) S→L:=E
(2) E→E+E
(3) E→(E)
(4) E→L
(5) L→Elist ]
(6) L→id
(7) Elist→ Elist, E
(8) Elist→id [ E

31. (1) S→L:=E
{ if L.offset=null then /*L is a simple variable*/
emit(L.place ‘:=’ E.place)
else emit( L.place ‘ [’ L.offset ‘]’ ‘:=’ E.place)}
(2) E→E1 +E2
{ E.place:=newtemp;
emit(E.place ‘:=’ E 1.place ‘+’ E 2.place)}

32. (3) E→(E1) {E.place:=E1.place}
(4) E→L
{ if L.offset=null then
E.place:=L.place
else begin
E.place:=newtemp;
emit(E.place ‘:=’ L.place ‘[’ L.offset ‘]’ )
end }

33. A[i1,i2,…,ik] ((…i1 n2+i2)n3+i3)…)nk+ik)×w + base-((…((low1 n2+low2)n3+low3)…)nk+lowk)×w
(8) Elist→id [ E
{ Elist.place:=E.place;
Elist.ndim:=1;
Elist.array:=id.place }

34. A[ i1,i2,…,ik ] ( (…i1 n2+i2)n3+i3)…)nk+ik)×w + base-((…((low1 n2+low2)n3+low3)…)nk+lowk)×w
(7) Elist→ Elist1, E
{ t:=newtemp;
m:=Elist1.ndim+1;
emit(t ‘:=’ Elist1.place ‘*’ limit(Elist1.array,m) );
emit(t ‘:=’ t ‘+’ E.place);
Elist.array:= Elist1.array;
Elist.place:=t;
Elist.ndim:=m }

35. A[i1,i2,…,ik] ((…i1 n2+i2)n3+i3)…)nk+ik) ×w + base-((…((low1 n2+low2)n3+low3)…)nk+lowk)×w
(5) L→Elist ]
{ L.place:=newtemp;
emit(L.place ‘:=’ Elist.array ‘－’ C);
L.offset:=newtemp;
emit(L.offset ‘:=’ w ‘*’ Elist.place) }
(6) L→id { L.place:=id.place; L.offset:=null }

36. a:=B[i,j]

37. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Procedure Translation

38. Type Conversion E.type: the data type of non-terminal E
Suppose there are two data types:
int op
real op
The semantic action for EE1 op E2：
{ if E1.type=integer and E2.type=integer
E.type:=integer
else E.type:=real }

39. Type Conversion Example
x:=y＋i*j
in which x,y are real and i,j are int。
Three address codes:
T1:=i int* j
T3:=inttoreal T1
T2:=y real+ T3
x:=T2

40. Semantic Action for E→E1 ＋E2
{ E.place:=newtemp;
if E1.type=integer and E2.type=integer then begin
emit (E.place ‘:=’ E 1.place ‘int+’ E 2.place);
E.type:=int
end
else if E1.type=real and E2.type=real then begin
emit (E.place ‘:=’ E 1.place ‘real+’ E 2.place);
E.type:=real

41. else if E1.type=integer and E2.type=real then begin
u:=newtemp;
emit (u ‘:=’ ‘inttoreal’ E 1.place);
emit (E.place ‘:=’ u ‘real+’ E 2.palce);
E.type:=real
end
else if E1.type=real and E1.type=integer then begin
emit (u ‘:=’ ‘inttoreal’ E 2.place);
emit (E.place ‘:=’ E 1.place ‘real+’ u);
else E.type:=type_error}

42. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Procedure Translation

43. Two translation methods
Direct translation：
A or B and C=D
(1) (=, C, D, T1)
(2) (and, B, T1, T2)
(3) (or, A, T2, T3)
Translation with optimization
if (x<100 or x>200 and x<>y) x:=0;
if x<100 goto L2 ifFalse x>200 goto L1 ifFlase x<>y goto L1 L2: x=0 L1:

44. Outline Three-Address Code Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Direct Translation
Optimized Translation
Backpatching
Procedure Translation

45. Direct translation a or b and not c can be translated into T1:=not c
T2:=b and T1
T3:=a or T1
a<b can be written as
if a<b then 1 else 0
Hence, it can translated into
100: if a<b goto 103
101: T:=0
102: goto 104
103: T:=1
104:

46. Boolean Expression Direct Translation SDT
emit – print the three address code to the output file
nextstat – address index for the next three address code
emit will add 1 to nextstat by generating a new three address code

47. Boolean Expression Direct Translation SDT
E→E1 or E2 {E.place:=newtemp;
emit(E.place ‘:=’ E 1.place ‘or’ E2.place)}
E→E1 and E2 {E.place:=newtemp;
emit(E.place ‘:=’ E 1.place ‘and’ E2.place)}
E→not E {E.place:=newtemp;
emit(E.place ‘:=’ ‘not’ E 1.place)}
E→(E1) {E.place:=E1.place}

48. Boolean Expression Direct Translation SDT
a<b is translated into
100: if a<b goto 103
101: T:=0
102: goto 104
103: T:=1
104:
Eid1 relop id2 { E.place:=newtemp;
emit(‘if’ id1.place relop. op id2. place
‘goto’ nextstat+3);
emit(E.place ‘:=’ ‘0’);
emit(‘goto’ nextstat+2);
emit(E.place‘:=’ ‘1’) }
E→id { E.place:=id.place }

49. a<b or c<d and e<f Direction Translation
100: if a<b goto 103
101: T1:=0
102: goto 104
103: T1:=1
104: if c<d goto 107
105: T2:=0
106: goto 108
107: T2:=1
108: if e<f goto 111
109: T3:=0
110: goto 112
111: T3:=1
112: T4:=T2 and T3
113: T5:=T1 or T4
Eid1 relop id2
{ E.place:=newtemp;
emit(‘if’ id1.place relop. op id2. place ‘goto’ nextstat+3);
emit(E.place ‘:=’ ‘0’);
emit(‘goto’ nextstat+2);
emit(E.place‘:=’ ‘1’) }
E→id
{ E.place:=id.place }
E→E1 or E2
{ E.place:=newtemp;
emit(E.place ‘:=’ E 1.place ‘or’ E2.place)}
E→E1 and E2
{ E.place:=newtemp;
emit(E.place ‘:=’ E 1.place ‘and’ E2.place) }

50. Outline Three-Address Code Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Direct Translation
Optimized Translation
Backpatching
Procedure Translation

51. Translation for Boolean Expression as Conditional Statement Control
if E then S1 else S2
Two exits for E : E.true and E.false
To E.true
E.code
To E.false
E.true:
S1.code
goto S.next
E.false:
S2.code ……
S.next

52. Example: if a>c or b <d then S1 else S2
the following three address code
if a>c goto L2 true exit
goto L1
L1: if b<d goto L2 true exit
goto L false exit
L2: (S1 three address code)
goto Lnext
L3: (S2 three address code)
Lnext:

53. Newlabel- a new label will be returned for each call.
For each Boolean expression E，there are two labels:
E.true is the label to reach when E is true
E.false is the label to reach when E is false

54. Three Address Code Generation SDD for Boolean Expression
Productions Semantic Rules
E→E1 or E2
E1.true:=E.true;
E1.false:=newlabel;
E2.true:=E.true;
E2.false:=E.false;
E.code:=E1.code ||
gen(E1.false ‘:’) || E2.code
E1.code
To E.true
To E1.false
E2.code
To E.false

55. Three Address Code Generation SDD for Boolean Expression
Productions Semantic Rules
E→E1 and E2
E1.true:=newlabel;
E1.false:=E.false;
E2.true:=E.true;
E2.false:=E.fasle;
E.code:=E1.code ||
gen(E1.true ‘:’) || E2.code
E1.code
To E. false
To E1. true
E2.code
To E.true
To E.false

56. Three Address Code Generation SDD for Boolean Expression
Productions Semantic Rules
E→not E E1.true:=E.false;
E1.false:=E.true;
E.code:=E1.code
E→ (E1) E1.true:=E.true;
E1.false:=E.false;

57. Three Address Code Generation SDD for Boolean Expression
Productions Semantic Rules
E→id1 relop id E.code:=gen(‘if ’ id1.place
relop.op id2.place ‘goto’ E.true) ||
gen(‘goto’ E.false)
E→true E.code:=gen(‘goto’ E.true)
E→false E.code:=gen(‘goto’ E.false)

58. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Direct Translation
Optimized Translation
Backpatching
Procedure Translation

59. Backpatching
Key problem: matching a jump instruction with the target of the jump
Passing labels as inherited attributes, a separate pass is needed to bind labels to addresses
Backpatching: passing lists of jumps as synthesized attributes

60. One-pass Code Generation for Boolean Expression
Quadruples
(jnz, a, -, p) -- if a goto p
(jrop, x, y, p) -- if x rop y goto p
(j, -, -, p) -- goto p

61. Translating Short-Circuit Expressions Using Backpatching
E  E or M E | E and M E | not E | ( E ) | id relop id | true
| false M  
Synthesized attributes:
E.code three-address code
E.truelist backpatch list for jumps on true E.falselist backpatch list for jumps on false M.quad location of current three-address quad

62. Backpatch Operations with Lists
nextquad –location of next quadruple
makelist(i) creates a new list containing three-address location i, returns a pointer to the list
merge(p1, p2) concatenates lists pointed to by p1 and p2, returns a pointer to the concatenates list
backpatch(p, i) inserts i as the target label for each of the statements in the list pointed to by p

63. Backpatching with Lists: Example
100: if a < b goto _ 101: goto _ 102: if c < d goto _ 103: goto _ 104: if e < f goto _ 105: goto _
a < b or c < d and e < f
backpatch
100: if a < b goto TRUE 101: goto : if c < d goto : goto FALSE 104: if e < f goto TRUE 105: goto FALSE

64. Backpatching with Lists: Translation Scheme
M   { M.quad := nextquad() } E  E1 or M E2
{ backpatch(E1.falselist, M.quad); E.truelist := merge(E1.truelist, E2.truelist); E.falselist := E2.falselist } E  E1 and M E2 { backpatch(E1.truelist, M.quad); E.truelist := E2.truelist; E.falselist := merge(E1.falselist, E2.falselist); } E  not E1 { E.truelist := E1.falselist; E.falselist := E1.truelist } E  ( E1 ) { E.truelist := E1.truelist; E.falselist := E1.falselist }

65. Backpatching with Lists: Translation Scheme (cont’d)
E  id1 relop id2
{ E.truelist := makelist(nextquad()); E.falselist := makelist(nextquad() + 1); emit(‘if’ id1.place relop.op id2.place ‘goto _’); emit(‘goto _’) } E  true { E.truelist := makelist(nextquad()); E.falselist := nil; emit(‘goto _’) } E  false { E.falselist := makelist(nextquad()); E.truelist := nil; emit(‘goto _’) }

66. Flow-of-Control Statements and Backpatching: Grammar
S  if E then S | if E then S else S | while E do S | begin L end | A L  L ; S | S
Synthesized attributes:
S.nextlist backpatch list for jumps to the next statement after S (or nil)
L.nextlist backpatch list for jumps to the next statement after L (or nil)
Jumps out of S1
S1 ; S2 ; S3 ; S4 ; S4 …
100: Code for S1 200: Code for S2 300: Code for S3 400: Code for S4 500: Code for S5
backpatch(S1.nextlist, 200) backpatch(S2.nextlist, 300) backpatch(S3.nextlist, 400) backpatch(S4.nextlist, 500)

67. Flow-of-Control Statements and Backpatching
S  A { S.nextlist := nil } S  begin L end { S.nextlist := L.nextlist } S  if E then M S1
{ backpatch(E.truelist, M.quad); S.nextlist := merge(E.falselist, S1.nextlist) } L  L1 ; M S { backpatch(L1.nextlist, M.quad); L.nextlist := S.nextlist; } L  S { L.nextlist := S.nextlist; } M   { M.quad := nextquad() }

68. Flow-of-Control Statements and Backpatching (cont’d)
S  if E then M1 S1 N else M2 S2
{ backpatch(E.truelist, M1.quad); backpatch(E.falselist, M2.quad); S.nextlist := merge(S1.nextlist, merge(N.nextlist, S2.nextlist)) } S  while M1 E do M2 S1 { backpatch(S1,nextlist, M1.quad); backpatch(E.truelist, M2.quad); S.nextlist := E.falselist; emit(‘goto _’) } N   { N.nextlist := makelist(nextquad()); emit(‘goto _’) }

69. while (a<b) do if (c<d) then x:=y+z;
S→if E then M S1
{ backpatch(E.truelist, M.quad);
S.nextlist:=merge(E.falselist, S1.nextlist) }
M→ { M.quad:=nextquad }
S→A { S.nextlist:=makelist( ) }
(5) E→id1 relop id2 { E.truelist:=makelist(nextquad);
E.falselist:=makelist(nextquad+1);
emit(‘j’ relop.op ‘,’ id 1.place ‘,’ id 2.place‘,’　‘_’);
emit(‘j, －, －, _’) }
S→while M1 E do M2 S1
{ backpatch(S1.nextlist, M1.quad);
backpatch(E.truelist, M2.quad);
S.nextlist:=E.falselist
emit(‘j,－,－,’ M1.quad) }
M→ { M.quad:=nextquad }
S→id:=E { p:=lookup(id.name);
if pnil then
emit(p ‘:=’ E.place)
else error }
E→E1+E2 { E.place:=newtemp;
emit(E.place ‘:=’ E1.place ‘+’ E2.place)}

70. while (a<b) do if (c<d) then x:=y+z;
100 (j<, a, b, 102)
101 (j, -, -, 107)
102 (j<, c, d, 104)
103 (j, -, -, 100)
104 (+, y, z, T)
105 (:=, T, -, x)
106 (j, -, -, 100)
107

71. Outline Intermediate Code Representation Expressions Translation
Array Element Translation
Type Conversion
Boolean Expression Translation
Procedure Translation

72. Translating Procedure Calls
S  call id ( Elist ) Elist  Elist , E | E
foo(a+1, b, 7)
t1 := a + 1 t2 := 7 param t1 param b param t2 call foo 3

73. Translating Procedure Calls
S  call id ( Elist ) { for each item p on queue do emit(‘param’ p); emit(‘call’ id.place |queue|) } Elist  Elist , E { append E.place to the end of queue } Elist  E { initialize queue to contain only E.place }