|
Wikipedia
Portale | Stichwörter | Bilder | Zufälliger Artikel

Compiler

Ein Compiler (auch Kompilierer oder Übersetzer) ist ein Computerprogramm, das ein in einer Quellsprache geschriebenes Programm - genannt Quellprogramm - in ein semantisch äquivalentes Programm einer Zielsprache (Zielprogramm) umwandelt. Üblicherweise handelt es sich dabei um die Übersetzung eines von einem Programmierer in einer Programmiersprache geschriebenen Quelltextes in Assemblersprache, Bytecode oder Maschinensprache. Das Übersetzen eines Quellprogramms in ein Zielprogramm durch einen Compiler wird auch als Kompilierung bezeichnet.

Der Compilerbau, also die Programmierung eines Compilers, ist eine eigenständige Disziplin innerhalb der Informatik. Er gilt als das älteste Gebiet der praktischen Informatik.

Die Bezeichnung Compiler (engl. "compile": zusammenstellen/-tragen, "pile" = Haufen/Pfahl/Stapel) ist eigentlich irreführend. Ursprünglich bezeichnete das Wort Compiler Programme, die Unterprogramme zusammenfügen (etwa mit heutigen Linkern vergleichbar)[1]. Dies geht an der heutigen Kernaufgabe eines Compilers vorbei.

Zur Steuerung des Übersetzens kann der Quelltext neben den Anweisungen der Programmiersprache zusätzliche spezielle Compiler-Anweisungen enthalten.

Verwandt mit einem Compiler ist ein Interpreter, der ein Programm nicht in die Zielsprache übersetzt, sondern Schritt für Schritt direkt ausführt.

Inhaltsverzeichnis

Aufbau eines Compilers

Moderne Compiler werden in verschiedene Phasen gegliedert, die jeweils verschiedene Teilaufgaben des Compilers übernehmen. Einige dieser Phasen können als eigenständige Programme realisiert werden (s. Precompiler, Präprozessor). Sie werden sequentiell ausgeführt. Im Wesentlichen lassen sich zwei Phasen unterscheiden: das Frontend (auch Analysephase), das den Quelltext analysiert und daraus einen attributierten Syntaxbaum erzeugt, sowie das Backend (auch Synthesephase), das daraus das Zielprogramm erzeugt.

Phasen eines Compilers
Phasen eines Compilers

Frontend (auch „Analysephase“)

Im Frontend wird der Code analysiert, strukturiert und auf Fehler geprüft. Es ist auch selbst wieder in Phasen gegliedert:

Lexikalische Analyse

Die lexikalische Analyse zerteilt den eingelesenen Quelltext in zusammengehörende Token verschiedener Klassen, z. B. Schlüsselwörter, Bezeichner, Zahlen und Operatoren. Dieser Teil des Compilers heißt Scanner oder Lexer.

Ein Scanner benutzt gelegentlich einen separaten Screener, um Whitespace (Leerraum, also Leerzeichen, Tabulatorzeichen, Zeilenenden, usw.) und Kommentare zu überspringen.

Syntaktische Analyse

Die syntaktische Analyse überprüft, ob der eingelesene Quellcode ein korrektes Programm der zu übersetzenden Quellsprache ist, d. h. der Syntax (Grammatik) der Quellsprache entspricht. Dabei wird die Eingabe in einen Syntaxbaum umgewandelt. Dieser Teil wird auch als Parser bezeichnet.

Semantische Analyse

Die semantische Analyse überprüft die statische Semantik, also über die syntaktische Analyse hinausgehende Bedingungen an das Programm. Zum Beispiel muss eine Variable in der Regel deklariert worden sein, bevor sie verwendet wird, und Zuweisungen müssen mit kompatiblen (verträglichen) Datentypen erfolgen. Dies kann mit Hilfe von Attributgrammatiken realisiert werden. Dabei werden die Knoten des vom Parser generierten Syntaxbaums mit Attributen versehen, die Informationen enthalten. So kann zum Beispiel eine Liste aller deklarierten Variablen erstellt werden. Die Ausgabe der semantischen Analyse nennt man dann dekorierter oder attributierter Syntaxbaum.

