Philipps-Universität Marburg Sommersemester 2017

Fachbereich Mathematik und Informatik 27.10.2017

Arbeitsgruppe Programmiersprachen und -werkzeuge

Prof. Dr. Christoph Bockisch Klausur zur Vorlesung

Stefan Schulz Grundlagen des Compilerbaus

Wichtige Hinweise:
• Schalten Sie, soweit noch nicht geschehen, sofort Ihr Mobiltelefon aus!
• Schalten Sie auch alle anderen medizinisch nicht notwendigen potentiellen Lärmquellen aus.
• Entfernen Sie jetzt alle Gegenstände vom Tisch, außer einen Stift (kein Rot-, Grün-, oder Bleistift),
Ihren Studentenausweis und Ihren Personalausweis/Reisepass, Getränke.
• Schreiben Sie jetzt auf jedes Blatt in Druckbuchstaben Ihren Namen und Ihre Matrikelnummer. Blät-
ter ohne Namen ergeben 0 Punkte und werden nicht korrigiert! Füllen Sie insbesondere auch fol-
gende Tabelle in Druckbuchstaben aus:
Vorname

Nachname

Matrikelnummer

Fachbereich

Studienfach

Angestrebter Abschluss

Semester

• Die Bearbeitungszeit beträgt 2 Stunden.

• Tragen Sie Ihre Lösungen auf den leeren Lösungsbögen und nicht auf den Bögen mit den Aufga-
benstellungen ein.
• Verwenden Sie kein eigenes Papier für Notizen, falls der Platz für die Lösung nicht ausreicht, son-
dern die Rückseiten. In dringenden Fällen erhalten Sie auf Anfrage Zusatzblätter. Machen Sie gut
kenntlich, wenn Sie Rückseiten oder Zusatzblätter für Lösungen verwenden und tragen Sie dort
Name und Matrikelnummer ein.
• Es sind keine Hilfsmittel erlaubt. Zuwiderhandlungen führen zum Ausschluss.
• Mehrere widersprüchliche Lösungen zu einer Aufgabe werden mit 0 Punkten bewertet.
• Falls Sie eine Frage haben, so wenden Sie sich bitte leise an den Tutor.

Wird bei der Korrektur ausgefüllt:

Aufgabe 1 2 3 4 5 6 Σ

Punkte 8 20 27 18 10 22 105

Erreicht

Note, Unterschrift:
 Vorname: Nachname: Matrikelnummer:

Aufgabe 1: Allgemeine Fragen (8 Punkte)

a) Nennen Sie jeweils eine Compiler-Phase im Front-End und Back-End und beschreiben Sie
diese in 1-2 Sätzen. (2P)
b) Ist die Menge der Sprachen, die durch einen nicht-deterministischen endlichen Automaten
(NFA) erkannt werden können größer als die Menge der Sprachen, die durch einen de-
terministischen endlichen Automaten (DFA) erkannt werden können? Begründen Sie Ihre
Antwort kurz. (2P)
c) Gegeben eine Menge von regulären Ausdrücken über dem Alphabet Σ und ein Wort aus
Σ+ . Wenn es für das Wort eine vollständige Zerlegung gibt, impliziert das, dass es auch
eine first-longest-match Zerlegung geben muss? Begründen Sie Ihre Antwort kurz. (2P)
d) Welche Informationen können von einem Bottom-Up Parser als Fehlerbericht ausgegeben
werden, wenn der Parser auf ein ungültiges Token stößt? Gehen sie davon aus, dass keine
Error-Recovery stattfindet. (2P)

2
Vorname: Nachname: Matrikelnummer:

3
 Vorname: Nachname: Matrikelnummer:

Aufgabe 2: Lexikalische Analyse (20 Punkte)

Über dem Alphabet Σ = {A, B} sind über die folgenden regulären Ausdrücke zwei Symbolklas-
sen mit den angegebenen Prioritäten definiert:

1. AB(AB)∗ (höchste Priorität) 2. A∗ BAA∗

a) Erstellen Sie einen DFA für jeden der regulären Ausdrücke. Dabei brauchen Sie keine Po-
tenzmengenkonstruktion anwenden. Konstruieren Sie anschließen den Produktautomaten
aus den DFAs. Sie können dabei davon ausgehen, dass alle nicht eingezeichneten Zu-
standstransitionen in den Senkenzustand übergehen. (12P)
b) Klassifizieren Sie die Endzustände nach den gegebenen Prioritäten. Geben Sie dazu an,
welcher der Teilautomaten in welchem Endzustand des Produktautomaten vorrangig ak-
zeptieren sollte. Geben Sie für die first-longest-match-Analyse des Wortes ABABAABA die
Zustandstripel aus ({N } ∪ ∆) × Σ∗ QΣ∗ × ∆∗ · {ε, lexerr} an, die beim Abarbeiten vom
Produktautomaten durchlaufen werden. Dabei sei Q die Menge der Zustände des Produkt-
automaten. Gehen Sie davon aus, dass der Backtrack-DFA im entsprechenden Modus aus
∆ startet, falls der Startzustand des Automaten ein akzeptierender Zustand ist. (8P)

