(b). Identify all basic blocks in your three address code. B1: 1; B2: 2; B3: 3,4,5,6; B4: 7,8,9; B5: 10; B6: 11; B7: 12,13,14; B8: 15;

Transcription

1 (a). Translate the program into three address code as defined in Section 6.2, dragon book. (1) i := 2 (2) if i > n goto (7) (3) a[i] := TRUE (4) t2 := i+1 (5) i := t2 (6) goto (2) (7) count := 0 (8) s := sqrt(n) (9) i := 2 (10) if i > s goto (23) (11) if a[i]!= TRUE goto (20) (12) t4 := count +1 (13) count := t4 (14) j := 2*i (15) if j > n goto (20) (16) a[j] := FALSE (17) t6 := j+1 (18) j := t6 (19) goto (15) (20) t7 := i+1 (21) i := t7 (22) goto (10) (23)exit (b). Identify all basic blocks in your three address code. B1: 1; B2: 2; B3: 3,4,5,6; B4: 7,8,9; B5: 10; B6: 11; B7: 12,13,14; B8: 15;

2 B9: 16,17,18,19; B10: 20,21,22; B11: 23 (c). Build the flow graph for the three address code. (1) i := 2 B1 (2) if i > n goto (7) B2 (3) a[i] := TRUE (4) t2 := i+1 (5) i := t2 (6) goto (2) B3 (7) count := 0 (8) s := sqrt(n) (9) i := 2 B4 (10) if i > s goto (23) B5 (11) if a[i]!= TRUE goto (20) B6 (12) t4 := count +1 (13) count := t4 (14) j := 2*i B7 (15) if j > n goto (20) B8 (16) a[j] := FALSE (17) t6 := j+1 (18) j := t6 (19) goto (15) B9 (20) t7 := i+1 (21) i := t7 (22) goto (10) B10 (23)exit B11

3 (d). Build the dominator tree and identify the back edges in your flow graph in (c) Flow graph Dominator tree Back edges are (10,5), (9,8), (3,2) (shown as the red edge of the flow graph). (e). Find the entry node and the set of nodes in the natural loop associated with each back edge identified in (d). back edge (10,5): entry code 5 code sets {5,6,7,8,9,10} back edge (9,8): entry code 8 code sets {8,9} back edge (3,2): entry code 2 code sets {2,3}

4 (a) Compute Gen and Kill sets for each block in the flow graph. Gen[B1] = {(1),(2)} Kill[B1] = {(8),(10),(11)} Gen[B2] = {(3),(4)} Kill[B2] = {(5),(6)} Gen[B3] = {(5)} Kill[B3] = {(4),(6)} Gen[B4] = {(6),(7)} Kill[B4] = {(4),(5),(9)} Gen[B5] = {(8),(9)} Kill[B5] = {(2),(7),(11)} Gen[B6] = {(10),(11)} Kill[B6] = {(1),(2),(8)} (b) Compute the In and Out sets for each block in the flow graph. Initialization: In[B1] = Out[B1] = Gen[B1] = {(1),(2)} In[B2] = Out[B2] = Gen[B2] = {(3),(4)} In[B3] = Out[B3] = Gen[B3] = {(5)} In[B4] = Out[B4] = Gen[B4] = {(6),(7)} In[B5] =

