CS6109 – COMPILER DESIGN

Module – 12

Presented By
Dr. S. Muthurajkumar,
Assistant Professor,
Dept. of CT, MIT Campus,
Anna University, Chennai.
MODULE - 12
 Principle sources of optimization
 Optimization in Basic blocks
 DAG
 Structure Preserving transformation
 Functional transformation
 Loop optimization
 Peep hole optimization

2
PRINCIPLE SOURCES OF
OPTIMIZATION
 A compiler optimization must preserve the semantics of the original program.
 Except in very special circumstances, once a programmer chooses and
implements a particular algorithm, the compiler cannot understand enough
about the program to replace it with a substantially different and more efficient
algorithm.
 A compiler knows only how to apply relatively low-level semantic
transformations, using general facts such as algebraic identities like i+0 = i or
program semantics such as the fact that performing the same operation on the
same values yields the same result.

3
EXAMPLE
C code for quicksort

4
EXAMPLE
Three-address code for fragment of quicksort

5
EXAMPLE
 t6 = 4*i
 x = a[t6]
 as shown in steps (14) and (15). Similarly, a[j] = x becomes
 t10 = 4*j
 a[t10] = x
 in steps (20) and (21).

6
EXAMPLE
 Flow graph for the quicksort fragment

7
Semantics-Preserving Transformations
 There are a number of ways in which a compiler can improve a program
without changing the function it computes.
 Common-subexpression elimination, copy propagation, dead-code elimination,
and constant folding are common examples of such function-preserving (or
semantics-preserving) transformations; we shall consider each in turn.

Local common-subexpression elimination 8

Semantics-Preserving Transformations
 Global Common Subexpressions
 An occurrence of an expression E is called a common subexpression if E was
previously computed and the values of the variables in E have not changed
since the previous computation.
 We avoid recomputing E if we can use its previously computed value; that is,
the variable x to which the previous computation of E was assigned has not
changed in the interim.

9
Semantics-Preserving Transformations
 B5 and B6 after
common-subexpression elimination

10
Semantics-Preserving Transformations
 Global Common Subexpressions
 t8 = 4*j
 t9 = a[t8]
 a[t8] = x
 in B5 can be replaced by
 t9 = a[t4]
 a[t4] = x
 using t4 computed in block B3.
 The statements
 t9 = a[t4]
 a[t6] = t9
 in B5 therefore can be replaced by
 a[t6] = t5
11
Semantics-Preserving Transformations
 Copy Propagation
 Copies introduced during common subexpression elimination

12
Semantics-Preserving Transformations
 Copy Propagation
 x = t3
 a[t2] = t5
 a[t4] = t3
 goto B2
 Basic block B5 after copy propagation

13
Semantics-Preserving Transformations
 Dead-Code Elimination
 a[t2] = t5
 a[t4] = t3
 goto B2
 This code is a further improvement of block B5.

14
Semantics-Preserving Transformations
 Code Motion
 Loops are a very important place for optimizations, especially the inner loops
where programs tend to spend the bulk of their time.
 The running time of a program may be improved if we decrease the number of
instructions in an inner loop, even if we increase the amount of code outside
that loop.
 An important modification that decreases the amount of code in a loop is code
motion.
 This transformation takes an expression that yields the same result independent
of the number of times a loop is executed (a loop-invariant computation) and
evaluates the expression before the loop.

15
Semantics-Preserving Transformations
 Induction Variables and Reduction in Strength
 Another important optimization is to find induction variables in loops and
optimize their computation.
 A variable x is said to be an “induction variable” if there is a positive or
negative constant c such that each time x is assigned, its value increases by c.

16
Semantics-Preserving Transformations
 Induction Variables and
Reduction in Strength

 Strength reduction
applied to 4 * j in block B3

17
Semantics-Preserving Transformations
 Induction Variables and
Reduction in Strength

 Flow graph after

induction-variable elimination
 We conclude this section with
one more instance of
induction-variable elimnation

18
PEEPHOLE OPTIMIZATION
 A simple but effective technique for locally improving the target code is
peephole optimization, which is done by examining a sliding window of target
instructions (called the peephole) and replacing instruction sequences within
the peephole by a shorter or faster sequence, whenever possible.
 Peephole optimization can also be applied directly after intermediate code
generation to improve the intermediate representation.
 The peephole is a small, sliding window on a program.
 The code in the peephole need not be contiguous, although some
implementations do require this.
 It is characteristic of peephole optimization that each improvement may spawn
opportunities for additional improvements.

