Lösungsvorschläge zum Übungsblatt 11: Übersetzung von Programmiersprachen (WS 05/06)

Transkript

1 Prof. Dr. A. Poetzsch-Heffter Dipl.-Inform. M. Gawkowski Technische Universität Kaiserslautern Fachbereich Informatik AG Softwaretechnik Lösungsvorschläge zum Übungsblatt 11: Übersetzung von Programmiersprachen (WS 05/06) Aufgabe 1 Points-to-Graph In dieser Lösung werden wir den Points-to-Graph für das folgende Programm zeigen: import java.lang.integer; class Exp { String unparse () {return "";; class Int extends Exp { private Integer i; Int(Integer ii) {i=ii; String unparse(){ return i.tostring(); class Id extends Exp { private String id; Id(String idd) {id=idd; String unparse(){ return id; class Plus extends Exp { private Exp l, r; Plus(Exp ll, Exp rr) {l=ll; r=rr; String unparse(){ return "(" + l.unparse() + "+" + r.unparse() + ")"; class Prog { public static void main(string args []) { Integer i1 = new Integer(1); Integer i2 = new Integer(2); String v3 = new String("3"); Exp x1 = new Int(i1); Exp x2 = new Int(i2); Exp x3 = new Id(v3); Exp e1 = new Plus(x1,x2); Exp e2 = new Plus(e1,x3); Siehe Abbildung 1 Aufgabe 2 Lebendigkeistsanalyse In dieser Lösung werden wir zeigen, wir man die in- und out-mengen für alle Basisblöcke eines Programms iterativ, durch einen Fixpunkt-Algorithmus berechnen kann. Um den Algorithmus auf den zu dem Programm Kontrollflussgraphen anwenden zu können muss Folgendes vorgeleistet werden:

2 ll e2 rr Plus_2 l r e1 ll rr Plus_1 l r Id_x3 x3 idd x1 ii Int_i1 Int_i2 x2 ii id i i i1 value i2 v3 Integer_1 value Integer_2 original String_3 Abbildung 1: Points-to-Graph für das Java Programm aus Aufgabe 1. Die virtuellen Variablen rr, ll, ii, idd, value und original wurden für die formalen Parameter der entsprechenden Konstruktoren eingeführt. 1. Im ersten Schritt müssen die Blöcke durchnumeriert werden. Die Nummerierung der Blöcke für diese Lösung kann aus Abbildung 2 entnommen werden. 2. Im zweiten Schritt müssen die gen- und kill-mengen für jedes Block B i berechnet werden. Im Folgenden werden zur Erinnerung noch einmal die Berechnungsvorschriften für diese Mengen noch einmal aufgestellt, siehe die Vorlesungsfolie Nr. 204: Die Menge gen(b i ) für ein Block B i ist die Menge der Variablen v, so dass v in B i eine Anwendung besitzt, der keine Definition von v vorausgeht. Die Menge kill(b i ) für ein Block B i ist die Menge der Variablen v, die in B i definiert werden. Nachdem diese Mengen für jedes Block berechnet wurden, ändern sie sich während der Berechnung nicht mehr und können als globale Konstanten des Fixpunkt-Algorithmus gesehen werden. Für unser Programm ergeben sich die folgenden Werte für die gen- und kill-mengen: gen(b 0 ) = {a, b, d, e, v 1 kill(b 0 ) = {v 1, v 0, c gen(b 1 ) = {g, h, i kill(b 1 ) = {d, f gen(b 2 ) = {c, h kill(b 2 ) = {a, b gen(b 3 ) = {i, f, g kill(b 3 ) = {b, c gen(b 4 ) = { kill(b 4 ) = {c, d 3. Im dritten Schritt werden die in- und out-mengen für alle Blöcke des Programms initialisiert. Da laut der Aufgabenstellung keine Variablen am Ende des Programms lebendig sein sollen, wird die out-menge des Basisblocks B 4 mit dem Wert { initialisiert. In der Praxis müsste man hier noch zwischen den Gegenständen der Lebendigkeitsanalyse unterscheiden: wäre zum Beispiel das zu untersuchende Programmstück nur eine Unterprozedur eines Programms, dann müsste man den Wert der out-menge des Prozedurausgangsblocks mit dem Wert {v i v i globale Variable initialisieren. Alle anderen in- und out-mengen des Programms werden während der Initialisierungsphase mit dem Wert { initialisiert. Für unser Programm ergeben die folgenden Werte 2

3 für die in- und out-mengen: out 0 (B 4 ) = { in 0 (B 4 ) = { out 0 (B 3 ) = { in 0 (B 3 ) = { out 0 (B 2 ) = { in 0 (B 2 ) = { out 0 (B 1 ) = { in 0 (B 1 ) = { out 0 (B 0 ) = { in 0 (B 0 ) = { Da bei der Lebendigkeitsanalyse die in- und out-mengen Kontrollfluss-aufwärts berechnet werden (Rückwärtsanalyse), haben wir gleich die Reihenfolge der zu berechnenden Mengen vertauscht, um die Reihenfolge der Berechnung in jeder Iteration zu verdeutlichen. Im Allgemeinen ist die Berechnung in der ursprünglichen Reihenfolge auch möglich jedoch ist sie weniger effizient, dazu siehe das Buch Modern Compiler Implementation in ML von Andrew W. Appel. B0 [1] v0 := v1 [2] v1 := a +b [3] c:= d + e [4] if a < b B1 [5] f := g [6] d := h + i [7] if g < h B2 [8] a := 7 [9] b := 8 [10] if c < h B3 [11] b := f + g [12] c := 2 + i [13] c := 5 [14] d := 2 * c B4 Abbildung 2: Der Eingabe-Kontrollflussgraph mit durchnummerierten Programmpunkten und Basisblöcken Jeder der unten aufgeführten Iterationsschritten wird nach dem folgenden Algorithmus durchgeführt: j := j + 1; B i set[b 4, B 3, B 2, B 1, B 0 ].{ out j (B i ) := out j 1 (B i ); in j (B i ) := in j 1 (B i ); B i set[b 4, B 3, B 2, B 1, B 0 ].{ out j (B i ) := B p succ(b i) in j(b p ) in j (B i ) := gen(b i ) (in j (B i ) kill(b i )) 3

4 Die Berechung der in- und out-mengen in der ersten Iteration: out 1 (B 4 ) = { in 1 (B 4 ) = gen(b 4 ) (out 1 (B 4 ) kill(b 4 )) = { ({ {c, d) = { out 1 (B 3 ) = in 1 (B 4 ) = { in 1 (B 3 ) = gen(b 3 ) (out 1 (B 3 ) kill(b 3 )) = {i, f, g ({ {b, c) = {i, f, g out 1 (B 2 ) = in 1 (B 4 ) in 1 (B 0 ) = { { = { in 1 (B 2 ) = gen(b 2 ) (out 1 (B 2 ) kill(b 2 )) = {c, h ({ {a, b) = {c, h out 1 (B 1 ) = in 1 (B 2 ) in 1 (B 3 ) = {c, h {i, f, g = {c, f, g, h, i in 1 (B 1 ) = gen(b 1 ) (out 1 (B 1 ) kill(b 1 )) = {g, h, i ({c, f, g, h, i {d, f) = {c, g, h, i out 1 (B 0 ) = in 1 (B 0 ) in 1 (B 1 ) = { {c, g, h, i = {c, g, h, i in 1 (B 0 ) = {gen(b 0 ) (out 1 (B 0 ) kill(b 0 )) = {a, b, d, e, v 1 ({c, g, h, i {v 1, v 0, c) = {a, b, d, e, g, h, i, v 1 out 0 (B 4 ) = out 1 (B 4 ) in 0 (B 4 ) = in 1 (B 4 ) out 0 (B 3 ) = out 1 (B 3 ) in 0 (B 3 ) in 1 (B 3 ) out 0 (B 2 ) = out 1 (B 2 ) in 0 (B 2 ) in 1 (B 2 ) out 0 (B 1 ) out 1 (B 1 ) in 0 (B 1 ) in 1 (B 1 ) out 0 (B 0 ) out 1 (B 0 ) in 0 (B 0 ) in 1 (B 0 ) ist der Fixpunkt nach der ersten Iteration noch nich erreicht und wir müssen weiter rechnen. Die Berechung der in- und out-mengen in der zweiten Iteration: out 2 (B i 4) = { in 2 (B 4 ) = gen(b 4 ) (out 2 (B 4 ) kill(b 4 )) = { ({ {c, d) = { out 2 (B 3 ) = in 2 (B 4 ) = { in 2 (B 3 ) = gen(b 3 ) (out 2 (B 3 ) kill(b 3 )) = {i, f, g ({ {b, c) = {i, f, g out 2 (B 2 ) = in 2 (B 4 ) in 2 (B 0 ) = { {a, b, d, e, g, h, i, v 1 = {a, b, d, e, g, h, i, v 1 in 2 (B 2 ) = gen(b 2 ) (out 2 (B 2 ) kill(b 2 )) = {c, h ({a, b, d, e, g, h, i, v 1 {a, b) = {c, d, e, g, h, i, v 1 out 2 (B 1 ) = in 2 (B 2 ) in 2 (B 3 ) = {c, d, e, g, h, i, v 1 {i, f, g = {c, d, e, f, g, h, i, v 1 in 2 (B 1 ) = gen(b 1 ) (out 2 (B 1 ) kill(b 1 )) = {g, h, i ({c, d, e, f, g, h, i, v 1 {d, f) = {c, e, g, h, i, v 1 out 2 (B 0 ) = in 2 (B 0 ) in 2 (B 1 ) = {a, b, d, e, g, h, i, v 1 {c, e, g, h, i, v 1 = {a, b, c, d, e, g, h, i, v 1 in 2 (B 0 ) = {gen(b 0 ) (out 2 (B 0 ) kill(b 0 )) = {a, b, d, e, v 1 ({a, b, c, d, e, g, h, i, v 1 {v 1, v 0, c) = {a, b, d, e, g, h, i, v 1 out 1 (B 4 ) = out 2 (B 4 ) in 1 (B 4 ) = in 2 (B 4 ) out 1 (B 3 ) = out 2 (B 3 ) in 1 (B 3 ) = in 2 (B 3 ) out 1 (B 2 ) out 2 (B 2 ) in 1 (B 2 ) in 2 (B 2 ) out 1 (B 1 ) out 2 (B 1 ) in 1 (B 1 ) in 2 (B 1 ) out 1 (B 0 ) out 2 (B 0 ) in 1 (B 0 ) = in 2 (B 0 ) ist der Fixpunkt nach der zweiten Iteration noch nich erreicht und wir müssen weiter rechnen. 4

5 Die Berechung der in- und out-mengen in der dritten Iteration: out 3 (B 4 ) = { in 3 (B 4 ) = gen(b 4 ) (out 3 (B 4 ) kill(b 4 )) = { ({ {c, d) = { out 3 (B 3 ) = in 3 (B 4 ) = { in 3 (B 3 ) = gen(b 3 ) (out 3 (B 3 ) kill(b 3 )) = {i, f, g ({ {b, c) = {i, f, g out 3 (B 2 ) = in 3 (B 4 ) in 2 (B 0 ) = { {a, b, d, e, g, h, i, v 1 = {a, b, d, e, g, h, i, v 1 in 3 (B 2 ) = gen(b 2 ) (out 3 (B 2 ) kill(b 2 )) = {c, h ({a, b, d, e, g, h, i, v 1 {a, b) = {c, d, e, g, h, i, v 1 out 3 (B 1 ) = in 3 (B 2 ) in 3 (B 3 ) = {c, d, e, g, h, i, v 1 {i, f, g = {c, d, e, f, g, h, i, v 1 in 3 (B 1 ) = gen(b 1 ) (out 3 (B 1 ) kill(b 1 )) = {g, h, i ({c, d, e, f, g, h, i, v 1 {d, f) = {c, e, g, h, i, v 1 out 3 (B 0 ) = in 2 (B 0 ) in 3 (B 1 ) = {a, b, d, e, g, h, i, v 1 {c, e, g, h, i, v 1 = {a, b, c, d, e, g, h, i, v 1 in 3 (B 0 ) = {gen(b 0 ) (out 3 (B 0 ) kill(b 0 )) = {a, b, d, e, v 1 ({a, b, c, d, e, g, h, i, v 1 {v 1, v 0, c) = {a, b, d, e, g, h, i, v 1 out 2 (B 4 ) = out 3 (B 4 ) in 2 (B 4 ) = in 3 (B 4 ) out 2 (B 3 ) = out 3 (B 3 ) in 2 (B 3 ) = in 3 (B 3 ) out 2 (B 2 ) = out 3 (B 2 ) in 2 (B 2 ) = in 3 (B 2 ) out 2 (B 1 ) = out 3 (B 1 ) in 2 (B 1 ) = in 3 (B 1 ) out 2 (B 0 ) = out 3 (B 0 ) in 2 (B 0 ) = in 3 (B 0 ) ist der Fixpunkt nach der dritten Iteration erreicht. Aufgabe 3 Analyse der erreichenden Definitionen Der erste Schritt: Die Blöcke bekommen die gleichen Nummern wie in der vorherigen Aufgabe. Der zweite Schritt: Die gen- und kill-mengen werden folgendermaßen definiert: gen(b 0 ) = {1, 2, 3 kill(b 0 ) = { gen(b 1 ) = {5, 6 kill(b 1 ) = { gen(b 2 ) = {8, 9 kill(b 2 ) = { gen(b 3 ) = {11, 12 kill(b 3 ) = { gen(b 4 ) = {13, 14 kill(b 4 ) = { 5

6 Der dritte Schritt: Die in- und out-mengen werden mit den folgenden Werten initialisiert: in 0 (B 0 ) = { out 0 (B 0 ) = { in 0 (B 1 ) = { out 0 (B 1 ) = { in 0 (B 2 ) = { out 0 (B 2 ) = { in 0 (B 3 ) = { out 0 (B 3 ) = { in 0 (B 4 ) = { out 0 (B 4 ) = { Da bei der Analyse der erreichenden Definitionen die in- und out-mengen dem Kontrollfluss nach abwärts berechnet werden (Abwärtsanalyse), haben wir die Reihenfolge der zu berechnenden Mengen in der Ordnung aufgelistet, die etwa der topologischen Ordnung der Blöcke im Kontrollflussgraph entspricht. Da B i.kill(b i ) = { gilt, können wir unsere Datenflussgleichungen vereinfachen: out j (B i ) = gen j (B i ) (in j (B i ) kill(b i )) = gen j (B i ) in j (B i ) Daraus ergibt sich der folgende Algorithmus für einen Iterationsschritt: j := j + 1; B i set[b 4, B 3, B 2, B 1, B 0 ].{ in j (B i ) := in j 1 (B i ); out j (B i ) := out j 1 (B i ); B i set[b 4, B 3, B 2, B 1, B 0 ].{ in j (B i ) := B p pred(b i) out j(b p ) out j (B i ) := gen(b i ) in j (B i ) Die Berechung der in- und out-mengen in der ersten Iteration: in 1 (B 0 ) = out 1 (B 0 ) out 1 (B 2 ) = { { = { out 1 (B 0 ) = gen(b 0 ) in 1 (B 0 ) = {1, 2, 3 { = {1, 2, 3 in 1 (B 1 ) = out 1 (B 0 ) = {1, 2, 3 out 1 (B 1 ) = gen(b 1 ) in(b 1 ) = {5, 6 {1, 2, 3 = {1, 2, 3, 5, 6 in 1 (B 2 ) = out 1 (B 1 ) = {1, 2, 3, 5, 6 out 1 (B 2 ) = gen(b 2 ) in(b 2 ) = {8, 9 {1, 2, 3, 5, 6 in 1 (B 3 ) = out 1 (B 1 ) = {1, 2, 3, 5, 6 out 1 (B 3 ) = gen(b 3 ) in 1 (B 3 ) = {11, 12 {1, 2, 3, 5, 6 = {1, 2, 3, 5, 6, 11, 12 in 1 (B4) = out 1 (B 2 ) out 1 (B 3 ) {1, 2, 3, 5, 6, 11, 12 = {1, 2, 3, 5, 6, 8, 9, 11, 12 out 1 (B 4 ) = gen(b 4 ) in 1 (B 4 ) = {13, 14 {1, 2, 3, 5, 6, 8, 9 = {1, 2, 3, 5, 6, 8, 9, 13, 14 out 0 (B 0 ) out 1 (B 0 ) in 0 (B 0 ) = in 1 (B 0 ) out 0 (B 1 ) out 1 (B 1 ) in 0 (B 1 ) in 1 (B 1 ) out 0 (B 2 ) out 1 (B 2 ) in 0 (B 2 ) in 1 (B 2 ) out 0 (B 3 ) out 1 (B 3 ) in 0 (B 3 ) in 1 (B 3 ) 6

7 out 0 (B 4 ) out 1 (B 4 ) in 0 (B 4 ) in 1 (B 4 ) ist der Fixpunkt nach der ersten Iteration noch nich erreicht und wir müssen weiter rechnen. Die Berechung der in- und out-mengen in der zweiten Iteration: in 2 (B 0 ) = out 2 (B 0 ) out 2 (B 2 ) = {1, 2, 3 {1, 2, 3, 5, 6, 8, 9 out 2 (B 0 ) = gen(b 0 ) in 2 (B 0 ) = {1, 2, 3 {1, 2, 3, 5, 6, 8, 9 in 2 (B 1 ) = out 2 (B 0 ) out 2 (B 1 ) = gen(b 1 ) in(b 1 ) = {5, 6 {1, 2, 3, 5, 6, 8, 9 in 2 (B 2 ) = out 2 (B 1 ) out 2 (B 2 ) = gen(b 2 ) in(b 2 ) = {8, 9 {1, 2, 3, 5, 6, 8, 9 in 2 (B 3 ) = out 2 (B 1 ) out 2 (B 3 ) = gen(b 3 ) in 2 (B 3 ) = {11, 12 {1, 2, 3, 5, 6, 8, 9 = {1, 2, 3, 5, 6, 8, 9, 11, 12 in 2 (B4) = out 2 (B 2 ) out 2 (B 3 ) {1, 2, 3, 5, 6, 8, 9, 11, 12 = {1, 2, 3, 5, 6, 8, 9, 11, 12 out 2 (B 4 ) = gen(b 4 ) in 2 (B 4 ) = {13, 14 {1, 2, 3, 5, 6, 8, 9, 11, 12 = {1, 2, 3, 5, 6, 8, 9, 11, 12, 13, 14 out 1 (B 0 ) out 2 (B 0 ) in 1 (B 0 ) in 2 (B 0 ) out 1 (B 1 ) out 2 (B 1 ) in 1 (B 1 ) in 2 (B 1 ) out 1 (B 2 ) = out 2 (B 2 ) in 1 (B 2 ) in 2 (B 2 ) out 1 (B 3 ) out 2 (B 3 ) in 1 (B 3 ) = in 2 (B 3 ) out 1 (B 4 ) out 2 (B 4 ) in 1 (B 4 ) = in 2 (B 4 ) ist der Fixpunkt nach der zweiten Iteration noch nich erreicht und wir müssen weiter rechnen. Die Berechung der in- und out-mengen in der dritten Iteration: in 3 (B 0 ) = out 3 (B 0 ) out 3 (B 2 ) {1, 2, 3, 5, 6, 8, 9 out 3 (B 0 ) = gen(b 0 ) in 3 (B 0 ) = {1, 2, 3 {1, 2, 3, 5, 6, 8, 9 in 3 (B 1 ) = out 3 (B 0 ) out 3 (B 1 ) = gen(b 1 ) in(b 1 ) = {5, 6 {1, 2, 3, 5, 6, 8, 9 in 3 (B 2 ) = out 3 (B 1 ) out 3 (B 2 ) = gen(b 2 ) in(b 2 ) = {8, 9 {1, 2, 3, 5, 6, 8, 9 in 3 (B 3 ) = out 3 (B 1 ) out 3 (B 3 ) = gen(b 3 ) in 3 (B 3 ) = {11, 12 {1, 2, 3, 5, 6, 8, 9 = {1, 2, 3, 5, 6, 8, 9, 11, 12 in 3 (B4) = out 3 (B 2 ) out 3 (B 3 ) {1, 2, 3, 5, 6, 8, 9, 11, 12 = {1, 2, 3, 5, 6, 8, 9, 11, 12 out 3 (B 4 ) = gen(b 4 ) in 3 (B 4 ) = {13, 14 {1, 2, 3, 5, 6, 8, 9, 11, 12 = {1, 2, 3, 5, 6, 8, 9, 11, 12, 13, 14 out 2 (B 0 ) = out 3 (B 0 ) in 2 (B 0 ) = in 3 (B 0 ) out 2 (B 1 ) = out 3 (B 1 ) in 2 (B 1 ) = in 3 (B 1 ) out 2 (B 2 ) = out 3 (B 2 ) in 2 (B 2 ) = in 3 (B 2 ) out 2 (B 3 ) = out 3 (B 3 ) in 2 (B 3 ) = in 3 (B 3 ) 7

8 out 2 (B 4 ) = out 3 (B 4 ) in 2 (B 4 ) = in 3 (B 4 ) ist der Fixpunkt nach der dritten Iteration erreicht und damit die Berechnung beendet. 8