如何只重新编译makefile中的更改并自动查找.cpp文件？

Question

I wrote the following makefile, which successfully compiles all the .cpp in the current folder into a static library. The clean_library target is used because if I try to compile and there is already the .a file, the compilation stops with the following error:

ar: libbackend.a is a fat file (use libtool(1) or lipo(1) and ar(1) on it)
ar: libbackend.a: Inappropriate file type or format
make: *** [libbackend] Error 1

I would like to speed up the compilation compiling only those .cpp which change. Currently all the .o files are recreated each time. I can achieve this removing the -arch part and removing the dependency clean_library .

How can I achieve the same behaviour without that?

A workaround is to create a target which builds for a single architecture and call the target which build for all the architectures only when needed/when the work is finished.

CC = g++
FLAGS = -g -std=c++14 -Wall -Wextra -O0 #debug
# FLAGS = -std=c++14 -Ofast # release

SRCS = $(wildcard *.cpp)
OBJS = $(SRCS:.cpp=.o)
OUT = my_library

$(OUT): $(OBJS)
    ar rcs $(OUT).a $^
# libtool -static -o $(OUT).a $^ #other possibilty

%.o: %.cpp Makefile #clean_library
    $(CC) $(FLAGS) -c $< -o $@ -arch x86_64 -arch i386

.PHONY: clean clean_library

clean: clean_library
    rm -rf *.o

clean_library:
    rm -rf $(OUT).a

Answer 1

Your question is not very clear about what you want to do. Is your goal to compile the same code multiple times in different ways?

You cannot have exactly the same targets compiled different ways, and still only have the modified files updated: make cannot know which way a pre-existing object file was compiled. When make starts up and sees a foo.o file, was it compiled for debug? Release? There's no way to know, so this can't work. You have to recompile everything to be sure.

What people do to work around this is name the output from the different types of compilation differently. The most common way to do this is to use a subdirectory: put all the files compiled for debug in the debug subdirectory and all the files compiled for release in the release subdirectory. So your makefile would look something like this:

CC = g++
debug_FLAGS = -g -std=c++14 -Wall -Wextra -O0
release_FLAGS = -std=c++14 -Ofast

SRCS := $(wildcard *.cpp)
OBJS := $(SRCS:.cpp=.o)
OUT := my_library.a

all: debug/$(OUT) release/$(OUT)

%/$(OUT):
        ar rcs $@ $^
# libtool -static -o $@ $^ #other possibilty

debug/$(OUT): $(addprefix debug/,$(OBJS))

debug/%.o: %.cpp Makefile | debug
        $(CC) $(debug_FLAGS) -c $< -o $@ -arch x86_64 -arch i386

release/$(OUT): $(addprefix release/,$(OBJS))

release/%.o: %.cpp Makefile | release
        $(CC) $(release_FLAGS) -c $< -o $@ -arch x86_64 -arch i386

debug release:
        mkdir -p $@

clean:
        rm -rf debug release

.PHONY: debug release clean

If you want to have lots of different options it might be worthwhile to get even more fancy but for just two you probably don't need to go to the extra effort.