Backend (auch „Synthesephase“)

Das Backend erzeugt aus dem vom Frontend erstellten attributierten Syntaxbaum den Programmcode der Zielsprache.

Zwischencodeerzeugung

Viele moderne Compiler erzeugen aus dem Syntaxbaum einen Zwischencode, der schon relativ maschinennah sein kann und führen auf diesem Zwischencode z. B. Programmoptimierungen durch. Das bietet sich besonders bei Compilern an, die mehrere Quellsprachen oder verschiedene Zielplattformen unterstützen. Hier kann der Zwischencode auch ein Austauschformat sein.

Programmoptimierung

Der Zwischencode ist Basis vieler Programmoptimierungen. Siehe Programmoptimierung.

Codegenerierung

Bei der Codegenerierung wird der Programmcode der Zielsprache entweder direkt aus dem Syntaxbaum oder aus dem Zwischencode erzeugt. Falls die Zielsprache eine Maschinensprache ist, kann das Ergebnis direkt ein ausführbares Programm sein oder eine sogenannte Objektdatei, die durch das Linken mit der Laufzeitbibliothek und evtl. weiteren Objektdateien zu einer Bibliothek oder einem ausführbaren Programm führt.

Einordnung verschiedener Compiler-Arten

  • Native Compiler
Compiler, der Programmcode für die Plattform erzeugt, auf der er selbst läuft.
Compiler, der auf einer Plattform ausgeführt wird und Programmcode für eine andere Plattform, z. B. ein anderes Betriebssystem oder eine andere Prozessorarchitektur, erzeugt.
Eine typische Anwendung ist die Erstellung von Programmen für ein eingebettetes System, das selbst keine oder keine guten Werkzeuge zur Softwareerstellung enthält, sowie die Erstellung oder Portierung eines Betriebssystems auf einer neuen Plattform.
  • Single-pass-Compiler
Compiler, der in einem einzigen Durchlauf aus dem Quellcode den Zielcode erzeugt (im Gegensatz zum Multi-pass-Compiler). Üblicherweise ist ein derartiger Compiler sehr schnell, aber kann nur einfache Optimierungen durchführen. Nur für bestimmte Programmiersprachen, z. B. Pascal, kann ein Single-Pass-Compiler erstellt werden.
  • Multi-pass-Compiler
Bei diesem Compilertyp wird der Quellcode in mehreren Schritten in den Zielcode übersetzt. In den Anfangszeiten des Compilerbaus wurde der Übersetzungsprozess hauptsächlich deshalb in mehrere Durchläufe zerlegt, weil die Kapazität der Computer oft nicht ausreichte, um den vollständigen Compiler und das zu übersetzende Programm gleichzeitig im Hauptspeicher zu halten. Heutzutage dient ein Multi-pass-Compiler vor allem dazu, Vorwärtsreferenzen (Deklaration eines Bezeichners nach dessen erster Verwendung) aufzulösen und aufwendige Optimierungen durchzuführen.

Sonderformen

  • Bei einem Transcompiler (auch als Transpiler bezeichnet) handelt es sich um einen speziellen Compiler, der Quellcode von einer Programmiersprache in den Quellcode einer anderen Programmiersprache übersetzt, z. B. von Pascal in C.
    Da jedoch viele Programmiersprachen besondere Eigenschaften und Leistungsmerkmale besitzen, die nur in den seltensten Fällen von Transcompilern berücksichtigt werden, kommt es häufig zu Effizienzverlusten. Oft ist auch eine manuelle Nachbearbeitung des Codes nötig, da die automatische Übersetzung nicht in allen Fällen zu hundert Prozent funktioniert.
  • Just-In-Time-Compiler (oder JIT-Compiler) übersetzen Quellcode oder Bytecode erst bei der Ausführung des Programms in Maschinencode. Dabei werden meist nur die benötigten Programmteile übersetzt und von einer virtuellen Maschine interpretiert.
  • Beim Compreter wird der Programm-Quellcode zunächst in einen Zwischencode übersetzt, der dann zur Laufzeit interpretiert wird. Compreter sollten die Vorteile des Compilers mit den Vorteilen des Interpreters verbinden. Effektiv sind viele heutige Interpreter zur Verringerung der Ausführungszeit intern als Compreter implementiert, die den Quellcode zur Laufzeit übersetzen, bevor er ausgeführt wird.

