Have CMake rebuild custom targets when transitive dependency outdated - cmake

Question

I have a multi-directory CMake project where I generate two files b and c. Then I have an executable d_target that needs c.
File b depends on some configuration file a
File c depends on file b
Executable target d_target needs c, it's a generated header file.
I added two add_custom_command() calls to generate the files and added dependencies.
Then, I added two add_custom_target() calls to make the targets available throughout the multi-directory project.
file a > file b > b_target > file c > c_target > d_target
The first time that I build c_target, all dependencies are built and the file c is equal to b and b equal to a.
Now, when I change the 'configuration' a and build d_target, d_target is not rebuilt.
How can I have CMake rebuild targets when any of their dependencies change?
cmake_minimum_required(VERSION 3.15)
project(abcd)
# ./b/CMakeLists.txt
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/b
COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/a > ${CMAKE_CURRENT_BINARY_DIR}/b
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/a)
add_custom_target(b_target DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/b)
# ./c/CMakeLists.txt
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/c
COMMAND cat ${CMAKE_CURRENT_BINARY_DIR}/b > ${CMAKE_CURRENT_BINARY_DIR}/c
DEPENDS b_target ${CMAKE_CURRENT_BINARY_DIR}/b)
add_custom_target(c_target DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/c)
# ./d/CMakeLists.txt
add_executable(d_target ${CMAKE_CURRENT_SOURCE_DIR}/d.cpp)
add_dependencies(d_target c_target)
# will not generate:
# add_dependencies(d_target c_target ${CMAKE_CURRENT_BINARY_DIR}/c)
In my specific situation, the commands for b and c and d are in CMakeLists.txt in their respective subdirectories.
Demonstration:
$ make d_target
[ 20%] Generating b
[ 20%] Built target b_target
[ 40%] Generating c
[ 60%] Built target c_target
[ 80%] Building CXX object CMakeFiles/d_target.dir/d.cpp.o
[100%] Linking CXX executable d_target
[100%] Built target d_target
$ touch ../a
$ make d_target
[ 20%] Generating b
[ 20%] Built target b_target
[ 40%] Generating c
[ 60%] Built target c_target
[100%] Built target d_target
When I try to add the c file to add_dependencies(d_target ...), CMake fails:
CMake Error at CMakeLists.txt:21 (add_dependencies):
The dependency target "/home/tom/tmp/abcd/build/c" of target
"d_target" does not exist.

Answer 1

Below is a solution with explanatory comments in the c/CMakeLists.txt snippet.
You can change the value to SOME_DEFINE inside of b/a and re-build to see it update.
root CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(abcd)
add_subdirectory(b)
add_subdirectory(c)
add_subdirectory(d)
b/a
#define SOME_DEFINE 4
b/CMakeLists.txt
set(B_INPUT "${CMAKE_CURRENT_SOURCE_DIR}/a")
set(B_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/b")
add_custom_command(
OUTPUT ${B_OUTPUT}
COMMAND ${CMAKE_COMMAND} -E copy ${B_INPUT} ${B_OUTPUT}
DEPENDS ${B_INPUT}
)
add_custom_target(b_target DEPENDS ${B_OUTPUT})
c/CMakeLists.txt
get_target_property(B_OUTPUT_DIR b_target BINARY_DIR)
set(C_INPUT "${B_OUTPUT_DIR}/b")
set(C_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/c")
add_custom_command(
OUTPUT ${C_OUTPUT}
COMMAND ${CMAKE_COMMAND} -E copy ${C_INPUT} ${C_OUTPUT}
DEPENDS ${C_INPUT}
)
# Using "_c_target" as a local target and intending the non underscore prefix
# for use outside this CMakeLists.txt file
add_custom_target(_c_target DEPENDS ${C_OUTPUT})
# This forces `b_target` to be built prior to `_c_target`. Since the custom
# command to build `C_INPUT` is in a different CMakeLists, CMake doesn't
# understand that `C_INPUT` is created by a custom command and thus doesn't know
# to generate it.
# This is only needed because the custom command for `C_INPUT` is in another
# file. If the custom command was here, in this file, CMake would implicitly
# hook up the dependency for us through the custom commands and we wouldn't need
# `b_target`.
add_dependencies(_c_target b_target)
# Since `C_OUTPUT` is a header file, we create a header only library that the
# executable can link to. This header only library provides the include
# directory of the generated file.
add_library(c_target INTERFACE)
target_include_directories(c_target INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
# Per docs for add_dependencies
#
# Dependencies added to an imported target or an interface library are
# followed transitively"
#
# This ensures that the `_c_target` will be built prior to anything that may end
# up using `c_target`.
add_dependencies(c_target _c_target)
d/CMakeLists.txt
add_executable(d_target ${CMAKE_CURRENT_SOURCE_DIR}/d.cpp)
target_link_libraries(d_target PRIVATE c_target)
d/d.cpp
#include <stdio.h>
#include "c"
int main(int argc, char *argv[]) {
printf("The value is %d.\n", SOME_DEFINE);
}