Comment utiliser la commande de compilation du système Linux

La commande de compilation du système Linux est "Make". Dans les systèmes Linux, make est une commande de compilation très importante. Les administrateurs l'utilisent pour compiler et installer de nombreux outils open source via la ligne de commande. Les programmeurs l'utilisent pour gérer les problèmes de compilation de leurs projets volumineux et complexes. Make est utilisé pour automatiser la tâche de compilation de programmes volumineux. Il peut détecter automatiquement les parties du programme qui doivent être recompilées et émettre les instructions de compilation correspondantes.

Introduction à Make

make est un programme utilitaire pour les systèmes Linux. Il est utilisé pour gérer les tâches de compilation automatique des gros programmes, déterminer automatiquement quelle partie du programme doit être recompilée et envoyer des instructions de compilation. Cependant, nous l’utilisons le plus souvent dans la compilation de programmes en langage C. Cependant, make n'est pas limité à un langage spécifique. Make peut être utilisé dans n'importe quel langage pouvant exécuter le compilateur via une commande shell. De plus, vous pouvez même utiliser make pour décrire toute tâche de construction dans laquelle un fichier doit être automatiquement mis à jour après la modification des fichiers dont il dépend.

Comment Make Works

Pour ceux qui ne connaissent pas les mécanismes qui la sous-tendent, la commande Make accepte les cibles tout comme les arguments de ligne de commande. Généralement, ces opérations sont stockées dans un fichier spécial appelé « Makefile » et correspondent à la cible. Pour plus d'informations, lisez cette série d'articles sur le fonctionnement des Makefiles.

La première fois que la commande Make est exécutée, le Makefile est analysé pour les cibles et les dépendances correspondantes. Si ces dépendances doivent également être compilées dans la cible, continuez à analyser le Makefile et à établir leurs dépendances, puis compilez. Une fois la compilation des dépendances principales terminée, la cible principale est compilée (elle est saisie via la commande make).

Maintenant, en supposant que vous avez modifié un certain fichier source et que vous exécutez à nouveau la commande make, elle ne compilera que les fichiers cibles liés au fichier source. Par conséquent, la compilation du fichier exécutable final permet de gagner beaucoup de temps.

>Exemple de commande Make

Voici l'environnement de test utilisé dans cet article :

OS —— Ubunut 13.04
Shell —— Bash 4.2.45
Application —— GNU Make 3.81

Ce qui suit est le contenu du projet :

$ ls 
anotherTest.c Makefile test.c test.h

Ce qui suit est le contenu du Makefile :

all: test test: test.o anotherTest.o 
    gcc -Wall test.o anotherTest.o -o testtest.o: test.c 
    gcc -c -Wall test.c 

anotherTest.o: anotherTest.c 
    gcc -c -Wall anotherTest.c 

clean: 
    rm -rf *.o test

Maintenant regardons quelques commandes make sous Exemples d'applications Linux :

1. Un exemple simple

Pour compiler l'intégralité du projet, vous pouvez simplement utiliser make ou ajouter la cible allcode> après la commande make . <code>make 或者在 make 命令后带上目标 all。

$ make 
gcc -c -Wall test.c 
gcc -c -Wall anotherTest.c 
gcc -Wall test.o anotherTest.o -o test

你能看到 make 命令第一次创建的依赖以及实际的目标。

如果你再次查看目录内容，里面多了一些 .o 文件和执行文件：

$ ls 
anotherTest.c anotherTest.o Makefile test test.c test.h test.o

现在，假设你对 test.c 文件做了一些修改，重新使用 make 编译工程：

$ make 
gcc -c -Wall test.c 
gcc -Wall test.o anotherTest.o -o test

你可以看到只有 test.o 重新编译了，然而另一个 Test.o 没有重新编译。

现在清理所有的目标文件和可执行文件 test，你可以使用目标 clean:

$ make clean
rm -rf *.o test$ ls
anotherTest.c Makefile test.c test.h

你可以看到所有的 .o 文件和执行文件 test 都被删除了。

2. 通过 -B 选项让所有目标总是重新建立

到目前为止，你可能注意到 make 命令不会编译那些自从上次编译之后就没有更改的文件，但是，如果你想覆盖 make 这种默认的行为，你可以使用 -B 选项。

下面是个例子：

