Rebuild dependant target after a custom target runs - c++

Question

I have a CMake project that uses an external tool to build special libraries for a certain platform. Running this tool uses a "config file" to generate several files that are injected into the compiler and linker options when the final program is built:
An object library
A linker command file that links in several pre-compiled libs and the above object library
A makefile options file that sets various platform compiler options
whenever any of these files change, the main program must be entirely rebuilt, as they are intrinsic parts of the program and involve things like compiler flags and system includes.
So far, I have something like this, which appears to be a recommended way:
# run the external build tool to generate platform libs
# and compiler/linker option files
add_custom_command(
OUTPUT ${LINKER_CMD_FILE} ${COMPILER_OPTS_FILE} ${PLATFORM_OBJECT_LIB}
COMMAND "${EXTERNAL_BUILD_TOOL}"
ARGS --config ${CFG_FILE}
DEPENDS ${CFG_FILE}
COMMENT "Invoking external build tool for ${CFG_FILE}"
)
add_custom_target(platform_libs
DEPENDS ${LINKER_CMD_FILE} ${COMPILER_OPTS_FILE} ${PLATFORM_OBJECT_LIB}
)
....
add_executable(main_prog
main.c
)
# whenever any of these change, rebuild
add_dependencies(main_prog platform_libs)
# add the platform compiler opts from the generated file
target_compile_options(main_prog PRIVATE
#${COMPILER_OPTS_FILE}
)
This is also pretty much what is done in this question.
When I change the config file, the platform_libs target runs and generates the library and other files as needed. However, although running make main_prog does trigger the build of the platform_libs correctly, it does not appear to "notice" any changes and therefore concludes it doesn't need to actually re-build the main program.
I can always run make clean, but it's not great to have CMake totally blind to fundamental system libraries changing.
How can I force main_prog to rebuild if platform_libs has run?

Answer 1

[This answer's central method comes from #KamilCuk's answer in the comment of the question].
The trick is to use one of:
Set the LINK_DEPENDS property on the downstream target (main_prog in the example) - this means if the file in this property changes, a re-link will be performed.
Set the OBJECT_DEPENDS on every source used for main_prog.
In my case, because the ${COMPILER_OPTS_FILE} affects every file's compilation, I needed the OBJECT_DEPENDS method. If you do this you don't really need LINK_DEPENDS since you'll recompile your sources and re-link anyway, but I did both for clarity of meaning. In theory you could engineer a situation where the linker command file changes, but not the compiler opts, in which case you might miss a re-link.
In my case, I needed to do this for not only main_prog but also all the other libraries main_prog used, so I stored the linker command files and the compiler opts file as target properties on the platform_libs target:
set_property(TARGET platform_libs
PROPERTY MY_LINKER_CMD_FILE ${LINKER_CMD_FILE}
)
set_property(TARGET platform_libs
PROPERTY MY_COMPILER_OPTS_FILE ${COMPILER_OPTS_FILE}
)
This means it's easy to pull them out later, without having to know the exact file names (or even have access to the variables themselves):
# Retrieve the previously-stored options
# To do this, we only need the target name and the (fixed) property name
get_target_property(MY_LINKER_CMD platform_libs MY_LINKER_CMD_FILE)
get_target_property(MY_COMPILER_OPTS platform_libs MY_COMPILER_OPTS_FILE)
set_target_properties(main_prog PROPERTIES
LINK_DEPENDS ${MY_LINKER_CMD}
)
# Also set as the linker cmd on the linker command line
# This depends on the linker, for GCC it's -Wl,T<file>
target_link_libraries(main_prog PRIVATE
-Wl,-T${MY_LINKER_CMD}
)
# these are the sources that depend on the opts file
get_target_property(MAIN_SRCS main_prog SOURCES)
# set the dependency of source files on platform_libs
set_property(SOURCE ${MAIN_SRCS}
PROPERTY OBJECT_DEPENDS ${MY_COMPILER_OPTS}
)
# Set as a compiler opt file
# For GCC: #<opt_file>
target_compile_options(${TARGET_TO_COMPILE} PRIVATE
#${MY_COMPILER_OPTS}
)
# make sure the platform_libs is a dep
# or the compiler opts and linker files won't be generated
add_dependencies(main_prog platform_libs)
Notably, in this Cmake code, the project names main_prog and platform_libs can be variables, and then you can make the whole thing into a function that just needs those two project names. This makes it easy to reuse the code for compiling libraries against platform_libs library.