Compilez sous GNU/Linux !

Un peu de culture

Compilez avec GCC

Installer GCC

sudo apt-get install build-essential

Utiliser gcc

gcc main.c fonctions.c -o Programme

g++ main.cpp fonctions.cpp -o Programme

./Programme

Les arguments de GCC

gcc -c main.c -o main.o

gcc sources/*.c -I headers -o Programme

gcc -o main.o -c main.c

gcc -c main.c -o main.o

Les bibliothèques statiques

gcc -c machin.c -o machin.o
ar -q libmachin.a machin.o

gcc bidule1.o bidule2.o bidule3.o libmachin.a -o Programme

Les bibliothèques dynamiques

• si la bibliothèque est utilisée par plusieurs programmes, elle n'est chargée qu'une fois en mémoire ;
• l'exécutable est plus léger ;
• on peut la mettre à jour sans recompiler le programme (à condition de ne pas modifier le header).

gcc -c -fPIC truc -o truc.o
gcc -shared -fPIC truc.o -o libtruc.so

gcc -fPIC bidule1.o bidule2.o bidule3.o libtruc.so -o Programme

• LA MAUVAISE : copier la bibliothèque dans /lib ou dans /usr/libCode : Console

  cp libtruc.so /lib

  (nécessite d'être root)
  On laisse ces répertoires aux programmes fournis et suivis par la distribution Linux. On ne pollue pas le système avec nos programmes personnels.
  Pour les programmes personnels (ou du voisin, ou que-sais-je), on utilise le répertoire /usr/local.
  On copiera donc les bibliothèques dans /usr/local/lib !
  Hélas, ce répertoire ne sera pas trouvé non plus par le système lorsque le programme appellera la bibliothèque !
On utilisera donc :
• LA BONNE MÉTHODE : utiliser la variable LD_LIBRARY_PATH. Cette variable donne les autres chemins où sont appelés les bibliothèques. Elle est sous la forme chemin1:chemin2:chemin3. Vous pouvez voir sa valeur en utilisant :Code : Console

  echo $LD_LIBRARY_PATH

  Généralement par défaut, elle n'est pas définie, la commande affichera alors un blanc. Pour ajouter un dossier, il suffit de mettreCode : Console

  export LD_LIBRARY_PATH=chemin:$LD_LIBRARY_PATH

  Pour indiquer le répertoire courant, utilisez le point (.).

echo export LD_LIBRARY_PATH=chemin:$LD_LIBRARY_PATH >> ~/.bash_profile

Les noms usuels

• -lmachin pour libmachin.a ou -ltruc pour libtruc.so,
  -l rajoute automatiquement lib devant et .a ou .so derrière ;
• -Lchemin pour indiquer le chemin ;
  non nécessaire si le chemin est /lib ou /usr/lib (mais ça ne devrait pas !) ou dans LD_LIBRARY_PATH.

gcc -fPIC bidule.o -L. -lbidule -o Programme

Mettre à jour une bibliothèque

ld -soname

gcc -Wl,-soname, libtruc.so.1 -o libtruc.so.1.1

Quelques explications

ldconfig

• /lib
• /usr/lib
• les chemins indiqués dans /etc/ld.so.conf (vous pouvez l'éditer si vous êtes root) ;
• les chemins de LD_LIBRARY_PATH.

• le nom de la bibliothèque doit être du type libnom.so.version pour être reconnue par ldconfig ;
• si vous éditez /etc/ld.so.conf, vous n'avez plus besoin de LD_LIBRARY_PATH ;
• une bibliothèque de ce type ne sera pas reconnue avec l'option -l, qui nécessite un type libnom.so (sans rien derrière) ;
• il existe certaines conventions : pour mettre à jour une bibliothèque il faut que les prototypes des fonctions soient identiques, si vous rajoutez une fonction à cette bibliothèque, il faudra mettre à votre bibliothèque -soname libtruc.so.2 ! Elle sera alors différente de libtruc.so.1 !
• il faudra exécuter ldconfig en console avant de lancer le programme.

Compiler avec des bibliothèques tierces

pkg-config --cflags [bibliothèque]

pkg-config --libs [bibliothèque]

gcc -c main.c ${pkg-config --cflags gtk+-2.0} -o main.o
gcc main.o ${pkg-config --libs gtk+-2.0} -o Programme

gcc main.c ${pkg-config --cflags --libs gtk+-2.0} -o Programme

man ar
man ldd
man ld.so
man ldconfig
man pkg-config

What does make make ?

• la syntaxe de make sera plus adaptée aux commandes de compilation ;
• make effectue les commandes en fonction des fichiers les plus récents ;
• make gère les dépendances ;
• et j'en passe...

La syntaxe du Makefile

Les règles

1
2
3

cible: dependances
        commandes
        ...

• cible est le nom du fichier créé (par exemple, Programme) ;
• dependances représente la liste des fichiers (ou règles) nécessaires à la construction de la cible ;
• commandes représente les commandes à effectuer pour créer la cible.

Un Makefile minimal

gcc -c fonctions.c -o fonctions.o
gcc -c main.c -o main.o
gcc main.o fonctions.o -o Programme

1
2
3
4
5
6
7
8
9

#Ceci est mon Makefile
Programme : main.o fonctions.o
        gcc main.o fonctions.o -o Programme
 
main.o : main.c fonctions.c
        gcc -c main.c -o main.o
 
fonctions.o : fonctions.c
        gcc -c fonctions.c -o fonctions.o

make Programme

make

Un Makefile enrichi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#mon Makefile enrichi
 
#création de l'exécutable 'Programme'
all: main.o fonctions.o
        gcc main.o fonctions.o -o Programme
 
main.o: main.c fonctions.h
        gcc -c main.c -o main.o
 
fonctions.o: fonctions.c
        gcc -c fonctions.c -o fonctions.o
 
#suppression des fichiers temporaires
clean:
        rm -rf *.o
 
#suppression de tous les fichiers, sauf les sources,
#en vue d'une reconstruction complète
mrproper: clean
        rm -rf hello

• all : compile tous les fichiers source pour créer l'exécutable principal ;
• install: exécute all, et copie l'exécutable, les librairies, les datas, et les fichiers en-tête s'il y en a dans les répertoires de destination ;
• uninstall : détruit les fichiers créés lors de l'installation, mais pas les fichiers du répertoire d'installation (où se trouvent les fichiers source et le Makefile) ;
• clean : détruit tout les fichiers créés par all ;
• info : génère un fichier info ;
• dvi : génère un fichier dvi ;
• dist : crée un fichier tar de distribution.

make all

make clean

make mrproper

make && make clean

make mrproper && make

Les directives

Cibles particulières : .PHONY

1
2

clean:
        rm -rf *.o

1

.PHONY: clean, mrproper

Les règles implicites

1
2
3
4
5
6
7
8

all: main.o fonctions.o
        gcc main.o fonctions.o -o Programme
 
main.o: main.c fonctions.h
        gcc -c main.c -o main.o
 
fonctions.o: fonctions.c
        gcc -c fonctions.c -o fonctions.o

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#définition des cibles particulières
.PHONY: clean, mrproper
 
#désactivation des règles implicites
.SUFFIXES
 
 
#all
all: main.o fonctions.o
        gcc main.o fonctions.o -o Programme
 
main.o: main.c fonctions.h
        gcc -c main.c -o main.o
 
fonctions.o: fonctions.c
        gcc -c fonctions.c -o fonctions.o
 
 
#clean
clean:
        rm -rf *.bak rm -rf *.o
 
#mrproper
mrproper: clean
        rm -rf hello

• si on a 120 fichiers main.c, on aura 120 règles à définir ;
• s'ils sont répartis dans 50 répertoires, le Makefile va être imposant ;
• si on veut compiler avec un autre compilateur, ou bien ajouter des arguments à gcc, il faudra corriger toutes les commandes.

Les variables

Variables personnalisées

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#définition des cibles particulières
.PHONY: clean, mrproper
 
#désactivation des règles implicites
.SUFFIXES
 
#définition des variables
CC = gcc
CFLAGS = -W -Wall -v
 
 
 
#all
all: main.o fonctions.o
        $(CC) main.o fonctions.o -o Programme
 
main.o: main.c fonctions.h
        $(CC) -c main.c -o main.o $(CFLAGS)
 
fonctions.o: fonctions.c fonctions.h
        $(CC) -c fonctions.c -o fonctions.o $(CFLAGS)
 
 
#clean
clean:
        rm -rf *.bak rm -rf *.o
 
#mrproper
mrproper: clean
        rm -rf Programme

• AR : programme de maintenance d'archive (ar) ;
• CC : compilateur C (gcc) ;
• CXX : compilateur C++ (g++) ;
• RM : commande pour effacer un fichier (rm) ;
• TEX : programme pour créer un fichier TeX dvi à partir d'un source TeX (tex) ;
• ARFLAGS : paramètres à passer au programme de maintenance d'archives ;
• CFLAGS : paramètres à passer au compilateur C ;
• CXXFLAGS : paramètres à passer au compilateur C++ ;
• LDFLAGS : paramètres à passer au compilateur pour l'éditions de liens.

• prefix : racine du répertoire d'installation (= /usr/local) ;
• exec_prefix : racine pour les binaires (= $(prefix)) ;
• bindir : répertoire d'installation des binaires (= $(exec_prefix)/bin);
• libdir : répertoire d'installation des librairies (= $(exec_prefix)/lib) ;
• datadir : répertoire d'installation des données statiques pour le programme (= $(exec_prefix)/lib) ;
• statedir : répertoire d'installation des données modifiables par le programme (= $(prefix)/lib);
• includedir : répertoire d'installation des en-têtes (= $(prefix)/include) ;
• mandir : répertoire d'installation des fichiers de manuel (= $(prefix)/man) ;
• manxdir : répertoire d'installation des fichiers de la section x du manuel (= $(prefix)/manx) ;
• infodir : répertoire d'installation des fichiers info (= $(prefix)/info) ;
• srcdir: répertoire d'installation des fichiers sources (= $(prefix)/src).

Les variables automatiques

• $@ : nom de la cible ;
• $< : première dépendance de la liste des dépendances ;
• $? : les dépendances plus récentes que la cible ;
• $^ : toutes les dépendances ;
• $* : correspond au ' * ' simple dans le shell, i.e. représente n'importe quel nom.

1
2
3
4
5
6
7
8
9

#all
all: main.o fonctions.o
        $(CC) $^ -o Programme $(CFLAGS)
 
main.o: main.c fonctions.h
        $(CC) -c $< -o $@ $(CFLAGS)
 
fonctions.o: fonctions.c
        $(CC) -c $< -o $@ $(CFLAGS)

Les règles d'inférence

1
2
3
4
5
6

#all
all: main.o fonctions.o
        $(CC) $^ -o Programme $(CFLAGS)
 
%.o: %.c
        $(CC) -c $< -o $@ $(CFLAGS)

1
2
3
4
5
6
7
8

all: main.o fonctions.o
        $(CC) $^ -o Programme $(CFLAGS)
 
 
main.o: fonctions.h
 
%.o: %.c
        $(CC) -c $< -o $@ $(CFLAGS)

• %.c pour les cibles ;
• %.c dans les dépendances;
• $*.c dans les commandes.

1
2
3

#clean
clean:
        rm -rf *.o

Les conditions

1
2
3
4
5
6

ifeq($(VARIABLE),valeur)
        #Actions
 
else
        #Actions
endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#définition des variables
CC = gcc
EXEC = Programme
DEBUG = yes
 
ifeq($(DEBUG),yes)
        CFLAGS = -g -W -Wall
else
        CFLAGS =
endif
 
 
#all conditionnel
all : $(EXEC)
ifeq($DEBUG),yes)
        @echo "Génération en mode Debug"
else
        @echo "Génération en mode Release"
endif
 
Programme: main.o fonctions.o
        $(CC) $^ -o $(EXEC)
 
 
main.o: fonctions.h
 
%.o: %.c
        $(CC) -c $< -o $@ $(CFLAGS)

L'appel récursif

make -C main all

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#Makefile racine
.SUFFIXES
.PHONY
 
LD = gcc
LDFLAGS =
OBJ = fonctions/*.o main/*.o
 
all:
        $(LD) $(OBJ) -o Programme
 
%.o
        make -C main
        make -C fonctions
 
clean:
        make -C main clean
        make -C fonctions clean
        rm -rf *.o

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#main/Makefile
.SUFFIXES
.PHONY : clean
 
CC = gcc
CFLAGS = -W
OBJ = main.o
 
all: $(OBJ)
 
%o: %c
        $(CC) -c $^ -o $@ $(CFLAGS)
 
clean:
        rm -rf *.o

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#fonctions/Makefile
.SUFFIXES
.PHONY : clean
 
CC =gcc
CFLAGS = -W
OBJ = fonctions1.o fonctions2.o fonctions3.o
 
 
all: $(OBJ)
 
%o: %c
        $(CC) -c $^ -o $@ $(CFLAGS)
 
clean: 
        rm -rf *.o

• -n : liste ce que make va faire, sans le faire ;
• -f : indique le fichier Makefile ;
• -j3 : parallélise l'exécution de make (très utile sur biprocesseur) ;
• -p : liste les règles implicites ;
• tapez man make en console (je n'ai pas trouvé de traduction pour celui-là, désolé !).

Des Makefile automatiques : les autotools

./configure
make
make install

Créer un paquet

checkinstall

checkinstall -D make install

checkinstall -R make install

checkinstall -S make install

À la sauce debian : debhelper impose les règles

./debian/rules binary

apt-get madwifi-source

Façon slackware : makepkg s'occupe du build

Compiler via make sous Windows