Compilerbau - Professur für Mikrorechner

mr.inf.tu.dresden.de

Compilerbau - Professur für Mikrorechner

Compilerbau

Einleitung

Florian Stock

2013


Agenda







Organisatorisches

Einleitung

Lexing/Parsing

Kontextanalyse

Laufzeitumgebung

Code-Generation

2


Organisatorisches





Florian Stock, TU Darmstadt, FG ESA

compilerbau@florian-stock.de

Blockveranstaltung – 3 CP

Mo 11:00 – 13:30 Uhr & 14:30 – 17:00 Uhr

Di - Fr 10:00 – 12:30 Uhr

Di - Do 13:30 – 16:00 Uhr

Übungsaufgaben, Folien & Aufzeichnungen:

Parallel zur Blockveranstaltung auf der

Vorlesungswebseite bei der Professur für Mikrorechner

Prüfung:



Klausur 90 min.

19.04.2013, 15:00 – 16:30 Uhr, 5./6. DS


Organisatorisches



Foliensatz von Christian Hochberger

(abgekupfert bei Andreas Koch, TU Darmstadt,

basierend auf Watt& Brown: PLPJ)

Literatur:



Zentrales Buch:

– Programming Language Processors in

Java

– von David Watt und Deryck Brown, Prentice-Hall 2000

Ergänzend:

– Compilers, 2. Auflage (!)

– von Aho, Sethi, Ullmann, Lam, Addison-Wesley 2006

4


Compiler

• Schnittstelle zw.

– Programmiersprache

– Maschine

• Programmiersprache: Gut für Menschen geeignet

– Smalltalk, Java, C++

• Maschine: Getrimmt auf

– Ausführungsgeschwindigkeit

– Preis/Chip-Fläche

– Energieverbrauch

– Nur selten: Leichte Programmierbarkeit

©Christian Hochberger Folie 5 von 68


Auswirkung von Compilern

• Entscheidet über dem Benutzer zugängliche

Rechenleistung

• Beispiel: Bildkompression auf Dothan CPU, 2GHz

Compiler Ausführungszeit Programmgröße

GCC 3.3.6 7,5ms 13KB

ICC 9.0 6,5ms 511KB

©Christian Hochberger Folie 6 von 68


Programmiersprachen

• Hohe Ebene:

• Smalltalk, Java, C++

• Mittlere Ebene:

• Assembler

• Niedrige Ebene:

• Maschinensprache

let

let

var i : Integer;

var i : Integer;

in

in

i := i + 1;

i := i + 1;

LOAD R1, (i)

LOAD R1, (i)

LOADI R2, 1

LOADI R2, 1

ADD R1, R1, R2

ADD R1, R1, R2

STORE R1, (i)

STORE R1, (i)

0110000100000110

0110000100000110

0111001001000001

0111001001000001

1011000100010010

1011000100010010

1001000100000110

1001000100000110

©Christian Hochberger Folie 7 von 68


Unterschiedliche Abstraktionsebenen

• Auf unteren Ebenen immer feinere Beschreibung

• Immer näher an Zielmaschine (Hardware)

• Details werden von Compiler hinzugefügt

– Durch verschiedenste Algorithmen

– Analyse von Programmeigenschaften

– Verfeinerung der Beschreibung durch Synthese von

Details

©Christian Hochberger Folie 8 von 68


Auswirkungen der Zielmaschine

• Rechnerarchitektur hat großen Einfluss auf

Compilation

• Einfache Maschinen:

– Wenig Spielraum bei Abbildung des Programms

• Komplexe Maschinen:

– Viele Optionen bei Abbildung

– Probleme, die Mächtigkeit der Maschine auszuschöpfen

©Christian Hochberger Folie 9 von 68


Auswirkungen der Zielmaschine: DLX/MIPS

4

==?

PC

Instr.

Mem.

Register

Data

Mem.

Eher einfach ...

Sign

Extend

©Christian Hochberger Folie 10 von 68


Auswirkungen der Zielmaschine: Analog Devices

TigerSHARC

©Christian Hochberger Folie 11 von 68


Auswirkungen der Zielmaschine: Cell Processor

©Christian Hochberger Folie 12 von 68