$ make
make: Nothing to be done for `all’.$ make -B
gcc -c -Wall test.c
gcc -c -Wall anotherTest.c
gcc -Wall test.o anotherTest.o -o test

你可以看到尽管 make 命令不会编译任何文件，然而 make -B 会强制编译所有的目标文件以及最终的执行文件。

3. 使用 -d 选项打印调试信息

如果你想知道 make 执行时实际做了什么，使用 -d 选项。

这是一个例子：

$ make -d | more
GNU Make 3.81
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.

This program built for x86_64-pc-linux-gnu
Reading makefiles…
Reading makefile `Makefile’…
Updating makefiles….
Considering target file `Makefile’.
Looking for an implicit rule for `Makefile’.
Trying pattern rule with stem `Makefile’.
Trying implicit prerequisite `Makefile.o’.
Trying pattern rule with stem `Makefile’.
Trying implicit prerequisite `Makefile.c’.
Trying pattern rule with stem `Makefile’.
Trying implicit prerequisite `Makefile.cc’.
Trying pattern rule with stem `Makefile’.
Trying implicit prerequisite `Makefile.C’.
Trying pattern rule with stem `Makefile’.
Trying implicit prerequisite `Makefile.cpp’.
Trying pattern rule with stem `Makefile’.
--More--

这是很长的输出，你也看到我使用了 more

$ ls 
file file2 frnd frnd1.cpp log1.txt log3.txt log5.txt
file1 file name with spaces frnd1 frnd.cpp log2.txt log4.txt

Vous pouvez voir les dépendances créées pour la première fois par la commande make et la cible réelle.

Si vous affichez à nouveau le contenu du répertoire, il contient d'autres fichiers .o et fichiers exécutables :

$ make -C ../make-dir/ 
make: Entering directory `/home/himanshu/practice/make-dir’ 
make: Nothing to be done for `all’. 
make: Leaving directory `/home/himanshu/practice/make-dir

Maintenant, en supposant que vous ayez apporté quelques modifications au fichier test.c et réutilisé make pour compiler le projet :

make -f my_makefile

Vous pouvez voir que seul test.o a été recompilé, mais l'autre Test.o n'a pas été recompilé.

Maintenant, pour nettoyer tous les fichiers objets et le test des fichiers exécutables, vous pouvez utiliser la cible clean:

rrreee

Vous pouvez voir que tous les fichiers .o et le test des fichiers exécutables ont été supprimés.

2. Faites en sorte que toutes les cibles soient toujours reconstruites avec l'option -B

À présent, vous avez peut-être remarqué que la commande make ne compile pas les fichiers qui n'ont pas changé depuis la dernière compilation, cependant, si vous le souhaitez. overwrite Pour ce comportement par défaut de make, vous pouvez utiliser l'option -B.

Voici un exemple :

rrreee

Vous pouvez voir que même si la commande make ne compilera aucun fichier, make -B forcera la compilation de tous les fichiers cibles et du fichier exécutable final. 🎜🎜🎜3. Utilisez l'option -d pour imprimer les informations de débogage 🎜🎜🎜 Si vous voulez savoir ce que make fait réellement lorsqu'il est exécuté, utilisez l'option -d. 🎜🎜Voici un exemple : 🎜rrreee🎜C'est une sortie très longue, vous avez également vu que j'ai utilisé la commande more pour afficher la sortie page par page. 🎜🎜🎜4. Utilisez l'option -C pour changer de répertoire 🎜🎜🎜Vous pouvez fournir un chemin de répertoire différent pour la commande make, et le répertoire sera changé avant de rechercher le Makefile. 🎜🎜Il s'agit d'un répertoire, en supposant que vous soyez dans le répertoire courant :🎜rrreee🎜Mais le Makefile de la commande make que vous souhaitez exécuter est enregistré dans le répertoire ../make-dir/, vous pouvez faire ceci :🎜rrreee🎜 Vous pouvez voir que la commande make bascule d'abord vers un répertoire spécifique, l'exécute là-bas, puis revient en arrière. 🎜🎜🎜5. Utilisez l'option -f pour traiter d'autres fichiers comme des Makefiles🎜🎜🎜Si vous souhaitez renommer le fichier Makefile, tel que my_makefile ou d'autres noms, et que nous voulons que make le traite comme un Makefile, vous pouvez utiliser - option f. 🎜rrreee🎜Avec cette méthode, la commande make choisira d'analyser my_makefile au lieu de Makefile. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!