Geschichte

Grace Hopper (1984)
Grace Hopper (1984)

Die Geschichte des Compilerbaus wurde von den jeweils aktuellen Programmiersprachen (vgl. Zeittafel der Programmiersprachen) und Hardwarearchitekturen geprägt. Der erste Compiler (A-0) wurde 1952 von der Mathematikerin Grace Hopper entwickelt. Weitere frühe Meilensteine sind 1957 der erste FORTRAN-Compiler und 1960 der erste COBOL-Compiler. Viele Architekturmerkmale heutiger Compiler wurden aber erst in den 1960er Jahren entwickelt.

Programmoptimierung (ausführlich)

Üblicherweise bietet ein Compiler Optionen für verschiedene Optimierungen mit dem Ziel, die Laufzeit des Zielprogramms zu verbessern oder dessen Speicherplatzbedarf zu minimieren. Die Optimierungen erfolgen teilweise in Abhängigkeit von den Eigenschaften der Hardware, z. B. wie viele und welche Register der Prozessor des Computers zur Verfügung stellt. Optimierungen optimieren oft nur bestimmte Aspekte eines Programms. Es ist möglich, dass ein Programm nach einer Optimierung langsamer ausgeführt wird, als das ohne sie der Fall gewesen wäre. Dies kann zum Beispiel eintreten, wenn eine Optimierung für ein Programmkonstrukt längereren Code erzeugt, der zwar an sich schneller ausgeführt werden würde, aber mehr Zeit benötigt, um erst einmal in den Cache geladen zu werden. Er ist damit erst bei häufigerer Benutzung vorteilhaft.

Einige Optimierungen führen dazu, dass der Compiler Programmkonstrukte aus der Quellsprache in Zielsprachenkonstrukte übersetzt, für die es gar keine direkten Entsprechungen in der Quellsprache gibt. Ein Nachteil solcher Optimierungen ist, dass es damit kaum noch möglich ist, den Programmablauf mit einem interaktiven Debugger zu verfolgen.

Optimierungen können sehr aufwendig sein. Vielfach muss in modernen Compilern daher abgewogen werden, ob es sich lohnt, einen Programmteil zu optimieren. Es können Tests und Anwendungsszenarien durchgespielt werden (s. Profiler), um herauszufinden, wo sich komplexe Optimierungen lohnen.

Im folgenden werden einige Optimierungsmöglichkeiten eines Compilers betrachtet. Das größte Optimierungspotenzial besteht allerdings oft in der Veränderung des Quellprogramms selbst, zum Beispiel darin, einen Algorithmus durch einen effizienteren zu ersetzen. Dieser Vorgang kann meistens nicht automatisiert werden, sondern muss durch den Programmierer erfolgen. Einfachere Optimierungen können dagegen an den Compiler delegiert werden, um den Quelltext lesbarer zu halten.

Einsparung von Maschinenbefehlen

In vielen höheren Programmiersprachen benötigt man beispielsweise eine Hilfsvariable, um den Inhalt zweier Variablen zu vertauschen:

Einsparung von Maschinenbefehlen (MB)
Höhere
Programmiersprache		 Maschinenbefehle
ohne Optimierung mit Optimierung
t = a a → Register 1
Register 1 → t		 a → Register 1
a = b b → Register 1
Register 1 → a		 b → Register 2
b = t t → Register 1
Register 1 → b		 Register 1 → b
Register 2 → a

Mit der Optimierung werden statt 6 nur noch 4 Assemblerbefehle benötigt, außerdem wird der Speicherplatz für die Hilfsvariable t nicht gebraucht. D. h. diese Vertauschung wird schneller ausgeführt und benötigt weniger Hauptspeicher. Dies gilt jedoch nur, wenn ausreichend Register im Prozessor zur Verfügung stehen. Die Speicherung von Daten in Registern statt im Hauptspeicher ist eine häufig angewendete Möglichkeit der Optimierung.

Statische Formelauswertung zur Übersetzungszeit

