Compiler Design Spring 2017

Size: px

Start display at page:

Download "Compiler Design Spring 2017"

Derrick Fitzgerald
5 years ago
Views:

1 Compiler Design Spring Live variables Dr. Zoltán Majó Compiler Group Java HotSpot Virtual Machine Oracle Corporation

2 Last lecture Definition: A variable V is live at point P if there is a path from P to EXIT that contains a statement S that uses V and there is no definition of V on this path between P and S. 33

3 (Detailed) local analysis S 1 : V = S 2 : W = expr S 3 : = X V S 4 : = Y 1 S 5 : = Z Live = {X, Z, Y} B Live = {X, Z, Y, V} Live = {X, Z, Y, V} Live = {X, Z, Y} Live = {X, Z} Given set of live variables at P after_b Determines live variables On a per-statement level, e.g., P before_s 5, P before_s4, etc. Also at P before_b == P before_s 1 Global analysis Propagates liveness information through control flow graph Through control structures and basic blocks (needs local analysis) Compiler transforms program Based on liveness information For example: No need to store value computed by S 2 in variable W If expr has no side effect stmt can be removed Live = {X, Z} 34

4 Observation Effect of statements in a basic block can be also summarized def B = { var var is defined in B prior to any use of var in B } use B = { var var is used in B prior to any definition of var in B } 35

5 Live = {X, Z, Y} = OUT(B) S 1 : V = S 2 : W = expr S 3 : = X V S 4 : = Y 1 S 5 : = Z B Live = {X, Z, Y, V} Live def = {V, {X, W} Z, Y, V} Live use = {X, Z, V, Y} Y, Z} Live = {X, Z} Live = {X, Z} = IN(B) Transfer function IN(B) = use B (OUT(B) def B ) 36

6 Finding live variables IN[EXIT] = Initialize IN[B] = for B EXIT while (changes to any IN(B)) { for (each basic block B EXIT) { OUT(B) = Bi, Bi is successor of B in CFG IN(Bi) IN(B) = use B (OUT(B) def B ) } } 37

7 Finding live variables IN[EXIT] = Initialize IN[B] = for B EXIT while (changes to any IN(B)) { for (each basic block B EXIT) { OUT(B) = Bi, Bi is successor of B in CFG IN(Bi) IN(B) = use B (OUT(B) def B ) } } 38

