Make

De Wiki de Calcul Québec
Aller à : Navigation, rechercher
Autres langues :anglais 100% • ‎français 100%

Description

make est un logiciel qui construit automatiquement des fichiers, souvent exécutables, ou des bibliothèques à partir d'éléments de base tels que du code source. En général, on l’utilise pour automatiser le processus de compilation et d'assemblage d'un programme.

La commande « make » interprète et exécute les instructions du fichier « makefile », qui spécifie comment construire les fichiers cibles. À la différence d'un simple script, « make » exécute les commandes seulement si elles sont nécessaires. Le but est d'arriver à un résultat (logiciel compilé ou installé, documentation créée, etc.) sans nécessairement refaire toutes les étapes.

Dans le fichier « makefile » se trouvent, entre autres, des informations sur les dépendances. Par exemple, puisque l'exécutable du programme dépend des fichiers objets, si certains de ces fichiers ont changé, un réassemblage du programme est nécessaire. De la même manière, les fichiers objets dépendant de leurs fichiers sources associés, si un fichier source a été modifié, ce dernier doit être recompilé pour recréer le nouveau fichier objet. Toutes ces dépendances doivent être incluses dans le fichier « makefile ». Ainsi, il n'est plus nécessaire de recompiler tous les fichiers sources à chaque modification, la commande « make » s'occupe de recompiler et réassembler uniquement ce qui est nécessaire. Il est aussi possible d'utiliser des variables à l'intérieur d'un « makefile ».

Exemples d'utilisation

Le principal argument de la commande « make » est généralement la cible. Il s'agit de la composante que « make » doit construire. Les cibles disponibles dépendent du contenu du « makefile », mais certaines cibles sont très communes. C'est le cas des cibles all, test, check, clean et install. Si aucune cible n'est spécifiée, tel que

[nom@serveur $] make


le comportement typique est de tout construire, soit l'équivalent de

[nom@serveur $] make all


Les cibles test ou check sont généralement utilisées pour exécuter des tests afin de valider que l'application ou la bibliothèque compilée fonctionne correctement. Généralement, ces cibles seront dépendantes de la cible all. Vous pourriez ainsi vérifier la compilation via la commande

[nom@serveur $] make all && make check


ou

[nom@serveur $] make all && make test


La cible clean efface tous les fichiers binaires compilés précédemment afin de recommencer la compilation de zéro. Il existe parfois aussi la cible distclean qui efface non seulement les fichiers créés par « make », mais aussi les fichiers créés lors de l'opération de configuration par configure ou cmake. Ainsi, pour nettoyer le répertoire de compilation, vous pouvez généralement exécuter

[nom@serveur $] make clean


et parfois

[nom@serveur $] make distclean


La cible install procède normalement à l'installation de l'application ou de la bibliothèque compilée. L'emplacement de l'installation dépendra du « makefile » mais peut souvent se modifier via un paramètre additionnel prefix ainsi :

[nom@serveur $] make install prefix=$HOME/LOGICIEL


Ces différentes cibles ne sont cependant que des conventions et l'auteur d'un « makefile » pourrait très bien choisir une autre convention. Pour davantage d'information sur les cibles typiques, notamment supportées par toutes les applications GNU, visitez cette page. Les options pour configurer les répertoires d'installation et autres sont quant à elles listées ici.

Exemple de « Makefile »

L'exemple suivant, d'utilisation générale, inclut beaucoup d'explications et de commentaires. Pour un guide approfondi sur la création de fichier « makefile », visitez le site web de GNU Make.


