This document discusses code optimization techniques performed by compilers. It describes how compilers apply transformations called optimizations to improve code performance and reduce code size. These optimizations are performed in multiple phases including at the source code level, intermediate code level, and target code level. Specific optimization techniques discussed include redundant instruction elimination, constant folding, algebraic transformations, copy propagation, common subexpression elimination, dead code elimination, and loop optimizations such as induction variable elimination and strength reduction.

1. C dCode
O i i iOptimization
P K Singh 1M M M Engg. College, Gorakhpur

2. Code Optimization and Phases
source front code
intermediate
code code
intermediate
code targetsource
program
front
end
code
optimizer
code code
generator
code target
code
symbol
table
P K Singh 2M M M Engg. College, Gorakhpur

3. Optimization
• Code produced by standard algorithms can often be made to run
faster, take less space or both
• These improvements are achieved through transformations called• These improvements are achieved through transformations called
optimization
• Compilers that apply these transformations are called optimizing
compilerscompilers
• It is especially important to optimize frequently executed parts of a
program
The 90/10 rule– The 90/10 rule
– Profiling can be helpful, but compilers do not typically have sample input
data
– Inner loops tend to be good candidates for optimizationInner loops tend to be good candidates for optimization
P K Singh 3M M M Engg. College, Gorakhpur

4. Criteria for Transformations
• A transformation must preserve the meaning of
a programa program
– Can not change the output produced for any input
– Can not introduce an errorCan not introduce an error
• Transformations should, on average, speed up
programsprograms
• Transformations should be worth the effort
P K Singh 4M M M Engg. College, Gorakhpur

5. Beyond Optimizing Compilers
• Really improvements can be made at various phases
• Source code:
Algorithmic transformations can produce spectacular– Algorithmic transformations can produce spectacular
improvements
– Profiling can be helpful to focus a programmer's attention on
important codep
• Intermediate code:
– Compiler can improve loops, procedure calls, and address
calculationscalculations
– Typically only optimizing compilers include this phase
• Target code:
Compilers can use registers efficiently– Compilers can use registers efficiently
– Peephole transformation can be applied
P K Singh 5M M M Engg. College, Gorakhpur

6. Peephole Optimizations
• A simple technique for locally improving target
code (can also be applied to intermediate code)( )
• The peephole is a small, moving window on the
target program
• Each improvement replaces the instructions of
the peephole with a shorter or faster sequence
• Each improvement may create opportunities for
additional improvements
• Repeated passes may be necessary
P K Singh 6M M M Engg. College, Gorakhpur

7. Redundant-Instruction Elimination
• Redundant loads and stores:
(1)MOV R0 a(1)MOV R0, a
(2)MOV a, R0
• Unreachable code:
#define debug 0
if (debug) {
/* i t d b i i f ti *//* print debugging information */
}
P K Singh 7M M M Engg. College, Gorakhpur

8. Flow-of-Control Optimizations
• Jumps to jumps, jumps to conditional jumps, and conditional jumps
to jumps are not necessary
• Jumps to jumps example:p j p p
– The following replacement is valid:
goto L1
…
goto L2
…
– If there are no other jumps to L1 and L1 is preceded by an unconditional
L1: goto L2 L1: goto L2
– If there are no other jumps to L1 and L1 is preceded by an unconditional
jump, the statement at L1 can be eliminated
• Jumps to conditional jumps and conditional jumps to jumps lead to
similar transformations
P K Singh 8M M M Engg. College, Gorakhpur

9. Other Peephole Optimizationsp p
• A few algebraic identities that occur frequently
(such as x := x + 0 or x := x * 1) can be
eliminated
• Reduction in strength replaces expensive
operations with cheaper onesoperations with cheaper ones
– Calculating x * x is likely much cheaper than x^2 using an
exponentiation routine
– It may be cheaper to implement x * 5 as x * 4 + x
• Some machines may have hardware instructions to
implement certain specific operations efficiently
– For example, auto-increment may be cheaper than a straight-For example, auto increment may be cheaper than a straight
forward x := x + 1
– Auto-increment and auto-decrement are also useful when
pushing into or popping off of a stackp g p pp g
P K Singh 9M M M Engg. College, Gorakhpur

10. Optimizing Intermediate Code
• This phase is generally only included in
optimizing compilersoptimizing compilers
• Offers the following advantages:
Operations needed to implement high level constructs– Operations needed to implement high-level constructs
are made explicit (i.e. address calculations)
– Intermediate code is independent of target machine;p g ;
code generator can be replaced for different machine
• We are assuming intermediate code uses three-
address instructions
P K Singh 10M M M Engg. College, Gorakhpur