4
Vorname: Nachname: Matrikelnummer:

5
Vorname: Nachname: Matrikelnummer:

6
 Vorname: Nachname: Matrikelnummer:

Aufgabe 3: Klassifizierung von Grammatiken (27 Punkte)

a) Gegeben sei die SLR(1)-Grammatik G mit

G := {{S 0 , S, E, I}, {id, let, lpar, rpar}, P, S 0 }

mit den Produktionen P:

S0 → S
S → id | id I | let E
E → I E | id
I → lpar S rpar

Stellen Sie die LR(0)-Itemsets für G auf. Ist G eine LR(0)-Grammatik? Begründen Sie Ihre
Antwort. (11P)
b) Gegeben Sei die Grammatik H mit

H := {{S 0 , A, B}, {c, d, f, n, r}, P, S 0 }

mit den Produktionen P:

S0 → A
A→Bc|dnABf
B→r|ε

und den dazugehörigen LR(0)-Itemsets:

Index Bezeichner Items

I0 LR(0)(ε) {[S 0 → ·A], [A → ·Bc], [A → ·dnABf ], [B → ·r], [B → ε·]}
I1 LR(0)(A) {[S 0 → A·]}
I2 LR(0)(B) {[A → B · c]}
I3 LR(0)(d) {[A → d · nABf ]}
I4 LR(0)(r) {[B → ·r]}
I5 LR(0)(Bc) {[A → Bc·]}
I6 LR(0)(dn) {[A → dn · ABf ], [A → ·Bc], [A → ·dnABf ], [B → ·r], [B → ε·]}
I7 LR(0)(dnA) {[A → dnA · Bf ], [B → ·r], [B → ε·]}
I8 LR(0)(dnAB) {[A → dnAB · f ]}
I9 LR(0)(dnABf) {[A → dnABf ·]}

Bestimmen Sie die first1 - und follow1 Mengen der einzelnen Nonterminale und stellen
Sie anschließend die action- und goto-Tabellen zu H auf. (12P)

7
Vorname: Nachname: Matrikelnummer:

c) Wandeln Sie die Grammatik I mit

I := {{S 0 , S, T, V }, {id, num, assign, ;}, P, S 0 }

mit den Produktionen P in eine äquivalente LL(1) Grammatik um:

S0 → S
S → S; T | T
T → V | V assign E
E → V | num
V → id

Verwenden Sie zur Umwandlung der Grammatik Linksfaktorisierung und Eliminierung von
Linksrekursionen. Benennen Sie die einzelnen Verfahren, die Sie bei der Umwandlung ver-
wenden. (4P)

8
Vorname: Nachname: Matrikelnummer:

9
Vorname: Nachname: Matrikelnummer:

10
Vorname: Nachname: Matrikelnummer:

11
Vorname: Nachname: Matrikelnummer:

12
 Vorname: Nachname: Matrikelnummer:

Aufgabe 4: Attributgrammatiken (18 Punkte)

Gegeben sei die folgende Attributgrammatik:

# Produktion Semantische Regeln

1 N →L N.v = L.v
L.p = 0
2 N → L1 .L2 N.v = L1 .v + L2 .v
L1 .p = 0
L2 .p = -L2 .l
3 L → L1 B L.v = L1 .v + B.v
L.l = L1 .l + 1
L1 .p = L.p + 1
B.p = L.p
4 L→B L.v = B.v
L.l = 1
B.p = L.p
5 B→0 B.v = 0
6 B→1 B.v = 2B.p

a) Kreuzen Sie in der Tabelle auf der nächsten Seite für Attribute L.l, L.p und B.v an, ob es
sich um ein synthetisches, oder ein vererbtes/inherites Attribut handelt. Richtige Antworten
werden mit einem Pluspunkt, falsche mit einem Minuspunkt gewertet. Die Teilaufgabe wird
minimal mit 0 Punkten gewertet. (3P)
b) Definieren Sie den Begriff „vererbtes Attribut“. (3P)
c) Gegeben sei die Grammatik G mit den Produktionen:

S → List
List → Item List | ε
Item → num

Mit G lassen sich Listen von Zahlen erstellen. Erweitern sie G zu einer Attributgrammatik,
sodass im Startzustand S das Attribute avg vorhanden sind, das den Durchschnittswert der
Liste angibt. Gehen Sie dabei davon aus, dass die mit G erstellten Listen nur positive, ganze
Zahlen (0 inklusive) enthalten. (12P)

13
Vorname: Nachname: Matrikelnummer:

Attribut L.l L.p B.v

Synthetisch

Vererbt

14
Vorname: Nachname: Matrikelnummer:

15
 Vorname: Nachname: Matrikelnummer:

