Vorlesung CompilertechnikSommersemester 2009

Einführung

M. Schölzel

2

Literatur

A.V. Aho, J.D. Ullman: The Theory of Parsing, Translation, and Compiling – Volume I: Parsing. Prentice Hall, 1972, ISBN: 0-13-914556-7 .

A.V. Aho, J.D. Ullman: The Theory of Parsing, Translation, and Compiling – Volume II: Compiling. Prentice Hall, 1973, ISBN: 0-13-914564-8.

W.M. Waite, G. Goos: Compiler Construction. Springer Verlag, 1984, ISBN: 0-387-90821-8.

R. Wilhelm, D. Maurer: Übersetzerbau – Theorie, Konstruktion, Generierung. Springer Verlag, 1992, ISBN:3-540-55704-0.

A.V. Aho, M.S. Lam, R. Sethi, J.D. Ullman: Compilers – Principles, Techniques, & Tools, Second edition. Pearson Addison Wesley, 2007, ISBN: 0-321-48681-1.

P. Bachmann: Mathematische Grundlagen der Informatik. Akademie Verlag, 1992, ISBN: 3-05-501242-5.

D. Scheibler, M. Henke, P. Bachmann: Skript zur Compilertechnik. Vorlesungsskript, 2004.

3

Gegenseitige Abhängigkeiten

Computer-architektur

Programmier-sprachen

CompilerSt

rukt

urie

rte P

rogr

amm

ieru

ng

Obj

ekto

rient

ieru

ng

Dek

lara

tive

Prog

ram

mie

rung

Native-Abarbeitung vonJava-Bytecode (JOP)

Ver

mei

dung

von

sch

wer

Beh

ande

lbar

en K

onst

rukt

en,

(z.B

. Sch

lüss

elw

orte

als

Bez

eich

ner z

ulas

sen)

Optim

ierungenGrenzen der statischen

Optim

ierung; Ausnutzung des CISC

-Befehlssatzes

Sprachen für Parallelrechner

Entwicklung der Compiler ist eng mit der Entwicklung der Programmiersprachen und Computerarchitekturen verbunden.

4

Geschichte der Programmiersprachen (und Compiler)

1940

Ers

te C

om

pute

r,

Pro

gra

mm

ieru

ng

mit

Bin

ärc

odes

1950 1960 1970 1980 1990

Aufk

om

men v

on A

ssem

ble

rmnem

onic

19

57

: Fort

ran e

rste

r kom

erz

ielle

r C

om

pile

r fü

r IB

M 7

04

CO

BO

L

LISP,

19

58

, zu

r Im

ple

menti

eru

ng v

on

FO

RTR

AN

Unte

rpro

gra

mm

en

Sim

ula

67

, erg

änzt

e A

lgol 6

0 u

m

obje

ktori

enti

ert

e K

onze

pte

: K

lass

en,

Obje

kte

, K

oro

uti

nen,

Vere

rbung

Sm

allt

alk

: re

in o

bje

kto

rienti

ert

Imperative Programmiersprachen

Strukturierte ProgrammiersprachenObjektorientierte Programmiersprachen

C19

72

: PA

SC

AL

als

konse

quente

U

mse

tzung e

ines

stru

kturi

ert

en

Pro

gra

mm

ierp

ara

dig

ma

s

C

Pla

nkalk

ül von

Zuse

für

ZR

4;

ers

t vie

l sp

äte

r pra

ktis

ch

um

gese

tzt

ALG

OL-

60

: Ers

tmals

Besc

hre

ibung d

er

Synta

x d

urc

h B

NF

Java

Ken Thompson, Dennis Ritchie James Gosling

John Warner Backus

19

52

: Ers

ter

Com

pile

r A

-0Grace Hopper

5

Beispiel: FORTRAN I

Anweisungen sind an festen Positionen auf der Lochkarte ausgerichtet

Keine Subroutinen Keine geschachtelten Ausdrücke Speziell für die IBM 704 entwickelt

Aus dem ersten Fortran Manual von 1956, gefunden auf: http://www.paulgraham.com/history.html

6

Beispiel: COBOL

