GNU C-Compiler

GNU Compiler Collection
Entwickler:	GCC-Team
Aktuelle Version:	4.4.0 (21. April 2009)
Betriebssystem:	Unix, GNU/Linux, Windows, Mac OS X, und andere
Kategorie:	Compiler
Lizenz:	GPL
Deutschsprachig:	ja
gcc.gnu.org

GCC ist der Name der Compiler-Suite des GNU-Projekts. GCC steht ursprünglich für GNU C Compiler. Da GCC heute aber außer C noch einige andere Programmiersprachen übersetzen kann, hat GCC inzwischen die Bedeutung GNU Compiler Collection erhalten (engl. für GNU-Compilersammlung). Das Kommando gcc (in Kleinbuchstaben) steht weiterhin für den C-Compiler.

Überblick

Die Sammlung enthält Compiler für die Programmiersprachen C, C++, Java, Objective-C, Fortran 95 und Ada. Die Compilersammlung unterliegt den Bedingungen der GNU General Public License.

Die erste öffentliche Version (0.9) des GCC wurde am 22. März 1987 von Richard Stallman für das GNU-Projekt freigegeben (Version 1.0 erschien am 23. Mai desselben Jahres) und wird heute von Programmierern auf der ganzen Welt weiterentwickelt. Die Erweiterung des C-Compilerpakets zur Compiler-Collection erfolgte im Rahmen des EGCS-Projektes, das eine Weile parallel zum GCC existierte und schließlich zum offiziellen GCC wurde.

GCC wird von einer Reihe von Systemen als Standardcompiler benutzt, darunter viele Linux-Distributionen, BSD, Mac OS X, NextStep, und BeOS bzw. ZETA. Er wurde auf mehr Systeme und Rechnerarchitekturen portiert als jeder andere Compiler und bietet sich besonders für Betriebssysteme an, die auf verschiedenen Hardware-Plattformen laufen sollen. Der GCC lässt sich auch als Cross-Compiler installieren. ^{[1] [2]}

Zielsysteme

GCC 4.1.3 in einem Kommandozeile-Fenster unter Ubuntu 7.10 mit GNOME 2.20

Das GCC-Projekt bezeichnet einige Plattformen offiziell als primäre und andere als sekundäre Evaluationsplattformen. Vor jeder Veröffentlichung einer neuen Version werden insbesondere diese beiden Gruppen getestet. Zu den Prozessoren, für die GCC Programme erzeugen kann, gehören (primäre und sekundäre Evaluationsplattformen sind markiert):

• Alpha
• ARM-Architektur (sekundär, unter Linux)
• H8/300
• S/370, S/390
• x86 und AMD64
• IA-64 „Itanium“
• Motorola 68000 und Motorola Coldfire
• Motorola 88000
• MIPS-Architektur (primär unter IRIX)
• PA-RISC (primär unter HP-UX)
• PDP-11
• PowerPC
• SuperH
• Sun SPARC (primär unter Solaris, sekundär unter Linux)
• VAX

Dazu kommen noch eine Reihe von Prozessoren aus dem Bereich eingebetteter Systeme, wie

• Motorola 68HC11
• A29K
• ARC
• Atmel AVR
• Atmel_AVR32
• C4x
• CRIS
• D30V
• DSP16xx
• FR-30
• FR-V
• Infineon TriCore
• Intel i960
• IP2000
• M32R
• MCORE
• MicroBlaze
• Microchip PIC24, dsPIC und PIC32 (nur in C)
• MMIX
• MN10200, MN10300
• NS32K
• ROMP
• Stormy16
• Texas Instruments MSP430
• V850
• Xtensa

Insgesamt unterstützt der GCC mehr als 60 Plattformen.^[3]

Struktur

Design Flow von GCC

Das externe Interface des gcc entspricht dem eines Standard-Unix-Compilers.

1. Der Benutzer ruft ein Hauptprogramm mit dem Namen gcc auf.
2. GCC interpretiert das Kommandozeilen-Argument
3. GCC stellt die Programmiersprache der vorliegenden Eingabedatei fest.
4. Der entsprechende Sprach-Compiler wird aufgerufen.
5. Die Ausgabe wird dem Assembler übergeben.
6. Schließlich wird der Linker aufgerufen.
7. Ein komplettes Programm wurde erstellt.

