1. Topic G: Static Single-Assignment Form José Nelson Amaral
CMPUT680
Topic G: Static Single-Assignment Form
José Nelson Amaral
CMPUT Compiler Design and Optimization

2. CMPUT 680 - Compiler Design and Optimization
Reading Material
Chapter 19 of the “Tiger book” (with a grain of salt!!).
Bilardi, G., Pingali, K., “The Static Single Assignment Form and its
Computation,” unpublished? (citeseer).
Cytron, R., Ferrante, J., Rosen, B. K., Wegman, M. N., Zadeck, F. K.,
“An Efficient Method of Computing Static Single Assignment Form,”
ACM Symposium on Principles of Programming Languages (PoPL),
pp , Austin, TX, Jan., 1989.
Cytron, R., Ferrante, J., Rosen, B. K., Wegman, M. N., “Efficiently
Computing Static Single Assignment Form and the Control Dependence
Graph,” ACM Transactions on Programming Languages and Systems
(TOPLAS), Vol. 13, No. 4, October, 1991, pp
Sreedhar, V. C., Gao, G. R., “A Linear Time Algorithm for Placing -Nodes,”
pp , 1995.
CMPUT Compiler Design and Optimization

3. Static Single-Assignment Form
Each variable has only one definition in the program text.
This single static definition can be in a loop and
may be executed many times. Thus even in a
program expressed in SSA, a variable can be
dynamically defined many times.
CMPUT Compiler Design and Optimization

4. CMPUT 680 - Compiler Design and Optimization
Advantages of SSA
Simpler dataflow analysis No need to use use-def/def-use chains, which requires N∗M space for N uses and M definitions SSA form relates in a useful way with dominance structures. SSA simplifies algorithms that construct interference graphs.
CMPUT Compiler Design and Optimization

5. CMPUT 680 - Compiler Design and Optimization
Main Goal of SSA
To create a sparse representation of the flow of values in a computer program.
Prevents propagation of a value through regions of the program that do not use it.
Factorize value propagation
If p definitions must be propagated to q uses, a dense flow representation requires p×q edges. An SSA representation requires only p+q edges.
CMPUT Compiler Design and Optimization

6. SSA Form in Control-Flow Path Merges
Is this code in SSA form? B1
b ← M[x]
a ← 0
No, two definitions of a appear in
the code (in B1 and B3) B2
if b<4
How can we transform this code
into a code in SSA form? B3
a ← b
We can create two versions of
a, one for B1 and another for B3. B4
c ← a + b
CMPUT Compiler Design and Optimization

7. SSA Form in Control-Flow Path Merges
But which version should we
use in B4 now? B1
b ← M[x]
a1 ← 0
We define a fictional function that
“knows” which control path was
taken to reach the basic block B4: B2
if b<4 B3
a2 ← b B4
c ← a? + b
CMPUT Compiler Design and Optimization

8. SSA Form in Control-Flow Path Merges
But which version should we
use in B4 now? B1
b ← M[x]
a1 ← 0
We define a fictional function that
“knows” which control path was
taken to reach the basic block B4: B2
if b<4 B3
a2 ← b B4
a3 ← ψ(a2,a1)
c ← a3 + b
CMPUT Compiler Design and Optimization

9. SSA Form in Control-Flow Path MergesB1
b ← M[x]
a1 ← 0
In some compilers the actual
representation of this Φ function is:
Φ(a1,a2,B2,B3) B2
if b<4 B3
a2 ← b B4
a3 ← ϕ(a2,a1)
c ← a3 + b
CMPUT Compiler Design and Optimization

10. CMPUT 680 - Compiler Design and Optimization
A Loop Example
a ← 0
a0 ← undef
b0 ← undef
c0 ← undef
a1 ← 0
b1 ← a?+1
c1 ← c?+b1
a2 ← b1*2
if a2 < N
return
b ← a+1
c ← c+b
a ← b*2
if a < N
return
CMPUT Compiler Design and Optimization

11. CMPUT 680 - Compiler Design and Optimization
A Loop Example
a ← 0
a0 ← undef
b0 ← undef
c0 ← undef
a1 ← 0
a3 ← Φ(a1,a2)
b1 ← a3+1
c1 ← c?+b1
a2 ← b1*2
if a2 < N
return
b ← a+1
c ← c+b
a ← b*2
if a < N
return
CMPUT Compiler Design and Optimization

