Lecture 2 Introduction to Data Flow Analysis

I. Introduction II. Example: Reaching definition analysis III.Example: Liveness analysis IV. A General Framework
(Theory in next lecture)

Reading: Chapter 9.2

Carnegie Mellon M. Lam CS243: Intro to Data Flow 1

I. Compiler Organization

Carnegie Mellon CS243: Intro to Data Flow 2 M. Lam

Flow Graph
Basic block = a maximal sequence of consecutive instructions s.t. flow of control only enters at the beginning flow of control can only leave at the end (no halting or branching except perhaps at end of block) Flow Graphs Nodes: basic blocks Edges

Bi --> Bj, iff Bj can follow Bi immediately in execution

Carnegie Mellon CS243: Intro to Data Flow 3 M. Lam

What is Data Flow Analysis?

Data flow analysis: Flow-sensitive: sensitive to the control flow in a function intraprocedural analysis Examples of optimizations: Constant propagation Common subexpression elimination Dead code elimination
a = b + c d = 7 e = b + c e = d+3 g = a a = 243

Value of x? Which definition defines x? Is the definition still meaningful (live)?

Carnegie Mellon CS243: Intro to Data Flow 4 M. Lam

Static Program vs. Dynamic Execution

Statically: Finite program Dynamically: Can have infinitely many possible execution paths Data flow analysis abstraction:
For each point in the program: combines information of all the instances of the same program point.

Example of a data flow question: Which definition defines the value used in statement b = a?
Carnegie Mellon CS243: Intro to Data Flow 5 M. Lam

Reaching Definitions
B0 d0: y = 3
d1: x = 10 d2: y = 11 if e

B1 d3: x = 1
d4: y = 2

d5: z = x d6: x = 4

B2

Every assignment is a definition A definition d reaches a point p if there exists path from the point immediately following d to p such that d is not killed (overwritten) along that path. Problem statement For each point in the program, determine if each definition in the program reaches the point A bit vector per program point, vector-length = #defs
Carnegie Mellon CS243: Intro to Data Flow 6 M. Lam

Data Flow Analysis Schema

Build a flow graph (nodes = basic blocks, edges = control flow) Set up a set of equations between in[b] and out[b] for all basic blocks b Effect of code in basic block: Effect of flow of control:
Transfer function fb relates in[b] and out[b], for same b relates out[b1], in[b2] if b1 and b2 are adjacent
Carnegie Mellon CS243: Intro to Data Flow 7 M. Lam

Find a solution to the equations

Effects of a Statement
in[B0]
d0: y = 3 d1: x = 10 d2: y = 11

fd0 fd1 fd2

out[B0]

fs : A transfer function of a statement abstracts the execution with respect to the problem of interest For a statement s (d: x = y + z) out[s] = fs(in[s]) = Gen[s] U (in[s]-Kill[s]) Gen[s]: definitions generated: Gen[s] = {d} Propagated definitions: in[s] - Kill[s], where Kill[s]=set of all other defs to x in the rest of program
Carnegie Mellon CS243: Intro to Data Flow 8 M. Lam

Effects of a Basic Block

in[B0]
d0: y = 3 d1: x = 10

fd0 fd1 fB = fd1fd0

out[B0]
Transfer function of a statement s: out[s] = fs(in[s]) = Gen[s] U (in[s]-Kill[s]) Transfer function of a basic block B: Composition of transfer functions of statements in B out[B] = fB(in[B]) = fd1fd0(in[B]) = Gen[d1] U (Gen[d0] U (in[B]-Kill[d0]))-Kill[d1]) = (Gen[d1] U (Gen[d0] - Kill[d1])) U in[B] - (Kill[d0] U Kill[d1]) = Gen[B] U (in[B] - Kill[B]) Gen[B]: locally exposed definitions (available at end of bb) Kill[B]: set of definitions killed by B
CS243: Intro to Data Flow 9 Carnegie Mellon M. Lam

Effects of the Edges (acyclic)

Join node: a node with multiple predecessors meet operator (): U in[b] = out[p1] U out[p2] U ... U out[pn], where p1, ..., pn are all predecessors of b
Carnegie Mellon CS243: Intro to Data Flow 10 M. Lam

