Programmiersprachen und ihre Übersetzer

Transkript

1 Folien zur Vorlesung Programmiersprachen und ihre Übersetzer Kapitel 5 Übersetzung imperativer Sprachen Faculty of Technology robert@techfak.uni-bielefeld.de June 18, 2013

2 Prozedurmechanismus Seit ALGOL und Pascal enthalten imperative (und dann auch alle objekt-orientierten) Sprachen die Konzepte Prozeduren / Funktionen / Methoden Prozedur-Parameter verschiedener Art, insbesondere wiederum Prozeduren globale und lokale Definitionen verschachtelte Sichtbarkeitsbereiche Rekursion Wie bildet man diese Konzepte auf eine Zielmaschine ab? Das ist Thema dieses Kapitels.

3 Statisch und dynamisch Zwei Grundbegriffe, die immer wieder auftauchen: Statische Größe: Zur Compilezeit bekannt und vom Compiler ermittelt Beispiel: Typ einer Variablen Dynamische Größe: Hängt ab vom Programmablauf Kann nicht vom Compiler bestimmt werden Compiler legt fest, WO diese Größe zur Laufzeit zu finden ist Compiler erzeugt Code, der zur Laufzeit diese Größe bestimmt Speicherbedarf für Felder (arrays)

4 Speicherabbildung Prozeduren sind statisch geschachtelt und ggf. dynamisch rekursiv Variablen werden im Hauptprogramm bzw. in den Prozeduren deklariert, ebenso formale Prozedurparameter. In inneren Prozeduren kann auf globale, d.h. in umfassenden Prozeduren deklarierte Variablen zugegriffen werden. (Das Hauptprogramm sehen wir als umfassende Prozedur, die vom Betriebssystem aufgerufen wird.)

5 Instanzen Wenn Prozeduren lokale Variable haben und rekursiv sind gibt es mehrere Instanzen dieser Variablen gleichzeitig, und sie können globale Variable für andere Prozeduren sein...

6 Instanzen Wenn Prozeduren lokale Variable haben und rekursiv sind gibt es mehrere Instanzen dieser Variablen gleichzeitig, und sie können globale Variable für andere Prozeduren sein... In diesem Kapitel geht es um die Speicherverteilung für Variablen unter den Gesichtspunkten: korrekte Implementierung der Gültigkeitsbereiche Speicherökonomie effiziente Adressierung der Variablen

7 Prozedur-Deklarationen, Objekte, Aufrufe Bei Pascal-Prozeduren müssen wir drei Aspekte unterscheiden : der Text P einer Prozedurdeklaration ein Prozedurobjekt O P, welches durch Auswertung einer Prozedurdeklaration entsteht, und schließlich der Aufruf A OP eines Prozedurobjektes O P. Wenn wir bei Aufrufen A OP nicht am spezifischen Exemplar O P von P interessiert sind, so sprechen wir auch einfach von einer Inkarnation I P von P.

8 Variablen- Deklarationen und Exemplare Entsprechend unterscheiden wir bei Variablen die Variablendeklaration von dem Exemplar der Variablen, das durch Auswertung der Deklaration zur Programmlaufzeit entsteht.

9 Semantische Festlegungen (1) Festlegung, was in Pascal (wie auch ähnlichen Sprachen) die Wirkung eines Prozeduraufrufs, einer Prozedur-Rueckkehr etc. ist Der Prozeduraufruf setzt die Existenz einer Prozedurobjektes voraus. (Initial ist dies nur das Hauptprogramm.) Beim Aufruf A OP eines Prozedurobjektes O P entsteht eine neue Inkarnation von P. Es werden neue Exemplare E x der lokalen Variablen x (einschließlich formale Parameter) und neue Prozedurobjekte O Q entsprechend dem Deklarationsteil der Prozedurdeklaration P erzeugt. A OP heißt dann der statische Vorgänger dieser O Q und aller ihrer Aufrufe A OQ.

10 Semantische Festlegungen (2) Benutzung einer Variablen setzt voraus, dass ihre Deklaration sichtbar ist. Die Bindung von Namen zu Deklarationen ist statisch und hierarchisch, d.h. ist x ein angewandtes Auftreten eines Namens im Text der Prozedur P, so gibt es eine kleinste textuell umfassende Prozedurdeklaration P (einschließlich P), die eine Deklaration D x für x enthält. Andernfalls ist das Programm statisch-semantisch inkorrekt. D x in P heißt die am Auftreten von x in P sichtbare Deklaration von x.

11 Semantische Festlegungen (2) Benutzung einer Variablen setzt voraus, dass ihre Deklaration sichtbar ist. Die Bindung von Namen zu Deklarationen ist statisch und hierarchisch, d.h. ist x ein angewandtes Auftreten eines Namens im Text der Prozedur P, so gibt es eine kleinste textuell umfassende Prozedurdeklaration P (einschließlich P), die eine Deklaration D x für x enthält. Andernfalls ist das Programm statisch-semantisch inkorrekt. D x in P heißt die am Auftreten von x in P sichtbare Deklaration von x. Deklaration ist auch die Einführung eines formalen Prozedurparameters im Kopf von P.

