Makefile, le dipendenze di intestazione

Question

Diciamo che ho un makefile con la regola

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

voglio * .o per essere ricostruito ogni volta che un file di intestazione modifiche. Invece di elaborare un elenco di dipendenze, ogni volta che viene modificato un file di intestazione in /include, è necessario ricreare tutti gli oggetti nella directory.

Non riesco a pensare a un bel modo per cambiare la regola per accogliere questo, sono aperto ai suggerimenti. I punti di bonus se l'elenco delle intestazioni non devono essere hard-coded

Answer 1

Se si utilizza un compilatore GNU, il compilatore può assemblare un elenco di dipendenze per l'utente. frammento Makefile:

depend: .depend 

.depend: $(SRCS) 
     rm -f ./.depend 
     $(CC) $(CFLAGS) -MM $^ -MF ./.depend; 

include .depend 

o

depend: .depend 

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

include .depend 

dove SRCS è una punta variabile per l'intero elenco dei file di origine.

C'è anche lo strumento makedepend, ma mi è mai piaciuto tanto quanto gcc -MM

Answer 2

ne dite qualcosa di simile:

includes = $(wildcard include/*.h) 

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

Si potrebbe anche usare i caratteri jolly direttamente, ma io tendo a trovarli ho bisogno in più di un posto.

Si noti che questo funziona bene solo su piccoli progetti, dal momento che presuppone che ogni file oggetto dipende da ogni file di intestazione.

Answer 3

Come ho scritto here gcc può creare dipendenze e compilare al tempo stesso:

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

-include $(DEPS) 

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

Il '-MF 'parametro specifica un file per memorizzare le dipendenze in.

Il trattino all'inizio di "-include" indica a Make per continuare quando il file .d non esiste (ad esempio nella prima compilazione).

Nota sembra che ci sia un errore in gcc riguardo all'opzione -o. Se si imposta il nome file dell'oggetto per dire obj/_file__c.o, il file .d generato contiene file .o, non obj/_file__c.o.

Answer 4

Preferisco questa soluzione, oltre la risposta accettata da Michael Williamson, rileva le modifiche a sorgenti + file inline, quindi sorgenti + intestazioni e infine solo fonti. Il vantaggio è che l'intera libreria non viene ricompilata se vengono apportate solo alcune modifiche. Non è una considerazione enorme per un progetto con un paio di file, se si hanno 10 o 100 fonti, noterete la differenza.

COMMAND= gcc -Wall -Iinclude ... 

%.o: %.cpp %.inl 
    $(COMMAND) 

%.o: %.cpp %.hpp 
    $(COMMAND) 

%.o: %.cpp 
    $(COMMAND) 

Answer 5

Questo farà il lavoro bene, e anche gestire subdirs essere specificato:

$(CC) $(CFLAGS) -MD -o $@ $< 

provato con gcc 4.8.3

Answer 6

soluzione di Martin sopra grandi opere, ma non gestisce .o file che risiedono in sottodirectory.Godric sottolinea che il flag -MT si occupa di questo problema, ma impedisce al tempo stesso che il file .o venga scritto correttamente. Quanto segue si occuperà di entrambi questi problemi:

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

-include $(DEPS) 

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

Answer 7

La maggior parte delle risposte è sorprendentemente complicata o errata. Tuttavia, esempi semplici e robusti sono stati pubblicati altrove [codereview]. Ammetto che le opzioni fornite dal preprocessore di Gnu sono un po 'confuse. Tuttavia, la rimozione di tutte le directory dal bersaglio di compilazione con -MM è documentato e non un bug [gpp]:

Per impostazione predefinita CPP prende il nome del file di input principale, elimina tutte componenti di directory e qualsiasi suffisso di file come '.c' e aggiunge il suffisso dell'oggetto normale della piattaforma .

L'opzione (un po 'più recente) -MMD è probabilmente quello che desideri. Per completezza un esempio di makefile che supporta più dirs di src e crea dir con alcuni commenti. Per una versione semplice senza dirs di build vedi [codereview].

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) 

Questo metodo funziona perché se sono presenti più linee di dipendenza per un singolo bersaglio, le dipendenze vengono semplicemente uniti, ad esempio:

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

è equivalente a:

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

come menzionato a: Makefile multiple dependency lines for a single target?

Answer 8

Le seguenti opere per me:

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

-include $(DEPS) 

%.o: %.cpp 
    $(CXX) $(CFLAGS) -MMD -c -o $@ $< 

Answer 9

Ecco un due-liner:

CPPFLAGS = -MMD 
-include $(OBJS:.c=.d) 

Questo funziona con la ricetta di default marca, fino a quando si dispone di un elenco di tutti i file oggetto in OBJS.