12. CMPUT 680 - Compiler Design and Optimization
A Loop Example
a ← 0
a0 ← undef
b0 ← undef
c0 ← undef
a1 ← 0
b ← a+1
c ← c+b
a ← b*2
if a < N
a3 ← Φ(a1,a2)
c2 ← Φ(c0,c1)
b1 ← a3+1
c1 ← c2+b1
a2 ← b1*2
if a2 < N
return
return
CMPUT Compiler Design and Optimization

13. A Loop Example a ← 0 a0 ← undef b0 ← undef c0 ← undef a1 ← 0 b ← a+1
c ← c+b
a ← b*2
if a < N
a3 ← ϕ(a1,a2)
c2 ← ϕ(c0,c1)
b2 ← ϕ(b0,b1)
b1 ← a3+1
c1 ← c2+b1
a2 ← b1*2
if a2 < N
return
Φ(b0,b1) is not necessary because b2 is
never used. But the phase that generates
Φ functions does not know it.
Unnecessary Φ functions are later
eliminated by dead code elimination.
return
CMPUT Compiler Design and Optimization

14. The Φ Function How can we implement a Φ function that “knows”
which control path was taken?
Answer 1: We don’t!! The Φ function is used only
to connect use to definitions during
optimization, but is never implemented.
Answer 2: If we must execute the Φ function, we can
implement it by inserting MOVE instructions
in all control paths.
CMPUT Compiler Design and Optimization

15. Criteria for Inserting Φ Functions
We could insert one Φ function for each variable
at every join point (a point in the CFG with more
than one predecessor). But that would be wasteful.
What criteria should we use to insert a Φ function
for a variable a at node z of the CFG?
Intuitively, we should add a function Φ if
there are two definitions of a that can reach
the point z through distinct paths.
CMPUT Compiler Design and Optimization

16. Path Convergence Criterion (Cytron-Ferrante/89)
Insert a Φ function for a variable a at a node z if
all the following conditions are true:
1. There is a block x that defines a
2. There is a block y ≠ x that defines a
3. There are paths x→z and y→z
4. Paths x→z and y→z don’t have any nodes in
common other than z
5. The node z does not appear in both x→z
and y→z prior to the end, but it may appear
in one or the other.
Note: The start node contains an
implicit definition of every variable.
CMPUT Compiler Design and Optimization

17. CMPUT 680 - Compiler Design and Optimization
Examples
a ← ⋅⋅⋅ x
a ← ⋅⋅⋅ y
a ← ⋅⋅⋅ x y z z
a ← ⋅⋅⋅ x y z
a ← ⋅⋅⋅ x y z
CMPUT Compiler Design and Optimization

18. Φ-Candidates are Join Nodes
Notice that according to the path convergence
criterion, the node z that will receive the Φ function
must be a join node.
z is the first node that joins the paths Pxz and Pyz.
CMPUT Compiler Design and Optimization

19. Iterated Path-Convergence Criterion
The Φ function itself is a definition of a.
Therefore the path-convergence criterion
is a set of equations that must be satisfied.
while there are nodes x, y, z satisfying conditions 1-5
and z does not contain a Φ function for a
do insert a← Φ(a0, a1, …, an) at node z
This algorithm is extremely costly, because it
requires the examination of every triple of
nodes x, y, z and every path from
x to z and from y to z.
Can we do better?
CMPUT Compiler Design and Optimization

20. The SSA Conversion Problem
For each variable x defined in a CFG G=(V,E),
given the set of nodes S ⊆ V such that each S
contains a definition for x, find the minimal set J(S) of
nodes that requires a Φ(xi,xj) function.
By definition, the START node defines all
the variables, therefore ∀ S ⊆ V, START ∈ S.
If we need to compute Φ nodes for several
variables, it may be efficient to precompute
data structures based on the CFG.
CMPUT Compiler Design and Optimization

