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