Makefile中的“可选”对象文件目标？

Question

I have some code that is "optional": the rest of the program can be linked without it.
How do I properly create a Makefile that excludes it as a dependency if there is an error when creating the object file?

So far I have something like this:

OUT=my_program
OBJS=$(subst .cc,.o,$(wildcard *.cc))

all: $(OUT)
$(OUT): $(OBJS)

my_optional_file.o: other_target

.IGNORE: my_optional_file.o

The good: When processing the rule my_optional_file.o , this correctly ignores all errors.

The bad: When linking the output, my_optional_file.o is specified as an argument to the linker despite the fact that it was not built, making the linker fail because it was given a nonexistent file as input!

How do I exclude my_optional_file.o when there is an error in building it?

Answer 1

Use $(shell find . -maxdepth 1 -iname "*.o") with an explicit call to the linker.

Like :

$(OUT): $(OBJS)
    $(CXX) $(LDFLAGS) $(shell find . -maxdepth 1 -iname "*.o") $(LDLIBS) -o $@

The reason is that when implicitly called, the linker command is called like this :

$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH) $^ $(LOADLIBES) $(LDLIBS) -o $@

With $^ expanding to the content of $(OBJS) . You need an explicit call to use specific files instead.

---

The $(wildcard *.o) function cannot be used because it is executed before the files are created so it is always empty.

Answer 2

Assuming your make is GNU make , here is one way of doing this.

Say my program prog has three source files main.c , necessary.c , optional.c such that I want to link prog from all three .o files, if they get built ( = a maximal build ), but I will settle for main.o and necessary.o ( = a minimal build ). (I waive the rationale for this).

A makefile to the purpose is:

.phony: all clean make_prog

max_objs=$(subst .c,.o,$(wildcard *.c))

all: make_prog

make_prog: $(max_objs)
    $(MAKE) prog

prog: $(wildcard *.o)
    gcc -o $@ $^

clean:
    rm -f prog *.o

.IGNORE: optional.o 

To make prog I first make the phony target, make_prog , whose prerequisites are all three .o files, but I ignore failure to make optional.o . Then I make prog for real, and to do that I just link whatever .o files I've got at this point. If optional.o isn't there, it doesn't matter.

To be clear about the behaviour of this:-

• If, initially, I have a maximal build of prog , then make a change that breaks optional.c and re-make, no .o is re-made, so prog is not re-made. It stays maximal.

• If, initially, I have a minimal build of prog , then make a change that fixes optional.c and re-make, optional.o is re-made, so prog is re-made. It becomes maximal.

Failure to make optional.o excludes prog 's dependency on it and introduces no new ones. So if all other dependencies are satisfied, there's no need to remake prog .

Now it might be the case that you actually want failure to make optional.o to introduce a dependency on the failure to make optional.o , in the sense that it would force prog to be rebuilt minimally .

A simple way to achieve that is by adding the line:

.INTERMEDIATE: optional.o

to the makefile, which will force optional.o always to be deleted at the end of a make. This has the cost that optional.c will always be compiled, and consequently a maximal build will always be re-linked.

Lastly, someone might wonder why the makefile couldn't more simply be:

.phony: all clean

objs=$(subst .c,.o,$(wildcard *.c))

all: prog

prog: $(objs)
    gcc -o $@ $(wildcard *.o)

clean:
    rm -f prog *.o

.IGNORE: optional.o

Well if we do a make from clean with that, the output is:

cc    -c -o main.o main.c
cc    -c -o necessary.o necessary.c
cc    -c -o optional.o optional.c
gcc -o prog 
gcc: fatal error: no input files
compilation terminated.
make: *** [prog] Error 4

That's because $(wildcard *.o) is expanded when the makefile is parsed, and at that point no .o files exist. We need to be parsing the makefile again when we expand this, having already made all the .o files we can.

Answer 3

GNU make does not have optional dependencies. You can simulate that by not returning failure when it fails to build and filtering out non-existent objects when linking.