11. QuickSort in C
void quicksort(int m, int n) {
int i, j, v, x;
if (n <= m) return;if (n < m) return;
/* Start of partition code */
i = m-1; j = n; v =a[n];
while (1) {
do i = i+1; while (a[i] < v);
do j = j-1; while (a[j] > v);
if (i >= j) break;( j) ;
x = a[i]; a[i] = a[j]; a[j] = x;
}
x = a[i]; a[i] = a[n]; a[n] = x;
/* E d f titi d *//* End of partition code */
quicksort(m, j); quicksort(i+1, n);
}
P K Singh 11M M M Engg. College, Gorakhpur

12. Partition in Three-Address Code
(1) i := m-1
(2) j := n
(3) 1 4*
(16) t7 := 4*i
(17) t8 := 4*j
(18) 9 [ 8](3) t1 := 4*n
(4) v := a[t1]
(5) i := i+1
(6) t2 := 4*i
(18) t9 := a[t8]
(19) a[t7] := t9
(20) t10 := 4*j
(21) a[t10] := x( )
(7) t3 := a[t2]
(8) if t3 < v goto (5)
(9) j := j-1
(10) t4 : 4*j
( ) [ ]
(22) goto (5)
(23) t11 := 4*i
(24) x := a[t11]
(25) t12 : 4*i(10) t4 := 4*j
(11) t5 := a[t4]
(12) if t5 > v goto (9)
(13) if i >= j goto (23)
(25) t12 := 4*i
(26) t13 := 4*n
(27) t14 := a[t13]
(28) a[t12] := t14
(14) t6 := 4*i
(15) x := a[t6]
(29) t15 := 4*n
(30) a[t15] := x
P K Singh 12M M M Engg. College, Gorakhpur

13. Partition Flow Graph
P K Singh 13M M M Engg. College, Gorakhpur

14. Local vs. Global Transformations
• Local transformations involve statements within a
single basic block
• All other transformations are called global
transformations
• Local transformations are generally performed first
• Many types of transformations can be performed
either locally or globally
P K Singh 14M M M Engg. College, Gorakhpur

15. Code Optimizations
• Local/global common subexpression elimination
• Dead code elimination• Dead-code elimination
• Instruction reordering
C t t f ldi• Constant folding
• Algebraic transformations
C i• Copy propagation
• Loop optimizations
15P K Singh M M M Engg. College, Gorakhpur

16. Loop Optimizations
• Code motion
• Induction variable elimination• Induction variable elimination
• Reduction in strength
l t• … lots more
16P K Singh M M M Engg. College, Gorakhpur

17. Code Motion
i := 0
t2 := 4*i
B1:
B2:
i := 0
t1 := n-2
B1:
t :
A[t2] := 0
i := i+1
t2 := 4*i
A[t2] := 0
i := i+1
B2:
t1 := n-2
if i < t1 goto B2
B3:
if i < t1 goto B2B3:
Move loop-invariant computations before the loop
17P K Singh M M M Engg. College, Gorakhpur

18. Strength Reduction
i := 0
t1 := n-2
B1: i := 0
t1 := n-2
t2 := 4*i
B1:
t2 := 4*i
A[t2] := 0
i := i+1
B2: A[t2] := 0
i := i+1
t2 := t2+4
B2:
if i < t1 goto B2B3: if i < t1 goto B2B3:
Replace expensive computations with induction variables
18P K Singh M M M Engg. College, Gorakhpur

19. Reduction Variable Elimination
i 0B1: t1 4*B1:i := 0
t1 := n-2
t2 := 4*i
B1:
B2
t1 := 4*n
t1 := t1-8
t2 := 4*i
B1:
A[t2] := 0
i := i+1
t2 := t2+4
B2:
A[t2] := 0
t2 := t2+4
B2:
if i<t1 goto B2B3: if t2<t1 goto B2B3:
Replace induction variable in expressions with another
19P K Singh M M M Engg. College, Gorakhpur

20. Common Subexpressions
• E is a common subexpression if:
– E was previously computed– E was previously computed
– Variables in E have not changed since previous
computation
• Can avoid recomputing E if previously computed
value is still available
• Dags are useful to detect common subexpressions
P K Singh 20M M M Engg. College, Gorakhpur

21. Local Common Subexpressionsp
t6 := 4*i
x := a[t6]
7 4*i
t6 := 4*i
[ 6]t7 := 4*i
t8 := 4*j
t9 := a[t8]
a[t7] := t9
x := a[t6]
t8 := 4*j
t9 := a[t8]
a[t6] := t9a[t7] := t9
t10 := 4*j
a[t10] := x
goto B2
a[t6] := t9
a[t8] := x
goto B2
goto B2
P K Singh 21M M M Engg. College, Gorakhpur

