Module : Atelier Linux Embarqué ISET Radès. A.

U : 2017/2018

 
 

Lab  2  :  Le  fichier  Makefile  

qSqs

1.  Introduction  
Soit le graphe de dépendance suivant :

Figure  1  –  Graphes  de  dépendances  

Ici, la cible f dépend de f1.o et f2.o, qui sont eux---­‐mêmes des cibles dépendant de f1.c et f2.c.

L'ensemble des sommets précédents f s'appelle la règle de dépendance de f.

2.  La  commande  make  

make est une commande qui permet, en particulier, de maintenir à jour un programme obtenu à

partir de modules objets différents. Pour atteindre cet objectif, make prend en compte :

- Les dates de modification des différents modules composant l'application,

-­‐ Les dépendances des différents modules.

make trouve les informations de dépendance dans un fichier appelé Makefile qui contient :

-­‐ La description des dépendances des modules (fichiers) composant l'application.

-­‐ Les actions à entreprendre pour remettre à jour les modules.

3.2.2  Utilisation  de  make  

make va chercher un fichier de configuration nommé Makefile pour y trouver le graphe de

dépendance de l'application.

Sans argument, la commande make va chercher la première cible de ce fichier, sinon, elle traite

d'abord celle dont on lui a donné le nom en argument.  

1      Pr.  Habib  SMEI  –  habibsmei&gmail.com  

 
 
 
Module : Atelier Linux Embarqué ISET Radès. A.U : 2017/2018

 
 
3.  Structure  de  fichier  Makefile  
Ci-­‐dessous un exemple d’un fichier Makefile de l’application réalisé dans le lab précédent, nommée
calcul. On peut le découper en deux parties : (1) déclaration des variables et (2) lignes de
dépendance et d’actions.
TARGET_ARCH  =  linux  Déclaration  de  variables  
 
CC =  gcc  
LD =  gcc  
CFLAGS =  -­‐Wall  -­‐g  
LDFLAGS  =                                             Déclaration des variables
INCDIR    =  -­‐I.  
LIBDIR    =  
LIBS =  
PROG =  calcul  
OFILES =  main.o  somme.o  produit.o  
all:  $(PROG)
$(PROG)  :  $(OFILES)    
<TAB>  $(LD)  $(LDFLAGS)  $(OFILES)  -­‐o  $@  
main.o:  main.c  somme.h             Lignes de dépendance et d’actions.
<TAB>  gcc–c  main.c
somme.o:  somme.c  somme.h  
<TAB>  gcc–c  somme.c  
clean  :  
<TAB>  rm  -­‐f  *.o  *~  $(PROG)  #détruire  les  fichiers  .o,  ceux  se  terminant  par    ~  (fichiers  buckups)  et  calcul  
 
3.1.   Les  variables  dans  un  fichier  Makefile  
Les variables généralement définies dans un fichier Makefile sont:
Nom   Rôle   Exemple  d’initialisation  
CFLAGS   Option  de  compilation   CFLAGS  =  -­‐c  -­‐g  -­‐Wall  
LDFLAGS   Option  d’édition  de  liens   LDFLAGS  =  -­‐g  
OFILES   Fichiers  objets   OFILES  =  f1.o  f2.o  
CFILES   Fichiers  sources   CFILES  =  f1.c  f2.c  
INCDIR   Répertoire  de  fichiers  .h   INCDIR  =../inc/  
SRCDIR   Répertoire  de  fichiers  .c   SRCDIR  =  ./  
CC   Nom  du  compilateur   CC  =  gcc  
LD   Nom  de  l’éditeur  de  liens   LD  =  gcc  
PROG   Nom  du  programme  exécutable  produit   PROG  =  calcul  
cible  calcul  
Les  variables  internes  :  
On  peut  utiliser  des  variables  dites  internes  dans  un  fichier  makefile.  
 
Variable  interne   Signification  
$@   Le nom de la cible
$<   Le nom de la première dépendance
$^   La liste des dépendances  
$?   La liste des dépendances plus récentes que la cible  
$* Le nom du fichier sans suffixe
 
 

