[CMake][compiler-rt] Make CRT separately buildable

[phosek]

Summary

This is useful when building a complete toolchain to ensure that CRT
is built after builtins but before the rest of the compiler-rt.

[phosek]

This was split from D89492. I plan on doing some addition cleanup in subsequent changes to reduce some of the duplication around project setup.

[kaz7]

Thank you. For the case of VE, this works fine as

$ mkdir build-crt
$ cd build-crt
$ cmake -G Ninja ../llvm-project/compiler-rt/lib/crt
$ ninja install

[kaz7]

LGTM.

[phosek]

This appears to have broken the VE bot.

[simoll]

Try relanding. I've updated llvm-zorg: commit 4b6aa0f2f4a8 "[ve] fix target triple"

[shchenz]

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

30

I know this was reverted. One question, do we need to include PPC32/PPC64/HEXAGON here? I see the legacy ALL_CRT_SUPPORTED_ARCH defined in compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake has these three archs. Thanks

[kaz7]

@simoll , thank you for fixing the VE bot problem. This should work fine now.

[q66]

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

30

indeed, i believe this will break ppc* builds

[phosek]

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

30

Thanks for catching this!

[MarcusJohnson91]

Hey man, I think you introduced a bug, when compiling compiler-rt as part of LLVM cmake is reconfigued and cached variables are deleted.

it changes the compiler to the freshly built version of clang, that in my case is buggy and it leads to the rest of llvm failing to compile.

more info: https://github.com/llvm/llvm-project/issues/54903

[mnadeem]

Seeing this cmake error for ARM32 after this patch.

--Supported architectures for crt: arm;armv6m
CMake Error: Attempt to add a custom rule to output ".../compiler-rt/arm32/linux/lib/linux/clang_rt.crtbegin-arm.o.rule" which already has a custom rule.
CMake Error: Attempt to add a custom rule to output ".../compiler-rt/arm32/linux/lib/linux/clang_rt.crtend-arm.o.rule" which already has a custom rule.

https://github.com/llvm/llvm-project/issues/55046

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

if(APPLE)
   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}
     ${HEXAGON})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9} ${HEXAGON})
-set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC32}
-    ${PPC64} ${RISCV32} ${RISCV64} ${VE} ${HEXAGON})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 

compiler-rt/cmake/Modules/CheckSectionExists.cmake

-add_compiler_rt_component(crt)
-
-function(check_cxx_section_exists section output)
+function(check_section_exists section output)
   cmake_parse_arguments(ARG "" "" "SOURCE;FLAGS" ${ARGN})
   if(NOT ARG_SOURCE)
     set(ARG_SOURCE "int main() { return 0; }\n")
   endif()
 
   string(RANDOM TARGET_NAME)
   set(TARGET_NAME "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cmTC_${TARGET_NAME}.dir")
   file(MAKE_DIRECTORY ${TARGET_NAME})
function(check_section_exists section output)
   if(NOT SECTION_FOUND EQUAL -1)
     set(${output} TRUE PARENT_SCOPE)
   else()
     set(${output} FALSE PARENT_SCOPE)
   endif()
 
   file(REMOVE_RECURSE ${TARGET_NAME})
 endfunction()
-
-check_cxx_section_exists(".init_array" COMPILER_RT_HAS_INITFINI_ARRAY
-  SOURCE "volatile int x;\n__attribute__((constructor)) void f() {x = 0;}\nint main() { 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()

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

function(get_compiler_rt_root_source_dir ROOT_DIR_VAR)
 
   # Compiler-rt supports different source root paths.
   # Handle each case here.
   set(PATH_TO_COMPILER_RT_SOURCE_ROOT "")
   if (DEFINED CompilerRTBuiltins_SOURCE_DIR)
     # Compiler-RT Builtins standalone build.
     # `llvm-project/compiler-rt/lib/builtins`
     set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CompilerRTBuiltins_SOURCE_DIR}/../../")
