1. CMPUT 680 - Compiler Design and Optimization1 CMPUT680 - Winter 2006 Topic G: Static Single- Assignment Form José Nelson Amaral http://www.cs.ualberta.ca/~amaral/courses/680

2. CMPUT 680 - Compiler Design and Optimization2 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. 25-35, 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. 451-490. Sreedhar, V. C., Gao, G. R., “A Linear Time Algorithm for Placing  -Nodes,” ACM Symposium on Principles of Programming Languages (PoPL), pp. 62-73, 1995.

3. CMPUT 680 - Compiler Design and Optimization3 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.

4. CMPUT 680 - Compiler Design and Optimization4 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.

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

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

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

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

9. CMPUT 680 - Compiler Design and Optimization9 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.

10. CMPUT 680 - Compiler Design and Optimization10 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.

11. CMPUT 680 - Compiler Design and Optimization11 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 is a non-empty 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 within 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.

12. CMPUT 680 - Compiler Design and Optimization12  -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 P xz and P yz.

13. CMPUT 680 - Compiler Design and Optimization13 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   (a 0, a 1, …, a n ) 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?

14. CMPUT 680 - Compiler Design and Optimization14 The SSA Conversion Problem For each variable x defined in a CFG G=(V,E), given the set of nodes S  V that contain a definition for x, find the minimal set, J(S) of nodes that requires a  (x i,x j ) 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.

15. CMPUT 680 - Compiler Design and Optimization15 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.

16. CMPUT 680 - Compiler Design and Optimization16 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

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

18. CMPUT 680 - Compiler Design and Optimization18 Lock-Step Algorithms Performs the reachability computation incrementally while the DF relation is computed. DF Computation Reachability J(S) 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. CFG S

19. CMPUT 680 - Compiler Design and Optimization19 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). A Two-Phase Algorithm is an extreme case of a lazy algorithm. DF Computation Reachability DF Graph SubGraph J(S) S CFG

20. CMPUT 680 - Compiler Design and Optimization20 Computing a Dominator Tree (Lowry and Medlock, 1969): Introduce the problem and give an O(n 4 ) 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. (n: # of nodes; m: # of edges)

21. CMPUT 680 - Compiler Design and Optimization21 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.

22. CMPUT 680 - Compiler Design and Optimization22 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.

23. CMPUT 680 - Compiler Design and Optimization23 Example 1 13 2 3 4 12 1011 9 8 67 5 What is the dominance frontier of node 5?

24. CMPUT 680 - Compiler Design and Optimization24 Example 1 13 2 3 4 12 1011 9 8 67 5 First we must find all nodes that node 5 dominates.

25. CMPUT 680 - Compiler Design and Optimization25 Example 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? 1 13 2 3 4 12 1011 9 8 67 5

26. CMPUT 680 - Compiler Design and Optimization26 Example 1 13 2 3 4 12 1011 9 8 67 5 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?

27. CMPUT 680 - Compiler Design and Optimization27 Example 1 13 2 3 4 12 1011 9 8 67 5 DF(5) = {4, 5, 12, 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?

28. CMPUT 680 - Compiler Design and Optimization28 Dominance Frontier Criterion 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?

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

30. CMPUT 680 - Compiler Design and Optimization30 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. 19.2 of Appel.

31. CMPUT 680 - Compiler Design and Optimization31 Example: Dominator Tree 1 13 2 3 4 12 1011 9 8 67 5 1 3 67 1011 45129213 8 Control Flow Graph Dominator Tree

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

33. CMPUT 680 - Compiler Design and Optimization33 Example: Local Dominance Frontier 1 13 2 3 4 12 1011 9 8 67 5 Control Flow Graph In the example, what are the local dominance frontier of nodes 5, 6 and 7? DF local [5] =  DF local [6] = {4,8} DF local [7] = {8,12}

34. CMPUT 680 - Compiler Design and Optimization34 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 parents dominance frontier is defined as [Cytron-Ferrante, 1991]: DF up [c] = nodes in the dominance frontier of c that are not strictly dominated by the immediate dominator of c

35. CMPUT 680 - Compiler Design and Optimization35 Example: Local Dominance Frontier 1 13 2 3 4 12 1011 9 8 67 5 Control Flow Graph In the example, what are the contributions of nodes 6, 7, and 8 to its parent dominance frontier? 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

36. CMPUT 680 - Compiler Design and Optimization36 Example: Local Dominance Frontier 1 13 2 3 4 12 1011 9 8 67 5 Control Flow Graph 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 Now we check for the DF up condition: DF up [6] = {4} DF up [7] = {12} DF up [8] = {5,13}

37. CMPUT 680 - Compiler Design and Optimization37 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] = 0000 0001 0001 0000 DF[7] = 0001 0001 0000 0000 DF[8] = 0010 0000 0010 0000

38. CMPUT 680 - Compiler Design and Optimization38 Strictly Dominated Sets 1 3 67 1011 45129213 8 Dominator Tree We can also represent the strictly dominated sets as vectors: SD[1] = 0011 1111 1111 1100 SD[2] = 0000 0000 0000 1000 SD[5] = 0000 0001 1100 0000 SD[9] = 0000 1100 0000 0000

39. CMPUT 680 - Compiler Design and Optimization39 A note on implementation DF up [c] = nodes in the dominance frontier of c that are not strictly dominated by the immediate dominator of c If we use bitvectors to represent these sets: DF[6] = 0000 0001 0001 0000 DF[7] = 0001 0001 0000 0000 DF[8] = 0010 0000 0010 0000 SD[5] = 0000 0001 1100 0000 DF up [c] = DF[6] ^ ~SD[5]

40. CMPUT 680 - Compiler Design and Optimization40 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]:

