[compiler-rt] Move crt into builtins

[phosek]

Summary

On Linux crt is typically use in combination with builtins. In the Clang
driver the use of builtins and crt is controlled by the --rtlib option.
Both builtins and crt also have similar build requirements where they
need to be built before any other runtimes and must avoid dependencies.
We also want builtins and crt these to be buildable separately from the
rest of compiler-rt for bootstrapping purposes. Given how simple crt is,
rather than maintaining a separate directory with its own separate build
setup, it's more efficient to just move crt into builtins. We still use
separate CMake option to control whether to built crt same as before.

This is an alternative to D89492 and D136664.

[phosek]

@smeenai I'd appreciate your thoughts on this change. I'd like to move forward with one of the solutions for buildining crt with builtins and so far this seems like the most efficient one, but I'm open to other ideas.

[smeenai]

Sorry, it's been a week :D I assume that crt doesn't need the builtins to be available for its configure (the way the rest of compiler-rt does)? If so, this LGTM.

compiler-rt/lib/builtins/CMakeLists.txt

56–57

While you're changing all these (is that important here or just a drive-by fix, btw?), could you either quote them or drop the ${} to prevent weird things from happening if we have have e.g. an AIX variable defined? (https://cmake.org/cmake/help/latest/command/if.html#variable-expansion for context for anyone not familiar with the issue here.)

[phosek]

In D153989#4465759, @smeenai wrote:

Sorry, it's been a week :D I assume that crt doesn't need the builtins to be available for its configure (the way the rest of compiler-rt does)? If so, this LGTM.

Great question, I checked and crt doesn't need builtins, just Clang headers, same as builtins.

[smeenai]

In D153989#4465907, @phosek wrote:

In D153989#4465759, @smeenai wrote:

Sorry, it's been a week :D I assume that crt doesn't need the builtins to be available for its configure (the way the rest of compiler-rt does)? If so, this LGTM.

Great question, I checked and crt doesn't need builtins, just Clang headers, same as builtins.

Cool, this does seem like the simplest and best way to go then.

[sylvestre.ledru]

Seems that it caused:
https://github.com/llvm/llvm-project/issues/63799

[arichardson]

I think reduplication of build logic makes sense but these are conceptually separate things. The compiler rt builtins are needed in many cases where the C start-up code isn't (e.g. baremetal OS code). Would moving it to a subdirectory of builtins/ work too? That way it's clearer which source files and tests are part of each component?

[phosek]

In D153989#4492229, @arichardson wrote:

I think reduplication of build logic makes sense but these are conceptually separate things. The compiler rt builtins are needed in many cases where the C start-up code isn't (e.g. baremetal OS code). Would moving it to a subdirectory of builtins/ work too? That way it's clearer which source files and tests are part of each component?

That's certainly possible, although I'd also argue that crtbegin.c and crtend.c isn't the only code in builtins directory that fits into this category (that is not needed in environments like baremetal, requiring C library): for example atomic*.c, os_version_check.c, emutls.c, enable_execute_stack.c, eprintf.c, gcc_personality_v0.c, clear_cache.c and probably some more that I missed. If we're going to reorganize things, we should probably do it more holistically.

[nathanchance]

This change appears to break -DCOMPILER_RT_BUILD_CRT=OFF:

$ cmake -B build -S llvm -DCMAKE_BUILD_TYPE=Release -DCOMPILER_RT_BUILD_CRT=OFF -DLLVM_ENABLE_PROJECTS='clang;compiler-rt;lld'
...
CMake Error at cmake/modules/AddLLVM.cmake:1935 (add_dependencies):
  The dependency target "crt" of target "check-all" does not exist.
Call Stack (most recent call first):
  cmake/modules/AddLLVM.cmake:1975 (add_lit_target)
  CMakeLists.txt:1211 (umbrella_lit_testsuite_end)


CMake Error at cmake/modules/AddLLVM.cmake:1935 (add_dependencies):
  The dependency target "crt" of target "check-compiler-rt" does not exist.
Call Stack (most recent call first):
  cmake/modules/AddLLVM.cmake:1975 (add_lit_target)
  /home/nathan/cbl/src/llvm-project/compiler-rt/test/CMakeLists.txt:114 (umbrella_lit_testsuite_end)


