Outline
Lecture Intermediate code
Intermediate Code & Local Optimizations
Local optimizations
Lecture 14
Next time: global optimizations
Prof. Aiken CS 143 Lecture 14
Prof. Aiken CS 143 Lecture 14
1
Code Generation Summary
Optimization
We have discussed
2
Optimization is our last compiler phase
Runtime organization
Simple stack machine code generation
Improvements to stack machine code generation
Our compiler maps AST to assembly language
And does not perform optimizations
Prof. Aiken CS 143 Lecture 14
Most complexity in modern compilers is in the
optimizer
Also by far the largest phase
First, we need to discuss intermediate
languages
3
Prof. Aiken CS 143 Lecture 14
4
Why Intermediate Languages?
Intermediate Languages
When should we perform optimizations?
Intermediate language = high-level assembly
On AST
Uses register names, but has an unlimited number
Uses control structures like assembly language
Uses opcodes but some are higher level
Pro: Machine independent
Con: Too high level
On assembly language
Pro: Exposes optimization opportunities
Con: Machine dependent
Con: Must reimplement optimizations when retargetting
E.g., push translates to several assembly instructions
Most opcodes correspond directly to assembly opcodes
On an intermediate language
Pro: Machine independent
Pro: Exposes optimization opportunities
Prof. Aiken CS 143 Lecture 14
5
Prof. Aiken CS 143 Lecture 14
6
1
Three-Address Intermediate Code
Generating Intermediate Code
Each instruction is of the form
x := y op z
x := op y
Similar to assembly code generation
But use any number of IL registers to hold
intermediate results
y and z are registers or constants
Common form of intermediate code
The expression x + y * z is translated
t1 := y * z
t2 := x + t1
Each subexpression has a name
Prof. Aiken CS 143 Lecture 14
7
Prof. Aiken CS 143 Lecture 14
8
Generating Intermediate Code (Cont.)
Intermediate Code Notes
igen(e, t) function generates code to compute
the value of e in register t
Example:
You should be able to use intermediate code
igen(e1 + e2, t) =
igen(e1, t1)
igen(e2, t2)
t := t1 + t2
At the level discussed in lecture
You are not expected to know how to generate
intermediate code
(t1 is a fresh register)
(t2 is a fresh register)
Because we wont discuss it
But really just a variation on code generation . . .
Unlimited number of registers
simple code generation
Prof. Aiken CS 143 Lecture 14
9
An Intermediate Language
10
Definition. Basic Blocks
PSP|e
ids are register names
S id := id op id
Constants can replace ids
| id := op id
Typical operators: +, -, *
| id := id
| push id
| id := pop
| if id relop id goto L
| L:
| jump L
Prof. Aiken CS 143 Lecture 14
Prof. Aiken CS 143 Lecture 14
11
A basic block is a maximal sequence of
instructions with:
no labels (except at the first instruction), and
no jumps (except in the last instruction)
Idea:
Cannot jump into a basic block (except at beginning)
Cannot jump out of a basic block (except at end)
A basic block is a single-entry, single-exit,
straight-line code segment
Prof. Aiken CS 143 Lecture 14
12
2
Basic Block Example
Definition. Control-Flow Graphs
A control-flow graph is a directed graph with
Consider the basic block
1. L:
2. t := 2 * x
3. w := t + x
4. if w > 0 goto L
Basic blocks as nodes
An edge from block A to block B if the execution
can pass from the last instruction in A to the first
instruction in B
E.g., the last instruction in A is jump LB
E.g., execution can fall-through from block A to block B
(3) executes only after (2)
We can change (3) to w := 3 * x
Can we eliminate (2) as well?
Prof. Aiken CS 143 Lecture 14
13
Example of Control-Flow Graphs
x := 1
i := 1
L:
x := x * x
i := i + 1
if i < 10 goto L
14
Optimization Overview
The body of a method (or
procedure) can be
represented as a controlflow graph
There is one initial node
All return nodes are
terminal
Prof. Aiken CS 143 Lecture 14
Prof. Aiken CS 143 Lecture 14
Optimization seeks to improve a programs
resource utilization
Execution time (most often)
Code size
Network messages sent, etc.
Optimization should not alter what the
program computes
The answer must still be the same
15
Prof. Aiken CS 143 Lecture 14
16
A Classification of Optimizations
Cost of Optimizations
In practice, a conscious decision is made not
to implement the fanciest optimization known
For languages like C and Cool there are three
granularities of optimizations
1. Local optimizations
Why?
Apply to a basic block in isolation
2. Global optimizations
Apply to a control-flow graph (method body) in isolation
3. Inter-procedural optimizations
Apply across method boundaries
Most compilers do (1), many do (2), few do (3)
Prof. Aiken CS 143 Lecture 14
17
Some optimizations are hard to implement
Some optimizations are costly in compilation time
Some optimizations have low benefit
Many fancy optimizations are all three!
Goal: Maximum benefit for minimum cost
Prof. Aiken CS 143 Lecture 14
18
3
Local Optimizations
Algebraic Simplification
The simplest form of optimizations
Some statements can be deleted
No need to analyze the whole procedure body
Just the basic block in question
Some statements can be simplified
x := x * 0
x := 0
y := y ** 2
y := y * y
x := x * 8
x := x << 3
x := x * 15
t := x << 4; x := t - x
(on some machines << is faster than *; but not on all!)
Example: algebraic simplification
Prof. Aiken CS 143 Lecture 14
x := x + 0
x := x * 1
19
Prof. Aiken CS 143 Lecture 14
Constant Folding
Flow of Control Optimizations
Operations on constants can be computed at
compile time
20
Eliminate unreachable basic blocks:
If there is a statement x := y op And z
y and z are constants
Then y op z can be computed at compile time
E.g., basic blocks that are not the target of any jump or
fall through from a conditional
Why would such basic blocks occur?
Example: x := 2 + 2 x := 4
Example: if 2 < 0 jump L can be deleted
When might constant folding be dangerous?
Prof. Aiken CS 143 Lecture 14
Code that is unreachable from the initial block
Removing unreachable code makes the
program smaller
And sometimes also faster
Due to memory cache effects (increased spatial locality)
21
Prof. Aiken CS 143 Lecture 14
Single Assignment Form
Common Subexpression Elimination
Some optimizations are simplified if each register
occurs only once on the left-hand side of an
assignment
22
If
Rewrite intermediate code in single assignment form
x := z + y
b := z + y
a := x
a := b
x := 2 * x
x := 2 * b
(b is a fresh register)
More complicated in general, due to loops
Prof. Aiken CS 143 Lecture 14
Basic block is in single assignment form
A definition x := is the first use of x in a block
Then
When two assignments have the same rhs, they
compute the same value
Example:
x := y + z
x := y + z
w := y + z
w := x
(the values of x, y, and z do not change in the code)
23
Prof. Aiken CS 143 Lecture 14
24
4
Copy Propagation
Copy Propagation and Constant Folding
If w := x appears in a block, replace subsequent uses
of w with uses of x
Example:
Assumes single assignment form
Example:
b := z + y
a := b
x := 2 * a
b := z + y
a := b
x := 2 * b
a := 5
x := 2 * a
y := x + 6
t := x * y
a := 5
x := 10
y := 16
t := x << 4
Only useful for enabling other optimizations
Constant folding
Dead code elimination
Prof. Aiken CS 143 Lecture 14
25
Prof. Aiken CS 143 Lecture 14
26
Copy Propagation and Dead Code Elimination
Applying Local Optimizations
If
Each local optimization does little by itself
w := rhs appears in a basic block
w does not appear anywhere else in the program
Typically optimizations interact
Then
the statement w := rhs is dead and can be eliminated
Dead = does not contribute to the programs result
Example: (a is not used anywhere else)
x := z + y
a := x
x := 2 * a
b := z + y
a := b
x := 2 * b
Prof. Aiken CS 143 Lecture 14
b := z + y
x := 2 * b
Performing one optimization enables another
Optimizing compilers repeat optimizations
until no improvement is possible
The optimizer can also be stopped at any point to
limit compilation time
27
Prof. Aiken CS 143 Lecture 14
An Example
An Example
Initial code:
28
Algebraic optimization:
a := x ** 2
b := 3
c := x
d := c * c
e := b * 2
f := a + d
g := e * f
Prof. Aiken CS 143 Lecture 14
a := x ** 2
b := 3
c := x
d := c * c
e := b * 2
f := a + d
g := e * f
29
Prof. Aiken CS 143 Lecture 14
30
5
An Example
An Example
Algebraic optimization:
Copy propagation:
a := x * x
b := 3
c := x
d := c * c
e := b << 1
f := a + d
g := e * f
Prof. Aiken CS 143 Lecture 14
a := x * x
b := 3
c := x
d := c * c
e := b << 1
f := a + d
g := e * f
31
Prof. Aiken CS 143 Lecture 14
An Example
An Example
Copy propagation:
32
Constant folding:
a := x * x
b := 3
c := x
d := x * x
e := 3 << 1
f := a + d
g := e * f
Prof. Aiken CS 143 Lecture 14
a := x * x
b := 3
c := x
d := x * x
e := 3 << 1
f := a + d
g := e * f
33
Prof. Aiken CS 143 Lecture 14
An Example
An Example
Constant folding:
34
Common subexpression elimination:
a := x * x
b := 3
c := x
d := x * x
e := 6
f := a + d
g := e * f
Prof. Aiken CS 143 Lecture 14
a := x * x
b := 3
c := x
d := x * x
e := 6
f := a + d
g := e * f
35
Prof. Aiken CS 143 Lecture 14
36
6
An Example
An Example
Common subexpression elimination:
Copy propagation:
a := x * x
b := 3
c := x
d := a
e := 6
f := a + d
g := e * f
Prof. Aiken CS 143 Lecture 14
a := x * x
b := 3
c := x
d := a
e := 6
f := a + d
g := e * f
37
Prof. Aiken CS 143 Lecture 14
An Example
An Example
Copy propagation:
38
Dead code elimination:
a := x * x
b := 3
c := x
d := a
e := 6
f := a + a
g := 6 * f
Prof. Aiken CS 143 Lecture 14
a := x * x
b := 3
c := x
d := a
e := 6
f := a + a
g := 6 * f
39
Prof. Aiken CS 143 Lecture 14
An Example
Peephole Optimizations on Assembly Code
Dead code elimination:
40
These optimizations work on intermediate
code
a := x * x
Target independent
But they can be applied on assembly language also
Peephole optimization is effective for
improving assembly code
f := a + a
g := 6 * f
The peephole is a short sequence of (usually
contiguous) instructions
The optimizer replaces the sequence with another
equivalent one (but faster)
This is the final form
Prof. Aiken CS 143 Lecture 14
41
Prof. Aiken CS 143 Lecture 14
42
7
Peephole Optimizations (Cont.)
Peephole Optimizations (Cont.)
Write peephole optimizations as replacement rules
Many (but not all) of the basic block
optimizations can be cast as peephole
optimizations
i1, , in j1, , jm
where the rhs is the improved version of the lhs
Example: addiu $a $b 0 move $a $b
Example: move $a $a
These two together eliminate addiu $a $a 0
Example:
move $a $b, move $b $a move $a $b
Works if move $b $a is not the target of a jump
Another example
As for local optimizations, peephole
optimizations must be applied repeatedly for
maximum effect
addiu $a $a i, addiu $a $a j addiu $a $a i+j
Prof. Aiken CS 143 Lecture 14
43
Prof. Aiken CS 143 Lecture 14
44
Local Optimizations: Notes
Intermediate code is helpful for many optimizations
Many simple optimizations can still be applied on
assembly language
Program optimization is grossly misnamed
Code produced by optimizers is not optimal in any
reasonable sense
Program improvement is a more appropriate term
Next time: global optimizations
Prof. Aiken CS 143 Lecture 14
45
8