# • Code optimization: ```• Code optimization:
– A transformation to a program to make it run
faster and/or take up less space
– Optimization should be safe, preserve the
meaning of a program.
– Code optimization is an important component
in a compiler
– Example: peephole optimization.
• Peephole: a small moving window in the instruction
sequence
• Technique: examine a short sequence of target
instructions (peephole) and try to replace it with a
faster or shorter sequence
• Peephole optimization:
•
•
•
•
Redundant instruction elimination
Flow of control optimization
Algebraic simplifications
Instruction selection
• Examples:
MOV R0, a
MOV a, R0
– Unreachable code
If debug = 1 goto L1
Goto L2
L1: print debugging info
L2:
– Examples:
• Flow of control optimization:
goto L1
goto L2
…
…
L1: goto L2 L1: goto L2
if a &lt; b goto L1
if a&lt;b goto L2
…
…
L1: goto L2
L1: goto L2
goto L1
…
L1: if a &lt; b goto L2
if a &lt; b goto L2
goto L3
…
L1:
L3:
• Algebraic simplification:
x : = x+0
x := x*1
== nop
• Reduction in strength
X^2  x * x
X * 4  x &lt;&lt; 2
• Instruction selection
Sometimes some hardware instructions can
implement certain operation efficiently.
• Code optimization can either be high level
or low level:
– High level code optimizations:
• Loop unrolling, loop fusion, procedure inlining
– Low level code optimizations:
• Instruction selection, register allocation
– Some optimization can be done in both levels:
• Common subexpression elimination, strength
reduction, etc.
– Flow graph is a common intermediate
representation for code optimization.
• Basic block: a sequence of consecutive statements with
exactly 1 entry and 1 exit.
• Flow graph: a directed graph where the nodes are basic
blocks and block B1 block B2 if and only if B2 can be
executed immediately after B1:
• Algorithm to construct flow graph:
– Finding leaders of the basic blocks:
• The first statement is a leader
• Any statement that is the target of a conditional or
• Any statement that immediately follows a goto or conditional
– For each leader, its basic block consists all statements
– B1B2 if and only if B2 can be executed immediately
after B1.
• Example:
100:
101:
102:
103:
104:
105:
106:
107:
sum = 0
j=0
goto 107
t1 = j &lt;&lt; 2
t3 = t2[t1]
sum = sum + t3
if j &lt; n goto 103
• Optimizations within a basic block is called local optimization.
• Optimizations across basic blocks is called global optimization.
• Some common optimizations:
–
–
–
–
–
–
–
–
–
–
–
–
–
–
Instruction selection
Register allocation
Common subexpression elimination
Code motion
Strength reduction
Induction variable elimination
Branch chaining
Jump elimination
Instruction scheduling
Procedure inlining
Loop unrolling
Loop fusing
Code hoisting
• Instruction selection:
– Using a more efficient instruction to replace a sequence of
instructions (space and speed).
– Example:
Mov R2, (R3)
Mov (R3), R2
• Register allocation: allocate variables to registers (speed)
• Example:
M[R13+sum] = 0
M[R13+j] = 0
GOTO L18
L19:
R0 = M[R13+j] * 4
M[R13+sum] = M[R13+sum]
+M[R0+_a]
M[R13+j] = M[R13+j]+1
L18:
NZ = M[R13+j] - M[_n]
if NZ &lt; 0 goto L19
R2 = 0
R1 = 0
GOTO L18
L19:
R0 = R1 * 4
R2 = R2+M[R0+_a]
R1 = R1+1
L18:
NZ = R1 - M[_n]
if NZ &lt; 0 goto L19
• Code motion: move a loop invariant computation before
the loop
• Example:
R2 = 0
R1 = 0
GOTO L18
R2 = 0
R1 = 0
R4 = M[_n]
GOTO L18
L19:
R0 = R1 * 4
R2 = R2+M[R0+_a]
R1 = R1+1
L19:
R4 = M[_n]
NZ = R1 – R4
if NZ &lt; 0 goto L19
L18:
R0 = R1 * 4
R2 = R2+M[R0+_a]
R1 = R1+1
L18:
NZ = R1 – R4
if NZ &lt; 0 goto L19
• Strength reduction: replace expensive operation by
equivalent cheaper operations
• Example:
R2 = 0
R1 = 0
R4 = M[_n]
GOTO L18
R2 = 0
R1 = 0
R4 = M[_n]
R3 = _a
GOTO L18
L19:
R0 = R1 * 4
R2 = R2+M[R0+_a]
R1 = R1+1
L19:
NZ = R1 – R4
if NZ &lt; 0 goto L19
L18:
R2 = R2+M[R3]
R3 = R3 + 4
R1 = R1+1
L18:
NZ = R1 – R4
if NZ &lt; 0 goto L19
• Induction variable elimination: can induce value from
another variable.
• Example:
R2 = 0
R1 = 0
R4 = M[_n]
R3 = _a
GOTO L18
R2 = 0
R4 = M[_n] &lt;&lt; 2
R3 = _a
GOTO L18
L19:
L19:
R2 = R2+M[R3]
R3 = R3 + 4
R1 = R1+1
L18:
NZ = R1 – R4
if NZ &lt; 0 goto L19
R2 = R2+M[R3]
R3 = R3 + 4
L18:
NZ = R3 – R4
if NZ &lt; 0 goto L19
• Common subexpression elimination:an expression was
previously calculated and the variables in the expression
have not changed. Can avoid recomputing the expression.
• Example:
R1 = M[R13+I] &lt;&lt; 2
R1 = M[R1+_b]
R2 = M[R13+I] &lt;&lt; 2;
R2 = M[R2+_b]
R1=M[R13+I] &lt;&lt; 2
R1 = M[R1+_b]
R2 = R1
```