21. Processing Time for SSA Conversion
The performance of an SSA conversion algorithm
should be measured by the processing time Tp,
the preprocessing space Sp, and the query time Tq.
(Shapiro and Saint 1970): outline an algorithm
(Reif and Tarjan 1981): extend the Lengauer-Tarjan
dominator algorithm to compute Φ-nodes.
(Cytron et al. 1991): show that SSA conversion can
use the idea of dominance frontiers, resulting on an
O(|V|2) algorithm.
(Sreedhar and Gao, 1995): An O(|E|) algorithm, but
in private commun. with Pingali in 1996 admits that it is in
practice 5 times slower than Cytron et al.
CMPUT Compiler Design and Optimization

22. Processing Time for SSA Conversion
Bilardi, Pingali, 1999: present a generalized framework and a
parameterized Augmented Dominator Tree (ADT) algorithm that allows
for a space-time tradeoff. They show that Cytron et al. and Gao-Shreedhar
are special cases of the ADT algorithm.
Bilardi and Pingali describe three strategies to compute
Φ-placement:
Two-Phase Algorithms
Lock-Step Algorithms
Lazy Algorithms
CMPUT Compiler Design and Optimization

23. CMPUT 680 - Compiler Design and Optimization
Two-Phase Algorithms
First build the entire Dominance Frontier Graph,
then find the nodes reachable from S
DF Computation
Reachability
DF Graph
J(S) S
CFG
Simple
DF Graph may be quite large
CMPUT Compiler Design and Optimization

24. CMPUT 680 - Compiler Design and Optimization
Lock-Step Algorithms
Performs the reachability computation incrementally
while the DF relation is computed.
CFG
Avoid storing the DF Graph.
Perform computations at all
nodes of the graph, even though
most are irrelevant
Inneficient when computing the
Φ-nodes for many variables.
DF Computation
Reachability S
J(S)
CMPUT Compiler Design and Optimization

25. CMPUT 680 - Compiler Design and Optimization
Lazy Algorithms
Lazily compute only the portion fo the DF Graph that
is needed. Carefully select a portion of the DF Graph
to compute eagerly (before it is needed).
CFG
DF Computation
A Two-Phase Algorithm
is an extreme case of
a lazy algorithm.
DF Graph
SubGraph S
Reachability
J(S)
CMPUT Compiler Design and Optimization

