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