Lecture 2. Introduction to Data Flow Analysis

Transcription

1 Lecture 2 Introduction to Data Flow Analysis I II III Example: Reaching definition analysis Example: Liveness Analysis A General Framework (Theory in next lecture) Reading: Chapter 9.2 Advanced Compilers M. Lam

2 Data flow analysis: Data Flow Analysis properties of data taken into consideration the control flow in a function (also known as flow-sensitive analysis) intraprocedural analysis Examples of optimizations: Constant propagation Common subexpression elimination Dead code elimination e=b+c a=b+c d=7 e=d+3 g=a a=243 Value of x? Which definition defines x? Is the definition still meaningful (live)? Advanced Compilers 2 L2:Intro to data flow

3 I. Static program vs. dynamic execution B1 a = 10 B2 if input() exit B3 b = a a = 11 Statically: Finite program Dynamically: Can have infinitely many possible execution paths Data flow analysis abstraction: For each static point in the program: combines information of all the dynamic instances of the same program point. Example of a data flow question: Which definition defines the value used in statement b = a? Advanced Compilers 3 L2:Intro to data flow

4 Reaching Definitions B0 d0: y = 3 d1: x = 10 d2: y = 11 if e B1 d3: x = 1 d5: z = x d4: y = 2 d6: x = 4 B2 Every assignment is a definition A definition d reaches a point p if there exists a 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 Advanced Compilers 4 L2:Intro to data flow

5 Data Flow Analysis Schema out[entry] in[1] out[1] entry f 1 in[2] in[3] out[2] f 2 exit f 3 in[exit] out[3] 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: Transfer function f b relates in[b] and out[b], for same b Effect of flow of control: relates out[b 1 ], in[b 2 ] if b 1 and b 2 are adjacent Find a solution to the equations Advanced Compilers 5 L2:Intro to data flow

6 Effects of a Basic Block in[b0] d 0 : y = 3 f d0 d 1 : x = 10 f d1 f B = f d2 o f d1 o f d0 out[b0] d 2 : y = 11 f d2 A statement s (d: x = y + z) out[s] = f s (in[s]) = Gen[s] U (in[s]-kill[s]) Gen[s]: definitions generated: Gen[s] = {d} in[s]-kill[s] : propagated definitions: in[s] - Kill[s], where Kill[s]=set of all other defs to x in rest of program out[b] = f d2 f d1 f d0 (in[b]) =Gen[d 2 ] U (Gen[d 1 ] U (Gen[d 0 ] U (in[b]-kill[d 0 ]))-Kill[d 1 ])) -Kill[d 2 ] = Gen[d 2 ] U (Gen[d 1 ] U (Gen[d 0 ] - Kill[d 1 ]) - Kill[d 2 ]) U in[b] - (Kill[d 0 ] U Kill[d 1 ] U Kill[d 2 ]) = 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 Advanced Compilers 6 L2:Intro to data flow

7 Effects of the Edges (acyclic) out[entry] entry in[1] out[1] f 1 in[2] out[2] f 2 f 3 in[3] out[3] exit in[exit] Join node: a node with multiple predecessors meet operator ( ): in[b] = out[p 1 ] out[p 2 ]... out[p n ], where p 1,..., p n are predecessors of b Advanced Compilers 7 L2:Intro to data flow

8 Cyclic Graphs out[entry] entry in[1] d1: a = 10 out[1] in[2] out[2] if e in[exit] exit in[3] d2: a = 11 out[3] Equations still hold out[b] = f b (in[b]) in[b] = out[p 1 ] out[p 2 ]... out[p n ], p 1,..., p n pred. Find: fixed point solution Advanced Compilers 8 L2:Intro to data flow

9 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] = f B (in[b]) // out[b]=gen[b] (in[b]-kill[b]) } Advanced Compilers 9 L2:Intro to data flow

10 Summary of Reaching Definitions Domain Transfer function f b (x) Meet Operation Reaching Definitions Sets of definitions forward: out[b] = f b (in[b]) f b (x) = Gen b (x -Kill b ) Gen b : definitions in b Kill b : killed defs Boundary Condition out[entry] = Initial interior points out[b] = in[b]= out[predecessors] Advanced Compilers 10 L2:Intro to data flow

11 II. 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 b, determine if each variable is live at the start/end point of b Size of bit vector: one bit for each variable Advanced Compilers 11 L2:Intro to data flow

12 Effects of a Basic Block (Transfer Function) Observation:Trace uses back to the definitions def def use example: m = n+q p = m in[b] b out[b] = f b (out[b]) f b Direction: backward: in[b] = f b (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.b. Advanced Compilers 12 L2:Intro to data flow

13 Across Basic Blocks Meet operator ( ): out[b] = in[s 1 ] in[s 2 ]... in[s n ], s 1,..., s n are successors of b Boundary condition: Advanced Compilers 13 L2:Intro to data flow

14 Example out[entry] in[1] out[1] entry n = p if g in[2] out[2] r = n+r m = n+q p = m in[3] out[3] exit in[exit] Advanced Compilers 14 L2:Intro to data flow

15 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 of B in[b] = f B (out[b]) // in[b]=use[b] (out[b]-def[b]) } Advanced Compilers 15 L2:Intro to data flow

16 III. Framework Reaching Definitions Live Variables Domain Sets of definitions Sets of variables Direction forward: out[b] = f b (in[b]) in[b] = out[pred(b)] backward: in[b] = f b (out[b]) out[b] = in[succ(b)] Transfer function f b (x) = Gen b (x -Kill b ) f b (x) = Use b (x -Def b ) Meet Operator ( ) Boundary Condition Initial Interior points out[entry] = in[exit] = out[b] = in[b] = Advanced Compilers 16 L2:Intro to data flow

17 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? Advanced Compilers 17 L2:Intro to data flow

18 Problem 2: A legal solution to (May) Reaching Def? entry out[entry]={} in[1]={} out[1]={} in[2]={d1} out[2]={d1} d1: b = 1 exit in[3]={d1} out[3]={d1} in[exit] Will the worklist algorithm generate this answer? Advanced Compilers 18 L2:Intro to data flow

19 What are the algorithm properties? Correctness Precision: how good is the answer? Convergence: will the analysis terminate? Speed: how long does it take? Advanced Compilers 19 L2:Intro to data flow