+  elseif (DEFINED CompilerRTCRT_SOURCE_DIR)
+    # Compiler-RT CRT standalone build.
+    # `llvm-project/compiler-rt/lib/crt`
+    set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CompilerRTCRT_SOURCE_DIR}/../../")
   elseif(DEFINED CompilerRT_SOURCE_DIR)
     # Compiler-RT standalone build.
     # `llvm-project/compiler-rt`
     set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CompilerRT_SOURCE_DIR}")
   elseif (EXISTS "${CMAKE_SOURCE_DIR}/../compiler-rt")
     # In tree build with LLVM as the root project.
     # See `llvm-project/projects/`.
     # Assumes monorepo layout.

compiler-rt/cmake/config-ix.cmake

if(APPLE)
   list_intersect(SHADOWCALLSTACK_SUPPORTED_ARCH
     ALL_SHADOWCALLSTACK_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(ORC_SUPPORTED_ARCH
     ALL_ORC_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)
-  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)
 else()
   set(COMPILER_RT_HAS_DFSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND

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

+include(BuiltinTests)
+include(CheckCSourceCompiles)
+
+# Make all the tests only check the compiler
+set(TEST_COMPILE_ONLY On)
+
+builtin_check_c_compiler_flag(-fPIC                 COMPILER_RT_HAS_FPIC_FLAG)
+builtin_check_c_compiler_flag(-std=c11              COMPILER_RT_HAS_STD_C11_FLAG)
+builtin_check_c_compiler_flag(-Wno-pedantic         COMPILER_RT_HAS_WNO_PEDANTIC)
+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)
+
+if(ANDROID)
+  set(OS_NAME "Android")
+else()
+  set(OS_NAME "${CMAKE_SYSTEM_NAME}")
+endif()
+
+set(ARM64 aarch64)
+set(ARM32 arm armhf armv6m armv7m armv7em armv7 armv7s armv7k)
+set(X86 i386)
+set(X86_64 x86_64)
+set(RISCV32 riscv32)
+set(RISCV64 riscv64)
+set(VE ve)
+
+set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC32}
+    ${PPC64} ${RISCV32} ${RISCV64} ${VE} ${HEXAGON})
+
+include(CompilerRTUtils)
+
+if(NOT APPLE)
+  if(COMPILER_RT_CRT_STANDALONE_BUILD)
+    test_targets()
+  endif()
+  # Architectures supported by compiler-rt crt library.
+  filter_available_targets(CRT_SUPPORTED_ARCH ${ALL_CRT_SUPPORTED_ARCH})
+  message(STATUS "Supported architectures for crt: ${CRT_SUPPORTED_ARCH}")
+endif()
+
+if (CRT_SUPPORTED_ARCH AND OS_NAME MATCHES "Linux" AND NOT LLVM_USE_SANITIZER)
+  set(COMPILER_RT_HAS_CRT TRUE)
+else()
+  set(COMPILER_RT_HAS_CRT FALSE)
+endif()

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 AND COMPILER_RT_HAS_CRT)
+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})
     add_subdirectory(${runtime})
     if(${runtime} STREQUAL tsan)

compiler-rt/lib/crt/CMakeLists.txt

-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()
-
-  string(RANDOM TARGET_NAME)
-  set(TARGET_NAME "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cmTC_${TARGET_NAME}.dir")
-  file(MAKE_DIRECTORY ${TARGET_NAME})
-
-  file(WRITE "${TARGET_NAME}/CheckSectionExists.c" "${ARG_SOURCE}\n")
-
-  string(REGEX MATCHALL "<[A-Za-z0-9_]*>" substitutions
-         ${CMAKE_C_COMPILE_OBJECT})
-
-  set(try_compile_flags "${ARG_FLAGS}")
-  if(CMAKE_C_COMPILER_ID MATCHES Clang AND CMAKE_C_COMPILER_TARGET)
-    list(APPEND try_compile_flags "-target ${CMAKE_C_COMPILER_TARGET}")
-  endif()
-  append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto try_compile_flags)
-  if(NOT COMPILER_RT_ENABLE_PGO)
-    if(LLVM_PROFDATA_FILE AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_FLAG)
-      list(APPEND try_compile_flags "-fno-profile-instr-use")
-    endif()
-    if(LLVM_BUILD_INSTRUMENTED MATCHES IR AND COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG)
-      list(APPEND try_compile_flags "-fno-profile-generate")
-    elseif((LLVM_BUILD_INSTRUMENTED OR LLVM_BUILD_INSTRUMENTED_COVERAGE) AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG)
-      list(APPEND try_compile_flags "-fno-profile-instr-generate")
-      if(LLVM_BUILD_INSTRUMENTED_COVERAGE AND COMPILER_RT_HAS_FNO_COVERAGE_MAPPING_FLAG)
-        list(APPEND try_compile_flags "-fno-coverage-mapping")
-      endif()
-    endif()
-  endif()
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  cmake_minimum_required(VERSION 3.13.4)
 
