[CMake][runtimes] Set clang-header dependency for builtins

[phosek]

Summary

compiler-rt builtins depend on clang headers, but that dependency
wasn't explicitly stated in the build system and we were relying
on the transitive depenendecy via clang. However, when we're
cross-compiling clang, we'll be using host compiler instead and
that depenendecy is missing, breaking the build.

[smeenai]

LGTM

llvm/runtimes/CMakeLists.txt

214 ↗

(On Diff #187650)

Any reason for spelling these as "DEPS" instead of the standard CMake spelling of "DEPENDS"?

[beanz]

Makes sense

[smeenai]

Ah, I didn't realize there were existing uses of DEPS, but thanks for the rename :)

llvm/trunk/runtimes/CMakeLists.txt

 else() # if this is included from LLVM's CMake
   include(LLVMExternalProjectUtils)
 
   if(NOT LLVM_BUILD_RUNTIMES)
     set(EXTRA_ARGS EXCLUDE_FROM_ALL)
   endif()
 
   function(builtin_default_target compiler_rt_path)
+    cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
+
     llvm_ExternalProject_Add(builtins
                              ${compiler_rt_path}/lib/builtins
+                             DEPENDS ${ARG_DEPENDS}
                              CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                         -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
                                         -DLLVM_DEFAULT_TARGET_TRIPLE=${TARGET_TRIPLE}
                                         -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON
                                         -DCMAKE_C_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_ASM_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_C_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                              PASSTHROUGH_PREFIXES COMPILER_RT
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
   function(builtin_register_target compiler_rt_path target)
+    cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
+
     string(REPLACE "-" ";" builtin_target_list ${target})
     foreach(item ${builtin_target_list})
       string(TOLOWER "${item}" item_lower)
       if(item_lower MATCHES "darwin")
         message(FATAL_ERROR "LLVM_BUILTIN_TARGETS isn't implemented for Darwin platform!")
       endif()
     endforeach()
 
     get_cmake_property(variableNames VARIABLES)
     foreach(variableName ${variableNames})
       if(variableName MATCHES "^BUILTINS_${target}")
         string(REPLACE "BUILTINS_${target}_" "" new_name ${variableName})
         list(APPEND ${target}_extra_args "-D${new_name}=${${variableName}}")
       endif()
     endforeach()
 
     llvm_ExternalProject_Add(builtins-${target}
                              ${compiler_rt_path}/lib/builtins
+                             DEPENDS ${ARG_DEPENDS}
                              CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                         -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
                                         -DLLVM_DEFAULT_TARGET_TRIPLE=${target}
                                         -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON
                                         -DCMAKE_C_COMPILER_TARGET=${target}
                                         -DCMAKE_ASM_COMPILER_TARGET=${target}
                                         -DCMAKE_C_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                                         -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON
                                         ${${target}_extra_args}
                              TOOLCHAIN_TOOLS clang lld llvm-ar llvm-ranlib llvm-nm llvm-objcopy llvm-objdump llvm-strip
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
   # If compiler-rt is present we need to build the builtin libraries first. This
   # is required because the other runtimes need the builtin libraries present
   # before the just-built compiler can pass the configuration tests.
   get_compiler_rt_path(compiler_rt_path)
   if(compiler_rt_path)
     if(NOT LLVM_BUILTIN_TARGETS)
-      builtin_default_target(${compiler_rt_path})
+      builtin_default_target(${compiler_rt_path}
+        DEPENDS clang-headers)
     else()
       if("default" IN_LIST LLVM_BUILTIN_TARGETS)
-        builtin_default_target(${compiler_rt_path})
+        builtin_default_target(${compiler_rt_path}
+          DEPENDS clang-headers)
         list(REMOVE_ITEM LLVM_BUILTIN_TARGETS "default")
       else()
         add_custom_target(builtins)
         add_custom_target(install-builtins)
         add_custom_target(install-builtins-stripped)
       endif()
 
       foreach(target ${LLVM_BUILTIN_TARGETS})
-        builtin_register_target(${compiler_rt_path} ${target})
+        builtin_register_target(${compiler_rt_path} ${target}
+          DEPENDS clang-headers)
 
         add_dependencies(builtins builtins-${target})
         add_dependencies(install-builtins install-builtins-${target})
         add_dependencies(install-builtins-stripped install-builtins-${target}-stripped)
       endforeach()
     endif()
     set(deps builtins)
     # We don't need to depend on the builtins if we're building instrumented
foreach(entry ${runtimes})
     string(FIND ${projName} "lib" LIB_IDX)
     if(LIB_IDX EQUAL 0)
       string(SUBSTRING ${projName} 3 -1 projName)
     endif()
     list(APPEND runtime_names ${projName})
   endforeach()
 
   function(runtime_default_target)
-    cmake_parse_arguments(ARG "" "" "DEPS;PREFIXES" ${ARGN})
+    cmake_parse_arguments(ARG "" "" "DEPENDS;PREFIXES" ${ARGN})
 
     include(${LLVM_BINARY_DIR}/runtimes/Components.cmake OPTIONAL)
     set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${LLVM_BINARY_DIR}/runtimes/Components.cmake)
 
     foreach(runtime_name ${runtime_names})
       list(APPEND extra_targets
         ${runtime_name}
         install-${runtime_name}
function(runtime_default_target)
     endforeach()
 
     if(LLVM_INCLUDE_TESTS)
       list(APPEND test_targets runtimes-test-depends check-runtimes)
     endif()
 
     llvm_ExternalProject_Add(runtimes
                              ${CMAKE_CURRENT_SOURCE_DIR}
-                             DEPENDS ${ARG_DEPS}
+                             DEPENDS ${ARG_DEPENDS}
                              # Builtins were built separately above
                              CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
                                         -DLLVM_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                                         -DLLVM_LIBRARY_DIR=${LLVM_LIBRARY_DIR}
                                         -DLLVM_DEFAULT_TARGET_TRIPLE=${TARGET_TRIPLE}
                                         -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON
                                         -DCMAKE_C_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_CXX_COMPILER_TARGET=${TARGET_TRIPLE}
llvm_ExternalProject_Add(runtimes
                                            ${SUB_INSTALL_TARGETS}
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
   # runtime_register_target(target)
   #   Utility function to register external runtime target.
   function(runtime_register_target name target)
-    cmake_parse_arguments(ARG "" "" "DEPS" ${ARGN})
+    cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
     include(${LLVM_BINARY_DIR}/runtimes/${name}/Components.cmake OPTIONAL)
     set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${LLVM_BINARY_DIR}/runtimes/${name}/Components.cmake)
 
-    set(${name}_deps ${ARG_DEPS})
+    set(${name}_deps ${ARG_DEPENDS})
     if(NOT name STREQUAL target)
       list(APPEND ${name}_deps runtimes-${target})
     endif()
 
     foreach(runtime_name ${runtime_names})
       set(${runtime_name}-${name} ${runtime_name})
       set(install-${runtime_name}-${name} install-${runtime_name})
       set(install-${runtime_name}-${name}-stripped install-${runtime_name}-stripped)
else() # if this is included from LLVM's CMake
   endfunction()
 
   if(runtimes)
     # Create a runtimes target that uses this file as its top-level CMake file.
     # The runtimes target is a configuration of all the runtime libraries
     # together in a single CMake invocaiton.
     if(NOT LLVM_RUNTIME_TARGETS)
       runtime_default_target(
-        DEPS ${deps}
-        PREFIXES ${prefixes}
-        )
+        DEPENDS ${deps}
+        PREFIXES ${prefixes})
     else()
       if("default" IN_LIST LLVM_RUNTIME_TARGETS)
         runtime_default_target(
-          DEPS ${deps}
+          DEPENDS ${deps}
           PREFIXES ${prefixes})
         list(REMOVE_ITEM LLVM_RUNTIME_TARGETS "default")
       else()
         add_custom_target(runtimes)
         add_custom_target(runtimes-configure)
         add_custom_target(install-runtimes)
         add_custom_target(install-runtimes-stripped)
         if(LLVM_INCLUDE_TESTS)
           add_custom_target(check-runtimes)
           add_custom_target(runtimes-test-depends)
           set(test_targets "")
         endif()
         if(LLVM_RUNTIME_DISTRIBUTION_COMPONENTS)
           foreach(component ${LLVM_RUNTIME_DISTRIBUTION_COMPONENTS})
             add_custom_target(${component})
             add_custom_target(install-${component})
           endforeach()
         endif()
       endif()
 
       foreach(name ${LLVM_RUNTIME_TARGETS})
         runtime_register_target(${name} ${name}
-          DEPS ${deps}
-          )
+          DEPENDS ${deps})
 
         add_dependencies(runtimes runtimes-${name})
         add_dependencies(runtimes-configure runtimes-${name}-configure)
         add_dependencies(install-runtimes install-runtimes-${name})
         add_dependencies(install-runtimes-stripped install-runtimes-${name}-stripped)
         if(LLVM_INCLUDE_TESTS)
           add_dependencies(check-runtimes check-runtimes-${name})
           add_dependencies(runtimes-test-depends runtimes-test-depends-${name})
else()
           set(sanitizer_name "tsan")
         elseif (sanitizer STREQUAL "Undefined")
           set(sanitizer_name "ubsan")
         else()
           message(FATAL_ERROR "Unsupported value of LLVM_RUNTIME_TARGET_SANITIZERS: ${sanitizers}")
         endif()
         foreach(name ${LLVM_RUNTIME_SANITIZER_${sanitizer}_TARGETS})
           runtime_register_target(${name}-${sanitizer_name} ${name}
-            DEPS runtimes-${name}
+            DEPENDS runtimes-${name}
             CMAKE_ARGS -DLLVM_USE_SANITIZER=${sanitizer}
                        -DLLVM_RUNTIMES_PREFIX=${name}/
-                       -DLLVM_RUNTIMES_LIBDIR_SUFFIX=/${sanitizer_name}
-            )
+                       -DLLVM_RUNTIMES_LIBDIR_SUFFIX=/${sanitizer_name})
           add_dependencies(runtimes runtimes-${name}-${sanitizer_name})
           add_dependencies(runtimes-configure runtimes-${name}-${sanitizer_name}-configure)
           add_dependencies(install-runtimes install-runtimes-${name}-${sanitizer_name})
           add_dependencies(install-runtimes-stripped install-runtimes-${name}-${sanitizer_name}-stripped)
         endforeach()
       endforeach()
     endif()