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

2. 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

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

4. 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

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

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

7. 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

8. 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

9. 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”

10. 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

11. 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

12. 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

13. “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

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

15. 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.

16. 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

17. 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

18. 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

19. 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)

20. 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

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

22. 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

23. 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) =

24. 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 }

25. 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

26. 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 }

27. 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.

28. 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

29. 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 }

30. 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.

31. 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

32. 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

33. 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

34. 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

35. 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”

36. 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

37. Next Time
More Data Flow