Jeder Sprachcompiler ist ein separates Programm, das Quellcode entgegennimmt und Assemblersprache produziert. Im Schema auf der rechten Seite sind Beispiele für C und Assembler gegeben, welche sich beide dem Preprocessing unterziehen müssen, bei dem Compilermakros, eingebundene Header-Dateien und ähnliches umgewandelt werden, um reinen C-Code bzw. Assembler zu erhalten. Jenes sprachabhängige Frontend parst die entsprechende Sprache und erzeugt einen abstrakten Syntaxbaum, der an ein Backend übergeben wird, das den Baum in GCCs Register Transfer Language (RTL) überführt (im Diagramm nicht gezeigt), verschiedene Codeoptimierungen durchführt und zum Schluss Assemblersprache erzeugt.

Fast alle Bestandteile des GCC sind in C geschrieben. Eine Ausnahme bildet das Ada-Frontend, das zum größten Teil in Ada geschrieben ist.

Frontends

Frontends müssen Bäume produzieren, die vom Backend verarbeitet werden können. Wie sie dies erreichen, bleibt ihnen überlassen. Einige Parser benutzen Yacc-ähnliche Grammatiken, andere verwenden handgeschriebene, rekursive Parser.

Bis vor kurzem war die Baumrepräsentation des Programms nicht völlig vom Zielprozessor unabhängig. Die Bedeutung eines Baums konnte für unterschiedliche Sprachfrontends unterschiedlich sein, und Frontends konnten ihren eigenen Baumcode zur Verfügung stellen.

Mit dem Tree-SSA-Projekt, das in die Version GCC 4.0 integriert wurde, wurden zwei neue Formen von sprachunabhängigen Bäumen eingeführt. Diese neuen Baumformate wurden GENERIC und GIMPLE getauft. Parsing wird nun durchgeführt, indem ein temporärer sprachabhängiger Baum nach GENERIC konvertiert wird. Der so genannte „Gimplifier“ überführt diese komplexe Form in die SSA-basierte GIMPLE-Form, von der ausgehend eine Reihe neuer sprach- und architekturunabhängiger Optimierungen durchgeführt werden können.

Middleend

Optimierung an Bäumen passt eigentlich nicht in das Schema von „Frontend“ und „Backend“, da sie nicht sprachabhängig sind und kein Parsen beinhalten. Die GCC-Entwickler haben diesem Teil des Compilers daher den Namen „Middleend“ gegeben. Zu den gegenwärtig am SSA-Baum durchgeführten Optimierungen gehören Dead Code Elimination, Partial Redundancy Elimination, Global Value Numbering, Sparse Conditional Constant Propagation, und Scalar replacement of Aggregates. Array-basierende Optimierungen wie zum Beispiel automatische Vektorisierung, wie sie der Intel-Compiler anbietet, werden gegenwärtig entwickelt. ^[4]

Backend

Das Verhalten des GCC-Backends wird teilweise durch Präprozessor-Makros und architekturspezifische Funktionen bestimmt, mit denen zum Beispiel die Endianness, Wortgröße, und Aufrufkonventionen definiert und die Registerstruktur der Zielmaschine beschrieben werden. Unter Verwendung der Maschinenbeschreibung, einer LISP-ähnlichen Beschreibungssprache, wandelt GCC die interne tree-Struktur in die RTL-Darstellung (Register Transfer Language) um. Obwohl diese dem Namen nach prozessorunabhängig ist, ist die Sequenz an abstrakten Instruktionen daher bereits an das Ziel angepasst.

Die Art und Anzahl der vom GCC an der RTL durchgeführten Optimierungen werden mit jeder Compiler-Version weiterentwickelt. Zu ihnen gehören etwa (global) common subexpression elimination, verschiedene Schleifen- und Sprungoptimierungen (if-conversion, branch probability estimation, sibling calls, constant propagation, ...) sowie der combine-pass, in dem mehrere Instruktionen zu einer einzigen kombiniert werden können.

