GCC - der Ursprung von allem

ArticleCategory:

AuthorImage:[Here we need a little image from you]

TranslationInfo:[Author + translation history. mailto: or http://homepage]

original in en Lorne Bailey 

en to de Rene S�ss

AboutTheAuthor:[A small biography about the author]

Lorne lebt in Chicago und arbeitet als Computer-Berater, spezialisiert auf den Umgang mit Oracle-Datenbanken. Seit seinem Umstieg auf ausschlie�liche *nix-Programmierung, hat Lorne die DLL-H�lle komplett vermieden. Derzeit arbeitet er an seinem Master-Titel in Informatik.

Abstract:[Here you write a little summary]

ArticleIllustration:[One image that will end up at the top of the article]

ArticleBody:[The main part of the article]

GCC ist klasse

Kannst Du Dir vorstellen, Freie Software mit einem kommerziellen, "closed Source" Compiler zu kompilieren? Woher weist Du, was in deinem ausf�hrbarem Programm passiert? Es k�nnte eine Art Hintert�r oder ein Trojaner eingebaut werden. Ken Thompson, schrieb f�r einen der gr��ten Hacks aller Zeiten, einen Compiler, der eine Hintert�r in das 'login' programm einbaute und den Trojaner verewigte, als der Compiler merkte, dass er sich selbst kompilierte. Lies seine Beschreibung dieses Klassikers hier. Gl�cklicherweise haben wir gcc. Immer wenn Du ein configure; make; make install ausf�hrst, macht gcc eine Menge Arbeit im Hintergrund. Wie lassen wir gcc f�r uns arbeiten? Wir werden damit anfangen, ein Kartenspiel zu programmieren, aber wir werden nur soviel schreiben, um die Funktionalit�t des Compilers zu demonstrieren. Da wir von Grund auf starten, haben wir gute Voraussetzungen dazu, den Kompilierungsprozess zu verstehen und was in welcher Reihenfolge passiert, um ein ausf�hrbares Programm zu erzeugen. Wir werden einen �berblick bekommen, wie ein C-Programm kompiliert wird, und die Optionen, um dem gcc zu sagen, was wir wollen. Die Schritte (und die Werkzeuge, die das machen ) sind Vor-kompilieren (gcc -E), Kompilieren (gcc), Assemblieren (as), und Linken (ld).

Zum Anfang...

Zuerst sollten wir wissen wie man den Compiler aufruft. Es ist wirklich einfach. Wir werden mit dem klassischen ersten C-Programm anfangen. (Fortgeschrittene m�ssen mir vergeben).

#include <stdio.h>

int main()

{
  printf("Hello World!\n");
}

Speichere diese Datei als game.c. Du kannst sie in der Kommandozeile �bersetzen mit:

gcc game.c

a.out
Hello World

gcc -o game game.c

game
Hello World

An diesem Punkt sind wir immer moch ein gutes St�ck davon entfernt, ein sinnvolles Programm zu haben. Wenn Du jetzt denkst, dass sei schlecht, solltest Du ber�cksichtigen, dass wir ein Programm haben, dass sich kompilieren l�sst und l�uft. Wenn wir jetzt St�ck f�r St�ck Funktionalit�t in das Programm bringen, dann nur um sicher zu gehen, dass es ausf�hrbar bleibt. Es scheint so zu sein, dass jeder angehende Programmierer zuerst 1000 Zeilen Sourcecode schreiben, und dann alles auf einmal korrigieren will. Niemand, und ich meine Niemand kann das. Du schreibst ein kleines Programm, das funktioniert, du �nderst es und l�sst es wieder laufen. Das schr�nkt die Anzahl der Fehler, die Du auf einmal korrigieren mu�t, ein. Und, Du wei�t genau, was Du gerade getan hast, damit Du es korrigieren kannst. Dies h�lt Dich davon ab, etwas zu erzeugen, von dem Du denkst, dass es arbeiten sollte, und auch kompiliert werden kann, aber niemals laufen wird. Erinnere Dich, nur weil es kompiliert wird, ist es nicht richtig.

Unser n�chster Schritt ist, ein Header-File f�r unser Spiel zu erzeugen. Ein Header-File sammelt Datentypen und Funktionsdeklarationen an einem Ort. Dies stellt sicher, dass die Definitionen der Datenstrukturen �bereinstimmen, so dass jeder Teil unseres Programms genau das gleiche sieht.

#ifndef DECK_H
#define DECK_H

#define DECKSIZE 52

typedef struct deck_t
{
  int card[DECKSIZE];
  /* number of cards used */
  int dealt;
}deck_t;

#endif /* DECK_H */

Speichere diese Datei als deck.h. Nur .c Dateien werden kompiliert, also m�ssen wir unsere Datei game.c �ndern. In Zeile 2 der Datei game.c, schreib #include "deck.h". In Zeile 5 schreib deck_t deck; Um sicher zu gehen, dass wir nichts zerst�rt haben, kompilieren wir es nochmal.

gcc -o game game.c

Keine Fehler, kein Problem. Wenn es nicht kompilierbar ist, arbeite daran, bis es funktioniert.

Vor-Kompilieren

Wie wei� der Compiler, was ein deck_t Typ ist? W�hrend der Vor-kompilierung, wird die Datei "deck.h" in die Datei "game.c" kopiert. Die Vor-kompilierer Anweisungen sind durch ein "#" gekennzeichnet. Du kannst den Precompiler (Die Vor-kompilierer) �ber den gcc mit der Option -E aufrufen.

gcc -E -o game_precompile.txt game.c
wc -l game_precompile.txt
  3199 game_precompile.txt

1. Kopieren der "#include" Dateien in das zu kompilierende Source-File.
2. Ersetzen der "#define" Texte mit den aktuellen Werten.
3. Ersetzen der Macros in der Zeile wann immer Sie aufgerufen werden.

Kompilieren

Als Zwischenschritt �bersetzt gcc deinen Code in Assembler-Code. Um das zu tun, muss er ausrechnen, was Du tun wolltest, indem es deinen Code �bersetzt. Wenn Du einen Syntax-Error machst, wird er es Dir das mitteilen und der Kompilierungsvorgang wird abgebrochen. Manche Leute glauben, dass dies der einzige Schritt im Kompilierungsvorgang ist, aber es gibt noch mehr f�r gcc zu tun.

Assemblieren

as �bersetzt den Assembler Code in Object-Code. Object-Code kann nicht am Prozessor verarbeitet werden, aber er ist sch�n geschlossen. Die Compiler Option -c verwandelt eine .c Datei in ein Object-File mit einer .o Endung. Wenn wir

gcc -c game.c

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "deck.h"

static time_t seed = 0;

void shuffle(deck_t *pdeck)
{
  /* Keeps track of what numbers have been used */
  int drawn[DECKSIZE] = {0};
  int i;

  /* One time initialization of rand */
  if(0 == seed)
  {
    seed = time(NULL);
    srand(seed);
  }
  for(i = 0; i < DECKSIZE; i++)
  {
    int value = -1;
    do
    {
      value = rand() % DECKSIZE;
    }
    while(drawn[value] != 0);

    /* mark value as used */
    drawn[value] = 1;

    /* debug statement */
    printf("%i\n", value);
    pdeck->card[i] = value;
  }
  pdeck->dealt = 0;
  return;
}

Speichere diese Datei als shuffle.c. Wir haben eine Debug-Anweisung in den Code eingef�gt, damit gibt es uns, wenn das Programm l�uft, die Kartenwerte aus, die es generiert. Dies ver�ndert zwar nicht die Funktionalit�t unseres Programms, aber es ist entscheidend, da wir wissen, was jetzt geschieht. Da wir gerade erst mit dem Spiel anfangen, haben wir keine andere M�glichkeit, um zu testen, ob unser Programm das tut, was wir wollen. Mit der printf Anweisung k�nnen wir exakt sehen, was gerade passiert, also k�nnen wir jetzt mit der n�chsten Phase beginnen, wo wir wissen, dass unser Blatt gut gemischt ist. Nachdem wir uns daran erfreut haben, dass es richtig arbeitet, k�nnen wir diese Zeile wieder aus dem Code entfernen. Die Art, ein Programm zu debuggen, wirkt zwar etwa ordin�r, aber es es ist die unkomplizierteste Art. Wir werden aufregendere debugger sp�ter kennenlernen.

1. Wir schreiben eine Variable mit ihrer Adresse, welche man mit dem '&' (Addresse von) Operator erh�lt. Diese �bergibt die Maschinenadresse der Variablen an die Funktion, also kann die Funktion selbst die Variable �ndern. Es ist zwar m�glich mit globalen Variablen zu arbeiten, aber diese sollten nur selten verwendet werden. Zeiger sind ein wichtiger Teil von C und sollten gut verstanden werden.
2. Wir verwenden einen Funktionsaufruf von einer neuen .c Datei. Das Betriebssystem schaut immer nach einer Funktion namens "main" und startet dort. shuffle.c hat keine Funktion "main", und vorher kann kein ausf�hrbares Programm erzeugt werden. Wir m�ssen es mit einem anderen Programm kombinieren, das eine Funktion "main" hat, und die Funktion "shuffle" aufruft.

F�hre folgenden Befehl aus:

gcc -c shuffle.c

shuffle(&deck);

gcc -o game game.c

/tmp/ccmiHnJX.o: In function `main':
/tmp/ccmiHnJX.o(.text+0xf): undefined reference to `shuffle'
collect2: ld returned 1 exit status

Linken

Der Linker, ld, nimmt den Object-Code, welcher zuvor von as erzeugt wurde, und wandelt es in ein ausf�hrbares Programm um mit dem Befehl

gcc -o game game.o shuffle.o

Der Linker findet die shuffle Funktion vom shuffle.o Objekt und f�gt es in die ausf�hrbare Datei ein. Das wirklich tolle an den Object-Files ist, dass, wenn wir die Funktion wieder verwenden wollen, wir nur noch die "deck.h" Datei einf�gen und das shuffle.o Object-File zur neuen auszuf�hrenden Datei dazulinken m�ssen.

Wiederverwendung von Code auf diese Art ist durchaus �blich. Wir haben nicht die printf Funktion geschrieben, die wir oben zum Debuggen verwendet haben, aber der Linker findet die Definitionen in dem File, das wir mit #include <stdlib.h> eingebunden haben, und zeigt zu dem Object-Code in der C-Bibliothek (/lib/libc.so.6). Auf diese Art k�nnen wir Funktionen von jemand anderem verwenden, ohne uns Sorgen zu machen, ob sie funktionieren, und uns um unsere eigenen Probleme k�mmern. Dies ist der Grund, weshalb Header-Dateien normalerweise die Daten- und Funktionsdeklarationen, aber nicht die Funktionen selbst enthalten. Normalerweise machst Du Object-Files bzw. Bibliotheken f�r den Linker, um es ins Programm zu schreiben. Ein Problem k�nnte auftreten, da wir nicht alle Funktionsdefinitionen in unseren Header geschrieben haben. Was k�nnen wir tun, um zu �berpr�fen, ob alles in Ordnung ist?

Zwei weitere wichtige Optionen

Die -Wall Option schaltet alle Warnungen betreffend Syntax ein, damit wir sicher sein k�nnen, dass unser Code in Ordnung und so weit wie m�glich portierbar ist. Wenn wir diese Option verwenden und unseren Code kompilieren, sehen wir etwas �hnliches wie:

game.c:9: warning: implicit declaration of function `shuffle'

void shuffle(deck_t *pdeck);

Eine weitere Compiler-Option ist die Optimierung. -O# (z.B.: -O2). Dies teilt dem Compiler mit, welche Stufe der Optimierung Du m�chtest. Der Compiler hat eine Menge Tricks, um Deinen Code ein bi�chen schneller zu machen. Bei kleinen Programmen wie unserem hier wirst Du keine Unterschiede merken, gr��ere Programme jedoch werden etwas kleiner. Du wirst es �berall sehen, deshalb solltest Du auch wissen, was es bedeutet.

Debuggen

Wie wir alle wissen, hei�t es nicht, wenn unser Code kompiliert wird, dass er auch so arbeitet, wie wir wollen. Du kannst �berpr�fen, ob alle Nummern verwendet werden, wenn du folgendes ausf�hrst

game | sort - n | less

gcc -g -c shuffle.c game.c
gcc -g -o game game.o shuffle.o

Zusammenfassung

Dieser Artikel war eine rasante Tour duch Kompilieren und Debuggen von C- Programmen. Wir diskutierten die Schritte, die der Compiler durchl�uft und welche Optionen gcc verwendet, um diese Schritte zu machen. Wir streiften das Linken mit shared libraries und endeten mit einer Einf�hrung �ber Debugger. Es nimmt viel Zeit in Anspruch, zu lernen, was Du tust, doch ich hoffe, dies hat dir geholfen, richtig zu beginnen. Mehr Informationen zu dem Thema findest Du im man und in den info Seiten f�r gcc, as und ld.

Selbst zu programmieren, lehrt am meisten. Zur �bung kannst Du die einfachen Anregungen f�r das Kartenspielprogramm in diesem Artikel verwenden und ein Black Jack Spiel programmieren. Nimm Dir die Zeit, um zu lernen, wie man den Debugger verwendet. Es ist viel einfacher mit einem GUI wie KDbg anzufangen. Wenn Du ein bi�chen Funktionalit�t auf einmal einbringst, wirst Du fertig sein, bevor Du es merkst. Denk daran, halt es lauff�hig!

Hier einige Dinge, die Du brauchen wirst, um ein vollst�ndiges Spiel zu programmieren.

• Eine Definition eines Spielers (Du k�nntest z.B.: deck_t als einen player_t definieren).
• Eine Funktion, die eine bestimmte Anzahl von Karten an einen bestimmten Spieler austeilt. Denk daran, die Zahl der 'ausgespielten' im Blatt zu merken, damit Du wei�t, von wo Du die n�chste Karte nehmen sollst. Denk daran Dir zu merken, wieviele Karten ein Spieler in der Hand hat.
• Eine Abfrage, ob der Spieler eine weitere Karte m�chte.
• Eine Funktion, um die Karten eines Spielers darzustellen. Der card -Wert ist % 13 (von 0 bis 12), der suit -Wert ist Wert / 13 (von 0 bis 3).
• Eine Funktion, um den Wert eines Blattes zu bestimmen. Asse haben die Nummer Null und k�nnen 1 oder 11 wert sein sein. K�nige haben die Nummer 12 und den Wert 10.

Links

• gcc GCC GNU Compiler Collection
• gdb GNU Debugger
• KDbg KDE's GUI Debugger
• Award Winning Compiler Hack Ken Thompson's gro�er Compiler-Hack