-  string(REPLACE ";" " " extra_flags "${try_compile_flags}")
-
-  set(test_compile_command "${CMAKE_C_COMPILE_OBJECT}")
-  foreach(substitution ${substitutions})
-    if(substitution STREQUAL "<CMAKE_C_COMPILER>")
-      string(REPLACE "<CMAKE_C_COMPILER>" "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"
-             test_compile_command ${test_compile_command})
-    elseif(substitution STREQUAL "<OBJECT>")
-      string(REPLACE "<OBJECT>" "${TARGET_NAME}/CheckSectionExists.o"
-             test_compile_command ${test_compile_command})
-    elseif(substitution STREQUAL "<SOURCE>")
-      string(REPLACE "<SOURCE>" "${TARGET_NAME}/CheckSectionExists.c"
-             test_compile_command ${test_compile_command})
-    elseif(substitution STREQUAL "<FLAGS>")
-      string(REPLACE "<FLAGS>" "${CMAKE_C_FLAGS} ${extra_flags}"
-             test_compile_command ${test_compile_command})
-    else()
-      string(REPLACE "${substitution}" "" test_compile_command
-             ${test_compile_command})
-    endif()
-  endforeach()
-
-  # Strip quotes from the compile command, as the compiler is not expecting
-  # quoted arguments (potential quotes added from D62063).
-  string(REPLACE "\"" "" test_compile_command "${test_compile_command}")
-
-  string(REPLACE " " ";" test_compile_command "${test_compile_command}")
-
-  execute_process(
-    COMMAND ${test_compile_command}
-    RESULT_VARIABLE TEST_RESULT
-    OUTPUT_VARIABLE TEST_OUTPUT
-    ERROR_VARIABLE TEST_ERROR
+  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"
     )
 
-  # Explicitly throw a fatal error message if test_compile_command fails.
-  if(TEST_RESULT)
-    message(FATAL_ERROR "${TEST_ERROR}")
-    return()
-  endif()
+  include(base-config-ix)
+  include(CompilerRTUtils)
 
-  execute_process(
-    COMMAND ${CMAKE_OBJDUMP} -h "${TARGET_NAME}/CheckSectionExists.o"
-    RESULT_VARIABLE CHECK_RESULT
-    OUTPUT_VARIABLE CHECK_OUTPUT
-    ERROR_VARIABLE CHECK_ERROR
-  )
-  string(FIND "${CHECK_OUTPUT}" "${section}" SECTION_FOUND)
+  load_llvm_config()
+  construct_compiler_rt_default_triple()
 
-  if(NOT SECTION_FOUND EQUAL -1)
-    set(${output} TRUE PARENT_SCOPE)
-  else()
-    set(${output} FALSE PARENT_SCOPE)
-  endif()
+  include(SetPlatformToolchainTools)
+  include(AddCompilerRT)
 
-  file(REMOVE_RECURSE ${TARGET_NAME})
-endfunction()
+include(crt-config-ix)
+
+if(COMPILER_RT_HAS_CRT)
+  add_compiler_rt_component(crt)
 
-check_cxx_section_exists(".init_array" COMPILER_RT_HAS_INITFINI_ARRAY
+  include(CheckSectionExists)
+  check_section_exists(".init_array" COMPILER_RT_HAS_INITFINI_ARRAY
     SOURCE "volatile int x;\n__attribute__((constructor)) void f() {x = 0;}\nint main() { 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 AND COMPILER_RT_HAS_CRT)
+  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()
 
 if(COMPILER_RT_STANDALONE_BUILD)

compiler-rt/test/crt/CMakeLists.txt

+include(crt-config-ix)
+
 set(CRT_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(CRT_TESTSUITES)
 
 set(CRT_TEST_DEPS)
 if(NOT COMPILER_RT_STANDALONE_BUILD)
   list(APPEND CRT_TEST_DEPS crt)
 endif()