Como gerar um Makefile com origem em subdiretórios usando apenas um makefile

Eu tenho fonte em um monte de subdiretórios como:

src/widgets/apple.cpp src/widgets/knob.cpp src/tests/blend.cpp src/ui/flash.cpp 

Na raiz do projeto, quero gerar um único Makefile usando uma regra como:

 %.o: %.cpp $(CC) -c $< build/test.exe: build/widgets/apple.o build/widgets/knob.o build/tests/blend.o src/ui/flash.o $(LD) build/widgets/apple.o .... build/ui/flash.o -o build/test.exe 

Quando eu tento isso, não há uma regra para build / widgets / apple.o. Posso alterar algo para que% .o:% .cpp seja usado quando precisar fazer build / widgets / apple.o?

A razão é que sua regra

 %.o: %.cpp ... 

espera que o arquivo .cpp resida no mesmo diretório que o .o do seu prédio. Como o test.exe no seu caso depende de build / widgets / apple.o (etc), make está esperando que apple.cpp seja build / widgets / apple.cpp.

Você pode usar o VPATH para resolver isso:

 VPATH = src/widgets BUILDDIR = build/widgets $(BUILDDIR)/%.o: %.cpp ... 

Ao tentar construir “build / widgets / apple.o”, make irá procurar por apple.cpp no VPATH . Observe que a regra de compilation tem que usar variables ​​especiais para acessar o nome do arquivo real.

 $(BUILDDIR)/%.o: %.cpp $(CC) $< -o $@ 

Onde "$ <" se expande para o caminho onde localiza a primeira dependência.

Observe também que isso criará todos os arquivos .o em build / widgets. Se você quiser construir os binários em diretórios diferentes, você pode fazer algo como

 build/widgets/%.o: %.cpp .... build/ui/%.o: %.cpp .... build/tests/%.o: %.cpp .... 

Eu recomendaria que você usasse " sequências de comandos enlatados " para evitar a repetição da regra de compilation do compilador:

 define cc-command $(CC) $(CFLAGS) $< -o $@ endef 

Você pode então ter várias regras como esta:

 build1/foo.o build1/bar.o: %.o: %.cpp $(cc-command) build2/frotz.o build2/fie.o: %.o: %.cpp $(cc-command) 