41. CMPUT 680 - Compiler Design and Optimization41 Example: Local Dominance Frontier 1 13 2 3 4 12 1011 9 8 67 5 Control Flow Graph What is DF[5]? Remember that: DF local [5] =  DF up [6] = {4} DF up [7] = {12} DF up [8] = {5,13} DTchildren[5] = {6,7,8}

42. CMPUT 680 - Compiler Design and Optimization42 Example: Local Dominance Frontier 1 13 2 3 4 12 1011 9 8 67 5 Control Flow Graph What is DF[5]? Remember that: DF local [5] =  DF up [6] = {4} DF up [7] = {12} DF up [8] = {5,13} DTchildren[5] = {6,7,8} Thus, DF[5] = {4, 5, 12, 13}

43. CMPUT 680 - Compiler Design and Optimization43 Join Sets In order to insert  -nodes for a variable x that is defined in a set of nodes S={n 1, n 2, …, n k } 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 P xz and P yz in G that have z as its first common node, x  S and y  S}

44. CMPUT 680 - Compiler Design and Optimization44 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:

45. CMPUT 680 - Compiler Design and Optimization45 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! Exercise: Find an example in which the IDF of a set S is different from the DF of the set!

46. CMPUT 680 - Compiler Design and Optimization46 Location of  -Nodes Given a variable x that is defined in a set of nodes S={n 1, n 2, …, n k } 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.

47. CMPUT 680 - Compiler Design and Optimization47 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 1994, Shreedar and Gao proposed a simple, linear algorithm for the insertion of  -nodes. 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(N 2 ).

48. CMPUT 680 - Compiler Design and Optimization48 Sreedhar and Gao’s DJ Graph 1 13 2 3 4 12 1011 9 8 67 5 1 3 67 1011 45129213 8 Control Flow Graph Dominator Tree

49. CMPUT 680 - Compiler Design and Optimization49 Sreedhar and Gao’s DJ Graph 1 13 2 3 4 12 1011 9 8 67 5 1 3 67 1011 45129213 8 Control Flow Graph Dominator Tree D nodes

50. CMPUT 680 - Compiler Design and Optimization50 Sreedhar and Gao’s DJ Graph 1 13 2 3 4 12 1011 9 8 67 5 1 3 67 1011 45129213 8 Control Flow Graph Dominator Tree D nodes J nodes

51. CMPUT 680 - Compiler Design and Optimization51 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 3 67 1011 45129213 8 What is the DF[5]?

52. CMPUT 680 - Compiler Design and Optimization52 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 3 67 1011 45129213 8 SubTree(5) = {5, 6, 7, 8} Initialization: DF[5] = 

53. CMPUT 680 - Compiler Design and Optimization53 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 3 67 1011 45129213 8 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 Initialization: DF[5] = 

54. CMPUT 680 - Compiler Design and Optimization54 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 3 67 1011 45129213 8 SubTree(5) = {5, 6, 7, 8} There are two edges originating in 6: {6  4, 6  8} but 8.level > 5.level Initialization: DF[5] =  After visiting 6: DF = {4}

