: Compiler Design

Transcription

1 : Compiler Design 9.0 Data- Flow Analysis Thomas R. Gross Computer Science Department ETH Zurich, Switzerland

2 Global program analysis is a crucial part of all real compilers. Global : beyond a statement or small group of statements Details to follow Program analysis : understanding a program s behavior without execumon No need to have input Analysis valid for all possible inputs Program analysis for a purpose Understand =ming behavior How long does it take un=l an interrupt is no=ced? Here: analyze for op=miza=ons and for error checking 2

3 Program analysis FoundaMon to reason about correctness of programs Need to make sure program computes defined value for given input Need to make sure program does not access values outside its data space 3

4 Program analysis FoundaMon for error checking and/or repormng May be required by the programming language The Java Language Specification, Third Edition, CHAPTER 16: Definite Assignment Each local variable ( 14.4) [..] must have a definitely assigned value when any access of its value occurs. [..] A Java compiler must carry out a specific conservative flow analysis to make sure that, for every access of a local variable [..] f, f is definitely assigned before the access; otherwise a compile-time error must occur. 4

5 IllustraMve examples (mostly from Java Language Spec) int k = 1; system.out.println(k); 5

6 IllustraMve examples int k = 1; system.out.println(k); [ok] 6

7 IllustraMve examples int k = 1; system.out.println(k); [ok] void flow(boolean flag) { } int k; if (flag) k = 3; else k = 4; System.out.println(k); 7

8 IllustraMve examples int k = 1; system.out.println(k); void flow(boolean flag) { } int k; if (flag) k = 3; else k = 4; System.out.println(k); [ok] [ok] 8

9 Program analysis Must understand the flow of assignments From assignment to use as an argument Must understand the structure of the program If- then- else 9

10 Program analysis Should the compiler look at the expression of a condimonal statement? 10

11 Example, conmnued { int k; int n = 5; if (n > 2) k = 3; System.out.println(k); } 11

12 Example, conmnued { } [Not OK] int k; int n = 5; if (n > 2) k = 3; System.out.println(k); // k is not "definitely assigned" // before this call 12

13 Examples, conmnued { } int k; while (true) { k = n; if (k >= 5) break; n = 6; } System.out.println(k); 13

14 Examples, conmnued { } int k; while (true) { k = n; if (k >= 5) break; n = 6; } System.out.println(k); [OK] 14

15 Examples, conmnued { int k; while (n < 4) { k = n; if (k >= 5) break; n = 6; } System.out.println(k); } 15

