GNU make - Target with several recipes where only one recipe is needed

Question

Abstract description

I have the following situation in a Makefile:

target_1 target_2 :
    some_recipe_that_creates_both

target_1 :
    some_recipe_that_creates_only_target_1

Note that it is impossible to have a recipe that builds target_2 without target_1 efficiently. Therefore, if I already need to build target_2 I would like to avoid running the target_1-only recipe. Ideally this would mean make would work as follows:

• If someone tries to make target_1 without target_2, then use the second recipe from the makefile sample since it is faster.
• If someone tries to make target_1 and target_2, use the first recipe from the makefile sample since it is faster than running the recipe that creates both.

Is there a way that I can achieve this? I am aware of double-colon rules, bu they would run both recipes instead of only one of them.

Note that I need a solution that supports make with the -j parameter as well (but there is no recursive make).

The real scenario

The following text is here only for completeness sake and due to comments asking what the real scenario here is, it describes what target_1 and target_2 are:

I am compiling a shared library and executables that depend on it. If I finished compiling the shared library, I would like to make sure that the exe still sees all the symbols it needs in it. There are two ways to do it:

• Have the exe linking depend on the shared objects.
• Split exe linking into two steps (with empty marker files as the targets), exe linking, and missing symbol check (ldd -r). The problem is that exe linking already implies missing symbols check, so missing symbol check is essentially target_1, and linking is doing both target_1 and target_2).

Answer 1

It's a little bit of a hack but something like the following might work

ifneq ($(filter target_1,$(if $(filter target_2,$(MAKECMDGOALS)),,$(MAKECMDGOALS))),)
target_1 :
    some_recipe_that_creates_only_target_1
else
target_1 : target_2
endif

target_2 :
    some_recipe_that_creates_both

Answer 2

I really do not see behind that sample provided by you and there are chances I didn't catch the problem in all its details. But, it just feels like the break down work of the makefile designer is simply not finished.

In my understanding:

1. If you need to make target_1 only, there is an existing target target_1 in the makefile. So, you just use it.
2. If you need to make target_2 only, there is no such possibility. Why?
3. If you need to make both targets, you use a special recipe that is faster than building the entire target_1 plus the entire target_2, probably because target_2 builds redundantly a piece from target_1 (am I right?).

So, it feels like you need something like:

target12_common:
    common_piece_absolutely_needed_by_target1_and_by_target2

target2: target12_common
    some_recipe_that_creates_target2_only

target1: target12_common
    some_recipe_that_creates_target1_only

all: target1 target2

Is it feasible in your system?