Intra-procedural Data Flow Analysis Introduction

Transcription

1 The Setting: Optimising Compilers The Essence of Program Analysis Reaching Definitions Analysis Intra-procedural Data Flow Analysis Introduction Hanne Riis Nielson and Flemming Nielson Informatics and Mathematical Modelling Technical University of Denmark c Hanne Riis Nielson & Flemming Nielson c HRN&FN (cf slide 2) October 23,

2 Copyright This set of transparencies is mainly based on Flemming Nielson, Hanne Riis Nielson, Chris Hankin: Principles of Program Analysis Springer, 1999; ISBN They may be used by instructors for presentations based on the book but may not be copied and distributed electronically or by other means A handout version with four slides per page may be used for producing paper copies of the slides for students; the students may be charged no fee beyond reasonable production cost The handout version of the transparancies is available from the webpage riis/ppahtm c HRN&FN (cf slide 2) October 23,

3 The Setting: Optimising Compilers The Setting: Optimising Compilers source program front intermediate back end representation end target code the programmer can: profile program change algorithm transform program beyond the compiler the compiler can: improve loops procedure calls address calculations architecture independent the compiler can: use registers instruction selection peephole optimisation architecture dependent c HRN&FN (cf slide 2) October 23,

4 The Setting: Optimising Compilers Criteria for Optimisations an optimisation must preserve the meaning of programs must not change the output for any input must not cause errors (eg division by 0) that were not present before an optimisation must speed up programs by a measurable amount occationally one optimise for space not every optimisation succeeds in improving every program occationally an optimisation may slow down a program slightly but this is acceptable as long as it improves the avarage speed up an optimisation must be worth the effort the additional time spend by the compiler must be repayed when running the target program c HRN&FN (cf slide 2) October 23,

5 The Setting: Optimising Compilers The Level of Optimisations source level: language dependent eg references to array elements give rise to redundant computations Pascal and Fortran programs cannot be optimised at the source levels C programs allow both kinds of references and can be optimised intermediate level: language and architecture independent source 1 source K 3 intermediate representation optimiser 3 architecture 1 architecture N target/low level: architecture dependent less likely to be portable c HRN&FN (cf slide 2) October 23,

6 The Setting: Optimising Compilers What Optimisations are Worthwhile? Folklore: most programs spend 90% of their execution time in 10% of the code Inner loops are good candidates Experiment, profiling, collect statistics, Build on other people s experience, see eg Steven S Muchnick: Advanced Compiler Design and Implementation Morgan Kaufmann, 1997 c HRN&FN (cf slide 2) October 23,

7 The Setting: Optimising Compilers Organisation of an Optimiser front optimiser back end end control data flow flow analysis analysis transformation aim: to discover the hierarchical flow of control aim: to determine information about data aim: to modify the program c HRN&FN (cf slide 2) October 23,

8 The Setting: Optimising Compilers Example Example (ack Reinhard Wilhelm) Base(A) m i Algol-like arrays: C-like arrays: n j i := 0; while i <= n do j := 0; while j <= m do A[i,j] := B[i,j] + C[i,j]; j := j+1 od; i := i+1 od i := 0; while i <= n do j := 0; while j <= m do temp := Base(A) + i * (m+1) + j; Cont(temp) := Cont(Base(B) + i * (m+1) + j) + Cont(Base(C) + i * (m+1) + j); j := j+1 od; i := i+1 od c HRN&FN (cf slide 2) October 23,

9 The Setting: Optimising Compilers Example Typical Optimisations Avoid redundant computations reuse available results move loop invariant computations out of loops Avoid superfluous computations results known not to be needed results known already at compile time i := 0; while i <= n do j := 0; while j <= m do temp := Base(A) + i * (m+1) + j; Cont(temp) := Cont(Base(B) + i * (m+1) + j) + Cont(Base(C) + i * (m+1) + j); j := j+1 od; i := i+1 od c HRN&FN (cf slide 2) October 23,

10 The Setting: Optimising Compilers Example Available Expressions Analysis i := 0; while i <= n do j := 0; while j <= m do temp := Base(A) + i*(m+1) + j; Cont(temp) := Cont(Base(B) + i*(m+1) + j) + Cont(Base(C) + i*(m+1) + j); j := j+1 od; i := i+1 od first computation re-computations Common subexpression elimination: t1 := i * (m+1) + j; temp := Base(A) + t1; Cont(temp) := Cont(Base(B)+t1) + Cont(Base(C)+t1); c HRN&FN (cf slide 2) October 23,

