Optimizing Compilers CISC 673 Spring 2009 Data flow analysis John Cavazos University of Delaware

Data flow analysis Solving set of equations posed over graph representation (e.g., CFG) Based on any or all paths through program “Any path” or “All path” problems

Includes Infeasible Paths if (a == 0) { } a = 2; Infeasible paths never actually taken by program, regardless of input Undecidable to distinguish from feasible

Data Flow-Based Optimizations Dead variable elimination a = 3; print a; x = 12; halt ) a = 3; print a; halt Copy propagation x = y; … use of x ) …use of y Partial redundancy a = 3*c + d; b = 3*c ) b = 3*c; a=b+d Constant propagation a = 3; b = 2; c = a+b ) a = 3; b = 2; c = 5

Example: Redundancy Elimination Expression e at point p redundant iff every path from procedure’s entry to p contains evaluation of e and value(s) of e’s operands do not change between those earlier evaluations and p Evaluating e at p always produces the same value as those earlier evaluations

Example m  a + b n  a + b A p  c + d r  c + d B q  a + b C

Redundancy Elimination If the compiler can prove expression redundant Replace redundant evaluation with reference Problem Proving x+y is redundant Eliminate redundant evaluation Can use value numbering

Value Numbering Key notion Assign a number, V(n), to each expression V(x+y) = V(j) iff x+y and j have same value  inputs Hash value numbers to make efficient Use numbers to improve the code

Local  one block at a time Local Value Numbering Local  one block at a time The algorithm For each expression e in the block Get value numbers for operands o1 and o2 from hash lookup Hash <operator,VN(o1),VN(o2)> to get value number for e If e already had a value number, replace e with a reference If o1 & o2 are constant, evaluate it & use a “load immediate”

Local Value Numbering Example Original Code a0  x0 + y0  b0  x0 + y0 a1  17  c0  x0 + y0 1. Renaming: Give each value a unique name While complex, the meaning is clear With VNs a03  x01 + y02  b03  x01 + y02 a14  17  c03  x01 + y02 Rewritten a03  x01 + y02  b03  a03 a14  17  c03  a03 2. Result: a03 is available rewriting works

Global Redundancy Elimination u  e + f D E x  e + f F e+f is redundant Find common subexpressions whose range spans basic blocks, and eliminate unnecessary re-evaluations

Expression “available” is as follows: Expression defined at point p if value computed at p Expression killed at point p if one or more operands defined at point p e available at p if every path leading to p contains a prior definition of e and e is not killed between definition and p

“Available” Expressions for GCSE Mechanism System of simultaneous equations over the CFG Solve the equations to produce a set for each CFG node Contains names of every expression available on entry Use these sets, AVAIL(n), for redundancy elimination Safety x+y  AVAIL(n) proves earlier value x+y is same Transformation provides name for each value Several schemes for this mapping

“Available” Expressions for GCSE Profitability Don’t add any evaluations Add some copy operations Copies are inexpensive Many copies coalesce away

Computing Available Expressions For each block b Let AVAIL(b) be the set of expressions available on entry to b AVAIL constructed from local sets Let EXPRKILL(b) be the set of expression killed in b Let DEEXPR(b) be the set of downward exposed expressions x  DEEXPR(b)  x defined in b & not subsequently killed in b EXPRKILL contains all those equations “killed” by a definition in b. An expression is killed if one or more of its operands are redefined in the block. If e is in DEEXPR(b) iff b evaluates e and none of e’s operands is defined between the last evaluation of e and the block’s end. DEEXPR contains those expressions that are downward exposed.

Computing Available Expressions Now, AVAIL(b) can be defined as: AVAIL(b) = ppred(b) (DEEXPR(p)  (AVAIL(p)  EXPRKILL(p) )) AVAIL(n0) = Ø where preds(b) is the set of b’s predecessors in the CFG This system of simultaneous equations forms a data-flow problem Solve it with a data-flow algorithm Entry node in CFG is n0

Computing Available Expressions AVAIL(b) = ppred(b) (DEEXPR(p)  (AVAIL(p)  EXPRKILL(p) )) Basic Block p … DEEXPR (p) Downward exposed expressions And not later killed

Computing Available Expressions AVAIL(b) = ppred(b) (DEEXPR(p)  (AVAIL(p)  EXPRKILL(p) )) AVAIL(p) Available upon entry Basic Block p … EXPRKILL(p) Any expresssions killed AVAIL(p)  EXPRKILL(p) Expressions that Pass through unscathed

Available Expressions for GCSE The Big Picture  block b, compute AVAIL(b) Assign unique global names to expressions in AVAIL(b)  block b, value number b starting with AVAIL(b)

Compute Local Sets for each Block b assume a block b with operations o1, o2, …, ok VARKILL  Ø DEEXPR(b)  Ø for i = k to 1 // from last to first insts assume oi is “x  y + z” add x to VARKILL if (y  VARKILL) and (z  VARKILL) then add “y + z” to DEEXPR(b) EXPRKILL(b)  Ø For each expression e in procedure for each variable v  e if v  VARKILL(b) then EXPRKILL(b)  EXPRKILL(b)  {e } } Compute DEExpr Compute ExprKill

Example v  a + b a  c + d x  e + f DEExpr = {c+d,e+f } VarKill = {y,a,x} ExprKill = {a+b}

