[compiler-rt] Enable building builtins using top-level CMake file

[phosek]

Summary

When building builtins separately as part of the runtime build, we
also want to include crt. To enable that, enable building builtins
together with crt using the top-level CMake file with a new option
COMPILER_RT_BOOTSTRAP set.

[phosek]

This is an alternative to D70744. I'm not a fan of introducing compiler-rt/builtins as a new top-level CMake, so I was trying to come up with an alternative and this is what I came up with, let me know what you think.

[daltenty]

In D89492#2333051, @phosek wrote:

This is an alternative to D70744. I'm not a fan of introducing compiler-rt/builtins as a new top-level CMake, so I was trying to come up with an alternative and this is what I came up with, let me know what you think.

I think this is an improvement, it was awkward to have two top-level entry points to the cmake anyway. This probably allows for some further de-duplication down the road as well.

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

49–55

206

OS_NAME doesn't currently get set in builtin-config-ix, we'll need to duplicate the setup from config-ix.

213–214

It would be nice to print the list of supported crt arch here as well.

compiler-rt/lib/builtins/CMakeLists.txt

7

We probably should retain the new cmake minimum

llvm/runtimes/CMakeLists.txt

415

We should probably disable the crt build here now.

528–529

Ditto the other comment

[daltenty]

LGTM, with slight adjustment. Though I will note that this requires a clean build because CMake will complain about the change in source directory in cache:

CMake Error: The source “../compiler-rt/CMakeLists.txt" does not match the source ../compiler-rt/lib/builtins/CMakeLists.txt" used to generate cache. Re-run cmake with a different source directory.

compiler-rt/CMakeLists.txt

126

fyi, this needs a slight adjustments because D87120 has landed

[daltenty]

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

207

The problem we have here is that the scope for these variables has changed, builtin-config-ix.cmake is only included in the builtins CMakeList.tx, so when we go to check COMPILER_RT_HAS_CRT it's out of scope.

Perhaps it would be cleaner to split the CRT checks into it's own crt-config-ix.cmake that can be included at the appropriate scope?

[kaz7]

Hi. Thank you for trying to achieve pre-compiling of crtbegin/crtend and builtins. Our architecture, SX-Aurora VE, doesn't have freely distributed crtbegin/crtend, so a mechanism like this is really important as I mentioned in D115038.

I take a look. I think the way to isolate each modules are good way to do. So, basically, it's fine to land in my opinion. However, we have been updating runtimes tramendously. So, it's better to rebase to recent main. We already have compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake. Scope is changed like @daltenty suggested.

After that, we can review it and run it. Thank you for your efforts.

[kaz7]

I also think separating this patch to following 3 parts makes applying this patch easy.

1. moving AIX related definitions
2. isolating crt-config-ix.cmake
3. supporting bootstrap build of crtbegin/crtend and builtins

[kaz7]

I've tested this patch after rebasing it by hand. It works great. So, I really want to contribute whatever I can. @phosek , please let me know what ever I can help. Thanks!

[kaz7]

Hi, is there anything I can help to merge this patch? We need this modification to compile crtbegin/crtend before runtime libraries in order to compile LLVM for VE using bootstrapping build, https://libcxx.llvm.org/BuildingLibcxx.html#bootstrapping-build.

[kaz7]

Hi @phosek

I understand you are very busy. But, is there any way to push forward this patch since the ability of runtime standalone build has been removed at D119255. We, VE, badly need this feature, compiling crtbegin.o and crtend.o before runtimes. I previously posted similar patch, D115038, but it is recommended to remove since you already post this patch. But, this patch is not merged yet. Now, this patch is blocking VE runtime build from my point of view. Is it OK to make a similar patch if you don't have time to work on this? Please let me know what you think. Thanks.

[q66]

