Chapter 8 Intermediate code generation Section 0 Overview 1.Position of Intermediate code generator...

Chapter 8 Intermediate code generation Section 0 Overview

1.Position of Intermediate code generator

parserToken stream

static

checker

Syntax tree

Intermediate code generator

Syntax tree

Intermediate code

Code generator


2.Benefits for using a machine-independent intermediate form

• Retargeting is facilitated

• A machine-independent code optimizer can be applied to the intermediate representation.


3.Implementation of Intermediate code generator

• Syntax-directed translation, folded into parsing

– Top-down parsing

– Bottom-up parsing

Chapter 8 Intermediate code generation Section 1 Intermediate languages

1.Intermediate representations

– Syntax tree (Graphical representation of statements)

• Abstract Syntax Tree

• Parsing Tree

• Directed acyclic graph(DAG)

– Postfix notation

– Three-address code

– Quadruple


2.Three-address code(TAC)

A sequence of statements of the general form x= y op z

Notes: 1)Here, x,y,z are names, constants, or compiler-generated temporaries; op stands for any operator

2)There is only one operator on the right side of a statement

3) Three address code is a linearized representation of a syntax tree or a DAG in which explicit names correspond to the interior nodes of the graph

4) Each three-address code statement contains three addresses, two for the operands and one for the result


3. Types of TAC

– X=y op z

– X=op y

– X=y

– goto L

– If x relop y goto L

– param x

call p,n

return y


3. Types of TAC

– x=y[i]

x[i]=y

– x=&y /*the value of x is the location of y*/

x=*y

*x=y


4.Syntax-directed Translation into TAC

– We can use S-attributed definition to generate three-address code for assignment statement.

– We create a new name every time a temporary is needed.

Production Semantic Rules

Sid=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 id E.place=id.place

E.code=‘’


Swhile E do S1 S.begin=newlabel();

S.after=newlabel();

S.code=gen(S.begin ‘:’)||E.code||

gen(‘if’ E.place ‘=‘ ‘0’ ‘goto’ S.after) ||

S1.code ||

gen(‘goto’ S.begin) ||

gen(S.after ‘:’)


Sif E then S1 S.after=newlabel();

S.code=E.code||

gen(‘if’ E.place ‘=‘ ‘0’ ‘goto’ S.after) ||

S1.code ||



Sif E then S1 S.after=newlabel();

else S2 E.false=newlabel();

S.code=E.code||

gen(‘if’ E.place ‘=‘ ‘0’ ‘goto’ E.false) ||

S1.code ||

gen(‘goto’ S.after) ||

gen(E.false ‘:’) ||

S2.code ||



5.Addressing array elements

1)One-dimensional array

Addr(A[i])=base+(i-low)*w=i*w+(base-low*w)

Notes:1)Here, we assume the width of each array element is w and the start address of the array block is base.

2)The array is defined as array[low..upper] of type

3)The sub-expression c=base-low*w can be evaluated when the declaration of the array is seen and we assume that c is saved in the symbol table entry for the array.


5.Addressing array elements

2)two-dimensional array

(1) row-major form

Addr(A[i1, i2])=base+((i1-low1)*n2+i2-low2)*w

=(i1*n2+i2)*w+base-(low1*n2+low2)*w

Where n2=upper2-low2+1

t1=low1*n2 t2=t1+low2 t3=t2*w t4=base-t3

t5=i1*n2 t6=t5+i2 t7=t6*w

t4[t7]=x x=t4[t7]

(2) column-major form


5.Addressing array elements3)n-dimensional array

Array[l1:u1,, l2:u2,… ln:un]

Let di=ui-li+1,i=1,2,…n, the width of each dimension is m

D=a+((i1-l1)d2d3…dn+ (i2-l2)d3d4…dn + (in-1-ln-1)dn + (in-ln))m

Change into D=conspart+varpartconspart=a-C

C=((…(l1d2+l2 )d3+ l3) d3…+ ln-1) dn+ ln)m

varpart= ((…(i1d2+i2 )d3+ i3) d3…+ in-1) dn+ in)m


