Compréhension simple de Makefile 1
Il existe de nombreux articles sur l'apprentissage Makefile sur Internet, et chaque article a ses propres caractéristiques. Rien que pour moi, j'ai toujours le sentiment que certains problèmes ne sont pas clairs. Maintenant, je veux analyser dans une perspective de base zéro et apprendre Makefile avec tout le monde.
Dans l'ensemble, c'est pour simplifier des problématiques complexes!
[Introduction aux fonctions] MakeFile peut être considéré comme un simple langage de programmation, le but essentiel de sa naissance est de réaliser une compilation automatique.
En prenant le compilateur gcc-c sous Linux comme exemple, la compilation d'un programme en langage C nécessite les étapes suivantes:
1. Pré-traitement pour générer des fichiers pré-compilés (fichiers .i):
gcc -E hello.c -o hello.i
2. Compilation pour générer du code d'assemblage (fichiers .s ):
gcc -S hello.i -o bonjour .s
3. Assemblage (Assemblage), générer un fichier objet (fichier .o):
gcc -c bonjour.s -o bonjour.o
4. Lien (Lien), générer un fichier exécutable:
gcc bonjour. o –o bonjour
Si vous voulez terminer tout le processus en une seule étape:
gcc hello.c -o bonjour
[Compilation et liaison]
Pour obtenir le programme exécutable final, vous devez d'abord compiler le fichier source dans un fichier de code intermédiaire, qui est un fichier .obj sous Windows, et un fichier .o sous UNIX \ Linux, à savoir Object File, compiler ( compiler). Combinez ensuite un grand nombre de fichiers objets dans des fichiers exécutables et liez-les.
Lors de la compilation, le compilateur a besoin d'une syntaxe correcte et d'une déclaration correcte des fonctions et des variables. Pour ce dernier, vous devez généralement indiquer au compilateur où se trouvent les fichiers d'en-tête. Tant que toute la syntaxe est correcte, le compilateur peut compiler des fichiers objets intermédiaires. De manière générale, chaque fichier source doit correspondre à un fichier cible intermédiaire (fichier O ou fichier OBJ).
[Méthode de travail]
Fichier Makefile .C -> fichier .o -> fichier exécutable
Si vous souhaitez spécifier un Makefile spécifique, vous pouvez utiliser les paramètres "-f" et "-file" de make, tels que: make -f Makefile ou make --file Makefile
[Exemple d'introduction] MakeFile du programme Hello
TOPDIR = ../
include $(TOPDIR)Rules.mak
EXTRA_LIBS +=
EXEC = $(INSTALL_DIR)/hello
OBJS = hello.o
all: $(EXEC)
$(EXEC): $(OBJS)
$(CC) $(LDFLAGS) -o $@ $(OBJS) $(EXTRA_LIBS)
install:
$(EXP_INSTALL) $(EXEC) $(INSTALL_DIR)
clean:
-rm -f $(EXEC) *.elf *.gdb *.o
[Explication]
CC spécifie la macro du compilateur
EXEC représente la macro du nom de fichier exécutable généré
Macro de liste de fichiers objets OBJS
Macro de paramètre de connexion LDFLAGS
Tout: compilez l'entrée principale
Nettoyer: effacez les résultats de la compilation
Installer: installez le fichier exécutable compilé avec succès dans le répertoire système, généralement le répertoire / usr / local / bin
[Règles Makefile]
Il y a principalement cinq choses dans le Makefile:
des règles explicites, des règles
implicites,
des définitions de variables,
des instructions de fichier, des
commentaires
1. Règles explicites.
Des règles explicites expliquent comment générer un ou plusieurs fichiers objets. Ceci est clairement indiqué par le rédacteur du Makefile, les fichiers à générer, les fichiers dépendants des fichiers et les commandes générées.
Tels que: foo.o: foo.c defs.h relation de dépendance
gcc -o foo.o foo.c La méthode (méthode) de génération de la cible
2. Règles implicites.
Puisque notre make a la fonction de dérivation automatique, les règles obscures nous permettent d'écrire Makefile de manière plus crue et concise, ce qui est supporté par make.
Tels que: foo.o: foo.c (Le fichier .o lui-même dérive le fichier dépendant avec le même nom.c.)
3. La définition des variables.
Dans le Makefile, nous devons définir une série de variables. Les variables sont généralement des chaînes. C'est un peu comme une macro dans le langage C. Lorsque le Makefile est exécuté, les variables qu'il contient seront développées aux positions de référence correspondantes.
Tels que: H: = foo.c gcc -o foo.o $ (H) (L'affectation peut utiliser: = ou directement =)
4. Instructions de fichier.
Il comprend trois parties, l'une est de référencer un autre Makefile dans un Makefile, tout comme l'inclusion en langage C; l'autre est de spécifier la partie effective du Makefile selon certaines circonstances, tout comme la précompilation en langage C # si c'est la même chose ; une autre consiste à définir une commande multiligne.
5. Remarques.
Il n'y a que des commentaires de ligne dans le Makefile, qui est identique au script UNIX Shell. Les commentaires utilisent le caractère "#", qui est juste comme le "//" en C / C ++ et Java.
Les commandes du Makefile doivent commencer par la touche [Tab].