26. Computing a Dominator Tree
(n: # of nodes; m: # of edges)
(Lowry and Medlock, 1969): Introduce the problem and give
an O(n4) algorithm.
(Lengauer and Tarjan, 1979): Give a complicated
O(mα(m.n)) algorithm [α(m.n) is the inverse Ackermann’s function].
(Harel, 1985): Give a linear time algorithm.
(Alstrup, Harel and Thorup, 1997): Give a simpler version of
Harel’s algorithm.
CMPUT Compiler Design and Optimization

27. Dominance Property of the SSA Form
In SSA form definitions dominate uses, i.e.:
1. If x is used in a Φ function in block n, then the
definition of x dominates every predecessor of n.
2. If x is used in a non-Φ statement in block n, then
the definition of x dominates n.
CMPUT Compiler Design and Optimization

28. The Dominance Frontier
A node x dominates a node w if every path from the start
node to w must go through x.
A node x strictly dominates a node w if x dominates
w and x ≠ w.
The dominance frontier of a node x is the set of
all nodes w such that x dominates a predecessor
of w, but x does not strictly dominates w.
CMPUT Compiler Design and Optimization

29. Example What is the dominance frontier of node 5? 1 2 3 4 8 6 7 5 1210 11 9 13
What is the dominance frontier of node 5?
CMPUT Compiler Design and Optimization

30. Example First we must find all nodes that node 5 dominates. 1 2 3 4 86 7 5 12 10 11 9 13
First we must find all nodes that
node 5 dominates.
CMPUT Compiler Design and Optimization

31. Example 1 2 3 4 8 6 7 5 12 10 11 9 13
A node w is in the dominance frontier of node 5
if 5 dominates a predecessor of w, but 5 does not strictly
dominates w itself. What is the dominance frontier of 5?
CMPUT Compiler Design and Optimization

32. Example 1 2 5 9 3 6 7 10 11 8 12 4 13
A node w is in the dominance frontier of node 5
if 5 dominates a predecessor of w, but 5 does not strictly
dominates w itself. What is the dominance frontier of 5?
CMPUT Compiler Design and Optimization

33. Example 1 2 5 9 3 6 7 10 11 8 12 4
DF(5) = {4, 5, 12, 13} 13
A node w is in the dominance frontier of node 5
if 5 dominates a predecessor of w, but 5 does not strictly
dominates w itself. What is the dominance frontier of 5?
CMPUT Compiler Design and Optimization

34. Dominance Frontier Criterion
If a node x contains a definition of variable a,
then any node z in the dominance frontier of
x needs a Φ function for a.
Can you think of an intuitive explanation
for why a node in the dominance frontier
of another node must be a join node?
CMPUT Compiler Design and Optimization

35. Example 1 If a node (12) is in the dominance frontier of
another node (5),
than there must be
at least two paths
converging to (12). 2 5 9 3 6 7 10 11 8 12 4
These paths must be
non-intersecting, and
one of them (5,7,12)
must contain a node strictly
dominated by (5). 13
CMPUT Compiler Design and Optimization

36. Dominator Tree To compute the dominance frontiers, we first compute
the dominator tree of the CFG.
There is an edge from node x to node y in the
dominator tree if node x immediately dominates node y.
I.e., x dominates y≠x, and x does not
dominate any other dominator of y.
Dominator trees can be computed
using the Lengauer-Tarjan algorithm(1979).
See sec of Appel.
CMPUT Compiler Design and Optimization

37. Example: Dominator Tree1 2 5 9
Dominator Tree 3 6 7 10 11 1 8 12 4 2 4 5 12 9 13 13 3 10 11
Control Flow Graph 6 7 8
CMPUT Compiler Design and Optimization

38. Local Dominance Frontier
Cytron-Ferrante define the local dominance frontier
of a node n as:
DFlocal[n] = successors of n in the CFG that are not
strictly dominated by n
CMPUT Compiler Design and Optimization

39. Example: Local Dominance Frontier
In the example, what are
the local dominance
frontiers of nodes 5, 6 and 7? 1 2 5 9
DFlocal[5] = 
DFlocal[6] = {4,8}
DFlocal[7] = {8,12} 3 6 7 10 11 8 12 4 13
Control Flow Graph
CMPUT Compiler Design and Optimization

40. Dominance Frontier Inherited From Its Children
The dominance frontier of a node n is formed by its
local dominance frontier plus nodes that are passed up
by the children of n in the dominator tree.
The contribution of a node c to its parent’s dominance
frontier is defined as [Cytron-Ferrante, 1991]:
DFup[c] = nodes in the dominance frontier
of c that are not strictly dominated by
the immediate dominator of c
CMPUT Compiler Design and Optimization

41. Example: Local Dominance Frontier1
In the example, what are
the contributions of nodes
6, 7, and 8 to its parent
dominance frontier? 2 5 9 3 6 7 10 11 8 12
First we compute
the DF and the immediate
dominator of each node:
DF[6] = {4,8}, idom(6)= 5
DF[7] = {8,12}, idom(7)= 5
DF[8] = {5,13}, idom(8)= 5 4 13
Control Flow Graph
CMPUT Compiler Design and Optimization

42. Example: Local Dominance Frontier
DFup[c] = nodes in the dominance frontier
of c that are not strictly dominated by
the immediate dominator of c
First we compute
the DF and the immediate
dominator of each node:
DF[6] = {4,8}, idom(6)= 5
DF[7] = {8,12}, idom(7)= 5
DF[8] = {5,13}, idom(8)= 5 1 2 5 9 3 6 7 10 11 8 12 4
Now we check for the
DFup condition:
DFup[6] = {4}
DFup[7] = {12}
DFup[8] = {5,13} 13
Control Flow Graph
CMPUT Compiler Design and Optimization

43. A note on implementation
We want to represent these sets efficiently:
DF[6] = {4,8}
DF[7] = {8,12}
DF[8] = {5,13}
If we use bitvectors to represent these sets:
DF[6] =
DF[7] =
DF[8] =
CMPUT Compiler Design and Optimization

44. Strictly Dominated Sets
We can also represent the strictly dominated sets as vectors:
SD[1] =
SD[2] =
SD[5] =
SD[9] =
Dominator Tree 1 2 4 5 12 9 13 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

45. A note on implementation
If we use bitvectors to represent these sets:
DF[6] =
DF[7] =
DF[8] =
SD[5] =
DFup[c] = DF[6] ^ ~SD[5]
DFup[c] = nodes in the dominance frontier
of c that are not strictly dominated by
the immediate dominator of c
CMPUT Compiler Design and Optimization

46. Dominance Frontier Inherited From Its Children
The dominance frontier of a node n is formed by its
local dominance frontier plus nodes that are passed up
by the children of n in the dominator tree.
Thus the dominance frontier of a node n is defined
as [Cytron-Ferrante, 1991]:
CMPUT Compiler Design and Optimization

47. Example: Local Dominance Frontier1
What is DF[5]?
Remember that:
DFlocal[5] = 
DFup[6] = {4}
DFup[7] = {12}
DFup[8] = {5,13}
DTchildren[5] = {6,7,8} 2 5 9 3 6 7 10 11 8 12 4 13
Control Flow Graph
CMPUT Compiler Design and Optimization

48. Example: Local Dominance Frontier1
What is DF[5]?
Remember that:
DFlocal[5] = ∅
DFup[6] = {4}
DFup[7] = {12}
DFup[8] = {5,13}
DTchildren[5] = {6,7,8} 2 5 9 3 6 7 10 11 8 12 4 13
Control Flow Graph
Thus, DF[5] = {4, 5, 12, 13}
CMPUT Compiler Design and Optimization

49. CMPUT 680 - Compiler Design and Optimization
Join Sets
In order to insert Φ-nodes for a variable x that is
defined in a set of nodes S={n1, n2, …, nk} we need
to compute the iterated set of join nodes of S.
Given a set of nodes S of a control flow graph G,
the set of join nodes of S, J(S), is defined as follows:
J(S) ={z ∈ G| ∃ two paths Pxz and Pyz in G that
have z as its first common node,
x ∈ S and y ∈ S}
CMPUT Compiler Design and Optimization

50. CMPUT 680 - Compiler Design and Optimization
Iterated Join Sets
Because a Φ-node is itself a definition of a variable,
once we insert Φ-nodes in the join set of S, we need
to find out the join set of S ∪ J(S).
Thus, Cytron-Ferrante define the iterated join set
of a set of nodes S, J+(S), as the limit of the sequence:
CMPUT Compiler Design and Optimization

51. Iterated Dominance Frontier
We can extend the concept of dominance frontier
to define the dominance frontier of a set of nodes as:
Now we can define the iterated dominance frontier,
DF+(S), of a set of nodes S as the limit of the sequence:
Exercise:
Find an example in which
the IDF of a set S is different
from the DF of the set!
CMPUT Compiler Design and Optimization

52. Location of Φ-Nodes
Given a variable x that is defined in a set of nodes
S={n1, n2, …, nk} the set of nodes that must receive
Φ-nodes for x is J+(S).
An important result proved by Cytron-Ferrante is that:
Thus we are mostly interested in computing
the iterated dominance frontier of a set of nodes.
CMPUT Compiler Design and Optimization

53. Algorithms to Compute Dominance Frontier
The algorithm to insert Φ-nodes, due to Cytron and
Ferrante (1991), computes the dominance frontier
of each node in the set S before computing the
iterated dominance frontier of the set.
In the worst case, the combination of the dominance
frontier of the sets can be quadratic in the number
of nodes in the CFG. Thus, Cytron-Ferrante’s
algorithm has a complexity O(N2).
In 1994, Shreedar and Gao proposed a simple,
linear algorithm for the insertion of Φ-nodes.
CMPUT Compiler Design and Optimization

54. Sreedhar and Gao’s DJ Graph1 2 5 9
Dominator Tree 3 6 7 10 11 1 8 12 4 2 4 5 12 9 13 13 3 10 11
Control Flow Graph 6 7 8
CMPUT Compiler Design and Optimization

55. Sreedhar and Gao’s DJ Graph1
D nodes 2 5 9
Dominator Tree 3 6 7 10 11 1 8 12 4 2 4 5 12 9 13 13 3 10 11
Control Flow Graph 6 7 8
CMPUT Compiler Design and Optimization

56. Sreedhar and Gao’s DJ Graph
D nodes 1
J nodes 2 5 9
Dominator Tree 3 6 7 10 11 1 8 12 4 2 4 5 12 9 13 13 3 10 11
Control Flow Graph 6 7 8
CMPUT Compiler Design and Optimization

57. Shreedar-Gao’s Dominance Frontier Algorithm
DominanceFrontier(x)
0: DF[x] = ∅
1: foreach y ∈ SubTree(x) do
2: if((y → z == J-edge) and
3: (z.level ≤ x.level))
4: then DF[x] = DF[x] ∪ z 1 2 4 5 12 9 13
What is the DF[5]? 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

58. Shreedar-Gao’s Dominance Frontier Algorithm
DominanceFrontier(x)
0: DF[x] = ∅
1: foreach y ∈ SubTree(x) do
2: if((y → z == J-edge) and
3: (z.level ≤ x.level))
4: then DF[x] = DF[x] ∪ z
Initialization: DF[5] = ∅ 1
SubTree(5) = {5, 6, 7, 8} 2 4 5 12 9 13 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

59. Shreedar-Gao’s Dominance Frontier Algorithm
DominanceFrontier(x)
0: DF[x] = ∅
1: foreach y ∈ SubTree(x) do
2: if((y → z == J-edge) and
3: (z.level ≤ x.level))
4: then DF[x] = DF[x] ∪ z
Initialization: DF[5] = ∅ 1
SubTree(5) = {5, 6, 7, 8}
There are three edges
originating in 5:
{5→6, 5→7, 5→8}
but they are all D-edges 2 4 5 12 9 13 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

60. Shreedar-Gao’s Dominance Frontier Algorithm
DominanceFrontier(x)
0: DF[x] = ∅
1: foreach y ∈ SubTree(x) do
2: if((y → z == J-edge) and
3: (z.level ≤ x.level))
4: then DF[x] = DF[x] ∪ z
Initialization: DF[5] = ∅
After visiting 6: DF = {4} 1
SubTree(5) = {5, 6, 7, 8}
There are two edges
originating in 6:
{6→4, 6→8}
but 8.level > 5.level 2 4 5 12 9 13 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

61. Shreedar-Gao’s Dominance Frontier Algorithm
DominanceFrontier(x)
0: DF[x] = ∅
1: foreach y ∈ SubTree(x) do
2: if((y → z == J-edge) and
3: (z.level ≤ x.level))
4: then DF[x] = DF[x] ∪ z
Initialization: DF[5] = ∅
After visiting 6: DF = {4}
After visiting 7: DF = {4,12} 1
SubTree(5) = {5, 6, 7, 8}
There are two edges
originating in 7:
{7→8, 7→12}
again 8.level > 5.level 2 4 5 12 9 13 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

62. Shreedar-Gao’s Dominance Frontier Algorithm
DominanceFrontier(x)
0: DF[x] = ∅
1: foreach y ∈ SubTree(x) do
2: if((y → z == J-edge) and
3: (z.level ≤ x.level))
4: then DF[x] = DF[x] ∪ z
Initialization: DF[5] = ∅
After visiting 6: DF = {4}
After visiting 7: DF = {4,12}
After visiting 8: DF = {4, 12, 5, 13} 1
SubTree(5) = {5, 6, 7, 8}
There are two edges
originating in 8:
{8→5, 8→13}
both satisfy cond. in steps 2-3 2 4 5 12 9 13 3 10 11 6 7 8
CMPUT Compiler Design and Optimization

63. Shreedhar-Gao’s Φ-Node Insertion Algorithm
Using the D-J graph, Shreedhar and Gao propose
a linear time algorithm to compute the iterated
dominance frontier of a set of nodes.
An important intuition in Shreedhar-Gao’s algorithm is:
If two nodes x and y are in S, and y is an
ancestor of x in the dominator tree, then if we
compute DF[x] first, we do not need to recompute
DF[x] when computing DF[y].
CMPUT Compiler Design and Optimization

64. Shreedhar-Gao’s Φ-Node Insertion Algorithm
Shreedhar-Gao’s algorithm also use a work list
of nodes hashed by their level in the dominator
tree and a visited flag to avoid visiting the
same node more than once.
The basic operation of the algorithm is similar to
their dominance-frontier algorithm, but it requires
a careful implementation to deliver the linear-time
complexity.
CMPUT Compiler Design and Optimization

65. Dead-Code Elimination in SSA Form
Because there is only one definition for each
variable, if the list of uses of the variable
is empty, the definition is dead.
When a statement v← x ⊕ y is eliminated because
v is dead, this statement must be removed from
the list of uses of x and y. Which might cause
those definitions to become dead.
Thus we need to iterate the dead code elimination
algorithm.
CMPUT Compiler Design and Optimization

66. Simple Constant Propagation in SSA
If there is a statement v ← c, where c is a constant,
then all uses of v can be replaced for c.
A Φ function of the form v ← Φ(c1, c2, …, cn) where all
ci are identical can be replaced for v ← c.
Using a work-list algorithm in a program in SSA form,
we can perform constant propagation in linear time
In the next slide we assume that x, y, z are variables
and a, b, c are constants.
CMPUT Compiler Design and Optimization

67. Linear Time Optimizations in SSA form
Copy propagation: The statement x ← Φ(y) or the statement
x ← y can be deleted and y can substitute every use of x.
Constant folding: If we have the statement x ← a ⊕ b, we can
evaluate c ← a ⊕ b at compile time and replace the
statement for x ← c
Constant conditions: The conditional
if a < b goto L1 else L2
can be replaced for goto L1 or goto L2, according to the
compile time evaluation of a < b, and the CFG, use lists,
adjust accordingly
Unreachable Code: eliminate unreachable blocks.
CMPUT Compiler Design and Optimization

68. Single Assignment FormB1
i ← 1
j ← 1
k← 0
i=1;
j=1;
k=0;
while(k<100) {
if(j<20)
j=i;
k=k+1; }
else
j=k;
k=k+2;
return j; B2
if k<100 B3 B4
if j<20
return j B5 B6
j ← i
k ← k+1
j ← k
k ← k+2 B7
CMPUT Compiler Design and Optimization

69. Single Assignment FormB1
i ← 1
j ← 1
k1← 0
i=1;
j=1;
k=0;
while(k<100) {
if(j<20)
j=i;
k=k+1; }
else
j=k;
k=k+2;
return j; B2
if k<100 B3 B4
if j<20
return j B5 B6
j ← i
k3 ← k+1
j ← k
k5 ← k+2 B7
CMPUT Compiler Design and Optimization

70. Single Assignment FormB1
i ← 1
j ← 1
k1← 0
i=1;
j=1;
k=0;
while(k<100) {
if(j<20)
j=i;
k=k+1; }
else
j=k;
k=k+2;
return j; B2
if k<100 B3 B4
if j<20
return j B5 B6
j ← i
k3 ← k+1
j ← k
k5 ← k+2 B7
k4 ← Φ(k3,k5)
CMPUT Compiler Design and Optimization

71. Single Assignment FormB1
i ← 1
j ← 1
k1← 0
i=1;
j=1;
k=0;
while(k<100) {
if(j<20)
j=i;
k=k+1; }
else
j=k;
k=k+2;
return j; B2
k2 ← Φ(k4,k1)
if k<100 B3 B4
if j<20
return j B5 B6
j ← i
k3 ← k+1
j ← k
k5 ← k+2 B7
k4 ← Φ(k3,k5)
CMPUT Compiler Design and Optimization

72. Single Assignment FormB1
i ← 1
j ← 1
k1← 0
i=1;
j=1;
k=0;
while(k<100) {
if(j<20)
j=i;
k=k+1; }
else
j=k;
k=k+2;
return j; B2
k2 ← Φ(k4,k1)
if k2<100 B3 B4
if j<20
return j B5 B6
j ← i
k3 ← k2+1
j ← k
k5 ← k2+2 B7
k4 ← Φ(k3,k5)
CMPUT Compiler Design and Optimization

73. Single Assignment Form
j1 ← 1
k1← 0
j3 ← i1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,j1)
k2 ← Φ(k4,k1)
if k2<100
j4 ← Φ(j3,j5)
k4 ← Φ(k3,k5) B1 B2 B3 B5 B6 B4 B7
i=1;
j=1;
k=0;
while(k<100) {
if(j<20)
j=i;
k=k+1; }
else
j=k;
k=k+2;
return j;
CMPUT Compiler Design and Optimization