CMake Error at cmake/modules/AddLLVM.cmake:1935 (add_dependencies):
  The dependency target "crt" of target "check-builtins" does not exist.
Call Stack (most recent call first):
  cmake/modules/AddLLVM.cmake:2001 (add_lit_target)
  /home/nathan/cbl/src/llvm-project/compiler-rt/test/builtins/CMakeLists.txt:112 (add_lit_testsuite)
...

[phosek]

In D153989#4494012, @nathanchance wrote:

This change appears to break -DCOMPILER_RT_BUILD_CRT=OFF:

$ cmake -B build -S llvm -DCMAKE_BUILD_TYPE=Release -DCOMPILER_RT_BUILD_CRT=OFF -DLLVM_ENABLE_PROJECTS='clang;compiler-rt;lld'
...
CMake Error at cmake/modules/AddLLVM.cmake:1935 (add_dependencies):
  The dependency target "crt" of target "check-all" does not exist.
Call Stack (most recent call first):
  cmake/modules/AddLLVM.cmake:1975 (add_lit_target)
  CMakeLists.txt:1211 (umbrella_lit_testsuite_end)


CMake Error at cmake/modules/AddLLVM.cmake:1935 (add_dependencies):
  The dependency target "crt" of target "check-compiler-rt" does not exist.
Call Stack (most recent call first):
  cmake/modules/AddLLVM.cmake:1975 (add_lit_target)
  /home/nathan/cbl/src/llvm-project/compiler-rt/test/CMakeLists.txt:114 (umbrella_lit_testsuite_end)


CMake Error at cmake/modules/AddLLVM.cmake:1935 (add_dependencies):
  The dependency target "crt" of target "check-builtins" does not exist.
Call Stack (most recent call first):
  cmake/modules/AddLLVM.cmake:2001 (add_lit_target)
  /home/nathan/cbl/src/llvm-project/compiler-rt/test/builtins/CMakeLists.txt:112 (add_lit_testsuite)
...

Thanks for this heads up, this should be addressed in rG926f3759ec62a8f170e76a60316cc0bdd9dd2ec9.

[phosek]

In D153989#4494278, @phosek wrote:

Thanks for this heads up, this should be addressed in rG926f3759ec62a8f170e76a60316cc0bdd9dd2ec9.

That didn't work, the actual fix turned out to be slightly more complex: D155126.

[arichardson]

In D153989#4492342, @phosek wrote:

In D153989#4492229, @arichardson wrote:

I think reduplication of build logic makes sense but these are conceptually separate things. The compiler rt builtins are needed in many cases where the C start-up code isn't (e.g. baremetal OS code). Would moving it to a subdirectory of builtins/ work too? That way it's clearer which source files and tests are part of each component?

That's certainly possible, although I'd also argue that crtbegin.c and crtend.c isn't the only code in builtins directory that fits into this category (that is not needed in environments like baremetal, requiring C library): for example atomic*.c, os_version_check.c, emutls.c, enable_execute_stack.c, eprintf.c, gcc_personality_v0.c, clear_cache.c and probably some more that I missed. If we're going to reorganize things, we should probably do it more holistically.

That is a good point and it would be nice to have more subdirectories (e.g. atomic should end up in libatomic.a). I was just suggesting subdirectories for this change since we already have an existing hierarchy that could be retained. Splitting things out later is slightly more involved.

compiler-rt/CMakeLists.txt

 include(base-config-ix)
 include(CompilerRTUtils)
 include(CMakeDependentOption)
 
 option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON)
 mark_as_advanced(COMPILER_RT_BUILD_BUILTINS)
 option(COMPILER_RT_DISABLE_AARCH64_FMV "Disable AArch64 Function Multi Versioning support" OFF)
 mark_as_advanced(COMPILER_RT_DISABLE_AARCH64_FMV)
-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)

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_FFREESTANDING_FLAG)
 builtin_check_c_compiler_flag(-fxray-instrument     COMPILER_RT_HAS_XRAY_COMPILER_FLAG)