6.Short-circuit code of Boolean expressions

• Translate a boolean expression into intermediate code without evaluating the entire expression.


7. Translation methods of Flow of control statements in Short-circuit code

1)Associate E with two labels

• E.true– The label to which control flows if E is true

• E.false– The label to which control flows if E is false



2)Associate S with a label

• S.next– Following S.code is a jump to some label

Production Semantic RulesSif E then S1 E.true=newlabel(); E.false=S.next; S1.next=S.next; S.code=E.code ||gen(E.true ‘:’) ||S1.codeSif E then S1 else S2 E.true=newlabel(); E.false=newlabel(); S1.next=S.next S2.next=S.next S.code=E.code ||gen(E.true ‘:’) ||S1.code||gen(‘goto’ S.next)|| gen(E.false ‘:’)||S2.code

Production Semantic RulesSwhile E do S1 S.begin=newlabel(); E.true=newlabel(); E.false=S.next; S1.next=S.begin S.code=gen(S.begin ‘:’)||E.code ||gen(E.true ‘:’) ||S1.code||gen(‘goto’ S.begin)

Production Semantic RulesEE1 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.codeEE1 and E2 E1.true=newlabel(); E1.false=E.false; E2.true=E.true; E2.false=E.false E.code=E1.code ||gen(E1.true ‘:’) ||E2.codeE id1 relop id2 E.code=gen(‘if’ id1.place relop.op id2.place ‘goto’ E.true)||gen(‘goto’ E.false)



3)Examples (1)a<b or c<d and e<f if a<b goto Ltrue goto L1 L1:if c<d goto L2 goto Lfalse L2:if e<f goto Ltrue goto Lfalse Here, we assume that the true and false exits for the entire

expression are Ltrue and Lfalse respectively



3)Examples

(2)while a<b do

if c<d then x=y+z

else x=y-z

L1: if a<b goto L2 goto LnextL2: if c<d goto L3 goto L4L3:t1=y+z x=t1 goto L1L4:t2=y-z x=t2 goto L1Lnext:

Chapter 8 Intermediate code generation Section 2 Backpatching

1.Why and what is backpatching?• When generating code for boolean expressions and flow-

of-control statements , we may not know the labels that control must go to.

• We can get around this problem by generating a series of branching statement with the targets of the jumps temporarily left unspecified.

• Each such statement will be put on a list of goto statements whose labels will be filled in when the proper label can be determined.

• This subsequent filling in of labels is called backpatching


2.Functions to manipulate lists of labels related to backpatching

• Makelist(i)– Creates a new list containing only i, an index into the

array of TAC instructions; makelist returns a pointer to the list it has made.

• Merge(p1,p2)– Concatenates the lists pointed to by p1 and p2, and

returns a pointer to the concatenated list.• Backpatch(p,i)

– Inserts i as the target label for each of the statements on the list pointed to by p.


3.Boolean expression1)Modify the grammar

E EAE | E0E | not E | (E) | i | Ea rop Ea

EA E andE0 E or

2)Semantic Rules(1) E i {E•TC=NXINSTR; E•FC=NXINSTR+1;

GEN(‘if’ i.place ‘<>0’ ‘goto 0’); GEN(‘goto 0’)}


3.Boolean expression 2)Semantic Rules (2) E Ea rop Eb

{E•TC=NXINSTR; E•FC=NXINSTR+1;

GEN(‘if’ Ea.place rop.op Eb.place ‘goto 0’);

GEN(‘goto 0’)}(3) E (E(1)) {E•TC= E(1)•TC; E•FC= E(1)•FC}(4) E not E(1) {E•TC= E(1)•FC; E•FC= E(1)•TC}


3.Boolean expression 2)Semantic Rules

(5)EA E(1) and {BACKPATCH(E(1)•TC,NXINSTR);

EA•FC= E(1)•FC;}

(6) EEAE(2)

{E•TC= E(2)•TC;

E•FC=MERG(EA•FC,E(2)•FC}


3.Boolean expression 2)Semantic Rules