Die Berechnung des Kreisumfangs mittels

         pi = 3.1415
         u  = 2 * pi * r

kann ein Compiler bereits zum Übersetzungszeitpunkt zu u = 6.2830 * r auswerten. Dies spart die Multiplikation 2 * pi zur Laufzeit des erzeugten Programms. Diese Vorgehensweise wird als Konstantenfaltung (engl. „constant folding“) bezeichnet. (Compiler für die Sprache Ada müssen diese Compile-Zeit-Berechnungen sogar in beliebiger Genauigkeit durchführen.)

Elimination toten Programmcodes

Wenn der Compiler erkennen kann, dass ein Teil des Programmes niemals durchlaufen wird, dann kann er diesen Teil bei der Übersetzung weglassen.

  
Beispiel:  ...   ...
           100   goto 900
           200   k=3
           900   i=7
           ...   ...

Wenn in diesem Programm niemals ein GOTO auf das Label 200 erfolgt, dann kann auf die Anweisung "200 k=3" verzichtet werden. Zusammen mit dem Label "200" ist der Sprung "100 goto 900" ebenfalls überflüssig.

Erkennung von unbenutzten Variablen

Wird eine Variable nicht benötigt, so braucht dafür kein Speicherplatz reserviert zu werden und kein Programmcode erzeugt zu werden.

Beispiel:  subroutine test (a,b)
           b = 2 * a
           c = 3.14 * b
           return b

Hier wird die Variable c nicht benötigt: Sie steht nicht in der Parameterliste, wird in späteren Berechnungen nicht verwendet und wird auch nicht ausgegeben. Deshalb kann die Anweisung c = 3.14 * b entfallen.

Optimierung von Schleifen

Insbesondere Schleifen versucht man zu optimieren, indem man z. B.

  • möglichst viele Variablen in Registern hält (normalerweise mindestens die Schleifenvariable).
  • statt eines Index, mit dem auf Elemente eines Feldes (englisch array) zugegriffen wird, Zeiger auf die Elemente verwendet. Dadurch wird der Aufwand beim Zugriff auf Feldelemente geringer.
  • Berechnungen innerhalb der Schleife, die in jedem Durchlauf dasselbe Ergebnis liefern, nur einmal vor der Schleife ausführt.
  • zwei Schleifen, die über denselben Wertebereich gehen, zu einer Schleife zusammenfasst. Damit fällt der Verwaltungsaufwand für die Schleife nur einmal an.
  • die Schleife teilweise oder (bei Schleifen mit konstanter, niedriger Durchlaufzahl) komplett auflöst (englisch loop unrolling), sodass die Anweisungen innerhalb der Schleife mehrfach direkt hintereinander ausgeführt werden, ohne dass jedesmal nach den Anweisungen eine Prüfung der Schleifenbedingung und ein Sprung zum Schleifenbeginn erfolgen.
  • die Schleife (vor allem bei Zählschleifen mit for) umgedreht, da beim Herunterzählen auf 0 effiziente Sprungbefehle (Jump-Not-Zero) benutzt werden können.
  • die Schleife umformt, damit die Überprüfung der Abbruchbedingung am Ende der Schleife durchgeführt wird (Schleifen mit Anfangsüberprüfung haben stets eine bedingte und eine unbedingte Sprunganweisung, während Schleifen mit Endüberprüfung nur eine bedingte Sprunganweisung haben).
  • wenn eine Schleife (nach einigen Optimierungen) einen leeren Rumpf besitzt, die ganze Schleife entfernt. Dies kann allerdings dazu führen, dass Warteschleifen, die ein Programm absichtlich verlangsamen sollen, entfernt werden. Allerdings sollten für diesen Zweck, soweit möglich, sowieso Funktionen des Betriebssystems benutzt werden.

Einfügen von Unterprogrammen

Bei kleinen Unterprogrammen fällt der Aufwand zum Aufruf des Unterprogrammes verglichen mit der vom Unterprogramm geleisteten Arbeit stärker ins Gewicht. Daher versuchen Compiler, den Maschinencode kleinerer Unterprogramme direkt einzufügen. Diese Technik wird auch als Inlining bezeichnet. In manchen Programmiersprachen ist es möglich, durch inline-Schlüsselwörter den Compiler darauf hinzuweisen, dass das Einfügen von bestimmten Unterprogrammen gewünscht ist. Das Einfügen von Unterprogrammen eröffnet oft, abhängig von den Parametern, weitere Möglichkeiten für Optimierungen.