004000-COMPUTE-PAYMENT. * MOVE 0 TO LW-LOAN-ERROR-FLAG. * IF (LW-LOAN-AMT ZERO) OR (LW-INT-RATE ZERO) OR (LW-NBR-PMTS ZERO) MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-INT-PMT = LW-INT-RATE / 1200 ON SIZE ERROR MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-PMT-AMT ROUNDED = (LW-LOAN-AMT * LW-INT-PMT) / (1 - 1.00000000 / ( (1 + LW-INT-PMT) ** LW-NBR-PMTS) ) ON SIZE ERROR MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-TOTAL-PMTS = LW-PMT-AMT * LW-NBR-PMTS ON SIZE ERROR MOVE 1 TO LW-LOAN-ERROR-FLAG GO TO 004000-EXIT. * COMPUTE LW-TOTAL-INT = LW-TOTAL-PMTS - LW-LOAN-AMT. * 004000-EXIT. EXIT.

7

Meilenstein: Algol-60

Spezifikation der Syntax durch eine BNF Bedeutung von Schlüsselworten hängt nicht von

ihrer Position ab (Prinzip der Formatfreiheit) Freie Zeileneinteilung: Weg vom festen Format

der Lochkarten wie bei FORTRAN und COBOL Verwendung von Rutishausers

Klammergebirgen zur Übersetzung von arithmetischen Formeln in Infixnotation (Bauer und Samelson)

Aber: Erzwingt keine strukturierte Programmierung

8

Beispiel Algol-60

'BEGIN' 'COMENT' POLYGON: CALCULATES THE SIDES OF A POLYGON FOR Z POINTS IN R2 WITH X AND Y VALUES. (Z IS THE FIRST INPUT VALUE FOLLOWED BY PAIRS OF VALUES FOR INDIVIDUAL POINTS) PRINTS FOR EACH POINT THE FOLLOWING VALUES: NUMBER, X, Y, LENGTH OF SIDE, TOTAL LENGTH.; 'INTEGER' I, Z; 'REAL' X0, Y0, XA, Y,A, XN, YN, TL, L; READ(Z); READ(XA, YA); X0:= XA; Y0:= YA; I:= 0; L:= 0.0; NEW: READ(XN, YN); LAST: I:= I+1; TL:= SQRT((XN-XA)*(XN-XA) + (YN-YA)*(YN-YA)); L:= L+TL; PRINT(I, XA, YA, TL, L); XA:= XN; YA:= YN; 'IF' I 'LESS' Z-1 'THEN' 'GOTO' NEW; 'IF' I 'EQUAL' Z-1 'THEN' 'BEGIN' XN:= X0; YN:= Y0; 'GOTO' LAST; 'END';'END' POLYGON

9

Klassifizierung nach Generation

1. Generation Maschinensprache (kein Compiler erforderlich)

2. Generation Assemblersprachen (sehr einfache Übersetzung)

3. Generation Höhere Programmiersprachen (Fortran, LISP, C, Java,

Haskell,…) (komplexe Compiler erforderlich) 4. Generation

Anwendungsspezifische Sprachen (SQL) (relativ einfache Syntax; damit einfache Analyse; aber komplexe Verarbeitung)

5. Generation Logische und Constraint-basierte Programmiersprachen

(Prolog) (relativ einfache Syntax; damit einfache Analyse; aber komplexe Verarbeitung)

10

Klassifizierung nach Programmierparadigma

Imperative Programmiersprachen Das Programm spezifiziert eine

Berechnungsvorschrift, also wie etwas zu berechnen ist (C, Java, …)

Starke Orientierung an der Von-Neumann-Architektur Es wird grundsätzlich unterschieden zwischen:

Anweisungen: Ändern den Zustand des Speichers oder steuern den Programmfluss

Ausdrücke: Berechnen Werte auf Grundlage des aktuellen Speicherzustandes

Deklarative Programmiersprachen Das Programm spezifiziert nur was zu berechnen ist

(Prolog, [Haskell])

11

Fokus der Vorlesung

Wir werden Techniken zur Entwicklung von Compilern für imperative (insbesondere strukturierte) Programmiersprachen der 3. Generation kennen lernen.

Die dabei betrachteten Techniken zur Analyse des Quelltextes lassen sich auch zur Analyse von deklarativen Sprachen und Sprachen der 4. und 5. Generation nutzen.

Lernziele: Prinzipien der Gestaltung von Compilern. Theoretische Grundlagen der lexikalischen und

syntaktischen Analyse. Umgang mit und Verständnis von Scanner- und

Parsergeneratoren. Prinzipien der Zielcodeerzeugung. Nach der Vorlesung sollten Sie in der Lage sein, einen

einfachen Compiler selbst zu implementieren!

