[runtimes][compiler-rt] Add optional runtimes step to build crt up front

[daltenty]

Summary

When building runtimes, the built compiler may depend on components from
compiler-rt's crt module depending on the target and configuration, and
thus have difficulty passing CMake configuration test if crt is not
already available (the same as is true for compiler-rt builtins).

Similar to builtins, this change provides the ability to build
crt prior to trying to build the rest of runtimes, in order to resolve
this dependency. This includes adding a standalone header to the crt
CMakeLists.txt and a separate crt-config-ix.cmake both in the same
style as what is currently done for builtins.

Enabling this build behavior is gated under the LLVM_RUNTIMES_CRT_STANDALONE_BUILD
variable, so the default build is unmodified and specific configurations
that need it can opt-in to it.

[phosek]

See D70744 which is trying to achieve the same, but instead it builds crt together with builtins. When I started working on that change, I also considered the approached used in this change and I briefly discussed it with @beanz, but there was a concern that adding more stages is going to increase already long build time even further.

[hubert.reinterpretcast]

compiler-rt/cmake/config-ix.cmake

670

What does setting this to TRUE more often do?

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

25–41

My guess is that the unreferenced lists here are going to become unmaintained lists very quickly. Also, what is the scope associated with these? Are we sure that these are not overriding other definitions before their corresponding use?

47

Nit: re: extra space.

48

Nit: Comma.

[daltenty]

In D88932#2315531, @phosek wrote:

See D70744 which is trying to achieve the same, but instead it builds crt together with builtins. When I started working on that change, I also considered the approached used in this change and I briefly discussed it with @beanz, but there was a concern that adding more stages is going to increase already long build time even further.

@phosek Thanks, I think it makes a lot of sense to keep it all together in a single stage. It also avoids duplicating a lot of the config which this approach does. I'm not opposed to abandoning this revision if you'd prefer to revive D70744 instead then?

[daltenty]

In D88932#2317202, @daltenty wrote:

In D88932#2315531, @phosek wrote:

See D70744 which is trying to achieve the same, but instead it builds crt together with builtins. When I started working on that change, I also considered the approached used in this change and I briefly discussed it with @beanz, but there was a concern that adding more stages is going to increase already long build time even further.

@phosek Thanks, I think it makes a lot of sense to keep it all together in a single stage. It also avoids duplicating a lot of the config which this approach does. I'm not opposed to abandoning this revision if you'd prefer to revive D70744 instead then?

@phosek Gentle ping on whether we are keeping this patch around, or if you'd like to update D70744 (since it's already approved) instead. I can merge the approach of D70744 into here if you'd prefer to abandon that one instead.

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

25–41

These really probably should have a common definition that get's included somewhere. Right now all the various cmake files that need it reproduce the list.

[phosek]

In D88932#2327933, @daltenty wrote:

In D88932#2317202, @daltenty wrote:

In D88932#2315531, @phosek wrote:

See D70744 which is trying to achieve the same, but instead it builds crt together with builtins. When I started working on that change, I also considered the approached used in this change and I briefly discussed it with @beanz, but there was a concern that adding more stages is going to increase already long build time even further.

@phosek Thanks, I think it makes a lot of sense to keep it all together in a single stage. It also avoids duplicating a lot of the config which this approach does. I'm not opposed to abandoning this revision if you'd prefer to revive D70744 instead then?

@phosek Gentle ping on whether we are keeping this patch around, or if you'd like to update D70744 (since it's already approved) instead. I can merge the approach of D70744 into here if you'd prefer to abandon that one instead.

I plan to land D70744.

[daltenty]

In D88932#2328459, @phosek wrote:

In D88932#2327933, @daltenty wrote:

In D88932#2317202, @daltenty wrote:

In D88932#2315531, @phosek wrote:

See D70744 which is trying to achieve the same, but instead it builds crt together with builtins. When I started working on that change, I also considered the approached used in this change and I briefly discussed it with @beanz, but there was a concern that adding more stages is going to increase already long build time even further.

@phosek Thanks, I think it makes a lot of sense to keep it all together in a single stage. It also avoids duplicating a lot of the config which this approach does. I'm not opposed to abandoning this revision if you'd prefer to revive D70744 instead then?

@phosek Gentle ping on whether we are keeping this patch around, or if you'd like to update D70744 (since it's already approved) instead. I can merge the approach of D70744 into here if you'd prefer to abandon that one instead.

I plan to land D70744.