8 Initialize IN[B] = while (changes to any IN(B)) { for (each basic block B EXIT) { OUT(B) = Bi, Bi is successor of B in CFG IN(Bi) IN(B) = use B (OUT(B) def B ) } def = {i, j, a} use = { m, n } ENTRY d1: i = m 1 d2: j = n d3: a = IN(B1) = OUT(B1) = def = {} use = {i, j} d4: i = i + 1 d5: j = j - 1 IN(B2) = OUT(B2) = d6: a = IN(B3) = def = {a} use = def = {i} use = OUT(B3) = d7: i = IN(B4) = OUT(B4) = From Aho et al Compilers, p 604 EXIT IN(EXIT) 39

9 40

10 Initialize IN[B] = while (changes to any IN(B)) { for (each basic block B EXIT) { OUT(B) = Bi, Bi is successor of B in CFG IN(Bi) IN(B) = use B (OUT(B) def B ) } def = {i, j, a} use = { m, n } ENTRY d1: i = m 1 d2: j = n d3: a = IN(B1) OUT(B1) {m,n} {i,j} def = {} use = {i, j} d4: i = i + 1 d5: j = j - 1 IN(B2) OUT(B2) {i,j} {j} d6: a = IN(B3) {j} def = {a} use = def = {i} use = OUT(B3) {j} d7: i = IN(B4) OUT(B4) {j} {i,j} From Aho et al Compilers, p 604 EXIT IN(EXIT) 41

11 Variation ENTRY def = {i, j, a} use = { m, n } d1: i = m 1 d2: j = n d3: a = IN(B1) OUT(B1) {m,n} {i,j} def = {} use = {i, j} d4: i = i + 1 d5: j = j - 1 IN(B2) OUT(B2) {i,j} {j} d6: a = IN(B3) {j} def = {a} use = def = {i} use = OUT(B3) {j} d7: i = d8: = i + 1 IN(B4) OUT(B4) {j} {i,j} From Aho et al Compilers, p 604 EXIT IN(EXIT) 42

12 Variation 2 ENTRY def = {i, j, a} use = { m, n } d1: i = m 1 d2: j = n d3: a = IN(B1) OUT(B1) {m,n} {i,j,n} def = {} use = {i, j} d4: i = i + 1 d5: j = j - 1 IN(B2) OUT(B2) {i,j,n} {j,n} d6: a = n + 1 IN(B3) {j,n} def = {a} use = {n} def = {i} use = OUT(B3) {n,j} d7: i = IN(B4) OUT(B4) {n,j} {i,j,n} From Aho et al Compilers, p 604 EXIT IN(EXIT) 43

13 Comments The set use B includes also uses in statements that are not assignment statements Expression in if-then statements Expressions in while loops Actuals in method calls The order of visiting the basic blocks (in main loop) determines how fast the fixed point is found But not the final result There may be other solutions that are also correct 44

14 Summary Reaching definitions and live variables require a similar approach Compute two sets for each basic block B Solution = OUT(B) / IN(B) Context = IN(B) / OUT(B) Two sets to capture local effects local_cut = def B (but with different meaning: sets of definitions/sets of variables) local_new = gen B / use B Init Solution(ENTRY) / Solution(EXIT) i.e. OUT(ENTRY) / IN(EXIT) Init remaining Solution sets Iterate over basic blocks B Context(B) = Bi, Bi is predecessor/successor of B in CFG Solution(Bi) Solution(B) = local_new B (Context(B) local_cut B ) 45

15 Flow of information Reaching definition: i ENTRY d1: i = m 1 d2: j = n d3: a = d4: = i + 1 d5: j = j - 1 d6: a = i + 1 d7: i = EXIT 46

16 Flow of information Reaching definition: j ENTRY d1: i = m 1 d2: j = n d3: a = d4: = i + 1 d5: j = j - 1 d6: a = i + 1 d7: i = EXIT 48

17 Flow of information Live variable: i ENTRY d1: i = m 1 d2: j = n d3: a = d4: = i + 1 d5: j = j - 1 d6: a = i + 1 d7: i = EXIT 49

18 Flow of information Live variable: j ENTRY d1: i = m 1 d2: j = n d3: a = d4: = i + 1 d5: j = j - 1 d6: a = i + 1 d7: i = EXIT 50

19 Implications Should try to propagate information in the direction of the flow For speed of conversion, not for correctness Reaching definitions: forward problem Information flows in the direction of the CFG, from ENTRY to EXIT Live variables: backward problem Information flows from EXIT to ENTRY 51

20 Implementation ENTRY d1: i = m 1 d2: j = n d3: a = d4: i = i + 1 d5: j = j - 1 d6: a = d7: i = Flow graph as used when EXIT computing reaching definitions 52

21 Implementation EXIT d1: i = m 1 d2: j = n d3: a = d4: i = i + 1 d5: j = j - 1 d6: a = d7: i = Flip flow graph when computing ENTRY live variables 53

22 Def-use and use-def chains Store information about reaching definitions as lists For each use of a variable include in the list all definitions that reach this use (use-def chain) For each definition of a variable include in the list all uses of this variable (def-use chain) DU chains or UD chains for short Can be obtained from solution to global data flow problem 54

23 UD chains ENTRY d 1 : i = m 1 d 2 : j = n d 3 : a = IN(B1) OUT(B1) {d 1,d 2,d 3 } d 4 : i = i + 1 d 5 : j = j - 1 IN(B2) OUT(B2) {d 1,d 2,d 3,d 5,d 6,d 7 } {d 3,d 4,d 5,d 6 } d 6 : a = IN(B3) OUT(B3) {d 3,d 4,d 5,d 6 } {d 4,d 5,d 6 } d 7 : i = IN(B4) OUT(B4) {d 3,d 4,d 5,d 6 } {d 3,d 5,d 6,d 7 } EXIT 55

24 56

25 DU chains ENTRY d 1 : i = m 1 d 2 : j = n d 3 : a = IN(B1) OUT(B1) {d 1,d 2,d 3 } d 4 : i = i + 1 d 5 : j = j - 1 IN(B2) OUT(B2) {d 1,d 2,d 3,d 5,d 6,d 7 } {d 3,d 4,d 5,d 6 } d 6 : a = IN(B3) OUT(B3) {d 3,d 4,d 5,d 6 } {d 4,d 5,d 6 } d 7 : i = IN(B4) OUT(B4) {d 3,d 4,d 5,d 6 } {d 3,d 5,d 6,d 7 } EXIT 58

26 59

27 ENTRY UD/DU chains Show the DU and UD chains r = 3 s = t t = u r = r + 1 v = r * s s = 0 s = s + 1 u = r + s w = u + 2 EXIT 60

28 61

29 Program analysis Compiler needs information Specific problem Devise flow analysis to compute information Can we think of other kinds of information that might be useful to the compiler? 63

: Compiler Design. 9.5 Live variables 9.6 Available expressions. Thomas R. Gross. Computer Science Department ETH Zurich, Switzerland

: Compiler Design. 9.5 Live variables 9.6 Available expressions. Thomas R. Gross. Computer Science Department ETH Zurich, Switzerland 252-210: Compiler Design 9.5 Live variables 9.6 Available expressions Thomas R. Gross Computer Science Department ETH Zurich, Switzerland Outline Warp up reaching definifons Live variables Available expressions