74. Example: Constant Propagation
j1 ← 1
k1← 0
j3 ← i1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,j1)
k2 ← Φ(k4,k1)
if k2<100
j4 ← Φ(j3,j5)
k4 ← Φ(k3,k5) B1 B2 B3 B5 B6 B4 B7
i1 ← 1
j1 ← 1
k1← 0
j3 ← 1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(j3,j5)
k4 ← Φ(k3,k5) B1 B2 B3 B5 B6 B4 B7
CMPUT Compiler Design and Optimization

75. Example: Dead-code Elimination
j1 ← 1
k1← 0
j3 ← 1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(j3,j5)
k4 ← Φ(k3,k5) B1 B2 B3 B5 B6 B4 B7
j3 ← 1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(j3,j5)
k4 ← Φ(k3,k5) B2 B3 B5 B6 B4 B7
CMPUT Compiler Design and Optimization

76. Constant Propagation and Dead Code Elimination
j3 ← 1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(j3,j5)
k4 ← Φ(k3,k5) B2 B3 B5 B6 B4 B7
j3 ← 1
k3 ← k2+1
j5 ← k2
k5 ← k2+2
return j2
if j2<20
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(1,j5)
k4 ← Φ(k3,k5) B2 B3 B5 B6 B4 B7
CMPUT Compiler Design and Optimization