11 The Setting: Optimising Compilers Example Detection of Loop Invariants i := 0; while i <= n do j := 0; while j <= m do t1 := i * (m+1) + j; temp := Base(A) + t1; Cont(temp) := Cont(Base(B) + t1) + Cont(Base(C) + t1); j := j+1 od; i := i+1 od loop invariant Invariant code motion: t2 := i * (m+1); while j <= m do t1 := t2 + j; temp := Cont(temp) := j := od c HRN&FN (cf slide 2) October 23,

12 The Setting: Optimising Compilers Example Detection of Induction Variables i := 0; 2 while i <= n do j := 0; t2 := i * (m+1); while j <= m do t1 := t2 + j; temp := Base(A) + t1; Cont(temp) := Cont(Base(B) + t1) + Cont(Base(C) + t1); j := j+1 od; i := i+1 od induction variable Strength reduction: i := 0; t3 := 0; while i <= n do j := 0; t2 := t3; while j <= m do i := i + 1; t3 := t3 + (m+1) od od c HRN&FN (cf slide 2) October 23,

13 The Setting: Optimising Compilers Example Copy Analysis i := 0; t3 := 0; while i <= n do j := 0; t2 := t3; t2 = t3 while j <= m do t1 := t2 + j; temp := Base(A) + t1; Cont(temp) := Cont(Base(B) + t1) + Cont(Base(C) + t1); j := j+1 od; i := i+1; t3 := t3 + (m+1) od Copy propagation: while j <= m do t1 := t3 + j; temp := ; Cont(temp) := ; j := od c HRN&FN (cf slide 2) October 23,

14 The Setting: Optimising Compilers Example Live Variables Analysis i := 0; t3 := 0; while i <= n do dead variable j := 0; t2 := t3; while j <= m do t1 := t3 + j; temp := Base(A) + t1; Cont(temp) := Cont(Base(B) + t1) + Cont(Base(C) + t1); j := j+1 od; i := i+1; t3 := t3 + (m+1) od Dead code elimination: i := 0; t3 := 0; while i <= n do j := 0; while j <= m do t1 := t3 + j; temp := Base(A) + t1; Cont(temp) := Cont(Base(B) + t1) + Cont(Base(C) + t1); j := j+1 od; i := i+1; t3 := t3 + (m+1) od c HRN&FN (cf slide 2) October 23,

15 The Setting: Optimising Compilers Example Analyses and Transformations Data Flow Analysis Transformation Available expressions analysis Common subexpression elimination Detection of loop invariants Invariant code motion Detection of induction variables Strength reduction Copy analysis Copy propagation Live variables analysis Dead code elimination c HRN&FN (cf slide 2) October 23,

16 The Essence of Program Analysis The Essence of Program Analysis Program analysis offers techniques for predicting statically at compile-time safe & efficient approximations to the set of configurations or behaviours arising dynamically at run-time we cannot expect exact answers! Safe: faithful to the semantics Efficient: implementation with good time performance and low space consumption c HRN&FN (cf slide 2) October 23,

17 The Essence of Program Analysis The Nature of Approximation The exact world Over-approximation Under-approximation universe exact set of configurations or behaviours overapproximation underapproximation unacceptable! Slogans: Err on the safe side! Trade precision for efficiency! c HRN&FN (cf slide 2) October 23,

