Makefile, dépendances des en-têtes

Question

Disons que j'ai un makefile avec la règle suivante

%.o: %.c
 gcc -Wall -Iinclude ...

Je veux que *.o soit reconstruit à chaque fois qu'un fichier d'en-tête change. Plutôt que d'établir une liste de dépendances, chaque fois qu'un fichier d'en-tête dans le fichier /include change, alors tous les objets du répertoire doivent être reconstruits.

Je ne vois pas comment modifier la règle pour tenir compte de cette situation, mais je suis ouvert à toute suggestion. Des points bonus si la liste des en-têtes ne doit pas être codée en dur.

Answer 1

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

depend: .depend

.depend: $(SRCS)
        rm -f "$@"
        $(CC) $(CFLAGS) -MM $^ -MF "$@"

include .depend

ou

depend: .depend

.depend: $(SRCS)
        rm -f "$@"
        $(CC) $(CFLAGS) -MM $^ > "$@"

include .depend

où SRCS est une variable qui pointe vers la liste complète de vos fichiers sources.

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

Answer 2

La plupart des réponses sont étonnamment compliquées ou erronées. Cependant, des exemples simples et solides ont été postés ailleurs [ revue de code ]. Il est vrai que les options fournies par le préprocesseur gnu sont un peu confuses. Cependant, la suppression de tous les répertoires de la cible de construction avec -MM est documenté et n'est pas un bug [ gpp ] :

Par défaut, CPP prend le nom du fichier d'entrée principal, supprime tout composants de l'annuaire et tout suffixe de fichier tel que '.c', et ajoute le suffixe d'objet habituel de la le suffixe d'objet habituel de la plate-forme.

Le (un peu plus récent) -MMD est probablement ce que vous voulez. Pour être complet, voici un exemple de fichier makefile qui supporte plusieurs répertoires src et répertoires de compilation avec quelques commentaires. Pour une version simple sans répertoire de compilation, voir [ revue de code ].

CXX = clang++
CXX_FLAGS = -Wfatal-errors -Wall -Wextra -Wpedantic -Wconversion -Wshadow

# Final binary
BIN = mybin
# Put all auto generated stuff to this build dir.
BUILD_DIR = ./build

# List of all .cpp source files.
CPP = main.cpp $(wildcard dir1/*.cpp) $(wildcard dir2/*.cpp)

# All .o files go to build dir.
OBJ = $(CPP:%.cpp=$(BUILD_DIR)/%.o)
# Gcc/Clang will create these .d files containing dependencies.
DEP = $(OBJ:%.o=%.d)

# Default target named after the binary.
$(BIN) : $(BUILD_DIR)/$(BIN)

# Actual target of the binary - depends on all .o files.
$(BUILD_DIR)/$(BIN) : $(OBJ)
    # Create build directories - same structure as sources.
    mkdir -p $(@D)
    # Just link all the object files.
    $(CXX) $(CXX_FLAGS) $^ -o $@

# Include all .d files
-include $(DEP)

# Build target for every single object file.
# The potential dependency on header files is covered
# by calling `-include $(DEP)`.
$(BUILD_DIR)/%.o : %.cpp
    mkdir -p $(@D)
    # The -MMD flags additionaly creates a .d file with
    # the same name as the .o file.
    $(CXX) $(CXX_FLAGS) -MMD -c $< -o $@

.PHONY : clean
clean :
    # This should remove all generated files.
    -rm $(BUILD_DIR)/$(BIN) $(OBJ) $(DEP)

Cette méthode fonctionne car s'il existe plusieurs lignes de dépendance pour une seule cible, les dépendances sont simplement jointes, par ex :

a.o: a.h
a.o: a.c
    ./cmd

est équivalent à :

a.o: a.c a.h
    ./cmd

comme mentionné à : Makefile plusieurs lignes de dépendance pour une seule cible ?

Answer 3

Comme je l'ai posté aquí gcc peut créer des dépendances et compiler en même temps :

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

-include $(DEPS)

%.o: %.c
    $(CC) $(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 étant obj/_file__c.o, alors le fichier généré est le même que celui de l'option -o. fichier .d contiendra toujours fichier .o, pas obj/_file__c.o.

Answer 4

Pourquoi pas quelque chose comme :

includes = $(wildcard include/*.h)

%.o: %.c ${includes}
    gcc -Wall -Iinclude ...

Vous pouvez également utiliser directement les caractères génériques, mais j'ai tendance à en avoir besoin à plusieurs endroits.

Notez que cela ne fonctionne bien que pour les petits projets, car cela suppose que chaque fichier objet dépend de chaque fichier d'en-tête.

Answer 5

La solution de Martin ci-dessus fonctionne très bien, mais ne gère pas les fichiers .o qui se trouvent dans des sous-répertoires. Godric fait remarquer que l'option -MT résout ce problème, mais empêche simultanément le fichier .o d'être écrit correctement. Ce qui suit résoudra ces deux problèmes :

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

-include $(DEPS)

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