19
PEEPHOLE OPTIMIZATION
 The program transformations that are characteristic of peephole optimizations:
 Redundant-instruction elimination
 Flow-of-control optimizations
 Algebraic simplifications
 Use of machine idioms

20
PEEPHOLE OPTIMIZATION
 Eliminating Redundant Loads and Stores
 If we see the instruction sequence
 LD R0, a
 ST a, R0
 in a target program, we can delete the store instruction because whenever it is
executed, the first instruction will ensure that the value of a has already been
loaded into register R0.

21
PEEPHOLE OPTIMIZATION
 Eliminating Unreachable Code
 Another opportunity for peephole optimization is the removal of unreachable
instructions. An unlabeled instruction immediately following an unconditional
jump may be removed. This operation can be repeated to eliminate a sequence
of instructions.
 In the intermediate representation, this code may look like
if debug == 1 goto L1
goto L2
L1: print debugging information
L2:
 One obvious peephole optimization is to eliminate jumps over jumps.

22
PEEPHOLE OPTIMIZATION
 Eliminating Unreachable Code
 Thus, no matter what the value of debug, the code sequence above can be
replaced by
if debug != 1 goto L2
print debugging information
L2:
 If debug is set to 0 at the beginning of the program, constant propagation would
transform this sequence into
if 0 != 1 goto L2
print debugging information
L2:
 Now the argument of the first statement always evaluates to true, so the statement
can be replaced by goto L2. Then all statements that print debugging information
are unreachable and can be eliminated one at a time.
23
PEEPHOLE OPTIMIZATION
 Flow-of-Control Optimizations
 Simple intermediate code-generation algorithms frequently produce jumps to
jumps, jumps to conditional jumps, or conditional jumps to jumps.
 These unnecessary jumps can be eliminated in either the intermediate code or
the target code by the following types of peephole optimizations.
 We can replace the sequence
goto L1
…
L1: goto L2
 by the sequence
goto L2
….
L1: goto L2
24
PEEPHOLE OPTIMIZATION
 Flow-of-Control Optimizations
 If there are now no jumps to L1, then it may be possible to eliminate the
statement L1: goto L2 provided it is preceded by an unconditional jump.
 Similarly, the sequence
if a < b goto L1
…
L1: goto L2
 can be replaced by the sequence
if a < b goto L2
…
L1: goto L2
25
PEEPHOLE OPTIMIZATION
 Finally, suppose there is only one jump to L1 and L1 is preceded by an
unconditional goto. Then the sequence
goto L1
...
L1: if a < b goto L2
L3:
 may be replaced by the sequence
if a < b goto L2
goto L3
...
L3:
 While the number of instructions in the two sequences is the same, we sometimes
skip the unconditional jump in the second sequence, but never in the first. Thus,
the second sequence is superior to the first in execution time.
26
PEEPHOLE OPTIMIZATION
 Algebraic Simplification and Reduction in Strength
 These algebraic identities can also be used by a peephole optimizer to eliminate
three-address statements such as
x=x+0
or
x=x*1
 in the peephole.
 Similarly, reduction-in-strength transformations can be applied in the peephole
to replace expensive operations by equivalent cheaper ones on the target
machine.
 Certain machine instructions are considerably cheaper than others and can
often be used as special cases of more expensive operators.
27
PEEPHOLE OPTIMIZATION
 Use of Machine Idioms
 The target machine may have hardware instructions to implement certain
specific operations efficiently.
 Detecting situations that permit the use of these instructions can reduce
execution time significantly.
 For example, some machines have auto-increment and auto-decrement
addressing modes.
 These add or subtract one from an operand before or after using its value.
 The use of the modes greatly improves the quality of code when pushing or
popping a stack, as in parameter passing.
 These modes can also be used in code for statements like x = x+1.

28
 REFERENCE
1. Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman, “Compilers:
Principles, Techniques and Tools”, Second Edition, Pearson Education Limited,
2014.
2. Randy Allen, Ken Kennedy, “Optimizing Compilers for Modern Architectures:
A Dependence-based Approach”, Morgan Kaufmann Publishers, 2002.
3. Steven S. Muchnick, “Advanced Compiler Design and Implementation”,
Morgan Kaufmann Publishers - Elsevier Science, India, Indian Reprint, 2003.
4. Keith D Cooper and Linda Torczon, “Engineering a Compiler”, Morgan
Kaufmann Publishers, Elsevier Science, 2004.
5. V. Raghavan, “Principles of Compiler Design”, Tata McGraw Hill Education
Publishers, 2010.
6. Allen I. Holub, “Compiler Design in C”, Prentice-Hall Software Series, 1993.

29
30