1 / 47

SSA

SSA. Agenda. SSA Introduction Converting to SSA Converting out of SSA SSA Example. SSA Introduction. SSA is a intermediate representation. SSA was developed by Ron Cytron, Jeanne Ferrante, Barry Rosen, Mark Wegman, and Ken Zadeck, researchers at IBM in the 1980s. Benefits

thyra
Télécharger la présentation

SSA

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. SSA

  2. Agenda • SSA Introduction • Converting to SSA • Converting out of SSA • SSA Example

  3. SSA Introduction • SSA is a intermediate representation. • SSA was developed by Ron Cytron, Jeanne Ferrante, Barry Rosen, Mark Wegman, and Ken Zadeck, researchers at IBM in the 1980s. • Benefits • constant propagation • sparse conditional constant propagation • dead code elimination • global value numbering • partial redundancy elimination • strength reduction • register allocation

  4. SSA Introduction • Static Single Assignment Form • Each variable has only one reaching definition. • When two definitions merge, a Ф function is introduced to with a new definition of the variable. • A Ф operand represents the reaching definition from the corresponding predecessor.

  5. SSA Introduction a3= a= a1= a= = a1+5 = a+5 = a+5 a4= Ф(a1,a3) a2= a= = a4+5 = a2+5 = a+5

  6. SSA Introduction • SSA Condition • If two nonnull paths X →+ Z and Y →+ Z converge at a node, and nodes X and Y contain assignments to V (in the original program), then a trivial -function V = (V,…,V) has been inserted at Z (in the new program) • Each mention of V in the original program or in an inserted -function has been replaced by a mention of a new variable Vi, leaving the new program in SSA form • Along any control flow path, consider any use of a variable V (in the original program) and the corresponding use of Vi (in the new program). Then V and Vi has same value.

  7. SSA Introduction • Where to insert -functions? • By condition 1, a node Z needs a -function for V because Z is a convergence point for two nonnull paths X →+ Z and Y →+ Z that start at nodes X and Y already containing assignments to V.

  8. SSA Introduction • What about arrays? • Treating A[i] as a variable would be awkward, both because an assignment to A[i] may or may not change the value of A[j] and because the value of A[i] could be changed by assigning to i rather than to A[i]. • Treat entire array as a scalar variable. = A[i] A[j] = V = A[k] = R(A,i) A = W(A,j,V) = R(A,k) = R(A8,i7) A9 = W(A8,j6,V5) = R(A9,k4)

  9. SSA Introduction • W operator may introduce unnecessary liveness for A. Introduce HW (HiddenW). repeat i2 = Ф(i1,i3) A2= HW(i2,i2) i3 = i2 +1 until i3>10 repeat A[i] = i i = i +1 until i>10 repeat i2 = Ф(i1,i3) A1 = Ф(A0,A2) A2= W(A1,i2,i2) i3 = i2 +1 until i3>10

  10. Converting to SSA • Big picture, translation to SSA form is done in 3 steps • The dominance frontier mapping is constructed form the control flow graph. • Using the dominance frontiers, the locations of the -functions for each variable in the original program are determined. • The variables are renamed by replacing each mention of an original variable V by an appropriate mention of a new variable Vi

  11. CFG • A control flow graph G = (V, E) • Set V contains distinguished nodes ENTRY and EXIT • every node is reachable from ENTRY • EXIT is reachable from every node in G. • ENTRY has no predecessors • EXIT has no successors. • Notation: predecessor, successor, path

  12. Dominance Relation • If X appears on every path from ENTRY to Y, then X dominates Y. • Dominance relation is both reflexive and transitive. • idom(Y): immediate dominator of Y • Dominator Tree • ENTRY is the root • Any node Y other than ENTRY has idom(Y) as its parent • Notation: parent, child, ancestor, descendant

  13. Dominator Tree Example ENTRY ENTRY a EXIT a c b b d c d CFG DT EXIT

  14. Dominator Tree Example

  15. Dominance Frontier • Dominance Frontier DF(X) for node X • Set of nodes Y • X dominates a predecessor of Y • X does not strictly dominate Y • Equation 1: DF(X) = {Y|(P∈Pred(Y))(XP and XY )} • Equation 2: DF(X) = DFlocal(X)∪ ∪Z∈Children(X)DFup(z) • DFlocal(X) = {Y∈Succ(x)|idom(Y)≠X} • DFup(X) = {Y∈DF(Z)|idom(Z) ≠X}

  16. Dominance Frontier • How to proof equation 1 and equation 2 are correct? • Easy to See that => is correct • Still have to show everything in DF(X) has been accounted for. • Suppose Y ∈DF(X) and UY be the edge that X dominate U but doesn’t strictly dominate Y. • If U == X, then Y ∈DFlocal(X) • If U ≠X, then there exists a path from X to U in Dominator Tree which implies there exists a child Z of X dominate U. Z doesn’t strictly dominate Y because X doesn’t strictly dominate Y. So Y ∈DFup(X).

  17. Ф-function and Dominance Frontier • Intuition behind dominance frontier • Y ∈DF(X) means: • Y has multiple predecessors • X dominate one of them, say U, U inherits everything defined in X • Reaching definition of Y are from U and other predecessors • So Y is exactly the place where Ф-function is needed

  18. Control Dependences and Dominance Frontier • A CFG node Y is control dependent on a CFG node X if both the following hold: • There is nonnull path p: X →+ Y such that Y postdominate every node after X. • The node Y doesn’t strictly postdominate the node X • If X appears on every path from Y to Exit, then X postdominate Y.

  19. Control Dependences and Dominance Frontier • In other words, there is some edge from X that definitely causes Y to execute, and there is also some path from X that avoids executing Y.

  20. RCFG • The reverse control flow graph RCFG has the same nodes as CFG, but has edge Y →X for each edge X→Y in CFG. • Entry and Exit are also reversed. • The postdominator relation in CFG is dominator relation in RCFG. • Let X and Y be nodes in CFG. Then Y is control dependent on X in CFG iff X∈DF(Y) in RCFG.

  21. SSA Construction– Place Ф Functions • For each variable V • Add all nodes with assignments to V to worklist W • While X in W do • For each Y in DF(X) do • If no Ф added in Y then • Place (V = Ф (V,…,V)) at Y • If Y has not been added before, add Y to W.

  22. SSA Construction– Rename Variables • Rename from the ENTRY node recursively • For node X • For each assignment (V = …) in X • Rename any use of V with the TOS of rename stack • Push the new name Vi on rename stack • i = i + 1 • Rename all the Ф operands through successor edges • Recursively rename for all child nodes in the dominator tree • For each assignment (V = …) in X • Pop Vi in X from the rename stack

  23. Rename Example TOS a= a1= a1 a0 a1+5 Rename expr a= Ф(a1,a) a = a+5 a+5

  24. Converting out of SSA • Eventually, a program must be executed. • The Ф-function have precise semantics, but they are generally not represented in existing target machines.

  25. Converting Out of SSA • Naively, a k-input Ф-function at entrance to node X can be replaced by k ordinary assignments, one at the end of each control predecessor of X. • Inefficient object code can be generated.

  26. Dead Code Elimination • Where does dead code come from? • Assignments without any use • Dead code elimination method • Initially all statements are marked dead • Some statements need to be marked live because of certain conditions • Mark these statements can cause others to be marked live. • After worklist is empty, truly dead code can be removed

  27. Allocation By Coloring • It might seem possible to map all occurrence of Vi back to V and delete all Ф-functions. • After certain optimization, this assumption might not be true.

  28. Allocation By Coloring • Use graph coloring techniques to allocate storage for variables. • In the case above,V1 and V2 are alive simultaneously, they have different color, and will be converted back to two different variables.

  29. SSA Example • Dead Code Elimination Intuition • 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. This might cause those definitions to become dead.

  30. SSA Example • Simple Constant Propagation Intuition • 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.

  31. j  i k  k+1 j  k k  k+2 SSA Example 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 B4 B3 return j if j<20 B6 B5 B7

  32. j  i k3  k+1 j  k k5  k+2 SSA Example 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 B4 B3 return j if j<20 B6 B5 B7

  33. j  i k3  k+1 j  k k5  k+2 SSA Example 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 B4 B3 return j if j<20 B6 B5 B7 k4  (k3,k5)

  34. j  i k3  k+1 j  k k5  k+2 SSA Example 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 B4 B3 return j if j<20 B6 B5 B7 k4  (k3,k5)

  35. j  i k3  k2+1 j  k k5  k2+2 SSA Example 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 B4 B3 return j if j<20 B6 B5 B7 k4  (k3,k5)

  36. B1 i1  1 j1  1 k1 0 B2 j2  (j4,j1) k2  (k4,k1) if k2<100 B4 B3 return j2 if j2<20 B6 B5 j3  i1 k3  k2+1 j5  k2 k5  k2+2 B7 j4  (j3,j5) k4  (k3,k5) SSA Example 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; }

  37. B1 B1 i1  1 j1  1 k1 0 i1  1 j1  1 k1 0 B2 B2 j2  (j4,j1) k2  (k4,k1) if k2<100 j2  (j4,1) k2  (k4,0) if k2<100 B4 B4 B3 B3 return j2 return j2 if j2<20 if j2<20 B6 B6 B5 B5 j3  1 k3  k2+1 j3  i1 k3  k2+1 j5  k2 k5  k2+2 j5  k2 k5  k2+2 B7 B7 j4  (j3,j5) k4  (k3,k5) j4  (j3,j5) k4  (k3,k5) SSA Example: Constant Propagation

  38. B1 i1  1 j1  1 k1 0 B2 B2 j2  (j4,1) k2  (k4,0) if k2<100 j2  (j4,1) k2  (k4,0) if k2<100 B4 B4 B3 B3 return j2 if j2<20 return j2 if j2<20 B6 B6 B5 B5 j3  1 k3  k2+1 j3  1 k3  k2+1 j5  k2 k5  k2+2 j5  k2 k5  k2+2 B7 j4  (j3,j5) k4  (k3,k5) B7 j4  (j3,j5) k4  (k3,k5) SSA Example: Dead Code Elimination

  39. B2 B2 j2  (j4,1) k2  (k4,0) if k2<100 j2  (j4,1) k2  (k4,0) if k2<100 B4 B4 B3 B3 return j2 return j2 if j2<20 if j2<20 B6 B6 B5 B5 j3  1 k3  k2+1 j3  1 k3  k2+1 j5  k2 k5  k2+2 j5  k2 k5  k2+2 B7 B7 j4  (1,j5) k4  (k3,k5) j4  (j3,j5) k4  (k3,k5) SSA Example: Constant Propagation and Dead Code Elimination

  40. k3  k2+1 j5  k2 k5  k2+2 SSA Example: One Step Further 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 B4 B3 SSA conditional constant propagation finds the least fixed point for the program and allows further elimination of dead code. return j2 if j2<20 B6 B5 B7 j4  (1,j5) k4  (k3,k5)

  41. B2 j2  (j4,1) k2  (k4,0) if k2<100 B4 return j2 B5 k3  k2+1 k3  k2+1 j5  k2 k5  k2+2 B7 j4  (1) k4  (k3) SSA Example: Dead Code Elimination B2 j2  (j4,1) k2  (k4,0) if k2<100 B4 B3 return j2 if j2<20 B6 B7 j4  (1,j5) k4  (k3,k5)

  42. B2 B2 j2  (j4,1) k2  (k4,0) if k2<100 j2  (j4,1) k2  (k4,0) if k2<100 B4 return j2 return j2 B5 B5 k3  k2+1 k3  k2+1 B7 B7 j4  (1) k4  (k3) j4  1 k4  k3 SSA Example: Single Argument  Function Elimination B4

  43. B2 B2 j2  (j4,1) k2  (k4,0) if k2<100 j2  (1,1) k2  (k3,0) if k2<100 B4 return j2 return j2 B5 B5 k3  k2+1 k3  k2+1 B7 B7 j4  1 k4  k3 j4  1 k4  k3 SSA Example: Constant and Copy Propagation B4

  44. B2 j2  (1,1) k2  (k3,0) if k2<100 B2 j2  (1,1) k2  (k3,0) if k2<100 B4 return j2 B4 return j2 B5 k3  k2+1 B5 k3  k2+1 B7 j4  1 k4  k3 SSA Example: More Dead Code

  45. B2 B2 j2  (1,1) k2  (k3,0) if k2<100 j2  1 k2  (k3,0) if k2<100 B4 B4 return j2 return j2 B5 B5 k3  k2+1 k3  k2+1 SSA Example: More  Function Simplification

  46. B2 B2 j2  1 k2  (k3,0) if k2<100 j2  1 k2  (k3,0) if k2<100 B4 B4 return j2 return 1 B5 B5 k3  k2+1 k3  k2+1 SSA Example: More Constant Propagation

  47. B2 j2  1 k2  (k3,0) if k2<100 B4 return 1 B4 return 1 B5 k3  k2+1 SSA Example: Ultimate Dead Code Elimination

More Related