[compiler-rt] Split the builtins CMake build to a separate file

[phosek]

Summary

When building builtins separately as part of the runtime build, we
also want to include crt. To enable that, move the builtins CMake
build into a separate file: compiler-rt/builtins/CMakeLists.txt,
which includes both builtins and crt.

[phosek]

I assume that builtins and crt would be eventually moved to their own top-level directory (e.g. builtins or just compiler-rt) separate from sanitizers at which point this new CMakeLists.txt would become the root of that directory.

[mstorsjo]

If I read this correctly, this would break existing setups that build builtins only, by pointing cmake to compiler-rt/lib/builtins? Is it possible to handle the transition more gracefully?

[phosek]

In D70744#1760792, @mstorsjo wrote:

If I read this correctly, this would break existing setups that build builtins only, by pointing cmake to compiler-rt/lib/builtins? Is it possible to handle the transition more gracefully?

Done

[phosek]

Ping?

[smeenai]

LGTM

[daltenty]

compiler-rt/builtins/CMakeLists.txt

29

just an fyi, looks like there are some minor changes, such as those from D87113, that need to be merged here.

[daltenty]

LGTM, this should still be good to land (with just the minor updates)

[hubert.reinterpretcast]

compiler-rt/builtins/CMakeLists.txt

6

Minor nit: The version bump to 3.13.4 should be reflected here too.

[daltenty]

Just a note on status: This patch is potentially being replaced by https://reviews.llvm.org/D89492

compiler-rt/builtins/CMakeLists.txt

+# CMake build for CompilerRT builtins.
+#
+# This includes just builtins and crtbegin/crtend.
+
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+cmake_minimum_required(VERSION 3.4.3)
+project(CompilerRTBuiltins C ASM)
+endif()
+
+list(INSERT CMAKE_MODULE_PATH 0
+  "${CMAKE_CURRENT_LIST_DIR}/../cmake"
+  "${CMAKE_CURRENT_LIST_DIR}/../cmake/Modules")
+
+set(COMPILER_RT_STANDALONE_BUILD TRUE)
+set(COMPILER_RT_BUILTINS_STANDALONE_BUILD TRUE)
+include(base-config-ix)
+include(CompilerRTUtils)
+
+load_llvm_config()
+construct_compiler_rt_default_triple()
+
+if(APPLE)
+  include(CompilerRTDarwinUtils)
+endif()
+if(CMAKE_HOST_APPLE AND APPLE)
+  include(UseLibtool)
+endif()
+
+include(AddCompilerRT)
+
+option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON)
+mark_as_advanced(COMPILER_RT_BUILD_BUILTINS)
+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)
+
+include(builtin-config-ix)
+
+if(COMPILER_RT_BUILD_BUILTINS)
+  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../lib/builtins lib/builtins)
+endif()
+if(COMPILER_RT_BUILD_CRT AND COMPILER_RT_HAS_CRT)
+  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../lib/crt lib/crt)
+endif()

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;
 }
 ")

 if(APPLE)
   set(ARM64 arm64)
   set(ARM32 armv7 armv7k armv7s)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_BUILTIN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${HEXAGON} ${MIPS32} ${MIPS64} ${PPC64} ${RISCV32} ${RISCV64} ${SPARC} ${SPARCV9} ${WASM32} ${WASM64})
+set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV32} ${RISCV64})
+
+if(ANDROID)
+  set(OS_NAME "Android")
+else()
+  set(OS_NAME "${CMAKE_SYSTEM_NAME}")
+endif()
 
 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}")

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")
-  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/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.4.3)
-
   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)
+  message(WARNING "Using this directory as top-level for build is deprecated, please use compiler-rt/builtins directory instead")
+  if(NOT __BUILTINS_PROCESSED__)
+    set(__BUILTINS_PROCESSED__ TRUE)
+    include(../../builtins/CMakeLists.txt)
+    return()
   endif()
-  if(CMAKE_HOST_APPLE AND APPLE)
-    include(UseLibtool)
-  endif()
-  include(AddCompilerRT)
-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
   absvsi2.c
   absvti2.c
   adddf3.c

llvm/runtimes/CMakeLists.txt

else() # if this is included from LLVM's CMake
   if(NOT LLVM_BUILD_RUNTIMES)
     set(EXTRA_ARGS EXCLUDE_FROM_ALL)
   endif()
 
   function(builtin_default_target compiler_rt_path)
     cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
 
     llvm_ExternalProject_Add(builtins
-                             ${compiler_rt_path}/lib/builtins
+                             ${compiler_rt_path}/builtins
                              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
foreach(variableName ${variableNames})
       string(FIND "${variableName}" "BUILTINS_${target}" out)
       if("${out}" EQUAL 0)
         string(REPLACE "BUILTINS_${target}_" "" new_name ${variableName})
         list(APPEND ${target}_extra_args "-D${new_name}=${${variableName}}")
       endif()
     endforeach()
 
     llvm_ExternalProject_Add(builtins-${target}
-                             ${compiler_rt_path}/lib/builtins
+                             ${compiler_rt_path}/builtins
                              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_ASM_COMPILER_TARGET=${target}
                                         -DCMAKE_C_COMPILER_WORKS=ON