Seit der kürzlichen Einführung von globalen SSA-basierten Optimierungen an GIMPLE-Bäumen haben die RTL-Optimierungen leicht an Bedeutung verloren, da in der RTL-Repräsentation des Programms weit weniger der für viele Optimierungen wichtigen High-Level-Informationen enthalten sind. Allerdings sind auch maschinenabhängige Optimierungen sehr wichtig, da für viele Optimierungen Informationen über die Maschine vorliegen müssen, etwa darüber, welche Instruktionen eine Maschine kennt, wie teuer diese sind und wie die Pipeline der Zielarchitektur beschaffen ist.

In der „Reload“-Phase wird die prinzipiell unbeschränkte Anzahl an abstrakten Pseudo-Register durch die begrenzte Anzahl an echten Maschinenregistern ersetzt, wobei hier unter Umständen neue Instruktionen in den Code eingefügt werden müssen, um zum Beispiel Pseudo-Register auf dem Stack der Funktion zwischenzuspeichern. Diese Registerzuteilung ist recht kompliziert, da die verschiedenen Eigenheiten der jeweiligen Zielarchitektur besonders berücksichtigt werden müssen.

In der letzten Phase geschehen Optimierungen wie peephole optimisation und delay slot scheduling bevor die recht maschinennahe Ausprägung der RTL auf Assemblercode abgebildet wird, indem die Namen von Registern und Adressen in Strings umgesetzt werden, die die Instruktionen spezifizieren.

EGCS

Experimental/Enhanced GNU Compiler System (EGCS, engl. für experimentelles/erweitertes GNU Compiler System) war ein Abspaltung von GCC (1997) und wurde 1999 wieder in GCC eingefügt.

GCC 1.x hatte 1991 eine gewisse Stabilität erreicht, aber architekturbedingte Einschränkungen verhinderten viele Verbesserungen, sodass die Free Software Foundation (FSF) begann, an GCC 2.x zu arbeiten. Aber in der Mitte der 1990er kontrollierte die FSF sehr genau, was und was nicht zu GCC 2.x hinzugefügt wurde, so dass GCC als Beispiel für das „Cathedral“-Entwicklungsmodell benutzt wurde, welches in Eric S. Raymonds Die Kathedrale und der Basar beschrieben wurde.

Da GCC freie Software ist, war es Programmierern, die in andere Richtung arbeiten wollten, erlaubt, eine Abspaltung zu entwickeln. Viele Abspaltungen erwiesen sich als ineffizient und unübersichtlich, und die Schwierigkeiten, dass ihre Arbeit vom offiziellen GCC-Projekt akzeptiert wurden, frustrierten viele.

1997 gründete eine Gruppe von Entwicklern EGCS, um mehrere experimentelle Abspaltungen in einem einzigen Projekt zu vereinen. Dazu gehörten g77 (Fortran), PGCC (Pentium-optimierter GCC), viele C++-Verbesserungen und neue Architekturen.

Die Entwicklung von EGCS war schneller und besser als die GCC-Entwicklung, sodass die FSF 1999 offiziell die Weiterentwicklung von GCC 2.x einstellte, stattdessen EGCS als die offizielle GCC-Version übernahm und die EGCS-Entwickler als Projektverantwortliche (engl.: maintainer) des GCC erklärte. Von da an wurde das Projekt explizit mit dem „Basar“-Modell entwickelt und nicht mit dem „Cathedral“-Modell. Mit der Veröffentlichung von GCC 2.95 im Juli 1999 waren beide Projekte wiedervereint.

Siehe auch

• GNU Compiler for Java
• GNU Compiler for Fortran
• GNU Debugger
• distcc, ccache
• MinGW, eine Portierung auf die Microsoft-Windows-Plattform
• Portable C Compiler

Quellen

1. ↑ Nikolaus Schüler: Der Gcc-Compiler - Überblick und Bedienung, bhv Verlags GmbH, Kaarst, 1997, 1. Auflage, Seite 28
2. ↑ setting up gcc as a cross-compiler
3. ↑ Host/Target specific installation notes for GCC auf der gnu.org Webseite, 23. Februar, 2006
4. ↑ Autovektorisierung in der GCC

Weblinks

• GCC, the GNU Compiler Collection (englisch) – Offizielle Website
• GCC Frontend HOWTO (englisch) – Anleitung zum Erstellen seines eigenen GCC-Frontends
• Kurzanleitung für den GCC