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