12 Semantische Festlegungen (3) Statische Verweiskette Gemäß (1) hat jede Inkarnation I P (abgesehen vom Hauptprogramm) einen statischen Vorgänger I Q. Letzterer ist in jedem Fall eine Inkarnation der P textuell unmittelbar umfassenden Prozedur Q. Der statische Vorgänger von I Q ist dann eine Inkarnation I R der Q direkt umfassenden Prozedur R, usw. Durch diese statische Vorgängerbeziehung wird damit, ausgehend von I P, eine statische Verweiskette SV (I P ) = I P, I Q, I R,..., I Hauptprogramm definiert, in der genau eine Inkarnation jeder umfassenden Prozedur vorkommt.

13 Semantische Festlegungen (4) Zugriff auf Variablen Arbeiten wir einen Aufruf von P ab, so liegt die statische Verweiskette vor A OP, A OQ, A OR,..., A OHauptprogramm Ist nun D x in P die an diesem Auftreten von x in P sichtbare Deklaration für x, so ist beim Zugriff auf x während der Ausführung eines Aufrufs A OP von P dasjenige Exemplar E x von x gemeint, dass in der auf der statischen Vorgängerkette von A OP liegenden Inkarnation von P erzeugt wurde.

14 Semantische Festlegungen (5) Zugriff auf Variable x Definiert man die Prozedurschachtelungstiefe pst(p) einer Prozedur P durch { 0 falls P = Hauptprogramm pst(p) = pst(q) + 1 falls P in Q deklariert, so findet man diese Inkarnation gerade als (pst(p) pst(p ))-tes Element (Zählung mit 0 beginnend) der statischen Verweiskette von A OP. Es folgt ein Beispiel, das zeigt, dass die Unterscheidung zwischen Prozeduren und Prozedurobjekten (bzw. -exemplaren) notwendig ist.

15 Quellcode-Beispiel Beispiel : procedure Q (procedure R; y : integer); var x : integer; procedure P; begin writeln(x); x := 5 end; begin x := 1; if y = 0 then begin R; P end else begin x := 2; Q(P,0) end end Wir werden den Aufruf Q(..., 1) betrachten

16 Aktionsfolge beim Aufruf von Q(..., 1) Bei Aufruf Q(..., 1) entsteht folgende Sequenz von Aktionen : Q 1 (..., 1) { erster Aufruf Q 1 von Q; neue Exemplare x 1 von x und P 1 von P, Q 1 wird SV von P 1 } x 1 := 1 x 1 := 2 Q 2 (P 1, 0) { zweiter Aufruf Q 2 von Q; entstehen x 2 und P 2, Q 2 wird SV von P 2 } x 2 := 1 P 1 1 { erster Aufruf P 1 1 von P 1, da R an P 1 geb. } writeln(x 1 ) 2 { da Q 1 SV von P 1 1 } x 1 := 5 { P ist in Q 2 an P 2 gebunden } writeln(x 2 ) 1 { da Q 2 statischer Vorgänger von P 2 1 } x 2 := 5 P 1 2

17 Beobachtungen zum Beispiel Das Beispiel zeigt, dass die Unterscheidung von verschiedenen Exemplaren einer Prozedur, wie P 1 und P 2, notwendig ist, weil es für den Zugriff auf die globale Variable x wichtig zu wissen ist, zu welchem rekursiven Aufruf von Q das x gehört. Wenn wir uns also vorstellen, dass jede Inkarnation I Q von Q ein eigenes Exemplar von P erzeugt, dessen in Q deklarierte globale Variablen gerade an die von I Q erzeugten Exemplare gebunden sind, so ist dieses Bindungsproblem eindeutig gelöst. Die verschiedenen Exemplare einer Prozedur unterscheiden sich also im allgemeinen in der Bindung der globalen Variablen.

18 Kellerprinzip für Inkarnationen Die Inkarnationen lassen sich kellerartig verwalten: Ausgangspunkt: der statische Vorgänger A OP eines Aufrufs A OQ lebt moch zum Zeitpunkt des Aufrufs A OQ. insbesondere der für seine lokalen Variablen allokierte Speicher ist noch verfügbar. Umgekehrt, wird A OP beendet, so kann es danach auch keine Aufrufe A OQ mehr geben, die A OP als statischen Vorgänger haben. Dies liegt daran, dass O Q nur so an Aufrufstellen außerhalb P transportiert werden kann, indem O Q als aktueller Parameter über eine in P beginnende Folge von Prozeduraufrufen zu dieser Aufrufstelle geleitet wird. Solange wie diese Aufrufsfolge nicht vollständig beendet ist, lebt A OP noch. Auf Exemplare der lokalen Variablen in A OP kann nach Beendigung von A OP nicht mehr zugegriffen werden

19 Speicherverteilung Die Grundidee für eine ökonomische Speicherverteilung ist daher, den Speicher kellerartig mit den Prozeduraufrufen pulsieren zu lassen. Zu Beginn eines Aufrufs A OP werden neue Speicherzellen oben auf dem Keller für die neuen Exemplare der lokalen Variablen (einschließlich Parameter) reserviert. Bei Beendigung von A OP wird der Kellerpegel auf den alten Stand vor A OP zurückgesetzt. Der Keller enthält damit jederzeit: alle dynamischen Vorgänger, und darin enthalten, alle statischen Vorgänger des aktuellen Aufrufs.

20 Festlegung Variablenzugriff Obige Betrachtungen ergeben folgendes Schema für Variablenzugriffe: Sei x ein angewandtes Auftreten einer Variablen in der Prozedur P. Sei Q die Prozedur, die die zugehörige Deklaration enthält. Dann gilt: 1 pst(q) pst(p) wegen der Sichtbarkeitsregeln 2 Ist I P eine Inkarnation von P, so ist, falls pst(q) < pst(p), das (pst(p) pst(q))-te Element 1 in SV (I P ) die Inkarnation von Q, die das Exemplar von x erzeugt hat, auf welches in I P zugegriffen wird. 3 Für pst(p) = pst(q) ist P = Q und x eine lokale Variable (oder ein formaler Parameter) von P. 1 Zählung bei 0 beginnend

21 Festlegung Variablenzugriff (2) 3 Für diese in 2. bestimmte Inkarnation I Q von Q gibt es einen eigenen Speicherbereich für die lokalen Variablen. Eine Basisadresse BA IQ zeige auf eine feste Stelle in diesem Speicherbereich. Die Adresse des an x gebundenen Objekts ist dann Adresse x = BA IQ + RelAdr (Q,x) Dabei ist BA IQ für jede Inkarnation I Q spezifisch und damit eine dynamische Größe. RelAdr (Q,x) ist eine Adresse von x relativ zur Basisadresse einer jeden Inkarnation von Q. Sie ist nur von Q, nicht von I Q abhängig, also statisch, d.h. vom Übersetzer auszurechnen.

22 Statisch und dynamisch Zwei Grundbegriffe, die immer wieder auftauchen: Statische Größe: Zur Compilezeit bekannt und vom Compiler ermittelt Beispiel: Typ einer Variablen Dynamische Größe: Hängt ab vom Programmablauf Kann nicht vom Compiler bestimmt werden Compiler legt fest, WO diese Größe zur Laufzeit zu finden ist Compiler erzeugt Code, der zur Laufzeit diese Größe bestimmt Speicherbedarf für Felder (arrays)

23 Aufbau des Prozedurspeicherbereichs (activation area) Prozedur P auf Schachtelungstiefe k. (I P, I Pk 1,..., I P0 ) SV-Kette für eine Inkarnation I P von P. Activation area für die Inkarnation I P :

24 Verwendung des Display Die aktuelle BAsisadresse in BR zeigt immer auf den Anfang des Display. Damit werden die aktuellen Parameter mit negativem offsets relativ zu BA adressiert. Display und lokale Variablen werden dagegen mit positiven offsets angesprochen. Rücksprungadresse und dynamischer Vorgänger werden erst beim Rücksprung wieder gebraucht. Die Basisadresse der laufenden Inkarnation und das Ende des belegten Speichers werden in geeigneten Registern BR (Basisregister) und TOP (Stack Top) gehalten. 2 2 Gängige Alternative zum Display: nur die Basisadresse des statischen Vorgängers abspeichern und die Adressierung über eine Folge von Dereferenzierungen vornehmen.

25 Adressierungsschema für Variablen und Parameter BR + reladr x A x = M[BR + i] + reladr x für lokale Variablen und Parameter für glob. Var. und Par., die auf pst i deklariert sind Konvention: In einem Ausdruck wie BR + i steht BR für den Inhalt des Registers BR. M[a] ist der Inhalt der Speicherzelle mit Adresse a. Für die Adressierung benötigen wir also die statischen Größen Relativadresse reladr x und Prozedurschachtelungstiefe i, sowie die dynamisch bestimmte aktuelle Basisadresse BA IP, die über das Register BR adressiert wird.

26 Codeerzeugung für Umgebungswechsel: Überblick(1) Um den Laufzeitkeller der activation areas zu organisieren, muss Code an vier Stellen erzeugt werden. In der Reihenfolge seiner Ausführung (P ruft Q): an Aufrufstelle in P, vor dem Aufruf von Q nach dem Eintritt in Q vor dem Austritt aus Q nach der Rückkehr an die Aufrufstelle in P Dabei kann Q für P global, lokal oder ein formaler Parameter sein.

27 Codeerzeugung für Umgebungswechsel: Überblick(2) Notwendige Schritte Auswerten der Parameter Bestimmung des Sprungziels Retten aktuelle BA und Rückkehraddresse Aufbau des Displays Allokation von Variablen für A OQ Freigabe des lokalen Speichers Rücksprung Wiederherstellung der vorherigen Umgebung