Spezialisierte Anforderungen

• Rechenleistung (hoch/niedrig)

• Datentypen (Gleitkomma, ganzzahlig, Vektoren)

• Operationen (Multiplikationen, MACs)

• Speicherbandbreite (parallele Speicherzugriffe)

• Energieeffizienz

• Platzbedarf

... können oft nur durch spezialisierte Prozessoren

erfüllt werden

Ohne passende Compiler

nutzlos!

©Christian Hochberger Folie 13 von 68


Aufbau von Compilern

Source

Code

Syntax-

Analyse

AST

Semantische

Analyse

DAST

Code

Erzeugung

Target

Code

Zwischendarstellungen für

den Informationsaustausch

©Christian Hochberger Folie 14 von 68


Syntaxanalyse

• Überprüfung ob Programm

Syntaxregeln gehorcht

• Speichern des Programms

in geeigneter Darstellung

Program

LetCommand

let

let

var i : Integer;

var i : Integer;

in

in

i := 1;

i := 1;

VarDeclaration

AssignCommand

Identifier

SimpleTypeDenoter

SimpleVname

IntegerExpression

i

Identifier

Identifier

IntegerLiteral

Identifier

i

1

Abstrakter Syntaxbaum (AST)

©Christian Hochberger Folie 15 von 68


Kontextanalyse - Identifikation

• Ordne Variablen ihren Deklarationen zu

• Berechne Typen von Ausdrücken

Programm

LetCommand

Dekorierter bzw. annotierter

AST (DAST)

VarDeclaration

AssignCommand

Identifier

SimpleTypeDenoter

SimpleVname

IntegerExpression

i

Identifier

Identifier

IntegerLiteral

Identifier

©Christian Hochberger Folie 16 von 68

i

1


Kontextanalyse - Überprüfung

• Erkenne Fehler in Variablen- und Typzuordnung

Programm

LetCommand

VarDeclaration

WhileCommand

Identifier

int

BinaryExpression : int

AssignCommand

n

IntegerExpression : int

Operator

IntegerExpression : int

SimpleVname

BinaryExpression

SimpleVname : int

/

IntegerLiteral

Identifier

CharExpression : char

Operator

IntegerExpression : int

Identifier

2

m

Identifier

>

IntegerLiteral

n

'n'

2

©Christian Hochberger Folie 17 von 68


Code-Erzeugung 1

• Programm ist syntaktisch und kontextuell korrekt

• Übersetzung in Zielsprache

– Maschinensprache

– Assembler

– C

– Andere Hochsprache

• Ordne DAST-Teilen Instruktionen der Zielsprache zu

• Handhabung von Variablen

– Deklaration: Reserviere Speicherplatz für eine Variable

– Verwendung: Referenziere immer den zugeordneten

Speicherplatz

©Christian Hochberger Folie 18 von 68


Code-Erzeugung 2

Programm

LetCommand

VarDeclaration

AssignCommand

Identifier

SimpleTypeDenoter

SimpleVname

IntegerExpression

i

Identifier

Identifier

IntegerLiteral

Identifier

i

1

0:PUSH 1 ;Platz fuer ‘i’ schaffen, Adresse 0[SB]

0:PUSH 1 ;Platz fuer ‘i’ schaffen, Adresse 0[SB]

1:LOADL 1 ;Wert 1 auf Stack legen

1:LOADL 1 ;Wert 1 auf Stack legen

2:STORE (1) 0[SB] ;ein Datenwort vom Stack nach Adresse 0[SB] schreiben

2:STORE (1) 0[SB] ;ein Datenwort vom Stack nach Adresse 0[SB] schreiben

3:POP (0) 1 ;Platz von ‘i’ wieder aufgeben

3:POP (0) 1 ;Platz von ‘i’ wieder aufgeben

4:HALT

;Ausfuehrung beenden

4:HALT

;Ausfuehrung beenden

©Christian Hochberger Folie 19 von 68


Optimierender Compiler

Programmtext IR IR Zielsprache

Front-End Middle-End Back-End

• Front-End: Syntaktische/kontextuelle Analyse

• Back-End: Code-Erzeugung

• Middle-End: Transformation von Zwischendarstellungen