55. CMPUT 680 - Compiler Design and Optimization55 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 3 67 1011 45129213 8 SubTree(5) = {5, 6, 7, 8} There are two edges originating in 7: {7  8, 7  12} again 8.level > 5.level Initialization: DF[5] =  After visiting 6: DF = {4} After visiting 7: DF = {4,12}

56. CMPUT 680 - Compiler Design and Optimization56 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 3 67 1011 45129213 8 SubTree(5) = {5, 6, 7, 8} There are two edges originating in 8: {8  5, 8  13} both satisfy cond. in steps 2-3 Initialization: DF[5] =  After visiting 6: DF = {4} After visiting 7: DF = {4,12} After visiting 8: DF = {4, 12, 5, 13}

57. CMPUT 680 - Compiler Design and Optimization57 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].

58. CMPUT 680 - Compiler Design and Optimization58 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.

59. CMPUT 680 - Compiler Design and Optimization59 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.

60. CMPUT 680 - Compiler Design and Optimization60 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   (c 1, c 2, …, c n ) where all c i 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.

61. CMPUT 680 - Compiler Design and Optimization61 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.

62. CMPUT 680 - Compiler Design and Optimization62 Single Assignment Form 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; } i  1 j  1 k  0 j  i k  k+1 j  k k  k+2 return j if j<20 if k<100 B1 B2 B3 B5 B6 B4 B7

63. CMPUT 680 - Compiler Design and Optimization63 Single Assignment Form 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; } i  1 j  1 k1  0 j  i k3  k+1 j  k k5  k+2 return j if j<20 if k<100 B1 B2 B3 B5 B6 B4 B7

64. CMPUT 680 - Compiler Design and Optimization64 Single Assignment Form 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; } i  1 j  1 k1  0 j  i k3  k+1 j  k k5  k+2 return j if j<20 if k<100 k4   (k3,k5) B1 B2 B3 B5 B6 B4 B7

65. CMPUT 680 - Compiler Design and Optimization65 Single Assignment Form 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; } i  1 j  1 k1  0 j  i k3  k+1 j  k k5  k+2 return j if j<20 k2   (k4,k1) if k<100 k4   (k3,k5) B1 B2 B3 B5 B6 B4 B7

66. CMPUT 680 - Compiler Design and Optimization66 Single Assignment Form 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; } i  1 j  1 k1  0 j  i k3  k2+1 j  k k5  k2+2 return j if j<20 k2   (k4,k1) if k2<100 k4   (k3,k5) B1 B2 B3 B5 B6 B4 B7

67. CMPUT 680 - Compiler Design and Optimization67 Single Assignment Form 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; } i1  1 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

68. CMPUT 680 - Compiler Design and Optimization68 Example: Constant Propagation i1  1 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

69. CMPUT 680 - Compiler Design and Optimization69 Example: Dead-code Elimination 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 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

70. CMPUT 680 - Compiler Design and Optimization70 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   (1,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   (j3,j5) k4   (k3,k5) B2 B3 B5 B6 B4 B7

71. CMPUT 680 - Compiler Design and Optimization71 Example: Is this the end? But block 6 is never executed! How can we find this out, and simplify the program? SSA conditional constant propagation finds the least fixed point for the program and allows further elimination of dead code. See algorithm on pg. 454-455 of Appel. k3  k2+1j5  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

72. CMPUT 680 - Compiler Design and Optimization72 Example: Dead code elimination k3  k2+1j5  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 B4 k3  k2+1 return j2 j2   (j4,1) k2   (k4,0) if k2<100 j4   (1) k4   (k3) B2 B5 B7

73. CMPUT 680 - Compiler Design and Optimization73 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 B4 k3  k2+1 return j2 j2   (j4,1) k2   (k4,0) if k2<100 j4  1 k4  k3 B2 B5 B7 B4

74. CMPUT 680 - Compiler Design and Optimization74 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

75. CMPUT 680 - Compiler Design and Optimization75 Example: Dead Code Elimination k3  k2+1 return j2 j2   (1,1) k2   (k3,0) if k2<100 j4  1 k4  k3 B2 B5 B7 B4 k3  k2+1 return j2 j2   (1,1) k2   (k3,0) if k2<100 B2 B5 B4

76. CMPUT 680 - Compiler Design and Optimization76 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

77. CMPUT 680 - Compiler Design and Optimization77 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

78. CMPUT 680 - Compiler Design and Optimization78 Example: Dead Code Elimination k3  k2+1 return 1 j2  1 k2   (k3,0) if k2<100 B2 B5 B4 return 1 B4