Halten von Werten in Registern

Anstatt mehrfach auf dieselbe Variable im Speicher, beispielsweise in einer Datenstruktur, zuzugreifen, kann der Wert nur einmal gelesen und für weitere Verarbeitungen in Registern oder im Stack zwischengespeichert werden. In C, C++ und Java muss dieses Verhalten ggf. mit dem Schlüsselwort volatile abgeschaltet werden: Eine als volatile bezeichnete Variable wird bei jeder Benutzung wiederholt vom originalem Speicherplatz gelesen, da ihr Wert sich unterdessen geändern haben könnte. Das kann beispielsweise der Fall sein, wenn es sich um einen Hardware-Port handelt oder ein parallel laufender Thread den Wert geändert haben könnte.

Beispiel:

int a = array[25]->element.x;
int b = 3 * array[25]->element.x;

Im Maschinenprogramm wird nur einmal auf array[25]->element.x zugegriffen, der Wert wird zwischengespeichert und zweimal verwendet. Ist x volatile, dann wird zweimal zugegriffen.

Es gibt außer volatile noch einen anderen Grund, der eine Zwischenspeicherung in Registern unmöglich macht: Wenn der Wert der Variablen v durch Verwendung des Zeigers z im Speicher verändert werden könnte, kann eine Zwischenspeicherung von v in einem Register zu fehlerhaftem Programmverhalten führen. Da die in der Programmiersprache C oft verwendeten Zeiger nicht auf ein Array beschränkt sind (sie könnten irgendwohin im Hauptspeicher zeigen), hat der Optimizer oft nicht genügend Informationen, um eine Veränderung einer Variable durch einen Zeiger auszuschließen.

Verwendung von schnelleren äquivalenten Anweisungen

Statt einer Multiplikation oder Division von Ganzzahlen mit einer Zweierpotenz kann eine Shift-Anweisung verwendet werden. Es gibt Fälle, in denen nicht nur Zweierpotenzen, sondern auch andere Zahlen (einfache Summen von Zweierpotenzen) für diese Optimierung herangezogen werden. So kann z. B. n << 1 + n << 2 schneller sein als n * 6. Statt einer Division durch eine Konstante kann eine Multiplikation mit dem Reziprokwert der Konstante erfolgen. Selbstverständlich sollte man solch spezielle Optimierungen auf jeden Fall dem Compiler überlassen.

Weglassen von Laufzeitüberprüfungen

Programmiersprachen wie Pascal und Java fordern Laufzeitüberprüfungen beim Zugriff auf Felder oder Variablen. Wenn der Compiler ermittelt, dass ein bestimmter Zugriff immer im erlaubten Bereich sein wird, kann der Code für diese Laufzeitüberprüfungen weggelassen werden.

Reduktion von Paging zur Laufzeit

Zusammenhängender Code, z. B. eine Schleife, sollte zur Laufzeit möglichst auf der gleichen „Seite“ (zusammenhängend vom Betriebssystem verwalteter Speicherblock) im Hauptspeicher liegen. Dies kann man z. B. dadurch erreichen, dass man dem Programmcode geeignete Leeranweisungen („NOPs“ – No OPeration) hinzufügt. Dadurch wird der Programmcode zwar größer, aber wegen des reduzierten Pagings wird das Programm schneller ausgeführt.

Vorziehen/Verzögern von Speicherzugriffen

Durch das Vorziehen von Speicherlesezugriffen und das Verzögern von Schreibzugriffen lässt sich die Fähigkeit moderner Prozessoren zur Parallelarbeit verschiedener Funktionseinheiten ausnutzen. So kann beispielsweise bei den Befehlen: a = b * c; d = e * f; der Operand e bereits geladen werden, während ein anderer Teil des Prozessors noch mit der ersten Multiplikation beschäftigt ist.

Ein Beispielcompiler