(7)E0 E(1) or

{BACKPATCH(E(1)•FC,NXINSTR);

E0•TC= E(1)•TC;}

(8) EE0E(2)

{E•FC= E(2)•FC;

E•TC=MERG(E0•TC,E(2)•TC}

Translate A and B or not C

-2----# EAi or not C#

-2--# EA B or not C#

2.(j,-,-(5))-2--1-#E and B or not C#

1.(jnz,a,-,(3))-2-1#E and B or not C#

----#i and B or not C#

--#A and B or not C#

TACFCTCSYMINPUT

TACFCTCSYMINPUT3.(jnz,B,－ ,0)

－ 2 4－－ 3# EAE or not C＃

success

－ 5－ 6#E #6.(j, － , － ,3)－－ 5－ 3 6# E0 E #5.(jnz,C,－ ,0)

－－－ 6－ 3 －5

# E0 notE #

－－－－－ 3 －－

# E0 not i ＃－－－－ 3 －# E0 not C ＃－－－ 3# E0 not C ＃－ 4 －－ 3 －#E or or not C ＃

4.(j, － , －(5))

－ 4－ 3#E or not C＃


4.Flow of control statements1) modify the grammarS if E then S(1) else S(2)

C if E thenT C S(1) elseS T S(2)

S if E then S(1)

C if E thenS C S(1)


4.Flow of control statements2) Semantic Rules

C if E then {BACKPATCH(E•TC,NXINSTR); C•CHAIN=E•FC;}T C S(1) else {q=NXINSTR; GEN(‘goto 0’);

BACKPATCH(C•CHAIN,NXINSTR); T •CHAIN=MERG(S(1)•CHAIN,q)}S T S(2)

{S•CHAIN=MERG(T•CHAIN,S(2)•CHAIN)}S C S(1) {S•CHAIN=MERG(C•CHAIN,S(1)•CHAIN)}

If a then

if b then

A:=2

else A:=3

Else if c then

A=4

Else a=5

(1)(jnz,a,_,(3))(2)(j,_,_,0)(3)(jnz,b,_,(5))(4)(j,_,_,0)

Ca•CHAIN->2

Cb•CHAIN->4

(5)(:=,2,_,A)


4.Flow of control statements

3) While statement

S while E do S(1)

W while

Wd W E do

S Wd S(1)


4.flow of control statements

3) While statement

W while {W•LABEL=NXINSTR}

Wd W E do {BACKPATCH(E•TC,NXINSTR);

Wd•CHAIN=E•FC;

Wd•LABEL=W•LABEL;}

S Wd S(1){BACKPATCH(S(1)•CHAIN, Wd•LABEL);

GEN(‘goto’ Wd •LABEL);

S • CHAIN= Wd•CHAIN}


4.flow of control statements

3) While statement

Code of E

Code of S(1)

S.CHAIN

Chapter 8 Intermediate code generation Section 3 Quadruples

1.Implementations of three-address statements

• Quadruples

– (op, arg1,arg2,result)

• Triples

– (n) (op,arg1,arg2)

– (m) (op,(n),arg)

Notes: A three-address statement is an abstract form of intermediate codes


2.Advantages of quadruples

• Easy to generate target code

• Good for optimizing


3 、 Assignment statements with only id

1) functions

NEWTEMP()

GEN(OP,ARG1,ARG2,RESULT)

2)Semantic rules for quadruple code generation

(1)A i=E {GEN(=, E•PLACE ,_, i.entry}

(2)E -E (1) {T=NEWTEMP();

GEN(@, E(1)•PLACE ,_,T);

E•PLACE =T }

(3)E E (1)*E(2) {T=NEWTEMP();

GEN(*, E(1)•PLACE , E(2)•PLACE ,T);

E•PLACE =T }

(4)E E (1) + E(2) {T=NEWTEMP();

GEN(+, E(1)•PLACE , E(2)•PLACE ,T);

E•PLACE =T }

(5)E (E (1)) {E•PLACE =E(1)•PLACE }

(6)E i {E•PLACE = i.entry}

iput SYM PLACE quadruples

A=-B*(C+D)#

=-B*(C+D)# i －-B*(C+D)# i= －－B*(C+D)# i=- －－－*(C+D)# i=-i －－－*(C+D)# i=-E －－－ B

*(C+D)# i=E －－ T1 (@,B,－ ,T1)

(C+D)# i=E* －－ T1 －C+D)# i=E*( －－ T1 －－+D)# i=E*(i －－ T1 －－

C

+D)# i=E*(E

