Download presentation

Presentation is loading. Please wait.

Published byReagan Dynes Modified about 1 year ago

1
Course Outline Traditional Static Program Analysis –Theory Today: Compiler Optimizations, Control Flow Graphs Data-flow Analysis –Classic analyses and applications Software Testing Dynamic Program Analysis

2
Textbooks Compilers: Principles, Techniques and Tools by Aho, Lam, Sethi and Ullman Addison-Wesley 2007 Principles of Program Analysis by Nielsen, Nielsen and Hankin, Springer 1999 Notes, handouts and papers

3
Static Program Analysis Analyzes the source code of the program and reasons about the run-time program behavior Many uses –Traditionally in compilers in order to perform optimizing, semantics-preserving transformations –Recently in software tools for testing and validation: our focus

4
Outline An Example: basic compiler optimizations Control flow graphs Local optimizations --- within basic blocks Global optimizations --- across basic blocks Reading: Compilers: Principles, Techniques and Tools, by Aho, Lam, Sethi and Ullman, Chapter 9.1

5
Compilation front end symbol table code generat or code optimiz er source program intermediate code target program An optimization is a semantics-preserving transformation

6
Example Define classical optimizations using an example Fortran loop Opportunities result from table-driven code generation … sum = 0 do 10 i = 1, n 10 sum = sum + a[i]*a[i] …

7
Three Address Code 1.sum = 0initialize sum 2.i = 1initialize loop counter 3.if i > n goto 15loop test, check for limit 4.t1 = addr(a) – 4 5.t2 = i * 4 a[i] 6.t3 = t1[t2] 7.t4 = addr(a) – 4 8.t5 = i * 4a[i] 9.t6 = t4[t5] 10.t7 = t3 * t6a[i]*a[i] 11.t8 = sum + t7 12.sum = t8increment sum 13.i = i + 1increment loop counter 14.goto 3 15.…

8
Control Flow Graph (CFG) 1.sum = 0 2.i = 1 3.if i > n goto 15 4.t1 = addr(a) – 4 5.t2 = i*4 6.t3 = t1[t2] 7.t4 = addr(a) – 4 8.t5 = i*4 9.t6 = t4[t5] 10.t7 = t3*t6 11.t8 = sum + t7 12.sum = t8 13.i = i goto … T F

9
Common Subexpression Elimination 1.sum = 01. sum = 0 2.i = 12. i = 1 3.if i > n goto 153. if i > n goto 15 4.t1 = addr(a) – 44. t1 = addr(a) – 4 5.t2 = i*4 5. t2 = i*4 6.t3 = t1[t2]6. t3 = t1[t2] 7.t4 = addr(a) – 47. t4 = addr(a) – 4 8.t5 = i*48. t5 = i*4 9.t6 = t4[t5]9. t6 = t4[t5] 10.t7 = t3*t610. t7 = t3*t6 11.t8 = sum + t710a t7 = t3*t3 12.sum = t811. t8 = sum + t7 13.i = i + 111a sum = sum + t7 14.goto 312. sum = t8 15.…13. i = i goto 3

10
Invariant Code Motion 1. sum = 02. i = 1 3.if i > n goto 152a t1 = addr(a) t1 = addr(a) – 43. if i > n goto t2 = i * 44. t1 = addr(a) t3 = t1[t2]5. t2 = i * 4 10a t7 = t3 * t36. t3 = t1[t2] 11a sum = sum + t710a t7 = t3 * t3 13. i = i + 111a sum = sum + t7 14. goto 313. i = i …14. goto …

11
Strength Reduction 1. sum = 0 2. i = 1 2a t1 = addr(a) – 42a t1 = addr(a) if i > n goto 152b t2 = i * 4 5. t2 = i * 43. if i > n goto t3 = t1[t2]5. t2 = i * 4 10a t7 = t3 * t36. t3 = t1[t2] 11a sum = sum + t710a t7 = t3 * t3 13. i = i + 111a sum = sum + t7 14. goto 311b t2 = t …13. i = i goto …

12
Test Elision and Induction Variable Elimination 1. sum = 02. i = 12a t1 = addr(a) – 42b t2 = i * 4 3. if i > n goto 152c t9 = n * 4 6. t3 = t1[t2]3. if i > n goto 15 10a t7 = t3 * t33a if t2 > t9 goto 15 11a sum = sum + t76. t3 = t1[t2] 11b t2 = t a t7 = t3 * t3 13. i = i + 111a sum = sum + t7 14. goto 311b t2 = t …13. i = i goto 3a 15. …

13
Constant Propagation and Dead Code Elimination 1. sum = 02. i = 1 2a t1 = addr(a) – 42a t1 = addr(a) - 42b t2 = i * 42c t9 = n * 4 3a if t2 > t9 goto 152d t2 = 4 6. t3 = t1[t2]3a if t2 > t9 goto 15 10a t7 = t3 * t36. t3 = t1[t2] 11a sum = sum + t710a t7 = t3 * t3 11b t2 = t a sum = sum + t7 14. goto 3a11b t2 = t …14. goto 3a 15. …

14
New Control Flow Graph 1. sum = 0 2. t1 = addr(a) t9 = n * 4 4. t2 = 4 5. if t2 > t9 goto t3 = t1[t2] 7. t7 = t3 * t3 8. sum = sum + t7 9. t2 = t goto … F T