Compute Available Expressions for all blocks b compute DEExpr(b) and EXPRKILL(b) Changed=true while (Changed) Changed=false OldValue = AVAIL(b) AVAIL(b) = ppred(b) (DEEXPR(p)  (AVAIL(p)  EXPRKILL(p) )) if AVAIL(b ) != OldValue Changed=true

Example: Compute DEEXPR m  a + b n  a + b A p  c + d r  c + d B y  a + b z  c + d G q  a + b C e  b + 18 s  a + b u  e + f D e  a + 17 t  c + d E v  a + b w  c + d x  e + f F assume a block b with operations o1, o2, …, ok VARKILL  Ø DEEXPR(b)  Ø for i = k to 1 // from last to first insts assume oi is “x  y + z” add x to VARKILL if (y  VARKILL) and (z  VARKILL) then add “y + z” to DEEXPR(b) =

Example: Compute EXPRKILL m  a + b n  a + b A p  c + d r  c + d B y  a + b z  c + d G q  a + b C e  b + 18 s  a + b u  e + f D e  a + 17 t  c + d E v  a + b w  c + d x  e + f F EXPRKILL(b)  Ø For each expression e in procedure for each variable v  e if v  VARKILL(b) then EXPRKILL(b)  EXPRKILL(b)  {e }

ppred(b) (DEEXPR(p)  (AVAIL(p)  EXPRKILL(p) )) Example ppred(b) (DEEXPR(p)  (AVAIL(p)  EXPRKILL(p) )) AVAIL(A) = Ø AVAIL(B) = {a+b}  (Ø  all) = {a+b} AVAIL(C) = {a+b} AVAIL(D) = {a+b,c+d}  ({a+b}  all) = {a+b,c+d} AVAIL(E) = {a+b,c+d} AVAIL(F) = [{b+18,a+b,e+f}  ({a+b,c+d}  {all - e+f})]  [{a+17,c+d,e+f}  = {a+b,c+d,e+f} AVAIL(G)= [ {c+d}  ({a+b}  all)]  [{a+b,c+d,e+f}  ({a+b,c+d,e+f}  all)] m  a + b n  a + b A p  c + d r  c + d B y  a + b z  c + d G q  a + b C e  b + 18 s  a + b u  e + f D e  a + 17 t  c + d E v  a + b w  c + d x  e + f F

Example  AVAIL sets in blue A B G C D E F { a+b } { a+b } { a+b,c+d } m  a + b n  a + b A p  c + d r  c + d B y  a + b z  c + d G q  a + b C e  b + 18 s  a + b u  e + f D e  a + 17 t  c + d E v  a + b w  c + d x  e + f F { a+b } { a+b } { a+b,c+d } { a+b,c+d } { a+b,c+d,e+f } { a+b,c+d }

Remember Big Picture The Big Picture  block b, compute AVAIL(b) Assign unique global names to expressions in AVAIL(b)  block b, value number b starting with AVAIL(b) We’ve done step 1.

Global CSE (replacement step) Compute a static mapping from expression to name After analysis & before transformation  b, e  AVAIL(b), assign e a global name by hashing on e

Assigning unique names to global CSEs Example  Assigning unique names to global CSEs a+b  t1 c+d  t2 e+f  t3 m  a + b n  a + b A p  c + d r  c + d B y  a + b z  c + d G q  a + b C e  b + 18 s  a + b u  e + f D e  a + 17 t  c + d E v  a + b w  c + d x  e + f F { a+b } { a+b } { a+b,c+d } { a+b,c+d } { a+b,c+d,e+f } { a+b,c+d }

Remember the Big Picture  block b, compute AVAIL(b) Assign unique global names to expressions in AVAIL(b)  block b, value number b starting with AVAIL(b) We’ve done steps 1 & 2.

Value Numbering To perform replacement, value numbering each block b Initialize hash table with AVAIL(b) Replace an expression in AVAIL(b) means copy from its name At each evaluation of a global name, copy new value to its name Otherwise, value number as in last lecture

Net Result Catches local redundancies with value numbering Catches nonlocal redundancies because of AVAIL sets Not quite same effect, but close Local redundancies found by value Global redundancies found by spelling

After replacement & local value numbering Example m  a + b t1  m n  t1 A p  c + d t2  p r  t2 B y  t1 z  t2 G q  t1 r  c + d t2  r C e  b + 18 s  t1 u  e + f t3  u D e  a + 17 t  t2 E v  t1 w  t2 x  t3 F After replacement & local value numbering

Example m  a + b t1  m n  t1 A p  c + d t2  p r  t2 B y  t1 z  t2 G q  t1 r  c + d t2  r C e  b + 18 s  t1 u  e + f t3  u D e  a + 17 t  t2 E v  t1 w  t2 x  t3 F In practice, most of these copies will be folded into subsequent uses… m m p m r m r u m r

Some Copies Serve a Purpose In the example, all the copies coalesce away. Sometimes, the copies are needed. Copies into t1 create a common name along two paths Makes the replacement possible w  a + b t1  w x  a + b t1  x y  t1 w  a + b x  a + b y  a + b  Cannot write “w or x”

Example A B G C D E F m  a + b n  a + b p  c + d r  c + d y  a + b z  c + d G q  a + b C e  b + 18 s  a + b u  e + f D e  a + 17 t  c + d E v  a + b w  c + d x  e + f F LVN GRE LVN GRE GRE GRE GRE GRE GRE GRE

Next Time More Data Flow