Makefile, dependências de cabeçalho

Digamos que eu tenha um makefile com a regra

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

Quero que * .o seja reconstruído sempre que um arquivo de cabeçalho for alterado. Em vez de elaborar uma lista de dependências, sempre que qualquer arquivo de cabeçalho for /includealterado, todos os objetos no diretório devem ser reconstruídos.

Não consigo pensar em uma maneira legal de mudar a regra para acomodar isso, estou aberto a sugestões. Pontos de bônus se a lista de cabeçalhos não precisar ser codificada

Se você estiver usando um compilador GNU, o compilador pode montar uma lista de dependências para você. Fragmento de Makefile:

depend: .depend

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

include .depend

ou

depend: .depend

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

include .depend

onde SRCSé uma variável apontando para sua lista inteira de arquivos de origem.

Existe também a ferramenta makedepend, mas nunca gostei tanto quantogcc -MM

A maioria das respostas é surpreendentemente complicada ou errônea. No entanto, exemplos simples e robustos foram postados em outro lugar [ codereview ]. É certo que as opções fornecidas pelo pré-processador GNU são um pouco confusas. No entanto, a remoção de todos os diretórios do destino de construção com -MMestá documentada e não é um bug [ gpp ]:

Por padrão, o CPP recebe o nome do arquivo de entrada principal, exclui quaisquer componentes do diretório e qualquer sufixo de arquivo, como '.c', e anexa o sufixo de objeto usual da plataforma.

A opção (um pouco mais recente) -MMDé provavelmente o que você deseja. Para completar, um exemplo de um makefile que suporta vários diretórios src e diretórios de construção com alguns comentários. Para uma versão simples sem diretórios de compilação, consulte [ 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)

Este método funciona porque se houver várias linhas de dependência para um único destino, as dependências serão simplesmente unidas, por exemplo:

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

é equivalente a:

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

conforme mencionado em: Makefile várias linhas de dependência para um único destino?

Como postei aqui, o gcc pode criar dependências e compilar ao mesmo tempo:

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

-include $(DEPS)

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

O parâmetro '-MF' especifica um arquivo para armazenar as dependências.

O traço no início de '-include' diz ao Make para continuar quando o arquivo .d não existir (por exemplo, na primeira compilação).

Observe que parece haver um bug no gcc em relação à opção -o. Se você definir o nome do arquivo do objeto como obj / _file__c.o, o arquivo .d gerado ainda conterá o arquivo .o, não obj / _file__c.o.

Que tal algo como:

includes = $(wildcard include/*.h)

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

Você também pode usar os curingas diretamente, mas tendo a descobrir que preciso deles em mais de um lugar.

Observe que isso só funciona bem em projetos pequenos, uma vez que assume que todo arquivo de objeto depende de todo arquivo de cabeçalho.

A solução de Martin acima funciona muito bem, mas não lida com arquivos .o que residem em subdiretórios. Godric aponta que o sinalizador -MT cuida desse problema, mas simultaneamente impede que o arquivo .o seja escrito corretamente. O seguinte cuidará de ambos os problemas:

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

-include $(DEPS)

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

Isso fará o trabalho muito bem e até mesmo manipulará subdiretórios sendo especificados:

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

testei com gcc 4.8.3

Aqui está uma linha dupla:

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

Isso funciona com a receita padrão do make, contanto que você tenha uma lista de todos os seus arquivos de objeto em OBJS.

Eu prefiro esta solução, em vez da resposta aceita por Michael Williamson, ela captura as alterações em fontes + arquivos embutidos, em seguida, fontes + cabeçalhos e, finalmente, apenas fontes. A vantagem aqui é que a biblioteca inteira não é recompilada se apenas algumas mudanças forem feitas. Não é uma grande consideração para um projeto com alguns arquivos, mas se você tiver 10 ou 100 fontes, notará a diferença.

COMMAND= gcc -Wall -Iinclude ...

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

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

%.o: %.cpp
    $(COMMAND)

O seguinte funciona para mim:

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

-include $(DEPS)

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

Uma versão ligeiramente modificada da resposta de Sophie que permite enviar os arquivos * .d para uma pasta diferente (vou colar apenas a parte interessante que gera os arquivos de dependência):

$(OBJDIR)/%.o: %.cpp
# Generate dependency file
    mkdir -p $(@D:$(OBJDIR)%=$(DEPDIR)%)
    $(CXX) $(CXXFLAGS) $(CPPFLAGS) -MM -MT $@ $< -MF $(@:$(OBJDIR)/%.o=$(DEPDIR)/%.d)
# Generate object file
    mkdir -p $(@D)
    $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< -o $@

Observe que o parâmetro

-MT $@

é usado para garantir que os destinos (ou seja, os nomes dos arquivos de objeto) nos arquivos * .d gerados contenham o caminho completo para os arquivos * .o e não apenas o nome do arquivo.

Não sei por que este parâmetro NÃO é necessário ao usar -MMD em combinação com -c (como na versão de Sophie ). Nesta combinação, parece gravar o caminho completo dos arquivos * .o nos arquivos * .d. Sem essa combinação, -MMD também grava apenas os nomes de arquivo puros sem quaisquer componentes de diretório nos arquivos * .d. Talvez alguém saiba por que -MMD grava o caminho completo quando combinado com -c. Não encontrei nenhuma dica na página de manual do g ++.