are there any plans to get this or an equivalent in? currently in my distribution i have to ship a version of this patch rebased to llvm 14 (https://github.com/chimera-linux/cports/blob/master/main/llvm/patches/999-build-runtimes-crt.patch) because if i don't, i can't build llvm at all (my system is fully llvm-based, therefore does not come with a gcc crt; an llvm crt is needed in order to build the rest of the runtimes, as otherwise invoking the in-tree clang used to build compiler-rt will try to find crtbeginS.o etc. which do not exist in my system)

[q66]

considering the old way of doing things is deprecated and as far as i can tell scheduled for removal in llvm 15, not having something equivalent to this means llvm will no longer build out of box in gcc-less linux systems...

[kaz7]

Hi, is it possible to rebase this patch to the latest main branch? I think this patch is almost done since many pieces of this patch is already merged. I appreciate if you have time to rebase it and merge this patch to main. I, llvm for VE, definitely need this feature to compile llvm at once. Thanks!

[phosek]

In D89492#3714788, @kaz7 wrote:

Hi, is it possible to rebase this patch to the latest main branch? I think this patch is almost done since many pieces of this patch is already merged. I appreciate if you have time to rebase it and merge this patch to main. I, llvm for VE, definitely need this feature to compile llvm at once. Thanks!

I'll try to upload an updated patch this week.

[kaz7]

Thank you!

This patch looks like very clean now. And, it works lika a charm on VE. LGTM.

[kaz7]

Hi @daltenty, is it possible to re-review this patch which you requested changes previously? This patch is holded because of your request, I think. Thank you!

[kaz7]

ping. Is there anything I can help? I'd like to merge this patch as soon as possible. :-)

[kaz7]

ping

[kaz7]

ping

[kaz7]

ping. Do I need to create a new patch copying this to merge this patch?

[barannikov88]

In D89492#4358665, @kaz7 wrote:

ping. Do I need to create a new patch copying this to merge this patch?

You've got an approval, just push the commit (assuming you have commit access). I guess you need to rebase it to resolve conflicts first.

[barannikov88]

In D89492#4358693, @barannikov88 wrote:

In D89492#4358665, @kaz7 wrote:

ping. Do I need to create a new patch copying this to merge this patch?

You've got an approval, just push the commit (assuming you have commit access). I guess you need to rebase it to resolve conflicts first.

Ah, never mind. I thought you are the author of the patch.
I'm also interested in this change.

[barannikov88]

reverse ping

[phosek]

I apologize about the delay, this change still has some issues that I haven't had yet time to resolve, I plan to land D136664 in the meantime,

[efocht]

As far as I can see https://reviews.llvm.org/D136664 was accepted on Nov 4, 2022 and can land.
Which would unblock this one (https://reviews.llvm.org/D89492). After almost 3 years we could actually send it to the Kindergarden ;-)

[phosek]

Superseded by D153989.

[kaz7]

Thank you. I don't notice that this problem has been already fixed. Now compiling llvm for VE is much easier.

compiler-rt/CMakeLists.txt

else()
   set(CMAKE_CFG_RESOLVED_INTDIR "")
 endif()
 
 include(base-config-ix)
 include(CompilerRTUtils)
 
 option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON)
 mark_as_advanced(COMPILER_RT_BUILD_BUILTINS)
+option(COMPILER_RT_BUILTINS_ENABLE_PIC "Use -fPIC for the builtin library" ON)
+mark_as_advanced(COMPILER_RT_BUILTINS_ENABLE_PIC)
 option(COMPILER_RT_BUILD_CRT "Build crtbegin.o/crtend.o" ON)
 mark_as_advanced(COMPILER_RT_BUILD_CRT)
 option(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY "Use eh_frame in crtbegin.o/crtend.o" ON)
 mark_as_advanced(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY)
-option(COMPILER_RT_BUILD_SANITIZERS "Build sanitizers" ON)
-mark_as_advanced(COMPILER_RT_BUILD_SANITIZERS)
-option(COMPILER_RT_BUILD_XRAY "Build xray" ON)
-mark_as_advanced(COMPILER_RT_BUILD_XRAY)
-option(COMPILER_RT_BUILD_LIBFUZZER "Build libFuzzer" ON)
-mark_as_advanced(COMPILER_RT_BUILD_LIBFUZZER)
-option(COMPILER_RT_BUILD_PROFILE "Build profile runtime" ON)
-mark_as_advanced(COMPILER_RT_BUILD_PROFILE)
-option(COMPILER_RT_BUILD_XRAY_NO_PREINIT "Build xray with no preinit patching" OFF)
-mark_as_advanced(COMPILER_RT_BUILD_XRAY_NO_PREINIT)
-
-set(COMPILER_RT_ASAN_SHADOW_SCALE ""
-    CACHE STRING "Override the shadow scale to be used in ASan runtime")
-
-if (NOT COMPILER_RT_ASAN_SHADOW_SCALE STREQUAL "")
-  # Check that the shadow scale value is valid.
-  if (NOT (COMPILER_RT_ASAN_SHADOW_SCALE GREATER -1 AND
-           COMPILER_RT_ASAN_SHADOW_SCALE LESS 8))
-    message(FATAL_ERROR "
-      Invalid ASan Shadow Scale '${COMPILER_RT_ASAN_SHADOW_SCALE}'.")
-  endif()
-
-  set(COMPILER_RT_ASAN_SHADOW_SCALE_LLVM_FLAG
-      -mllvm -asan-mapping-scale=${COMPILER_RT_ASAN_SHADOW_SCALE})
-  set(COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION
-      ASAN_SHADOW_SCALE=${COMPILER_RT_ASAN_SHADOW_SCALE})
-  set(COMPILER_RT_ASAN_SHADOW_SCALE_FLAG
-      -D${COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION})
-endif()
-
-set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS ON CACHE BOOL
-    "Enable libc interceptors in HWASan (testing mode)")
-
-set(COMPILER_RT_BAREMETAL_BUILD OFF CACHE BOOL
-  "Build for a bare-metal target.")
 
 if (COMPILER_RT_STANDALONE_BUILD)
   load_llvm_config()
   if (TARGET intrinsics_gen)
     # Loading the llvm config causes this target to be imported so place it
     # under the appropriate folder in an IDE.
     set_target_properties(intrinsics_gen PROPERTIES FOLDER "Compiler-RT Misc")
   endif()
if (${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "^arm")
     CHECK_SYMBOL_EXISTS (__thumb__ "" COMPILER_RT_ARM_THUMB)
   endif()
 endif()
 if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*android.*")
   set(ANDROID 1)
 endif()
 pythonize_bool(ANDROID)
 
+option(COMPILER_RT_BUILTINS_ONLY "Build just builtins and crt" OFF)
+
+if(COMPILER_RT_BUILTINS_ONLY)
+  include(AddCompilerRT)
+
+  if(COMPILER_RT_STANDALONE_BUILD)
+    set(COMPILER_RT_BUILTINS_STANDALONE_BUILD TRUE)
+  endif()
+
+  if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+    set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> -X32_64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+    set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -X32_64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+    set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> -X32_64 q <TARGET> <LINK_FLAGS> <OBJECTS>")
+    set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> -X32_64 q <TARGET> <LINK_FLAGS> <OBJECTS>")
+    set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> -X32_64 <TARGET>")
+    set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -X32_64 <TARGET>")
+  endif()
+
+  if(COMPILER_RT_BUILD_BUILTINS)
+    add_subdirectory(lib/builtins)
+  endif()
+  if(COMPILER_RT_BUILD_CRT AND COMPILER_RT_HAS_CRT)
+    add_subdirectory(lib/crt)
+  endif()
+  return()
+endif()
+
+option(COMPILER_RT_BUILD_SANITIZERS "Build sanitizers" ON)
+mark_as_advanced(COMPILER_RT_BUILD_SANITIZERS)
+option(COMPILER_RT_BUILD_XRAY "Build xray" ON)
+mark_as_advanced(COMPILER_RT_BUILD_XRAY)
+option(COMPILER_RT_BUILD_LIBFUZZER "Build libFuzzer" ON)
+mark_as_advanced(COMPILER_RT_BUILD_LIBFUZZER)
+option(COMPILER_RT_BUILD_PROFILE "Build profile runtime" ON)
+mark_as_advanced(COMPILER_RT_BUILD_PROFILE)
+option(COMPILER_RT_BUILD_XRAY_NO_PREINIT "Build xray with no preinit patching" OFF)
+mark_as_advanced(COMPILER_RT_BUILD_XRAY_NO_PREINIT)
+
+set(COMPILER_RT_ASAN_SHADOW_SCALE ""
+    CACHE STRING "Override the shadow scale to be used in ASan runtime")
+
+if (NOT COMPILER_RT_ASAN_SHADOW_SCALE STREQUAL "")
+  # Check that the shadow scale value is valid.
+  if (NOT (COMPILER_RT_ASAN_SHADOW_SCALE GREATER -1 AND
+           COMPILER_RT_ASAN_SHADOW_SCALE LESS 8))
+    message(FATAL_ERROR "
+      Invalid ASan Shadow Scale '${COMPILER_RT_ASAN_SHADOW_SCALE}'.")
+  endif()
+
+  set(COMPILER_RT_ASAN_SHADOW_SCALE_LLVM_FLAG
+      -mllvm -asan-mapping-scale=${COMPILER_RT_ASAN_SHADOW_SCALE})
+  set(COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION
+      ASAN_SHADOW_SCALE=${COMPILER_RT_ASAN_SHADOW_SCALE})
+  set(COMPILER_RT_ASAN_SHADOW_SCALE_FLAG
+      -D${COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION})
+endif()
+
+set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS ON CACHE BOOL
+    "Enable libc interceptors in HWASan (testing mode)")
+
+set(COMPILER_RT_BAREMETAL_BUILD OFF CACHE BOOL
+  "Build for a bare-metal target.")
+
 set(ANDROID_NDK_VERSION 18
     CACHE STRING "Set this to the Android NDK version that you are using")
 
 set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 pythonize_bool(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
 

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

 include(BuiltinTests)
 include(CheckCSourceCompiles)
 
 # Make all the tests only check the compiler
 set(TEST_COMPILE_ONLY On)
 
 # Check host compiler support for certain flags
 builtin_check_c_compiler_flag(-fPIC                 COMPILER_RT_HAS_FPIC_FLAG)
 builtin_check_c_compiler_flag(-fPIE                 COMPILER_RT_HAS_FPIE_FLAG)
 builtin_check_c_compiler_flag(-fno-builtin          COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
 builtin_check_c_compiler_flag(-std=c11              COMPILER_RT_HAS_STD_C11_FLAG)
 builtin_check_c_compiler_flag(-fvisibility=hidden   COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG)
 builtin_check_c_compiler_flag(-fomit-frame-pointer  COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG)
 builtin_check_c_compiler_flag(-ffreestanding        COMPILER_RT_HAS_FREESTANDING_FLAG)
 builtin_check_c_compiler_flag(-fxray-instrument     COMPILER_RT_HAS_XRAY_COMPILER_FLAG)
+builtin_check_c_compiler_flag(-Wno-pedantic         COMPILER_RT_HAS_WNO_PEDANTIC)
 
 builtin_check_c_compiler_source(COMPILER_RT_HAS_ATOMIC_KEYWORD
 "
 int foo(int x, int y) {
  _Atomic int result = x * y;
  return result;
 }
 ")

 set(WASM64 wasm64)
 set(VE ve)
 
 if(APPLE)
   set(ARM64 arm64 arm64e)
   set(ARM32 armv7 armv7k armv7s)
   set(X86_64 x86_64 x86_64h)
 endif()
 
+if(ANDROID)
+  set(OS_NAME "Android")
+else()
+  set(OS_NAME "${CMAKE_SYSTEM_NAME}")
+endif()
+
 set(ALL_BUILTIN_SUPPORTED_ARCH
   ${X86} ${X86_64} ${ARM32} ${ARM64}
   ${HEXAGON} ${MIPS32} ${MIPS64} ${PPC32} ${PPC64}
   ${RISCV32} ${RISCV64} ${SPARC} ${SPARCV9}
   ${WASM32} ${WASM64} ${VE})
+set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV32} ${RISCV64})
 
 include(CompilerRTUtils)
 include(CompilerRTDarwinUtils)
 
 if(APPLE)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
else()
   # config-ix.cmake to tell us what to build. Otherwise we need to do some leg
   # work here...
   if(COMPILER_RT_BUILTINS_STANDALONE_BUILD)
     test_targets()
   endif()
   # Architectures supported by compiler-rt libraries.
   filter_available_targets(BUILTIN_SUPPORTED_ARCH
     ${ALL_BUILTIN_SUPPORTED_ARCH})
+  filter_available_targets(CRT_SUPPORTED_ARCH
+    ${ALL_CRT_SUPPORTED_ARCH})
+
+  if (CRT_SUPPORTED_ARCH AND OS_NAME MATCHES "Linux")
+    set(COMPILER_RT_HAS_CRT TRUE)
+  else()
+    set(COMPILER_RT_HAS_CRT FALSE)
+  endif()
 endif()
 
-message(STATUS "Builtin supported architectures: ${BUILTIN_SUPPORTED_ARCH}")
+message(STATUS "Supported architectures for builtin: ${BUILTIN_SUPPORTED_ARCH}")
+message(STATUS "Supported architectures for crt: ${CRT_SUPPORTED_ARCH}")

compiler-rt/cmake/config-ix.cmake

if(APPLE)
   set(ARM32 armv7 armv7s armv7k)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64} ${RISCV64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9})
-set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV32} ${RISCV64})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 
if(APPLE)
   list_intersect(XRAY_SUPPORTED_ARCH
     ALL_XRAY_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SHADOWCALLSTACK_SUPPORTED_ARCH
     ALL_SHADOWCALLSTACK_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
 
 else()
-  filter_available_targets(CRT_SUPPORTED_ARCH ${ALL_CRT_SUPPORTED_ARCH})
   # Architectures supported by compiler-rt libraries.
   filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
     ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
   # LSan and UBSan common files should be available on all architectures
   # supported by other sanitizers (even if they build into dummy object files).
   filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH

compiler-rt/lib/builtins/CMakeLists.txt

 # This directory contains a large amount of C code which provides
 # generic implementations of the core runtime library along with optimized
 # architecture-specific code in various subdirectories.
 
-if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   cmake_minimum_required(VERSION 3.13.4)
-
   project(CompilerRTBuiltins C ASM)
-  set(COMPILER_RT_STANDALONE_BUILD TRUE)
-  set(COMPILER_RT_BUILTINS_STANDALONE_BUILD TRUE)
-  list(INSERT CMAKE_MODULE_PATH 0
-    "${CMAKE_SOURCE_DIR}/../../cmake"
-    "${CMAKE_SOURCE_DIR}/../../cmake/Modules")
-  include(base-config-ix)
-  include(CompilerRTUtils)
-
-  load_llvm_config()
-  construct_compiler_rt_default_triple()
-
-  if(APPLE)
-    include(CompilerRTDarwinUtils)
-  endif()
-  if(APPLE)
-    include(UseLibtool)
-  endif()
-  include(AddCompilerRT)
 
-  if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
-    set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> -X32_64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
-    set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -X32_64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
-    set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> -X32_64 q <TARGET> <LINK_FLAGS> <OBJECTS>")
-    set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> -X32_64 q <TARGET> <LINK_FLAGS> <OBJECTS>")
-    set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> -X32_64 <TARGET>")
-    set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -X32_64 <TARGET>")
-  endif()
+  if(NOT __BUILTINS_PROCESSED__)
+    message(WARNING "Using this directory is deprecated, use compiler-rt with COMPILER_RT_BUILTINS_ONLY")
+    set(COMPILER_RT_BUILTINS_ONLY TRUE)
+    include(../../CMakeLists.txt)
+    set(__BUILTINS_PROCESSED__ TRUE)
+    return()
   endif()
-
-if (COMPILER_RT_STANDALONE_BUILD)
-  # When compiler-rt is being built standalone, possibly as a cross-compilation
-  # target, the target may or may not want position independent code. This
-  # option provides an avenue through which the flag may be controlled when an
-  # LLVM configuration is not being utilized.
-  option(COMPILER_RT_BUILTINS_ENABLE_PIC
-    "Turns on or off -fPIC for the builtin library source"
-    ON)
 endif()
 
 include(builtin-config-ix)
 
 # TODO: Need to add a mechanism for logging errors when builtin source files are
 # added to a sub-directory and not this CMakeLists file.
 set(GENERIC_SOURCES
   absvdi2.c

llvm/runtimes/CMakeLists.txt

function(builtin_default_target compiler_rt_path)
 
     set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default ON)
     # AIX should fold 32-bit & 64-bit arch libraries into a single archive.
     if (TARGET_TRIPLE MATCHES "aix")
       set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default OFF)
     endif()
 
     llvm_ExternalProject_Add(builtins
-                             ${compiler_rt_path}/lib/builtins
+                             ${compiler_rt_path}
                              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=${LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default}
                                         -DCMAKE_C_COMPILER_TARGET=${TARGET_TRIPLE}
+                                        -DCMAKE_CXX_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_ASM_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_C_COMPILER_WORKS=ON
+                                        -DCMAKE_CXX_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
+                                        -DCOMPILER_RT_BUILTINS_ONLY=ON
                                         ${BUILTINS_CMAKE_ARGS}
                              PASSTHROUGH_PREFIXES COMPILER_RT
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
   function(builtin_register_target compiler_rt_path target)
     cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
 
     check_apple_target(${target} builtin)
 
     get_cmake_property(variableNames VARIABLES)
     foreach(variableName ${variableNames})
       string(FIND "${variableName}" "BUILTINS_${target}" out)
       if("${out}" EQUAL 0)
         string(REPLACE "BUILTINS_${target}_" "" new_name ${variableName})
         string(REPLACE ";" "|" new_value "${${variableName}}")
         list(APPEND ${target}_extra_args "-D${new_name}=${new_value}")
       endif()
     endforeach()
 
     llvm_ExternalProject_Add(builtins-${target}
-                             ${compiler_rt_path}/lib/builtins
+                             ${compiler_rt_path}
                              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_CXX_COMPILER_TARGET=${target}
                                         -DCMAKE_ASM_COMPILER_TARGET=${target}
                                         -DCMAKE_C_COMPILER_WORKS=ON
+                                        -DCMAKE_CXX_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                                         -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON
+                                        -DCOMPILER_RT_BUILTINS_ONLY=ON
                                         ${${target}_extra_args}
                              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.
function(runtime_default_target)
     if (TARGET_TRIPLE MATCHES "aix")
       set(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default OFF)
     endif()
 
     llvm_ExternalProject_Add(runtimes
                              ${CMAKE_CURRENT_SOURCE_DIR}
                              DEPENDS ${ARG_DEPENDS}
                              # Builtins were built separately above
-                             CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
+                             CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=OFF
+                                        -DCOMPILER_RT_BUILD_CRT=OFF
                                         -DLLVM_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                                         -DLLVM_DEFAULT_TARGET_TRIPLE=${TARGET_TRIPLE}
                                         -DLLVM_ENABLE_PROJECTS_USED=${LLVM_ENABLE_PROJECTS_USED}
                                         -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=${LLVM_ENABLE_PER_TARGET_RUNTIME_DIR_default}
                                         -DCMAKE_C_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_CXX_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_ASM_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_C_COMPILER_WORKS=ON
function(runtime_register_target name target)
     if(target IN_LIST LLVM_RUNTIME_BUILD_ID_LINK_TARGETS)
       list(APPEND EXTRA_ARGS STRIP_TOOL ${CMAKE_CURRENT_BINARY_DIR}/llvm-strip-link)
     endif()
 
     llvm_ExternalProject_Add(runtimes-${name}
                              ${CMAKE_CURRENT_SOURCE_DIR}
                              DEPENDS ${${name}_deps}
                              # Builtins were built separately above
-                             CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
+                             CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=OFF
+                                        -DCOMPILER_RT_BUILD_CRT=OFF
                                         -DLLVM_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                                         -DLLVM_DEFAULT_TARGET_TRIPLE=${target}
                                         -DLLVM_ENABLE_PROJECTS_USED=${LLVM_ENABLE_PROJECTS_USED}
                                         -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON
                                         -DCMAKE_C_COMPILER_TARGET=${target}
                                         -DCMAKE_CXX_COMPILER_TARGET=${target}
                                         -DCMAKE_ASM_COMPILER_TARGET=${target}
                                         -DCMAKE_C_COMPILER_WORKS=ON