Generar todas las dependencias del proyecto en un solo archivo usando gcc -MM flag

Question

Quiero generar un solo archivo de dependencia que conste de todas las dependencias de los archivos fuente utilizando gcc -M flags a través de Makefile. Busqué en Google esta solución, pero todas las soluciones mencionadas son para generar múltiples archivos deps para múltiples objetos.

DEPS = make.dep 

$(OBJS): $(SOURCES) 
    @$(CC) -MM $(SOURCEs) > $(DEPS) 
    @mv -f $(DEPS) $(DEPS).tmp 
    @sed -e 's|.$@:|$@:|' < $(DEPS).tmp > $(DEPS) 
    @sed -e 's/.*://' -e 's/\\$$//' < $(DEPS).tmp | fmt -1 | \ 
     sed -e 's/^ *//' -e 's/$$/:/' >> $(DEPS) 
    @rm -f $(DEPS).tmp 

Pero no funciona correctamente. Por favor dime dónde estoy cometiendo el error.

Answer 1

Algo a lo largo de estas líneas es lo que utilizo para conseguir todos mis dependencias en un solo archivo:

program_H_SRCS := $(wildcard *.h) 
program_C_SRCS := $(wildcard *.c) 
DEPS = make.deps 

make.deps: $(program_C_SRCS) $(program_H_SRCS) 
    $(CC) $(CPPFLAGS) -MM $(program_C_SRCS) > make.deps 

include $(DEPS) 

Básicamente, esto hace que todo el usuario (en comparación con el sistema) dependencias que ser reconstruido en un solo archivo cada vez cualquier archivo C o H en el proyecto se modifica.

+++++++++ EDITAR +++++++++++

Desde entonces, he encontrado una mejor forma de hacer las cosas. Genero un archivo dep separado para cada archivo fuente. Aquí está el archivo MAKE básica:

program_NAME := myprogram 
program_SRCS := $(wildcard *.c) 
program_OBJS := ${program_SRCS:.c=.o} 
clean_list += $(program_OBJS) $(program_NAME) 

# C Preprocessor Flags 
CPPFLAGS += 
# compiler flags 
CFLAGS += -ansi -Wall -Wextra -pedantic-errors 

.PHONY: all clean distclean 

all: $(program_NAME) 

clean: 
    @- $(RM) $(clean_list) 

distclean: clean 

# Generate dependencies for all files in project 
%.d: $(program_SRCS) 
    @ $(CC) $(CPPFLAGS) -MM $*.c | sed -e 's@^\(.*\)\.o:@\1.d \1.o:@' > $@ 

clean_list += ${program_SRCS:.c=.d} 

$(program_NAME): $(program_OBJS) 
    indent -linux -brf $(program_SRCS) 
    splint $(program_SRCS) 
    $(LINK.c) $(program_OBJS) -o $(program_NAME) 

ifneq "$(MAKECMDGOALS)" "clean" 
# Include the list of dependancies generated for each object file 
-include ${program_SRCS:.c=.d} 
endif 

Esto hace dos cosas:

1. Si alguno de los archivos que Foo.c dependen de cambio, entonces foo.o se reconstruye sin tener que reconstruir otros archivos en el proyecto.
2. El archivo dep en sí tiene las mismas dependencias que el archivo objeto, de modo que si alguna de las definiciones se modifica, el archivo dep también se regenera, antes de que se marquen los datos del archivo objeto.

Answer 2

Creo que es el comportamiento esperado para gcc -M, donde normalmente se haría algo como esto:

FOO_SOURCES= \ 
    src/foo.c \ 
    src/bar.c 

FOO_OBJECTS = $(FOO_SOURCES:.c=.o) 
FOO_DEPS = $(FOO_OBJECTS:.o=.d) 

(... un montón de objetivos ...)

-include $(FOO_DEPS) 

Nota, -include no include ya que las dependencias obviamente no existirán hasta que se haya ejecutado al menos una compilación. De todos modos, las dependencias se generan por módulos.

También tenga en cuenta que gcc -M no siempre funciona como usted esperaría que funcione, en términos generales según la versión de gcc que esté utilizando.

Creo que lo que quiere es algo llamado makedep, que hace lo que quiere sin sed hackery en el archivo MAKE.