: Advanced Compiler Design Compu=ng DF(X) 3.4 Algorithm for inser=on of φ func=ons 3.5 Algorithm for variable renaming

Transcription

1 : Advanced Compiler Design Compu=ng DF(X) 3.4 Algorithm for inser=on of φ func=ons 3.5 Algorithm for variable renaming Thomas R. Gross Computer Science Department ETH Zurich, Switzerland

2 Outline 3.1 Graphs 3.2 Approaches to inser=on of φ func=ons 3.3 Dominance fron=er 3.4 Algorithm for inser=on of φ func=ons 3.5 Algorithm for variable renaming 3.6 Example 2

3 3.3.1 Introduc=on Control flow graph summarizes program. Dominance fron=er computed for control flow graph. Deal with defini.ons of a variable in the control flow node Defini.on d in node Q insert φ func.on in node N in dominance fron.er of Q. Given a node Q in the control flow graph. The dominance fron=er DF(Q) is the set of nodes { N k } such that Q dom N k At least one predecessor P of N k is dominated by Q: Q dom P DF(Q) = { N path from Q to N, (Q N), direct predecessor P of N s.t. Q P } 3

4 Dominance fron=ers Q B N 1 4

5 Dominance fron=ers DF(Q) Q B B N Q N 1 N 1 5

6 7

7 DF UP (Y) A node N DF(child) is DF(parent) if (parent N) DF UP (Y) = { N N DF(Y) and ( Parent(Y) N) } Parent(Y) = idom (Y) 8

8 Compu=ng DF(X) ENTRY X B Y X B Z 1 Z 2 Z 1 Z 2 Y DF(Y) = { Z 1, Z 2 } DF UP (Y) = { Z 1, Z 2 } 9

9 ENTRY X Y X Z 1 Z 1 Z 2 Y Z 2 DF(Y) = { Z 1, Z 2 } DF UP (Y) = { Z 1 } 10

10 DF(X) Node X with children Y 1, Y 2, DF(X) contains those nodes from DF(Y 1 ), DF(Y 2 ), that are not dominated by X DF(X) contains the nodes from DF UP (Y 1 ), DF UP (Y 2 ), DF(X) = ( DF UP (Y i ) with Y i child of X) (other_nodes) 11

11 What other nodes belong to DF(X)? DF(X) = { N path from X to N, (X N), predecessor P of N s.t. X P } Direct successors of X that are not dominated (trivially) belong to DF(X) X B ENTRY Y X B Z 1 Z 3 Z 1 Z 2 Z 3 Y Z 2 12

12 DF Local (X) DF Local (X) is the set of nodes N that are direct successors of X but not descendants DF Local (Y) = { Z 1, Z 2 } DF Local (X) = {Z 3 } 13

13 Incremental computa=on of DF(X) DF (X) = DF Local (X) ( ( DF UP (Y i ) with Y i child of X)) Proof 14

14 Incremental computa=on of DF(X) DF (X) = DF Local (X) ( ( DF UP (Y i ) with Y i child of X)) DF Local (X) : Set of nodes in DF(X) determined by (CFG) successors DF UP (Y) : Set of nodes in DF(X) contributed by children Y of X 15

15 Efficient computa=on Compute DF Local (X): inspect all direct CFG successors Usually a small number Assume DF(Y) has been computed for all children Y i of X Get DF UP (Y i ): all nodes N DF (Y i ) with ( X N) 16

16 18

17 20

18 Compu=ng DF Local (X) DF Local (X) = { N N is a direct successor of X, ( X N) N s. t. X N and N direct predecessor of N } Really easy if X is a leaf node of the DT No children in dominator tree only direct successors must be inspected 21

19 DF for leafs DF (X) = DF Local (X) ( ( DF UP (Y i ) with Y i child of X)) Leaf nodes have no children X leaf node: DF (X) = DF Local (X) 22

20 3.3.3 Puing DF Local and DF UP together DF(X) = DF Local (X) ( ( DF UP (Y i ) with Y i child of X)) Must combine DF Local and DF UP of children 23