18 The Essence of Program Analysis Example Example Program with labels for elementary blocks: [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 do [z := z y] 4 ; Flow graph: [y := x] 1 [z := 1] 2 [y > 0] 3 [y := 0] 6 [y := y 1] 5 od; [z := z y] 4 [y := 0] 6 [y := y 1] 5 c HRN&FN (cf slide 2) October 23,

19 The Essence of Program Analysis Example Example: Reaching Definitions Analysis Problem: which definitions reach which program points For a simple while language: a definition of a variable x is an assignment [x := a] l to x The assignment [x := a] l reaches l if there is an execution where x was last assigned at l [y := x] 1 [z := 1] 2 [y > 0] 3 [z := z y] 4 [y := y 1] 5 [y := 0] 6 c HRN&FN (cf slide 2) October 23,

20 The Essence of Program Analysis Example Analysing the Program by Hand (1) [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 od; [z := z y] 4 ; do [y := y 1] 5 {(x,?), (y,?), (z,?)} {(x,?), (y, 1), (z,?)} {(x,?), (y, 1), (z, 2)} {(x,?), (y, 1), (z, 2)} [y := 0] 6 {(x,?), (y, 1), (z, 2)} c HRN&FN (cf slide 2) October 23,

21 The Essence of Program Analysis Example Analysing the Program by Hand (2) [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 do [z := z y] 4 ; {(x,?), (y,?), (z,?)} {(x,?), (y, 1), (z,?)} {(x,?), (y, 1), (z, 2)} {(y, 5), (z, 4)} {(x,?), (y, 1), (z, 2)} [y := y 1] 5 {(x,?), (y, 1), (z, 4)} od; {(x,?), (y, 5), (z, 4)} [y := 0] 6 {(x,?), (y, 1), (z, 2)} c HRN&FN (cf slide 2) October 23,

22 The Essence of Program Analysis Example Analysing the Program by Hand (3) [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 do [z := z y] 4 ; {(x,?), (y,?), (z,?)} {(x,?), (y, 1), (z,?)} {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} {(y, 5), (z, 4)} {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} [y := y 1] 5 {(x,?), (y, 1), (y, 5), (z, 4)} od; {(x,?), (y, 5), (z, 4)} [y := 0] 6 {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} {(x,?), (y, 6), (z, 2), (z, 4)} c HRN&FN (cf slide 2) October 23,

23 The Essence of Program Analysis Example The Best Solution [y := x] 1 ; [z := 1] 2 ; {(x,?), (y,?), (z,?)} {(x,?), (y, 1), (z,?)} while [y > 0] 3 do {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} [z := z y] 4 ; {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} [y := y 1] 5 {(x,?), (y, 1), (y, 5), (z, 4)} od; {(x,?), (y, 5), (z, 4)} [y := 0] 6 {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} {(x,?), (y, 6), (z, 2), (z, 4)} c HRN&FN (cf slide 2) October 23,

24 The Essence of Program Analysis Example A Safe Solution but not the Best [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 [z := z y] 4 ; do {(x,?), (y,?), (z,?)} {(x,?), (y, 1), (z,?)} {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} [y := y 1] 5 {(x,?), (y, 1), (y, 5), (z,2), (z, 4)} od; {(x,?), (y,1), (y, 5), (z,2), (z, 4)} [y := 0] 6 {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} {(x,?), (y, 6), (z, 2), (z, 4)} c HRN&FN (cf slide 2) October 23,

25 The Essence of Program Analysis Example An Unsafe Solution [y := x] 1 ; [z := 1] 2 ; {(x,?), (y,?), (z,?)} {(x,?), (y, 1), (z,?)} while [y > 0] 3 do {(x,?), (y, 1), (z, 2), (y, 5), (z, 4)} [z := z y] 4 ; {(x,?), (y,1), (z,2), (y, 5), (z, 4)} [y := y 1] 5 {(x,?), (y,1), (y, 5), (z, 4)} od; {(x,?), (y, 5), (z, 4)} [y := 0] 6 {(x,?), (y,1), (z,2), (y, 5), (z, 4)} {(x,?), (y, 6), (z,2), (z, 4)} c HRN&FN (cf slide 2) October 23,

26 Formalising the development Formalising the Development Problem: which definitions reach which program points The assignment [x := a] l reaches l if there is an execution where x was last assigned at l extract compute the equations least solution from the program to the equations the programming language of interest abstract flow graphs extract and solve the equations c HRN&FN (cf slide 2) October 23,

27 Formalising the development The while language The While Language: a ::= x n a 1 op a a 2 b ::= true false not b b 1 op b b 2 a 1 op r a 2 S ::= [x := a] l [skip] l S 1 ; S 2 if [b] l then S 1 else S 2 while [b] l do S od Assignments and tests are (uniquely) labelled to allow the analyses to refer to these program fragments the labels corresponds to pointers into the syntax tree We use abstract syntax and insert paranthesis to disambiguate the syntax again this corresponds to thinking in terms of syntax trees OBS: the control structure is known there is no need for a control flow analysis! c HRN&FN (cf slide 2) October 23,

28 Formalising the development The while language Talking about Flow Graphs labels(s) init(s) final(s) flow(s) flow R (S) the set of nodes of the flow graphs of S the initial node of the flow graph of S; this is the unique node where the execution of the program starts the final nodes of the flow graphs for S; this is the set of nodes where the execution of the program may terminate the edges of the flow graphs for S; there is an edge from one node to another if the flow of control may go from the first node to the second used for forward analyses the reversed edges of the flow graphs of S; there is an edge from one node to another if the flow of control may go from the second node to the first used for backwards analyses c HRN&FN (cf slide 2) October 23,

29 Formalising the development The while language The Abstract Flow Graph Example: [z:=1] 1 ; while [x>0] 2 do [z:=z*y] 3 ; [x:=x-1] 4 od labels( ) = {1, 2, 3, 4} [z := 1] 1 init( ) = 1 final( ) = {2} flow( ) = {(1, 2), (2, 3), (3, 4), (4, 2)} [x > 0] 2 yes [z := z y] 3 no flow R ( ) = {(2, 1), (2, 4), (3, 2), (4, 3)} [x := x 1] 4 c HRN&FN (cf slide 2) October 23,

30 Formalising the development The while language Computing the Information (1) S labels(s) init(s) final(s) [x := a] l {l} l {l} [skip] l {l} l {l} S 1 ; S 2 labels(s 1 ) labels(s 2 ) init(s 1 ) final(s 2 ) if [b] l then S 1 {l} labels(s 1 ) l final(s 1 ) else S 2 labels(s 2 ) final(s 2 ) while [b] l do S od {l} labels(s) l {l} c HRN&FN (cf slide 2) October 23,

31 Formalising the development The while language Computing the Information (2) S flow(s) blocks(s) [x := a] l {[x := a] l } [skip] l {[skip] l } S 1 ; S 2 flow(s 1 ) flow(s 2 ) blocks(s 1 ) {(l, init(s 2 )) l final(s 1 )} blocks(s 2 ) if [b] l then S 1 flow(s 1 ) flow(s 2 ) {[b] l } blocks(s 1 ) else S 2 {(l, init(s 1 )), (l, init(s 2 ))} blocks(s 2 ) while [b] l do S od {(l, init(s))} flow(s) {[b] l } blocks(s) {(l, l) l final(s)} flow R (S) = {(l, l ) (l, l) flow(s)} c HRN&FN (cf slide 2) October 23,

32 Formalising the development The while language Simplifying assumptions The program of interest S is often assumed to satisfy: S has isolated entries if there are no edges leading into init(s ): l : (l, init(s )) / flow(s ) S has isolated exits if there are no edges leading out of labels in final(s ): S is label consistent if l final(s ), l : (l, l ) / flow(s ) [B l 1 1 ], [Bl 2 2 ] blocks(s ) : l 1 = l 2 B 1 = B 2 This holds if S is uniquely labelled c HRN&FN (cf slide 2) October 23,

33 Reaching Definitions Reaching Definitions Analysis The aim of the Reaching Definitions Analysis is to determine For each program point, which assignments may have been made and not overwritten, when program execution reaches this point along some path Example [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 do [z := z y] 4 ; [y := y 1] 5 od; [y := 0] 6 c HRN&FN (cf slide 2) October 23,

34 Reaching Definitions The Basic Idea RD (l) [x := a] l RD (l) Analysis information: [skip] l RD (l) RD (l) [b] l RD (l) RD (l) RD (l): the definitions that reach the entry of block l RD (l): the definitions that reach the exit of block l Auxiliary information: kill RD (l): the definitions that are killed by an elementary block gen RD (l): the definitions that are generated by an elementary block c HRN&FN (cf slide 2) October 23,

35 Reaching Definitions Analysis of the program RD (l) [x := a] l RD (l) [] l 1 [] l k [] l RD (l 1 ) RD (l k ) RD (l) RD (l) = (RD (l)\kill RD (B l )) gen RD (B l ) if B l blocks(s ) {(x,?) x FV(S )} if l = init(s ) RD (l) = {RD (l ) (l, l) flow(s )} otherwise kill RD ([x := a] l ) = {(x,?)} {(x, l ) B l is an assignment to x} gen RD ([x := a] l ) = {(x, l)} kill RD (B l ) = gen RD (B l ) = otherwise c HRN&FN (cf slide 2) October 23,

36 Reaching Definitions Example Example [y := x] 1 ; [z := 1] 2 ; while [y > 0] 3 do [z := z y] 4 ; [y := y 1] 5 od; [y := 0] 6 Equations: RD (1) = RD (1) \ {(y,?), (y, 1), (y, 5), (y, 6)} {(y, 1)} RD (2) = RD (2) \ {(z,?), (z, 2), (z, 4)} {(z, 2)} RD (3) = RD (3) \ RD (4) = RD (4) \ {(z,?), (z, 2), (z, 4)} {(z, 4)} RD (5) = RD (5) \ {(y,?), (y, 1), (y, 5), (y, 6)} {(y, 5)} RD (6) = RD (6) \ {(y,?), (y, 1), (y, 5), (y, 6)} {(y, 6)} RD (1) = {(x,?), (y,?), (z,?)} RD (2) = RD (1) RD (3) = RD (2) RD (5) RD (4) = RD (3) RD (5) = RD (4) RD (6) = RD (3) Compute the least solution to these equations c HRN&FN (cf slide 2) October 23,

37 Reaching Definitions Example Solving the equations 1 W := nil; for all (l, l ) in flow(s ) do W := cons((l, l ),W); for all l in labels(s ) do if l = init(s ) then RD (l) := {(x,?) x FV(S )} else RD (l) := 2 while W nil do (l, l ) := head(w); W := tail(w); if (RD (l) \ kill RD (l)) gen RD (l) }{{} RD (l) RD (l ) then RD (l ) := RD (l ) (RD (l) \ kill RD (l)) gen RD (l); }{{} RD (l) for all l with (l, l ) in flow(s ) do W := cons((l, l ),W); c HRN&FN (cf slide 2) October 23,