Comment puis-je faire en sorte qu'un Makefile reconstruise automatiquement les fichiers sources qui incluent un fichier d'en-tête modifié ? (En C/C++)

Question

J'ai le makefile suivant que j'utilise pour construire un programme (un noyau, en fait) sur lequel je travaille. C'est à partir de zéro et j'apprends le processus, donc ce n'est pas parfait, mais je pense que c'est assez puissant à ce stade pour mon niveau d'expérience dans l'écriture de makefiles.

AS  =   nasm
CC  =   gcc
LD  =   ld

TARGET      =   core
BUILD       =   build
SOURCES     =   source
INCLUDE     =   include
ASM         =   assembly

VPATH = $(SOURCES)

CFLAGS  =   -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions \
            -nostdinc -fno-builtin -I $(INCLUDE)
ASFLAGS =   -f elf

#CFILES     =   core.c consoleio.c system.c
CFILES      =   $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
SFILES      =   assembly/start.asm

SOBJS   =   $(SFILES:.asm=.o)
COBJS   =   $(CFILES:.c=.o)
OBJS    =   $(SOBJS) $(COBJS)

build : $(TARGET).img

$(TARGET).img : $(TARGET).elf
    c:/python26/python.exe concat.py stage1 stage2 pad.bin core.elf floppy.img

$(TARGET).elf : $(OBJS)
    $(LD) -T link.ld -o $@ $^

$(SOBJS) : $(SFILES)
    $(AS) $(ASFLAGS) $< -o $@

%.o: %.c
    @echo Compiling $<...
    $(CC) $(CFLAGS) -c -o $@ $<

#Clean Script - Should clear out all .o files everywhere and all that.
clean:
    -del *.img
    -del *.o
    -del assembly\*.o
    -del core.elf

Mon principal problème avec ce makefile est que lorsque je modifie un fichier d'en-tête qu'un ou plusieurs fichiers C incluent, les fichiers C ne sont pas reconstruits. Je peux résoudre ce problème assez facilement en faisant en sorte que tous mes fichiers d'en-tête soient des dépendances pour tous mes fichiers C, mais cela entraînerait effectivement une reconstruction complète du projet à chaque fois que je modifie/ajoute un fichier d'en-tête, ce qui ne serait pas très gracieux.

Ce que je veux, c'est que seulement les fichiers C que inclure le fichier d'en-tête que je modifie doit être reconstruit, et le projet entier doit être lié à nouveau. Je peux effectuer la liaison en faisant en sorte que tous les fichiers d'en-tête soient des dépendances de la cible, mais je n'arrive pas à trouver comment faire en sorte que les fichiers C soient invalidés lorsque les fichiers d'en-tête inclus sont plus récents.

J'ai entendu dire que GCC avait des commandes pour rendre cela possible (de sorte que le makefile puisse d'une manière ou d'une autre déterminer quels fichiers doivent être reconstruits) mais je n'arrive pas à trouver un exemple d'implémentation réelle à regarder. Quelqu'un peut-il poster une solution permettant d'activer ce comportement dans un fichier makefile ?

EDIT : Je devrais clarifier, je suis familier avec le concept de mettre les cibles individuelles et d'avoir chaque cible.o nécessitant les fichiers d'en-tête. Cela m'oblige à modifier le makefile à chaque fois que j'inclus un fichier d'en-tête quelque part, ce qui est un peu pénible. Je cherche une solution qui puisse dériver les dépendances des fichiers d'en-tête par elle-même, ce que je suis pratiquement certain d'avoir vu dans d'autres projets.

Answer 1

Comme déjà signalé ailleurs sur ce site, voir cette page : Génération automatique de dépendances

En bref, gcc peut créer automatiquement des fichiers de dépendance .d pour vous, qui sont des mini-fragments de makefile contenant les dépendances du fichier .c que vous avez compilé. Chaque fois que vous modifiez le fichier .c et le compilez, le fichier .d sera mis à jour.

En plus d'ajouter le drapeau -M à gcc, vous devrez inclure les fichiers .d dans le makefile (comme Chris l'a écrit ci-dessus). Il y a quelques problèmes plus compliqués dans la page qui sont résolus en utilisant sed, mais vous pouvez les ignorer et faire un "make clean" pour effacer les fichiers .d chaque fois que make se plaint de ne pas pouvoir construire un fichier d'en-tête qui n'existe plus.

Answer 2

Vous pourriez ajouter une commande 'make depend' comme d'autres l'ont dit, mais pourquoi ne pas demander à gcc de créer les dépendances et de compiler en même temps ?

DEPS := $(COBJS:.o=.d)

-include $(DEPS)

%.o: %.c
    $(CC) -c $(CFLAGS) -MM -MF $(patsubst %.o,%.d,$@) -o $@ $<

Le paramètre '-MF' spécifie un fichier dans lequel stocker les dépendances.

Le tiret au début de '-include' indique à Make de continuer lorsque le fichier .d n'existe pas (par exemple, lors de la première compilation).

Notez qu'il semble y avoir un bogue dans gcc concernant l'option -o. Si vous définissez le nom de fichier de l'objet comme suit obj/_file__c.o alors le produit _file_.d contiendra toujours _file_.o pas obj/_file_c.o .

Answer 3

Ceci est équivalent à Réponse de Chris Dodd mais utilise une convention d'appellation différente (et, par coïncidence, ne nécessite pas l'ajout de la balise sed magique. Copié de un duplicata ultérieur .

---

Si vous utilisez un compilateur GNU, le compilateur peut assembler une liste de dépendances pour vous. Fragment de Makefile :

depend: .depend

.depend: $(SOURCES)
        rm -f ./.depend
        $(CC) $(CFLAGS) -MM $^>>./.depend;

include .depend

Il existe également l'outil makedepend mais je ne l'ai jamais autant aimé que gcc -MM

Answer 4

Vous devrez créer des cibles individuelles pour chaque fichier C, puis lister le fichier d'en-tête comme une dépendance. Vous pouvez toujours utiliser vos cibles génériques, en plaçant simplement la balise .h dépendances après, comme ceci :

%.o: %.c
        @echo Compiling $<...
        $(CC) $(CFLAGS) -c -o $@ $<

foo.c: bar.h
# And so on...

Answer 5

En plus de ce que @mipadi a dit, vous pouvez également explorer l'utilisation de l'élément ' -M L'option ' pour générer un enregistrement des dépendances. Vous pouvez même les générer dans un fichier séparé (peut-être 'depend.mk') que vous incluez ensuite dans le makefile. Ou vous pouvez trouver une option ' make depend qui édite le makefile avec les dépendances correctes (termes Google : "ne pas supprimer cette ligne" et dépendance).