－－ T1 －－C


4.The translation scheme for addressing array elements

1) grammar

AV:=E

V i[Elist] | i

Elist Elist,E | E

E E op E | (E) | V



2) Rewriting of the grammar

AV:=E

V Elist] | i

Elist Elist(1),E | i[ E

E E op E | (E) | V

Notes: This rewriting aims that the various dimensional limits nj of the array be available as we group index expressions into an Elist.



3) semantic variables

ARRAY

DIM

PLACE

OFFSET



4) Translation code

(1)AV=E

{if (V•OFFSET=null)

GEN(=,E • PLACE,_,V•PLACE);

else GEN([ ]=,E•PLACE,_,V•PLACE[V•OFFSET])}


(2)E E(1) op E (2) {T=NEWTEMP();

GEN(op, E(1) •PLACE, E(2) •PLACE,T);

E • PLACE =T}

(3)E (E (1)) {E • PLACE = E(1) •PLACE}

(4)E V {if (V•OFFSET=null)

E • PLACE = V •PLACE;

else

{T=NEWTEMP();

GEN(=[ ], E • PLACE[V •OFFSET],_,T);

E • PLACE =T;}}


(5)V Elist] {if (TYPE[ARRAY]<>1)

{T=NEWTEMP();

GEN(*,Elist•PLACE,TYPE[ARRAY],T);

Elist •PLACE=T;}

V •OFFSET=Elist •PLACE;

T=NEWTEMP();

GEN(-,HEAD[ARRAY],CONS[ARRAY],T);

V •PLACE=T}

(6)V i {V •PLACE=ENTRY[i];

V •OFFSET=null}


(7)Elist Elist(1),E {T=NEWTEMP();

k= Elist(1) •DIM+1;

dk=LIMIT(Elist(1)•ARRAY,k);

GEN(*,Elist (1) •PLACE, dk,T);

T1=NEWTEMP();

GEN(+,T,E •PLACE, T1);

Elist•ARRAY= Elist(1)•ARRAY;

Elist•PLACE= T1;

Elist•DIM=k;


(8)Elist i[ E

{Elist•PLACE=E•PLACE;

Elist•DIM=1;

Elist•ARRAY=ENTRY(i)}


E.g. Let A be an array:ARRAY[1:10,1:20]; the address of the beginning of the array is a, m=1.

We can get C by the computing: (low1*n2+low2)*m=(1*20+1)*1=21

The quadruples for X=A[I,J] are:

(1) (*,I,20,T1)

(2) (+, T1,J, T2)

(3) (-,a,21, T3)

(4) (=[ ], T3[T2],_, T4)

(5) (=, T4,_,X)


5.Boolean expressions1)Primary purposes of boolean expressions

– Compute logical values– Used as conditional expressions in

statements that alter the flow of control,such as if or while statements.

2)Grammar– E E and E | E or E | not E | (E) | i | Ea rop

Ea


5.Boolean expressions

3).Numerical representation

(1)EEa(1) rop Ea

(2) {T=NEWTEMP();

GEN(rop, Ea(1)•PLACE , Ea

(2)•PLACE ,T);

E•PLACE =T }

(2)E E (1) bop E(2) {T=NEWTEMP();

GEN(bop, E(1)•PLACE , E(2)•PLACE ,T);

E•PLACE =T }



3).Numerical representation

(3)E not E (1) {T=NEWTEMP; GEN(not, E(1)•PLACE , _ ,T); E•PLACE =T }

