compiler-rt/cmake/config-ix.cmake

   1 include(CMakePushCheckState)
   2 include(CheckCCompilerFlag)
   3 include(CheckCXXCompilerFlag)
   4 include(CheckLibraryExists)
   5 include(CheckSymbolExists)
   6 include(TestBigEndian)
   7
   8 function(check_linker_flag flag out_var)
   9   cmake_push_check_state()
  10   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag}")
  11   check_cxx_compiler_flag("" ${out_var})
  12   cmake_pop_check_state()
  13 endfunction()
  14
  15 check_library_exists(c fopen "" COMPILER_RT_HAS_LIBC)
  16 if (NOT SANITIZER_USE_COMPILER_RT)
  17   if (ANDROID)
  18     check_library_exists(gcc __gcc_personality_v0 "" COMPILER_RT_HAS_GCC_LIB)
  19   else()
  20     check_library_exists(gcc_s __gcc_personality_v0 "" COMPILER_RT_HAS_GCC_S_LIB)
  21   endif()
  22 endif()
  23
  24 check_c_compiler_flag(-nodefaultlibs COMPILER_RT_HAS_NODEFAULTLIBS_FLAG)
  25 if (COMPILER_RT_HAS_NODEFAULTLIBS_FLAG)
  26   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
  27   if (COMPILER_RT_HAS_LIBC)
  28     list(APPEND CMAKE_REQUIRED_LIBRARIES c)
  29   endif ()
  30   if (SANITIZER_USE_COMPILER_RT)
  31     list(APPEND CMAKE_REQUIRED_FLAGS -rtlib=compiler-rt)
  32     find_compiler_rt_library(builtins COMPILER_RT_BUILTINS_LIBRARY)
  33     list(APPEND CMAKE_REQUIRED_LIBRARIES "${COMPILER_RT_BUILTINS_LIBRARY}")
  34   elseif (COMPILER_RT_HAS_GCC_S_LIB)
  35     list(APPEND CMAKE_REQUIRED_LIBRARIES gcc_s)
  36   elseif (COMPILER_RT_HAS_GCC_LIB)
  37     list(APPEND CMAKE_REQUIRED_LIBRARIES gcc)
  38   endif ()
  39 endif ()
  40
  41 # CodeGen options.
  42 check_cxx_compiler_flag(-fPIC                COMPILER_RT_HAS_FPIC_FLAG)
  43 check_cxx_compiler_flag(-fPIE                COMPILER_RT_HAS_FPIE_FLAG)
  44 check_cxx_compiler_flag(-fno-builtin         COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
  45 check_cxx_compiler_flag(-fno-exceptions      COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
  46 check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)
  47 check_cxx_compiler_flag(-funwind-tables      COMPILER_RT_HAS_FUNWIND_TABLES_FLAG)
  48 check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG)
  49 check_cxx_compiler_flag(-fno-sanitize=safe-stack COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG)
  50 check_cxx_compiler_flag(-fvisibility=hidden  COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
  51 check_cxx_compiler_flag(-frtti               COMPILER_RT_HAS_FRTTI_FLAG)
  52 check_cxx_compiler_flag(-fno-rtti            COMPILER_RT_HAS_FNO_RTTI_FLAG)
  53 check_cxx_compiler_flag(-ffreestanding       COMPILER_RT_HAS_FFREESTANDING_FLAG)
  54 check_cxx_compiler_flag("-Werror -fno-function-sections" COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG)
  55 check_cxx_compiler_flag(-std=c++11           COMPILER_RT_HAS_STD_CXX11_FLAG)
  56 check_cxx_compiler_flag(-ftls-model=initial-exec COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC)
  57 check_cxx_compiler_flag(-fno-lto             COMPILER_RT_HAS_FNO_LTO_FLAG)
  58 check_cxx_compiler_flag("-Werror -msse3" COMPILER_RT_HAS_MSSE3_FLAG)
  59 check_cxx_compiler_flag("-Werror -msse4.2"   COMPILER_RT_HAS_MSSE4_2_FLAG)
  60 check_cxx_compiler_flag(--sysroot=.          COMPILER_RT_HAS_SYSROOT_FLAG)
  61 check_cxx_compiler_flag("-Werror -mcrc"      COMPILER_RT_HAS_MCRC_FLAG)
  62
  63 if(NOT WIN32 AND NOT CYGWIN)
  64   # MinGW warns if -fvisibility-inlines-hidden is used.
  65   check_cxx_compiler_flag("-fvisibility-inlines-hidden" COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG)
  66 endif()
  67
  68 check_cxx_compiler_flag(/GR COMPILER_RT_HAS_GR_FLAG)
  69 check_cxx_compiler_flag(/GS COMPILER_RT_HAS_GS_FLAG)
  70 check_cxx_compiler_flag(/MT COMPILER_RT_HAS_MT_FLAG)
  71 check_cxx_compiler_flag(/Oy COMPILER_RT_HAS_Oy_FLAG)
  72
  73 # Debug info flags.
  74 check_cxx_compiler_flag(-gline-tables-only COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG)
  75 check_cxx_compiler_flag(-g COMPILER_RT_HAS_G_FLAG)
  76 check_cxx_compiler_flag(/Zi COMPILER_RT_HAS_Zi_FLAG)
  77
  78 # Warnings.
  79 check_cxx_compiler_flag(-Wall COMPILER_RT_HAS_WALL_FLAG)
  80 check_cxx_compiler_flag(-Werror COMPILER_RT_HAS_WERROR_FLAG)
  81 check_cxx_compiler_flag("-Werror -Wframe-larger-than=512" COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG)
  82 check_cxx_compiler_flag("-Werror -Wglobal-constructors"   COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG)
  83 check_cxx_compiler_flag("-Werror -Wc99-extensions"     COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG)
  84 check_cxx_compiler_flag("-Werror -Wgnu"                COMPILER_RT_HAS_WGNU_FLAG)
  85 check_cxx_compiler_flag("-Werror -Wnon-virtual-dtor"   COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG)
  86 check_cxx_compiler_flag("-Werror -Wvariadic-macros"    COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG)
  87 check_cxx_compiler_flag("-Werror -Wunused-parameter"   COMPILER_RT_HAS_WUNUSED_PARAMETER_FLAG)
  88 check_cxx_compiler_flag("-Werror -Wcovered-switch-default" COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG)
  89
  90 check_cxx_compiler_flag(/W4 COMPILER_RT_HAS_W4_FLAG)
  91 check_cxx_compiler_flag(/WX COMPILER_RT_HAS_WX_FLAG)
  92 check_cxx_compiler_flag(/wd4146 COMPILER_RT_HAS_WD4146_FLAG)
  93 check_cxx_compiler_flag(/wd4291 COMPILER_RT_HAS_WD4291_FLAG)
  94 check_cxx_compiler_flag(/wd4221 COMPILER_RT_HAS_WD4221_FLAG)
  95 check_cxx_compiler_flag(/wd4391 COMPILER_RT_HAS_WD4391_FLAG)
  96 check_cxx_compiler_flag(/wd4722 COMPILER_RT_HAS_WD4722_FLAG)
  97 check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG)
  98
  99 # Symbols.
 100 check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL)
 101
 102 # Libraries.
 103 check_library_exists(dl dlopen "" COMPILER_RT_HAS_LIBDL)
 104 check_library_exists(rt shm_open "" COMPILER_RT_HAS_LIBRT)
 105 check_library_exists(m pow "" COMPILER_RT_HAS_LIBM)
 106 check_library_exists(pthread pthread_create "" COMPILER_RT_HAS_LIBPTHREAD)
 107 if (ANDROID AND COMPILER_RT_HAS_LIBDL)
 108   # Android's libstdc++ has a dependency on libdl.
 109   list(APPEND CMAKE_REQUIRED_LIBRARIES dl)
 110 endif()
 111 check_library_exists(stdc++ __cxa_throw "" COMPILER_RT_HAS_LIBSTDCXX)
 112
 113 # Linker flags.
 114 if(ANDROID)
 115   check_linker_flag("-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
 116   check_library_exists(log __android_log_write "" COMPILER_RT_HAS_LIBLOG)
 117 endif()
 118
 119 # Architectures.
 120
 121 # List of all architectures we can target.
 122 set(COMPILER_RT_SUPPORTED_ARCH)
 123
 124 # Try to compile a very simple source file to ensure we can target the given
 125 # platform. We use the results of these tests to build only the various target
 126 # runtime libraries supported by our current compilers cross-compiling
 127 # abilities.
 128 set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc)
 129 file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <stdio.h>\nint main() { printf(\"hello, world\"); }\n")
 130
 131 # Detect whether the current target platform is 32-bit or 64-bit, and setup
 132 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
 133 if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
 134     NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
 135   message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
 136 endif()
 137
 138 test_targets()
 139
 140 # Returns a list of architecture specific target cflags in @out_var list.
 141 function(get_target_flags_for_arch arch out_var)
 142   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
 143   if(ARCH_INDEX EQUAL -1)
 144     message(FATAL_ERROR "Unsupported architecture: ${arch}")
 145   else()
 146     if (NOT APPLE)
 147       set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
 148     else()
 149       # This is only called in constructing cflags for tests executing on the
 150       # host. This will need to all be cleaned up to support building tests
 151       # for cross-targeted hardware (i.e. iOS).
 152       set(${out_var} -arch ${arch} PARENT_SCOPE)
 153     endif()
 154   endif()
 155 endfunction()
 156
 157 # Returns a compiler and CFLAGS that should be used to run tests for the
 158 # specific architecture.  When cross-compiling, this is controled via
 159 # COMPILER_RT_TEST_COMPILER and COMPILER_RT_TEST_COMPILER_CFLAGS.
 160 macro(get_test_cc_for_arch arch cc_out cflags_out)
 161   if(ANDROID OR ${arch} MATCHES "arm|aarch64")
 162     # This is only true if we are cross-compiling.
 163     # Build all tests with host compiler and use host tools.
 164     set(${cc_out} ${COMPILER_RT_TEST_COMPILER})
 165     set(${cflags_out} ${COMPILER_RT_TEST_COMPILER_CFLAGS})
 166   else()
 167     get_target_flags_for_arch(${arch} ${cflags_out})
 168     if(APPLE)
 169       list(APPEND ${cflags_out} ${DARWIN_osx_CFLAGS})
 170     endif()
 171     string(REPLACE ";" " " ${cflags_out} "${${cflags_out}}")
 172   endif()
 173 endmacro()
 174
 175 set(ARM64 aarch64)
 176 set(ARM32 arm armhf)
 177 set(X86 i386)
 178 set(X86_64 x86_64)
 179 set(MIPS32 mips mipsel)
 180 set(MIPS64 mips64 mips64el)
 181 set(PPC64 powerpc64 powerpc64le)
 182 set(S390X s390x)
 183 set(WASM32 wasm32)
 184 set(WASM64 wasm64)
 185
 186 if(APPLE)
 187   set(ARM64 arm64)
 188   set(ARM32 armv7 armv7s armv7k)
 189   set(X86_64 x86_64 x86_64h)
 190 endif()
 191
 192 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
 193     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X})
 194 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
 195     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 196 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 197 set(ALL_FUZZER_SUPPORTED_ARCH x86_64)
 198
 199 if(APPLE)
 200   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64})
 201 else()
 202   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64} ${ARM32})
 203 endif()
 204 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 205 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
 206     ${MIPS32} ${MIPS64} ${S390X})
 207 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 208 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
 209     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 210 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 211 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64})
 212 set(ALL_ESAN_SUPPORTED_ARCH ${X86_64} ${MIPS64})
 213 set(ALL_SCUDO_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64})
 214 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} powerpc64le)
 215
 216 if(APPLE)
 217   include(CompilerRTDarwinUtils)
 218
 219   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
 220   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
 221   find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos)
 222   find_darwin_sdk_dir(DARWIN_watchossim_SYSROOT watchsimulator)
 223   find_darwin_sdk_dir(DARWIN_watchos_SYSROOT watchos)
 224   find_darwin_sdk_dir(DARWIN_tvossim_SYSROOT appletvsimulator)
 225   find_darwin_sdk_dir(DARWIN_tvos_SYSROOT appletvos)
 226
 227   if(NOT DARWIN_osx_SYSROOT)
 228     if(EXISTS /usr/include)
 229       set(DARWIN_osx_SYSROOT /)
 230     else()
 231       message(ERROR "Could not detect OS X Sysroot. Either install Xcode or the Apple Command Line Tools")
 232     endif()
 233   endif()
 234
 235   if(COMPILER_RT_ENABLE_IOS)
 236     list(APPEND DARWIN_EMBEDDED_PLATFORMS ios)
 237     set(DARWIN_ios_MIN_VER_FLAG -miphoneos-version-min)
 238     set(DARWIN_ios_SANITIZER_MIN_VER_FLAG
 239       ${DARWIN_ios_MIN_VER_FLAG}=8.0)
 240   endif()
 241   if(COMPILER_RT_ENABLE_WATCHOS)
 242     list(APPEND DARWIN_EMBEDDED_PLATFORMS watchos)
 243     set(DARWIN_watchos_MIN_VER_FLAG -mwatchos-version-min)
 244     set(DARWIN_watchos_SANITIZER_MIN_VER_FLAG
 245       ${DARWIN_watchos_MIN_VER_FLAG}=2.0)
 246   endif()
 247   if(COMPILER_RT_ENABLE_TVOS)
 248     list(APPEND DARWIN_EMBEDDED_PLATFORMS tvos)
 249     set(DARWIN_tvos_MIN_VER_FLAG -mtvos-version-min)
 250     set(DARWIN_tvos_SANITIZER_MIN_VER_FLAG
 251       ${DARWIN_tvos_MIN_VER_FLAG}=9.0)
 252   endif()
 253
 254   # Note: In order to target x86_64h on OS X the minimum deployment target must
 255   # be 10.8 or higher.
 256   set(SANITIZER_COMMON_SUPPORTED_OS osx)
 257   set(PROFILE_SUPPORTED_OS osx)
 258   set(TSAN_SUPPORTED_OS osx)
 259   if(NOT SANITIZER_MIN_OSX_VERSION)
 260     string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)"
 261            MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
 262     if(MACOSX_VERSION_MIN_FLAG)
 263       set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}")
 264     elseif(CMAKE_OSX_DEPLOYMENT_TARGET)
 265       set(SANITIZER_MIN_OSX_VERSION ${CMAKE_OSX_DEPLOYMENT_TARGET})
 266     else()
 267       set(SANITIZER_MIN_OSX_VERSION 10.9)
 268     endif()
 269     if(SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.7")
 270       message(FATAL_ERROR "macOS deployment target '${SANITIZER_MIN_OSX_VERSION}' is too old.")
 271     endif()
 272     if(SANITIZER_MIN_OSX_VERSION VERSION_GREATER "10.9")
 273       message(WARNING "macOS deployment target '${SANITIZER_MIN_OSX_VERSION}' is too new, setting to '10.9' instead.")
 274       set(SANITIZER_MIN_OSX_VERSION 10.9)
 275     endif()
 276   endif()
 277
 278   # We're setting the flag manually for each target OS
 279   set(CMAKE_OSX_DEPLOYMENT_TARGET "")
 280
 281   set(DARWIN_COMMON_CFLAGS -stdlib=libc++)
 282   set(DARWIN_COMMON_LINK_FLAGS
 283     -stdlib=libc++
 284     -lc++
 285     -lc++abi)
 286
 287   check_linker_flag("-fapplication-extension" COMPILER_RT_HAS_APP_EXTENSION)
 288   if(COMPILER_RT_HAS_APP_EXTENSION)
 289     list(APPEND DARWIN_COMMON_LINK_FLAGS "-fapplication-extension")
 290   endif()
 291
 292   set(DARWIN_osx_CFLAGS
 293     ${DARWIN_COMMON_CFLAGS}
 294     -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
 295   set(DARWIN_osx_LINK_FLAGS
 296     ${DARWIN_COMMON_LINK_FLAGS}
 297     -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
 298
 299   if(DARWIN_osx_SYSROOT)
 300     list(APPEND DARWIN_osx_CFLAGS -isysroot ${DARWIN_osx_SYSROOT})
 301     list(APPEND DARWIN_osx_LINK_FLAGS -isysroot ${DARWIN_osx_SYSROOT})
 302   endif()
 303
 304   # Figure out which arches to use for each OS
 305   darwin_get_toolchain_supported_archs(toolchain_arches)
 306   message(STATUS "Toolchain supported arches: ${toolchain_arches}")
 307
 308   if(NOT MACOSX_VERSION_MIN_FLAG)
 309     darwin_test_archs(osx
 310       DARWIN_osx_ARCHS
 311       ${toolchain_arches})
 312     message(STATUS "OSX supported arches: ${DARWIN_osx_ARCHS}")
 313     foreach(arch ${DARWIN_osx_ARCHS})
 314       list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
 315       set(CAN_TARGET_${arch} 1)
 316     endforeach()
 317
 318     foreach(platform ${DARWIN_EMBEDDED_PLATFORMS})
 319       if(DARWIN_${platform}sim_SYSROOT)
 320         set(DARWIN_${platform}sim_CFLAGS
 321           ${DARWIN_COMMON_CFLAGS}
 322           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
 323           -isysroot ${DARWIN_${platform}sim_SYSROOT})
 324         set(DARWIN_${platform}sim_LINK_FLAGS
 325           ${DARWIN_COMMON_LINK_FLAGS}
 326           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
 327           -isysroot ${DARWIN_${platform}sim_SYSROOT})
 328
 329         set(DARWIN_${platform}sim_SKIP_CC_KEXT On)
 330         darwin_test_archs(${platform}sim
 331           DARWIN_${platform}sim_ARCHS
 332           ${toolchain_arches})
 333         message(STATUS "${platform} Simulator supported arches: ${DARWIN_${platform}sim_ARCHS}")
 334         if(DARWIN_${platform}sim_ARCHS)
 335           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform}sim)
 336           list(APPEND PROFILE_SUPPORTED_OS ${platform}sim)
 337           list(APPEND TSAN_SUPPORTED_OS ${platform}sim)
 338         endif()
 339         foreach(arch ${DARWIN_${platform}sim_ARCHS})
 340           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
 341           set(CAN_TARGET_${arch} 1)
 342         endforeach()
 343       endif()
 344
 345       if(DARWIN_${platform}_SYSROOT)
 346         set(DARWIN_${platform}_CFLAGS
 347           ${DARWIN_COMMON_CFLAGS}
 348           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
 349           -isysroot ${DARWIN_${platform}_SYSROOT})
 350         set(DARWIN_${platform}_LINK_FLAGS
 351           ${DARWIN_COMMON_LINK_FLAGS}
 352           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
 353           -isysroot ${DARWIN_${platform}_SYSROOT})
 354
 355         darwin_test_archs(${platform}
 356           DARWIN_${platform}_ARCHS
 357           ${toolchain_arches})
 358         message(STATUS "${platform} supported arches: ${DARWIN_${platform}_ARCHS}")
 359         if(DARWIN_${platform}_ARCHS)
 360           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform})
 361           list(APPEND PROFILE_SUPPORTED_OS ${platform})
 362           list(APPEND TSAN_SUPPORTED_OS ${platform})
 363         endif()
 364         foreach(arch ${DARWIN_${platform}_ARCHS})
 365           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
 366           set(CAN_TARGET_${arch} 1)
 367         endforeach()
 368       endif()
 369     endforeach()
 370   endif()
 371
 372   # for list_intersect
 373   include(CompilerRTUtils)
 374
 375
 376   list_intersect(SANITIZER_COMMON_SUPPORTED_ARCH
 377     ALL_SANITIZER_COMMON_SUPPORTED_ARCH
 378     COMPILER_RT_SUPPORTED_ARCH
 379     )
 380   set(LSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
 381   set(UBSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
 382   list_intersect(ASAN_SUPPORTED_ARCH
 383     ALL_ASAN_SUPPORTED_ARCH
 384     SANITIZER_COMMON_SUPPORTED_ARCH)
 385   list_intersect(DFSAN_SUPPORTED_ARCH
 386     ALL_DFSAN_SUPPORTED_ARCH
 387     SANITIZER_COMMON_SUPPORTED_ARCH)
 388   list_intersect(LSAN_SUPPORTED_ARCH
 389     ALL_LSAN_SUPPORTED_ARCH
 390     SANITIZER_COMMON_SUPPORTED_ARCH)
 391   list_intersect(MSAN_SUPPORTED_ARCH
 392     ALL_MSAN_SUPPORTED_ARCH
 393     SANITIZER_COMMON_SUPPORTED_ARCH)
 394   list_intersect(PROFILE_SUPPORTED_ARCH
 395     ALL_PROFILE_SUPPORTED_ARCH
 396     SANITIZER_COMMON_SUPPORTED_ARCH)
 397   list_intersect(TSAN_SUPPORTED_ARCH
 398     ALL_TSAN_SUPPORTED_ARCH
 399     SANITIZER_COMMON_SUPPORTED_ARCH)
 400   list_intersect(UBSAN_SUPPORTED_ARCH
 401     ALL_UBSAN_SUPPORTED_ARCH
 402     SANITIZER_COMMON_SUPPORTED_ARCH)
 403   list_intersect(SAFESTACK_SUPPORTED_ARCH
 404     ALL_SAFESTACK_SUPPORTED_ARCH
 405     SANITIZER_COMMON_SUPPORTED_ARCH)
 406   list_intersect(CFI_SUPPORTED_ARCH
 407     ALL_CFI_SUPPORTED_ARCH
 408     SANITIZER_COMMON_SUPPORTED_ARCH)
 409   list_intersect(ESAN_SUPPORTED_ARCH
 410     ALL_ESAN_SUPPORTED_ARCH
 411     SANITIZER_COMMON_SUPPORTED_ARCH)
 412   list_intersect(SCUDO_SUPPORTED_ARCH
 413     ALL_SCUDO_SUPPORTED_ARCH
 414     SANITIZER_COMMON_SUPPORTED_ARCH)
 415   list_intersect(XRAY_SUPPORTED_ARCH
 416     ALL_XRAY_SUPPORTED_ARCH
 417     SANITIZER_COMMON_SUPPORTED_ARCH)
 418   list_intersect(FUZZER_SUPPORTED_ARCH
 419     ALL_FUZZER_SUPPORTED_ARCH
 420     ALL_SANITIZER_COMMON_SUPPORTED_ARCH)
 421
 422 else()
 423   # Architectures supported by compiler-rt libraries.
 424   filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
 425     ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
 426   # LSan and UBSan common files should be available on all architectures
 427   # supported by other sanitizers (even if they build into dummy object files).
 428   filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
 429     ${SANITIZER_COMMON_SUPPORTED_ARCH})
 430   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
 431     ${SANITIZER_COMMON_SUPPORTED_ARCH})
 432   filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
 433   filter_available_targets(FUZZER_SUPPORTED_ARCH ${ALL_FUZZER_SUPPORTED_ARCH})
 434   filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
 435   filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
 436   filter_available_targets(MSAN_SUPPORTED_ARCH ${ALL_MSAN_SUPPORTED_ARCH})
 437   filter_available_targets(PROFILE_SUPPORTED_ARCH ${ALL_PROFILE_SUPPORTED_ARCH})
 438   filter_available_targets(TSAN_SUPPORTED_ARCH ${ALL_TSAN_SUPPORTED_ARCH})
 439   filter_available_targets(UBSAN_SUPPORTED_ARCH ${ALL_UBSAN_SUPPORTED_ARCH})
 440   filter_available_targets(SAFESTACK_SUPPORTED_ARCH
 441     ${ALL_SAFESTACK_SUPPORTED_ARCH})
 442   filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH})
 443   filter_available_targets(ESAN_SUPPORTED_ARCH ${ALL_ESAN_SUPPORTED_ARCH})
 444   filter_available_targets(SCUDO_SUPPORTED_ARCH ${ALL_SCUDO_SUPPORTED_ARCH})
 445   filter_available_targets(XRAY_SUPPORTED_ARCH ${ALL_XRAY_SUPPORTED_ARCH})
 446 endif()
 447
 448 if (MSVC)
 449   # See if the DIA SDK is available and usable.
 450   set(MSVC_DIA_SDK_DIR "$ENV{VSINSTALLDIR}DIA SDK")
 451   if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
 452     set(CAN_SYMBOLIZE 1)
 453   else()
 454     set(CAN_SYMBOLIZE 0)
 455   endif()
 456 else()
 457   set(CAN_SYMBOLIZE 1)
 458 endif()
 459
 460 find_program(GOLD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.gold ld.gold ${LLVM_DEFAULT_TARGET_TRIPLE}-ld ld DOC "The gold linker")
 461
 462 if(COMPILER_RT_SUPPORTED_ARCH)
 463   list(REMOVE_DUPLICATES COMPILER_RT_SUPPORTED_ARCH)
 464 endif()
 465 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 466
 467 if(ANDROID)
 468   set(OS_NAME "Android")
 469 else()
 470   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 471 endif()
 472
 473 set(ALL_SANITIZERS asan;dfsan;msan;tsan;safestack;cfi;esan;scudo)
 474 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
 475     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 476 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
 477
 478 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
 479     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD|NetBSD|Fuchsia" OR
 480     (OS_NAME MATCHES "Windows" AND (NOT MINGW AND NOT CYGWIN))))
 481   set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
 482 else()
 483   set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
 484 endif()
 485
 486 if (COMPILER_RT_HAS_SANITIZER_COMMON)
 487   set(COMPILER_RT_HAS_INTERCEPTION TRUE)
 488 else()
 489   set(COMPILER_RT_HAS_INTERCEPTION FALSE)
 490 endif()
 491
 492 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH)
 493   set(COMPILER_RT_HAS_ASAN TRUE)
 494 else()
 495   set(COMPILER_RT_HAS_ASAN FALSE)
 496 endif()
 497
 498 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD")
 499   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 500 else()
 501   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
 502 endif()
 503
 504 # TODO: Add builtins support.
 505
 506 if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
 507     OS_NAME MATCHES "Linux")
 508   set(COMPILER_RT_HAS_DFSAN TRUE)
 509 else()
 510   set(COMPILER_RT_HAS_DFSAN FALSE)
 511 endif()
 512
 513 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
 514     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
 515   set(COMPILER_RT_HAS_LSAN TRUE)
 516 else()
 517   set(COMPILER_RT_HAS_LSAN FALSE)
 518 endif()
 519
 520 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
 521     OS_NAME MATCHES "Linux")
 522   set(COMPILER_RT_HAS_MSAN TRUE)
 523 else()
 524   set(COMPILER_RT_HAS_MSAN FALSE)
 525 endif()
 526
 527 if (PROFILE_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
 528     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows|Android")
 529   set(COMPILER_RT_HAS_PROFILE TRUE)
 530 else()
 531   set(COMPILER_RT_HAS_PROFILE FALSE)
 532 endif()
 533
 534 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
 535     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Android")
 536   set(COMPILER_RT_HAS_TSAN TRUE)
 537 else()
 538   set(COMPILER_RT_HAS_TSAN FALSE)
 539 endif()
 540
 541 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
 542     OS_NAME MATCHES "Darwin|Linux|FreeBSD|NetBSD|Windows|Android|Fuchsia")
 543   set(COMPILER_RT_HAS_UBSAN TRUE)
 544 else()
 545   set(COMPILER_RT_HAS_UBSAN FALSE)
 546 endif()
 547
 548 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND
 549     OS_NAME MATCHES "Darwin|Linux|FreeBSD|NetBSD")
 550   set(COMPILER_RT_HAS_SAFESTACK TRUE)
 551 else()
 552   set(COMPILER_RT_HAS_SAFESTACK FALSE)
 553 endif()
 554
 555 if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND
 556     OS_NAME MATCHES "Linux")
 557   set(COMPILER_RT_HAS_CFI TRUE)
 558 else()
 559   set(COMPILER_RT_HAS_CFI FALSE)
 560 endif()
 561
 562 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ESAN_SUPPORTED_ARCH AND
 563     OS_NAME MATCHES "Linux")
 564   set(COMPILER_RT_HAS_ESAN TRUE)
 565 else()
 566   set(COMPILER_RT_HAS_ESAN FALSE)
 567 endif()
 568
 569 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SCUDO_SUPPORTED_ARCH AND
 570     OS_NAME MATCHES "Linux")
 571   set(COMPILER_RT_HAS_SCUDO TRUE)
 572 else()
 573   set(COMPILER_RT_HAS_SCUDO FALSE)
 574 endif()
 575
 576 if (COMPILER_RT_HAS_SANITIZER_COMMON AND XRAY_SUPPORTED_ARCH AND
 577     OS_NAME MATCHES "Linux")
 578   set(COMPILER_RT_HAS_XRAY TRUE)
 579 else()
 580   set(COMPILER_RT_HAS_XRAY FALSE)
 581 endif()
 582
 583 if (COMPILER_RT_HAS_SANITIZER_COMMON AND FUZZER_SUPPORTED_ARCH AND
 584       OS_NAME MATCHES "Darwin|Linux")
 585   set(COMPILER_RT_HAS_FUZZER TRUE)
 586 else()
 587   set(COMPILER_RT_HAS_FUZZER FALSE)
 588 endif()