Download presentation

Presentation is loading. Please wait.

Published byBreana Yoke Modified over 2 years ago

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 Merges**

B1 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 12**

10 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 8**

6 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 Tree**

1 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 Frontier**

1 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 Frontier**

1 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 Frontier**

1 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 Graph**

1 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 Graph**

1 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 Form**

B1 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 Form**

B1 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 Form**

B1 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 Form**

B1 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 Form**

B1 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 elimination**

B2 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

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google