[compiler-rt] Support building builtins for a single target

[phosek]

Summary

This is used when building builtins for multiple targets as part of LLVM runtimes.

[beanz]

I have one long comment below, but otherwise this is great. Thanks for working on this!

cmake/Modules/CompilerRTUtils.cmake

232 ↗

(On Diff #77920)

This is actually bad because of the way CMake's caching behavior works. CMAKE_C_COMPILER_TARGET if set would be a cached variable, and defining another cached variable off of it means that if you update one CMAKE_C_COMPILER_TARGET COMPILER_RT_DEFAULT_TARGET_TRIPLE won't be updated as well.

I'm not sure if there is a good way to change this without breaking existing users. If you can't come up with something can you add a check to ensure that if CMAKE_C_COMPILER_TARGET is defined, it is the same as COMPILER_RT_DEFAULT_TARGET_TRIPLE? That will at least tell users when something goes wrong.

An alternative approach that appeals to me would be to have the code paths based on COMPILER_RT_DEFAULT_TARGET_ONLY use CMAKE_C_COMPILER_TARGET instead of COMPILER_RT_DEFAULT_TARGET_TRIPLE, and make an error if COMPILER_RT_DEFAULT_TARGET_TRIPLE is specified without CMAKE_C_COMPILER_TARGET.

The reason I like that approach is that as users migrate onto COMPILER_RT_DEFAULT_TARGET_ONLY we will be encouraging them to also migrate to using CMake's builtin cross-targeting mechanisms instead of the hand rolled ones.

[phosek]

cmake/Modules/CompilerRTUtils.cmake

249 ↗

(On Diff #78296)

I'm not a big fan of the triple parsing business done in CMake, we should probably use the triple directly everywhere without interpreting its content, but that's something that should be done separately as it'll likely require multiple changes.

[phosek]

Ping, could you please take a look again if this solution is fine with you?

[beanz]

Yep, LGTM!

Sorry for the delay, I was out all last week.

compiler-rt/trunk/cmake/Modules/CompilerRTUtils.cmake

foreach(arch ${ARGN})
     list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
     if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch})
       list(APPEND archs ${arch})
     endif()
   endforeach()
   set(${out_var} ${archs} PARENT_SCOPE)
 endfunction()
 
+# Add $arch as supported with no additional flags.
+macro(add_default_target_arch arch)
+  set(TARGET_${arch}_CFLAGS "")
+  set(CAN_TARGET_${arch} 1)
+  list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+endmacro()
+
 function(check_compile_definition def argstring out_var)
   if("${def}" STREQUAL "")
     set(${out_var} TRUE PARENT_SCOPE)
     return()
   endif()
   cmake_push_check_state()
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}")
   check_symbol_exists(${def} "" ${out_var})
macro(load_llvm_config)
   # Get some LLVM variables from LLVMConfig.
   include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake")
 
   set(LLVM_LIBRARY_OUTPUT_INTDIR
     ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
 endmacro()
 
 macro(construct_compiler_rt_default_triple)
+  if(COMPILER_RT_DEFAULT_TARGET_ONLY)
+    if(DEFINED COMPILER_RT_DEFAULT_TARGET_TRIPLE)
+      message(FATAL_ERROR "COMPILER_RT_DEFAULT_TARGET_TRIPLE isn't supported when building for default target only")
+    endif()
+    set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${CMAKE_C_COMPILER_TARGET})
+  else()
     set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING
           "Default triple for which compiler-rt runtimes will be built.")
+  endif()
+
   if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE)
     # Backwards compatibility: this variable used to be called
     # COMPILER_RT_TEST_TARGET_TRIPLE.
     set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${COMPILER_RT_TEST_TARGET_TRIPLE})
   endif()
 
   string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE})
   list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH)
   list(GET TARGET_TRIPLE_LIST 1 COMPILER_RT_DEFAULT_TARGET_OS)
+  list(LENGTH TARGET_TRIPLE_LIST TARGET_TRIPLE_LIST_LENGTH)
+  if(TARGET_TRIPLE_LIST_LENGTH GREATER 2)
     list(GET TARGET_TRIPLE_LIST 2 COMPILER_RT_DEFAULT_TARGET_ABI)
+  endif()
   # Determine if test target triple is specified explicitly, and doesn't match the
   # default.
   if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL TARGET_TRIPLE)
     set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE)
   else()
     set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE)
   endif()
 endmacro()

compiler-rt/trunk/cmake/base-config-ix.cmake

execute_process(COMMAND xcodebuild -version -sdk macosx Path
        ERROR_QUIET
        OUTPUT_STRIP_TRAILING_WHITESPACE)
     set(OSX_SYSROOT_FLAG "-isysroot${OSX_SYSROOT}")
   endif()
 
   option(COMPILER_RT_ENABLE_IOS "Enable building for iOS" On)
   option(COMPILER_RT_ENABLE_WATCHOS "Enable building for watchOS - Experimental" Off)
   option(COMPILER_RT_ENABLE_TVOS "Enable building for tvOS - Experimental" Off)
+else()
+  option(COMPILER_RT_DEFAULT_TARGET_ONLY "Build builtins only for the default target" Off)
 endif()
 
 if(WIN32 AND NOT MINGW AND NOT CYGWIN)
   set(CMAKE_SHARED_LIBRARY_PREFIX_C "")
   set(CMAKE_SHARED_LIBRARY_PREFIX_CXX "")
   set(CMAKE_STATIC_LIBRARY_PREFIX_C "")
   set(CMAKE_STATIC_LIBRARY_PREFIX_CXX "")
   set(CMAKE_STATIC_LIBRARY_SUFFIX_C ".lib")
macro(test_targets)
   endif()
 
   # Generate the COMPILER_RT_SUPPORTED_ARCH list.
   if(ANDROID)
     # Examine compiler output to determine target architecture.
     detect_target_arch()
     set(COMPILER_RT_OS_SUFFIX "-android")
   elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
-    if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64")
+    if(COMPILER_RT_DEFAULT_TARGET_ONLY)
+      add_default_target_arch(${COMPILER_RT_DEFAULT_TARGET_ARCH})
+    elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64")
       if(NOT MSVC)
         test_target_arch(x86_64 "" "-m64")
         # FIXME: We build runtimes for both i686 and i386, as "clang -m32" may
         # target different variant than "$CMAKE_C_COMPILER -m32". This part should
         # be gone after we resolve PR14109.
         test_target_arch(i686 __i686__ "-m32")
         test_target_arch(i386 __i386__ "-m32")
       else()

compiler-rt/trunk/cmake/config-ix.cmake

 
 # Try to compile a very simple source file to ensure we can target the given
 # platform. We use the results of these tests to build only the various target
 # runtime libraries supported by our current compilers cross-compiling
 # abilities.
 set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc)
 file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <stdio.h>\nint main() { printf(\"hello, world\"); }\n")
 
-# Add $arch as supported with no additional flags.
-macro(add_default_target_arch arch)
-  set(TARGET_${arch}_CFLAGS "")
-  set(CAN_TARGET_${arch} 1)
-  list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
-endmacro()
-
 # Detect whether the current target platform is 32-bit or 64-bit, and setup
 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
 if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
     NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
   message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
 endif()
 
 test_targets()