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 6cmake_minimum_required(VERSION 3.4.3) 7 8if(POLICY CMP0075) 9 cmake_policy(SET CMP0075 NEW) 10endif() 11 12# Check if compiler-rt is built as a standalone project. 13if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR OR COMPILER_RT_STANDALONE_BUILD) 14 project(CompilerRT C CXX ASM) 15 set(COMPILER_RT_STANDALONE_BUILD TRUE) 16 set_property(GLOBAL PROPERTY USE_FOLDERS ON) 17endif() 18 19# Add path for custom compiler-rt modules. 20list(INSERT CMAKE_MODULE_PATH 0 21 "${CMAKE_CURRENT_SOURCE_DIR}/cmake" 22 "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules" 23 ) 24 25if(CMAKE_CONFIGURATION_TYPES) 26 set(CMAKE_CFG_RESOLVED_INTDIR "${CMAKE_CFG_INTDIR}/") 27else() 28 set(CMAKE_CFG_RESOLVED_INTDIR "") 29endif() 30 31include(base-config-ix) 32include(CompilerRTUtils) 33 34option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON) 35mark_as_advanced(COMPILER_RT_BUILD_BUILTINS) 36option(COMPILER_RT_BUILD_CRT "Build crtbegin.o/crtend.o" ON) 37mark_as_advanced(COMPILER_RT_BUILD_CRT) 38option(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY "Use eh_frame in crtbegin.o/crtend.o" ON) 39mark_as_advanced(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY) 40option(COMPILER_RT_BUILD_SANITIZERS "Build sanitizers" ON) 41mark_as_advanced(COMPILER_RT_BUILD_SANITIZERS) 42option(COMPILER_RT_BUILD_XRAY "Build xray" ON) 43mark_as_advanced(COMPILER_RT_BUILD_XRAY) 44option(COMPILER_RT_BUILD_LIBFUZZER "Build libFuzzer" ON) 45mark_as_advanced(COMPILER_RT_BUILD_LIBFUZZER) 46option(COMPILER_RT_BUILD_PROFILE "Build profile runtime" ON) 47mark_as_advanced(COMPILER_RT_BUILD_PROFILE) 48option(COMPILER_RT_BUILD_XRAY_NO_PREINIT "Build xray with no preinit patching" OFF) 49mark_as_advanced(COMPILER_RT_BUILD_XRAY_NO_PREINIT) 50 51set(COMPILER_RT_ASAN_SHADOW_SCALE "" 52 CACHE STRING "Override the shadow scale to be used in ASan runtime") 53 54if (NOT COMPILER_RT_ASAN_SHADOW_SCALE STREQUAL "") 55 # Check that the shadow scale value is valid. 56 if (NOT (COMPILER_RT_ASAN_SHADOW_SCALE GREATER -1 AND 57 COMPILER_RT_ASAN_SHADOW_SCALE LESS 8)) 58 message(FATAL_ERROR " 59 Invalid ASan Shadow Scale '${COMPILER_RT_ASAN_SHADOW_SCALE}'.") 60 endif() 61 62 set(COMPILER_RT_ASAN_SHADOW_SCALE_LLVM_FLAG 63 -mllvm -asan-mapping-scale=${COMPILER_RT_ASAN_SHADOW_SCALE}) 64 set(COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION 65 ASAN_SHADOW_SCALE=${COMPILER_RT_ASAN_SHADOW_SCALE}) 66 set(COMPILER_RT_ASAN_SHADOW_SCALE_FLAG 67 -D${COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION}) 68endif() 69 70set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS ON CACHE BOOL 71 "Enable libc interceptors in HWASan (testing mode)") 72 73set(COMPILER_RT_BAREMETAL_BUILD OFF CACHE BOOL 74 "Build for a bare-metal target.") 75 76if (COMPILER_RT_STANDALONE_BUILD) 77 load_llvm_config() 78 if (TARGET intrinsics_gen) 79 # Loading the llvm config causes this target to be imported so place it 80 # under the appropriate folder in an IDE. 81 set_target_properties(intrinsics_gen PROPERTIES FOLDER "Compiler-RT Misc") 82 endif() 83 84 if(CMAKE_VERSION VERSION_LESS 3.12) 85 # Find Python interpreter. 86 include(FindPythonInterp) 87 if(NOT PYTHONINTERP_FOUND) 88 message(FATAL_ERROR " 89 Unable to find Python interpreter required testing. Please install Python 90 or specify the PYTHON_EXECUTABLE CMake variable.") 91 endif() 92 93 add_executable(Python3::Interpreter IMPORTED) 94 set_target_properties(Python3::Interpreter PROPERTIES 95 IMPORTED_LOCATION ${PYTHON_EXECUTABLE}) 96 set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE}) 97 else() 98 find_package(Python3 COMPONENTS Interpreter) 99 if(NOT Python3_Interpreter_FOUND) 100 message(WARNING "Python3 not found, using python2 as a fallback") 101 find_package(Python2 COMPONENTS Interpreter REQUIRED) 102 if(Python2_VERSION VERSION_LESS 2.7) 103 message(SEND_ERROR "Python 2.7 or newer is required") 104 endif() 105 106 # Treat python2 as python3 107 add_executable(Python3::Interpreter IMPORTED) 108 set_target_properties(Python3::Interpreter PROPERTIES 109 IMPORTED_LOCATION ${Python2_EXECUTABLE}) 110 set(Python3_EXECUTABLE ${Python2_EXECUTABLE}) 111 endif() 112 endif() 113 114 # Ensure that fat libraries are built correctly on Darwin 115 if(CMAKE_HOST_APPLE AND APPLE) 116 include(UseLibtool) 117 endif() 118 119 # Define default arguments to lit. 120 set(LIT_ARGS_DEFAULT "-sv") 121 if (MSVC OR XCODE) 122 set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar") 123 endif() 124 set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit") 125 set(LLVM_LIT_OUTPUT_DIR "${COMPILER_RT_EXEC_OUTPUT_DIR}") 126endif() 127 128construct_compiler_rt_default_triple() 129if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*hf$") 130 if (${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "^arm") 131 set(COMPILER_RT_DEFAULT_TARGET_ARCH "armhf") 132 endif() 133endif() 134if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*android.*") 135 set(ANDROID 1) 136endif() 137pythonize_bool(ANDROID) 138 139set(ANDROID_NDK_VERSION 18 140 CACHE STRING "Set this to the Android NDK version that you are using") 141 142set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) 143set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}) 144 145pythonize_bool(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR) 146 147# We support running instrumented tests when we're not cross compiling 148# and target a UNIX-like system or Windows. 149# We can run tests on Android even when we are cross-compiling. 150if(("${CMAKE_HOST_SYSTEM}" STREQUAL "${CMAKE_SYSTEM}" AND (UNIX OR WIN32)) OR ANDROID 151 OR COMPILER_RT_EMULATOR) 152 option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" ON) 153else() 154 option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" OFF) 155endif() 156 157option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF) 158option(COMPILER_RT_EXTERNALIZE_DEBUGINFO 159 "Generate dSYM files and strip executables and libraries (Darwin Only)" OFF) 160# COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in. 161pythonize_bool(COMPILER_RT_DEBUG) 162 163option(COMPILER_RT_INTERCEPT_LIBDISPATCH 164 "Support interception of libdispatch (GCD). Requires '-fblocks'" OFF) 165option(COMPILER_RT_LIBDISPATCH_INSTALL_PATH 166 "Specify if libdispatch is installed in a custom location" "") 167if (COMPILER_RT_INTERCEPT_LIBDISPATCH AND NOT APPLE) 168 set(COMPILER_RT_LIBDISPATCH_CFLAGS -fblocks) 169 set(COMPILER_RT_TEST_LIBDISPATCH_CFLAGS) 170 if (COMPILER_RT_LIBDISPATCH_INSTALL_PATH) 171 list(APPEND COMPILER_RT_TEST_LIBDISPATCH_CFLAGS 172 -I${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/include 173 -L${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/lib 174 -Wl,-rpath=${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/lib) 175 endif() 176 list(APPEND COMPILER_RT_TEST_LIBDISPATCH_CFLAGS -lBlocksRuntime -ldispatch) 177endif() 178if (APPLE) # Always enable on Apple platforms. 179 set(COMPILER_RT_INTERCEPT_LIBDISPATCH ON) 180endif() 181pythonize_bool(COMPILER_RT_INTERCEPT_LIBDISPATCH) 182 183if(APPLE AND SANITIZER_MIN_OSX_VERSION AND SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.9") 184 # Mac OS X prior to 10.9 had problems with exporting symbols from 185 # libc++/libc++abi. 186 set(cxxabi_supported OFF) 187else() 188 set(cxxabi_supported ON) 189endif() 190 191option(SANITIZER_ALLOW_CXXABI "Allow use of C++ ABI details in ubsan" ON) 192 193set(SANITIZE_CAN_USE_CXXABI OFF) 194if (cxxabi_supported AND SANITIZER_ALLOW_CXXABI) 195 set(SANITIZER_CAN_USE_CXXABI ON) 196endif() 197pythonize_bool(SANITIZER_CAN_USE_CXXABI) 198 199macro(handle_default_cxx_lib var) 200 if (${var} STREQUAL "default") 201 if (APPLE OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD") 202 set(${var}_LIBNAME "libc++") 203 set(${var}_SYSTEM 1) 204 elseif (FUCHSIA) 205 set(${var}_LIBNAME "libc++") 206 set(${var}_INTREE 1) 207 else() 208 set(${var}_LIBNAME "libstdc++") 209 set(${var}_SYSTEM 1) 210 endif() 211 else() 212 set(${var}_LIBNAME "${${var}}") 213 set(${var}_SYSTEM 1) 214 endif() 215endmacro() 216 217# This is either directly the C++ ABI library or the full C++ library 218# which pulls in the ABI transitively. 219set(SANITIZER_CXX_ABI "default" CACHE STRING 220 "Specify C++ ABI library to use.") 221set(CXXABIS none default libstdc++ libc++ libcxxabi) 222set_property(CACHE SANITIZER_CXX_ABI PROPERTY STRINGS ;${CXXABIS}) 223handle_default_cxx_lib(SANITIZER_CXX_ABI) 224 225# This needs to be a full C++ library for linking gtest and unit tests. 226set(SANITIZER_TEST_CXX "default" CACHE STRING 227 "Specify C++ library to use for tests.") 228set(CXXLIBS none default libstdc++ libc++) 229set_property(CACHE SANITIZER_TEST_CXX PROPERTY STRINGS ;${CXXLIBS}) 230handle_default_cxx_lib(SANITIZER_TEST_CXX) 231 232set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER OFF) 233if (FUCHSIA) 234 set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER ON) 235elseif (DEFINED LIBUNWIND_ENABLE_SHARED AND NOT LIBUNWIND_ENABLE_SHARED) 236 set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER ON) 237endif() 238 239option(SANITIZER_USE_STATIC_LLVM_UNWINDER 240 "Use static LLVM unwinder." ${DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER}) 241 242set(DEFAULT_SANITIZER_USE_STATIC_CXX_ABI OFF) 243if (DEFINED LIBCXXABI_ENABLE_SHARED AND NOT LIBCXXABI_ENABLE_SHARED) 244 set(DEFAULT_SANITIZER_USE_STATIC_CXX_ABI ON) 245endif() 246 247option(SANITIZER_USE_STATIC_CXX_ABI 248 "Use static libc++abi." ${DEFAULT_SANITIZER_USE_STATIC_CXX_ABI}) 249 250set(DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY OFF) 251if (FUCHSIA) 252 set(DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY ON) 253endif() 254 255option(COMPILER_RT_USE_BUILTINS_LIBRARY 256 "Use compiler-rt builtins instead of libgcc" ${DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY}) 257 258include(config-ix) 259 260#================================ 261# Setup Compiler Flags 262#================================ 263 264if(MSVC) 265 # Override any existing /W flags with /W4. This is what LLVM does. Failing to 266 # remove other /W[0-4] flags will result in a warning about overriding a 267 # previous flag. 268 if (COMPILER_RT_HAS_W4_FLAG) 269 string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") 270 string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") 271 append_string_if(COMPILER_RT_HAS_W4_FLAG /W4 CMAKE_C_FLAGS CMAKE_CXX_FLAGS) 272 endif() 273else() 274 append_string_if(COMPILER_RT_HAS_WALL_FLAG -Wall CMAKE_C_FLAGS CMAKE_CXX_FLAGS) 275endif() 276if(COMPILER_RT_ENABLE_WERROR) 277 append_string_if(COMPILER_RT_HAS_WERROR_FLAG -Werror CMAKE_C_FLAGS CMAKE_CXX_FLAGS) 278 append_string_if(COMPILER_RT_HAS_WX_FLAG /WX CMAKE_C_FLAGS CMAKE_CXX_FLAGS) 279endif() 280 281append_string_if(COMPILER_RT_HAS_STD_CXX14_FLAG -std=c++14 CMAKE_CXX_FLAGS) 282 283# Emulate C99 and C++11's __func__ for MSVC prior to 2013 CTP. 284if(NOT COMPILER_RT_HAS_FUNC_SYMBOL) 285 add_definitions(-D__func__=__FUNCTION__) 286endif() 287 288# Provide some common commmandline flags for Sanitizer runtimes. 289if(NOT WIN32) 290 append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC SANITIZER_COMMON_CFLAGS) 291endif() 292append_list_if(COMPILER_RT_HAS_FNO_BUILTIN_FLAG -fno-builtin SANITIZER_COMMON_CFLAGS) 293append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SANITIZER_COMMON_CFLAGS) 294if(NOT COMPILER_RT_DEBUG AND NOT APPLE) 295 append_list_if(COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG -fomit-frame-pointer SANITIZER_COMMON_CFLAGS) 296endif() 297append_list_if(COMPILER_RT_HAS_FUNWIND_TABLES_FLAG -funwind-tables SANITIZER_COMMON_CFLAGS) 298append_list_if(COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG -fno-stack-protector SANITIZER_COMMON_CFLAGS) 299append_list_if(COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG -fno-sanitize=safe-stack SANITIZER_COMMON_CFLAGS) 300append_list_if(COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden SANITIZER_COMMON_CFLAGS) 301if(NOT COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG) 302 append_list_if(COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG -fvisibility-inlines-hidden SANITIZER_COMMON_CFLAGS) 303endif() 304append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto SANITIZER_COMMON_CFLAGS) 305 306# By default do not instrument or use profdata for compiler-rt. 307if(NOT COMPILER_RT_ENABLE_PGO) 308 if(LLVM_PROFDATA_FILE AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_FLAG) 309 list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-instr-use") 310 endif() 311 if(LLVM_BUILD_INSTRUMENTED MATCHES IR AND COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG) 312 list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-generate") 313 elseif(LLVM_BUILD_INSTRUMENTED AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG) 314 list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-instr-generate") 315 endif() 316endif() 317 318# The following is a workaround for powerpc64le. This is the only architecture 319# that requires -fno-function-sections to work properly. If lacking, the ASan 320# Linux test function-sections-are-bad.cpp fails with the following error: 321# 'undefined symbol: __sanitizer_unaligned_load32'. 322if(DEFINED TARGET_powerpc64le_CFLAGS) 323 if(CMAKE_CXX_COMPILER_ID MATCHES "XL") 324 append("-qnofuncsect" TARGET_powerpc64le_CFLAGS) 325 else() 326 append_list_if(COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG -fno-function-sections TARGET_powerpc64le_CFLAGS) 327 endif() 328endif() 329 330# The following is a workaround for s390x. This avoids creation of "partial 331# inline" function fragments when building the asan libraries with certain 332# GCC versions. The presence of those fragments, in particular for the 333# interceptors, changes backtraces seen in asan error cases, which causes 334# testsuite failures. 335if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "s390x") 336 append_list_if(COMPILER_RT_HAS_FNO_PARTIAL_INLINING_FLAG -fno-partial-inlining SANITIZER_COMMON_CFLAGS) 337endif() 338 339if(MSVC) 340 # Replace the /M[DT][d] flags with /MT, and strip any definitions of _DEBUG, 341 # which cause definition mismatches at link time. 342 # FIXME: In fact, sanitizers should support both /MT and /MD, see PR20214. 343 if(COMPILER_RT_HAS_MT_FLAG) 344 foreach(flag_var 345 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE 346 CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO 347 CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE 348 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) 349 string(REGEX REPLACE "/M[DT]d" "/MT" ${flag_var} "${${flag_var}}") 350 string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") 351 string(REGEX REPLACE "/D_DEBUG" "" ${flag_var} "${${flag_var}}") 352 endforeach() 353 endif() 354 append_list_if(COMPILER_RT_HAS_Oy_FLAG /Oy- SANITIZER_COMMON_CFLAGS) 355 append_list_if(COMPILER_RT_HAS_GS_FLAG /GS- SANITIZER_COMMON_CFLAGS) 356 357 # Disable thread safe initialization for static locals. ASan shouldn't need 358 # it. Thread safe initialization assumes that the CRT has already been 359 # initialized, but ASan initializes before the CRT. 360 list(APPEND SANITIZER_COMMON_CFLAGS /Zc:threadSafeInit-) 361endif() 362 363append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 SANITIZER_COMMON_CFLAGS) 364 365# If we're using MSVC, 366# always respect the optimization flags set by CMAKE_BUILD_TYPE instead. 367if (NOT MSVC) 368 369 # Build with optimization, unless we're in debug mode. 370 if(COMPILER_RT_DEBUG) 371 list(APPEND SANITIZER_COMMON_CFLAGS -O0) 372 else() 373 list(APPEND SANITIZER_COMMON_CFLAGS -O3) 374 endif() 375endif() 376 377# Determine if we should restrict stack frame sizes. 378# Stack frames on PowerPC, Mips, SystemZ and in debug build can be much larger than 379# anticipated. 380# FIXME: Fix all sanitizers and add -Wframe-larger-than to 381# SANITIZER_COMMON_FLAGS 382if(COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG AND NOT COMPILER_RT_DEBUG 383 AND NOT ${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "powerpc|mips|s390x") 384 set(SANITIZER_LIMIT_FRAME_SIZE TRUE) 385else() 386 set(SANITIZER_LIMIT_FRAME_SIZE FALSE) 387endif() 388 389if(FUCHSIA OR UNIX) 390 set(SANITIZER_USE_SYMBOLS TRUE) 391else() 392 set(SANITIZER_USE_SYMBOLS FALSE) 393endif() 394 395# Build sanitizer runtimes with debug info. 396if(MSVC) 397 # Use /Z7 instead of /Zi for the asan runtime. This avoids the LNK4099 398 # warning from the MS linker complaining that it can't find the 'vc140.pdb' 399 # file used by our object library compilations. 400 list(APPEND SANITIZER_COMMON_CFLAGS /Z7) 401 foreach(var_to_update 402 CMAKE_CXX_FLAGS 403 CMAKE_CXX_FLAGS_DEBUG 404 CMAKE_CXX_FLAGS_RELWITHDEBINFO) 405 string(REGEX REPLACE "(^| )/Z[i7I]($| )" " /Z7 " 406 "${var_to_update}" "${${var_to_update}}") 407 endforeach() 408elseif(COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG AND NOT COMPILER_RT_DEBUG) 409 list(APPEND SANITIZER_COMMON_CFLAGS -gline-tables-only) 410elseif(COMPILER_RT_HAS_G_FLAG) 411 list(APPEND SANITIZER_COMMON_CFLAGS -g) 412endif() 413 414if(LLVM_ENABLE_MODULES) 415 # Sanitizers cannot be built with -fmodules. The interceptors intentionally 416 # don't include system headers, which is incompatible with modules. 417 list(APPEND SANITIZER_COMMON_CFLAGS -fno-modules) 418endif() 419 420# Turn off several warnings. 421append_list_if(COMPILER_RT_HAS_WGNU_FLAG -Wno-gnu SANITIZER_COMMON_CFLAGS) 422append_list_if(COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG -Wno-variadic-macros SANITIZER_COMMON_CFLAGS) 423append_list_if(COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG -Wno-c99-extensions SANITIZER_COMMON_CFLAGS) 424append_list_if(COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG -Wno-non-virtual-dtor SANITIZER_COMMON_CFLAGS) 425append_list_if(COMPILER_RT_HAS_WD4146_FLAG /wd4146 SANITIZER_COMMON_CFLAGS) 426append_list_if(COMPILER_RT_HAS_WD4291_FLAG /wd4291 SANITIZER_COMMON_CFLAGS) 427append_list_if(COMPILER_RT_HAS_WD4391_FLAG /wd4391 SANITIZER_COMMON_CFLAGS) 428append_list_if(COMPILER_RT_HAS_WD4722_FLAG /wd4722 SANITIZER_COMMON_CFLAGS) 429append_list_if(COMPILER_RT_HAS_WD4800_FLAG /wd4800 SANITIZER_COMMON_CFLAGS) 430 431append_list_if(MINGW -fms-extensions SANITIZER_COMMON_CFLAGS) 432 433# Set common link flags. 434append_list_if(COMPILER_RT_HAS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_LINK_FLAGS) 435append_list_if(COMPILER_RT_HAS_Z_TEXT -Wl,-z,text SANITIZER_COMMON_LINK_FLAGS) 436 437if (COMPILER_RT_USE_BUILTINS_LIBRARY) 438 string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}") 439else() 440 if (ANDROID) 441 append_list_if(COMPILER_RT_HAS_GCC_LIB gcc SANITIZER_COMMON_LINK_LIBS) 442 else() 443 append_list_if(COMPILER_RT_HAS_GCC_S_LIB gcc_s SANITIZER_COMMON_LINK_LIBS) 444 endif() 445endif() 446 447append_list_if(COMPILER_RT_HAS_LIBC c SANITIZER_COMMON_LINK_LIBS) 448 449if("${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia") 450 list(APPEND SANITIZER_COMMON_LINK_FLAGS -Wl,-z,defs,-z,now,-z,relro) 451 list(APPEND SANITIZER_COMMON_LINK_LIBS zircon) 452endif() 453 454macro(append_libcxx_libs var) 455 if (${var}_INTREE) 456 if (SANITIZER_USE_STATIC_LLVM_UNWINDER AND (TARGET unwind_static OR HAVE_LIBUNWIND)) 457 list(APPEND ${var}_LIBRARIES unwind_static) 458 elseif (TARGET unwind_shared OR HAVE_LIBUNWIND) 459 list(APPEND ${var}_LIBRARIES unwind_shared) 460 endif() 461 462 if (SANITIZER_USE_STATIC_CXX_ABI AND (TARGET cxxabi_static OR HAVE_LIBCXXABI)) 463 list(APPEND ${var}_LIBRARIES cxxabi_static) 464 elseif (TARGET cxxabi_shared OR HAVE_LIBCXXABI) 465 list(APPEND ${var}_LIBRARIES cxxabi_shared) 466 endif() 467 else() 468 append_list_if(COMPILER_RT_HAS_LIBCXX c++ ${var}_LIBRARIES) 469 endif() 470endmacro() 471 472if (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libc++") 473 append_libcxx_libs(SANITIZER_CXX_ABI) 474elseif (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libcxxabi") 475 list(APPEND SANITIZER_CXX_ABI_LIBRARIES "c++abi") 476elseif (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libstdc++") 477 append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ SANITIZER_CXX_ABI_LIBRARIES) 478endif() 479 480if (SANITIZER_TEST_CXX_LIBNAME STREQUAL "libc++") 481 append_libcxx_libs(SANITIZER_TEST_CXX) 482elseif (SANITIZER_TEST_CXX_LIBNAME STREQUAL "libstdc++") 483 append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ SANITIZER_TEST_CXX_LIBRARIES) 484endif() 485 486# Warnings to turn off for all libraries, not just sanitizers. 487append_string_if(COMPILER_RT_HAS_WUNUSED_PARAMETER_FLAG -Wno-unused-parameter CMAKE_C_FLAGS CMAKE_CXX_FLAGS) 488 489if (CMAKE_LINKER MATCHES "link.exe$") 490 # Silence MSVC linker warnings caused by empty object files. The 491 # sanitizer libraries intentionally use ifdefs that result in empty 492 # files, rather than skipping these files in the build system. 493 # Ideally, we would pass this flag only for the libraries that need 494 # it, but CMake doesn't seem to have a way to set linker flags for 495 # individual static libraries, so we enable the suppression flag for 496 # the whole compiler-rt project. 497 set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221") 498endif() 499 500add_subdirectory(include) 501 502option(COMPILER_RT_USE_LIBCXX 503 "Enable compiler-rt to use libc++ from the source tree" ON) 504if(COMPILER_RT_USE_LIBCXX) 505 if(LLVM_ENABLE_PROJECTS_USED) 506 # Don't use libcxx if LLVM_ENABLE_PROJECTS does not enable it. 507 set(COMPILER_RT_LIBCXX_PATH ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR}) 508 set(COMPILER_RT_LIBCXXABI_PATH ${LLVM_EXTERNAL_LIBCXXABI_SOURCE_DIR}) 509 else() 510 foreach(path IN ITEMS ${LLVM_MAIN_SRC_DIR}/projects/libcxx 511 ${LLVM_MAIN_SRC_DIR}/runtimes/libcxx 512 ${LLVM_MAIN_SRC_DIR}/../libcxx 513 ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR}) 514 if(IS_DIRECTORY ${path}) 515 set(COMPILER_RT_LIBCXX_PATH ${path}) 516 break() 517 endif() 518 endforeach() 519 foreach(path IN ITEMS ${LLVM_MAIN_SRC_DIR}/projects/libcxxabi 520 ${LLVM_MAIN_SRC_DIR}/runtimes/libcxxabi 521 ${LLVM_MAIN_SRC_DIR}/../libcxxabi 522 ${LLVM_EXTERNAL_LIBCXXABI_SOURCE_DIR}) 523 if(IS_DIRECTORY ${path}) 524 set(COMPILER_RT_LIBCXXABI_PATH ${path}) 525 break() 526 endif() 527 endforeach() 528 endif() 529endif() 530 531set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/tools/lld) 532if(EXISTS ${COMPILER_RT_LLD_PATH}/ AND LLVM_TOOL_LLD_BUILD) 533 set(COMPILER_RT_HAS_LLD TRUE) 534else() 535 set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/../lld) 536 if(EXISTS ${COMPILER_RT_LLD_PATH}/ AND LLVM_TOOL_LLD_BUILD) 537 set(COMPILER_RT_HAS_LLD TRUE) 538 endif() 539endif() 540pythonize_bool(COMPILER_RT_HAS_LLD) 541 542add_subdirectory(lib) 543 544if(COMPILER_RT_INCLUDE_TESTS) 545 add_subdirectory(unittests) 546 add_subdirectory(test) 547 if (COMPILER_RT_STANDALONE_BUILD) 548 # If we have a valid source tree, generate llvm-lit into the bin directory. 549 # The user can still choose to have the check targets *use* a different lit 550 # by specifying -DLLVM_EXTERNAL_LIT, but we generate it regardless. 551 if (EXISTS ${LLVM_MAIN_SRC_DIR}/utils/llvm-lit) 552 # Needed for lit support in standalone builds. 553 include(AddLLVM) 554 add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit ${CMAKE_CURRENT_BINARY_DIR}/llvm-lit) 555 elseif(NOT EXISTS ${LLVM_EXTERNAL_LIT}) 556 message(WARNING "Could not find LLVM source directory and LLVM_EXTERNAL_LIT does not" 557 "point to a valid file. You will not be able to run tests.") 558 endif() 559 endif() 560endif() 561 562add_subdirectory(tools) 563