16 Examples, conmnued { int k; while (n < 4) { } k = n; if (k >= 5) break; n = 6; System.out.println(k); // k is not //"definitely assigned" before this call } [Not OK] 16

17 Program analysis Just the Mp of the Java (Language Spec) iceberg The chapter (16) on definite assignments has 15 pages 17

18 Program analysis FoundaMon to reason about correctness of programs Need to make sure program computes defined value for given input Need to make sure program does not access values outside its data space FoundaMon for opmmizamon 18

19 Example void foo( ) { int j; j = 0; a[j] = } Can we replace a[j] with a[0]? Faster 19

20 Example void foo( ) { int j; j = 0; a[j] = } Can we replace a[j] with a[0]? Faster Yes, provided j does not change in shaded region 20

21 VariaMons void foo( ) { int a, b, c; a = 1; b = 2; c = a * b ; } Can we set c to 2? Faster May open more opportuni=es (see last example) 21

22 VariaMons void foo( ) { int a, b, c; a = 1; b = 2; c = a * b ; } Can we set c to 2? Faster Yes, provided a and b do not change in shaded region 22

23 Program analysis FoundaMon to reason about correctness of programs Need to make sure program computes defined value for given input Need to make sure program does not access values outside its data space FoundaMon for opmmizamon May be useful (essenmal) for tools Find statements that modify elements of an array A Must inspect all methods that are given a reference to A 23

24 Program analysis Tied to the intended use of analysis informamon Check definite assignment in Java Do not propagate informa=on into expression of if- statement See example Find opportunimes to remove unused code Evaluate expression at compile =me Remove code if it is never executed 24

25 EvaluaMon expression in compiler int j, k, m ; k = 1; j = 1; if ( j ==0 ) k = 2; m = k; 25

26 int j, k, m ; k = 1; j = 1; if ( j ==0 ) k = 2; m = 1; //?? Let there be no changes to k in the shaded region 26

27 int j, k, m ; k = 1; j = 1; if ( false ) k = 2; m = 1; //?? Let there be no changes to k in the shaded region 27

28 int j, k, m ; k = 1; j = 1; m = 1; // OK Let there be no changes to k in the shaded region 28

29 Program analysis Analysis must be correct Depends on use Do not mislead the compiler Analysis should be accurate As accurate as possible (given the informa=on in the program) As accurate as feasible (may not be able to keep all details) 29

30 9.1 Program representamon Current IR forest of trees Edges between root nodes indicate sequencing Structure of program not directly visible in IR Sequencing of statements is enough but blurs big picture Must deal with control- flow ( big picture ) before we can consider data- flow 30

31 int foo(int max, int [] A) { int k = 1; int minval = A[0]; while (k < max) { if (A[k] < minval) { minval = A[k]; } k = k + 1; } return minval; } 31

32 int foo(int max, int [] A) { k = 1 minval = A[0] L: TCond1 = k < max if (TCond1) TCond2 = A[k] < minval if (TCond2) minval = A[k] k = k + 1 Goto L return minval } 32

33 int foo(int max, int [] A) { k = 1 minval = A[0] L: TCond1 = k < max if (TCond1) TCond2 = A[k] < minval if (TCond2) minval = A[k] k = k + 1 Goto L return minval } 33

34 int foo(int max, int [] A) { k = 1 minval = A[0] L: TCond1 = k < max if (TCond1) TCond2 = A[k] < minval if (TCond2) minval = A[k] k = k + 1 Goto L return minval } 34

35 All instrucmons in a box are executed together We ignore for now that there could be excep=ons if (ConditionVariable) Test CondiMonVariable and proceed accordingly TRUE path FALSE path Only one path is taken Goto Label has the obvious meaning 35

36 Basic block The maximal sequence of instrucmons that is executed together is known as a basic block Together means w/o control flow change You can form basic blocks directly from the JavaLi IR May be harder in other languages ObservaMons An if- statement ends a basic block We do not know which statement will be executed next A Goto- statement ends a basic block A Return statement ends a basic block A label starts a basic block (and ends the previous block) Method call does not end a basic block For some compilers a method call ends a basic block 36

37 We can build a graph that captures the control flow CFG: control- flow graph Nodes: basic blocks Edges: There is an edge between block B 1 and block B 2 if B 2 may be executed immediately ager B 1. Two special nodes: START and EXIT START has no in- edges EXIT has no out- edges All other nodes have at least one in- edge and one out- edge 37

38 k = 1 minval = A[0] L: TCond1 = k < max B0 B1 if (TCond1) TCond2 = A[k] < minval if (TCond2) B2 minval = A[k] B3 k = k + 1 Goto L B4 return minval B5 38

39 k = 1 minval = A[0] L: TCond1 = k < max if (TCond1) B0 B1 START TCond2 = A[k] < minval if (TCond2) B2 minval = A[k] B3 k = k + 1 Goto L B4 return minval B5 EXIT 39

40 Control- Flow graph Edge defines successor/predecessor relamonship A block can be its own predecessor Edges capture possible successor (predecessor) relamonships Upon further inspec=on may want to remove edges and/or blocks Always built for one method/funcmon May want to include header block to deal with parameters Some compilers may include in header code to free registers etc and may have an exit block for restore opera=ons ExcepMonal control flow discussion postponed try- throw- catch Excep=on triggered by hardware 40

41 CFG construcmon Basic blocks a convenient abstracmon Not necessary for compiler Some algorithms easier to describe when using basic blocks, with control flow edges between blocks But many algorithms easy to explain in flat IR (sequences of statements) If you must/want to construct a CFG (and idenmfy blocks): single pass over current IR, form basic blocks (CFG nodes) on the fly 41

42 Comments on intermediate representamons Previous example close to JavaLi source For illustra=on Statements: JavaLi statements (almost) Basic block concept applies also to low- level (assembler) languages Statement: asm instruc=on Or to other kinds of internal representamons 42

43 Comments, conmnued Many algorithms easier to explain/discuss for simple statements des=na=on = source 1 op source 2 Instead of des=na=on = source 1 op source 2 op source 3 op source 4 We assume that our programs have this form It s easy to transform a program a = b + c + d turns into temp1 = c + d a = b + temp1 43

44 Why bother? Now it s easy (e.g.) to see that there is a common sub- expression a = b + c + d; x = a + 1; y = c + d; turns into temp1 = c + d; a = b + temp1; x = a + 1; y = c + d; 44

45 Why bother? Now it s easy (e.g.) to see that there is a common sub- expression a = b + c + d; x = a + 1; y = c + d; turns into temp1 = c + d; a = b + temp1; x = a + 1; y = c + d; temp1 = c + d; a = b + temp1; x = a + 1; y = temp1; 45

46 Once we idenmfy c+d as a common sub- expression (i.e., an expression that s evaluated more than once) it s easy to change the program We could also work on large trees but it s painful Of course it s not clear if the compiler should replace the second occurrence of c+d by temp1. 46

47 Analysis inside a basic block As the compiler knows that all instrucmons are executed together, it s easy to analyze a basic block It s smll far from trivial to consider transformamons or to idenmfy operands 47

48 Example a = b + c + d ; x = b + d; There is a common sub- expression but the compiler (most likely) won t find it Even if we deal with integer operands 48

49 a[k] = 1; a[m] = 2; b = a[k] + 1; Can the compiler assume a[k]= 1? k, m method parameters (int) a some (large) array (int) no mul=- threading, no hidden changes to k, m 49

50 a[k] = 1; a[m] = 2; b = a[k] + 1; Can the compiler assume a[k] = 1? k, m method parameters (int) a some (large) array (int) no mul=- threading, no hidden changes to k, m No, as k = m is possible. 50

51 Analysis (and opmmizamon) of basic blocks postponed. Not difficult 51

52 Terminology Local {analysis transformamon}: inside a basic block Global {analysis transformamon}: inside a method/funcmon Intra- procedural.. Inter- procedural {analysis transformamon}: across methods/funcmons 52

53 9.2 Paths and points Want to talk about flow of data in program Point: a place in the program Given a statement S P before_s : point before statement S is executed P aker_s : point aker statement S is executed Drop S if no risk of confusion Example a = b + c; //S1 x = a + 2; //S2 53

54 54

55 Point: a place in a program Given a basic block B P before_b : point before basic block B is executed P aker_b : point aker basic block B is executed Drop B if no risk of confusion 55

56 k = 1 minval = A[0] L: TCond1 = k < max B0 B1 if (TCond1) TCond2 = A[k] < minval if (TCond2) B2 minval = A[k] B3 k = k + 1 Goto L B4 return minval B5 56

57 A path is a sequence of points (x 0, x 1, x 2,, x n ) such that for any pair (x j, x j+1 ) with 0 j<n one of these condimons holds 1. x j is the point before basic block B and x j+1 is the point aker basic block B 2. x j is the point aker basic block B k and x j+1 is the point before basic block B m and there is an edge from B k to B m in the CFG DefiniMon can be extended to deal with points before statements. 57

58 Comments Points may have mulmple predecessors Join points Join nodes (in the CFG) Points may have mulmple successors Split points Split nodes When summarizing paths we may just list the basic blocks 58

59 Paths B0 B1 B2 B3 59

60 Paths i = 0 if (i>0) B0 B1 B2 B3 60

61 Paths if (i>0) B0 B1 if (i<0) B2 B3 B4 B5 B6 61

62 Paths We are interested in all paths in a CFG Even if they can never be taken in an execu=on Need summary informamon There can be arbitrarily many paths 62

63 Loops B0 if (COND) B1 B2 B3 63

64 Loops B0 if (COND) B1 B2 B3 B0 B1 B3 B0 B1 B2 B1 B3 B0 B1 B2 B1 B2 B1 B3 64 B0 B1 B2 B1 B2 B1 B2 B1 B2 B1 B2 B1 B2 B1 B2 B1 B2 B1 B2

65 Paths We deal only with finite paths PracMcal view: what has happened when program execumon reaches B3 P before_b3 Execu=on (for some input) may never reach B3. Summary informamon is needed 65

66 9.3 Transfer funcmons 66

67 Greek αααααβδερργλλλµµµννννωωω 67

68 68