+builtin_check_c_compiler_flag(-fno-lto              COMPILER_RT_HAS_FNO_LTO_FLAG)
+builtin_check_c_compiler_flag(-fno-profile-generate COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG)
+builtin_check_c_compiler_flag(-fno-profile-instr-generate COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG)
+builtin_check_c_compiler_flag(-fno-profile-instr-use COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_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;
 }
 ")
 
 builtin_check_c_compiler_source(COMPILER_RT_HAS_ASM_LSE
 "
 asm(\".arch armv8-a+lse\");
 asm(\"cas w0, w1, [x2]\");
 ")
 
+if(ANDROID)
+  set(OS_NAME "Android")
+else()
+  set(OS_NAME "${CMAKE_SYSTEM_NAME}")
+endif()
+
 set(ARM64 aarch64)
 set(ARM32 arm armhf armv4t armv5te armv6 armv6m armv7m armv7em armv7 armv7s armv7k armv8m.base armv8m.main armv8.1m.main)
 set(AVR avr)
 set(HEXAGON hexagon)
 set(X86 i386)
 set(X86_64 x86_64)
 set(LOONGARCH64 loongarch64)
 set(MIPS32 mips mipsel)
else()
   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})
 endif()
 
+if (OS_NAME MATCHES "Linux" AND NOT LLVM_USE_SANITIZER)
+  set(COMPILER_RT_HAS_CRT TRUE)
+else()
+  set(COMPILER_RT_HAS_CRT FALSE)
+endif()
+
 message(STATUS "Builtin supported architectures: ${BUILTIN_SUPPORTED_ARCH}")

compiler-rt/lib/CMakeLists.txt

if (COMPILER_RT_HAS_SANITIZER_COMMON AND
     (COMPILER_RT_BUILD_SANITIZERS OR COMPILER_RT_BUILD_XRAY OR COMPILER_RT_BUILD_MEMPROF))
   add_subdirectory(sanitizer_common)
 endif()
 
 if(COMPILER_RT_BUILD_BUILTINS)
   add_subdirectory(builtins)
 endif()
 
-if(COMPILER_RT_BUILD_CRT)
-  add_subdirectory(crt)
-endif()
-
 function(compiler_rt_build_runtime runtime)
   string(TOUPPER ${runtime} runtime_uppercase)
   if(COMPILER_RT_HAS_${runtime_uppercase})
     if(${runtime} STREQUAL tsan)
       add_subdirectory(tsan/dd)
     endif()
     if(${runtime} STREQUAL scudo_standalone)
       add_subdirectory(scudo/standalone)

compiler-rt/lib/builtins/CMakeLists.txt

if (COMPILER_RT_STANDALONE_BUILD)
   # 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)
+include(CMakeDependentOption)
 include(CMakePushCheckState)
 
-if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
-  include(CompilerRTAIXUtils)
-endif()
-
 option(COMPILER_RT_BUILTINS_HIDE_SYMBOLS
   "Do not export any symbols from the static library." ON)
 
 # 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
   absvsi2.c
   absvti2.c
set(powerpc64_SOURCES
   ppc/gcc_qadd.c
   ppc/gcc_qdiv.c
   ppc/gcc_qmul.c
   ppc/gcc_qsub.c
   ppc/multc3.c
   ${GENERIC_SOURCES}
 )
 # These routines require __int128, which isn't supported on AIX.
-if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+if (NOT OS_NAME MATCHES "AIX")
   set(powerpc64_SOURCES
     ppc/floattitf.c
     ppc/fixtfti.c
     ppc/fixunstfti.c
     ${powerpc64_SOURCES}
   )
 endif()
 set(powerpc64le_SOURCES ${powerpc64_SOURCES})
if (CAN_TARGET_${arch})
                               DEFS ${BUILTIN_DEFS}
                               CFLAGS ${BUILTIN_CFLAGS_${arch}}
                               PARENT_TARGET builtins)
       cmake_pop_check_state()
     endif ()
   endforeach ()
 endif ()
 
+add_dependencies(compiler-rt builtins)
+
 option(COMPILER_RT_BUILD_STANDALONE_LIBATOMIC
   "Build standalone shared atomic library."
   OFF)
 
 if(COMPILER_RT_BUILD_STANDALONE_LIBATOMIC)
   add_custom_target(builtins-standalone-atomic)
   set(BUILTIN_TYPE SHARED)