Thanks, I'll abandon this revision in favour for D70744 then.

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}
     ${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

 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD|SunOS")
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 else()
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
 endif()
 
 # TODO: Add builtins support.
 
-if (CRT_SUPPORTED_ARCH AND OS_NAME MATCHES "Linux" AND NOT LLVM_USE_SANITIZER)
+if (OS_NAME MATCHES "Linux" AND NOT LLVM_USE_SANITIZER)
   set(COMPILER_RT_HAS_CRT TRUE)
 else()
   set(COMPILER_RT_HAS_CRT FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_DFSAN TRUE)

compiler-rt/cmake/crt-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_CRT_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_source(COMPILER_RT_HAS_ATOMIC_KEYWORD
+"
+int foo(int x, int y) {
+ _Atomic int result = x * y;
+ return result;
+}
+")
+
+set(ARM64 aarch64)
+set(ARM32 arm armhf armv6m armv7m armv7em armv7 armv7s armv7k)
+set(HEXAGON hexagon)
+set(X86 i386)
+set(X86_64 x86_64)
+set(MIPS32 mips mipsel)
+set(MIPS64 mips64 mips64el)
+set(PPC32 powerpc)
+set(PPC64 powerpc64 powerpc64le)
+set(RISCV32 riscv32)
+set(RISCV64 riscv64)
+set(SPARC sparc)
+set(SPARCV9 sparcv9)
+set(WASM32 wasm32)
+set(WASM64 wasm64)
+set(S390X s390x)
+set(VE ve)
+
+set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV32} ${RISCV64})
+
+include(CompilerRTUtils)
+
+# If we're not building the crt standalone, just rely on the  tests in
+# config-ix.cmake to tell us what to build. Otherwise we need to do some leg
+# work here...
+if(COMPILER_RT_CRT_STANDALONE_BUILD)
+  test_targets()
+endif()
+# Architectures supported by compiler-rt libraries.
+filter_available_targets(CRT_SUPPORTED_ARCH ${ALL_CRT_SUPPORTED_ARCH})
+
+
+message(STATUS "CRT supported architectures: ${CRT_SUPPORTED_ARCH}")

compiler-rt/lib/crt/CMakeLists.txt

+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  cmake_minimum_required(VERSION 3.13.4)
+
+  project(CompilerRTCRT C ASM)
+  set(COMPILER_RT_STANDALONE_BUILD TRUE)
+  set(COMPILER_RT_CRT_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)
+endif()
+
+include(crt-config-ix)
+
 add_compiler_rt_component(crt)
 
 function(check_cxx_section_exists section output)
   cmake_parse_arguments(ARG "" "" "SOURCE;FLAGS" ${ARGN})
   if(NOT ARG_SOURCE)
     set(ARG_SOURCE "int main() { return 0; }\n")
   endif()
 

llvm/runtimes/CMakeLists.txt

llvm_ExternalProject_Add(builtins-${target}
                                         -DCMAKE_C_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                                         -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON
                                         ${${target}_extra_args}
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
+  function(crt_default_target compiler_rt_path)
+    cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
+
+    llvm_ExternalProject_Add(crt
+                             ${compiler_rt_path}/lib/crt
+                             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
+                                        ${BUILTINS_CMAKE_ARGS}
+                             PASSTHROUGH_PREFIXES COMPILER_RT
+                             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}
         DEPENDS clang-resource-headers)
+      if (LLVM_RUNTIMES_CRT_STANDALONE_BUILD)
+        crt_default_target(${compiler_rt_path}
+          DEPENDS clang-resource-headers)
+      endif()
     else()
       if("default" IN_LIST LLVM_BUILTIN_TARGETS)
         builtin_default_target(${compiler_rt_path}
           DEPENDS clang-resource-headers)
         list(REMOVE_ITEM LLVM_BUILTIN_TARGETS "default")
       else()
         add_custom_target(builtins)
         add_custom_target(install-builtins)
function(runtime_default_target)
     endif()
 
     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()
 
+    if(LLVM_RUNTIMES_CRT_STANDALONE_BUILD)
+      set(RUNTIMES_EXTRA_CMAKE_ARGS -DCOMPILER_RT_BUILD_CRT=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
                                         -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
                                         -DCMAKE_CXX_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
+                                        ${RUNTIMES_EXTRA_CMAKE_ARGS}
                                         ${RUNTIMES_CMAKE_ARGS}
                              PASSTHROUGH_PREFIXES LLVM_ENABLE_RUNTIMES
                                                   ${ARG_PREFIXES}
                              EXTRA_TARGETS ${extra_targets}
                                            ${test_targets}
                                            ${SUB_COMPONENTS}
                                            ${SUB_CHECK_TARGETS}
                                            ${SUB_INSTALL_TARGETS}