compiler-rt/CMakeLists.txt

   1 # CMake build for CompilerRT.
   2 #
   3 # An important constraint of the build is that it only produces libraries
   4 # based on the ability of the host toolchain to target various platforms.
   5
   6 cmake_minimum_required(VERSION 3.20.0)
   7 set(LLVM_SUBPROJECT_TITLE "Compiler-RT")
   8
   9 if(NOT DEFINED LLVM_COMMON_CMAKE_UTILS)
  10   set(LLVM_COMMON_CMAKE_UTILS ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
  11 endif()
  12 include(${LLVM_COMMON_CMAKE_UTILS}/Modules/CMakePolicy.cmake
  13   NO_POLICY_SCOPE)
  14
  15 # TODO(CMake 3.22): remove
  16 if(POLICY CMP0128)
  17   cmake_policy(SET CMP0128 NEW)
  18 endif()
  19
  20 # Check if compiler-rt is built as a standalone project.
  21 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR OR COMPILER_RT_STANDALONE_BUILD)
  22   project(CompilerRT C CXX ASM)
  23   set(COMPILER_RT_STANDALONE_BUILD TRUE)
  24   set_property(GLOBAL PROPERTY USE_FOLDERS ON)
  25 endif()
  26
  27 # Add path for custom compiler-rt modules.
  28 list(INSERT CMAKE_MODULE_PATH 0
  29   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
  30   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
  31   "${LLVM_COMMON_CMAKE_UTILS}"
  32   "${LLVM_COMMON_CMAKE_UTILS}/Modules"
  33   )
  34
  35 if(CMAKE_CONFIGURATION_TYPES)
  36   set(CMAKE_CFG_RESOLVED_INTDIR "${CMAKE_CFG_INTDIR}/")
  37 else()
  38   set(CMAKE_CFG_RESOLVED_INTDIR "")
  39 endif()
  40
  41 include(SetPlatformToolchainTools)
  42 include(base-config-ix)
  43 include(CompilerRTUtils)
  44 include(CMakeDependentOption)
  45 include(GetDarwinLinkerVersion)
  46
  47 include(CheckCXXCompilerFlag)
  48
  49 # Check if we can compile with --no-default-config, or if that omits a config
  50 # file that is essential for the toolchain to work properly.
  51 #
  52 # Using CMAKE_REQUIRED_FLAGS to make sure the flag is used both for compilation
  53 # and for linking.
  54 #
  55 # Doing this test early on, to see if the flag works on the toolchain
  56 # out of the box. Later on, we end up adding -nostdlib and similar flags
  57 # to all test compiles, which easily can give false positives on this test.
  58 set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
  59 set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} --no-default-config")
  60 check_cxx_compiler_flag("" COMPILER_RT_HAS_NO_DEFAULT_CONFIG_FLAG)
  61 set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
  62
  63 option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON)
  64 mark_as_advanced(COMPILER_RT_BUILD_BUILTINS)
  65 option(COMPILER_RT_DISABLE_AARCH64_FMV "Disable AArch64 Function Multi Versioning support" OFF)
  66 mark_as_advanced(COMPILER_RT_DISABLE_AARCH64_FMV)
  67 option(COMPILER_RT_BUILD_SANITIZERS "Build sanitizers" ON)
  68 mark_as_advanced(COMPILER_RT_BUILD_SANITIZERS)
  69 option(COMPILER_RT_BUILD_XRAY "Build xray" ON)
  70 mark_as_advanced(COMPILER_RT_BUILD_XRAY)
  71 option(COMPILER_RT_BUILD_LIBFUZZER "Build libFuzzer" ON)
  72 mark_as_advanced(COMPILER_RT_BUILD_LIBFUZZER)
  73 option(COMPILER_RT_BUILD_PROFILE "Build profile runtime" ON)
  74 mark_as_advanced(COMPILER_RT_BUILD_PROFILE)
  75 option(COMPILER_RT_BUILD_CTX_PROFILE "Build ctx profile runtime" ON)
  76 mark_as_advanced(COMPILER_RT_BUILD_CTX_PROFILE)
  77 option(COMPILER_RT_BUILD_MEMPROF "Build memory profiling runtime" ON)
  78 mark_as_advanced(COMPILER_RT_BUILD_MEMPROF)
  79 option(COMPILER_RT_BUILD_XRAY_NO_PREINIT "Build xray with no preinit patching" OFF)
  80 mark_as_advanced(COMPILER_RT_BUILD_XRAY_NO_PREINIT)
  81 option(COMPILER_RT_BUILD_ORC "Build ORC runtime" ON)
  82 mark_as_advanced(COMPILER_RT_BUILD_ORC)
  83 option(COMPILER_RT_BUILD_GWP_ASAN "Build GWP-ASan, and link it into SCUDO" ON)
  84 mark_as_advanced(COMPILER_RT_BUILD_GWP_ASAN)
  85 option(COMPILER_RT_ENABLE_CET "Build Compiler RT with CET enabled" OFF)
  86
  87 option(COMPILER_RT_SCUDO_STANDALONE_SYSROOT_PATH "Set custom sysroot for building SCUDO standalone" OFF)
  88 mark_as_advanced(COMPILER_RT_SCUDO_STANDALONE_SYSROOT_PATH)
  89 option(COMPILER_RT_SCUDO_STANDALONE_BUILD_SHARED "Build SCUDO standalone for shared libraries" ON)
  90 mark_as_advanced(COMPILER_RT_SCUDO_STANDALONE_BUILD_SHARED)
  91 option(COMPILER_RT_BUILD_SCUDO_STANDALONE_WITH_LLVM_LIBC "Build SCUDO standalone with LLVM's libc headers" OFF)
  92 mark_as_advanced(COMPILER_RT_BUILD_SCUDO_STANDALONE_WITH_LLVM_LIBC)
  93
  94 if(FUCHSIA)
  95   set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS_DEFAULT OFF)
  96 else()
  97   set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS_DEFAULT ON)
  98 endif()
  99 set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS ${COMPILER_RT_HWASAN_WITH_INTERCEPTORS_DEFAULT} CACHE BOOL "Enable libc interceptors in HWASan (testing mode)")
 100
 101 set(COMPILER_RT_BAREMETAL_BUILD OFF CACHE BOOL
 102   "Build for a bare-metal target.")
 103
 104 if (COMPILER_RT_STANDALONE_BUILD)
 105   set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to conform to")
 106   set(CMAKE_CXX_STANDARD_REQUIRED YES)
 107   set(CMAKE_CXX_EXTENSIONS NO)
 108
 109   if (NOT LLVM_RUNTIMES_BUILD)
 110     load_llvm_config()
 111   endif()
 112   if (TARGET intrinsics_gen)
 113     # Loading the llvm config causes this target to be imported so place it
 114     # under the appropriate folder in an IDE.
 115     set_target_properties(intrinsics_gen PROPERTIES FOLDER "LLVM/Tablegenning")
 116   endif()
 117
 118   find_package(Python3 COMPONENTS Interpreter)
 119   if(NOT Python3_Interpreter_FOUND)
 120     message(WARNING "Python3 not found, using python2 as a fallback")
 121     find_package(Python2 COMPONENTS Interpreter REQUIRED)
 122     if(Python2_VERSION VERSION_LESS 2.7)
 123       message(SEND_ERROR "Python 2.7 or newer is required")
 124     endif()
 125
 126     # Treat python2 as python3
 127     add_executable(Python3::Interpreter IMPORTED)
 128     set_target_properties(Python3::Interpreter PROPERTIES
 129       IMPORTED_LOCATION ${Python2_EXECUTABLE})
 130     set(Python3_EXECUTABLE ${Python2_EXECUTABLE})
 131   endif()
 132
 133   # Ensure that fat libraries are built correctly on Darwin
 134   if(APPLE)
 135     include(UseLibtool)
 136   endif()
 137
 138   # Define default arguments to lit.
 139   set(LIT_ARGS_DEFAULT "-sv")
 140   if (MSVC OR XCODE)
 141     set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
 142   endif()
 143   set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
 144   set(LLVM_LIT_OUTPUT_DIR "${COMPILER_RT_EXEC_OUTPUT_DIR}")
 145 endif()
 146
 147 construct_compiler_rt_default_triple()
 148 if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*hf$")
 149   if (${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "^arm")
 150     set(COMPILER_RT_DEFAULT_TARGET_ARCH "armhf")
 151     CHECK_SYMBOL_EXISTS (__thumb__ "" COMPILER_RT_ARM_THUMB)
 152   endif()
 153 endif()
 154 if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*android.*")
 155   set(ANDROID 1)
 156   string(REGEX MATCH "-target(=| +)[^ ]+android[a-z]*([0-9]+)" ANDROID_API_LEVEL "${CMAKE_C_FLAGS}")
 157   set(ANDROID_API_LEVEL ${CMAKE_MATCH_2})
 158 endif()
 159 pythonize_bool(ANDROID)
 160
 161 set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 162 set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 163
 164 pythonize_bool(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
 165
 166 # We support running instrumented tests when we're not cross-compiling
 167 # and target a UNIX-like system or Windows.
 168 # We can run tests on Android even when we are cross-compiling.
 169 if((NOT "${CMAKE_CROSSCOMPILING}" AND (UNIX OR WIN32))
 170    OR ANDROID OR COMPILER_RT_EMULATOR)
 171   option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" ON)
 172 else()
 173   option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" OFF)
 174 endif()
 175
 176 option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF)
 177 option(COMPILER_RT_EXTERNALIZE_DEBUGINFO
 178   "Generate dSYM files and strip executables and libraries (Darwin Only)" OFF)
 179 # COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
 180 pythonize_bool(COMPILER_RT_DEBUG)
 181
 182 option(COMPILER_RT_INTERCEPT_LIBDISPATCH
 183   "Support interception of libdispatch (GCD). Requires '-fblocks'" OFF)
 184 option(COMPILER_RT_LIBDISPATCH_INSTALL_PATH
 185   "Specify if libdispatch is installed in a custom location" "")
 186 if (COMPILER_RT_INTERCEPT_LIBDISPATCH AND NOT APPLE)
 187   set(COMPILER_RT_LIBDISPATCH_CFLAGS -fblocks)
 188   set(COMPILER_RT_TEST_LIBDISPATCH_CFLAGS)
 189   if (COMPILER_RT_LIBDISPATCH_INSTALL_PATH)
 190     list(APPEND COMPILER_RT_TEST_LIBDISPATCH_CFLAGS
 191         -I${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/include
 192         -L${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/lib
 193         -Wl,-rpath=${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/lib)
 194   endif()
 195   list(APPEND COMPILER_RT_TEST_LIBDISPATCH_CFLAGS -lBlocksRuntime -ldispatch)
 196 endif()
 197 if (APPLE) # Always enable on Apple platforms.
 198   set(COMPILER_RT_INTERCEPT_LIBDISPATCH ON)
 199 endif()
 200 pythonize_bool(COMPILER_RT_INTERCEPT_LIBDISPATCH)
 201
 202 if(APPLE AND SANITIZER_MIN_OSX_VERSION AND SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.9")
 203   # Mac OS X prior to 10.9 had problems with exporting symbols from
 204   # libc++/libc++abi.
 205   set(cxxabi_supported OFF)
 206 else()
 207   set(cxxabi_supported ON)
 208 endif()
 209
 210 option(SANITIZER_ALLOW_CXXABI "Allow use of C++ ABI details in ubsan" ON)
 211
 212 set(SANITIZER_CAN_USE_CXXABI OFF)
 213 if (cxxabi_supported AND SANITIZER_ALLOW_CXXABI)
 214   set(SANITIZER_CAN_USE_CXXABI ON)
 215 endif()
 216 pythonize_bool(SANITIZER_CAN_USE_CXXABI)
 217
 218 macro(handle_default_cxx_lib var)
 219   # Specifying -stdlib= in CMAKE_CXX_FLAGS overrides the defaults.
 220   if (CMAKE_CXX_FLAGS MATCHES "-stdlib=([a-zA-Z+]*)")
 221     set(${var}_LIBNAME "${CMAKE_MATCH_1}")
 222     set(${var}_SYSTEM 1)
 223   elseif (${var} STREQUAL "default")
 224     if (APPLE OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 225       set(${var}_LIBNAME "libc++")
 226       set(${var}_SYSTEM 1)
 227     elseif (FUCHSIA)
 228       set(${var}_LIBNAME "libc++")
 229       set(${var}_INTREE 1)
 230     else()
 231       set(${var}_LIBNAME "libstdc++")
 232       set(${var}_SYSTEM 1)
 233     endif()
 234   else()
 235     set(${var}_LIBNAME "${${var}}")
 236     set(${var}_SYSTEM 1)
 237   endif()
 238 endmacro()
 239
 240 # This is either directly the C++ ABI library or the full C++ library
 241 # which pulls in the ABI transitively.
 242 # TODO: Mark this as internal flag, most users should use COMPILER_RT_CXX_LIBRARY.
 243 set(SANITIZER_CXX_ABI "default" CACHE STRING
 244     "Specify C++ ABI library to use.")
 245 set(CXXABIS none default libstdc++ libc++ libcxxabi)
 246 set_property(CACHE SANITIZER_CXX_ABI PROPERTY STRINGS ;${CXXABIS})
 247 handle_default_cxx_lib(SANITIZER_CXX_ABI)
 248
 249 # This needs to be a full C++ library for linking gtest and unit tests.
 250 # TODO: Mark this as internal flag, most users should use COMPILER_RT_CXX_LIBRARY.
 251 set(SANITIZER_TEST_CXX "default" CACHE STRING
 252     "Specify C++ library to use for tests.")
 253 set(CXXLIBS none default libstdc++ libc++)
 254 set_property(CACHE SANITIZER_TEST_CXX PROPERTY STRINGS ;${CXXLIBS})
 255 handle_default_cxx_lib(SANITIZER_TEST_CXX)
 256
 257 option(COMPILER_RT_USE_LLVM_UNWINDER "Use the LLVM unwinder." OFF)
 258 cmake_dependent_option(COMPILER_RT_ENABLE_STATIC_UNWINDER
 259   "Statically link the LLVM unwinder." OFF
 260   "COMPILER_RT_USE_LLVM_UNWINDER" OFF)
 261
 262 set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER OFF)
 263 if (FUCHSIA)
 264   set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER ON)
 265 elseif (DEFINED LIBUNWIND_ENABLE_SHARED AND NOT LIBUNWIND_ENABLE_SHARED)
 266   set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER ON)
 267 endif()
 268
 269 option(SANITIZER_USE_STATIC_LLVM_UNWINDER
 270   "Use static LLVM unwinder." ${DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER})
 271 pythonize_bool(SANITIZER_USE_STATIC_LLVM_UNWINDER)
 272
 273 set(DEFAULT_SANITIZER_USE_STATIC_CXX_ABI OFF)
 274 if (DEFINED LIBCXXABI_ENABLE_SHARED AND NOT LIBCXXABI_ENABLE_SHARED)
 275   set(DEFAULT_SANITIZER_USE_STATIC_CXX_ABI ON)
 276 endif()
 277
 278 option(SANITIZER_USE_STATIC_CXX_ABI
 279   "Use static libc++abi." ${DEFAULT_SANITIZER_USE_STATIC_CXX_ABI})
 280 pythonize_bool(SANITIZER_USE_STATIC_CXX_ABI)
 281
 282 set(DEFAULT_SANITIZER_USE_STATIC_TEST_CXX OFF)
 283 if (DEFINED LIBCXX_ENABLE_SHARED AND NOT LIBCXX_ENABLE_SHARED)
 284   set(DEFAULT_SANITIZER_USE_STATIC_TEST_CXX ON)
 285 endif()
 286
 287 option(SANITIZER_USE_STATIC_TEST_CXX
 288   "Use static libc++ for tests." ${DEFAULT_SANITIZER_USE_STATIC_TEST_CXX})
 289 pythonize_bool(SANITIZER_USE_STATIC_TEST_CXX)
 290
 291 set(COMPILER_RT_SUPPORTED_CXX_LIBRARIES none default libcxx)
 292 set(COMPILER_RT_CXX_LIBRARY "default" CACHE STRING "Specify C++ library to use. Supported values are ${COMPILER_RT_SUPPORTED_CXX_LIBRARIES}.")
 293 if (NOT "${COMPILER_RT_CXX_LIBRARY}" IN_LIST COMPILER_RT_SUPPORTED_CXX_LIBRARIES)
 294   message(FATAL_ERROR "Unsupported C++ library: '${COMPILER_RT_CXX_LIBRARY}'. Supported values are ${COMPILER_RT_SUPPORTED_CXX_LIBRARIES}.")
 295 endif()
 296 cmake_dependent_option(COMPILER_RT_STATIC_CXX_LIBRARY
 297   "Statically link the C++ library." OFF
 298   "COMPILER_RT_CXX_LIBRARY" OFF)
 299
 300 set(DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY OFF)
 301 if (FUCHSIA)
 302   set(DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY ON)
 303 endif()
 304
 305 option(COMPILER_RT_USE_BUILTINS_LIBRARY
 306   "Use compiler-rt builtins instead of libgcc" ${DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY})
 307
 308 option(COMPILER_RT_USE_ATOMIC_LIBRARY "Use compiler-rt atomic instead of libatomic" OFF)
 309
 310 include(config-ix)
 311
 312 #================================
 313 # Setup Compiler Flags
 314 #================================
 315
 316 # fcf-protection is a gcc/clang option for CET support on Linux platforms.
 317 # We need to handle MSVC CET option on Windows platforms.
 318 if (NOT MSVC)
 319   if (COMPILER_RT_ENABLE_CET AND NOT COMPILER_RT_HAS_FCF_PROTECTION_FLAG)
 320     message(FATAL_ERROR "Compiler used to build compiler-rt doesn't support CET!")
 321   endif()
 322 endif()
 323
 324 if(MSVC)
 325   # Override any existing /W flags with /W4. This is what LLVM does.  Failing to
 326   # remove other /W[0-4] flags will result in a warning about overriding a
 327   # previous flag.
 328   if (COMPILER_RT_HAS_W4_FLAG)
 329     string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 330     string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 331     append_string_if(COMPILER_RT_HAS_W4_FLAG /W4 CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 332   endif()
 333 else()
 334   append_string_if(COMPILER_RT_HAS_WALL_FLAG -Wall CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 335 endif()
 336 if(COMPILER_RT_ENABLE_WERROR)
 337   append_string_if(COMPILER_RT_HAS_WERROR_FLAG -Werror CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 338   append_string_if(COMPILER_RT_HAS_WX_FLAG /WX CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 339 endif()
 340
 341 # Emulate C99 and C++11's __func__ for MSVC prior to 2013 CTP.
 342 if(NOT COMPILER_RT_HAS_FUNC_SYMBOL)
 343   add_definitions(-D__func__=__FUNCTION__)
 344 endif()
 345
 346 # Provide some common commandline flags for Sanitizer runtimes.
 347 if("${ANDROID_API_LEVEL}" GREATER_EQUAL 29)
 348   list(APPEND SANITIZER_COMMON_CFLAGS -fno-emulated-tls)
 349   string(APPEND COMPILER_RT_TEST_COMPILER_CFLAGS " -fno-emulated-tls")
 350 endif()
 351 if(NOT WIN32)
 352   append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC SANITIZER_COMMON_CFLAGS)
 353 endif()
 354 append_list_if(COMPILER_RT_HAS_FNO_BUILTIN_FLAG -fno-builtin SANITIZER_COMMON_CFLAGS)
 355 append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SANITIZER_COMMON_CFLAGS)
 356 if(NOT COMPILER_RT_DEBUG AND NOT APPLE)
 357   append_list_if(COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG -fomit-frame-pointer SANITIZER_COMMON_CFLAGS)
 358 endif()
 359 append_list_if(COMPILER_RT_HAS_FUNWIND_TABLES_FLAG -funwind-tables SANITIZER_COMMON_CFLAGS)
 360 append_list_if(COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG -fno-stack-protector SANITIZER_COMMON_CFLAGS)
 361 append_list_if(COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG -fno-sanitize=safe-stack SANITIZER_COMMON_CFLAGS)
 362 append_list_if(COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden SANITIZER_COMMON_CFLAGS)
 363 if(NOT COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
 364   append_list_if(COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG -fvisibility-inlines-hidden SANITIZER_COMMON_CFLAGS)
 365 endif()
 366 append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto SANITIZER_COMMON_CFLAGS)
 367
 368 # By default do not instrument or use profdata for compiler-rt.
 369 if(NOT COMPILER_RT_ENABLE_PGO)
 370   if(LLVM_PROFDATA_FILE AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_FLAG)
 371     list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-instr-use")
 372   endif()
 373   if(LLVM_BUILD_INSTRUMENTED MATCHES IR AND COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG)
 374     list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-generate")
 375   elseif((LLVM_BUILD_INSTRUMENTED OR LLVM_BUILD_INSTRUMENTED_COVERAGE) AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG)
 376     list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-instr-generate")
 377     if(LLVM_BUILD_INSTRUMENTED_COVERAGE AND COMPILER_RT_HAS_FNO_COVERAGE_MAPPING_FLAG)
 378       list(APPEND SANITIZER_COMMON_CFLAGS "-fno-coverage-mapping")
 379     endif()
 380   endif()
 381 endif()
 382
 383 # The following is a workaround for powerpc64le. This is the only architecture
 384 # that requires -fno-function-sections to work properly. If lacking, the ASan
 385 # Linux test function-sections-are-bad.cpp fails with the following error:
 386 # 'undefined symbol: __sanitizer_unaligned_load32'.
 387 if(DEFINED TARGET_powerpc64le_CFLAGS)
 388   if(CMAKE_CXX_COMPILER_ID MATCHES "XL")
 389     append("-qnofuncsect" TARGET_powerpc64le_CFLAGS)
 390   else()
 391     append_list_if(COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG -fno-function-sections TARGET_powerpc64le_CFLAGS)
 392   endif()
 393 endif()
 394
 395 # The following is a workaround for s390x.  This avoids creation of "partial
 396 # inline" function fragments when building the asan libraries with certain
 397 # GCC versions.  The presence of those fragments, in particular for the
 398 # interceptors, changes backtraces seen in asan error cases, which causes
 399 # testsuite failures.
 400 if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "s390x")
 401   append_list_if(COMPILER_RT_HAS_FNO_PARTIAL_INLINING_FLAG -fno-partial-inlining SANITIZER_COMMON_CFLAGS)
 402 endif()
 403
 404 if(MSVC)
 405
 406   set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
 407
 408   # Remove any /M[DT][d] flags, and strip any definitions of _DEBUG.
 409   # Since we're using CMAKE_MSVC_RUNTIME_LIBRARY (CMP0091 set to NEW),
 410   # these options shouldn't be included in these flags variables. However,
 411   # package managers that don't know which mechanism is used for passing
 412   # CRT choice flags might be passing them both ways - which leads to
 413   # duplicate CRT choice options. Thus make sure to strip out these flags
 414   # from these variables, when we're forcing a CRT choice other than what
 415   # the user requested here.
 416   foreach(flag_var
 417     CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
 418     CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
 419     CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
 420     CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
 421     string(REGEX REPLACE "[/-]M[DT]d" "" ${flag_var} "${${flag_var}}")
 422     string(REGEX REPLACE "[/-]MD" "" ${flag_var} "${${flag_var}}")
 423     string(REGEX REPLACE "[/-]D_DEBUG" "" ${flag_var} "${${flag_var}}")
 424   endforeach()
 425
 426   append_list_if(COMPILER_RT_HAS_Oy_FLAG /Oy- SANITIZER_COMMON_CFLAGS)
 427   append_list_if(COMPILER_RT_HAS_GS_FLAG /GS- SANITIZER_COMMON_CFLAGS)
 428
 429   # Disable thread safe initialization for static locals. ASan shouldn't need
 430   # it. Thread safe initialization assumes that the CRT has already been
 431   # initialized, but ASan initializes before the CRT.
 432   list(APPEND SANITIZER_COMMON_CFLAGS /Zc:threadSafeInit-)
 433 endif()
 434
 435 append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 SANITIZER_COMMON_CFLAGS)
 436
 437 append_list_if(COMPILER_RT_HAS_WTHREAD_SAFETY_FLAG -Wthread-safety THREAD_SAFETY_FLAGS)
 438 append_list_if(COMPILER_RT_HAS_WTHREAD_SAFETY_REFERENCE_FLAG -Wthread-safety-reference THREAD_SAFETY_FLAGS)
 439 append_list_if(COMPILER_RT_HAS_WTHREAD_SAFETY_BETA_FLAG -Wthread-safety-beta THREAD_SAFETY_FLAGS)
 440 list(APPEND SANITIZER_COMMON_CFLAGS ${THREAD_SAFETY_FLAGS})
 441 string(REPLACE ";" " " thread_safety_flags_space_sep "${THREAD_SAFETY_FLAGS}")
 442 string(APPEND COMPILER_RT_TEST_COMPILER_CFLAGS " ${thread_safety_flags_space_sep}")
 443
 444 # If we're using MSVC,
 445 # always respect the optimization flags set by CMAKE_BUILD_TYPE instead.
 446 if (NOT MSVC)
 447
 448   # Build with optimization, unless we're in debug mode.
 449   if(COMPILER_RT_DEBUG)
 450     list(APPEND SANITIZER_COMMON_CFLAGS -O1)
 451   else()
 452     list(APPEND SANITIZER_COMMON_CFLAGS -O3)
 453   endif()
 454 endif()
 455
 456 # Determine if we should restrict stack frame sizes.
 457 # Stack frames on PowerPC, Mips, SystemZ and in debug build can be much larger than
 458 # anticipated.
 459 # FIXME: Fix all sanitizers and add -Wframe-larger-than to
 460 # SANITIZER_COMMON_FLAGS
 461 if(COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG AND NOT COMPILER_RT_DEBUG
 462    AND NOT ${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "powerpc|mips|s390x")
 463   set(SANITIZER_LIMIT_FRAME_SIZE TRUE)
 464 else()
 465   set(SANITIZER_LIMIT_FRAME_SIZE FALSE)
 466 endif()
 467
 468 if(FUCHSIA OR UNIX)
 469   set(SANITIZER_USE_SYMBOLS TRUE)
 470 else()
 471   set(SANITIZER_USE_SYMBOLS FALSE)
 472 endif()
 473
 474 # Get the linker version while configuring compiler-rt and explicitly pass it
 475 # in cflags during testing. This fixes the compiler/linker version mismatch
 476 # issue when running a clang built with a newer Xcode in an older Xcode
 477 set(COMPILER_RT_DARWIN_LINKER_VERSION)
 478 if (APPLE AND NOT CMAKE_LINKER MATCHES ".*lld.*")
 479   get_darwin_linker_version(COMPILER_RT_DARWIN_LINKER_VERSION)
 480   message(STATUS "Host linker version: ${COMPILER_RT_DARWIN_LINKER_VERSION}")
 481 endif()
 482
 483 # Build sanitizer runtimes with debug info.
 484 if(MSVC)
 485   # Use /Z7 instead of /Zi for the asan runtime. This avoids the LNK4099
 486   # warning from the MS linker complaining that it can't find the 'vc140.pdb'
 487   # file used by our object library compilations.
 488   list(APPEND SANITIZER_COMMON_CFLAGS /Z7)
 489   foreach(var_to_update
 490     CMAKE_CXX_FLAGS
 491     CMAKE_CXX_FLAGS_DEBUG
 492     CMAKE_CXX_FLAGS_RELWITHDEBINFO)
 493     string(REGEX REPLACE "(^| )/Z[i7I]($| )" " /Z7 "
 494            "${var_to_update}" "${${var_to_update}}")
 495   endforeach()
 496 elseif(APPLE)
 497   # On Apple platforms use full debug info (i.e. not `-gline-tables-only`)
 498   # for all build types so that the runtime can be debugged.
 499   if(NOT COMPILER_RT_HAS_G_FLAG)
 500     message(FATAL_ERROR "-g is not supported by host compiler")
 501   endif()
 502   list(APPEND SANITIZER_COMMON_CFLAGS -g)
 503 elseif(COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG AND NOT COMPILER_RT_DEBUG)
 504   list(APPEND SANITIZER_COMMON_CFLAGS -gline-tables-only)
 505 elseif(COMPILER_RT_HAS_G_FLAG)
 506   list(APPEND SANITIZER_COMMON_CFLAGS -g)
 507 endif()
 508
 509 if(LLVM_ENABLE_MODULES)
 510   # Sanitizers cannot be built with -fmodules. The interceptors intentionally
 511   # don't include system headers, which is incompatible with modules.
 512   list(APPEND SANITIZER_COMMON_CFLAGS -fno-modules)
 513 endif()
 514
 515 # Turn off several warnings.
 516 append_list_if(COMPILER_RT_HAS_WGNU_FLAG -Wno-gnu SANITIZER_COMMON_CFLAGS)
 517 append_list_if(COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG -Wno-variadic-macros SANITIZER_COMMON_CFLAGS)
 518 append_list_if(COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG -Wno-c99-extensions SANITIZER_COMMON_CFLAGS)
 519 # format-pedantic warns about passing T* for %p, which is not useful.
 520 append_list_if(COMPILER_RT_HAS_WD4146_FLAG /wd4146 SANITIZER_COMMON_CFLAGS)
 521 append_list_if(COMPILER_RT_HAS_WD4291_FLAG /wd4291 SANITIZER_COMMON_CFLAGS)
 522 append_list_if(COMPILER_RT_HAS_WD4391_FLAG /wd4391 SANITIZER_COMMON_CFLAGS)
 523 append_list_if(COMPILER_RT_HAS_WD4722_FLAG /wd4722 SANITIZER_COMMON_CFLAGS)
 524 append_list_if(COMPILER_RT_HAS_WD4800_FLAG /wd4800 SANITIZER_COMMON_CFLAGS)
 525
 526 append_list_if(MINGW -fms-extensions SANITIZER_COMMON_CFLAGS)
 527
 528 # When lsan scans the stack for detecting reachable pointers, it's possible for
 529 # a leaked pointer, which was pushed to the stack on an earlier function call,
 530 # to still exist on the stack when doing a leak check if that part of the stack
 531 # was not overwritten. In particular, if there's any uninitialized data in the
 532 # lsan runtime, and the SP we start from is sufficiently deep into the runtime,
 533 # then a leaked pointer could be marked as reachable. Such instances could be
 534 # mitigated by clobbering any uninitialized data. Note that this won't cover
 535 # all possible uninitialized stack contents, such as those used for register
 536 # spill slots, unused portions for alignment, or even local variables not
 537 # yet in scope at a certain point in the function.
 538 #
 539 # Note that this type of issue was discovered with lsan, but can apply to other
 540 # sanitizers.
 541 # Disable PowerPC because of https://github.com/llvm/llvm-project/issues/84654.
 542 if(NOT "${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "powerpc")
 543   append_list_if(COMPILER_RT_HAS_TRIVIAL_AUTO_INIT -ftrivial-auto-var-init=pattern SANITIZER_COMMON_CFLAGS)
 544 endif()
 545
 546 # Set common link flags.
 547 # TODO: We should consider using the same model as libc++, that is use either
 548 # -nostdlib++ and --unwindlib=none if supported, or -nodefaultlibs otherwise.
 549 append_list_if(C_SUPPORTS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_LINK_FLAGS)
 550 append_list_if(COMPILER_RT_HAS_Z_TEXT -Wl,-z,text SANITIZER_COMMON_LINK_FLAGS)
 551
 552 # Only necessary for 32-bit SPARC.  Solaris 11.2+ ld uses -z ignore/-z record
 553 # natively, but supports --as-needed/--no-as-needed for GNU ld compatibility.
 554 if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "sparc")
 555   list(APPEND SANITIZER_COMMON_LINK_LIBS -Wl,--as-needed atomic -Wl,--no-as-needed)
 556 endif()
 557
 558 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
 559   string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
 560 else()
 561   if (ANDROID)
 562     append_list_if(COMPILER_RT_HAS_GCC_LIB gcc SANITIZER_COMMON_LINK_LIBS)
 563   else()
 564     append_list_if(COMPILER_RT_HAS_GCC_S_LIB gcc_s SANITIZER_COMMON_LINK_LIBS)
 565   endif()
 566 endif()
 567
 568 append_list_if(COMPILER_RT_HAS_LIBC c SANITIZER_COMMON_LINK_LIBS)
 569 if("${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia")
 570   list(APPEND SANITIZER_COMMON_LINK_LIBS zircon)
 571 endif()
 572
 573 if("${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia")
 574   set(SANITIZER_NO_UNDEFINED_SYMBOLS_DEFAULT ON)
 575 else()
 576   set(SANITIZER_NO_UNDEFINED_SYMBOLS_DEFAULT OFF)
 577 endif()
 578 option(SANITIZER_NO_UNDEFINED_SYMBOLS "Report error on unresolved symbol references" ${SANITIZER_NO_UNDEFINED_SYMBOLS_DEFAULT})
 579 if (SANITIZER_NO_UNDEFINED_SYMBOLS)
 580   list(APPEND SANITIZER_COMMON_LINK_FLAGS -Wl,-z,defs)
 581 endif()
 582
 583 # TODO: COMPILER_RT_COMMON_CFLAGS and COMPILER_RT_COMMON_LINK_FLAGS are
 584 # intended for use in non-sanitizer runtimes such as libFuzzer, profile or XRay,
 585 # move these higher to include common flags, then derive SANITIZER_COMMON_CFLAGS
 586 # and SANITIZER_COMMON_LINK_FLAGS from those and append sanitizer-specific flags.
 587 set(COMPILER_RT_COMMON_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 588 set(COMPILER_RT_COMMON_LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS})
 589
 590 # We don't use the C++ standard library, so avoid including it by mistake.
 591 append_list_if(COMPILER_RT_HAS_NOSTDINCXX_FLAG -nostdinc++ SANITIZER_COMMON_CFLAGS)
 592 append_list_if(COMPILER_RT_HAS_NOSTDLIBXX_FLAG -nostdlib++ SANITIZER_COMMON_LINK_FLAGS)
 593
 594 # Remove -stdlib= which is unused when passing -nostdinc++...
 595 string(REGEX MATCHALL "-stdlib=[a-zA-Z+]*" stdlib_flag "${CMAKE_CXX_FLAGS}")
 596 string(REGEX REPLACE "-stdlib=[a-zA-Z+]*" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 597
 598 # ...we need it to build some runtimes and tests so readd it where appropriate.
 599 list(APPEND COMPILER_RT_COMMON_CFLAGS ${stdlib_flag})
 600 list(APPEND COMPILER_RT_COMMON_LINK_FLAGS ${stdlib_flag})
 601
 602 # TODO: There's a lot of duplication across lib/*/tests/CMakeLists.txt files,
 603 # move some of the common flags to COMPILER_RT_UNITTEST_CFLAGS.
 604
 605 # Unittests need access to C++ standard library.
 606 string(APPEND COMPILER_RT_TEST_COMPILER_CFLAGS " ${stdlib_flag}")
 607
 608 # When cross-compiling, COMPILER_RT_TEST_COMPILER_CFLAGS help in compilation
 609 # and linking of unittests.
 610 string(REPLACE " " ";" COMPILER_RT_UNITTEST_CFLAGS "${COMPILER_RT_TEST_COMPILER_CFLAGS}")
 611 set(COMPILER_RT_UNITTEST_LINK_FLAGS ${COMPILER_RT_UNITTEST_CFLAGS})
 612
 613 option(COMPILER_RT_TEST_STANDALONE_BUILD_LIBS
 614   "When set to ON and testing in a standalone build, test the runtime \
 615   libraries built by this standalone build rather than the runtime libraries \
 616   shipped with the compiler (used for testing). When set to OFF and testing \
 617   in a standalone build, test the runtime libraries shipped with the compiler \
 618   (used for testing). This option has no effect if the compiler and this \
 619   build are configured to use the same runtime library path."
 620   ON)
 621 if (COMPILER_RT_TEST_STANDALONE_BUILD_LIBS)
 622   # Ensure that the unit tests can find the sanitizer headers prior to installation.
 623   list(APPEND COMPILER_RT_UNITTEST_CFLAGS "-I${CMAKE_CURRENT_LIST_DIR}/include")
 624   # Ensure that unit tests link against the just-built runtime libraries instead
 625   # of the ones bundled with the compiler by overriding the resource directory.
 626   #
 627   if ("${COMPILER_RT_TEST_COMPILER_ID}" MATCHES "Clang")
 628     list(APPEND COMPILER_RT_UNITTEST_LINK_FLAGS "-resource-dir=${COMPILER_RT_OUTPUT_DIR}")
 629   endif()
 630 endif()
 631
 632 if(COMPILER_RT_USE_LLVM_UNWINDER)
 633   # We're linking directly against the libunwind that we're building so don't
 634   # try to link in the toolchain's default libunwind which may be missing.
 635   append_list_if(CXX_SUPPORTS_UNWINDLIB_NONE_FLAG --unwindlib=none COMPILER_RT_COMMON_LINK_FLAGS)
 636   append_list_if(CXX_SUPPORTS_UNWINDLIB_NONE_FLAG --unwindlib=none COMPILER_RT_UNITTEST_LINK_FLAGS)
 637   if (COMPILER_RT_ENABLE_STATIC_UNWINDER)
 638     list(APPEND COMPILER_RT_UNWINDER_LINK_LIBS "$<TARGET_LINKER_FILE:unwind_static>")
 639   else()
 640     list(APPEND COMPILER_RT_UNWINDER_LINK_LIBS "$<TARGET_LINKER_FILE:$<IF:$<BOOL:${LIBUNWIND_ENABLE_SHARED}>,unwind_shared,unwind_static>>")
 641   endif()
 642 endif()
 643
 644 if (COMPILER_RT_CXX_LIBRARY STREQUAL "libcxx")
 645   # We are using the in-tree libc++ so avoid including the default one.
 646   append_list_if(COMPILER_RT_HAS_NOSTDINCXX_FLAG -nostdinc++ COMPILER_RT_COMMON_CFLAGS)
 647   append_list_if(COMPILER_RT_HAS_NOSTDLIBXX_FLAG -nostdlib++ COMPILER_RT_COMMON_LINK_FLAGS)
 648   # Use the in-tree libc++ through explicit include and library paths.
 649   set(COMPILER_RT_CXX_CFLAGS "$<$<TARGET_EXISTS:cxx-headers>:$<IF:$<BOOL:${MSVC}>,/imsvc,-isystem>$<JOIN:$<TARGET_PROPERTY:cxx-headers,INTERFACE_INCLUDE_DIRECTORIES>,$<SEMICOLON>$<IF:$<BOOL:${MSVC}>,/imsvc,-isystem>>>")
 650   if (COMPILER_RT_STATIC_CXX_LIBRARY)
 651     set(COMPILER_RT_CXX_LINK_LIBS "$<TARGET_LINKER_FILE:cxx_static>")
 652   else()
 653     set(COMPILER_RT_CXX_LINK_LIBS "$<TARGET_LINKER_FILE:$<IF:$<BOOL:${LIBCXX_ENABLE_SHARED}>,cxx_shared,cxx_static>>")
 654   endif()
 655 elseif (COMPILER_RT_CXX_LIBRARY STREQUAL "none")
 656   # We aren't using any C++ standard library so avoid including the default one.
 657   append_list_if(COMPILER_RT_HAS_NOSTDINCXX_FLAG -nostdinc++ COMPILER_RT_COMMON_CFLAGS)
 658   append_list_if(COMPILER_RT_HAS_NOSTDLIBXX_FLAG -nostdlib++ COMPILER_RT_COMMON_LINK_FLAGS)
 659 else()
 660   # Nothing to be done for `default`.
 661 endif()
 662
 663 if (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libc++")
 664   if (SANITIZER_CXX_ABI_INTREE)
 665     # TODO: We don't need to add --unwindlib=none to SANITIZER_COMMON_LINK_FLAGS
 666     # because we added -nodefaultlibs there earlier, and adding would result in
 667     # a warning, but if we switch to -nostdlib++, we would need to add it here.
 668     # append_list_if(CXX_SUPPORTS_UNWINDLIB_NONE_FLAG --unwindlib=none SANITIZER_COMMON_LINK_FLAGS)
 669     if(SANITIZER_USE_STATIC_CXX_ABI)
 670       if(TARGET libcxx-abi-static)
 671         set(SANITIZER_CXX_ABI_LIBRARIES libcxx-abi-static)
 672       endif()
 673     else()
 674       if(TARGET libcxx-abi-shared)
 675         set(SANITIZER_CXX_ABI_LIBRARIES libcxx-abi-shared)
 676       elseif(TARGET libcxx-abi-static)
 677         set(SANITIZER_CXX_ABI_LIBRARIES libcxx-abi-static)
 678       endif()
 679     endif()
 680   else()
 681     append_list_if(COMPILER_RT_HAS_LIBCXX c++ SANITIZER_CXX_ABI_LIBRARIES)
 682   endif()
 683 elseif (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libcxxabi")
 684   list(APPEND SANITIZER_CXX_ABI_LIBRARIES "c++abi")
 685 elseif (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libstdc++")
 686   append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ SANITIZER_CXX_ABI_LIBRARIES)
 687 endif()
 688
 689 if (SANITIZER_TEST_CXX_LIBNAME STREQUAL "libc++")
 690   if (SANITIZER_TEST_CXX_INTREE)
 691     list(APPEND SANITIZER_TEST_CXX_CFLAGS "$<$<TARGET_EXISTS:cxx-headers>:$<IF:$<BOOL:${MSVC}>,/imsvc,-isystem>$<JOIN:$<TARGET_PROPERTY:cxx-headers,INTERFACE_INCLUDE_DIRECTORIES>,$<SEMICOLON>$<IF:$<BOOL:${MSVC}>,/imsvc,-isystem>>>")
 692     if (SANITIZER_USE_STATIC_TEST_CXX)
 693       list(APPEND SANITIZER_TEST_CXX_LIBRARIES "$<TARGET_LINKER_FILE:cxx_static>")
 694     else()
 695       list(APPEND SANITIZER_TEST_CXX_LIBRARIES "$<TARGET_LINKER_FILE:$<IF:$<BOOL:${LIBCXX_ENABLE_SHARED}>,cxx_shared,cxx_static>>")
 696     endif()
 697     # We are using the in tree libc++ so avoid including the default one.
 698     append_list_if(COMPILER_RT_HAS_NOSTDINCXX_FLAG -nostdinc++ COMPILER_RT_UNITTEST_CFLAGS)
 699     append_list_if(COMPILER_RT_HAS_NOSTDLIBXX_FLAG -nostdlib++ COMPILER_RT_UNITTEST_LINK_FLAGS)
 700   else()
 701     append_list_if(COMPILER_RT_HAS_LIBCXX -lc++ SANITIZER_TEST_CXX_LIBRARIES)
 702   endif()
 703 elseif (SANITIZER_TEST_CXX_LIBNAME STREQUAL "libstdc++")
 704   append_list_if(COMPILER_RT_HAS_LIBSTDCXX -lstdc++ SANITIZER_TEST_CXX_LIBRARIES)
 705 endif()
 706
 707 # Unittests support.
 708 # FIXME: When compiler-rt is build using -DLLVM_BUILD_EXTERNAL_COMPILER_RT=ON, then
 709 # The LLVM_THIRD_PARTY_DIR variable is not set.
 710 if (NOT LLVM_THIRD_PARTY_DIR)
 711   set(LLVM_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../third-party")
 712 endif()
 713
 714 set(COMPILER_RT_GTEST_PATH ${LLVM_THIRD_PARTY_DIR}/unittest/googletest)
 715 set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc)
 716 set(COMPILER_RT_GTEST_CFLAGS
 717   -DGTEST_NO_LLVM_SUPPORT=1
 718   -DGTEST_HAS_RTTI=0
 719   -I${COMPILER_RT_GTEST_PATH}/include
 720   -I${COMPILER_RT_GTEST_PATH}
 721 )
 722
 723 # Mocking support.
 724 set(COMPILER_RT_GMOCK_PATH ${LLVM_THIRD_PARTY_DIR}/unittest/googlemock)
 725 set(COMPILER_RT_GMOCK_SOURCE ${COMPILER_RT_GMOCK_PATH}/src/gmock-all.cc)
 726 set(COMPILER_RT_GMOCK_CFLAGS
 727   -DGTEST_NO_LLVM_SUPPORT=1
 728   -DGTEST_HAS_RTTI=0
 729   -I${COMPILER_RT_GMOCK_PATH}/include
 730   -I${COMPILER_RT_GMOCK_PATH}
 731 )
 732
 733 if(COMPILER_RT_HAS_G_FLAG)
 734   list(APPEND COMPILER_RT_UNITTEST_CFLAGS -g)
 735 endif()
 736 append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 COMPILER_RT_UNITTEST_CFLAGS)
 737 append_list_if(COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG -Wno-covered-switch-default COMPILER_RT_UNITTEST_CFLAGS)
 738 append_list_if(COMPILER_RT_HAS_WSUGGEST_OVERRIDE_FLAG -Wno-suggest-override COMPILER_RT_UNITTEST_CFLAGS)
 739 # Detect if the compiler toolchain includes gcc-toolset-12.
 740 if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR
 741     "${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
 742   execute_process(COMMAND ${CMAKE_CXX_COMPILER} -v
 743                   RESULT_VARIABLE compiler_info_rc
 744                   OUTPUT_VARIABLE compiler_info
 745                   ERROR_VARIABLE compiler_info)
 746   if(compiler_info MATCHES ".*gcc-toolset-12.*")
 747     set(USING_GCC_TOOLSET_12 TRUE)
 748   endif()
 749 endif()
 750 if(MSVC OR (LINUX AND DEFINED USING_GCC_TOOLSET_12 AND
 751             CMAKE_CXX_STANDARD EQUAL 17))
 752   # gtest use a lot of stuff marked as deprecated on Windows or if using
 753   # gcc-toolset-12 in the compiler toolchain on Linux; all of the
 754   # deprecated declarations in gcc-toolset-12 used in Google Tests have been
 755   # observed to be _GLIBCXX17_DEPRECATED and should go away once
 756   # CMAKE_CXX_STANDARD is greater than 17.
 757   list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations)
 758 endif()
 759
 760 # Warnings to turn off for all libraries, not just sanitizers.
 761 append_string_if(COMPILER_RT_HAS_WUNUSED_PARAMETER_FLAG -Wno-unused-parameter CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 762
 763 if (CMAKE_LINKER MATCHES "link.exe$")
 764   # Silence MSVC linker warnings caused by empty object files. The
 765   # sanitizer libraries intentionally use ifdefs that result in empty
 766   # files, rather than skipping these files in the build system.
 767   # Ideally, we would pass this flag only for the libraries that need
 768   # it, but CMake doesn't seem to have a way to set linker flags for
 769   # individual static libraries, so we enable the suppression flag for
 770   # the whole compiler-rt project.
 771   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221")
 772 endif()
 773
 774 add_subdirectory(include)
 775
 776 option(COMPILER_RT_USE_LIBCXX
 777   "Enable compiler-rt to use libc++ from the source tree" ON)
 778 if(COMPILER_RT_USE_LIBCXX)
 779   if(LLVM_ENABLE_PROJECTS_USED)
 780     # Don't use libcxx if LLVM_ENABLE_PROJECTS does not enable it.
 781     set(COMPILER_RT_LIBCXX_PATH ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR})
 782     set(COMPILER_RT_LIBCXXABI_PATH ${LLVM_EXTERNAL_LIBCXXABI_SOURCE_DIR})
 783   else()
 784     foreach(path IN ITEMS ${LLVM_MAIN_SRC_DIR}/projects/libcxx
 785                           ${LLVM_MAIN_SRC_DIR}/runtimes/libcxx
 786                           ${LLVM_MAIN_SRC_DIR}/../libcxx
 787                           ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR})
 788       if(IS_DIRECTORY ${path})
 789         set(COMPILER_RT_LIBCXX_PATH ${path})
 790         break()
 791       endif()
 792     endforeach()
 793     foreach(path IN ITEMS ${LLVM_MAIN_SRC_DIR}/projects/libcxxabi
 794                           ${LLVM_MAIN_SRC_DIR}/runtimes/libcxxabi
 795                           ${LLVM_MAIN_SRC_DIR}/../libcxxabi
 796                           ${LLVM_EXTERNAL_LIBCXXABI_SOURCE_DIR})
 797       if(IS_DIRECTORY ${path})
 798         set(COMPILER_RT_LIBCXXABI_PATH ${path})
 799         break()
 800       endif()
 801     endforeach()
 802   endif()
 803 endif()
 804
 805 if (LINKER_IS_LLD OR LLVM_TOOL_LLD_BUILD)
 806   set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/tools/lld)
 807   if(EXISTS ${COMPILER_RT_LLD_PATH}/)
 808     set(COMPILER_RT_HAS_LLD TRUE)
 809   else()
 810     set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/../lld)
 811     if(EXISTS ${COMPILER_RT_LLD_PATH}/)
 812       set(COMPILER_RT_HAS_LLD TRUE)
 813     endif()
 814   endif()
 815 endif()
 816
 817 if(ANDROID)
 818   set(COMPILER_RT_HAS_LLD TRUE)
 819   set(COMPILER_RT_TEST_USE_LLD TRUE)
 820   append_list_if(COMPILER_RT_HAS_FUSE_LD_LLD_FLAG -fuse-ld=lld SANITIZER_COMMON_LINK_FLAGS)
 821   append_list_if(COMPILER_RT_HAS_LLD -fuse-ld=lld COMPILER_RT_UNITTEST_LINK_FLAGS)
 822 endif()
 823 if(${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES sparc)
 824   # lld has several bugs/limitations on SPARC, so disable (Issue #100320).
 825   set(COMPILER_RT_HAS_LLD FALSE)
 826 endif()
 827 pythonize_bool(COMPILER_RT_HAS_LLD)
 828 pythonize_bool(COMPILER_RT_TEST_USE_LLD)
 829
 830 option(COMPILER_RT_ENABLE_INTERNAL_SYMBOLIZER "Build Compiler RT linked with in LLVM symbolizer" OFF)
 831 mark_as_advanced(COMPILER_RT_ENABLE_INTERNAL_SYMBOLIZER)
 832
 833 add_subdirectory(lib)
 834
 835 if(COMPILER_RT_INCLUDE_TESTS)
 836   # Don't build llvm-lit for runtimes-build, it will clean up map_config.
 837   if (COMPILER_RT_STANDALONE_BUILD AND NOT LLVM_RUNTIMES_BUILD)
 838     # If we have a valid source tree, generate llvm-lit into the bin directory.
 839     # The user can still choose to have the check targets *use* a different lit
 840     # by specifying -DLLVM_EXTERNAL_LIT, but we generate it regardless.
 841     if (EXISTS ${LLVM_MAIN_SRC_DIR}/utils/llvm-lit)
 842       # Needed for lit support in standalone builds.
 843       include(AddLLVM)
 844       add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit ${CMAKE_CURRENT_BINARY_DIR}/llvm-lit)
 845       # Ensure that the testsuite uses the local lit rather than
 846       # LLVM_INSTALL_DIR/bin/llvm-lit (which probably does not exist).
 847       get_llvm_lit_path(_base_dir _file_name)
 848       set(LLVM_EXTERNAL_LIT "${_base_dir}/${_file_name}" CACHE STRING "Command used to spawn lit" FORCE)
 849     elseif(NOT EXISTS ${LLVM_EXTERNAL_LIT})
 850       message(WARNING "Could not find LLVM source directory and LLVM_EXTERNAL_LIT does not"
 851                        "point to a valid file.  You will not be able to run tests.")
 852     endif()
 853   endif()
 854   add_subdirectory(unittests)
 855   add_subdirectory(test)
 856 endif()
 857
 858 add_subdirectory(tools)