-  if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+  if(OS_NAME MATCHES "AIX")
+    include(CompilerRTAIXUtils)
     if(NOT COMPILER_RT_LIBATOMIC_LINK_FLAGS)
       get_aix_libatomic_default_link_flags(COMPILER_RT_LIBATOMIC_LINK_FLAGS
         "${CMAKE_CURRENT_SOURCE_DIR}/ppc/atomic.exp")
     endif()
     # For different versions of cmake, SHARED behaves differently. For some
     # versions, we might need MODULE rather than SHARED.
     get_aix_libatomic_type(BUILTIN_TYPE)
   else()
     list(APPEND COMPILER_RT_LIBATOMIC_LINK_FLAGS -nodefaultlibs)
   endif()
   foreach (arch ${BUILTIN_SUPPORTED_ARCH})
     if(CAN_TARGET_${arch})
       add_compiler_rt_runtime(clang_rt.atomic
                               ${BUILTIN_TYPE}
                               ARCHS ${arch}
                               SOURCES atomic.c
                               LINK_FLAGS ${COMPILER_RT_LIBATOMIC_LINK_FLAGS}
                               DEPS builtins
                               PARENT_TARGET builtins-standalone-atomic)
     endif()
   endforeach()
   # FIXME: On AIX, we have to archive built shared libraries into a static
   # archive, i.e., libatomic.a. Once cmake adds support of such usage for AIX,
   # this ad-hoc part can be removed.
-  if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+  if(OS_NAME MATCHES "AIX")
     archive_aix_libatomic(clang_rt.atomic libatomic
                           ARCHS ${BUILTIN_SUPPORTED_ARCH}
                           PARENT_TARGET builtins-standalone-atomic)
   endif()
   add_dependencies(compiler-rt builtins-standalone-atomic)
 endif()
 
-add_dependencies(compiler-rt builtins)
+cmake_dependent_option(COMPILER_RT_BUILD_CRT "Build crtbegin.o/crtend.o" ON "COMPILER_RT_HAS_CRT" OFF)
+
+if(COMPILER_RT_BUILD_CRT)
+  add_compiler_rt_component(crt)
+
+  option(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY "Use eh_frame in crtbegin.o/crtend.o" ON)
+
+  include(CheckSectionExists)
+  check_section_exists(".init_array" COMPILER_RT_HAS_INITFINI_ARRAY
+    SOURCE "volatile int x;\n__attribute__((constructor)) void f(void) {x = 0;}\nint main(void) { return 0; }\n")
+
+  append_list_if(COMPILER_RT_HAS_STD_C11_FLAG -std=c11 CRT_CFLAGS)
+  append_list_if(COMPILER_RT_HAS_INITFINI_ARRAY -DCRT_HAS_INITFINI_ARRAY CRT_CFLAGS)
+  append_list_if(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY -DEH_USE_FRAME_REGISTRY CRT_CFLAGS)
+  append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC CRT_CFLAGS)
+  append_list_if(COMPILER_RT_HAS_WNO_PEDANTIC -Wno-pedantic CRT_CFLAGS)
+  if (COMPILER_RT_HAS_FCF_PROTECTION_FLAG)
+    append_list_if(COMPILER_RT_ENABLE_CET -fcf-protection=full CRT_CFLAGS)
+  endif()
+
+  foreach(arch ${BUILTIN_SUPPORTED_ARCH})
+    add_compiler_rt_runtime(clang_rt.crtbegin
+      OBJECT
+      ARCHS ${arch}
+      SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/crtbegin.c
+      CFLAGS ${CRT_CFLAGS}
+      PARENT_TARGET crt)
+    add_compiler_rt_runtime(clang_rt.crtend
+      OBJECT
+      ARCHS ${arch}
+      SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/crtend.c
+      CFLAGS ${CRT_CFLAGS}
+      PARENT_TARGET crt)
+  endforeach()
+
+  add_dependencies(compiler-rt crt)
+endif()

compiler-rt/lib/crt/CMakeLists.txt

