1. COMPILER DESIGN
BCA 5th
Semester 2020
Topic: Intermediate code generation
Sakhi Bandyopadhyay
Department of Computer Science and BCA
Kharagpur College
2. Introduction
• Intermediate code is the interface between front end and back end in a
compiler
• Ideally the details of source language are confined to the front end and
the details of target machines to the back end (a m*n model)
• In this chapter we study intermediate representations, static type
checking and intermediate code generation
Parser
Static
Checker
Intermediate Code
Generator
Code
Generator
Front end Back end
3. Variants of syntax trees
• It is sometimes beneficial to crate a DAG instead of tree for Expressions.
• This way we can easily show the common sub-expressions and then use
that knowledge during code generation
• Example: a+a*(b-c)+(b-c)*d
+
+ *
*
-
b c
a
d
4. SDD for creating DAG’s
1) E -> E1+T
2) E -> E1-T
3) E -> T
4) T -> (E)
5) T -> id
6) T -> num
Production Semantic Rules
E.node= new Node(‘+’, E1.node,T.node)
E.node= new Node(‘-’, E1.node,T.node)
E.node = T.node
T.node = E.node
T.node = new Leaf(id, id.entry)
T.node = new Leaf(num, num.val)
Example:
1)p1=Leaf(id, entry-a)
2)P2=Leaf(id, entry-a)=p1
3)p3=Leaf(id, entry-b)
4)p4=Leaf(id, entry-c)
5)p5=Node(‘-’,p3,p4)
6)p6=Node(‘*’,p1,p5)
7)p7=Node(‘+’,p1,p6)
8) p8=Leaf(id,entry-b)=p3
9) p9=Leaf(id,entry-c)=p4
10) p10=Node(‘-’,p3,p4)=p5
11) p11=Leaf(id,entry-d)
12) p12=Node(‘*’,p5,p11)
13) p13=Node(‘+’,p7,p12)
5. Value-number method for constructing
DAG’s
• Algorithm
• Search the array for a node M with label op, left child l and right child r
• If there is such a node, return the value number M
• If not create in the array a new node N with label op, left child l, and right child r
and return its value
• We may use a hash table
=
+
10
i
id To entry for i
num 10
+ 1 2
3 1 3
6. Three address code
• In a three address code there is at most one operator at the right side of
an instruction
• Example:
+
+ *
*
-
b c
a
d
t1 = b – c
t2 = a * t1
t3 = a + t2
t4 = t1 * d
t5 = t3 + t4
7. Forms of three address instructions
• x = y op z
• x = op y
• x = y
• goto L
• if x goto L and ifFalse x goto L
• if x relop y goto L
• Procedure calls using:
• param x
• call p,n
• y = call p,n
• x = y[i] and x[i] = y
• x = &y and x = *y and *x =y
8. Example
• do i = i+1; while (a[i] < v);
L: t1 = i + 1
i = t1
t2 = i * 8
t3 = a[t2]
if t3 < v goto L
Symbolic labels
100: t1 = i + 1
101: i = t1
102: t2 = i * 8
103: t3 = a[t2]
104: if t3 < v goto 100
Position numbers
9. Data structures for three address codes
• Quadruples
• Has four fields: op, arg1, arg2 and result
• Triples
• Temporaries are not used and instead references to instructions are made
• Indirect triples
• In addition to triples we use a list of pointers to triples
10. Example
• b * minus c + b * minus c
t1 = minus c
t2 = b * t1
t3 = minus c
t4 = b * t3
t5 = t2 + t4
a = t5
Three address code
minus
*
minus c t3
*
+
=
c t1
b t2
t1
b t4
t3
t2 t5
t4
t5 a
arg1 result
arg2
op
Quadruples
minus
*
minus c
*
+
=
c
b (0)
b (2)
(1) (3)
a
arg1 arg2
op
Triples
(4)
0
1
2
3
4
5
minus
*
minus c
*
+
=
c
b (0)
b (2)
(1) (3)
a
arg1 arg2
op
Indirect Triples
(4)
0
1
2
3
4
5
(0)
(1)
(2)
(3)
(4)
(5)
op
35
36
37
38
39
40
11. Type Expressions
Example: int[2][3]
array(2,array(3,integer))
• A basic type is a type expression
• A type name is a type expression
• A type expression can be formed by applying the array type constructor to a
number and a type expression.
• A record is a data structure with named field
• A type expression can be formed by using the type constructor for
function types
• If s and t are type expressions, then their Cartesian product s*t is a type
expression
• Type expressions may contain variables whose values are type expressions
12. Type Equivalence
• They are the same basic type.
• They are formed by applying the same constructor to structurally
equivalent types.
• One is a type name that denotes the other.
18. Translation of Expressions and
Statements
• We discussed how to find the types and offset of variables
• We have therefore necessary preparations to discuss about
translation to intermediate code
• We also discuss the type checking
26. Abstract syntax tree for the function
definition
fun length(x) =
if null(x) then 0 else length(tl(x)+1)
This is a polymorphic function
in ML language
29. Unification algorithm
boolean unify (Node m, Node n) {
s = find(m); t = find(n);
if ( s = t ) return true;
else if ( nodes s and t represent the same basic type ) return true;
else if (s is an op-node with children s1 and s2 and
t is an op-node with children t1 and t2) {
union(s , t) ;
return unify(s1, t1) and unify(s2, t2);
}
else if s or t represents a variable {
union(s, t) ;
return true;
}
else return false;
}
36. Backpatching
• Previous codes for Boolean expressions insert symbolic labels for
jumps
• It therefore needs a separate pass to set them to appropriate
addresses
• We can use a technique named backpatching to avoid this
• We assume we save instructions into an array and labels will be
indices in the array
• For nonterminal B we use two attributes B.truelist and B.falselist
together with following functions:
• makelist(i): create a new list containing only I, an index into the array of
instructions
• Merge(p1,p2): concatenates the lists pointed 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 instruction on the
list pointed to by p
![Forms of three address instructions
• x = y op z
• x = op y
• x = y
• goto L
• if x goto L and ifFalse x goto L
• if x relop y goto L
• Procedure calls using:
• param x
• call p,n
• y = call p,n
• x = y[i] and x[i] = y
• x = &y and x = *y and *x =y](https://image.slidesharecdn.com/458237-250810185229-4ed61b10/85/Compiler-Design-Intermediate-code-generation-ppt-7-320.jpg)
![Example
• do i = i+1; while (a[i] < v);
L: t1 = i + 1
i = t1
t2 = i * 8
t3 = a[t2]
if t3 < v goto L
Symbolic labels
100: t1 = i + 1
101: i = t1
102: t2 = i * 8
103: t3 = a[t2]
104: if t3 < v goto 100
Position numbers](https://image.slidesharecdn.com/458237-250810185229-4ed61b10/85/Compiler-Design-Intermediate-code-generation-ppt-8-320.jpg)
![Type Expressions
Example: int[2][3]
array(2,array(3,integer))
• A basic type is a type expression
• A type name is a type expression
• A type expression can be formed by applying the array type constructor to a
number and a type expression.
• A record is a data structure with named field
• A type expression can be formed by using the type constructor for
function types
• If s and t are type expressions, then their Cartesian product s*t is a type
expression
• Type expressions may contain variables whose values are type expressions](https://image.slidesharecdn.com/458237-250810185229-4ed61b10/85/Compiler-Design-Intermediate-code-generation-ppt-11-320.jpg)