Isso faz o truque:

 CC := g++ LD := g++ MODULES := widgets test ui SRC_DIR := $(addprefix src/,$(MODULES)) BUILD_DIR := $(addprefix build/,$(MODULES)) SRC := $(foreach sdir,$(SRC_DIR),$(wildcard $(sdir)/*.cpp)) OBJ := $(patsubst src/%.cpp,build/%.o,$(SRC)) INCLUDES := $(addprefix -I,$(SRC_DIR)) vpath %.cpp $(SRC_DIR) define make-goal $1/%.o: %.cpp $(CC) $(INCLUDES) -c $$< -o $$@ endef .PHONY: all checkdirs clean all: checkdirs build/test.exe build/test.exe: $(OBJ) $(LD) $^ -o $@ checkdirs: $(BUILD_DIR) $(BUILD_DIR): @mkdir -p $@ clean: @rm -rf $(BUILD_DIR) $(foreach bdir,$(BUILD_DIR),$(eval $(call make-goal,$(bdir)))) 

Este Makefile assume que você tenha seus arquivos de inclusão nos diretórios de origem. Também verifica se os diretórios de construção existem e os cria, se eles não existirem.

A última linha é a mais importante. Ele cria as regras implícitas para cada build usando a function make-goal , e não é necessário escrevê-las uma por uma

Você também pode adicionar geração de dependência automática, usando o caminho de Tromey

A coisa é $@ includeá todo o caminho (relativo) para o arquivo de origem, que por sua vez é usado para construir o nome do object (e, portanto, seu caminho relativo)

Nós usamos:

 ##################### # rules to build the object files $(OBJDIR_1)/%.o: %.c @$(ECHO) "$< -> $@" @test -d $(OBJDIR_1) || mkdir -pm 775 $(OBJDIR_1) @test -d $(@D) || mkdir -pm 775 $(@D) @-$(RM) $@ $(CC) $(CFLAGS) $(CFLAGS_1) $(ALL_FLAGS) $(ALL_DEFINES) $(ALL_INCLUDEDIRS:%=-I%) -c $< -o $@ 

Isso cria um diretório de objects com o nome especificado em $(OBJDIR_1) e subdiretórios de acordo com os subdiretórios da origem.

Por exemplo (suponha objs como diretório de object de nível superior), no Makefile:

 widget/apple.cpp tests/blend.cpp 

resulta no seguinte diretório de objects:

 objs/widget/apple.o objs/tests/blend.o 

Isso será feito sem manipulação dolorosa ou várias sequências de comando:

 construir /%. o: src /%. cpp
 src /%. o: src /%. cpp
 % .o:
     $ (CC) -c $ <-o $ @

 build / test.exe: compilação / widgets / apple.o compilação / widgets / knob.o compilação / testes / blend.o src / ui / flash.o
     $ (LD) $ ^ -o $ @

JasperE explicou porque "% .o:% .cpp" não funciona; esta versão tem uma regra padrão (% .o 🙂 com comandos e sem pré-requisitos, e duas regras padrão (build /%. o: e src /%. o 🙂 com pré-requisitos e sem comandos. (Note que eu coloquei a regra src /% .o para lidar com src / ui / flash.o, assumindo que não era um erro de digitação para build / ui / flash.o, então se você não precisa, você pode deixe de fora.)

build / test.exe precisa construir / widgets / apple.o,
build / widgets / apple.o parece com build /%. o, então ele precisa de src /%. cpp (neste caso src / widgets / apple.cpp),
build / widgets / apple.o também se parece com% .o, então ele executa o comando CC e usa os pré-requisitos que encontrou (src / widgets / apple.cpp) para construir o alvo (build / widgets / apple.o)

Este é outro truque.

No principal ‘Makefile’ defina SRCDIR para cada diretório de origem e inclua ‘makef.mk’ para cada valor de SRCDIR. Em cada diretório de origem coloque o arquivo ‘files.mk’ com uma lista de arquivos de origem e opções de compilation para alguns deles. No principal ‘Makefile’ pode-se definir opções de compilation e excluir arquivos para cada valor de SRCDIR.

Makefile:

 PRG := prog-name OPTIMIZE := -O2 -fomit-frame-pointer CFLAGS += -finline-functions-called-once LDFLAGS += -Wl,--gc-section,--reduce-memory-overheads,--relax .DEFAULT_GOAL := hex OBJDIR := obj MK_DIRS := $(OBJDIR) SRCDIR := . include makef.mk SRCDIR := crc CFLAGS_crc := -DCRC8_BY_TABLE -DMODBUS_CRC_BY_TABLE ASFLAGS_crc := -DCRC8_BY_TABLE -DMODBUS_CRC_BY_TABLE include makef.mk ################################################################ CC := avr-gcc -mmcu=$(MCU_TARGET) -I. OBJCOPY := avr-objcopy OBJDUMP := avr-objdump C_FLAGS := $(CFLAGS) $(REGS) $(OPTIMIZE) CPP_FLAGS := $(CPPFLAGS) $(REGS) $(OPTIMIZE) AS_FLAGS := $(ASFLAGS) LD_FLAGS := $(LDFLAGS) -Wl,-Map,$(OBJDIR)/$(PRG).map C_OBJS := $(C_SRC:%.c=$(OBJDIR)/%.o) CPP_OBJS := $(CPP_SRC:%.cpp=$(OBJDIR)/%.o) AS_OBJS := $(AS_SRC:%.S=$(OBJDIR)/%.o) C_DEPS := $(C_OBJS:%=%.d) CPP_DEPS := $(CPP_OBJS:%=%.d) AS_DEPS := $(AS_OBJS:%=%.d) OBJS := $(C_OBJS) $(CPP_OBJS) $(AS_OBJS) DEPS := $(C_DEPS) $(CPP_DEPS) $(AS_DEPS) hex: $(PRG).hex lst: $(PRG).lst $(OBJDIR)/$(PRG).elf : $(OBJS) $(CC) $(C_FLAGS) $(LD_FLAGS) $^ -o $@ %.lst: $(OBJDIR)/%.elf -@rm $@ 2> /dev/nul $(OBJDUMP) -h -s -S $< > $@ %.hex: $(OBJDIR)/%.elf -@rm $@ 2> /dev/nul $(OBJCOPY) -j .text -j .data -O ihex $< $@ $(C_OBJS) : $(OBJDIR)/%.o : %.c Makefile $(CC) -MMD -MF $@.pd -c $(C_FLAGS) $(C_FLAGS_$(call clear_name,$<)) $< -o $@ @sed -e 's,.*:,SRC_FILES += ,g' < $@.pd > $@.d @sed -e "\$$s/$$/ $(subst /,\/,$(dir $<))files.mk\n/" < $@.pd >> $@.d @sed -e 's,^[^:]*: *,,' -e 's,^[ \t]*,,' -e 's, \\$$,,' -e 's,$$, :,' < $@.pd >> $@.d -@rm -f $@.pd $(CPP_OBJS) : $(OBJDIR)/%.o : %.cpp Makefile $(CC) -MMD -MF $@.pd -c $(CPP_FLAGS) $(CPP_FLAGS_$(call clear_name,$<)) $< -o $@ @sed -e 's,.*:,SRC_FILES += ,g' < $@.pd > $@.d @sed -e "\$$s/$$/ $(subst /,\/,$(dir $<))files.mk\n/" < $@.pd >> $@.d @sed -e 's,^[^:]*: *,,' -e 's,^[ \t]*,,' -e 's, \\$$,,' -e 's,$$, :,' < $@.pd >> $@.d -@rm -f $@.pd $(AS_OBJS) : $(OBJDIR)/%.o : %.S Makefile $(CC) -MMD -MF $@.pd -c $(AS_FLAGS) $(AS_FLAGS_$(call clear_name,$<)) $< -o $@ @sed -e 's,.*:,SRC_FILES += ,g' < $@.pd > $@.d @sed -e "\$$s/$$/ $(subst /,\/,$(dir $<))files.mk\n/" < $@.pd >> $@.d @sed -e 's,^[^:]*: *,,' -e 's,^[ \t]*,,' -e 's, \\$$,,' -e 's,$$, :,' < $@.pd >> $@.d -@rm -f $@.pd clean: -@rm -rf $(OBJDIR)/$(PRG).elf -@rm -rf $(PRG).lst $(OBJDIR)/$(PRG).map -@rm -rf $(PRG).hex $(PRG).bin $(PRG).srec -@rm -rf $(PRG)_eeprom.hex $(PRG)_eeprom.bin $(PRG)_eeprom.srec -@rm -rf $(MK_DIRS:%=%/*.o) $(MK_DIRS:%=%/*.od) -@rm -f tags cscope.out # -rm -rf $(OBJDIR)/* # -rm -rf $(OBJDIR) # -rm $(PRG) tag: tags tags: $(SRC_FILES) if [ -e tags ] ; then ctags -u $? ; else ctags $^ ; fi cscope -U -b $^ # include dep. files ifneq "$(MAKECMDGOALS)" "clean" -include $(DEPS) endif # Create directory $(shell mkdir $(MK_DIRS) 2>/dev/null) 

makef.mk

 SAVE_C_SRC := $(C_SRC) SAVE_CPP_SRC := $(CPP_SRC) SAVE_AS_SRC := $(AS_SRC) C_SRC := CPP_SRC := AS_SRC := include $(SRCDIR)/files.mk MK_DIRS += $(OBJDIR)/$(SRCDIR) clear_name = $(subst /,_,$(1)) define rename_var $(2)_$(call clear_name,$(SRCDIR))_$(call clear_name,$(1)) := \ $($(subst _,,$(2))_$(call clear_name,$(SRCDIR))) $($(call clear_name,$(1))) $(call clear_name,$(1)) := endef define proc_lang ORIGIN_SRC_FILES := $($(1)_SRC) ifneq ($(strip $($(1)_ONLY_FILES)),) $(1)_SRC := $(filter $($(1)_ONLY_FILES),$($(1)_SRC)) else ifneq ($(strip $(ONLY_FILES)),) $(1)_SRC := $(filter $(ONLY_FILES),$($(1)_SRC)) else $(1)_SRC := $(filter-out $(EXCLUDE_FILES),$($(1)_SRC)) endif endif $(1)_ONLY_FILES := $(foreach name,$($(1)_SRC),$(eval $(call rename_var,$(name),$(1)_FLAGS))) $(foreach name,$(ORIGIN_SRC_FILES),$(eval $(call clear_name,$(name)) :=)) endef $(foreach lang,C CPP AS, $(eval $(call proc_lang,$(lang)))) EXCLUDE_FILES := ONLY_FILES := SAVE_C_SRC += $(C_SRC:%=$(SRCDIR)/%) SAVE_CPP_SRC += $(CPP_SRC:%=$(SRCDIR)/%) SAVE_AS_SRC += $(AS_SRC:%=$(SRCDIR)/%) C_SRC := $(SAVE_C_SRC) CPP_SRC := $(SAVE_CPP_SRC) AS_SRC := $(SAVE_AS_SRC) 

./files.mk

 C_SRC := main.c CPP_SRC := AS_SRC := timer.S main.c += -DDEBUG 

./crc/files.mk

 C_SRC := byte-modbus-crc.c byte-crc8.c AS_SRC := modbus-crc.S crc8.S modbus-crc-table.S crc8-table.S byte-modbus-crc.c += --std=gnu99 byte-crc8.c += --std=gnu99 

Aqui está a minha solução, inspirada na resposta da Beta. É mais simples que as outras soluções propostas

Eu tenho um projeto com vários arquivos C, armazenados em muitos subdiretórios. Por exemplo:

 src/lib.c src/aa/a1.c src/aa/a2.c src/bb/b1.c src/cc/c1.c 

Aqui está o meu Makefile (no diretório src/ ):

 # make -> compile the shared library "libfoo.so" # make clean -> remove the library file and all object files (.o) # make all -> clean and compile SONAME = libfoo.so SRC = lib.c \ aa/a1.c \ aa/a2.c \ bb/b1.c \ cc/c1.c # compilation options CFLAGS = -O2 -g -W -Wall -Wno-unused-parameter -Wbad-function-cast -fPIC # linking options LDFLAGS = -shared -Wl,-soname,$(SONAME) # how to compile individual object files OBJS = $(SRC:.c=.o) .co: $(CC) $(CFLAGS) -c $< -o $@ .PHONY: all clean # library compilation $(SONAME): $(OBJS) $(SRC) $(CC) $(OBJS) $(LDFLAGS) -o $(SONAME) # cleaning rule clean: rm -f $(OBJS) $(SONAME) *~ # additional rule all: clean lib 

Este exemplo funciona bem para uma biblioteca compartilhada e deve ser muito fácil de adaptar para qualquer processo de compilation.

Normalmente, você cria um Makefile em cada subdiretório e escreve no Makefile de nível superior para chamar make nos subdiretórios.

Esta página pode ajudar: http://www.gnu.org/software/make/