Fichier : Makefile
# Makefile pour facilement mettre à jour la compilation d'un programme (.out)
# --------
#
# par Alain Veilleux, 4 août 1993
#     Dernière révision : 30 mars 1998
#
# BUT ET FONCTIONNEMENT DU PRÉSENT SCRIPT :
#    Script sous forme "Makefile" permettant de mettre à jour un programme
#    comprenant plusieurs routines séparées sur le disque.  Ce script n'est pas
#    exécuté par lui-même, mais est plutot lu et interprété par la commande
#    « make ».  Lors de son appel, la commande « make » vérifie les dates des
#    différents fichiers composants votre programme compilé.  Seulement les
#    routines ayant été modifiées depuis la compilation du programme final
#    seront recompilées sous forme objet (fichiers terminés par .o).  Les
#    fichiers .o seront ensuite liés ensemble pour reformer une version mise à
#    jour du programme final.
#
# POUR ADAPTER LE PRÉSENT SCRIPT À VOTRE PROGRAMME :
#    Modifiez le contenu des variables de la section ci-dessous.  Des
#    commentaires vous guideront dans ce sens.
#
# UTILISATION DE « make » SUR LA LIGNE DE COMMANDE UNIX :
#    1- Tapez « make » pour mettre à jour l'ensemble du programme.
#    2- Tapez « make NomRoutine » pour mettre à jour seulement la
#          routine NomRoutine.
#
 
 
#====================  Définition des variables  ====================
# Remarque : les variables sont parfois appelées des « macros » dans les fichiers Makefile
 
# Nom du compilateur à utiliser (FORTRAN, C ou autre)
NomCompilateur= xlf
 
# Options de compilation : ci-dessous, vous trouverez les options normalement
#                          utilisées pour compiler en FORTRAN.  Vous pouvez
#                          assigner d'autres valeurs que celles suggerées à la
#                          variables "OptionsDeCompilation".
#OptionsDeCompilation= -O3
# Enlever le caractère « # » ci-dessous pour activer la compilation en mode debug
#OptionsDeCompilation= -g
# Enlever le caractère « # » ci-dessous pour utiliser "gprof" qui indique le temps de
#    calcul de chaque sous-routine
#OptionsDeCompilation= -O3 -pg
 
# Liste des routines à compiler : on nomme ici les versions objet
# Placez un "\" a la fin de chaque ligne si vous voulez poursuivre la liste
#    des routines sur la ligne suivante.
FichiersObjets= trnb3-1.part.o mac4251.o inith.o dsite.o initv.o main.o \
                entree.o gcals.o defvar1.o defvar2.o magst.o mesure.o
 
# Nom du programme exécutable finalement produit
ProgrammeOut= trnb3-1.out
#=====  Fin de la définition des variables  =====
#===============  Il n'y a rien à changer à partir d'ici  ===============
 
 
# Définit une règle : comment construire un fichier objet (terminé par « .o »)
#                   à partir d'un fichier source (termine par « .f »)
# remarque : les symboles « $< » seront remplacés par le nom du programme à compiler
# Compilation de programmes en langage Fortran
.f.o:
	$(NomCompilateur) $(OptionsDeCompilation) -c $<
 
# Définit une règle : comment construire un fichier objet (terminé par « .o »)
#                   à partir d'un fichier source (terminé par « .c »)
# remarque : les symboles « $< » seront remplacés par le nom du programme à compiler
# Compilation de programmes en langage C
.c.o:
	$(NomCompilateur) $(OptionsDeCompilation) -c $<
 
# Définit une règle : comment construire un fichier objet (terminé par « .o »)
#                   à partir d'un fichier source (terminé par « .C »)
# remarque : les symboles « $< » seront remplacés par le nom du programme à compiler
# Compilation de programmes en langage C
.C.o:
	$(NomCompilateur) $(OptionsDeCompilation) -c $<
 
# Dépendance du programme exécutable envers les fichiers objets (« .o ») le
#    composant.
# La dépendance des fichiers objets envers les fichiers sources (« .f » et « .c ») est
#    sous-entendue par les règles définies plus haut.
$(ProgrammeOut): $(FichiersObjets)
	$(NomCompilateur) $(OptionsDeCompilation) -o $(ProgrammeOut) \
							$(FichiersObjets)


Outils personnels
Espaces de noms

Variantes
Actions
Navigation
Ressources de Calcul Québec
Outils
Partager