compiler-rt/cmake/config-ix.cmake

   1 include(CMakePushCheckState)
   2 include(AddLLVM)
   3 include(CheckCCompilerFlag)
   4 include(CheckCXXCompilerFlag)
   5 include(CheckIncludeFiles)
   6 include(CheckLibraryExists)
   7 include(LLVMCheckCompilerLinkerFlag)
   8 include(CheckSymbolExists)
   9 include(TestBigEndian)
  10
  11 # The compiler driver may be implicitly trying to link against libunwind.
  12 # This is normally ok (libcxx relies on an unwinder), but if libunwind is
  13 # built in the same cmake invocation as compiler-rt and we're using the
  14 # in tree version of runtimes, we'd be linking against the just-built
  15 # libunwind (and the compiler implicit -lunwind wouldn't succeed as the newly
  16 # built libunwind isn't installed yet). For those cases, it'd be good to
  17 # link with --unwindlib=none. Check if that option works.
  18 llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
  19
  20 check_library_exists(c fopen "" COMPILER_RT_HAS_LIBC)
  21 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
  22   include(HandleCompilerRT)
  23   find_compiler_rt_library(builtins COMPILER_RT_BUILTINS_LIBRARY
  24                            FLAGS ${SANITIZER_COMMON_FLAGS})
  25   # TODO(PR51389): We should check COMPILER_RT_BUILTINS_LIBRARY and report an
  26   # error if the value is NOTFOUND rather than silenty continuing but we first
  27   # need to fix find_compiler_rt_library on Darwin.
  28 else()
  29   if (ANDROID)
  30     check_library_exists(gcc __gcc_personality_v0 "" COMPILER_RT_HAS_GCC_LIB)
  31   else()
  32     check_library_exists(gcc_s __gcc_personality_v0 "" COMPILER_RT_HAS_GCC_S_LIB)
  33   endif()
  34 endif()
  35
  36 check_c_compiler_flag(-nodefaultlibs C_SUPPORTS_NODEFAULTLIBS_FLAG)
  37 if (C_SUPPORTS_NODEFAULTLIBS_FLAG)
  38   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
  39   if (COMPILER_RT_HAS_LIBC)
  40     if (HAIKU)
  41       list(APPEND CMAKE_REQUIRED_LIBRARIES root)
  42     else()
  43       list(APPEND CMAKE_REQUIRED_LIBRARIES c)
  44     endif()
  45   endif ()
  46   if (COMPILER_RT_USE_BUILTINS_LIBRARY)
  47     # TODO: remote this check once we address PR51389.
  48     if (${COMPILER_RT_BUILTINS_LIBRARY})
  49       list(APPEND CMAKE_REQUIRED_LIBRARIES "${COMPILER_RT_BUILTINS_LIBRARY}")
  50     endif()
  51   elseif (COMPILER_RT_HAS_GCC_S_LIB)
  52     list(APPEND CMAKE_REQUIRED_LIBRARIES gcc_s)
  53   elseif (COMPILER_RT_HAS_GCC_LIB)
  54     list(APPEND CMAKE_REQUIRED_LIBRARIES gcc)
  55   endif ()
  56   if (MINGW)
  57     # Mingw64 requires quite a few "C" runtime libraries in order for basic
  58     # programs to link successfully with -nodefaultlibs.
  59     if (COMPILER_RT_USE_BUILTINS_LIBRARY)
  60       set(MINGW_RUNTIME ${COMPILER_RT_BUILTINS_LIBRARY})
  61     else ()
  62       set(MINGW_RUNTIME gcc_s gcc)
  63     endif()
  64     set(MINGW_LIBRARIES mingw32 ${MINGW_RUNTIME} moldname mingwex msvcrt advapi32
  65                         shell32 user32 kernel32 mingw32 ${MINGW_RUNTIME}
  66                         moldname mingwex msvcrt)
  67     list(APPEND CMAKE_REQUIRED_LIBRARIES ${MINGW_LIBRARIES})
  68   endif()
  69   if (NOT TARGET unwind)
  70     # Don't check for a library named unwind, if there's a target with that name within
  71     # the same build.
  72     check_library_exists(unwind _Unwind_GetRegionStart "" COMPILER_RT_HAS_LIBUNWIND)
  73     if (COMPILER_RT_HAS_LIBUNWIND)
  74       # If we're omitting default libraries, we might need to manually link in libunwind.
  75       # This can affect whether we detect a statically linked libc++ correctly.
  76       list(APPEND CMAKE_REQUIRED_LIBRARIES unwind)
  77     endif()
  78   endif()
  79 endif ()
  80
  81 if (COMPILER_RT_USE_ATOMIC_LIBRARY)
  82   include(HandleCompilerRT)
  83   find_compiler_rt_library(atomic COMPILER_RT_ATOMIC_LIBRARY SHARED
  84                            FLAGS ${SANITIZER_COMMON_FLAGS})
  85 else()
  86   check_library_exists(atomic __atomic_load_8 "" COMPILER_RT_HAS_LIBATOMIC)
  87 endif()
  88
  89 # CodeGen options.
  90 check_c_compiler_flag(-ffreestanding         COMPILER_RT_HAS_FFREESTANDING_FLAG)
  91 check_c_compiler_flag(-fomit-frame-pointer   COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG)
  92 check_c_compiler_flag(-std=c11               COMPILER_RT_HAS_STD_C11_FLAG)
  93 check_c_compiler_flag(-fcf-protection=full   COMPILER_RT_HAS_FCF_PROTECTION_FLAG)
  94 check_cxx_compiler_flag(-fPIC                COMPILER_RT_HAS_FPIC_FLAG)
  95 check_cxx_compiler_flag(-fPIE                COMPILER_RT_HAS_FPIE_FLAG)
  96 check_cxx_compiler_flag(-fno-builtin         COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
  97 check_cxx_compiler_flag(-fno-exceptions      COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
  98 check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)
  99 check_cxx_compiler_flag(-funwind-tables      COMPILER_RT_HAS_FUNWIND_TABLES_FLAG)
 100 check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG)
 101 check_cxx_compiler_flag(-fno-sanitize=safe-stack COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG)
 102 check_cxx_compiler_flag(-fvisibility=hidden  COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
 103 check_cxx_compiler_flag(-frtti               COMPILER_RT_HAS_FRTTI_FLAG)
 104 check_cxx_compiler_flag(-fno-rtti            COMPILER_RT_HAS_FNO_RTTI_FLAG)
 105 check_cxx_compiler_flag("-Werror -fno-function-sections" COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG)
 106 check_cxx_compiler_flag(-ftls-model=initial-exec COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC)
 107 check_cxx_compiler_flag(-fno-lto             COMPILER_RT_HAS_FNO_LTO_FLAG)
 108 check_cxx_compiler_flag(-fno-profile-generate COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG)
 109 check_cxx_compiler_flag(-fno-profile-instr-generate COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG)
 110 check_cxx_compiler_flag(-fno-profile-instr-use COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_FLAG)
 111 check_cxx_compiler_flag(-fno-coverage-mapping COMPILER_RT_HAS_FNO_COVERAGE_MAPPING_FLAG)
 112 check_cxx_compiler_flag("-Werror -mcrc32"    COMPILER_RT_HAS_MCRC32_FLAG)
 113 check_cxx_compiler_flag("-Werror -msse4.2"   COMPILER_RT_HAS_MSSE4_2_FLAG)
 114 check_cxx_compiler_flag(--sysroot=.          COMPILER_RT_HAS_SYSROOT_FLAG)
 115 check_cxx_compiler_flag("-Werror -mcrc"      COMPILER_RT_HAS_MCRC_FLAG)
 116 check_cxx_compiler_flag(-fno-partial-inlining COMPILER_RT_HAS_FNO_PARTIAL_INLINING_FLAG)
 117 check_cxx_compiler_flag("-Werror -ftrivial-auto-var-init=pattern" COMPILER_RT_HAS_TRIVIAL_AUTO_INIT)
 118
 119 if(NOT WIN32 AND NOT CYGWIN)
 120   # MinGW warns if -fvisibility-inlines-hidden is used.
 121   check_cxx_compiler_flag("-fvisibility-inlines-hidden" COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG)
 122 endif()
 123
 124 check_cxx_compiler_flag(/GR COMPILER_RT_HAS_GR_FLAG)
 125 check_cxx_compiler_flag(/GS COMPILER_RT_HAS_GS_FLAG)
 126 check_cxx_compiler_flag(/MT COMPILER_RT_HAS_MT_FLAG)
 127 check_cxx_compiler_flag(/Oy COMPILER_RT_HAS_Oy_FLAG)
 128
 129 # Debug info flags.
 130 check_cxx_compiler_flag(-gline-tables-only COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG)
 131 check_cxx_compiler_flag(-g COMPILER_RT_HAS_G_FLAG)
 132 check_cxx_compiler_flag(/Zi COMPILER_RT_HAS_Zi_FLAG)
 133
 134 # Warnings.
 135 check_cxx_compiler_flag(-Wall COMPILER_RT_HAS_WALL_FLAG)
 136 check_cxx_compiler_flag(-Werror COMPILER_RT_HAS_WERROR_FLAG)
 137 check_cxx_compiler_flag("-Werror -Wframe-larger-than=512" COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG)
 138 check_cxx_compiler_flag("-Werror -Wglobal-constructors"   COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG)
 139 check_cxx_compiler_flag("-Werror -Wc99-extensions"     COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG)
 140 check_cxx_compiler_flag("-Werror -Wgnu"                COMPILER_RT_HAS_WGNU_FLAG)
 141 check_cxx_compiler_flag("-Werror -Wgnu-anonymous-struct" COMPILER_RT_HAS_WGNU_ANONYMOUS_STRUCT_FLAG)
 142 check_cxx_compiler_flag("-Werror -Wvariadic-macros"    COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG)
 143 check_cxx_compiler_flag("-Werror -Wunused-parameter"   COMPILER_RT_HAS_WUNUSED_PARAMETER_FLAG)
 144 check_cxx_compiler_flag("-Werror -Wcovered-switch-default" COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG)
 145 check_cxx_compiler_flag("-Werror -Wsuggest-override"   COMPILER_RT_HAS_WSUGGEST_OVERRIDE_FLAG)
 146 check_cxx_compiler_flag("-Werror -Wthread-safety" COMPILER_RT_HAS_WTHREAD_SAFETY_FLAG)
 147 check_cxx_compiler_flag("-Werror -Wthread-safety-reference" COMPILER_RT_HAS_WTHREAD_SAFETY_REFERENCE_FLAG)
 148 check_cxx_compiler_flag("-Werror -Wthread-safety-beta" COMPILER_RT_HAS_WTHREAD_SAFETY_BETA_FLAG)
 149 check_cxx_compiler_flag(-Wno-pedantic COMPILER_RT_HAS_WNO_PEDANTIC)
 150 check_cxx_compiler_flag(-Wno-format COMPILER_RT_HAS_WNO_FORMAT)
 151 check_cxx_compiler_flag(-Wno-format-pedantic COMPILER_RT_HAS_WNO_FORMAT_PEDANTIC)
 152
 153 check_cxx_compiler_flag("/experimental:external /external:W0" COMPILER_RT_HAS_EXTERNAL_FLAG)
 154
 155 check_cxx_compiler_flag(/W4 COMPILER_RT_HAS_W4_FLAG)
 156 check_cxx_compiler_flag(/WX COMPILER_RT_HAS_WX_FLAG)
 157 check_cxx_compiler_flag(/wd4146 COMPILER_RT_HAS_WD4146_FLAG)
 158 check_cxx_compiler_flag(/wd4206 COMPILER_RT_HAS_WD4206_FLAG)
 159 check_cxx_compiler_flag(/wd4291 COMPILER_RT_HAS_WD4291_FLAG)
 160 check_cxx_compiler_flag(/wd4221 COMPILER_RT_HAS_WD4221_FLAG)
 161 check_cxx_compiler_flag(/wd4391 COMPILER_RT_HAS_WD4391_FLAG)
 162 check_cxx_compiler_flag(/wd4722 COMPILER_RT_HAS_WD4722_FLAG)
 163 check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG)
 164
 165 check_cxx_compiler_flag("-Werror -Warray-bounds" COMPILER_RT_HAS_ARRAY_BOUNDS_FLAG)
 166 check_cxx_compiler_flag("-Werror -Wuninitialized" COMPILER_RT_HAS_UNINITIALIZED_FLAG)
 167 check_cxx_compiler_flag("-Werror -Wshadow" COMPILER_RT_HAS_SHADOW_FLAG)
 168 check_cxx_compiler_flag("-Werror -Wempty-body" COMPILER_RT_HAS_EMPTY_BODY_FLAG)
 169 check_cxx_compiler_flag("-Werror -Wsizeof-pointer-memaccess" COMPILER_RT_HAS_SIZEOF_POINTER_MEMACCESS_FLAG)
 170 check_cxx_compiler_flag("-Werror -Wsizeof-array-argument" COMPILER_RT_HAS_SIZEOF_ARRAY_ARGUMENT_FLAG)
 171 check_cxx_compiler_flag("-Werror -Wsuspicious-memaccess" COMPILER_RT_HAS_SUSPICIOUS_MEMACCESS_FLAG)
 172 check_cxx_compiler_flag("-Werror -Wbuiltin-memcpy-chk-size" COMPILER_RT_HAS_BUILTIN_MEMCPY_CHK_SIZE_FLAG)
 173 check_cxx_compiler_flag("-Werror -Warray-bounds-pointer-arithmetic" COMPILER_RT_HAS_ARRAY_BOUNDS_POINTER_ARITHMETIC_FLAG)
 174 check_cxx_compiler_flag("-Werror -Wreturn-stack-address" COMPILER_RT_HAS_RETURN_STACK_ADDRESS_FLAG)
 175 check_cxx_compiler_flag("-Werror -Wsizeof-array-decay" COMPILER_RT_HAS_SIZEOF_ARRAY_DECAY_FLAG)
 176 check_cxx_compiler_flag("-Werror -Wformat-insufficient-args" COMPILER_RT_HAS_FORMAT_INSUFFICIENT_ARGS_FLAG)
 177 check_cxx_compiler_flag("-Werror -Wformat-security" COMPILER_RT_HAS_BUILTIN_FORMAL_SECURITY_FLAG)
 178 check_cxx_compiler_flag("-Werror -Wsizeof-array-div" COMPILER_RT_HAS_SIZEOF_ARRAY_DIV_FLAG)
 179 check_cxx_compiler_flag("-Werror -Wsizeof-pointer-div" COMPILER_RT_HAS_SIZEOF_POINTER_DIV_FLAG)
 180
 181 # Symbols.
 182 check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL)
 183
 184 # Includes.
 185 check_cxx_compiler_flag(-nostdinc++ COMPILER_RT_HAS_NOSTDINCXX_FLAG)
 186 check_cxx_compiler_flag(-nostdlib++ COMPILER_RT_HAS_NOSTDLIBXX_FLAG)
 187 check_include_files("sys/auxv.h"    COMPILER_RT_HAS_AUXV)
 188
 189 # Libraries.
 190 check_library_exists(dl dlopen "" COMPILER_RT_HAS_LIBDL)
 191 check_library_exists(rt shm_open "" COMPILER_RT_HAS_LIBRT)
 192 check_library_exists(m pow "" COMPILER_RT_HAS_LIBM)
 193 check_library_exists(pthread pthread_create "" COMPILER_RT_HAS_LIBPTHREAD)
 194 check_library_exists(execinfo backtrace "" COMPILER_RT_HAS_LIBEXECINFO)
 195
 196 if (ANDROID AND COMPILER_RT_HAS_LIBDL)
 197   # Android's libstdc++ has a dependency on libdl.
 198   list(APPEND CMAKE_REQUIRED_LIBRARIES dl)
 199 endif()
 200 check_library_exists(c++ __cxa_throw "" COMPILER_RT_HAS_LIBCXX)
 201 check_library_exists(stdc++ __cxa_throw "" COMPILER_RT_HAS_LIBSTDCXX)
 202
 203 # Linker flags.
 204 llvm_check_compiler_linker_flag(C "-Wl,-z,text" COMPILER_RT_HAS_Z_TEXT)
 205 llvm_check_compiler_linker_flag(C "-fuse-ld=lld" COMPILER_RT_HAS_FUSE_LD_LLD_FLAG)
 206
 207 if(${CMAKE_SYSTEM_NAME} MATCHES "SunOS" AND LLVM_LINKER_IS_SOLARISLD)
 208   set(VERS_COMPAT_OPTION "-Wl,-z,gnu-version-script-compat")
 209   llvm_check_compiler_linker_flag(C "${VERS_COMPAT_OPTION}" COMPILER_RT_HAS_GNU_VERSION_SCRIPT_COMPAT)
 210 endif()
 211
 212 set(DUMMY_VERS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/dummy.vers)
 213 file(WRITE ${DUMMY_VERS} "{};")
 214 set(VERS_OPTION "-Wl,--version-script,${DUMMY_VERS}")
 215 if(COMPILER_RT_HAS_GNU_VERSION_SCRIPT_COMPAT)
 216   # Solaris 11.4 ld only supports --version-script with
 217   # -z gnu-version-script-compat.
 218   string(APPEND VERS_OPTION " ${VERS_COMPAT_OPTION}")
 219 endif()
 220 llvm_check_compiler_linker_flag(C "${VERS_OPTION}" COMPILER_RT_HAS_VERSION_SCRIPT)
 221
 222 if(ANDROID)
 223   llvm_check_compiler_linker_flag(C "-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
 224   check_library_exists(log __android_log_write "" COMPILER_RT_HAS_LIBLOG)
 225 endif()
 226
 227 # Architectures.
 228
 229 # List of all architectures we can target.
 230 set(COMPILER_RT_SUPPORTED_ARCH)
 231
 232 # Try to compile a very simple source file to ensure we can target the given
 233 # platform. We use the results of these tests to build only the various target
 234 # runtime libraries supported by our current compilers cross-compiling
 235 # abilities.
 236 set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc)
 237 file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <stdio.h>\nint main(void) { printf(\"hello, world\"); }\n")
 238
 239 # Detect whether the current target platform is 32-bit or 64-bit, and setup
 240 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
 241 # AVR and MSP430 are omitted since they have 16-bit pointers.
 242 if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
 243     NOT CMAKE_SIZEOF_VOID_P EQUAL 8 AND
 244     NOT ${arch} MATCHES "avr|msp430")
 245   message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
 246 endif()
 247
 248 test_targets()
 249
 250 # Returns a list of architecture specific target cflags in @out_var list.
 251 function(get_target_flags_for_arch arch out_var)
 252   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
 253   if(ARCH_INDEX EQUAL -1)
 254     message(FATAL_ERROR "Unsupported architecture: ${arch}")
 255   else()
 256     if (NOT APPLE)
 257       set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
 258     else()
 259       # This is only called in constructing cflags for tests executing on the
 260       # host. This will need to all be cleaned up to support building tests
 261       # for cross-targeted hardware (i.e. iOS).
 262       set(${out_var} -arch ${arch} PARENT_SCOPE)
 263     endif()
 264   endif()
 265 endfunction()
 266
 267 # Returns a list of architecture specific target ldflags in @out_var list.
 268 function(get_target_link_flags_for_arch arch out_var)
 269   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
 270   if(ARCH_INDEX EQUAL -1)
 271     message(FATAL_ERROR "Unsupported architecture: ${arch}")
 272   else()
 273     # Workaround for direct calls to __tls_get_addr on Solaris/amd64.
 274     if(OS_NAME MATCHES "SunOS" AND ${arch} MATCHES x86_64)
 275       set(${out_var} "-Wl,-z,relax=transtls" PARENT_SCOPE)
 276     endif()
 277   endif()
 278 endfunction()
 279
 280 # Returns a list of architecture specific dynamic ldflags in @out_var list.
 281 function(get_dynamic_link_flags_for_arch arch out_var)
 282   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
 283   if(ARCH_INDEX EQUAL -1)
 284     message(FATAL_ERROR "Unsupported architecture: ${arch}")
 285   else()
 286     get_compiler_rt_output_dir(${arch} rtlib_dir)
 287     if (NOT WIN32)
 288       set(${out_var} "-Wl,-rpath,${rtlib_dir}" PARENT_SCOPE)
 289     endif()
 290   endif()
 291 endfunction()
 292
 293 # Returns a compiler and CFLAGS that should be used to run tests for the
 294 # specific architecture.  When cross-compiling, this is controled via
 295 # COMPILER_RT_TEST_COMPILER and COMPILER_RT_TEST_COMPILER_CFLAGS.
 296 macro(get_test_cc_for_arch arch cc_out cflags_out)
 297   if (NOT ${ARGC} EQUAL 3)
 298     message(FATAL_ERROR "got too many args. expected 3, got ${ARGC} (namely: ${ARGV})")
 299   endif()
 300   if(ANDROID OR (NOT APPLE AND ${arch} MATCHES "arm|aarch64|riscv32|riscv64"))
 301     # This is only true if we are cross-compiling.
 302     # Build all tests with host compiler and use host tools.
 303     set(${cc_out} ${COMPILER_RT_TEST_COMPILER})
 304     set(${cflags_out} ${COMPILER_RT_TEST_COMPILER_CFLAGS})
 305   else()
 306     get_target_flags_for_arch(${arch} ${cflags_out})
 307     if(APPLE)
 308       list(APPEND ${cflags_out} ${DARWIN_osx_CFLAGS})
 309     endif()
 310     string(REPLACE ";" " " ${cflags_out} "${${cflags_out}}")
 311   endif()
 312 endmacro()
 313
 314 # Returns CFLAGS that should be used to run tests for the
 315 # specific apple platform and architecture.
 316 function(get_test_cflags_for_apple_platform platform arch cflags_out)
 317   is_valid_apple_platform("${platform}" is_valid_platform)
 318   if (NOT is_valid_platform)
 319     message(FATAL_ERROR "\"${platform}\" is not a valid apple platform")
 320   endif()
 321   set(test_cflags "")
 322   get_target_flags_for_arch(${arch} test_cflags)
 323
 324   if (NOT "${arch}" STREQUAL "arm64e")
 325     list(APPEND test_cflags ${DARWIN_${platform}_CFLAGS})
 326   else()
 327     # arm64e is not currently ABI stable so we need to build for the
 328     # OS version being tested. Rather than querying the device under test
 329     # we use the SDK version which "should" be the same as the
 330     # device under test (it is a configuration error for these not to match).
 331     # FIXME(dliew): We can remove this if we build the runtimes with the appropriate
 332     # deployment target for arm64e.
 333     foreach (flag ${DARWIN_${platform}_CFLAGS})
 334       if ("${flag}" MATCHES "^${DARWIN_${platform}_MIN_VER_FLAG}=.+")
 335         # Find the SDK version
 336         get_xcrun_platform_from_apple_platform("${platform}" xcrun_platform_name)
 337         # TODO(dliew): Remove this check once get_xcrun_platform_from_apple_platform
 338         # emits a fatal error for unrecognised platforms.
 339         if (NOT "${xcrun_platform_name}" STREQUAL "")
 340           find_darwin_sdk_version(platform_sdk_version "${xcrun_platform_name}")
 341           # Patch flag with correct deployment target
 342           set(replacement_flag "${DARWIN_${platform}_MIN_VER_FLAG}=${platform_sdk_version}")
 343           list(APPEND test_cflags "${replacement_flag}")
 344         endif()
 345       else()
 346         # Copy through
 347         list(APPEND test_cflags "${flag}")
 348       endif()
 349     endforeach()
 350   endif()
 351
 352   string(REPLACE ";" " " test_cflags_str "${test_cflags}")
 353   string(APPEND test_cflags_str "${COMPILER_RT_TEST_COMPILER_CFLAGS}")
 354   set(${cflags_out} "${test_cflags_str}" PARENT_SCOPE)
 355 endfunction()
 356
 357 function(get_capitalized_apple_platform platform platform_capitalized)
 358   # TODO(dliew): Remove uses of this function. It exists to preserve needlessly complex
 359   # directory naming conventions used by the Sanitizer lit test suites.
 360   is_valid_apple_platform("${platform}" is_valid_platform)
 361   if (NOT is_valid_platform)
 362     message(FATAL_ERROR "\"${platform}\" is not a valid apple platform")
 363   endif()
 364   string(TOUPPER "${platform}" platform_upper)
 365   string(REGEX REPLACE "OSSIM$" "OSSim" platform_upper_capitalized "${platform_upper}")
 366   set(${platform_capitalized} "${platform_upper_capitalized}" PARENT_SCOPE)
 367 endfunction()
 368
 369 function(is_valid_apple_platform platform is_valid_out)
 370   set(is_valid FALSE)
 371   if ("${platform}" STREQUAL "")
 372     message(FATAL_ERROR "platform cannot be empty")
 373   endif()
 374   if ("${platform}" MATCHES "^(osx|((ios|watchos|tvos)(sim)?))$")
 375     set(is_valid TRUE)
 376   endif()
 377   set(${is_valid_out} ${is_valid} PARENT_SCOPE)
 378 endfunction()
 379
 380 # Maps the Apple platform name used in Compiler-rt's CMake code
 381 # to the name recognised by xcrun's `--sdk` argument
 382 function(get_xcrun_platform_from_apple_platform platform out_var)
 383   set(xcrun_platform "")
 384   if ("${platform}" STREQUAL "osx")
 385     set(xcrun_platform "macosx")
 386   elseif ("${platform}" STREQUAL "iossim")
 387     set(xcrun_platform "iphonesimulator")
 388   elseif ("${platform}" STREQUAL "ios")
 389     set(xcrun_platform "iphoneos")
 390   elseif ("${platform}" STREQUAL "watchossim")
 391     set(xcrun_platform "watchsimulator")
 392   elseif ("${platform}" STREQUAL "watchos")
 393     set(xcrun_platform "watchos")
 394   elseif ("${platform}" STREQUAL "tvossim")
 395     set(xcrun_platform "appletvsimulator")
 396   elseif ("${platform}" STREQUAL "tvos")
 397     set(xcrun_platform "appletvos")
 398   else()
 399     # TODO(dliew): Make this an error.
 400     message(WARNING "\"${platform}\" is not a handled apple platform")
 401   endif()
 402   set(${out_var} ${xcrun_platform} PARENT_SCOPE)
 403 endfunction()
 404
 405 include(AllSupportedArchDefs)
 406
 407 if(APPLE)
 408   include(CompilerRTDarwinUtils)
 409
 410   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
 411   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
 412   find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos)
 413   find_darwin_sdk_dir(DARWIN_watchossim_SYSROOT watchsimulator)
 414   find_darwin_sdk_dir(DARWIN_watchos_SYSROOT watchos)
 415   find_darwin_sdk_dir(DARWIN_tvossim_SYSROOT appletvsimulator)
 416   find_darwin_sdk_dir(DARWIN_tvos_SYSROOT appletvos)
 417
 418   if(NOT DARWIN_osx_SYSROOT)
 419     message(WARNING "Could not determine OS X sysroot, trying /usr/include")
 420     if(EXISTS /usr/include)
 421       set(DARWIN_osx_SYSROOT /)
 422     else()
 423       message(ERROR "Could not detect OS X Sysroot. Either install Xcode or the Apple Command Line Tools")
 424     endif()
 425   endif()
 426
 427   if(COMPILER_RT_ENABLE_IOS)
 428     list(APPEND DARWIN_EMBEDDED_PLATFORMS ios)
 429     set(DARWIN_ios_MIN_VER 9.0)
 430     set(DARWIN_ios_MIN_VER_FLAG -miphoneos-version-min)
 431     set(DARWIN_ios_SANITIZER_MIN_VER_FLAG
 432       ${DARWIN_ios_MIN_VER_FLAG}=${DARWIN_ios_MIN_VER})
 433     set(DARWIN_iossim_MIN_VER_FLAG -mios-simulator-version-min)
 434     set(DARWIN_iossim_SANITIZER_MIN_VER_FLAG
 435       ${DARWIN_iossim_MIN_VER_FLAG}=${DARWIN_ios_MIN_VER})
 436   endif()
 437   if(COMPILER_RT_ENABLE_WATCHOS)
 438     list(APPEND DARWIN_EMBEDDED_PLATFORMS watchos)
 439     set(DARWIN_watchos_MIN_VER 2.0)
 440     set(DARWIN_watchos_MIN_VER_FLAG -mwatchos-version-min)
 441     set(DARWIN_watchos_SANITIZER_MIN_VER_FLAG
 442       ${DARWIN_watchos_MIN_VER_FLAG}=${DARWIN_watchos_MIN_VER})
 443     set(DARWIN_watchossim_MIN_VER_FLAG -mwatchos-simulator-version-min)
 444     set(DARWIN_watchossim_SANITIZER_MIN_VER_FLAG
 445       ${DARWIN_watchossim_MIN_VER_FLAG}=${DARWIN_watchos_MIN_VER})
 446   endif()
 447   if(COMPILER_RT_ENABLE_TVOS)
 448     list(APPEND DARWIN_EMBEDDED_PLATFORMS tvos)
 449     set(DARWIN_tvos_MIN_VER 9.0)
 450     set(DARWIN_tvos_MIN_VER_FLAG -mtvos-version-min)
 451     set(DARWIN_tvos_SANITIZER_MIN_VER_FLAG
 452       ${DARWIN_tvos_MIN_VER_FLAG}=${DARWIN_tvos_MIN_VER})
 453     set(DARWIN_tvossim_MIN_VER_FLAG -mtvos-simulator-version-min)
 454     set(DARWIN_tvossim_SANITIZER_MIN_VER_FLAG
 455       ${DARWIN_tvossim_MIN_VER_FLAG}=${DARWIN_tvos_MIN_VER})
 456   endif()
 457
 458   set(SANITIZER_COMMON_SUPPORTED_OS osx)
 459   set(PROFILE_SUPPORTED_OS osx)
 460   set(TSAN_SUPPORTED_OS osx)
 461   set(XRAY_SUPPORTED_OS osx)
 462   set(FUZZER_SUPPORTED_OS osx)
 463   set(ORC_SUPPORTED_OS)
 464   set(UBSAN_SUPPORTED_OS osx)
 465   set(LSAN_SUPPORTED_OS osx)
 466   set(STATS_SUPPORTED_OS osx)
 467
 468   # FIXME: Support a general COMPILER_RT_ENABLE_OSX to match other platforms.
 469   set(ORC_ENABLE_OSX 1 CACHE BOOL "Whether to build the orc runtime library for osx")
 470   if(ORC_ENABLE_OSX)
 471     set(ORC_SUPPORTED_OS osx)
 472   endif()
 473
 474   set(DEFAULT_SANITIZER_MIN_OSX_VERSION 10.13)
 475   set(DARWIN_osx_MIN_VER_FLAG "-mmacosx-version-min")
 476
 477   string(REGEX MATCH "${DARWIN_osx_MIN_VER_FLAG}=([.0-9]+)"
 478          MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
 479
 480   if(NOT SANITIZER_MIN_OSX_VERSION)
 481     if(MACOSX_VERSION_MIN_FLAG)
 482       set(MIN_OSX_VERSION "${CMAKE_MATCH_1}")
 483     elseif(CMAKE_OSX_DEPLOYMENT_TARGET)
 484       set(MIN_OSX_VERSION ${CMAKE_OSX_DEPLOYMENT_TARGET})
 485     else()
 486       set(MIN_OSX_VERSION ${DEFAULT_SANITIZER_MIN_OSX_VERSION})
 487     endif()
 488
 489     # Note: In order to target x86_64h on OS X the minimum deployment target must
 490     # be 10.8 or higher.
 491     if(MIN_OSX_VERSION VERSION_LESS "10.7")
 492       message(FATAL_ERROR "macOS deployment target '${SANITIZER_MIN_OSX_VERSION}' is too old.")
 493     endif()
 494   endif()
 495
 496   set(SANITIZER_MIN_OSX_VERSION "${MIN_OSX_VERSION}" CACHE STRING
 497     "Minimum OS X version to target (e.g. 10.10) for sanitizers.")
 498
 499   # We're setting the flag manually for each target OS
 500   set(CMAKE_OSX_DEPLOYMENT_TARGET "")
 501
 502   set(DARWIN_COMMON_CFLAGS -stdlib=libc++)
 503   set(DARWIN_COMMON_LINK_FLAGS
 504     -stdlib=libc++
 505     -lc++
 506     -lc++abi)
 507
 508   llvm_check_compiler_linker_flag(C "-fapplication-extension" COMPILER_RT_HAS_APP_EXTENSION)
 509   if(COMPILER_RT_HAS_APP_EXTENSION)
 510     list(APPEND DARWIN_COMMON_LINK_FLAGS "-fapplication-extension")
 511   endif()
 512
 513   set(DARWIN_osx_CFLAGS
 514     ${DARWIN_COMMON_CFLAGS}
 515     ${DARWIN_osx_MIN_VER_FLAG}=${SANITIZER_MIN_OSX_VERSION})
 516   set(DARWIN_osx_LINK_FLAGS
 517     ${DARWIN_COMMON_LINK_FLAGS}
 518     ${DARWIN_osx_MIN_VER_FLAG}=${SANITIZER_MIN_OSX_VERSION})
 519
 520   if(DARWIN_osx_SYSROOT)
 521     list(APPEND DARWIN_osx_CFLAGS -isysroot ${DARWIN_osx_SYSROOT})
 522     list(APPEND DARWIN_osx_LINK_FLAGS -isysroot ${DARWIN_osx_SYSROOT})
 523   endif()
 524
 525   # Figure out which arches to use for each OS
 526   darwin_get_toolchain_supported_archs(toolchain_arches)
 527   message(STATUS "Toolchain supported arches: ${toolchain_arches}")
 528
 529   if(NOT MACOSX_VERSION_MIN_FLAG)
 530     darwin_test_archs(osx
 531       DARWIN_osx_ARCHS
 532       ${toolchain_arches})
 533     message(STATUS "OSX supported arches: ${DARWIN_osx_ARCHS}")
 534     foreach(arch ${DARWIN_osx_ARCHS})
 535       list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
 536       set(CAN_TARGET_${arch} 1)
 537     endforeach()
 538
 539     foreach(platform ${DARWIN_EMBEDDED_PLATFORMS})
 540       if(DARWIN_${platform}sim_SYSROOT)
 541         set(DARWIN_${platform}sim_CFLAGS
 542           ${DARWIN_COMMON_CFLAGS}
 543           ${DARWIN_${platform}sim_SANITIZER_MIN_VER_FLAG}
 544           -isysroot ${DARWIN_${platform}sim_SYSROOT})
 545         set(DARWIN_${platform}sim_LINK_FLAGS
 546           ${DARWIN_COMMON_LINK_FLAGS}
 547           ${DARWIN_${platform}sim_SANITIZER_MIN_VER_FLAG}
 548           -isysroot ${DARWIN_${platform}sim_SYSROOT})
 549
 550         set(DARWIN_${platform}sim_SKIP_CC_KEXT On)
 551         darwin_test_archs(${platform}sim
 552           DARWIN_${platform}sim_ARCHS
 553           ${toolchain_arches})
 554         message(STATUS "${platform} Simulator supported arches: ${DARWIN_${platform}sim_ARCHS}")
 555         if(DARWIN_${platform}sim_ARCHS)
 556           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform}sim)
 557           list(APPEND PROFILE_SUPPORTED_OS ${platform}sim)
 558           list(APPEND TSAN_SUPPORTED_OS ${platform}sim)
 559           list(APPEND FUZZER_SUPPORTED_OS ${platform}sim)
 560           list(APPEND ORC_SUPPORTED_OS ${platform}sim)
 561           list(APPEND UBSAN_SUPPORTED_OS ${platform}sim)
 562           list(APPEND LSAN_SUPPORTED_OS ${platform}sim)
 563           list(APPEND STATS_SUPPORTED_OS ${platform}sim)
 564         endif()
 565         foreach(arch ${DARWIN_${platform}sim_ARCHS})
 566           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
 567           set(CAN_TARGET_${arch} 1)
 568         endforeach()
 569       endif()
 570
 571       if(DARWIN_${platform}_SYSROOT)
 572         set(DARWIN_${platform}_CFLAGS
 573           ${DARWIN_COMMON_CFLAGS}
 574           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
 575           -isysroot ${DARWIN_${platform}_SYSROOT})
 576         set(DARWIN_${platform}_LINK_FLAGS
 577           ${DARWIN_COMMON_LINK_FLAGS}
 578           ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG}
 579           -isysroot ${DARWIN_${platform}_SYSROOT})
 580
 581         darwin_test_archs(${platform}
 582           DARWIN_${platform}_ARCHS
 583           ${toolchain_arches})
 584         message(STATUS "${platform} supported arches: ${DARWIN_${platform}_ARCHS}")
 585         if(DARWIN_${platform}_ARCHS)
 586           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform})
 587           list(APPEND PROFILE_SUPPORTED_OS ${platform})
 588
 589           list_intersect(DARWIN_${platform}_TSAN_ARCHS DARWIN_${platform}_ARCHS ALL_TSAN_SUPPORTED_ARCH)
 590           if(DARWIN_${platform}_TSAN_ARCHS)
 591             list(APPEND TSAN_SUPPORTED_OS ${platform})
 592           endif()
 593           list(APPEND FUZZER_SUPPORTED_OS ${platform})
 594           list(APPEND ORC_SUPPORTED_OS ${platform})
 595           list(APPEND UBSAN_SUPPORTED_OS ${platform})
 596           list(APPEND LSAN_SUPPORTED_OS ${platform})
 597           list(APPEND STATS_SUPPORTED_OS ${platform})
 598         endif()
 599         foreach(arch ${DARWIN_${platform}_ARCHS})
 600           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
 601           set(CAN_TARGET_${arch} 1)
 602         endforeach()
 603       endif()
 604     endforeach()
 605   endif()
 606
 607   # Explicitly disable unsupported Sanitizer configurations.
 608   list(REMOVE_ITEM FUZZER_SUPPORTED_OS "watchos")
 609   list(REMOVE_ITEM FUZZER_SUPPORTED_OS "watchossim")
 610
 611   # for list_intersect
 612   include(CompilerRTUtils)
 613
 614   list_intersect(SANITIZER_COMMON_SUPPORTED_ARCH
 615     ALL_SANITIZER_COMMON_SUPPORTED_ARCH
 616     COMPILER_RT_SUPPORTED_ARCH
 617     )
 618   set(LSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
 619   set(UBSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH})
 620   set(ASAN_ABI_SUPPORTED_ARCH ${ALL_ASAN_ABI_SUPPORTED_ARCH})
 621   list_intersect(ASAN_SUPPORTED_ARCH
 622     ALL_ASAN_SUPPORTED_ARCH
 623     SANITIZER_COMMON_SUPPORTED_ARCH)
 624   list_intersect(RTSAN_SUPPORTED_ARCH
 625     ALL_RTSAN_SUPPORTED_ARCH
 626     SANITIZER_COMMON_SUPPORTED_ARCH)
 627   list_intersect(DFSAN_SUPPORTED_ARCH
 628     ALL_DFSAN_SUPPORTED_ARCH
 629     SANITIZER_COMMON_SUPPORTED_ARCH)
 630   list_intersect(GWP_ASAN_SUPPORTED_ARCH
 631     ALL_GWP_ASAN_SUPPORTED_ARCH
 632     SANITIZER_COMMON_SUPPORTED_ARCH)
 633   list_intersect(LSAN_SUPPORTED_ARCH
 634     ALL_LSAN_SUPPORTED_ARCH
 635     SANITIZER_COMMON_SUPPORTED_ARCH)
 636   list_intersect(MSAN_SUPPORTED_ARCH
 637     ALL_MSAN_SUPPORTED_ARCH
 638     SANITIZER_COMMON_SUPPORTED_ARCH)
 639   list_intersect(NSAN_SUPPORTED_ARCH
 640     ALL_NSAN_SUPPORTED_ARCH
 641     SANITIZER_COMMON_SUPPORTED_ARCH)
 642   list_intersect(HWASAN_SUPPORTED_ARCH
 643     ALL_HWASAN_SUPPORTED_ARCH
 644     SANITIZER_COMMON_SUPPORTED_ARCH)
 645   list_intersect(MEMPROF_SUPPORTED_ARCH
 646     ALL_MEMPROF_SUPPORTED_ARCH
 647     SANITIZER_COMMON_SUPPORTED_ARCH)
 648   list_intersect(PROFILE_SUPPORTED_ARCH
 649     ALL_PROFILE_SUPPORTED_ARCH
 650     SANITIZER_COMMON_SUPPORTED_ARCH)
 651   list_intersect(CTX_PROFILE_SUPPORTED_ARCH
 652     ALL_CTX_PROFILE_SUPPORTED_ARCH
 653     SANITIZER_COMMON_SUPPORTED_ARCH)
 654   list_intersect(TSAN_SUPPORTED_ARCH
 655     ALL_TSAN_SUPPORTED_ARCH
 656     SANITIZER_COMMON_SUPPORTED_ARCH)
 657   list_intersect(UBSAN_SUPPORTED_ARCH
 658     ALL_UBSAN_SUPPORTED_ARCH
 659     SANITIZER_COMMON_SUPPORTED_ARCH)
 660   list_intersect(SAFESTACK_SUPPORTED_ARCH
 661     ALL_SAFESTACK_SUPPORTED_ARCH
 662     SANITIZER_COMMON_SUPPORTED_ARCH)
 663   list_intersect(CFI_SUPPORTED_ARCH
 664     ALL_CFI_SUPPORTED_ARCH
 665     SANITIZER_COMMON_SUPPORTED_ARCH)
 666   list_intersect(SCUDO_STANDALONE_SUPPORTED_ARCH
 667     ALL_SCUDO_STANDALONE_SUPPORTED_ARCH
 668     SANITIZER_COMMON_SUPPORTED_ARCH)
 669   list_intersect(FUZZER_SUPPORTED_ARCH
 670     ALL_FUZZER_SUPPORTED_ARCH
 671     SANITIZER_COMMON_SUPPORTED_ARCH)
 672   list_intersect(XRAY_SUPPORTED_ARCH
 673     ALL_XRAY_SUPPORTED_ARCH
 674     SANITIZER_COMMON_SUPPORTED_ARCH)
 675   list_intersect(XRAY_DSO_SUPPORTED_ARCH
 676     ALL_XRAY_DSO_SUPPORTED_ARCH
 677     SANITIZER_COMMON_SUPPORTED_ARCH)
 678   list_intersect(SHADOWCALLSTACK_SUPPORTED_ARCH
 679     ALL_SHADOWCALLSTACK_SUPPORTED_ARCH
 680     SANITIZER_COMMON_SUPPORTED_ARCH)
 681   list_intersect(ORC_SUPPORTED_ARCH
 682     ALL_ORC_SUPPORTED_ARCH
 683     SANITIZER_COMMON_SUPPORTED_ARCH)
 684
 685 else()
 686   # Architectures supported by compiler-rt libraries.
 687   filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
 688     ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
 689   # LSan and UBSan common files should be available on all architectures
 690   # supported by other sanitizers (even if they build into dummy object files).
 691   filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
 692     ${SANITIZER_COMMON_SUPPORTED_ARCH})
 693   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
 694     ${SANITIZER_COMMON_SUPPORTED_ARCH})
 695   filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
 696   filter_available_targets(RTSAN_SUPPORTED_ARCH ${ALL_RTSAN_SUPPORTED_ARCH})
 697   filter_available_targets(FUZZER_SUPPORTED_ARCH ${ALL_FUZZER_SUPPORTED_ARCH})
 698   filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
 699   filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
 700   filter_available_targets(MSAN_SUPPORTED_ARCH ${ALL_MSAN_SUPPORTED_ARCH})
 701   filter_available_targets(HWASAN_SUPPORTED_ARCH ${ALL_HWASAN_SUPPORTED_ARCH})
 702   filter_available_targets(MEMPROF_SUPPORTED_ARCH ${ALL_MEMPROF_SUPPORTED_ARCH})
 703   filter_available_targets(PROFILE_SUPPORTED_ARCH ${ALL_PROFILE_SUPPORTED_ARCH})
 704   filter_available_targets(CTX_PROFILE_SUPPORTED_ARCH ${ALL_CTX_PROFILE_SUPPORTED_ARCH})
 705   filter_available_targets(TSAN_SUPPORTED_ARCH ${ALL_TSAN_SUPPORTED_ARCH})
 706   filter_available_targets(UBSAN_SUPPORTED_ARCH ${ALL_UBSAN_SUPPORTED_ARCH})
 707   filter_available_targets(SAFESTACK_SUPPORTED_ARCH
 708     ${ALL_SAFESTACK_SUPPORTED_ARCH})
 709   filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH})
 710   filter_available_targets(SCUDO_STANDALONE_SUPPORTED_ARCH ${ALL_SCUDO_STANDALONE_SUPPORTED_ARCH})
 711   filter_available_targets(XRAY_SUPPORTED_ARCH ${ALL_XRAY_SUPPORTED_ARCH})
 712   filter_available_targets(XRAY_DSO_SUPPORTED_ARCH ${ALL_XRAY_DSO_SUPPORTED_ARCH})
 713   filter_available_targets(SHADOWCALLSTACK_SUPPORTED_ARCH
 714     ${ALL_SHADOWCALLSTACK_SUPPORTED_ARCH})
 715   filter_available_targets(GWP_ASAN_SUPPORTED_ARCH ${ALL_GWP_ASAN_SUPPORTED_ARCH})
 716   filter_available_targets(NSAN_SUPPORTED_ARCH ${ALL_NSAN_SUPPORTED_ARCH})
 717   filter_available_targets(ORC_SUPPORTED_ARCH ${ALL_ORC_SUPPORTED_ARCH})
 718 endif()
 719
 720 if (MSVC)
 721   # Allow setting clang-cl's /winsysroot flag.
 722   set(LLVM_WINSYSROOT "" CACHE STRING
 723     "If set, argument to clang-cl's /winsysroot")
 724
 725   if (LLVM_WINSYSROOT)
 726     set(MSVC_DIA_SDK_DIR "${LLVM_WINSYSROOT}/DIA SDK" CACHE PATH
 727         "Path to the DIA SDK")
 728   else()
 729     set(MSVC_DIA_SDK_DIR "$ENV{VSINSTALLDIR}DIA SDK" CACHE PATH
 730         "Path to the DIA SDK")
 731   endif()
 732
 733   # See if the DIA SDK is available and usable.
 734   if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
 735     set(CAN_SYMBOLIZE 1)
 736   else()
 737     set(CAN_SYMBOLIZE 0)
 738   endif()
 739 else()
 740   set(CAN_SYMBOLIZE 1)
 741 endif()
 742
 743 find_program(GNU_LD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.bfd ld.bfd DOC "GNU ld")
 744 find_program(GOLD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.gold ld.gold DOC "GNU gold")
 745
 746 if(COMPILER_RT_SUPPORTED_ARCH)
 747   list(REMOVE_DUPLICATES COMPILER_RT_SUPPORTED_ARCH)
 748 endif()
 749 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 750
 751 set(ALL_SANITIZERS asan;rtsan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;nsan;asan_abi)
 752 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
 753     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 754 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
 755
 756 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
 757     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD|NetBSD|Fuchsia|SunOS" OR
 758     (OS_NAME MATCHES "Windows" AND NOT CYGWIN AND
 759         (NOT MINGW OR CMAKE_CXX_COMPILER_ID MATCHES "Clang"))))
 760   set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
 761 else()
 762   set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
 763 endif()
 764
 765 if (COMPILER_RT_HAS_SANITIZER_COMMON)
 766   set(COMPILER_RT_HAS_INTERCEPTION TRUE)
 767 else()
 768   set(COMPILER_RT_HAS_INTERCEPTION FALSE)
 769 endif()
 770
 771 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND APPLE)
 772   set(COMPILER_RT_HAS_ASAN_ABI TRUE)
 773 else()
 774   set(COMPILER_RT_HAS_ASAN_ABI FALSE)
 775 endif()
 776 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH)
 777   set(COMPILER_RT_HAS_ASAN TRUE)
 778 else()
 779   set(COMPILER_RT_HAS_ASAN FALSE)
 780 endif()
 781
 782 if (COMPILER_RT_HAS_SANITIZER_COMMON AND HWASAN_SUPPORTED_ARCH AND
 783     OS_NAME MATCHES "Linux|Android|Fuchsia")
 784   set(COMPILER_RT_HAS_HWASAN TRUE)
 785 else()
 786   set(COMPILER_RT_HAS_HWASAN FALSE)
 787 endif()
 788
 789 if (COMPILER_RT_HAS_SANITIZER_COMMON AND RTSAN_SUPPORTED_ARCH AND
 790     OS_NAME MATCHES "Darwin|Linux")
 791   set(COMPILER_RT_HAS_RTSAN TRUE)
 792 else()
 793   set(COMPILER_RT_HAS_RTSAN FALSE)
 794 endif()
 795
 796 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD|SunOS")
 797   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 798 else()
 799   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
 800 endif()
 801
 802 # TODO: Add builtins support.
 803
 804 if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
 805     OS_NAME MATCHES "Linux")
 806   set(COMPILER_RT_HAS_DFSAN TRUE)
 807 else()
 808   set(COMPILER_RT_HAS_DFSAN FALSE)
 809 endif()
 810
 811 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
 812     OS_NAME MATCHES "Android|Darwin|Linux|NetBSD|Fuchsia")
 813   set(COMPILER_RT_HAS_LSAN TRUE)
 814 else()
 815   set(COMPILER_RT_HAS_LSAN FALSE)
 816 endif()
 817
 818 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
 819     OS_NAME MATCHES "Linux|FreeBSD|NetBSD")
 820   set(COMPILER_RT_HAS_MSAN TRUE)
 821 else()
 822   set(COMPILER_RT_HAS_MSAN FALSE)
 823 endif()
 824
 825 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MEMPROF_SUPPORTED_ARCH AND
 826     OS_NAME MATCHES "Linux")
 827   set(COMPILER_RT_HAS_MEMPROF TRUE)
 828 else()
 829   set(COMPILER_RT_HAS_MEMPROF FALSE)
 830 endif()
 831
 832 if (PROFILE_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
 833     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows|Android|Fuchsia|SunOS|NetBSD|AIX|WASI|Haiku")
 834   set(COMPILER_RT_HAS_PROFILE TRUE)
 835 else()
 836   set(COMPILER_RT_HAS_PROFILE FALSE)
 837 endif()
 838
 839 if (COMPILER_RT_HAS_SANITIZER_COMMON AND CTX_PROFILE_SUPPORTED_ARCH AND
 840     OS_NAME MATCHES "Linux")
 841   set(COMPILER_RT_HAS_CTX_PROFILE TRUE)
 842 else()
 843   set(COMPILER_RT_HAS_CTX_PROFILE FALSE)
 844 endif()
 845
 846 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH)
 847   if (OS_NAME MATCHES "Linux|Darwin|FreeBSD|NetBSD")
 848     set(COMPILER_RT_HAS_TSAN TRUE)
 849   elseif (OS_NAME MATCHES "Android" AND ANDROID_PLATFORM_LEVEL GREATER 23)
 850     set(COMPILER_RT_HAS_TSAN TRUE)
 851   else()
 852     set(COMPILER_RT_HAS_TSAN FALSE)
 853   endif()
 854 else()
 855   set(COMPILER_RT_HAS_TSAN FALSE)
 856 endif()
 857
 858 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD|SunOS")
 859   set(COMPILER_RT_TSAN_HAS_STATIC_RUNTIME TRUE)
 860 else()
 861   set(COMPILER_RT_TSAN_HAS_STATIC_RUNTIME FALSE)
 862 endif()
 863
 864 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
 865     OS_NAME MATCHES "Darwin|Linux|FreeBSD|NetBSD|Windows|Android|Fuchsia|SunOS")
 866   set(COMPILER_RT_HAS_UBSAN TRUE)
 867 else()
 868   set(COMPILER_RT_HAS_UBSAN FALSE)
 869 endif()
 870
 871 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
 872     OS_NAME MATCHES "Linux|FreeBSD|NetBSD|Android|Darwin")
 873   set(COMPILER_RT_HAS_UBSAN_MINIMAL TRUE)
 874 else()
 875   set(COMPILER_RT_HAS_UBSAN_MINIMAL FALSE)
 876 endif()
 877
 878 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND
 879     OS_NAME MATCHES "Linux|FreeBSD|NetBSD|SunOS")
 880   set(COMPILER_RT_HAS_SAFESTACK TRUE)
 881 else()
 882   set(COMPILER_RT_HAS_SAFESTACK FALSE)
 883 endif()
 884
 885 if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH)
 886   set(COMPILER_RT_HAS_CFI TRUE)
 887 else()
 888   set(COMPILER_RT_HAS_CFI FALSE)
 889 endif()
 890
 891 #TODO(kostyak): add back Android & Fuchsia when the code settles a bit.
 892 if (SCUDO_STANDALONE_SUPPORTED_ARCH AND
 893     COMPILER_RT_BUILD_SANITIZERS AND
 894     "scudo_standalone" IN_LIST COMPILER_RT_SANITIZERS_TO_BUILD AND
 895     OS_NAME MATCHES "Linux" AND
 896     COMPILER_RT_HAS_AUXV)
 897   set(COMPILER_RT_HAS_SCUDO_STANDALONE TRUE)
 898 else()
 899   set(COMPILER_RT_HAS_SCUDO_STANDALONE FALSE)
 900 endif()
 901
 902 if (COMPILER_RT_HAS_SANITIZER_COMMON AND XRAY_SUPPORTED_ARCH AND
 903     OS_NAME MATCHES "Darwin|Linux|FreeBSD|NetBSD|Fuchsia")
 904   set(COMPILER_RT_HAS_XRAY TRUE)
 905 else()
 906   set(COMPILER_RT_HAS_XRAY FALSE)
 907 endif()
 908
 909 if (ORC_SUPPORTED_ARCH)
 910   set(COMPILER_RT_HAS_ORC TRUE)
 911 else()
 912   set(COMPILER_RT_HAS_ORC FALSE)
 913 endif()
 914
 915 if (COMPILER_RT_HAS_SANITIZER_COMMON AND FUZZER_SUPPORTED_ARCH AND
 916     OS_NAME MATCHES "Android|Darwin|Linux|NetBSD|FreeBSD|Fuchsia|Windows")
 917   set(COMPILER_RT_HAS_FUZZER TRUE)
 918 else()
 919   set(COMPILER_RT_HAS_FUZZER FALSE)
 920 endif()
 921
 922 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SHADOWCALLSTACK_SUPPORTED_ARCH AND
 923     OS_NAME MATCHES "Linux|Android")
 924   set(COMPILER_RT_HAS_SHADOWCALLSTACK TRUE)
 925 else()
 926   set(COMPILER_RT_HAS_SHADOWCALLSTACK FALSE)
 927 endif()
 928
 929 # Note: Fuchsia and Windows are not currently supported by GWP-ASan. Support
 930 # is planned for these platforms. Darwin is also not supported due to TLS
 931 # calling malloc on first use.
 932 # TODO(hctim): Enable this on Android again. Looks like it's causing a SIGSEGV
 933 # for Scudo and GWP-ASan, further testing needed.
 934 if (GWP_ASAN_SUPPORTED_ARCH AND
 935     COMPILER_RT_BUILD_GWP_ASAN AND
 936     COMPILER_RT_BUILD_SANITIZERS AND
 937     "gwp_asan" IN_LIST COMPILER_RT_SANITIZERS_TO_BUILD AND
 938     OS_NAME MATCHES "Linux")
 939   set(COMPILER_RT_HAS_GWP_ASAN TRUE)
 940 else()
 941   set(COMPILER_RT_HAS_GWP_ASAN FALSE)
 942 endif()
 943
 944 if (COMPILER_RT_HAS_SANITIZER_COMMON AND NSAN_SUPPORTED_ARCH AND
 945     OS_NAME MATCHES "Linux")
 946   set(COMPILER_RT_HAS_NSAN TRUE)
 947 else()
 948   set(COMPILER_RT_HAS_NSAN FALSE)
 949 endif()
 950 pythonize_bool(COMPILER_RT_HAS_GWP_ASAN)