Vous trouverez sur ce wiki quelques notes personnelles sur l'UE Projets Technologiques en L2 Info.

Site Web : https://moodle1.u-bordeaux.fr/course/view.php?id=2930

Ici, nous nous intéressons uniquement à la compilation de programme C99 sous Linux avec le compilateur GNU.

Considérons un programme hello.c en un seul fichier.

hello.c

#include <stdio.h>
int main(int argc, char* argv[]) {
  printf("hello world!\n");
  return 0;
}

Pour rendre ce programme exécutable, il faut le compiler avec gcc:

gcc -std=c99 hello.c -o hello   # compilation
./hello                         # exécution

En fait, la ligne de compilation précédente est un raccourci. En principe, on distingue deux étapes, la compilation des fichiers sources (.c) en fichier objet (.o) et l'édition de lien qui combine les fichiers objets pour générer un exécutable. Ce qui donne :

gcc -std=c99 -c hello.c             # compilation (génère hello.o)
gcc hello.o -o hello                # édition de lien (génère l'exécutable hello)

Supposons maintenant que notre programme se compose de plusieurs fichiers : le programme principal toto.c avec la fonction main() ainsi que plusieurs fichiers annexes tutu.c et tata.c. De plus, ce programme utilise la fonction sqrt() de la bibliothèque mathématique standard (libm.a). Pour compiler ce programme en ligne de commande, il faut d'abord générer tous les fichiers objets !

gcc -std=c99 -c toto.c tutu.c tata.c

Puis, on réalise l'édition de lien sans oublier l'option “-lm” qui indique d'utiliser la bibliothèque statique libm.a, généralement disponible dans un répertoire standard du système (typiquement /usr/lib).

gcc toto.o tutu.o tata.o -o toto -lm

Imaginons maintenant qu nous souhaitons regrouper les fichiers tutu.c et tata.c au sein d'une bibliothèque statique libpouet.a. La construction de bibliothèque permet de favoriser la “réutilisabilité” des fonctions d'une sous-partie du programme. Pour construire cette bibliothèque, il faut regrouper plusieurs fichiers objets au sein d'un archive :

ar rcs libpouet.a tutu.o tata.o 

On peut ensuite utiliser cette bibliothèque pour la compilation avec l'option '-lpouet' :

gcc toto.o -o toto -L. -lpouet -lm

L'option '-L.' indique que le fichier libpouet.a est disponible dans le répertoire courant ('.').

Pour compiler automatiquement et efficacement un projet de programmation, le Makefile est une solution élégante.

Un fichier Makefile est un simple fichier texte qui définit un ensemble de régles, chaque règle permettant de générer un fichier cible à partir de ses dépendances (une liste de fichiers). Voici la syntaxe d'un règle :

cible1: dep1 dep2 dep3 ...
    commande                     

Attention, il faut une tabulation avant d'écrire la commande qui réalise la cible !

Notons que la commande n'est exécutée que si le fichier cible1 n'existe pas, ou que la cible est périmée, c'est-à-dire qu'il y a au moins une dépendance qui est plus récente que la cible. Dans ce dernier cas, il faut mettre à jour la cible. Par ailleurs, les dépendances peuvent également être la cible d'autres règles. Dans ce cas, si le fichier d'une dépendance comme dep1 n'existe pas (ou qu'elle est périmée), alors on va appliquer cette autre règle en cascade pour mettre à jour cette dépendance, avant de mettre à jour cible1.

dep1: autredep1 autredep2 ...
    autre_commande

Au final, grâce à un chaînage précis des dépendances, le Makefile permet de re-compiler un projet en ne mettant à jour que les cibles qui dépendent des fichiers modifiés.

Voici un exemple type de fichier Makefile pour le programme C précédent.

Makefile

# variable standard pour la compilation
CC=gcc                      # compilateur
CFLAGS=-Wall -g -std=c99    # options de compilation
LDFLAGS=-L. -lm             # options de link
CPPFLAGS=                   # options de preprocessing
 
# cible principale (par défaut)
all: toto
 
# règle spécifique pour générer l'exécutable
toto: toto.o tutu.o tata.o
	$(CC) $^ -o $@ $(LDFLAGS)
 
# règle générique de compilation des fichiers C
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@
 
.PHONY: clean
clean:
	rm -f *.o *~ toto

Dans ce Makefile, il y a quelques notions à comprendre :

• Les commentaires sont précédés du symbole #.
• La variable $@ représente la cible courante.
• La variable $^ représente la liste des dépendances.
• La variable $< représente la première dépendance.
• La cible .PHONY permet d'indiquer des cibles particulières qui ne sont pas des fichiers, comme par exemple clean.

Pour fabriquer une cible particulière, on fait make cible. Par défault, l'appel à make fabrique la première cible (all dans notre exemple.

$ make
gcc -Wall -g -std=c99 -c toto.c -o toto.o
gcc -Wall -g -std=c99 -c tutu.c -o tutu.o
gcc -Wall -g -std=c99 -c tata.c -o tata.o
gcc toto.o tutu.o tata.o -o toto -L. -lm
 
$ make clean
rm -f *.o *~ toto

Expliquer comment injecter automatiquement des dépendances complexes dans un Makefile grâce à l'option '-MM'de gcc.