21 Visit nodes N in a bolom-up traversal of the DT for each node N { DF(N) = for each node X, X successor of N { if ( idom(x) N) { DF(N) = DF(N) { X } } } for each node Z, Z child of N { for each Y DF(Z) { if ( idom(y) N ) { DF(N) = DF(N) { Y } } } } 24

22 27

23 Find DF(X) for this CFG ENTRY EXIT 6 28

24 33

25 3.4 Algorithm for inser=on of φ func=ons Given a CFG, DF for all nodes (blocks) For each variable V, we need List of all nodes that contain defini.ons of V (Basic blocks with assignments to V) Call this list ASSIGN(V) Idea: insert φ func=ons for V for all CFG nodes in ASSIGN(V) Check if inser.ng a φ func.on (a special assignment, creates new version) requires inser.on of addi.onal φ func.ons has_φ_fct(x): true for a block X in CFG iff X contains a φ func=on for V worklist W: set of blocks (nodes) s=ll to be processed 34 added_to_worklist(x): true for block X iff has been added to W

26 Implementa=on concerns Need to keep track where a φ func=on is inserted One op=on: bit vector Length: number of basic blocks (nodes in CFG) Drawback: poten=ally inefficient Beler idea: use integer (counter) to keep track of processing CFG nodes Record when a φ func.on is inserted has_φ_fct(x) = C with C integer, C itera.on when φ func.on is inserted added_to_worklist(x) = C with C integer, C itera.on when added to W 35

27 int count = 0 for each node X in CFG { has_φ_fct(x) = count added_to_worklist(x) = count } 36

28 for all variables V { count ++ W = ASSIGN(V) for all X ASSIGN(V) { added_to_worklist(x) = count } while ( W ) { pick B from W, remove B from W for all nodes Y DF(B) { if ( has_φ_fct(y) < count ) { insert φ func=on into Y has_φ_fct(y) = count if (added_to_worklist(y) < count) { add Y to W, added_to_worklist(y) = count } } // if no φ_fct } // for all nodes in DF } // while // for all variables 37

29 Example 0 ENTRY a = b = 1 2 b = a = 9 5 EXIT 6 b = 38

30 Example 0 ENTRY a = b = 1 2 b = 3 a = φ(, ) b = φ(, ) a = φ(, ) b = φ(, ) a = 9 a = φ(, ) b = φ(, ) EXIT 5 6 b = 42

31 3.5 Renaming variables Given a CFG, with φ func=ons inserted Given a statement S in block B of the CFG, find version(s) for all variables V on the RHS (or in an expression) on the LHS in a φ func.on 44

32 46

33 47

34 Pick version Inside region dominated by B Use version assigned in B Unless there is a more recent version Inside region dominated by C.. and so on Process nodes of the CFG in the order defined by DT Assume C is processed before A Make sure to use in A version defined in B restore old set of versions when done with C 49

35 Stack of versions For each variable V: stack of versions stack[v] Ini=ally empty For each variable: counter counter[v] Ini=alized to 0 50

36 Process (basic block X) { for all statements S in X { if ( S is not a φ func=on) { for each variable V in RHS { replace V with V i = Stack[V].top } // RHS for each variable V on the LHS { c = counter[v] Stack[V].push( c ) replace V with V c on the LHS counter[v] = c + 1 } // LHS 51 } // for all statements

37 for all successors Y of X { for all φ func=ons F in Y { let V be the LHS of F let X be the k-th predecessor of Y set the k-th argument of F to V i = Stack[V].top } // for all φ func=ons } // for all successors 52

38 for all children C of X { Process ( C ) } for all assignments A in X { if V is set by A { Stack[V].pop } } // for all assignments } // for all blocks 53

39 No need to insert φ func=ons into EXIT node 54

40 Example 0 ENTRY a = b = 1 2 b = 3 a = φ(, ) b = φ(, ) a = φ(, ) b = φ(, ) a = 9 a = φ(, ) b = φ(, ) EXIT 5 6 b = 57

41 Insert φ func:ons ENTRY 1 X = 2 = X 3 X = = X 4 5 X = = X 6 7 = X EXIT 61

42 Rename variables ENTRY 1 X = 2 = X 3 X = = X 4 =φ (, ) = X 5 X = 6 7 =φ (, ) = X =φ (, ) EXIT 62

43 SSA format DF(X) = { N path from X to N, (X N), direct predecessor P of N s.t. X P } DF (X) = DF Local (X) ( ( DF UP (Y i ) with Y i child of X)) Given node N with assignment to V, insert φ func=ons for V into DF(N) May trigger more inser.ons of φ func.ons Rename variables, insert arguments for φ func=on 63