Dataflow Analysis. A sample program int fib10(void) { int n = 10; int older = 0; int old = 1; Simple Constant Propagation

Transcription

1 -74 Lecture 2 Dataflow Analysis Basic Blocks Related Optimizations SSA Copyright Seth Copen Goldstein Dataflow Analysis Last time we looked at code transformations Constant propagation Copy propagation Common sub-expression elimination Today, dataflow analysis: How to determine if it is legal to perform such an optimization (Not doing analysis to determine if it is beneficial) Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein A sample program int fib0(void) { int n = 0; int older = 0; int old = ; int What result are = those 0; numbers? int i; : n <- 0 2: older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- 2 7: if i > n goto if (n <= ) return n; for (i = 2; i<n; i++) { result = old + older; older = old; old = result; return result; : return result 4: return n 8: result <- old + older 9: older <- old 0: old <- result : i <- i + 2: JUMP 7 Lecture 2-74 Seth Copen Goldstein Simple Constant Propagation : n <- 0 2: older <- 0 : old < 4: result <- 0 Can we do SCP? How do we recognize it? : old <- : if n <= goto 4 What aren t we doing? 6: i <- 2 7: if i > n goto Metanote: keep opts simple! Use combined power 0: old <- result 8: result <- old + older 9: older <- old : i <- i + 2: JUMP 7 : return result 4: return n Lecture 2-74 Seth Copen Goldstein

2 Reaching Definitions A definition iti of variable v at program point d reaches program point u if there exists a path of control flow edges from d to u that does not contain a definition of v. : n < : older <- 0 : old < : result <- 0 : if n <= goto 4 6: i < : if i > n goto 4 8: result <- old + older 0 9: older <- old 0: old <- result : i <- i : JUMP 7 : return result 4: return n Lecture 2-74 Seth Copen Goldstein Reaching Definitions (ex) reaches, 7, and 4 2 reaches 8 Older in 8 is reached by 2 9 Tells us which definitions reach a particular use (ud-info) : n <- 0 2: older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- 2 7: if i > n goto 8: result <- old + older 9: older <- old 0: old <- result : i <- i + 2: JUMP 7 : return result 4: return n Lecture 2-74 Seth Copen Goldstein Reaching Definitions (ex) reaches, 7, and 4 2 reaches 4, Really? 8 Meta-notes: Older in 8 is reached by (almost) always conservative only 2 know what we know Keep 9it simple: What opt(s), if run before this would help Tells What us about: which definitions : x <- 0 reach a 2: if (false) x<- particular use (ud-info) : x Does reach? What opt changes this? : n <- 0 2: older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- 2 7: if i > n goto 8: result <- old + older 9: older <- old 0: old <- result : i <- i + 2: JUMP 7 : return result 4: return n Lecture 2-74 Seth Copen Goldstein Calculating Reaching Definitions A definition iti of variable v at program point d reaches program point u if there exists a path of control flow edges from d to u that does not contain a definition of v. Build up RD stmt by stmt Stmt s, d: v <- x op y, generates d Stmt s, d: v <- x op y, kills all other defs(v) Or, Gen[s] = { d Kill[s] = defs(v) { d Lecture 2-74 Seth Copen Goldstein

3 Gen and kill for each stmt Gen kill : n <- 0 2: older < : old <- 0 4: result < : if n <= goto 4 6: i < : if i > n goto 8: result <- old + older 8 4 9: older <- old 9 2 0:old <- result 0 : i <- i + 6 2: JUMP 7 : return result 4: return n How can we determine the defs that reach a node? We can use: control flow information gen and kill info Lecture 2-74 Seth Copen Goldstein In[: Out[: Computing in[ and out[ the set of defs that reach the beginning ng of node n the set of defs that reach the end of node n in[ = out[ [ p ] out[ = p pred[ gen [ n ] ( in [ n ] kill [ n ]) Initialize in[=out[={ for all n Solve iteratively Lecture 2-74 Seth Copen Goldstein What is pred[? Pred[ are all nodes that can reach n in the control flow graph. E.g., pred[7] = { 6, 2 : n < : older <- 0 : old < : result <- 0 : if n <= goto 4 6: i < : if i > n goto 4 8: result <- old + older 0 9: older <- old 0: old <- result : i <- i : JUMP 7 : return result 4: return n Lecture 2-74 Seth Copen Goldstein What order to eval nodes? Does it matter? Lets do:,2,,4,,4,6,7,,8,9,0,, : n < : older <- 0 : old < : result <- 0 : if n <= goto 4 6: i < : if i > n goto 4 8: result <- old + older 0 9: older <- old 0: old <- result : i <- i : JUMP 7 : return result 4: return n Lecture 2-74 Seth Copen Goldstein

4 Example: Order: ,2,,4,,4,6,7,,8,9,0,,2 in[ out[ p] = out[ = gen[ ( in[ kill[ ) p pred [ n ] Gen kill in out : n <- 0 2: older < ,2 : old <- 0,2-4: result < : if n <= goto 4 6: i < : if i > n goto 8: result <- old + older 8 4 9: older <- old 9 2 0: old <- result 0 : i <- i + 6 2: JUMP 7 : return result 4: return n Example (pass ) Order: ,2,,4,,4,6,7,,8,9,0,,2 in[ out[ p] = out[ = gen[ ( in[ kill[ ) p pred [ n ] Gen kill in out : n <- 0 2: older < ,2 : old <- 0,2,2, 4: result < : if n <= goto : i < ,6 7: if i > n goto -4,6-4,6 8: result <- old + older 8 4-4,6 -,6,8 9: older <- old 9 2 -,6,8,,6,8,9 0: old <- result 0,,6,8,9,6,8-0 : i <- i + 6,6,8-0,8-2: JUMP 7,8-,8- : return result -4,6-4,6 4: return n -4-4 Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Example (pass 2) Order: ,2,,4,,4,6,7,,8,9,0,,2 in[ out[ p] = out[ = gen[ ( in[ kill[ ) p pred [ n ] Gen kill in out : n <- 0 2: older < ,2 : old <- 0,2,2, 4: result < : if n <= goto : i < ,6 7: if i > n goto -4,6,8- -4,6,8-8: result <- old + older 8 4-4,6,8- -,6,8-9: older <- old 9 2 -,6,8-,,6,8-0: old <- result 0,,6,8-,6,8- : i <- i + 6,6,8-,8-2: JUMP 7,8-,8- : return result -4,6-4,6 4: return n -4-4 Lecture 2-74 Seth Copen Goldstein An Improvement: Basic Blocks No need to compute this one stmt at a time For straight line code: In[s; s2] = in[s] Out[s; s2] = out[s2] Can we combine the gen and kill sets into one set per BB? Gen kill Gen[BB]={24 Gen[BB]={2,,4, Kill[BB]={,8, Gen[s;s2]= Kill[s;s2]= : i <- 8,4 2: j <- 2 2 : k <- + i 4: i <- j 4,8 : m <- i + k Lecture 2-74 Seth Copen Goldstein

5 BB sets BB sets Gen kill : n <- 0 2: older < : old <- 0 4: result < : if n <= goto 4,2,,4 8,9,0 6: i < : if i > n goto 8: result <- old + older 8 4 9: older <- old 9 2 0: old <- result 0 : i <- i + 6 2: JUMP ,6 : return result 4: return n 2 4 Gen={,2,,4 Kill={890 {8,9,0 Gen={6 Kill={ 6 Gen={8,9,0, Kill={2,,4,6 In out,2,,4 Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein BB sets Forward Dataflow 2 Gen={8,9,0, Kill={2,,4,6 4 6 Gen={,2,,4 Kill={890 {8,9,0 Gen={6 Kill={ In out,2,,4,2,,4,,,2,,4,6,,, -4,6, ,6, ,6, ,8- Reaching definitions is a forward dataflow problem: It propgates information from preds of a node to the node Defined by: Basic attributes: (gen and kill) Transfer function: out[b]=f bb (in[b]) Meet operator: in[b]=m(out[p]) for all p pred(b) Set of values (a lattice, in this case powerset of program points) ) Initial values for each node b Solve for fixed point solution Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

6 How to implement? Values? Gen? Kill? F bb? Order to visit nodes? When are we done? In fact, do we know we terminate? Implementing RD Values: bits in a bit vector Gen: in each position generated, otherwise 0 Kill: 0 in each position killed, otherwise F bb : out[b] = (in[b] gen[b]) & kill[b] Init in[b]=out[b]=0 When are we done? What order to visit it nodes? Does it matter? Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein RD Worklist algorithm Initialize: in[b] = out[b] = Initialize: in[entry] = Work queue, W = all Blocks in topological order while ( W!= 0) { remove b from W old = out[b] in[b] = {over all pred(p) b out[p] out[b] = gen[b] (in[b] - kill[b]) if (old!= out[b]) W = W succ(b) Lecture 2-74 Seth Copen Goldstein Storing Rd information Use-def chains: for each use of var x in s, a list of definitions of x that reach s : n <- 0 2: older <- 0,2 : old <-,2,2, 4: result < : if n <= goto : i < ,6 7: if i > n goto -4,6,8- -4,6,8-8: result <- old + older -4,6,8- -,6,8-9: older <- old -,6,8-,,6,8-0:old <- result,,6,8-,6,8- : i <- i +,6,8-,8-2: JUMP 7,8-,8- : return result -4,6-4,6 4: return n -4-4 Lecture 2-74 Seth Copen Goldstein

7 Def-use chains are valuable too Def-use chain: for each definition of var x, a list of all uses of that definition Computed from liveness analysis, a backward dataflow problem Def-use and use-def are different z > x <- z > y x <- 2 y <- x + z <- x + Lecture 2-74 Seth Copen Goldstein Using RD for Simple Const. Prop. : n <- 0 2: older <- 0,2 : old <-,2,2, 4: result < : if n <= goto : i < ,6 7: if i > n goto -4,6,8- -4,6,8-8: result <- old + older -4,6,8- -,6,8-9: older <- old -,6,8-,,6,8-0:old <- result,,6,8-,6,8- : i <- i +,6,8-,8-2: JUMP 7,8-,8- : return result -4,6-4,6 4: return n -4-4 Lecture 2-74 Seth Copen Goldstein Better Constant Propagation Better Constant Propagation What about: x <- if (y > z) a <- x x <- What about: x <- Lattice if (y > z) a <- x x <- -inf inf Meet: a <- a <- a c <- c c <- c d ( if c d) Init all vars to: bot or top? Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

8 Loop Invariant Code Motion Loop Invariant Code Motion When can expression be moved out of a loop? x <- y + z a <-.. x.. When can expression be moved out of a loop? When all reaching definitions of operands are outside of loop, expression is loop invariant Use ud-chains to detect Can du-chains be helpful? x <- y + z a <-.. x.. Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Liveness (def-use chains) A variable x is live-out of a stmt s if x can be used along some path starting a s, otherwise x is dead. Why is this important? How can we frame this as a dataflow problem? Lecture 2-74 Seth Copen Goldstein Liveness as a dataflow problem This is a backwards analysis A variable is live out if used by a successor Gen: For a use: indicate it is live coming into s Kill: Defining a variable v in s makes it dead before s (unless s uses v to define v) Lattice is just live (top) and dead (bottom) Values are variables In[ = variables live before n = out[ kill[ gen[ Out[ = variables live after n = In[ s] s succ( n) Lecture 2-74 Seth Copen Goldstein

9 Dead Code Elimination Code is dead if it has no effect on the outcome of the program. When is code dead? Dead Code Elimination Code is dead if it has no effect on the outcome of the program. When is code dead? When the definition is dead, and When the instruction has no side effects So: run liveness Construct def-use chains Any instruction which has no users and has no side effects can be eliminated Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein When can we do CSE? Available Expressions? a <- 4 + i X+Y is available at statement S if x+y is computed along every path from the start to S AND neither x nor y is modified after the last evaluation of x+y b <- 4 + i a <- b+c b <- a-d c <- b+c d <- a-d Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

10 Computing Available Expressions Forward or backward? Values? Lattice? gen[b] = kill[b] = in[b] = out[b] = initialization? iti Computing Available Expressions Forward Values: all expressions Lattice: available, not-avail gen[b] = if b evals expr e and doesn t define variables used in e kill[b] = if b assigns to x, then all exprs using x are killed. out[b] = in[b] kill[b] gen[b] in[b] = what to do at a join point? initialization? Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Computing Available Expressions Forward Values: all expressions Lattice: available, not-avail gen[b] = if b evals expr e and doesn t define variables used in e kill[b] = if b assigns to x, exprs(x) are killed out[b] = in[b] kill[b] gen[b] in[b] = An expr is avail only if avail on ALL edges, so: in[b] = over all p pred(b), out[p] Initialization All nodes, but entry are set to ALL avail Entry is set to NONE avail Lecture 2-74 Seth Copen Goldstein Constructing Gen & Kill Stmt Gen Kill t <- x op y {x op y-kill[s] {exprs containing t t <- M[a] {M[a]-kill[s] M[a] <- b f(a, ) {M[x] for all x t <- f(a, ) Lecture 2-74 Seth Copen Goldstein

11 Constructing Gen & Kill Example Entry Stmt Gen Kill t <- x op y {x op y-kill[s] {exprs containing t t <- M[a] {M[a]-kill[s] {exprs containing t M[a] <- b { {for all x, M[x] f(a, ) { {for all x, M[x] t <- f(a, ) { {exprs containing t for all x, M[x] g[i] <- a*c c<-a+b d<-a*c e<-d*d i <- f[i] <- a+b c <- c*2 br c>d i <- i+ br i>0 g[i] <- d*d Exit Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein g[i] <- a*c Example Entry c<-a+b d <- a*c e<-d*d i <- f[i] <- a+b c <- c*2 br c>d Gen={a*c Kill={M[x] i <- i+ br i>0 Exit g[i] <- d*d Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ Gen={a+b,c>d Kill={c*2,M[x],a*c Gen={i>0 Kill={i+ Gen={d*d Kill={M[x] Lecture 2-74 Seth Copen Goldstein Example W={ { In={ out={ Entry in={ c<-a+b 2 d<-a*c e<-d*d out={a+b, a*c, d*d, c>d, c*2, i>0, i+ i <- in={ f[i] <- a+b c <- c*2 out={a+b,a*c,d*d,c>d,c*2,i>0,i+ br c>d Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ Gen={a+b,c>d Kill={c*2,M[x],a*c in={ in={ 4Gen={a*c g[i] <- a*c Gen={d*d Kill={M[x] g[i] <- d*d Kill={M[x] out={a+b,a*c,d*d,c>d,c*2,i>0,i+ in={ i <- i+ 6 Gen={i>0 br i>0 out={a+b,a*c,d*d,c>d,c*2,i>0,i+ a*c c>d c*2 i+ Kill={i+ in={ 7 Exit Lecture 2-74 Seth Copen Goldstein

12 W={ out={a+b, a*c, d*d Example In={ out={ in={ Entry c<-a+b 2 d <- a*c e<-d*d i <- in={ f[i] <- a+b c <- c*2 out={a+b,a*c,d*d,c>d,c*2,i>0,i+ br c>d Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ Gen={a+b,c>d Kill={c*2,M[x],a*c in={ in={ 4Gen={a*c g[i] <- a*c Gen={d*d Kill={M[x] g[i] <- d*d Kill={M[x] out={a+b,a*c,d*d,c>d,c*2,i>0,i+ in={ i <- i+ 6 Gen={i>0 br i>0 out={a+b,a*c,d*d,c>d,c*2,i>0,i+ a*c c>d c*2 i+ Kill={i+ in={ 7 Exit Lecture 2-74 Seth Copen Goldstein W={6 out={a+b, a*c, d*d Example In={ out={ in={ Entry c<-a+b 2 d<-a*c e<-d*d i <- Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ in={a+b, a*c, d*d f[i] <- a+b Gen={a+b,c>d c <- c*2 out={a+b, d*d, c>d Kill={c*2,M[x],a*c br c>d in={a+b, d*d, c>d in={a+b, d*d, c>d 4Gen={a*c g[i] <- a*c Gen={d*d Kill={M[x] g[i] <- d*d Kill={M[x] out={a+b, d*d, c>d, a*c out={a+b, d*d, c>d in={ i <- i+ 6 Gen={i>0 br i>0 out={a+b,a*c,d*d,c>d,c*2,i>0,i+ a*c c>d c*2 i+ Kill={i+ in={ 7 Exit Lecture 2-74 Seth Copen Goldstein W={,7 out={a+b, a*c, d*d Example In={ out={ in={ Entry c<-a+b 2 d <- a*c e<-d*d i <- Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ in={a+b, a*c, d*d f[i] <- a+b Gen={a+b,c>d c <- c*2 out={a+b, d*d, c>d Kill={c*2,M[x],a*c br c>d in={a+b, d*d, c>d in={a+b, d*d, c>d 4Gen={a*c g[i] <- a*c Gen={d*d Kill={M[x] g[i] <- d*d Kill={M[x] out={a+b, d*d, c>d, a*c out={a+b, d*d, c>d in={a+b, d*d, c>d i <- i+ 6 Gen={i>0 br i>0 out={a+b, d*d, c>d, i>0 Kill={i+ in={ 7 Exit Lecture 2-74 Seth Copen Goldstein W={ out={a+b, a*c, d*d Example In={ out={ in={ Entry c<-a+b 2 d<-a*c e<-d*d i <- Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ in={a+b, d*d f[i] <- a+b Gen={a+b,c>d c <- c*2 out={a+b, d*d, c>d Kill={c*2,M[x],a*c br c>d in={a+b, d*d, c>d in={a+b, d*d, c>d 4Gen={a*c g[i] <- a*c Gen={d*d Kill={M[x] g[i] <- d*d Kill={M[x] out={a+b, d*d, c>d, a*c out={a+b, d*d, c>d in={a+b, d*d, c>d i <- i+ 6 Gen={i>0 br i>0 out={a+b, d*d, c>d, i>0 Kill={i+ in={ 7 Exit Lecture 2-74 Seth Copen Goldstein

13 CSE Calculate Available expressions For every stmt in program If expression, x op y, is available { Compute reaching expressions for x op y at this stmt foreach stmt in RE of the form t <- x op y rewrite at: t <- x op y t <- t replace x op y in stmt with t Lecture 2-74 Seth Copen Goldstein W={ out={a+b, a*c, d*d Example In={ out={ in={ Entry c<-a+b 2 d<-a*c e<-d*d i <- Gen={a+b,a*c,d*d Kill={c>d,c*2,i>0,i+ in={a+b, d*d f[i] <- a+b Gen={a+b,c>d c <- c*2 out={a+b, d*d, c>d Kill={c*2,M[x],a*c br c>d in={a+b, d*d, c>d in={a+b, d*d, c>d 4Gen={a*c g[i] <- a*c Gen={d*d Kill={M[x] g[i] <- d*d Kill={M[x] out={a+b, d*d, c>d, a*c out={a+b, d*d, c>d in={a+b, d*d, c>d i <- i+ 6 Gen={i>0 br i>0 out={a+b, d*d, c>d, i>0 Kill={i+ in={ 7 Exit Lecture 2-74 Seth Copen Goldstein Calculating RE Could be dataflow problem, but not needed enough, so To find RE for x op y at stmt S traverse cfg backward from S until reach t <- x + y (& put into RE) reach definition of x or y Example Entry c<-a+b 2 d<-a*c e<-d*d i <- f[i] <- t ;a+b c <- c*2 br c>d t <- a+b c <- t t2 <- d*d e <- t2 g[i] <- a*c 4 g[i] <- t2 ; d*d i <- i+ 6 br i>0 Exit 7 Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

14 Dataflow Summary Dataflow Framework Forward Backward Union Reaching defs Live variables intersection Available exprs Lattice Universe of values Meet operator Basic attributes (e.g., gen, kill) Traversal order Transfer function Later in course we look at bidirectional dataflow Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Def-Use chains are expensive foo(int i, int j) { switch (i) { case 0: x=;break; case : x=; break; case 2: x=6; break; case : x=7; break; default: x = ; switch (j) { case 0: y=x+7; break; case : y=x+4; break; case 2: y=x-2; break; case : y=x+; break; default: y=x+9; Lecture 2-74 Seth Copen Goldstein Def-Use chains are expensive foo(int i, int j) { switch (i) { case 0: x=; case : x=; case 2: x=6; case : x=7; default: x = ; switch (j) { case 0: y=x+7; case : y=x+4; case 2: y=x-2; case : y=x+; default: y=x+9; In general, N defs M uses O(NM) space and time A solution is to limit each var to ONE def site Lecture 2-74 Seth Copen Goldstein

15 Def-Use chains are expensive foo(int i, int j) { switch (i) { case 0: x=; break; case : x=; break; case 2: x=6; case : x=7; default: x = ; x is one of the above x s switch (j) { A solution is to limit each case 0: y=x+7; var to ONE def site case : y=x+4; case 2: y=x-2; case : y=x+; default: y=x+9; Lecture 2-74 Seth Copen Goldstein Advantages of SSA Makes du-chains explicit Makes dataflow analysis easier Improves register allocation Automatically builds Webs Makes building interference graphs easier For most programs reduces space/time requirements Lecture 2-74 Seth Copen Goldstein SSA Static single assignment is an IR where every variable able is assigned a value at most once in the program text Easy for a basic block: assign to a fresh variable at each stmt. Each use uses the most recently defined var. (Similar to Value Numbering) a x + y b a + x a b + 2 c y + a c + a Straight-line SSA Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

16 Straight-line SSA SSA a x + y b a + x a b + 2 c y + a c + a a x + y b a + x a 2 b + 2 c y + a c + a 2 Static single assignment is an IR where every variable able is assigned a value at most once in the program text Easy for a basic block: assign to a fresh variable at each stmt. Each use uses the most recently defined var. (Similar to Value Numbering) What about at joins in the CFG? Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Merging at Joins c 2 c 2 if (i) { if (i) a x + y b a + x else { a b + 2 c y + a x + y b a + x a b + 2 c y + a 4 c? + a? a c + a SSA Static single assignment is an IR where every variable able is assigned a value at most once in the program text Easy for a basic block: assign to a fresh variable at each stmt. Each use uses the most recently defined var. (Similar to Value Numbering) What about at joins in the CFG? Use a notional fiction: A Φ function Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

17 Merging at Joins a x + y b a + x c 2 if (i) a 2 b + 2 c 2 y + a Φ(a(,a 2 ) c Φ(c,c 2 ) b 2 Φ(b,?) The Φ function Φ merges multiple definitions along multiple control paths into a single definition. At a BB with p predecessors, there are p arguments to the Φ function. x new Φ(x, x, x,, x p ) How do we choose which x i to use? We don t really care! If we care, use moves on each incoming edge a 4 c + a Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Implementing Φ c 2 if (i) a x + a 2 b + 2 y b a + x c 2 y + a a a a 2 c c c 2 c a Φ(a,a 2 ) c Φ(c,c 2 ) a 4 c + a Trivial SSA Each assignment generates a fresh variable. At each join point insert Φ functions for all live variables. x x y x y 2 y x y 2 2 Way too many Φ functions inserted. z y + x x 2 Φ(x,x ) y Φ(y,y 2 ) z y + x 2 Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein

18 Minimal SSA Another Example Each assignment generates a fresh variable. At each join point insert Φ functions for all variables with multiple outstanding defs. a 0 x y x y 2 x y x y 2 2 b a + c c + b a b * 2 a < N z y + x y Φ(y,y 2 ) z y + x return c Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Another Example a 0 a 0 Notice use of c a Φ(a,a 2 ) b a + c Φ(c,c 2 ) c c + b b 2 a + a b * 2 c 2 c + b 2 a < N a 2 b 2 * 2 < N return c return c 2 Lecture 2-74 Seth Copen Goldstein a 2 Lets optimize the following: i=; j=; k=0; while (k<00) { if (j<20) { j=i; k++; else { j=k; k+=2; return j; i j k 0 2 k < 00? j < 20? 4 return j j i 6 j k k k + k k + 2 Lecture 2-74 Seth Copen Goldstein

19 i j k 0 First, turn into SSA 4 i j k 0 2 k < 00? 2 k < 00? j < 20? j i k k + return j 6 j k k k + 2 j < 20? j i k k + 4 return j 6 j k k k + 2 i j k 0 Properties of SSA Only assignment per variable definitions dominate j 2 Φ(j 4,j ) uses 2 k 2 Φ(k 4,k ) k 2 < 00? Can we use this to help with constant propagation? j i 6 j k 2 k k 2 + k k j 4 Φ(j,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Constant Propagation If v c, replace all uses of v with c If v Φ(c,c,c) replace all uses of v with c W <- list of all defs while!w.isempty { Stmt S <- W.removeOne if S has form v <- Φ(c,,c) replace S with V <- c if S has form v <- c then delete S foreach stmt U that uses v, replace v with c in U W.add(U) Lecture 2-74 Seth Copen Goldstein Other stuff we can do? Copy propagation delete x Φ(y) and replace all x with y delete x y and replace all x with y Constant Folding (Also, constant conditions too!) Unreachable Code Remember to delete all edges from unreachable block Lecture 2-74 Seth Copen Goldstein

20 Constant Propagation Constant Propagation i j k 0 i j k 0 j 2 Φ(j 4,j ) 2 k 2 Φ(k 4,k ) k 2 < 00? j 2 Φ(j 4,) 2 k 2 Φ(k 4,k ) k 2 < 00? j i k k j k 2 k k j 6 k k 2 + j k 2 k k j 4 Φ(j,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein j 4 Φ(j,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein Constant Propagation Constant Propagation i j k 0 i j k 0 j 2 Φ(j 4,) 2 k 2 Φ(k 4,k ) k 2 < 00? 2 j 2 k 2 Φ(j 4,) Φ(k 4,0) k 2 < 00? But, so what? You will have to wait til next time :) j k k j k 2 k k j k k j k 2 k k j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein

21 Summary Dataflow framework Lattice, meet, direction, transfer function, initial values Du-chains chains, ud-chains CSE SSA One static definition per variable Φ-functions Conditional Constant Propagation i j k 0 j 2 Φ(j 4,) Does block 6 ever execute? Simple CP can t tell 2 k 2 Φ(k 4,0) CCP can tell: k 2 < 00? Assumes blocks don t execute until proven otherwise Assumes Values are constants until proven j 6 j k 2 otherwise k k 2 + k k j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Tracks: - Blocks (assume unexecuted until proven otherwise) - Variables (assume not executed, only with proof of assignments of a non-constant value do we assume not constant) Use a lattice for variables: TOP = we have evidence that variable can hold different values at different times integers = we have seen evidence that t the var has been assigned a constant with the value BOT = not executed Lecture 2-74 Seth Copen Goldstein Conditional Constant Propagation i j k 0 j 2 Φ(j 4,) 2 k 2 Φ(k 4,0) k 2 < 00? j 6 k k j k 2 k k j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein

22 Conditional Constant Propagation i j k 0 Conditional Constant Propagation i j k 0 j 2 Φ(j 4,) 2 k 2 Φ(k 4,0) k 2 < 00? j 6 k k 2 + j k 2 k k j 2 Φ(j 4,) 2 k 2 Φ(k 4,0) k 2 < 00? j 6 k k 2 + j k 2 k k j 4 Φ(,j ) k 4 Φ(k,k ) 7 j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein Lecture 2-74 Seth Copen Goldstein Conditional Constant Propagation i j k 0 Conditional Constant Propagation i j k 0 j 2 Φ(j 4,) 2 k 2 Φ(k 4,0) k 2 < 00? j 6 k k 2 + j k 2 k k j 2 Φ(j 4,) k 2 TOP 2 Φ(k 4,0) k 2 < 00? j 6 k k 2 + j k 2 k k j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein

23 Conditional Constant Propagation i j k 0 i j k 0 CCP j 2 Φ(j 4,) k 2 TOP 2 Φ(k 4,0) k 2 < 00? j 6 k k j k 2 k k j 4 Φ(,j ) k 4 Φ(k,k ) Lecture 2-74 Seth Copen Goldstein j 2 Φ(j,j ) 2 k 2 Φ(k 4,k ) k < 00? j i 6 j k 2 k k 2 + k k j 4 Φ(j,j ) k 4 Φ(k,k ) k 2 Φ(k,0) k 2 < 00? k k 2 + return Lecture 2-74 Seth Copen Goldstein