[CMake] Multi-target builtins build

[phosek]

Summary

This change enables building builtins for multiple different targets using LLVM runtimes directory.

To specify the builtin targets to be built, use the LLVM_BUILTIN_TARGETS variable, where the value is the list of targets. To pass a per target variable to the builtin build, you can set BUILTINS_<target>_<variable> where <variable> will be passed to the builtin build for <target>.

[phosek]

There is a related compiler-rt change D26653 and example use case D26654.

[beanz]

Minor comments below. Otherwise LGTM! Thank you for picking this up. I'm really excited to see this taking shape.

Looping in @rengolin because he has been interested in this in the past.

cmake/modules/LLVMExternalProjectUtils.cmake

47–50

Adding llvm-ar to the default toolchain tools isn't valid on all platforms. In fact, I only think it is valid for Linux-based platforms, because it isn't for Darwin or (I think) Windows. Can you make this conditional?

77

CMake now has if(... IN_LIST ...) that makes this simpler. I know we're not universally using it yet, but we should at least use it in new code because it is way easier to read.

[phosek]

Ping, could you please take a look again?

[beanz]

LGTM! Thank you for doing this!

cmake/modules/LLVMExternalProjectUtils.cmake

 function(llvm_ExternalProject_Add name source_dir)
   cmake_parse_arguments(ARG
     "USE_TOOLCHAIN;EXCLUDE_FROM_ALL;NO_INSTALL;ALWAYS_CLEAN"
     "SOURCE_DIR"
     "CMAKE_ARGS;TOOLCHAIN_TOOLS;RUNTIME_LIBRARIES;DEPENDS;EXTRA_TARGETS;PASSTHROUGH_PREFIXES"
     ${ARGN})
   canonicalize_tool_name(${name} nameCanon)
   if(NOT ARG_TOOLCHAIN_TOOLS)
     set(ARG_TOOLCHAIN_TOOLS clang lld)
+    if(NOT APPLE AND NOT WIN32)
+      list(APPEND ARG_TOOLCHAIN_TOOLS llvm-ar llvm-ranlib)
+    endif()
   endif()
   foreach(tool ${ARG_TOOLCHAIN_TOOLS})
     if(TARGET ${tool})
       list(APPEND TOOLCHAIN_TOOLS ${tool})
       list(APPEND TOOLCHAIN_BINS $<TARGET_FILE:${tool}>)
     endif()
   endforeach()
 
if(ARG_ALWAYS_CLEAN)
     set(always_clean clean)
   endif()
 
   list(FIND TOOLCHAIN_TOOLS clang FOUND_CLANG)
   if(FOUND_CLANG GREATER -1)
     set(CLANG_IN_TOOLCHAIN On)
   endif()
 
   if(RUNTIME_LIBRARIES AND CLANG_IN_TOOLCHAIN)
     list(APPEND TOOLCHAIN_BINS ${RUNTIME_LIBRARIES})
   endif()
 
   set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/${name}-stamps/)
   set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${name}-bins/)
 
   add_custom_target(${name}-clear
     COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR}
foreach(prefix ${ARG_PASSTHROUGH_PREFIXES})
     endforeach()
   endforeach()
 
   if(ARG_USE_TOOLCHAIN)
     if(CLANG_IN_TOOLCHAIN)
       set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
                         -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++)
     endif()
+    if(llvm-ar IN_LIST TOOLCHAIN_TOOLS)
+      list(APPEND compiler_args -DCMAKE_AR=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ar)
+    endif()
+    if(llvm-ranlib IN_LIST TOOLCHAIN_TOOLS)
+      list(APPEND compiler_args -DCMAKE_RANLIB=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ranlib)
+    endif()
     list(APPEND ARG_DEPENDS ${TOOLCHAIN_TOOLS})
   endif()
 
   add_custom_command(
     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp
     DEPENDS ${ARG_DEPENDS}
     COMMAND ${CMAKE_COMMAND} -E touch ${BINARY_DIR}/CMakeCache.txt
     COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_DIR}/${name}-mkdir

runtimes/CMakeLists.txt

else() # if this is included from LLVM's CMake
   include(${LLVM_BINARY_DIR}/runtimes/Components.cmake OPTIONAL)
   set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${LLVM_BINARY_DIR}/runtimes/Components.cmake)
   include(LLVMExternalProjectUtils)
 
   # 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.
   if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt)
+    if(APPLE OR NOT LLVM_BUILTIN_TARGETS)
       llvm_ExternalProject_Add(builtins
                                ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt/lib/builtins
                                CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                           -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
+                                          -DCMAKE_C_COMPILER_TARGET=${TARGET_TRIPLE}
+                                          -DCMAKE_ASM_COMPILER_TARGET=${TARGET_TRIPLE}
                                PASSTHROUGH_PREFIXES COMPILER_RT
                                USE_TOOLCHAIN)
+    else()
+      get_cmake_property(variableNames VARIABLES)
+      add_custom_target(builtins)
+      foreach(target ${LLVM_BUILTIN_TARGETS})
+        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}
+                               ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt/lib/builtins
+                               CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
+                                          -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
+                                          -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}
+                               PASSTHROUGH_PREFIXES COMPILER_RT
+                               USE_TOOLCHAIN)
+        add_dependencies(builtins builtins-${target})
+      endforeach()
+    endif()
     set(deps builtins)
     # We don't need to depend on the builtins if we're building instrumented
     # because the next stage will use the same compiler used to build this stage.
     if(NOT LLVM_BUILD_INSTRUMENTED AND CLANG_ENABLE_BOOTSTRAP)
       add_dependencies(clang-bootstrap-deps builtins)
     endif()
   endif()