Dataflow Analysis Lecture 2. Simple Constant Propagation. A sample program int fib10(void) {

Transcription

1 -4 Lecture Dataflow Analysis Basic Blocks Related Optimizations Copyright Seth Copen Goldstein 00 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 -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 A sample program int fib0(void) { } int n = 0; int older = 0; int old = ; intwhat result are = those 0; numbers? int i; if (n <= ) return n; for (i = ; i<n; i++) { result = old + older; older = old; old = result; } return result; A Comment about the IR : n <- 0 : older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- : if i > n goto 8: result <- old + older 9: older <- old 0: old <- result : i <- i + : JUMP : return result 4: return n Lecture -4 Seth Copen Goldstein 00 Simple Constant Propagation Can we do SCP? How do we recognize it? What aren t we doing? Metanote: keep opts simple! Use combined power : n <- 0 : older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- : if i > n goto 8: result <- old + older 9: older <- old 0: old <- result : i <- i + : JUMP : return result 4: return n Lecture -4 Seth Copen Goldstein 00 4

2 Reaching Definitions A definition 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 <- 0 : older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- : if i > n goto 8: result <- old + older 9: older <- old 0: old <- result : i <- i + : JUMP : return result 4: return n Lecture -4 Seth Copen Goldstein 00 Reaching Definitions (ex) reaches,, and 4 reaches 4, Really? 8 Meta-notes: Older in 8 is reached by (almost) always conservative only know what we know Keep 9it simple: What opt(s), if run before this would help Tells What us about: which definitions : x <- 0reach a : if (false) x<- particular use (ud-info) : x Does reach? What opt changes this? : n <- 0 : older <- 0 : old <- 4: result <- 0 : if n <= goto 4 6: i <- : if i > n goto 8: result <- old + older 9: older <- old 0: old <- result : i <- i + : JUMP : return result 4: return n Lecture -4 Seth Copen Goldstein 00 6 Calculating Reaching Definitions A definition 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 -4 Seth Copen Goldstein 00 Gen and kill for each stmt Gen : n <- 0 : older <- 0 9 : old <- 0 4: result < : if n <= goto 4 6: i <- 6 : if i > n goto 8: result <- old + older 8 4 9: older <- old 9 0: old <- result 0 : i <- i + 6 : JUMP : return result 4: return n Lecture -4 Seth Copen Goldstein 00 8 kill How can we determine the defs that reach a node? We can use: control flow information gen and kill info

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

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

5 BB sets BB sets Gen={,,,4} Kill={8,9,0} In out,,,4 Gen={,,,4} Kill={8,9,0} In out,,,4 Gen={6} Kill={} Gen={6} Kill={},,,4,,,4, ,6,8- -4,6,8-6 Gen={8,9,0,} Kill={,,4,6} Gen={8,9,0,} Kill={,,4,6} 6-4,6,8-,8- Lecture -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 8 Forward Dataflow 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 How to implement? Values? Gen? Kill? F bb? Order to visit nodes? When are we done? In fact, do we know we terminate? Lecture -4 Seth Copen Goldstein 00 9 Lecture -4 Seth Copen Goldstein 00 0

6 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 nodes? Does it matter? 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 -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 Storing Rd information Def-use chains are valuable too Use-def chains: for each use of var x in s, a list of definitions of x that reach s : n <- 0 : older <- 0, : old <-,,, 4: result < : if n <= goto : i <- -4-4,6 : 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- : JUMP,8-,8- : return result -4,6-4,6 4: return n -4-4 Lecture -4 Seth Copen Goldstein 00 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 is NOT symmetric to use-def z > x <- z > y x <- y <- x + z <- x + Lecture -4 Seth Copen Goldstein 00 4

7 Using RD for Simple Const. Prop. : n <- 0 : older <- 0, : old <-,,, 4: result < : if n <= goto : i <- -4-4,6 : 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- : JUMP,8-,8- : return result -4,6-4,6 4: return n -4-4 Better Constant Propagation What about: x <- if (y > z) x <- a <- x Lecture -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 6 Better Constant Propagation Loop Invariant Code Motion What about: x <- if (y > z) x <- a <- x Use a better lattice -inf inf When can expression be moved out of a loop? x <- y + z Meet: a <- a top bot <- a bot c <- c c bot <- c d ( if c d) Init all vars to: bot or top? a <-.. x.. Lecture -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 8

8 Loop Invariant Code Motion Liveness (def-use chains) 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.. 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 -4 Seth Copen Goldstein 00 9 Lecture -4 Seth Copen Goldstein 00 0 Liveness as a dataflow problem Dead Code Elimination 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 = U In[ s] Code is dead if it has no effect on the outcome of the program. When is code dead? s succ( n) Lecture -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00

9 Dead Code Elimination When can we do CSE? 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? a <- 4 + i b <- 4 + i Lecture -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 4 Available Expressions 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 a <- b+c b <- a-d c <- b+c Computing Available Expressions Forward or backward? Values? Lattice? gen[b] = kill[b] = in[b] = out[b] = initialization? d <- a-d Lecture -4 Seth Copen Goldstein 00 Lecture -4 Seth Copen Goldstein 00 6

10 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 -4 Seth Copen Goldstein 00 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 is set to NONE avail Lecture -4 Seth Copen Goldstein 00 8 Constructing Gen & Kill Constructing Gen & Kill Stmt Gen Kill Stmt Gen Kill t <- x op y {x op y}-kill[s] {exprs containing t} t <- x op y {x op y}-kill[s] {exprs containing t} t <- M[a] {M[a]}-kill[s] t <- M[a] {M[a]}-kill[s] {exprs containing t} M[a] <- b M[a] <- b {} {for all x, M[x]} f(a, ) {M[x] for all x} f(a, ) {} {for all x, M[x]} t <- f(a, ) t <- f(a, ) {} {exprs containing t for all x, M[x]} Lecture -4 Seth Copen Goldstein 00 9 Lecture -4 Seth Copen Goldstein 00 40

11 i <- c <- c* i <- c <- c* Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} g[i] <- a*c g[i] <- d*d g[i] <- a*c Gen={a*c} g[i] <- d*d Gen={d*d} i <- i+ br i>0 i <- i+ br i>0 Gen={i>0} Kill={i+} Lecture -4 Seth Copen Goldstein 00 4 Lecture -4 Seth Copen Goldstein 00 4 W={} In={} out={} out={a+b, a*c, d*d, c>d, c*, i>0, i+} out={a+b,a*c,d*d,c>d,c*,i>0,i+} out={a+b,a*c,d*d,c>d,c*,i>0,i+} i <- c <- c* 4Gen={a*c} g[i] <- a*c g[i] <- d*d out={a+b,a*c,d*d,c>d,c*,i>0,i+} i <- i+ 6 br i>0 Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} Gen={i>0} Kill={i+} Gen={d*d} Lecture -4 Seth Copen Goldstein 00 4 W={} out={a+b, a*c, d*d} In={} out={} out={a+b,a*c,d*d,c>d,c*,i>0,i+} out={a+b,a*c,d*d,c>d,c*,i>0,i+} i <- c <- c* 4Gen={a*c} g[i] <- a*c g[i] <- d*d out={a+b,a*c,d*d,c>d,c*,i>0,i+} i <- i+ 6 br i>0 Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} Gen={i>0} Kill={i+} Gen={d*d} Lecture -4 Seth Copen Goldstein 00 44