(4)E (E (1)) {E•PLACE =E(1)•PLACE }

(5)E i {E•PLACE = ENTRY(i)}


5.Boolean expressions3).Numerical representationE.g. X+Y>Z or A and (not B or C)

(+,X,Y,T1) ;E+E

(>, T1,Z, T2) ; E >E

(not,B,_, T3) ; not E

(or, T3,C, T4) ; E or E

(and ,A, T4,T5) ; E and E

(or, T2, T5, T6) ; E or E



4).Short-circuit code

• Translate a boolean expression into intermediate code without evaluating the entire expression.

• Represent the value of an expression by a position in the code sequence.

• E.g. if A or B<D then S1 else S2

(1)(jnz,A,_,(5)) ;E.true, to S1

(2)(j,__,(3)) ;E.false, look at the right of or(3)(j<,B,D,(5)) ;Ea.true, to S1 (4)(j,_,_,(P+1)) ; Ea.false, to S2 (5) S1

……(P)(j,_,_,(q)) ;jump over S2

(p+1) S2

……(q)the code after S2


6.BackPatching1).Functions to manipulate lists of labels related to

backpatching• Makelist(i)

– Creates a new list containing only i, an index into the array of quadruples; makelist returns a pointer to the list it has made.

• Merge(p1,p2)• Backpatch(p,i)


6.Backpatching2).Boolean expression(1)Modify the grammar

E EAE | E0E | not E | (E) | i | Ea rop Ea

EA E andE0 E or

(2)Semantic Rules(1) E i {E•TC=NXQ; E•FC=NXQ+1; GEN(jnz,ENTRY(i),_,0); GEN(j,_,_,0)}


6.Backpatching2).Boolean expression (2)Semantic Rules (2) E Ea rop Ea

{E•TC=NXQ; E•FC=NXQ+1;

GEN(jrop, Ea(1)•PLACE, Ea

(2)•PLACE,0); GEN(j,_,_,0)}(3) E (E(1)) {E•TC= E(1)•TC; E•FC= E(1)•FC}(4) E not E(1) {E•TC= E(1)•FC; E•FC= E(1)•TC}


6.Backpatching2).Boolean expression(2)Semantic Rules

(5)EA E(1) and {BACKPATCH(E(1)•TC,NXQ);

EA•FC= E(1)•FC;}

(6) EEAE(2)

{E•TC= E(2)•TC;

E•FC=MERG(EA•FC,E(2)•FC}


6.Backpatching2).Boolean expression (2)Semantic Rules

(7)E0 E(1) or

{BACKPATCH(E(1)•FC,NXQ);

E0•TC= E(1)•TC;}

(8) EE0E(2)

{E•FC= E(2)•FC;

E•TC=MERG(E0•TC,E(2)•TC}

Translate A and B or not C

-2----# EAi or not C#

-2--# EA B or not C#

2.(j,-,-(5))-2--1-#E and B or not C#

1.(jnz,a,-,(3))-2-1#E and B or not C#

----#i and B or not C#

--#A and B or not C#

quadrupleFCTCSYMINPUT

quadrupleFCTCSYMINPUT3.(jnz,B,－ ,0)

－ 2 4－－ 3# EAE or not C＃

success

－ 5－ 6#E #6.(j, － , － ,3)－－ 5－ 3 6# E0 E #5.(jnz,C,－ ,0)

－－－ 6－ 3 －5

# E0 notE #

－－－－－ 3 －－

# E0 not i ＃－－－－ 3 －# E0 not C ＃－－－ 3# E0 not C ＃－ 4 －－ 3 －#E or or not C ＃

4.(j, － , －(5))

－ 4－ 3#E or not C＃


6.Backpatching3) Flow of control statements(1) modify the grammarS if E then S(1) else S(2)

C if E thenT C S(1) elseS T S(2)

S if E then S(1)

C if E thenS C S(1)


6.Backpatching3) Flow of control statements(2) Semantic Rules