-if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-  cmake_minimum_required(VERSION 3.20.0)
-
-  set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
-  project(CompilerRTCRT C)
-  set(COMPILER_RT_STANDALONE_BUILD TRUE)
-  set(COMPILER_RT_CRT_STANDALONE_BUILD TRUE)
-
-  set(COMPILER_RT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
-
-  set(LLVM_COMMON_CMAKE_UTILS "${COMPILER_RT_SOURCE_DIR}/../cmake")
-
-  # Add path for custom modules
-  list(INSERT CMAKE_MODULE_PATH 0
-    "${COMPILER_RT_SOURCE_DIR}/cmake"
-    "${COMPILER_RT_SOURCE_DIR}/cmake/Modules"
-    "${LLVM_COMMON_CMAKE_UTILS}"
-    "${LLVM_COMMON_CMAKE_UTILS}/Modules"
-    )
-
-  include(base-config-ix)
-  include(CompilerRTUtils)
-
-  load_llvm_config()
-  construct_compiler_rt_default_triple()
-
-  include(SetPlatformToolchainTools)
-  include(AddCompilerRT)
-endif()
-
-include(crt-config-ix)
-
-if(COMPILER_RT_HAS_CRT)
-  add_compiler_rt_component(crt)
-
-  include(CheckSectionExists)
-  check_section_exists(".init_array" COMPILER_RT_HAS_INITFINI_ARRAY
-    SOURCE "volatile int x;\n__attribute__((constructor)) void f(void) {x = 0;}\nint main(void) { return 0; }\n")
-
-  append_list_if(COMPILER_RT_HAS_STD_C11_FLAG -std=c11 CRT_CFLAGS)
-  append_list_if(COMPILER_RT_HAS_INITFINI_ARRAY -DCRT_HAS_INITFINI_ARRAY CRT_CFLAGS)
-  append_list_if(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY -DEH_USE_FRAME_REGISTRY CRT_CFLAGS)
-  append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC CRT_CFLAGS)
-  append_list_if(COMPILER_RT_HAS_WNO_PEDANTIC -Wno-pedantic CRT_CFLAGS)
-  if (COMPILER_RT_HAS_FCF_PROTECTION_FLAG)
-    append_list_if(COMPILER_RT_ENABLE_CET -fcf-protection=full CRT_CFLAGS)
-  endif()
-
-  foreach(arch ${CRT_SUPPORTED_ARCH})
-    add_compiler_rt_runtime(clang_rt.crtbegin
-      OBJECT
-      ARCHS ${arch}
-      SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/crtbegin.c
-      CFLAGS ${CRT_CFLAGS}
-      PARENT_TARGET crt)
-    add_compiler_rt_runtime(clang_rt.crtend
-      OBJECT
-      ARCHS ${arch}
-      SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/crtend.c
-      CFLAGS ${CRT_CFLAGS}
-      PARENT_TARGET crt)
-  endforeach()
-endif()

compiler-rt/test/CMakeLists.txt

if(COMPILER_RT_BUILD_MEMPROF)
     compiler_rt_test_runtime(memprof)
   endif()
   if(COMPILER_RT_BUILD_XRAY)
     compiler_rt_test_runtime(xray)
   endif()
   if(COMPILER_RT_BUILD_ORC)
     compiler_rt_Test_runtime(orc)
   endif()
-  if(COMPILER_RT_BUILD_CRT)
-    add_subdirectory(crt)
-  endif()
   # ShadowCallStack does not yet provide a runtime with compiler-rt, the tests
   # include their own minimal runtime
   add_subdirectory(shadowcallstack)
 endif()
 
 # Now that we've traversed all the directories and know all the lit testsuites,
 # introduce a rule to run to run all of them.
 add_custom_target(compiler-rt-test-depends DEPENDS ${LLVM_COMPILER_RT_LIT_DEPENDS})
 umbrella_lit_testsuite_end(check-compiler-rt)
 
 if(COMPILER_RT_STANDALONE_BUILD)
   if(NOT TARGET check-all)
     add_custom_target(check-all)
   endif()
   add_dependencies(check-all check-compiler-rt)
 endif()

compiler-rt/test/builtins/CMakeLists.txt

 set(BUILTINS_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(BUILTINS_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS} builtins)
 set(BUILTINS_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/TestCases)
 
 # Test cases.
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
 )
 
 #Unit tests.
 
 include(builtin-config-ix)
 