12 W={6} out={a+b, a*c, d*d} In={} out={} in={a+b, a*c, d*d} i <- c <- c* Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} 4Gen={a*c} g[i] <- a*c Gen={d*d} g[i] <- d*d out={a+b, d*d, c>d, a*c} i <- i+ 6 Gen={i>0} br i>0 out={a+b,a*c,d*d,c>d,c*,i>0,i+} Kill={i+} Lecture -4 Seth Copen Goldstein 00 4 W={,} out={a+b, a*c, d*d} In={} out={} in={a+b, a*c, d*d} i <- c <- c* Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} 4Gen={a*c} g[i] <- a*c Gen={d*d} g[i] <- d*d out={a+b, d*d, c>d, a*c} i <- i+ 6 Gen={i>0} br i>0 out={a+b, d*d, c>d, i>0} Kill={i+} Lecture -4 Seth Copen Goldstein W={} out={a+b, a*c, d*d} in={a+b, d*d} In={} out={} i <- c <- c* Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} 4Gen={a*c} g[i] <- a*c Gen={d*d} g[i] <- d*d out={a+b, d*d, c>d, a*c} i <- i+ 6 Gen={i>0} br i>0 out={a+b, d*d, c>d, i>0} Kill={i+} Lecture -4 Seth Copen Goldstein 00 4 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 -4 Seth Copen Goldstein 00 48

13 W={} out={a+b, a*c, d*d} in={a+b, d*d} In={} out={} i <- c <- c* Gen={a+b,a*c,d*d} Kill={c>d,c*,i>0,i+} Gen={a+b,c>d} Kill={c*,M[x],a*c} 4Gen={a*c} g[i] <- a*c Gen={d*d} g[i] <- d*d out={a+b, d*d, c>d, a*c} i <- i+ 6 Gen={i>0} br i>0 out={a+b, d*d, c>d, i>0} Kill={i+} Lecture -4 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 Lecture -4 Seth Copen Goldstein 00 0 i <- f[i] <- t ;a+b c <- c* 4 g[i] <- a*c g[i] <- t ; d*d t <- a+b c <- t t <- d*d e <- t Forward Backward Dataflow Summary Union Reaching defs Live variables intersection Available exprs i <- i+ 6 br i>0 Lecture -4 Seth Copen Goldstein 00 Later in course we look at bidirectional dataflow Lecture -4 Seth Copen Goldstein 00

14 Dataflow Framework Lattice Universe of values Meet operator Basic attributes (e.g., gen, kill) Traversal order Transfer function Lecture -4 Seth Copen Goldstein 00