5 Out[B5] = Gen[B5] = {(8),(9)} In[B6] = Out[B6] = Gen[B6] = {(10),(11)} Update: 1. In[B1] = Out[B1] = Gen[B1] (In[B1]-Kill[B1]) = {(1),(2)} In[B2] = Out[B1] Out[B5] ={(1),(2), (8),(9)} Out[B2] = Gen[B2] (In[B2]-Kill[B2]) = {(1),(2), (3),(4), (8),(9)} In[B3] = Out[B2] Out[B4] ={(1),(2),(3),(4),(6),(7),(8),(9)} Out[B3] = Gen[B3] (In[B3]-Kill[B3]) = {(1),(2),(3),(5),(7),(8),(9)} In[B4] = Out[B3] ={(1),(2),(3),(5),(7),(8),(9)} Out[B4] = Gen[B4] (In[B4]-Kill[B4]) = {(1),(2),(3),(6),(7),(8)} In[B5] = Out[B3] = {(1),(2),(3),(5),(7),(8),(9)} Out[B5] = Gen[B5] (In[B5]-Kill[B5]) = {(1),(3),(5),(8),(9)} In[B6] = Out[B5] ={(1),(3),(5),(8),(9)} Out[B6] = Gen[B6] (In[B6]-Kill[B6]) = {(3),(5),(9),(10),(11)} 2. In[B1] = Out[B1] = Gen[B1] (In[B1]-Kill[B1]) = {(1),(2)} In[B2] = Out[B1] Out[B5] ={(1),(2), (5),(6),(8),(9)} Out[B2] = Gen[B2] (In[B2]-Kill[B2]) = {(1),(2), (3),(4), (8),(9)} In[B3] = Out[B2] Out[B4] ={(1),(2), (3),(4), (6),(7),(8),(9)} Out[B3] = Gen[B3] (In[B3]-Kill[B3]) = {(1),(2), (3),(5),(7),(8),(9)} In[B4] = Out[B3] ={(1),(2), (3),(5),(7),(8),(9)} Out[B4] = Gen[B4] (In[B4]-Kill[B4]) = {(1),(2),(3),(6),(7),(8)} In[B5] = Out[B3] = {(1),(2),(3),(5),(7),(8),(9)} Out[B5] = Gen[B5] (In[B5]-Kill[B5]) = {(1),(3),(5),(8),(9)} In[B6] = Out[B5] ={(1),(3),(5),(8),(9)} Out[B6] = Gen[B6] (In[B6]-Kill[B6]) = {(3),(5),(9),(10),(11)} Reached fixed point (c) Perform constant propagation and constant folding. B1: In: no definition of a and b Out: a = 1; b =2 B2: In: a = 1; b = *; c = *; d = *; e = *; Out: a = 1; b = *; c = *; d = *; e = *; B3: In: a = 1; b = *; c = *; d = *; e = *; Out: a = 1; b = *; c = *; d = *; e = *; B4: In: a = 1; b = *; c = *; d = *; e = *; Out: a = 1; b = *; c = *; d = *; e = *; B5: In: a = 1; b = *; c = *; d = *; e = *; Out: a = 1; b = *; c = *; d = *; e = *;

6 B6: In: a = 1; b = *; c = *; d = *; e = *; Out: a = *; b = *; c = *; d = *; e = *; (d) Perform common sub expression elimination. Update Gen and Kill sets: Gen[B1] = Kill[B1] = Gen[B2] = {c = a+b, d = c-a} Kill[B2] = {d = b+d, a = b*d, b = a-d, e = c-a} Gen[B3] = {d = b+d} Kill[B3] = {a = b*d, b = a-d, d = a+b} Gen[B4] = {d = a+b, e = e+1} Kill[B4] = {d = b+d, a = b*d, b = a-d} Gen[B5] = {b = a+b, e = c-a} Kill[B5] = {c = a+b, d = b+d, d = a+b, e = e+1, a = b*d} Gen[B6] = {a = b*d, b = a-d} Kill[B6] = {c = a+b, d = c-a, d = b+d, d = a+b, b = a+b, e = c-a} Update In and Out sets In[B1] = Out[B1] = Gen[B1] (In[B1]-Kill[B1]) = In[B2] = Out[B1] Out[B5] = Out[B2] = Gen[B2] (In[B2]-Kill[B2]) = {c = a+b, d = c-a} In[B3] = Out[B2] Out[B4] = Out[B3] = Gen[B3] (In[B3]-Kill[B3]) = {d = b+d} In[B4] = Out[B3] = { d = b+d } Out[B4] = Gen[B4] (In[B4]-Kill[B4]) = {d = a+b, e = e+1 } In[B5] = Out[B3] = { d = b+d } Out[B5] = Gen[B5] (In[B5]-Kill[B5]) = {b = a+b, e = c-a} In[B6] = Out[B5] = {b = a+b, e = c-a} Out[B6] = Gen[B6] (In[B6]-Kill[B6]) = {a = b*d, b = a-d} Final In and Out sets In[B1] = Out[B1] = Gen[B1] (In[B1]-Kill[B1]) = In[B2] = Out[B1] Out[B5] = Out[B2] = Gen[B2] (In[B2]-Kill[B2]) = {c = a+b, d = c-a} In[B3] = Out[B2] Out[B4] = {c,d = a+b} Out[B3] = Gen[B3] (In[B3]-Kill[B3]) = {d = b+d, c,d = a+b } In[B4] = Out[B3] ={ d = b+d, c,d = a+b } Out[B4] = Gen[B4] (In[B4]-Kill[B4]) = { c,d = a+b, e = e+1} In[B5] = Out[B3] = { d = b+d, c = a+b } Out[B5] = Gen[B5] (In[B5]-Kill[B5]) = {b,c,d = a+b, e = c-a} In[B6] = Out[B5] = {b,c,d = a+b, e = c-a} Out[B6] = Gen[B6] (In[B6]-Kill[B6]) = {a = b*d, b = a-d} Do common sub expression elimination:

7 Because c = a+b is in In[B4] set and d = a+b is in B4, for c = a+b in B2 we can replace c = a+b with t1 = a+b; c = t1 and in B4 we can replace d = a+b with d = t1 ; Because c = a+b is in In[B5] set and b = a+b is in B5, for c = a+b in B2 we can replace c = a+b with t1 = a+b; c = t1 and in B5 we can replace b = a+b with b = t1 ; 3. Consider the following flow graph. (a) Identify and mark define-use links within the loop based on data flow analysis results (based on the In and Out sets). You need to consider the block level define-use relations as well as define-use relations within the block.

8 (b) Identify all the loop invariants based on the define-use links computed in (b). Assume that all the loop invariants can be moved out of the loop. So you need to find loop invariants repetitively till a fixed point is reached. In each round, you need to pretend to move out those loop invariants you found in the previous rounds. Round 1: B2: Statement N = 100, N is loop invariant, move N = 100 out of the loop; Statement M = 1000, M is loop invariant, move M = 1000 out of the loop; Statement s1 = 2, s1 is loop invariant, move s1 = 2 out of the loop; B3: Statement s1 = 1, s1 is loop invariant, move s1 = 1 out of the loop; B4: Statement s2 = 2, s2 is loop invariant, move s2 = 2 out of the loop; Round2: B2: move statement t2 = t1+s1 out of the loop; B7: Statement M = M-1, M is loop invariant, move M = M-1 out of the loop; Round3: B3: move t2 = t2-n out of the loop; Round4: B4: move t3 = t2+s2 out of the loop; Round 5: B5: move t3 = t3-n out of the loop

9 Round6: B6: move d = A[t1] + A[t2] out of the loop Round7: B7: move d = d-m out of the loop Round8: B8: move A[t3] = d out of the loop (c) For each loop invariant, determine whether it can actually be moved out of the loop. If so, move it out of the loop. If not, state the reason why it cannot be moved out. Generate the new code after code motion.

10 Round 1: B2: Statement N = 100, N is loop invariant, move N = 100 out of the loop; Can be moved out of the loop. Statement M = 1000, M is loop invariant, move M = 1000 out of the loop; Cannot be moved out of the loop, because there is other definition of M in the loop, say M = M-1 in B7. Statement s1 = 2, s1 is loop invariant, move s1 = 2 out of the loop; Cannot be moved out of the loop, because there is other definition of s1 in the loop, say s1 = 1 in B3. B3: Statement s1 = 1, s1 is loop invariant, move s1 = 1 out of the loop; Cannot be moved out of the loop, because there is other definition of s1 in the loop, say s1 = 2 in B2. B4: Statement s2 = 2, s2 is loop invariant, move s2 = 2 out of the loop; Can be moved out of the loop. Round2: B2: move statement t2 = t1+s1 out of the loop; Cannot be moved out of the loop, because s1 is defined inside the loop. B7: Statement M = M-1, M is loop invariant, move M = M-1 out of the loop; Cannot be moved out of the loop, because there is other definition of M in the loop, say M = 1000 in B2. Round3: B3: move t2 = t2-n out of the loop; Cannot be moved out of the loop, because t2 is defined inside the loop. Round4: B4: move t3 = t2+s2 out of the loop; Cannot be moved out of the loop, because t2 is defined inside the loop. Round 5: B5: move t3 = t3-n out of the loop Cannot be moved out of the loop, because t3 is defined inside the loop. Round6: B6: move d = A[t1] + A[t2] out of the loop Cannot be moved out of the loop, because t2 is defined inside the loop. Round7: B7: move d = d-m out of the loop Cannot be moved out of the loop, because d and M is defined inside the loop. Round8: B8: move A[t3] = d out of the loop Cannot be moved out of the loop, because t3 is defined inside the loop. The new code generated after code motion:

11 (a) Perform copy propagation. You need to do necessary data flow analysis to make sure that the propagation can be done correctly. (added additional rule: A[j] := y op z shall be killed if the current block contains x := A[i], that is, we should add A[j] := y op z in the kill[b] if B contains x:=a[i] ) Gen[1] = kill[1] = ; In[1]=Out[1]= Gen[2] = kill[2] = ; In[2]=Out[2]= Gen[3] = {3}, Kill[3] = {10,14}; In[3] =, Out[3] = {3}; Gen[4] = {4}, Kill[4] = ; In[4] = {3}, Out[4] = {3,4} Gen[5] = kill[5] = ; In[5] = {3,4}, Out[5] = {3,4} Gen[6] = kill[6] = ; In[6] = {3,4}, Out[6] = {3,4}

12 Gen[7] = {7}, Kill[7] = {10,14}; In[7] = {3,4}, Out[7] = {3,4,7} Gen[8] = kill[8] = ; In[8] = {3,4,7}, Out[8] = {3,4,7} Gen[9] = kill[9] = ; In[9] = {3,4,7}, Out[9] = {3,4,7} Gen[10] = {10}, Kill[10] = {3,7,14}; In[10] = {3,4,7}, Out[10] = {4,10} Gen[11] = {11}, Kill[10] = ; In[11] = {4,10}, Out[11] = {4,10,11} Gen[12] = kill[12] = ; In[12] = {4,10,11}, Out[12] = {4,10,11} Gen[13] = kill[13] = ; In[13] = {4,10,11}, Out[13] = {4,10,11} Gen[14] = {14}, Kill[14] = {3,10}; In[14] = {4,10,11}, Out[14] = {4,11,14} Statement 6 uses t3, statement 4 reaches statement 6, statement 4 is the only definition for t3 that reaches statement 6, no definition of j on the path from 4 to 6, thus we can substitute the use of t3 by j in 6. Statement 13 uses t9, 11 reaches 13, 11 is the only definition of t9 that reaches 13, no definition of j on the path from 11 to 13, thus we can substitute the use of t9 by j in 13. (b) Perform dead code elimination. You need to do necessary analysis to make sure that the elimination can be done correctly. Also, assume that after the basic block, A[i], for all i, are alive and no other variables are alive. After performing the copy propagation, the three address code should be revised as following: (1) t1 = j 1 (2) t2 = 4 * t1 (3) temp = A[t2] (4) t3 = j (5) t4 = j + 1 (6) t5 = 4 * j (7) t6 = A[t5] (8) t7 = j 1 (9) t8 = 4 * t7 (10) A[t8] = t6 (11) t9 = j (12) t10 = j + 1 (13) t11 = 4 * j (14) A[t11] = temp We just consider index of A[i], which is i, when come across A[i]. Let P(i) denotes the live set after statement i, for 1<=i<=14, then: P A = P(14) = P(13) = {P(14)} {temp, t11} = {temp,t11} P(12) = {P(13) t11} {j} = {temp, j} P(11) = {P(12) - t10} {j} = {temp, j} P(10) = {P(11) t9} {j} = { temp, j} P(9) = {P(10)} {t6, t8} = { temp, t6, t8, j} P(8) = {P(9) t8} {t7} = { temp, t6, t7, j} P(7) = {P(8) t7} {j} = { temp, t6, j} P(6) = {P(7) t6} {t5} = { temp, t5, j} P(5) = {P(6) t5} {j} = { temp, j} P(4) = {P(5) t4} {j} = { temp, j}

13 P(3) = {P(4) t3} {j} = { temp, j} P(2) = {P(3) temp} {t2} = {t2, j} P(1) = {P(2) t2} {t1} = {t1, j} P B = {P(2) t1} {j} = {j} 12 can be eliminated because t10 is defined in 12, but t10 is not included in P(12) = {t2,j}. 11 can be eliminated because t9 is defined in 11, but t9 is not included in P(11) = {t2,j}. 5 can be eliminated because t4 is defined in 5, but t4 is not included in P(5) = {t2, j} 4 can be eliminated because t3 is defined in 4, but t3 is not included in P(4) = {t2, j} Definition of t1 in loop B2 is: t1 := t1+2, also within B2, t2 is defined as a linear function of t1: t2 := t1*3+5, t1 and t2 are only defined once in B2. Thus we can perform strength reduction for induction variables t1 and t2: Create a new variable st2 immediately before the entry of B2; Initialize st2 by using st2 := t1*3+5 ; Add st2 := st2 + 6 immediately after t1 := t1+2 ; Replace t2 := t1*3+5 by t2 := s2 ; The revised code is as following:

14 t1 := 0 read (x, y) st2 := t1*3+5 a := x * t1 t2 := st2 b := y * t2 c := t2 + 5 d := c * b t1 := t1 + 2 st2 := st2 + 6 There is no more induction variables can be found.