12

Gliederung (1)

1. Einführung2. Grundlagen

1. Formale Sprachen2. Grammatiken3. Entwurf kontextfreier Grammatiken4. Aufbau eines Compilers

13

Gliederung (2)

3. Lexikalische Analyse4. Syntaktische Analyse

1. Starkes LL(k)2. Schwaches LL(k)3. LR(k)

5. Kontextprüfung (semantische Analyse)6. Zwischencodeerzeugung7. Zielcodeerzeugung8. Standardoptimierungen

Ende der Einführung

Weiter zum Kapitel Grundlagen

15

Rutishausers Klammergebirge

Strukturierung vollständig geklammerter arithmetischer Ausdrücke zur Bestimmung einer Auswertungsreihenfolge:

Aufwärtsstrich bei: ( und Operandensymbol Abwärtsstrich bei: ) und Operatorsymbol

Beispiel: (((a:(b+c))-((d*e)*f))+g) Abarbeitung an der höchsten Stelle beginnen.

(

(

(

a:

(

cb + ))

-(

(

d e* )

))

+g )

*f

16

Rutishausers Klammergebirge – Abarbeitung

(

(

(

a:

(

cb + ))

-(

(

d e* )

))

+g )

*f

17

Rutishausers Klammergebirge – Abarbeitung

(

(

(

a: t1

)

-(

(

d e* )

*f )

)

+g )

t1 = b + c

18

Rutishausers Klammergebirge – Abarbeitung

(

(

(

a: t1

)

-(t2 *

f ))

+g )

t1 = b + c

t2 = d * e

19

Rutishausers Klammergebirge – Abarbeitung

(

(

t3 -(t2 *

f ))

+g )

t1 = b + c

t2 = d * e

t3 = a : t1

20

Rutishausers Klammergebirge – Abarbeitung

(

(

t3 -t4

)

+g )

t1 = b + c

t2 = d * e

t3 = a : t1

t4 = t2 * f

21

Rutishausers Klammergebirge – Abarbeitung

(

t5+

g )

t1 = b + c

t2 = d * e

t3 = a : t1

t4 = t2 * f

t5 = t3 - t4

22

Rutishausers Klammergebirge – Abarbeitung

t6

t1 = b + c

t2 = d * e

t3 = a : t1

t4 = t2 * f

t5 = t3 - t4

t6 = t5 + g

23

Bauer/Samelson – Erfindung des Kellerprinzips

Keller speichert noch nicht ausgewertete Präfixe: Einstapeln bis eine schließende Klammer erreicht Suchen der zugehörigen öffnenden Klammer im Stapel und Auswerten der geklammerten Operation und Einstapeln des berechneten

Wertes Abarbeitungsreihenfolge entspricht der Auswertung des am weitesten

links stehenden lokalen Maximum im Klammergebirge. Beispiel: (((a:(b+c))-((d*e)*f))+g)

Stapel Eingabe

(((a:(b+c ))-((d*e)*f))+g)

(((a:t1 )-((d*e)*f))+g) t1 = b + c

((t2 -((d*e)*f))+g) t2 = a : t1

((t2-((d*e )*f))+g)

((t2-(t3 *f))+g) t3 = d*e

((t2-(t3*f ))+g)

((t2-t4 )+g) t4 = t3*f

(t5 +g) t5 = t2-t4

(t5+g )

t6 t6 = t5+g

Ausgabe

24

Bauer/Samelson – Erfindung des Kellerprinzips

Auf vollständige Klammerung kann verzichtet werden, trotzdem Beachtung von Prioritäten der Operatoren, wenn außerdem:

ein Operator nur dann eingestapelt wird, wenn der am weitesten oben liegende Operator im Keller eine niedrigere Priorität hat

oder nach der letzten öffnenden Klammer im Stapel kein Operator eingestapelt wurde.

Ansonsten wird der Operator im Keller ausgewertet Beispiel: ((a:(b+c))-d*e*f+g)

Stapel Eingabe

((a:(b+c ))-d*e*f+g)

((a:t1 )-d*e*f+g) t1 = b + c

(t2 -d*e*f+g) t2 = a : t1

(t2-d*e *f+g)

(t2-t3 *f+g) t3 = d*e

(t2-t3*f +g)

(t2-t4 +g) t4 = t3*f

(t5 +g) t5 = t2-t4

(t5+g )

t6 t6 = t5+g

Ausgabe

zurück