Compiler Design Spring 2017

Transcription

1 Compiler Design Spring Data-Flow Analysis Dr. Zoltán Majó Compiler Group Java HotSpot Virtual Machine Oracle Corporation

2 Admin issues There will be a code review session next week On 15:15 (same time as the recitation session) Details: See description of HWC (out today) Some details (e.g., rooms) will follow by There is no recitation session today 2

3 Last lecture: Introduction to program analysis Why is program analysis needed? Foundation to reason about the correctness of programs Incl. understand language specification (e.g., Java language spec) May be essential for tools E.g., find statements that modify an array A Foundation for optimization E.g., remove unused (dead) code 3

4 Properties of program analysis Analysis must be correct Depends on use Do not mislead the compiler Analysis should be accurate As accurate as possible (given the information in the program) As accurate as feasible (may not be able to keep all details) 4

5 Outline Introduction Why do we need data-flow analysis Examples Program representation Points Paths Transfer functions 5

6 8.1 Program representation 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 6

7 7

8 8

9 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; } 9

10 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 } 10

11 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 } 11

12 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 } 12

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

14 Basic block The maximal sequence of instructions 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 or IRs Observations 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 14

15 Control-flow graph 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 after B 1. Two special nodes: ENTRY and EXIT ENTRY has no in-edges EXIT has no out-edges All other nodes have at least one in-edge and one out-edge 15

16 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 16

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

18 x = 2; if (x > 0) { y = 0; while (x < Nmax) { } y = y + 1; x = 2 * x; if (x == Nspecial) { } } else { } y = 1; x = x * x; Construct the CFG for this program (5 min) 18

19 How many nodes (basic blocks) are in the CFG? Did you include ENTRY and EXIT? 19

20 x = 2 Cond = x > 0 if (Cond) y = 0; L: TCond = x < Nmax if (Tcond) y = y + 1 x = 2 * x Cond = x == Nspecial if (Cond) x = x * x Goto M Goto L ENTRY M: y = 1; EXIT 20

21 Control-flow graph Edge defines successor/predecessor relationship A block can be its own predecessor Edges capture possible successor (predecessor) relationships Upon further inspection may want to remove edges and/or blocks Always built for one method/function May want to include header block to deal with parameters Some compilers may include in header code to free registers, stack banging, etc., and may have an exit block for restore operations Exceptional control flow discussion postponed try-throw-catch Exception triggered by hardware 21

22 CFG construction Basic blocks are a convenient abstraction 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 identify blocks): Single pass over current IR Form basic blocks (CFG nodes) on the fly 22

23 Comments on intermediate representations Previous example close to JavaLi source For illustration Statements: JavaLi statements (almost) Basic block concept applies also to low-level (assembler) languages Statement: asm instruction Or to other kinds of internal representations 23

24 Comments (cont d) Many algorithms easier to explain/discuss for simple statements destination = source 1 op source 2 Instead of destination = source 1 op source 2 op source 3 op source 4 We assume that our programs have this form (2 operands) Three-address code It s easy to transform a program a = b + c + d turns into temp1 = c + d a = b + temp1 24

25 Why bother? Now it s easy (e.g.) to see that there is a common subexpression 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; 25

26 Once we identify 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. 26

27 Analysis inside a basic block Local program analysis As the compiler knows that all instructions are executed together, it s easy to analyze a basic block It s still far from trivial to consider transformations or to identify operands 27

28 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 28

29 Another example 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 multi-threading, no hidden changes to k, m 29

30 Another example 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 multi-threading, no hidden changes to k, m No, as k == m is possible. 30

31 Analysis inside a basic block Analysis (and optimization) of basic blocks postponed Not difficult Chapter 8 of Aho et al. contains a discussion of the topic 31

32 Terminology Local {analysis transformation}: inside a basic block Global {analysis transformation}: inside a method/function Intra-procedural Inter-procedural {analysis transformation}: across methods/functions 32

33 Outline Introduction Why do we need data-flow analysis Examples Program representation Points Paths Transfer functions 33

34 8.2 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 after_s : point after statement S is executed Drop S if no risk of confusion Example a = b + c; // S1 x = a + 2; // S2 34

35 35

36 8.2 Points (cont d) Points can be extended to basic blocks as well Point (as before): a place in a program Given a basic block B P before_b : point before basic block B is executed P after_b : point after basic block B is executed Drop B if no risk of confusion 36

37 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 37

38 38

39 8.3 Paths 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 conditions holds 1. x j is the point before basic block B and x j+1 is the point after basic block B 2. x j is the point after 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 Definition can be extended to deal with points before/after statements. 39

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

41 Paths B0 B1 B2 B3 41

42 42

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

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

45 45

46 Paths We are interested in all paths in a CFG Even if they can never be taken in an execution Need summary information There can be arbitrarily many paths 46

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

48 48

49 Paths We deal only with finite paths Practical view: What has happened when program execution reaches B3 P before_b3 Execution (for some input) may never reach B3 Summary information is needed 49

50 Outline Introduction Why do we need data-flow analysis Examples Program representation Points Paths Transfer functions Use constant propagation as an example 50