Chapitre 2 : Compilation d’un programme
sous GNU/Linux
GNU Compiler Collection - GCC
GNU Compiler Collection, abrégé en GCC, est un
ensemble de compilateurs créés par le projet GNU. GCC
est un logiciel libre capable de compiler divers langages de
programmation.
GCC est utilisé pour le développement de la plupart des
logiciels libres.
2
GNU Compiler Collection - GCC
Exemples de langages supportés :
gcc : le compilateur C de GNU ;
g++ : le compilateur C++ de GNU ;
gcj : le compilateur Java de GNU. Capable de compiler à la fois
des binaires natifs ou en byte code ;
gobjc : le compilateur Objective-C de GNU ;
gobjc++ : le compilateur Objective-C++ de GNU ;
gnat : le compilateur Ada de GNU ;
gfortran : le compilateur Fortran 95 de GNU (qui remplace g77);
3
GNU Compiler Collection - GCC
Exemple : Programme Hello world (hello.c)
#include <stdio.h>
int main ()
{ printf ("Hello world!\n");
return 0; }
Pour le compiler :
$ gcc hello.c à Ceci produira un fichier binaire nommé [Link]. Vous pouvez
l'exécuter avec la commande suivante : $ ./[Link]
Comme prévu, le programme affichera la phrase « Hello world! » dans le
shell. Si vous avez plusieurs fichiers sources, vous pouvez les passer tous en
paramètre à GCC ; ils seront compilés et liés ensemble :
$ gcc hello.c foo.c bar.c
4
GNU Compiler Collection - GCC
Il est recommandé aussi d'activer les messages d'avertissement avec
l'option -Wall et de distribuer les programmes compilant sans
aucun avertissement.
On peut utiliser l'option -Werror pour demander à GCC de
traiter les avertissements comme des erreurs !
5
Les étapes de compilation
gcc effectue quatre étapes pour produire
l’exécutable :
1. Passage au pré-processeur (Preprocessing)
2. Compilation en langage Assembleur
(Compiling)
3. Conversion du langage assembleur en code
machine objet (assembling)
4. Edition des liens (Linking)
6
Les étapes de compilation
7
Les étapes de compilation
Le programme bonjour.c
#include <stdio.h>
int main (void)
{
/* afficher le mot bonjour et sauter une ligne */
printf("bonjour !!!\n");
return 0;
}
8
Les étapes de compilation
9
Les étapes de compilation
10
Les étapes de compilation
11
Les étapes de compilation
12
Les étapes de compilation
13
GNU Compiler Collection - GCC
Options :
L’option – o $ gcc -o hello hello.c (hello au lieu de [Link])
On peut demander à gcc de faire seulement la compilation d’un
fichier source avec l'option -c :
$ gcc -c hello.c ! Ceci produira un fichier objet intermédiaire
hello.o. On devra alors appeler l'éditeur de liens afin d'obtenir un
binaire exécutable. Pour invoquer l'éditeur de liens, on appelle
simplement GCC avec les fichiers objet en paramètre :
$ gcc -o hello hello.o (Appel de l’éditeur de liens et production de hello)
14
GNU Compiler Collection - GCC
Options :
On peut ainsi compiler chaque fichier source de votre programme
séparément, et appeler ensuite l'éditeur de liens :
$ gcc -c hello.c
$ gcc -c foo.c
$ gcc -c bar.c
$ gcc -o hello hello.o foo.o bar.o
Par défaut, GCC recherche les fichiers d'en-tête (Ceux qu’on incluse avec la
directive #include) dans les dossiers /usr/local/include et /usr/include.
15
Les étapes de compilation
Le programme gcc se base simplement sur l’extension du fichier qu’on lui
donne pour déterminer quels programmes il doit appeler. Par exemple, si le
fichier se termine par :
.c : il appelle dans l’ordre : le pré-processeur, le compilateur, l’assembleur et
l’éditeur de lien ;
.i : il appelle dans l’ordre : le compilateur, l’assembleur et l’éditeur de liens ;
.s : il appelle dans l’ordre : l’assembleur et l’éditeur de liens ;
.o : il appelle simplement l’éditeur de liens.
16
Environnement de programmation
Ligne de commande : Lorsqu'on donne le nom de l'exécutable sur la ligne de
commande, il est possible de passer des paramètres au programme, le nombre de
paramètres sur la ligne (nom de la commande inclus) est stocké dans l'argument argc de la
fonction main, et la liste des paramètres est stockée dans le tableau de chaînes de caractères
argv[] de la fonction main.
#include <stdio.h>
// main(int argc, char *argv[]) // // ARGUMENTS : // // argc = nombre d'arguments sur la ligne (nom de l'executable compris) // argv= tableau de
chaines de car. qui contient dans la case 0 le // nom de la commande et dans les autres les arguments de la commande // // RETOURNE : 0 en cas d'exécution
normale
int main(int argc, char *argv[])
{
int nb; printf("les %d paramètres de la commande %s sont :\n", argc-1, argv[0]);
nb = 1;
while(nb < argc)
{ printf("\t%s\n",argv[nb]); nb++; }
return 0;
}
>./test 1 15.3 bonjour A -39
les 5 paramètres de la commande ./test sont : 1 15.3 bonjour A -39
>
17
Environnement de programmation
Écrivez un programme qui compte le nombre de lettres du mot qui est passé en paramètres sur la ligne de commandes
> gcc -Wall compte_lettres.c -o compte_lettre_mots
> ./compte_lettre_mots abracadabra le mot abracadabra contient 11 lettres
> ./compte_lettre_mots abricot le mot abricot contient 7 lettres
> ./compte_lettre_mots zoo le mot zoo contient 3 lettres
> ./compte_lettre_mots ce le mot ce contient 2 lettres
> ./compte_lettre_mots a le mot a contient 1 lettres
>
indication : la deuxième case de argv contient une chaîne (argv est un tableau à deux dimensions).
Compter le nombre de lettres d'un mot sur la ligne de commande
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int indice; if(argc != 2)
{
printf("erreur");
exit(1);
}
indice = 0;
while(argv[1][indice] != '\0'){ indice++; }
printf("le mot %s contient %d lettres\n", argv[1], indice);
return 0;
}
18
Environnement de programmation
Une fois qu’on a généré le binaire de notre programme, on peut
l’exécuter en tapant la commande ./bonjour dans un terminal.
Le système d’exploitation fait alors un certain travail que l’on peut
résumer comme suit :
1. Allouer un espace mémoire pour le programme et charger le binaire
(contenant le code et les données statiques) dans cet espace ;
2. Résoudre les liens vers des bibliothèques dynamiques : en effet, en
plus des bibliothèques statiques comme la bibliothèque C standard, un
programme utilise souvent des bibliothèques partagées qui sont chargées
automatiquement par le système (comme les [Link] sous Windows
ou des fichiers .so sous Unix).
19
Environnement de programmation
3. Résoudre les accès mémoires vers des destinations qui n’étaient pas
connues à la compilation : dans le cas d’un code dépendant de la position
mémoire, il faut traduire les accès pour qu’ils pointent vers des adresses
cohérentes avec l’adresse réelle à laquelle le programme a été chargé (on
parle le plus souvent de translations) ;
4. Lancer l’exécution du code du programme, qui se trouve au début de
la zone qui lui a été allouée.
20
Structure générale du programme binaire
(processus ) en mémoire
Les 4 zones d’un processus sont :
— La zone de code (text) qui contient le code
binaire (les instructions) de notre programme ;
— La zone de données statiques (data) qui
contient les données allouées statiquement dans le
programme (c’est à dire les variables globale en C) ;
— La zone de données dynamiques (appelée aussi
tas, Heap en anglais) où la fonction malloc va chercher
de la mémoire lorsqu’on fait une allocation dynamique
dans le programme ;
— La pile d’exécution (stack) qui contient entre
autres les variables locales aux différentes fonctions du
programme
21