2      Pr.  Habib  SMEI  –  habibsmei&gmail.com  

 
 
 
Module : Atelier Linux Embarqué ISET Radès. A.U : 2017/2018

 
 
3.2.  Dépendances  et  actions  

Un fichier Makefile contient la représentation du graphe de dépendance d'une application sous

forme de texte. Il contient aussi, à la suite de chaque règle de dépendance, les actions à entreprendre
pour passer des dépendances à la cible. Un fichier Makefile est donc une succession de lignes de
dépendance et de lignes d'action :

Ligne  de  dépendance   cible  :  dépendance  1    dépendance  n  

Ligne  d’action   Commandes  à  exécuter  pour  (re)créer  la  cible  si  une  dépendance  est  modifiée  

Exemple  :  
$(PROG)  :  $(OFILES)  
<TAB>  $(LD)  $(LDFLAGS)  $(OFILES)  -­‐o  $@  
Attention :
-­‐ Une ligne d'action commence par le caractère <TAB>
-­‐ Une ligne de commentaires commence par #
Après une modification de l'un des fichiers impliqués dans le Makefile, il suffit de donner la
commande :
$ make nom_de_la_cible
ou :
$ make

Pour (re)créer l'exécutable cible en ne gérant que les actions nécessaires, (make sans paramètre
traite la première cible).

Remarque : la cible n'est pas forcément un fichier, par exemple la commande «make RM » va
nettoyer le répertoire courant:

RM :
<TAB> rm $(OFILES) $(PROG)

TAF 1 :
Soit un projet composé des fichiers suivants :

hello.c hello.h main.c

#ifndef H_GL_HELLO #include <stdio.h>
#include <stdio.h> #define H_GL_HELLO #include <stdlib.h>
#include <stdlib.h> void Hello(void); #include "hello.h"
void Hello (void) #endif int main(void)
{ {
printf("Hello World\n"); Hello();
} return EXIT_SUCCESS;
}

1. Créer le fichier Makefile de ce projet.

2. Ajouter les règles suivantes au fichier Makefile :

all : qui regroupe dans ses dépendances l'ensemble des exécutables à produire.
clean : qui permet de supprimer tous les fichiers intermédiaires.
mrproper : qui supprime tout ce qui peut être régénéré et permet une reconstruction complète du projet.

3      Pr.  Habib  SMEI  –  habibsmei&gmail.com  

 
 
 
Module : Atelier Linux Embarqué ISET Radès. A.U : 2017/2018

 
 
3. Définir les quatre variables suivantes dans le Makefile :

- Une désignant le compilateur utilisée nommée CC (une telle variable est typiquement nommé CC pour
un compilateur C, CPP pour un compilateur C++). Mettre gcc dans CC
- CFLAGS regroupant les options de compilation (Généralement cette variable est nommées CFLAGS
pour une compilation en C, CXXFLAGS pour le C++). Mettre dans CFALGS -W -Wall -ansi -pedantic
- LDFLAGS regroupant les options de l'édition de liens. Ne rien mettre dans cette variable.
- EXEC contenant le nom des exécutables à générer. Mettre hello dans EXEC.

Rappel : options de gcc

Option Signification

--help Affiche l'écran d'aide du compilateur.

--version Affiche la version du compilateur.

-o nom Donne le nom du fichier de sortie.

-g Génère les informations symboliques de débogage.

Active les optimisations (n allant de 0 à 3, ou « s » pour optimiser la taille du code

-On
généré).

-f<option> Active une option.

-ansi Demande la compilation du code ANSI.

-pedantic Affiche les warnings requis par la norme ANSI du langage.

-pedantic-errors Génère les erreurs requis par la norme ANSI du langage.

-w Supprime tous les warnings.

-W Active les warnings supplémentaires.

-Wall Active tous les warnings possibles.

-p Active le profiling des fonctions.

-a Active le profiling des blocks.

-ax Active le profiling des branchements.

Génère du code indépendant de son adresse de chargement (nécessaire pour les

-fPIC bibliothèques dynamiques, dont le chargement peut être réalisé par le système
n'importe où en mémoire a priori).

4      Pr.  Habib  SMEI  –  habibsmei&gmail.com