Chapter 11 - Intermediate Code Generation.pdf

Dr. Shaukat Ali
Chapter # 11
Inermediate Code Generation
Dr. Shaukat Ali
Department of Computer Science
University of Peshawar

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 source code can directly be translated into its target machine
code
 Why at all we need to translate the source code into an intermediate
code which is then translated to its target code?

Why Intermediate Code?
 If a compiler translates the source language to its target machine
language without having the option for generating intermediate
code, then for each new machine, a full native compiler is
required
 Intermediate code eliminates the need of a new full compiler for
every unique machine by keeping the analysis portion same for all
every unique machine by keeping the analysis portion same for all
the compilers
 The second part of compiler, synthesis, is changed according to the
target machine
 It becomes easier to apply the source code modifications to
improve code performance by applying code optimization
techniques on the intermediate code

Why Intermediate Code?
 While generating machine code directly from source code is
possible, it entails problems
 With m languages and n target machines, we need to write m
front ends, m x n optimizers, and m x n code generators
 The code optimizer which is one of the largest and very-
 The code optimizer which is one of the largest and very-
difficult-to-write components of a compiler, cannot be reused
 By converting source code to an intermediate code, a
machine-independent code optimizer may be written
 This means just m front ends, n code generators and 1
optimizer

Intermediate Representation
 Intermediate codes can be represented in a variety of ways and
they have their own benefits
 High Level IR - High-level intermediate code representation is very
close to the source language itself.They can be easily generated from
the source code and we can easily apply code modifications to
enhance performance. But for target machine optimization, it is less
enhance performance. But for target machine optimization, it is less
preferred
 Low Level IR -This one is close to the target machine, which makes
it suitable for register and memory allocation, instruction set
selection, etc. It is good for machine-dependent optimizations
 Intermediate code can be either language specific (e.g., Byte Code
for Java) or language independent (three-address code).

Intermediate Code Generation
 Intermediate code must be easy to produce and easy to translate
to machine code
 A sort of universal assembly language
 Should not contain any machine-specific parameters (registers,
addresses, etc.)
 Intermediate code is represented in three-address space but the
 Intermediate code is represented in three-address space but the
type of intermediate code implementation is based on the
compiler designer
 Quadruples, triples, indirect triples are the classical forms used for
machine-independent optimizations and machine code generation
 Static SingleAssignment form (SSA) is a recent form and enables
more effective optimizations

Three-Address Code
 Instructions are very simple : LHS is the target and the
RHS has at most two sources and one operator
 RHS sources can be either variables or constants
 Examples: a = b + c, x = -y, if a > b
Examples: a = b + c, x = -y, if a > b
goto L1
 Three-address code is a generic form and can be
implemented as quadruples, triples, indirect triples
 Example:The three-address code for (a+b*c)-
(d/(b*c)) is below

IR Code is Made From
 (a+b*c)- (d/(b*c))
 Intermediate Code
t1 = b * c
t2 = a + t1
t3 = d / t1
t4 = t2 – t3

Example
 The intermediate code produced from DAG is more
compact as compared AST
 a = b * (minus c) + b * (minus c)

Instructions in 3 – Address Space (1)
 Assignment instructions: a = b biop c, a = uop b,
and a = b (copy)
 Where
 biop is any binary arithmetic, logical, or relational operator
 uop is any unary arithmetic (++, --, conversion) or logical operator (!)
 Conversion operators are useful for converting integers to floating point
numbers, etc.
numbers, etc.
 Jump instructions:
goto L (unconditional jump to L),
if t goto L (it t is true then jump to L),
if a relop b goto L (jump to L if a relop b is true),
 where
 L is the label of the next three-address instruction to be executed
 t is a boolean variable
 a and b are either variables or constants

 Functions:
func begin <name> (beginning of the function),
func end (end of a function),
param p (place a value parameter p on stack),
refparam p (place a reference parameter p on stack),
call f, n (call a function f with n parameters),
call f, n (call a function f with n parameters),
return (return from a function),
return a (return from a function with a value a)
 Indexed copy instructions:
a = b[i] (a is set to contents(baseaddress(b)+offset(i)),
where b is (usually) the base address of an array
a[i] = b (ith location of array a is set to b)

 Pointer assignments:
a = &b (a is set to the address of b, i.e., a points to b)
*a = b (contents(contents(a)) is set to contents(b))
a = *b (a is set to contents(contents(b)))

Intermediate Code – Example 1

Data Structures for 3 – Address Code
 Quadruples
 Has four fields: op, arg1, arg2 and result
 Temporaries are used
 Triples
 Temporaries are not used and instead references to instructions
 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

Quadruples
 In quadruples representation, there are four fields for each
instruction: op, arg1, arg2, result
 Binary ops have the obvious representation
 Unary ops do not use arg2
 Operators like param does not use either arg2 result
 Operators like param does not use either arg2 result
 Jumps put the target label into the result
 The quadruples implement the three address space for the
expression
a = b * (-c) + b * (-c)

Triples
 Triples has only three fields for each instruction: op, arg1,
arg2
 The result of an operation x op y is referred by its position
 Triples are equivlant to signature of nodes in DAG or syntax
tree
tree
 Triples and DAG are equivalent representations only for
expressions
 Ternary operation like X[i] =Y requires two entries in the
triple structure; similarly forY = X[i]

Indirect Triples
 These consist of a listing of pointers to triples; rather than a
listing of the triples themselves
 The triples consists of three fields: op, arg1, arg2
 The arg1 or arg2 could be pointers

Example
 a = 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
IndirectTriples
(4)
0
1
2
3
4
5
(0)
(1)
(2)
(3)
(4)
(5)
op
35
36
37
38
39
40

Chapter 11 - Intermediate Code Generation.pdf

More Related Content

Similar to Chapter 11 - Intermediate Code Generation.pdf (20)

Recently uploaded (20)

Chapter 11 - Intermediate Code Generation.pdf