77. Example: Is this the end?
But block 6 is never
executed! How can we
find this out, and simplify
the program? B2
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100 B3 B4
SSA conditional constant
propagation finds the
least fixed point for the
program and allows
further elimination of
dead code.
if j2<20
return j2 B5 B6
k3 ← k2+1
j5 ← k2
k5 ← k2+2 B7
j4 ← Φ(1,j5)
k4 ← Φ(k3,k5)
See algorithm on pg of Appel.
CMPUT Compiler Design and Optimization

78. Example: Dead code eliminationB2 B4
k3 ← k2+1
return j2
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(1)
k4 ← Φ(k3) B2 B5 B7
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100 B3 B4
if j2<20
return j2 B5 B6
k3 ← k2+1
j5 ← k2
k5 ← k2+2 B7
j4 ← Φ(1,j5)
k4 ← Φ(k3,k5)
CMPUT Compiler Design and Optimization

79. Example: Single Argument Φ-Function Elimination
k3 ← k2+1
return j2
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← Φ(1)
k4 ← Φ(k3) B2 B5 B7
k3 ← k2+1
return j2
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← 1
k4 ← k3 B2 B5 B7 B4 B4
CMPUT Compiler Design and Optimization

80. Example: Constant and Copy Propagation
k3 ← k2+1
return j2
j2 ← Φ(j4,1)
k2 ← Φ(k4,0)
if k2<100
j4 ← 1
k4 ← k3 B2 B5 B7
k3 ← k2+1
return j2
j2 ← Φ(1,1)
k2 ← Φ(k3,0)
if k2<100
j4 ← 1
k4 ← k3 B2 B5 B7 B4 B4
CMPUT Compiler Design and Optimization