C if E then {BACKPATCH(E•TC,NXQ); C•CHAIN=E•FC;}T C S(1) else {q=NXQ; GEN(j, － , － 0); BACKPATCH(C•CHAIN,NXQ); T •CHAIN=MERG(S(1)•CHAIN,q)}S T S(2)

{S•CHAIN=MERG(T•CHAIN,S(2)•CHAIN)}S C S(1) {S•CHAIN=MERG(C•CHAIN,S(1)•CHAIN)}

e.g.

If a then

if b then

A:=2

else A:=3

Else if c then

A=4

Else a=5

(1) (jnz,a,_,0)(2) (j,_,_,0)

If a then

if b then

A:=2

else A:=3

Else if c then

A=4

Else a=5

(1)(jnz,a,_,(3))(2)(j,_,_,0)(3)(jnz,b,_,0)(4)(j,_,_,0)

Ca•CHAIN->2

If a then

if b then

A:=2

else A:=3

Else if c then

A=4

Else a=5

(1)(jnz,a,_,(3))(2)(j,_,_,0)(3)(jnz,b,_,(5))(4)(j,_,_,0)

Ca•CHAIN->2

Cb•CHAIN->4

(5)(:=,2,_,A)

If a then

if b then

A:=2

else A:=3

Else if c then

A=4

Else a=5

(1)(jnz,a,_,(3))(2)(j,_,_,0)(3)(jnz,b,_,(5))(4)(j,_,_,(7))(5)(:=,2,_,A)

Ca•CHAIN->2

Cb•CHAIN->6

(6)(j,_,_,0)

Answer

(1)(jnz,a,_,(3)) (8)(j,_,_,6)

(2)(j,_,_,(9)) (9)(jnz,c,_,(11))

(3)(jnz,b,_,(5)) (10)(j,_,_,(13))

(4)(j,_,_,(7)) (11)(:=,4,_,A)

(5)(:=,2,_,A) (12)(j,_,_,8)

(6)(j,_,_,0) (13)(:=,5,_,A)

(7)(:=,3,_,A)S•CHAIN->6->8->12

a

b

S1(A:=2)

S2(A:=3)

c

S3(A:=4)

S4(A:=5)

TRUEFALSE

1,2

3,4

5

7

9,10

11

13

6

8

12


6.Backpatching4) While statement

S while E do S(1)

W while

Wd W E do

S Wd S(1)


6.Backpatching4) While statement W while {W•QUAD=NXQ}

Wd W E do {BACKPATCH(E•TC,NXQ);

Wd•CHAIN=E•FC;

Wd•QUAD=W•QUAD;}

S Wd S(1){BACKPATCH(S(1)•CHAIN, Wd•QUAD);

GEN(j,_,_, Wd •QUAD);

S • CHAIN= Wd•CHAIN}


6.Backpatching4) While statement

Code of E

Code of S(1)

S.CHAIN

e.g.

While (A<B) do

if (C<D) then

X:=Y+Z; (100) (j<,A,B,0)

(101)(j,_,_,0)

e.g.

While (A<B) do

if (C<D) then

X:=Y+Z;

： (100) (j<,A,B,(102))

(101)(j,_,_,0)

(102)(j<,C,D,0)

(103)(j,_,_,(100))

e.g.

While (A<B) do

if (C<D) then

X:=Y+Z; ： (100) (j<,A,B,(102))

(101)(j,_,_,0)

(102)(j<,C,D,(104))

(103)(j,_,_,(100))

(104)(+,Y,Z,T1)

(105)(:=, T1,_,X)

e.g.

While (A<B) do

if (C<D) then

X:=Y+Z;

： (100) (j<,A,B,(102)) (106)(j,_,_,(100))

(101)(j,_,_,(107))

(102)(j<,C,D,(104))

(103)(j,_,_,(100))

(104)(+,Y,Z,T1)

(105)(:=, T1,_,X)

Chapter 8 Intermediate code generation Section 0 Overview 1.Position of Intermediate code generator...

Documents

Transcript of Chapter 8 Intermediate code generation Section 0 Overview 1.Position of Intermediate code generator...