15
Building Control Flow Graph Partition into basic blocks 1.Determine the leader statements (i) First program statement (ii) Targets of conditional or unconditional goto’s (iii) Any statement following a goto 2.For each leader, its basic block consists of the leader and all statements up to but not including the next leader or the end of the program

16
Building Control Flow Graph Add flow-of-control information There is a directed edge from basic block B 1 to block B 2 if B 2 can immediately follow B 1 in some execution sequence (i)B 2 immediately follows B 1 and B 1 does not end in an unconditional jump (ii)There is a jump from the last statement in B 1 to the first statement in B 2

17
Leader Statements and Basic Blocks 1.sum = 0 2.i = 1 3.if i > n goto 15 4.t1 = addr(a) – 4 5.t2 = i*4 6.t3 = t1[t2] 7.t4 = addr(a) – 4 8.t5 = i*4 9.t6 = t5[t5] 10.t7 = t3*t6 11.t8 = sum + t7 12.sum = t8 13.i = i goto 3 15.…

18
Analysis and optimizing transformations Local optimizations – performed by local analysis of a basic block Global optimizations – requires analysis of statements outside a basic block Local optimizations are performed first, followed by global optimizations

19
Local optimizations --- optimizing transformations of a basic blocks Local common subexpression elimination Dead code elimination Copy propagation Constant propagation Renaming of compiler-generated temporaries to share storage

20
Example 1: Local Common Subexpression Elimination 1.t1 = 4 * i 2.t2 = a [ t1 ] 3.t3 = 4 * i 4.t4 = b [ t3 ] 5.t5 = t2 * t4 6.t6 = prod * t5 7.prod = t6 8.t7 = i i = t7 10.if i <= 20 goto 1

21
Example 2: Local Dead Code Elimination 1.a = y + 21’. a = y z = x + w2’. x = a 3.x = y + 23’. z = b + c 4.z = b + c4’. b = a 5.b = y + 2

22
Example 3: Local Constant Propagation 1.t1 = 1 Assuming a, k, t3, and t4 are used beyond: 2.a = t11’. a = 1 3.t2 = 1 + a2’. k = 2 4.k = t23’. t4 = t3 = cvttoreal(k)4’. t3 = t4 = t3 7.t3 = t4 D. Gries’ algorithm: Process 3-address statements in order Check if operand is constant; if so, substitute If all operands are constant, Do operation, and add value to table associated with LHS If not all operands constant Delete any table entry for LHS

23
Problems Troubles with arrays and pointers. Consider: x = a[k]; a[j] = y; z = a[k]; Can we transform this code into the following? x = a[k]; a[j] = y; z = x;

24
Global optimizations --- require analysis outside of basic blocks Global common subexpression elimination Dead code elimination Constant propagation Loop optimizations –Loop invariant code motion –Strength reduction –Induction variable elimination

25
Global optimizations --- depend on data-flow analysis Data-flow analysis refers to a body of techniques that derive information about the flow of data along program execution paths For example, in order to perform global subexpression elimination we need to determine that 2 textually identical expressions evaluate to the same result along any possible execution path

26
Introduction to Data-flow Analysis Collects information about the flow of data along execution paths –E.g., at some point we needed to know where a variable was last defined Data-flow information Data-flow analysis

27
Data-flow Analysis G = (N, E, ρ) Data-flow equations (also referred as transfer functions): out(i) = gen(i) (in(i) – kill(i)) Equations can be defined over basic blocks or over single statements. We will use equations over single statements

28
Four Classical Data-flow Problems Reaching definitions (Reach) Live uses of variables (Live) Available expressions (Avail) Very Busy Expressions (VeryB) Def-use chains built from Reach, and the dual Use-def chains, built from Live, play role in many optimizations Avail enables global common subexpression elimination VeryB is used for conservative code motion

29
Reaching Definitions Definition A statement that may change the value of a variable (e.g., x = i+5) A definition of a variable x at node k reaches node n if there is a path clear of a definition of x from k to n. k n x = … … = x x = …

30
Live Uses of Variables Use Appearance of a variable as an operand of a 3-address statement (e.g., y=x+4) A use of a variable x at node n is live on exit from k if there is a path from k to n clear of definition of x. k n x = … … = x x = …

31
Def-use Relations Use-def chain links an use to a definition that reaches that use Def-use chain links a definition to an use that it reaches k n x = … … = x x = …

32
Optimizations Enabled Dead code elimination (Def-use) Code motion (Use-def) Constant propagation (Use-def) Strength reduction (Use-def) Test elision (Use-def) Copy propagation (Def-use)

33
Dead Code Elimination 1. sum = 0 2. i = 1 3. if i > n goto t1 = addr(a)–4 5. t2 = i * 4 6. i = i + 1 T F After strength reduction, test elision and constant propagation, the def-use links from i=1 disappear. It becomes dead code.

34
Constant Propagation 1. i = 1 2. i = 1 3. i = 2 4. p = i*2 5. i = 1 6. q = 5*i+3 = 8

35
Terms Control flow graph (CFG) Basic block Local optimization Global optimization Data-flow analysis

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google