Folgendes in der Programmiersprache C definiertes Programm stellt einen einfachen Einpass-Compiler dar. Dieser Compiler übersetzt einfache Ausdrücke in Infix-Notation in Ausdrücke der Postfix-Notation sowie in eine maschinennahe Assemblersprache. Er arbeitet mit der Technik des rekursiven Abstiegs.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define MODE_POSTFIX   0
#define MODE_ASSEMBLY  1
 
char    lookahead;
int     pos;
int     compile_mode;
char    expression[20+1];
 
void error() {
  printf("Syntaxfehler!\n");
}
 
void match( char t ) {
  if( lookahead == t ) {
    pos++;
    lookahead = expression[pos];            
  }
  else
    error();
}
 
void digit() {
  switch( lookahead ) {
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        printf( compile_mode == MODE_POSTFIX ? "%c" : "\tPUSH %c\n", lookahead );
        match( lookahead );
        break;
    default:
        error();
        break;
  }
}
 
void term() {
  digit();
  while( 1 ) {
    switch( lookahead ) {
      case '*':
        match('*');
        digit();
        printf( "%s", compile_mode == MODE_POSTFIX
                      ? "*" : "\tPOP B\n\tPOP A\n\tMUL A, B\n\tPUSH A\n" );
        break;
      case '/':
        match('/');
        digit();
        printf( "%s", compile_mode == MODE_POSTFIX
                      ? "/" : "\tPOP B\n\tPOP A\n\tDIV A, B\n\tPUSH A\n" );
        break;
      default:
        return;
    }
  }
}
 
void expr() {
  term();
  while( 1 ) {
    switch( lookahead ) {
      case '+':
        match('+');
        term();
        printf( "%s", compile_mode == MODE_POSTFIX
                      ? "+" : "\tPOP B\n\tPOP A\n\tADD A, B\n\tPUSH A\n" );
        break;
      case '-':
        match('-');
        term();
        printf( "%s", compile_mode == MODE_POSTFIX
                      ? "-" : "\tPOP B\n\tPOP A\n\tSUB A, B\n\tPUSH A\n");
        break;
      default:
        return;
    }
  }
}
 
int main ( int argc, char** argv ) {
  printf("Bitte geben Sie einen Ausdruck in Infix-Notation ein:\n\n\t");
  gets( expression );
 
  printf("\nCompilierter Ausdruck in Postfix-Notation:\n\n\t");       
  compile_mode = MODE_POSTFIX;
  pos = 0;
  lookahead = *expression;
  expr();
 
  printf("\n\nCompilierter Ausdruck in Assemblersprache:\n\n");        
  compile_mode = MODE_ASSEMBLY;
  pos = 0;
  lookahead = *expression;
  expr();
 
  return 0;
}

Ein Lauf dieses Compilers führt beispielsweise zu folgender Ausgabe:

Bitte geben Sie einen Ausdruck in Infix-Notation ein:

        5+3*2-9

Compilierter Ausdruck in Postfix-Notation:

        532*+9-

Compilierter Ausdruck in Assemblersprache:

        PUSH 5
        PUSH 3
        PUSH 2
        POP B
        POP A
        MUL A, B
        PUSH A
        POP B
        POP A
        ADD A, B
        PUSH A
        PUSH 9
        POP B
        POP A
        SUB A, B
        PUSH A

Bekannte Compiler

Siehe auch

Literatur

Quellen

  1. ↑ Bauer, F.L. and Eickel, J. Compiler Construction: An Advanced Course. Springer-Verlag. 1975

Weblinks

Quelle:
Artikel Compiler aus der freien Enzyklopädie Wikipedia mit dieser Versionsgeschichte
Lizenz:
GFDL
Kategorien:
Lexikalischer Artikel
Tipp:  Das Meta-Lexikon
Beispielartikel: Bielefeld, Diamant, Frankfurt am Main, Hanau, Jugendschutz, Lanzarote, Moers, Plauen, Solingen, Wesel ...
Bookmarks
delicious wong linkarena google
Sponsoren

ars mundi
S?ddeutsche Zeitung Shop
AbeBooks.de - 100 Mio. neue, gebrauchte und antiquarische B?cher