– Intermediate Representation (IR)

– Keine direkte Code-Erzeugung aus Front-End IR

– Verwendet in der Regel zusätzliche interne Darstellungen

Ziel: Verbesserung des erzeugten Codes in Bezug auf

bestimmte Gütemaße

©Christian Hochberger Folie 20 von 68


Optimierender Compiler: Beispiele

• Typische Optimierungen

– Constant propagation / Dead Code Elimination

– Strength reduction

– Common subexpression elimination (CSE)

– Loop-invariant code motion

– (Partial) loop unrolling

• Viele mehr bei hoch entwickelten Compilern

– Loop Tiling, Loop Fusion, Procedure Inlining, ...

©Christian Hochberger Folie 21 von 68


Optimierender Compiler: Strength reduction

• Ersetze schwierige Operationen durch einfache

– Spart meistens Rechenzeit

• Oft zusammen mit Schleifenanalyse

– Entscheidend: Identifikation der Schleifenvariable

for (int i=0; i


Optimierender Compiler: CSE

• Suche nach Ausdrücken im Code (subexpressions),

die mehrfach genutzt werden

• Einführen von Hilfsvariablen

• Berechne gemeinsame Ausdrücke nur einmal

• Spart Code und Rechenzeit

x = 5 * a + b;

x = 5 * a + b;

y = 5 * a + c;

y = 5 * a + c;

int t = 5 * a;

int t = 5 * a;

x = t + b;

x = t + b;

y = t + c;

y = t + c;

©Christian Hochberger Folie 23 von 68


Optimierender Compiler: Loop-invariant Code Motion

• Suche nach Teilen des Schleifenkörpers,

– die in allen Iterationen das gleiche Ergebnis liefern

– die keine Seiteneffekte haben

• Verschiebung dieser Teile vor die Schleife

– Schwierige Analyse

– Taucht öfter auf, als man glaubt

int t;

int t;

for (int i=0; i


Optimierender Compiler: Loop Unrolling

• Wenn Schleifengrenzen bekannt:

– Repliziere Schleifenkörper entsprechend oft

– Ersetze Schleifenvariable durch Konstante

• Verbessert das Potenzial anderer Optimierungen

int s=0;

int s=0;

for (int i=0; i


Optimierender Compiler: Constant Propagation

• Berechne Operationen mit konstanten Argumenten zur

Compile-Zeit

• Verwerfe Code-Teile, die nicht erreicht werden können

int s=0;

int s=0;

for (int i=0; i


Optimierender Compiler: Partial Loop Unrolling

• Wenn die Schleifengrenzen von i nicht bekannt sind

• Generiere dreiteilige Struktur int s=0;

int s=0;

– Prolog: Korrigiere Ausrichtung von i int i;

int i;

– Eigentliche Schleife: Original Schleife,

aber n mal den Schleifenkörper

else s=s­a[i];

– Epilog: Berechne maximal n-1 }

}

verbleibende Iterationen

int s=0;

int s=0;

for (int i=a; i0;i++) {

if (i%2==0) s=s+a[i]

if (i%2==0) s=s+a[i]

else s=s­a[i];

for (; i


Syntax oder Grammatik

Beschreibt die Satzstruktur von korrekten Programmen

– n := n + 1;

Syntaktisch korrektes Statement in Triangle

– “Ein Kreis hat zwei Ecken.”

Syntaktisch korrekte Aussage in Deutsch

©Christian Hochberger Folie 28 von 68


Syntax oder Grammatik (2)

• Kontextuelle Einschränkungen

• Regeln für den Geltungsbereich (scope) und den

Typ von Aussagen

– n muss bei Auftreten des Statements passend deklariert

sein

– Kreise haben im Allgemeinen keine Ecken. Hier passen die

Typen offenbar nicht.

©Christian Hochberger Folie 29 von 68


Semantik

• Bedeutung einer Anweisung/Aussage in einer

Sprache

• Bei Programmiersprachen häufig beschrieben als

– Operationell:

Welche Schritte laufen ab, wenn das Programm gestartet

wird?

– Denotational:

Abbildung von Eingaben auf Ausgaben

©Christian Hochberger Folie 30 von 68


Art der Spezifikation

• Für alle drei Teile

– Syntax

– Kontextuelle Einschränkungen

– Semantik

• gibt es jeweils zwei Spezifikationsarten

– Formal

– Informal

Triangle

Triangle

Spezifikation

Spezifikation

•Formale

•Formale

Syntax

Syntax

(reguläre

(reguläre

Ausdrucke,

Ausdrucke,

EBNF)

EBNF)

•Informale

•Informale

kontextuelle

kontextuelle

Einschränkungen

Einschränkungen

•Informale

•Informale

Semantik

Semantik

©Christian Hochberger Folie 31 von 68


Syntax

Eine Sprache ist eine Menge von Zeichenketten

aus einem Alphabet

• Wie diese Menge angeben?

• Bei endlichen Sprachen: Einfach Elemente aufzählen

• Geht nicht bei unendlichen Sprachen

• Mögliche Vorgehensweisen

(1) Mathematische Mengennotation

(2) Reguläre Ausdrücke

(3) Kontextfreie Grammatik

©Christian Hochberger Folie 32 von 68


Syntax durch Mengenbeschreibung

• Beispiele fur die beschriebenen Zeichenketten

– L = {a, b, c} beschreibt a, b, c

– L = {x n |n > 0} beschreibt x, xx, xxx, . . .

– L = { x n y m | n > 0, m > 0} beschreibt xxy, xyy, xxxyy, ...

– L = { x n y n | n> 0} beschreibt xy, xxyy, . . . , aber z.B. nicht

xxy

• Offensichtlich keine sonderlich nützliche und gut zu

handhabende Spezifikationsform für komplexere

Sprachen

©Christian Hochberger Folie 33 von 68


Reguläre Ausdrücke (REs)

• Erweitere Zeichenketten aus dem Alphabet um

Operatoren

– | zeigt Alternativen an

– ∗ vorangehendes Zeichen kann beliebig oft auftreten

– ε ist die leere Zeichenkette

– ( . . . ) Gruppierung von Teilausdrücken durch Klammerung

• Beispiele:

– L = a|b|c ergibt a, b, c

– L = ab ergibt ∗ a, ab, abb, . . .

– L = (ab) ergibt die leere Zeichenkette

∗ ε, ab, abab, ababab, . . .

– L = a(b|ε) ergibt a oder ab

©Christian Hochberger Folie 34 von 68


Mächtigkeit von REs?

• Kann man die Menge aller regulären Ausdrücke

selbst mit REs beschreiben?

• Nein! REs sind daher ungeeignet zur Beschreibung

der Syntax komplexer Programmiersprachen

• Also weiter suchen nach geeigneter

Beschreibungsform für Syntax

• Aber: REs sind trotzdem innerhalb eines Compilers

nützlich (Scanner)

©Christian Hochberger Folie 35 von 68


Kontextfreie Grammatiken (CFGs)

• Eine kontextfreie Grammatik besteht aus

– Einer Menge von Terminalsymbolen T aus dem Alphabet

– Einer Menge von Nicht-Terminalsymbolen N

– Einem Startsymbol S ∈ N

– Einer Menge von Produktionen P

• Beschreiben, wie Nicht-Terminalsymbole aus

Terminalsymbolen zusammengesetzt sind.

©Christian Hochberger Folie 36 von 68


Kontextfreie Grammatiken (CFGs) 2

• Produktionen in Backus-Naur-Form (BNF)

– Nicht-Terminal ::= Zeichenkette aus Terminal und Nicht-

Terminalsymbolen

• Produktionen in Extended Backus-Naur-Form (EBNF)

– Nicht-Terminal ::= REs aus Terminal und Nicht-

Terminalsymbolen

©Christian Hochberger Folie 37 von 68


BNF Beispiel 1

• T = {x, y},

N = {S, B},

S = S,

• P = { S ::= xS (1)

S ::= yB (2)

S ::= x (3)

B ::= yB (4)

B ::= y (5) }

• Ist die Zeichenkette xxyyy Element der durch T, N,

S, P beschriebenen Sprache?

– S → xS → xxS → xxyB → xxyyB → xxyyy

• Ja, da sie sich aus S herleiten lässt!

©Christian Hochberger Folie 38 von 68


BNF Beispiel 2

• T = {x, y},

N = {S, B},

S = S,

• P = { S ::= xS (6)

S ::= yB (7)

S ::= x (8)

B ::= yB (9)

B ::= y (10) }

• Ist die Zeichenkette xy Element der durch T, N, S, P

beschriebenen Sprache?

– S → xS → xyB → ?

• Nein, da sie sich nicht aus S herleiten lässt!

©Christian Hochberger Folie 39 von 68


Mehrdeutigkeit in BNF

• Gegeben seien die Produktionen:

– S ::= S+S (11)

– S ::= x (12)

• Wie lässt sich die Zeichenkette x+x+x herleiten?

– S → S+S → x+S → x+S+S → x+x+S → x+x+x

• Aber auch anders:

– S → S+S → S+x → S+S+x → S+x+x → x+x+x

©Christian Hochberger Folie 40 von 68


Eindeutige CFG

• Für sinnvolle praktische Anwendungen müssen

CFGs eindeutig sein.

• Eindeutige Produktionen für die gleiche CFG:

– S ::= x+S (13)

– S ::= x (14)

©Christian Hochberger Folie 41 von 68


Programmiersprachen Beispiel für Vorlesung

• (Mini)-Triangle

• Pascal-artige Sprache als Anschauungsobjekt

• Compiler-Quellcode auf Web-Page

• In der Vorlesung: Mini-Triangle

– Weiter vereinfachte Version

– Z.B. keine Definition von Unterfunktionen

©Christian Hochberger Folie 42 von 68


Mini-Triangle: Beispiel

Lokale Deklarationen

let

let

const MAX ~ 10;

const MAX ~ 10;

var n: Integer

var n: Integer

in begin

in begin

getint(var n);

getint(var n);

if (n>0) /\ (n0) /\ (n 0 do begin

while n > 0 do begin

putint(n); puteol();

putint(n); puteol();

n := n­1

n := n­1

end

end

else

else

end

end

Konstante (hässliches ~)

Variable kann in getint() geändert werden

Folge von Anweisungen

zwischen begin und end

else ist erforderlich, kann aber leer sein

©Christian Hochberger Folie 43 von 68


Mini-Triangle: Produktionen

Program

Program

::=

::=

single-Command

single-Command

single-Command

single-Command

::=

::=

empty

empty

|

|

V-name

V-name

:=

:=

Expression

Expression

|

|

Identifier

Identifier

(

(

Expression

Expression

)

)

|

|

if

if

Expression

Expression

then

then

single-Command

single-Command

else

else

single-Command

single-Command

|

|

while

while

Expression

Expression

do

do

single-Command

single-Command

|

|

let

let

Declaration

Declaration

in

in

single-Command

single-Command

|

|

begin

begin

Command

Command

end

end

Command

Command

::=

::=

single-Command

single-Command

|

|

Command

Command

;

;

single-Command

single-Command

...

...

©Christian Hochberger Folie 44 von 68


Mini-Triangle: Produktionen (2)

Expression

Expression

::=

::=

primary-Expression

primary-Expression

|

|

Expression

Expression

Operator

Operator

primary-Expression

primary-Expression

primary-Expression

primary-Expression

::=

::=

Integer-Literal

Integer-Literal

|

|

V-name

V-name

|

|

Operator

Operator

primary-Expression

primary-Expression

|

|

(

(

Expression

Expression

)

)

V-name

V-name

::=

::=

Identifier

Identifier

Identifier

Identifier

::=

::=

Letter

Letter

|

|

Identifier

Identifier

Letter

Letter

|

|

Identifier

Identifier

Digit

Digit

Integer-Literal

Integer-Literal

::=

::=

Digit

Digit

|

|

Integer-Literal

Integer-Literal

Digit

Digit

Operator

Operator

::=

::=

+ |

|

-

-

|

|

*

*

|

|

/

/

|

|

< |

|

> |

|

=

©Christian Hochberger Folie 45 von 68


Mini-Triangle: Produktionen (3)

Declaration

Declaration

::=

::=

single-Declaration

single-Declaration

|

|

Declaration

Declaration

;

;

single-Declaration

single-Declaration

single-Declaration

single-Declaration

::=

::=

const

const

Identifier

Identifier

~ Expression

Expression

|

|

var

var

Identifier

Identifier

:

:

Type-denoter

Type-denoter

Type-denoter

Type-denoter

::=

::=

Identifier

Identifier

©Christian Hochberger Folie 46 von 68


Mini-Triangle: Produktionen (4)

Comment

Comment

::=

::=

!

!

CommentLine

CommentLine

eol

eol

CommentLine

CommentLine

::=

::=

Graphic

Graphic

CommentLine

CommentLine

Graphic

Graphic

::=

::=

any

any

printable

printable

character

character

or

or

space

space

Digit

Digit

::=

::=

0

0

|

|

1

1

|

|

2

2

|

|

3

3

|

|

4

4

|

|

5

5

|

|

6

6

|

|

7

7

|

|

8

8

|

|

9

9

©Christian Hochberger Folie 47 von 68


Terminologie

• Phrase:

– Von einem gegebenen Nicht-Terminalsymbol herleitbare

Kette von Terminalsymbolen. Z.B. Expression-Phrase,

Command-Phrase . . .

• Satz:

– S-Phrase, wobei S das Startsymbol der CFG ist

• Beispiel:

– Das gesamte Programm ist

ein Satz der CFG

– Zeile 2 ist eine single-Declaration-Phrase

– Zeile 4 ist eine single-Command-Phrase

let (1)

let (1)

var y : Integer (2)

var y : Integer (2)

in (3)

in (3)

y := y + 1 (4)

y := y + 1 (4)

©Christian Hochberger Folie 48 von 68


Syntaxbäume

• Ein Syntaxbaum ist ein geordneter, markierter Baum

bei dem

– die Blätter mit Terminalsymbolen markiert sind

– die inneren Knoten mit Nicht-Terminalsymbolen markiert

sind

– jeder innere Knoten N (von links nach rechts) die Kinder X 1

, . . . , X n

hat, entsprechend der Produktion N := X 1

. . . X n

• Ein N-Baum ist ein Baum mit einem N Nicht-

Terminalsymbol am Wurzelknoten

©Christian Hochberger Folie 49 von 68


Expression-Baum für a+5*b

Expression

Expression

Expression

primary-Expr.

primary-Expr.

primary-Expr.

V-name

V-name

Ident.

Op.

Int.-Lit.

Op.

Ident.

a

+

5

*

b

©Christian Hochberger Folie 50 von 68


single-Command-Baum

single-command

while r do begin

while r do begin

n := 0;

n := 0;

r := false

r := false

end

end

single-command

Command

Expression

primary-Expr.

Command

single-command

Expression

single-command

Expression

primary-Expr.

V-name

V-name

primary-Expr.

V-name

V-name

Ident.

Ident.

Int.-Lit.

Ident.

Ident.

while r do begin n := 0 ; r := false end

©Christian Hochberger Folie 51 von 68


Konkrete und abstrakte Syntax

• Grammatik spezifiziert präzise syntaktische Details

– do, :=, . . .

– Konkrete Syntax, wichtig zum Verfassen korrekter Programme

• Konkrete Syntax hat aber keinen Einfluss auf Semantik

der Programme

– V = E

– V := E

– set V = E

– assign E to V

– V ← Ë

Kann alles das gleiche bedeuten:

Eine Zuweisung von E nach V

• Für weitere Verarbeitung Darstellung vereinfachen!

©Christian Hochberger Folie 52 von 68


Abstrakte Syntax

• Modelliert nur essentielle Information

• Idee: Orientierung an der Subphrasen-Struktur der

• Produktionen

• Beispiel: V­name := Expression hat zwei

Subphrasen

(1)V­name

(2)Expression

©Christian Hochberger Folie 53 von 68


Abstrakte Syntax (2)

• Schlüsselworte, Begrenzer wie do, := sind

irrelevant

Unterscheidungen zwischen

– Command und single­Command

– Declaration und single­Declaration

– Expression und primary­Expression

• ... sind nur fur das Erkennen des Programmes

relevant, nicht zur Darstellung seiner Semantik

• Alle dafür unwichtigen Details weglassen!

©Christian Hochberger Folie 54 von 68


Auszug aus der abstrakten Syntax

Command

Command

::=

::=

V-name

V-name

:=

:=

Expression

Expression

AssignCmd

AssignCmd

|

|

Identifier

Identifier

(

(

Expression

Expression

)

)

CallCmd

CallCmd

|

|

if

if

Expression

Expression

then

then

Command

Command

IfCmd

IfCmd

else

else

Command

Command

|

|

while

while

Expression

Expression

do

do

Command

Command

WhileCmd

WhileCmd

|

|

let

let

Declaration

Declaration

in

in

Command

Command

LetCmd

LetCmd

|

|

Command

Command

;

;

Command

Command

SequentialCmd

SequentialCmd

©Christian Hochberger Folie 55 von 68


Auszug aus der abstrakten Syntax (2)

Expression

Expression

::=

::=

Integer-Literal

Integer-Literal

IntegerExp

IntegerExp

|

|

V-name

V-name

VnameExp

VnameExp

|

|

Operator

Operator

Expression

Expression

UnaryExp

UnaryExp

|

|

Expression

Expression

Op

Op

Expression

Expression

BinaryExp

BinaryExp

V-name::=

V-name::=

Identifier

Identifier

SimpleVName

SimpleVName

©Christian Hochberger Folie 56 von 68


Beispiel der abstrakten Syntax

WhileCommand

while r do begin

while r do begin

n := 0;

n := 0;

r := false

r := false

end

end

SequentialCommand

AssignCommand

AssignCommand

VnameExpr.

IntExpr.

VnameExpr.

SimpleV.

SimpleV.

SimpleV.

SimpleV.

Ident.

Ident.

Int.-Lit.

Ident.

Ident.

r n 0 r false

©Christian Hochberger Folie 57 von 68


AST als Zwischendarstellung

• AST ist eine weit verbreite Form der IR

• High-level IR

• Sehr nah an der Eingabesprache

• Gut geeignet für weitreichende Analysen und

Transformationen

– Unabhängig von Architektur der Zielmaschine

– Verschieben von Anweisungen

– Änderungen der Programmstruktur

©Christian Hochberger Folie 58 von 68


AST als Zwischendarstellung (2)

• Schlechter geeignet für maschinennahe Analysen

und Transformationen

– Ausnutzung von Maschinenregistern Optimierung

– Ausnutzung von speziellen Maschinenbefehlsfolgen

• Hier: Konzentration auf maschinenunabhängige

Ebene

• (D)AST ist Hauptrepräsentation

• Für weitergehende Optimierungen: Andere IRs

©Christian Hochberger Folie 59 von 68


Kontextuelle Einschränkungen: Geltungsbereich

• Syntaktische Korrektheit reicht nicht aus für

sinnvolle Übersetzung

Geltungsbereiche

Geltungsbereiche

(Scope)

(Scope)


● Betreffen Betreffen Sichtbarkeit Sichtbarkeit von von Bezeichern Bezeichern


● Jeder Jeder verwendete verwendete Bezeichner Bezeichner muss muss vorher vorher deklariert deklariert werden werden


● . . . . nicht nicht bei bei allen allen Programmiersprachen

Programmiersprachen


● Deklaration Deklaration ist ist sog. sog. bindendes bindendes Auftreten Auftreten des des Bezeichners

Bezeichners


● Benutzung Benutzung ist ist sog. sog. verwendendes verwendendes Auftreten Auftreten des des Bezeichners

Bezeichners


● Aufgabe: Aufgabe: Bringe Bringe jede jede Verwendung Verwendung mit mit genau genau der der einen einen

passenden

passenden

Bindung

Bindung

in

in

Zusammenhang

Zusammenhang

©Christian Hochberger Folie 60 von 68


Beispiele Geltungsbereiche

let

let

const m ~ 2;

const m ~ 2;

var n: Integer

var n: Integer

in begin

in begin

...

...

n := m*2;

n := m*2;

...

...

end

end

Definition von n:

Bindung

Benutzung von n:

Verwendung

let

let

var n: Integer

var n: Integer

in begin

in begin

...

...

n := m*2;

n := m*2;

end

end

Falls im Geltungsbereich der

Verwendung von m keine Bindung

von m existiert: Fehler!

Verwendung von m

©Christian Hochberger Folie 61 von 68


Kontextuelle Einschrankungen: Typen

• Typen

– Jeder Wert hat einen Typ

– Jede Operation

• . . . hat Anforderungen an die Typen der Operanden

• . . . hat Regeln für den Typ des Ergebnisses

• ... auch nicht bei allen Programmiersprachen

– Hier: statische Typisierung (zur Compile-Zeit)

– Alternativ: dynamische Typisierung (zur Laufzeit)

©Christian Hochberger Folie 62 von 68


Beispiel Typen

let

let

var n: Integer

var n: Integer

in begin

in begin

...

...

while n > 0 do

while > 0 do

n := n ­1;

n := n ­1;

...

...

end

end

Typregel für E 1

> E 2

(GreaterOp):

Wenn E 1

und E 2

beide vom Typ int,

dann ist Ergebnis vom Typ bool

Typregel für while E do C (WhileCmd):

E muss vom Typ boolean sein

Typregel für V:=E (AssignCmd):

Die Typen von V und E müssen

äquivalent sein

©Christian Hochberger Folie 63 von 68


Semantik

• Semantik beschreibt die Bedeutung eines

Programmes zur Ausführungszeit

• Drei unterschiedliche Bereiche

– Anweisungen

– Ausdrücke

– Deklarationen

• Jeder Bereich mit unterschiedlichen Aufgaben

verbunden

©Christian Hochberger Folie 64 von 68


Semantik (2)

• Anweisungen

– werden ausgeführt

– Mögliche Seiteneffekte:

• Ändern der Werte von Variablen

• Ein-/Ausgabeoperationen

• Ausdrücke

– werden ausgewertet (evaluiert), um ein Ergebnis zu

erhalten

– Evaluation kann in einigen Sprachen auch Seiteneffekte

haben

©Christian Hochberger Folie 65 von 68


Semantik (3)

• Deklarationen

– werden elaboriert um eine Bindung vorzunehmen

– Mögliche Seiteneffekte:

• Allokieren von Speicherplatz

• Initialisieren von Speicherplatz

©Christian Hochberger Folie 66 von 68


Beispiel: Semantik von (Mini-)Triangle

• Beschreibung orientiert sich am AST

• AssignCmd V := E

(1) Der Ausdruck E wird evaluiert um einen Wert v zu erhalten

(2) v wird an die Variable V zugewiesen

• BinaryExp E 1

op E 2

(1) Ausdruck E 1

evaluieren, um einen Wert v 1

zu erhalten

(2) Ausdruck E 2

evaluieren, um einen Wert v 2

zu erhalten

(3) Die Werte v 1

und v 2

werden mit dem Operator op zu

einem Wert v 3

verknüpft.

(4) v 3

ist das Ergebnis der BinaryExp

©Christian Hochberger Folie 67 von 68


Beispiel: Semantik von (Mini-)Triangle (2)

• Declaration var I : T

(1) Der Bezeichner I wird an eine Variable vom Typ T

gebunden

(2) Es wird ein für T passender Speicherbereich bereitgestellt

(3) Der Speicherbereich ist nicht initialisiert

(4) Der Geltungsbereich für I ist der eingeschlossene Block

(LetCmd)

(5) Am Ende des Blockes wird die Bindung aufgehoben

(6) ... und der Speicherbereich wieder freigegeben

©Christian Hochberger Folie 68 von 68


Triangle

• Vorlesung beschränkt sich auf Mini-Triangle

– Stark vereinfacht

– Z.B. keine Unterprogramme (Prozeduren, Funktionen)

• Im Buch PLPJ volles Triangle:

– Pascal-artige Sprache

– Arrays, Records, Prozeduren, Funktionen

– Parameterübergabe durch Wert oder Referenz

– Prozeduren/Funktionen als Parameter erlaubt

– Ausdrücke haben keine Seiteneffekte

©Christian Hochberger Folie 69 von 68

Weitere Magazine dieses Users
Ähnliche Magazine