Aufgabe 5: ASTs & DAGs (10 Punkte)

a) Gegeben sei der folgende AST:

Dieser AST ist eine mögliche Darstellung des arithmetischen Ausdrucks

(a + b) ∗ (a + b) − c + (a + b) ∗ c

Geben Sie einen äquivalenten DAG ohne Redundanzen um. Beschriften Sie die Kanten
gegebenenfalls mit l und r, um zu verdeutlichen, auf welcher Seite der Operation der Kind-
knoten steht. Es gelten dabei die üblichen Eigenschaften der mathematischen Operatoren.
(5P)
b) Nutzen Sie die Value-Number-Methode, um zu dem folgenden Ausdruck einen DAG zu
konstruieren:
(n ∗ n + n)/2

Verwenden Sie dabei die folgende Attributgrammatik: (5P)

# Produktion Semantische Regeln

1 E → E1 + T E.node = Node(add, E1 .node, T.node)
2 E → E1 − T E.node = Node(sub, E1 .node, T.node)
3 E→T E.node = T.node
4 T → T1 ∗ F T.node = Node(mult, T1 .node, F.node)
5 T → T1 /F T.node = Node(div, T1 .node, F.node)
6 T →F T.node = F.node
7 F → (E) F.node = E.node
8 F → id F.node = Leaf(id, id.lexval)
9 F → num F.node = Leaf(num, num.lexval)

16
Vorname: Nachname: Matrikelnummer:

17
Vorname: Nachname: Matrikelnummer:

18
 Vorname: Nachname: Matrikelnummer:

Aufgabe 6: Drei-Adress-Code (22 Punkte)

Gegeben sei der folgende Drei-Adress-Code:

1 n = -50
2 goto L 3
3 L1 sqr = n * n
4 sum = sqr + n
5 sum = sum / 2
6 if sqr < sum goto L2
7 a[n] = 1
8 L2 n = n + 1
9 L3 if n <= 50 goto L1

a) Übersetzen Sie den Drei-Adress-Code in die Maschinensprache einer Register-basierten

Maschine. Gehen Sie dabei davon aus, dass die Elemente in a jeweils 4 Byte breit sind.
Eine vollständige Beschreibung der Maschinensprache befindet sich auf Seite 20 und darf
aus dem Klausurbogen herausgetrennt werden. (12P)
b) Teilen Sie den Drei-Adress-Code in Basic Blocks ein. Stellen Sie die Basic Blocks in einem
Kontrollflussgraphen dar. (6P)
c) Optimieren Sie den folgenden Codeblock Schritt für Schritt ausgehend davon, dass am
Ende die Variablen a, d und e lebendig sind. Benennen Sie dabei die einzelnen Optimie-
rungen, die sie anwenden. (4P)

1 a = b * c
2 f = a - e
3 b = a + x
4 d = b * c
5 a = a + d
6 e = c * b

19
Vorname: Nachname: Matrikelnummer:

20
Vorname: Nachname: Matrikelnummer:

21
Vorname: Nachname: Matrikelnummer:

22
 Vorname: Nachname: Matrikelnummer:

Die Register-basierte Maschine unterstützt die folgenden Befehle:

Befehl Argumente Erklärung

LD arg1, arg2 arg1: Register Lädt den Wert an Adresse arg2 in Register arg1.
arg2: Adresse
ST arg1, arg2 arg1: Variable Speichert den Wert an Adresse arg2 in Variable arg1.
arg2: Adresse
arg1(arg2) arg1: Offset Gibt die Adresse arg2 + Offset arg1 zurück.
arg2: Adresse Register und Variablen können für arg1 verwendet wer-
den. In diesem Fall wird ihr Wert als Offset interpretiert.
BR arg1 arg1: Label Unbedingter Sprung zu Label arg1.
BRZ arg1, arg2 arg1: Adresse Springt zu arg2, falls arg1 gleich 0 ist.
arg2: Label Ist arg1 ein Register, wird dessen Inhalt betrachtet.
BRLTZ arg1, arg2 arg1: Adresse Springt zu arg2, falls arg1 negativ ist.
arg2: Label Ist arg1 ein Register, wird dessen Inhalt betrachtet.
BRLEZ arg1, arg2 arg1: Adresse Springt zu arg2, falls arg1 kleiner gleich 0 ist.
arg2: Label Ist arg1 ein Register, wird dessen Inhalt betrachtet.
OP arg1, arg2, arg3 arg1: Register Speichert das Resultat von OP in arg1.
(ADD, SUB, MUL, DIV) arg2: Adresse arg2 und arg3 sind die Operanden.
arg3: Adresse

Beachten Sie, dass Konstanten anstelle von Adressen in den jeweiligen Befehlen verwendet
werden können. Diese werden mit einem vorangestellten # kenntlich gemacht. So bewirkt
beispielsweise der Ausdruck LD R1, #100, dass der Wert 100 in Register R1 geladen wird.

23