22. Global Common Subexpressionsp
P K Singh 22M M M Engg. College, Gorakhpur

23. Copy Propagation
• Assignments of the form f := g are called copy
statements (or copies)
• The idea behind copy propagation is to use g for f
whenever possible after such a statement
• For example applied to block B5 of the previous• For example, applied to block B5 of the previous
flow graph, we obtain:
x := t3
[t2] t5a[t2] := t5
a[t4] := t3
goto B2
Copy propagation often turns the copy statement• Copy propagation often turns the copy statement
into "dead code"
P K Singh 23M M M Engg. College, Gorakhpur

24. Dead-Code Elimination
• Dead code includes code that can never be reached and
code that computes a value that never gets used
C id if (d b ) i• Consider: if (debug) print …
– It can sometimes be deduced at compile time that the value of an
expression is constant
– Then the constant can be used in place of the expression (constant– Then the constant can be used in place of the expression (constant
folding)
– Let's assume a previous statement assigns debug := false and
value never changes
– Then the print statement becomes unreachable and can be
eliminated
• Consider the example from the previous slide
The value of computed by the copy statement never gets used after– The value of x computed by the copy statement never gets used after
the copy propagation
– The copy statement is now dead code and can be eliminated
P K Singh 24M M M Engg. College, Gorakhpur

25. Loop Optimizations (1)
• The running time of a program may be improved if
we do both of the following:we do both of the following:
– Decrease the number of statements in an inner loop
– Increase the number of statements in the outer loopp
• Code motion moves code outside of a loop
– For example, consider:p ,
while (i <= limit-2) …
– The result of code motion would be:
t li it 2t = limit – 2
while (i <= t) …
P K Singh 25M M M Engg. College, Gorakhpur

26. Loop Optimizations (2)
• Induction variables: variables that remain in "lock-step"
– For example, in block B3 of previous flow graph, j and t4 are
induction variablesinduction variables
– Induction-variable elimination can sometimes eliminate all but one of
a set of induction variables
• Reduction in strength replaces a more expensive operationReduction in strength replaces a more expensive operation
with a less expensive one
– For example, in block B3, t4 decreases by four with every iteration
– If initialized correctly, can replace multiplication with subtractiony
– Often application of reduction in strength leads to induction-variable
elimination
• Methods exist to recognize induction variables and apply
i t t f ti t ti llappropriate transformations automatically
P K Singh 26M M M Engg. College, Gorakhpur

27. Loop Optimization Examplep p p
P K Singh 27M M M Engg. College, Gorakhpur

28. Example
• Given the following code segment, obtain:
The 3AC statements for this computation– The 3AC statements for this computation
– The basic blocks and the flow graph
prod = 0; i = 1;prod 0; i 1;
do {
prod = prod + a[i] * b[i];prod = prod + a[i] b[i];
i = i + 1;
} while ( i <= 20 );} while ( i <= 20 );
P K Singh 28M M M Engg. College, Gorakhpur

29. Example …contd
• 3AC for the given code segment
(1) prod :=0
(2) i := 1
(3) t1 := 4 * i (9) prod := t6
(4) t2 := a [t1] (10) t7 := i + 1
(5) t3 := 4 * i (11) i := t7
(6) t4 := b [t3] (12) if i <= 20 goto (3)
(7) t5 := t2 * t4(7) t5 := t2 * t4
(8) t6 := prod + t5
P K Singh 29M M M Engg. College, Gorakhpur

30. Example …contd
2 Basic blocks
(1) prod :=0
(2) i := 1
B1
(3) t1 := 4 * i (9) prod := t6
(4) t2 := a [t1] (10) t7 := i + 1
(5) t3 := 4 * i (11) i := t7
(6) t4 := b [t3] (12) if i <= 20 goto (3)
(7) t5 := t2 * t4(7) t5 := t2 * t4
(8) t6 := prod + t5
B2
P K Singh 30M M M Engg. College, Gorakhpur
B2

31. Example …contd
Flow Graph
t1 := 4 * iB2
prod := 0
t1 := 4 i
t2 := a [t1]
t3 := 4 * i
t4 := b [t3]B1
B2
i := 1 t5 := t2 * t4
t6 := prod + t5
prod := t6
t7 := i + 1t7 : i 1
i := t7
if i <= 20 goto B2B1
B2
P K Singh 31M M M Engg. College, Gorakhpur

32. Implementing a Code Optimizer
• Organization consists of control-flow analysis, then data-
flow analysis, and then transformations
• The code generator is applied to the transformedThe code generator is applied to the transformed
intermediate code
• Details of code optimization are beyond the scope of this
coursecourse
P K Singh 32M M M Engg. College, Gorakhpur