Cyclic Graphs

Equations still hold out[b] = fb(in[b]) in[b] = out[p1] U out[p2] U ... U out[pn], p1, ..., pn pred. Find: fixed point solution
Carnegie Mellon CS243: Intro to Data Flow 11 M. Lam

Reaching Definitions: Iterative Algorithm

input: control flow graph CFG = (N, E, Entry, Exit) // Boundary condition out[Entry] = // Initialization for iterative algorithm For each basic block B other than Entry out[B] = // iterate While (Changes to any out[] occur) { For each basic block B other than Entry { in[B] = (out[p]), for all predecessors p of B out[B] = fB(in[B]) // out[B]=gen[B](in[B]-kill[B]) }

Carnegie Mellon CS243: Intro to Data Flow 12 M. Lam

Summary of Reaching Definitions

Reaching Definitions Domain Transfer function fb(x) Sets of definitions forward: out[b] = fb(in[b]) fb(x) = Genb (x -Killb) Genb: definitions in b Killb: killed defs in[b]= out[predecessors] out[entry] = out[b] =

Meet Operation Boundary Condition Initial interior points

Carnegie Mellon CS243: Intro to Data Flow 13 M. Lam

III. Live Variable Analysis

Definition A variable v is live at point p if
the value of v is used along some path in the flow graph starting at p.

Otherwise, the variable is dead. Problem statement For each basic block
determine if each variable is live in each basic block

Size of bit vector: one bit for each variable

Carnegie Mellon CS243: Intro to Data Flow 14 M. Lam

Effects of a Basic Block (Transfer Function)

Observation: Trace uses back to the definitions

Direction: backward: in[b] = fb(out[b]) Transfer function for statement s: x = y + z

generate live variables: Use[s] = {y, z} propagate live variables: out[s] - Def[s], Def[s] = x in[s] = Use[s] (out(s)-Def[s])

Transfer function for basic block b:

in[b] = Use[b] (out(b)-Def[b]) Use[b], set of locally exposed uses in b, uses not covered by definitions in b Def[b]= set of variables defined in b.
Carnegie Mellon CS243: Intro to Data Flow 15 M. Lam

Across Basic Blocks

Meet operator (): out[b] = in[s1] in[s2] ... in[sn], s1, ..., sn are successors of b Boundary condition:

Carnegie Mellon CS243: Intro to Data Flow 16 M. Lam

Example

Carnegie Mellon CS243: Intro to Data Flow 17 M. Lam

Liveness: Iterative Algorithm

input: control flow graph CFG = (N, E, Entry, Exit) // Boundary condition in[Exit] = // Initialization for iterative algorithm For each basic block B other than Exit in[B] = // iterate While (Changes to any in[] occur) { For each basic block B other than Exit { out[B] = (in[s]), for all successors s of B in[B] = fB(out[B]) // in[B]=Use[B](out[B]-Def[B]) }

Carnegie Mellon CS243: Intro to Data Flow 18 M. Lam

IV. Framework
Reaching Definitions Domain Direction Sets of definitions forward: out[b] = fb(in[b]) in[b] = out[pred(b)] fb(x) = Genb (x Killb) out[entry] = out[b] = Live Variables Sets of variables backward: in[b] = fb(out[b]) out[b] = in[succ(b)] fb(x) = Useb (x -Defb) in[exit] = in[b] =

Transfer function Meet Operation () Boundary Condition Initial interior points

Carnegie Mellon CS243: Intro to Data Flow 19 M. Lam

Thought Problem 1. Must-Reach Definitions

A definition D (a = b+c) must reach point P iff D appears at least once along on all paths leading to P a is not redefined along any path after last appearance of D and before P How do we formulate the data flow algorithm for this problem?

Carnegie Mellon CS243: Intro to Data Flow 20 M. Lam

10

Problem 2: A legal solution to (May) Reaching Def?

Will the worklist algorithm generate this answer?

Carnegie Mellon CS243: Intro to Data Flow 21 M. Lam

Problem 3. What are the algorithm properties?

Correctness

Precision: how good is the answer?

Convergence: will the analysis terminate?

Speed: how long does it take?

Carnegie Mellon CS243: Intro to Data Flow 22 M. Lam

11