+if (COMPILER_RT_HAS_CRT)
+  list(APPEND BUILTINS_TEST_DEPS crt)
+endif()
+
 # Indicate if this is an MSVC environment.
 pythonize_bool(MSVC)
 
 # Indicate if the compiler for the builtins library was MSVC. If the builtins
 # compiler was clang-cl, we will enable some features that the host compiler
 # will not, like C99 _Complex and int128.
 set(BUILTINS_IS_MSVC OFF)
 if (MSVC AND NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang")

compiler-rt/test/builtins/Unit/ctor_dtor.c

+// REQUIRES: linux
+
 // RUN: %clang -fno-use-init-array -g -c %s -o %t.o
 // RUN: %clang -o %t -no-pie -nostdlib %crt1 %crti %crtbegin %t.o -lc %libgcc %crtend %crtn
 // RUN: %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
 
 // Ensure the various startup functions are called in the proper order.

compiler-rt/test/builtins/Unit/dso_handle.cpp

-// RUN: %clangxx -g -DCRT_SHARED -c %s -fPIC -o %tshared.o
-// RUN: %clangxx -g -c %s -fPIC -o %t.o
+// REQUIRES: linux
+
+// RUN: %clangxx -g -fno-exceptions -DCRT_SHARED -c %s -fPIC -o %tshared.o
+// RUN: %clangxx -g -fno-exceptions -c %s -fPIC -o %t.o
 // RUN: %clangxx -g -shared -o %t.so -nostdlib %crti %crtbegin %tshared.o %libstdcxx -lc -lm %libgcc %crtend %crtn
 // RUN: %clangxx -g -o %t -fno-pic -no-pie -nostdlib %crt1 %crti %crtbegin %t.o %libstdcxx -lc -lm %libgcc %t.so %crtend %crtn
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // UNSUPPORTED: target={{(arm|aarch64).*}}
 
 #include <stdio.h>
 

compiler-rt/test/builtins/Unit/lit.cfg.py

 # -*- Python -*-
 
 import os
 import platform
+import shlex
+import subprocess
 
 import lit.formats
 
 # Choose between lit's internal shell pipeline runner and a real shell.  If
 # LIT_USE_INTERNAL_SHELL is in the environment, we use that as an override.
 use_lit_shell = os.environ.get("LIT_USE_INTERNAL_SHELL")
 if use_lit_shell:
     # 0 is external, "" is default, and everything else is internal.
if attr_value == None:
         lit_config.fatal(
             "No attribute %r in test configuration! You may need to run "
             "tests from your build directory or add this attribute "
             "to lit.site.cfg.py " % attr_name
         )
     return attr_value
 
 
+def get_library_path(file):
+    cmd = subprocess.Popen(
+        [config.clang.strip(), "-print-file-name=%s" % file]
+        + shlex.split(config.target_cflags),
+        stdout=subprocess.PIPE,
+        env=config.environment,
+        universal_newlines=True,
+    )
+    if not cmd.stdout:
+        lit_config.fatal("Couldn't find the library path for '%s'" % file)
+    dir = cmd.stdout.read().strip()
+    if sys.platform in ["win32"] and execute_external:
+        # Don't pass dosish path separator to msys bash.exe.
+        dir = dir.replace("\\", "/")
+    return dir
+
+
+def get_libgcc_file_name():
+    cmd = subprocess.Popen(
+        [config.clang.strip(), "-print-libgcc-file-name"]
+        + shlex.split(config.target_cflags),
+        stdout=subprocess.PIPE,
+        env=config.environment,
+        universal_newlines=True,
+    )
+    if not cmd.stdout:
+        lit_config.fatal("Couldn't find the library path for '%s'" % file)
+    dir = cmd.stdout.read().strip()
+    if sys.platform in ["win32"] and execute_external:
+        # Don't pass dosish path separator to msys bash.exe.
+        dir = dir.replace("\\", "/")
+    return dir
+
+
 # Setup config name.
 config.name = "Builtins" + config.name_suffix
 
 # Platform-specific default Builtins_OPTIONS for lit tests.
 default_builtins_opts = ""
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
else:
     base_lib = os.path.join(
         config.compiler_rt_libdir, "libclang_rt.builtins%s.a" % config.target_suffix
     )
     if sys.platform in ["win32"] and execute_external:
         # Don't pass dosish path separator to msys bash.exe.
         base_lib = base_lib.replace("\\", "/")
     config.substitutions.append(("%librt ", base_lib + " -lc -lm "))
 
+    if config.host_os == "Linux":
+        base_obj = os.path.join(
+            config.compiler_rt_libdir, "clang_rt.%%s%s.o" % config.target_suffix
+        )
+        if sys.platform in ["win32"] and execute_external:
+            # Don't pass dosish path separator to msys bash.exe.
+            base_obj = base_obj.replace("\\", "/")
+
+        config.substitutions.append(("%crtbegin", base_obj % "crtbegin"))
+        config.substitutions.append(("%crtend", base_obj % "crtend"))
+
+        config.substitutions.append(("%crt1", get_library_path("crt1.o")))
+        config.substitutions.append(("%crti", get_library_path("crti.o")))
+        config.substitutions.append(("%crtn", get_library_path("crtn.o")))
+
+        config.substitutions.append(("%libgcc", get_libgcc_file_name()))
+
+        config.substitutions.append(
+            ("%libstdcxx", "-l" + config.sanitizer_cxx_lib.lstrip("lib"))
+        )
+
 builtins_source_dir = os.path.join(
     get_required_attr(config, "compiler_rt_src_root"), "lib", "builtins"
 )
 if sys.platform in ["win32"] and execute_external:
     # Don't pass dosish path separator to msys bash.exe.
     builtins_source_dir = builtins_source_dir.replace("\\", "/")
 builtins_lit_source_dir = get_required_attr(config, "builtins_lit_source_dir")
 

compiler-rt/test/builtins/Unit/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.name_suffix = "@BUILTINS_TEST_CONFIG_SUFFIX@"
 config.builtins_lit_source_dir = "@BUILTINS_LIT_SOURCE_DIR@/Unit"
 config.target_cflags = "@BUILTINS_TEST_TARGET_CFLAGS@"
 config.target_arch = "@BUILTINS_TEST_TARGET_ARCH@"
+config.sanitizer_cxx_lib = "@SANITIZER_TEST_CXX_LIBNAME@"
 config.is_msvc = @MSVC_PYBOOL@
 config.builtins_is_msvc = @BUILTINS_IS_MSVC_PYBOOL@
 config.builtins_lit_source_features = "@BUILTINS_LIT_SOURCE_FEATURES@"
 config.test_suite_supports_overriding_runtime_lib_path = True
 
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@BUILTINS_LIT_SOURCE_DIR@/Unit/lit.cfg.py")

compiler-rt/test/crt/CMakeLists.txt

-include(crt-config-ix)
-
-if (COMPILER_RT_HAS_CRT)
-  set(CRT_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-
-  if(NOT COMPILER_RT_STANDALONE_BUILD)
-    list(APPEND CRT_TEST_DEPS crt)
-  endif()
-  if(NOT COMPILER_RT_STANDALONE_BUILD AND NOT LLVM_RUNTIMES_BUILD)
-    # Use LLVM utils and Clang from the same build tree.
-    list(APPEND CRT_TEST_DEPS
-      clang clang-resource-headers FileCheck not llvm-config)
-  endif()
-
-  set(CRT_TEST_ARCH ${CRT_SUPPORTED_ARCH})
-  foreach(arch ${CRT_TEST_ARCH})
-    set(CRT_TEST_TARGET_ARCH ${arch})
-    string(TOLOWER "-${arch}-${OS_NAME}" CRT_TEST_CONFIG_SUFFIX)
-    get_test_cc_for_arch(${arch} CRT_TEST_TARGET_CC CRT_TEST_TARGET_CFLAGS)
-    string(TOUPPER ${arch} ARCH_UPPER_CASE)
-    set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
-
-    if (COMPILER_RT_ENABLE_CET)
-      if (${arch} MATCHES "i386|x86_64")
-        list(APPEND CRT_TEST_TARGET_CFLAGS -fcf-protection=full)
-        string(REPLACE ";" " " CRT_TEST_TARGET_CFLAGS "${CRT_TEST_TARGET_CFLAGS}")
-      else()
-        message(FATAL_ERROR "The target arch ${arch} doesn't support CET")
-      endif()
-    endif()
-    configure_lit_site_cfg(
-      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
-      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
-    list(APPEND CRT_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
-  endforeach()
-
-  add_lit_testsuite(check-crt "Running the CRT tests"
-    ${CRT_TESTSUITES}
-    DEPENDS ${CRT_TEST_DEPS})
-  set_target_properties(check-crt PROPERTIES FOLDER "Compiler-RT Misc")
-endif()

compiler-rt/test/crt/lit.cfg.py

-# -*- Python -*-
-
-import os
-import subprocess
-import shlex
-
-# Setup config name.
-config.name = "CRT" + config.name_suffix
-
-# Setup source root.
-config.test_source_root = os.path.dirname(__file__)
-
-
-# Choose between lit's internal shell pipeline runner and a real shell.  If
-# LIT_USE_INTERNAL_SHELL is in the environment, we use that as an override.
-use_lit_shell = os.environ.get("LIT_USE_INTERNAL_SHELL")
-if use_lit_shell:
-    # 0 is external, "" is default, and everything else is internal.
-    execute_external = use_lit_shell == "0"
-else:
-    # Otherwise we default to internal on Windows and external elsewhere, as
-    # bash on Windows is usually very slow.
-    execute_external = not sys.platform in ["win32"]
-
-
-def get_library_path(file):
-    cmd = subprocess.Popen(
-        [config.clang.strip(), "-print-file-name=%s" % file]
-        + shlex.split(config.target_cflags),
-        stdout=subprocess.PIPE,
-        env=config.environment,
-        universal_newlines=True,
-    )
-    if not cmd.stdout:
-        lit_config.fatal("Couldn't find the library path for '%s'" % file)
-    dir = cmd.stdout.read().strip()
-    if sys.platform in ["win32"] and execute_external:
-        # Don't pass dosish path separator to msys bash.exe.
-        dir = dir.replace("\\", "/")
-    return dir
-
-
-def get_libgcc_file_name():
-    cmd = subprocess.Popen(
-        [config.clang.strip(), "-print-libgcc-file-name"]
-        + shlex.split(config.target_cflags),
-        stdout=subprocess.PIPE,
-        env=config.environment,
-        universal_newlines=True,
-    )
-    if not cmd.stdout:
-        lit_config.fatal("Couldn't find the library path for '%s'" % file)
-    dir = cmd.stdout.read().strip()
-    if sys.platform in ["win32"] and execute_external:
-        # Don't pass dosish path separator to msys bash.exe.
-        dir = dir.replace("\\", "/")
-    return dir
-
-
-def build_invocation(compile_flags):
-    return " " + " ".join([config.clang] + compile_flags) + " "
-
-
-# Setup substitutions.
-config.substitutions.append(("%clang ", build_invocation([config.target_cflags])))
-config.substitutions.append(
-    ("%clangxx ", build_invocation(config.cxx_mode_flags + [config.target_cflags]))
-)
-
-base_lib = os.path.join(
-    config.compiler_rt_libdir, "clang_rt.%%s%s.o" % config.target_suffix
-)
-
-if sys.platform in ["win32"] and execute_external:
-    # Don't pass dosish path separator to msys bash.exe.
-    base_lib = base_lib.replace("\\", "/")
-
-config.substitutions.append(("%crtbegin", base_lib % "crtbegin"))
-config.substitutions.append(("%crtend", base_lib % "crtend"))
-
-config.substitutions.append(("%crt1", get_library_path("crt1.o")))
-config.substitutions.append(("%crti", get_library_path("crti.o")))
-config.substitutions.append(("%crtn", get_library_path("crtn.o")))
-
-config.substitutions.append(("%libgcc", get_libgcc_file_name()))
-
-config.substitutions.append(
-    ("%libstdcxx", "-l" + config.sanitizer_cxx_lib.lstrip("lib"))
-)
-
-# Default test suffixes.
-config.suffixes = [".c", ".cpp"]
-
-if config.host_os not in ["Linux"]:
-    config.unsupported = True

compiler-rt/test/crt/lit.site.cfg.py.in

-@LIT_SITE_CFG_IN_HEADER@
-
-# Tool-specific config options.
-config.name_suffix = "@CRT_TEST_CONFIG_SUFFIX@"
-config.crt_lit_source_dir = "@CRT_LIT_SOURCE_DIR@"
-config.target_cflags = "@CRT_TEST_TARGET_CFLAGS@"
-config.target_arch = "@CRT_TEST_TARGET_ARCH@"
-config.sanitizer_cxx_lib = "@SANITIZER_TEST_CXX_LIBNAME@"
-
-# Load common config for all compiler-rt lit tests
-lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
-
-# Load tool-specific config that would do the real work.
-lit_config.load_config(config, "@CRT_LIT_SOURCE_DIR@/lit.cfg.py")