81. Example: Dead Code Elimination
k3 ← k2+1
return j2
j2 ← Φ(1,1)
k2 ← Φ(k3,0)
if k2<100 B2 B5 B4
k3 ← k2+1
return j2
j2 ← Φ(1,1)
k2 ← Φ(k3,0)
if k2<100
j4 ← 1
k4 ← k3 B2 B5 B7 B4
CMPUT Compiler Design and Optimization

82. Example: Φ-Function Simplification
k3 ← k2+1
return j2
j2 ← Φ(1,1)
k2 ← Φ(k3,0)
if k2<100 B2 B5 B4
k3 ← k2+1
return j2
j2 ← 1
k2 ← Φ(k3,0)
if k2<100 B2 B5 B4
CMPUT Compiler Design and Optimization

83. Example: Constant Propagation
k3 ← k2+1
return j2
j2 ← 1
k2 ← Φ(k3,0)
if k2<100 B2 B5 B4
k3 ← k2+1
return 1
j2 ← 1
k2 ← Φ(k3,0)
if k2<100 B2 B5 B4
CMPUT Compiler Design and Optimization

84. Example: Dead Code Elimination
k3 ← k2+1
return 1
j2 ← 1
k2 ← Φ(k3,0)
if k2<100 B2 B5 B4
return 1 B4
CMPUT Compiler Design and Optimization