Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 1 | include(CMakePushCheckState) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 2 | include(CheckCXXCompilerFlag) |
| 3 | include(CheckLibraryExists) |
| 4 | include(CheckSymbolExists) |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 5 | include(TestBigEndian) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 6 | |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 7 | function(check_linker_flag flag out_var) |
| 8 | cmake_push_check_state() |
| 9 | set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag}") |
| 10 | check_cxx_compiler_flag("" ${out_var}) |
| 11 | cmake_pop_check_state() |
| 12 | endfunction() |
| 13 | |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 14 | # CodeGen options. |
| 15 | check_cxx_compiler_flag(-fPIC COMPILER_RT_HAS_FPIC_FLAG) |
| 16 | check_cxx_compiler_flag(-fPIE COMPILER_RT_HAS_FPIE_FLAG) |
| 17 | check_cxx_compiler_flag(-fno-builtin COMPILER_RT_HAS_FNO_BUILTIN_FLAG) |
| 18 | check_cxx_compiler_flag(-fno-exceptions COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG) |
| 19 | check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG) |
| 20 | check_cxx_compiler_flag(-funwind-tables COMPILER_RT_HAS_FUNWIND_TABLES_FLAG) |
| 21 | check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG) |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 22 | check_cxx_compiler_flag(-fno-sanitize=safe-stack COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 23 | check_cxx_compiler_flag(-fvisibility=hidden COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG) |
| 24 | check_cxx_compiler_flag(-fno-rtti COMPILER_RT_HAS_FNO_RTTI_FLAG) |
| 25 | check_cxx_compiler_flag(-ffreestanding COMPILER_RT_HAS_FFREESTANDING_FLAG) |
| 26 | check_cxx_compiler_flag("-Werror -fno-function-sections" COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG) |
| 27 | check_cxx_compiler_flag(-std=c++11 COMPILER_RT_HAS_STD_CXX11_FLAG) |
| 28 | check_cxx_compiler_flag(-ftls-model=initial-exec COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC) |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 29 | check_cxx_compiler_flag(-fno-lto COMPILER_RT_HAS_FNO_LTO_FLAG) |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 30 | check_cxx_compiler_flag("-Werror -msse3" COMPILER_RT_HAS_MSSE3_FLAG) |
| 31 | check_cxx_compiler_flag(-std=c99 COMPILER_RT_HAS_STD_C99_FLAG) |
| 32 | check_cxx_compiler_flag(--sysroot=. COMPILER_RT_HAS_SYSROOT_FLAG) |
| 33 | |
| 34 | if(NOT WIN32 AND NOT CYGWIN) |
| 35 | # MinGW warns if -fvisibility-inlines-hidden is used. |
| 36 | check_cxx_compiler_flag("-fvisibility-inlines-hidden" COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG) |
| 37 | endif() |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 38 | |
| 39 | check_cxx_compiler_flag(/GR COMPILER_RT_HAS_GR_FLAG) |
| 40 | check_cxx_compiler_flag(/GS COMPILER_RT_HAS_GS_FLAG) |
| 41 | check_cxx_compiler_flag(/MT COMPILER_RT_HAS_MT_FLAG) |
| 42 | check_cxx_compiler_flag(/Oy COMPILER_RT_HAS_Oy_FLAG) |
| 43 | |
| 44 | # Debug info flags. |
| 45 | check_cxx_compiler_flag(-gline-tables-only COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG) |
| 46 | check_cxx_compiler_flag(-g COMPILER_RT_HAS_G_FLAG) |
| 47 | check_cxx_compiler_flag(/Zi COMPILER_RT_HAS_Zi_FLAG) |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 48 | |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 49 | # Warnings. |
| 50 | check_cxx_compiler_flag(-Wall COMPILER_RT_HAS_WALL_FLAG) |
| 51 | check_cxx_compiler_flag(-Werror COMPILER_RT_HAS_WERROR_FLAG) |
| 52 | check_cxx_compiler_flag("-Werror -Wframe-larger-than=512" COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG) |
| 53 | check_cxx_compiler_flag("-Werror -Wglobal-constructors" COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 54 | check_cxx_compiler_flag("-Werror -Wc99-extensions" COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG) |
| 55 | check_cxx_compiler_flag("-Werror -Wgnu" COMPILER_RT_HAS_WGNU_FLAG) |
| 56 | check_cxx_compiler_flag("-Werror -Wnon-virtual-dtor" COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG) |
| 57 | check_cxx_compiler_flag("-Werror -Wvariadic-macros" COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 58 | |
| 59 | check_cxx_compiler_flag(/W3 COMPILER_RT_HAS_W3_FLAG) |
| 60 | check_cxx_compiler_flag(/WX COMPILER_RT_HAS_WX_FLAG) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 61 | check_cxx_compiler_flag(/wd4146 COMPILER_RT_HAS_WD4146_FLAG) |
| 62 | check_cxx_compiler_flag(/wd4291 COMPILER_RT_HAS_WD4291_FLAG) |
| 63 | check_cxx_compiler_flag(/wd4391 COMPILER_RT_HAS_WD4391_FLAG) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 64 | check_cxx_compiler_flag(/wd4722 COMPILER_RT_HAS_WD4722_FLAG) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 65 | check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 66 | |
| 67 | # Symbols. |
| 68 | check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL) |
| 69 | |
| 70 | # Libraries. |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 71 | check_library_exists(c fopen "" COMPILER_RT_HAS_LIBC) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 72 | check_library_exists(dl dlopen "" COMPILER_RT_HAS_LIBDL) |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 73 | check_library_exists(rt shm_open "" COMPILER_RT_HAS_LIBRT) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 74 | check_library_exists(m pow "" COMPILER_RT_HAS_LIBM) |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 75 | check_library_exists(pthread pthread_create "" COMPILER_RT_HAS_LIBPTHREAD) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 76 | check_library_exists(stdc++ __cxa_throw "" COMPILER_RT_HAS_LIBSTDCXX) |
| 77 | |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 78 | # Linker flags. |
| 79 | if(ANDROID) |
| 80 | check_linker_flag("-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL) |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 81 | check_library_exists(log __android_log_write "" COMPILER_RT_HAS_LIBLOG) |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 82 | endif() |
| 83 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 84 | # Architectures. |
| 85 | |
| 86 | # List of all architectures we can target. |
| 87 | set(COMPILER_RT_SUPPORTED_ARCH) |
| 88 | |
| 89 | # Try to compile a very simple source file to ensure we can target the given |
| 90 | # platform. We use the results of these tests to build only the various target |
| 91 | # runtime libraries supported by our current compilers cross-compiling |
| 92 | # abilities. |
| 93 | set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc) |
| 94 | file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <limits>\nint main() {}\n") |
| 95 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 96 | function(check_compile_definition def argstring out_var) |
| 97 | if("${def}" STREQUAL "") |
| 98 | set(${out_var} TRUE PARENT_SCOPE) |
| 99 | return() |
| 100 | endif() |
| 101 | cmake_push_check_state() |
| 102 | set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}") |
| 103 | check_symbol_exists(${def} "" ${out_var}) |
| 104 | cmake_pop_check_state() |
| 105 | endfunction() |
| 106 | |
| 107 | # test_target_arch(<arch> <def> <target flags...>) |
| 108 | # Checks if architecture is supported: runs host compiler with provided |
| 109 | # flags to verify that: |
| 110 | # 1) <def> is defined (if non-empty) |
| 111 | # 2) simple file can be successfully built. |
| 112 | # If successful, saves target flags for this architecture. |
| 113 | macro(test_target_arch arch def) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 114 | set(TARGET_${arch}_CFLAGS ${ARGN}) |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 115 | set(argstring "") |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 116 | foreach(arg ${ARGN}) |
| 117 | set(argstring "${argstring} ${arg}") |
| 118 | endforeach() |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 119 | check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF) |
| 120 | if(NOT HAS_${arch}_DEF) |
| 121 | set(CAN_TARGET_${arch} FALSE) |
| 122 | else() |
| 123 | set(argstring "${CMAKE_EXE_LINKER_FLAGS} ${argstring}") |
| 124 | try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE} |
| 125 | COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS}" |
| 126 | OUTPUT_VARIABLE TARGET_${arch}_OUTPUT |
| 127 | CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${argstring}") |
| 128 | endif() |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 129 | if(${CAN_TARGET_${arch}}) |
| 130 | list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 131 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "${arch}" AND |
| 132 | COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 133 | # Bail out if we cannot target the architecture we plan to test. |
| 134 | message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}") |
| 135 | endif() |
| 136 | endmacro() |
| 137 | |
| 138 | # Add $arch as supported with no additional flags. |
| 139 | macro(add_default_target_arch arch) |
| 140 | set(TARGET_${arch}_CFLAGS "") |
| 141 | set(CAN_TARGET_${arch} 1) |
| 142 | list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) |
| 143 | endmacro() |
| 144 | |
| 145 | macro(detect_target_arch) |
| 146 | check_symbol_exists(__arm__ "" __ARM) |
| 147 | check_symbol_exists(__aarch64__ "" __AARCH64) |
| 148 | check_symbol_exists(__x86_64__ "" __X86_64) |
| 149 | check_symbol_exists(__i686__ "" __I686) |
| 150 | check_symbol_exists(__i386__ "" __I386) |
| 151 | check_symbol_exists(__mips__ "" __MIPS) |
| 152 | check_symbol_exists(__mips64__ "" __MIPS64) |
| 153 | if(__ARM) |
| 154 | add_default_target_arch(arm) |
| 155 | elseif(__AARCH64) |
| 156 | add_default_target_arch(aarch64) |
| 157 | elseif(__X86_64) |
| 158 | add_default_target_arch(x86_64) |
| 159 | elseif(__I686) |
| 160 | add_default_target_arch(i686) |
| 161 | elseif(__I386) |
| 162 | add_default_target_arch(i386) |
| 163 | elseif(__MIPS64) # must be checked before __MIPS |
| 164 | add_default_target_arch(mips64) |
| 165 | elseif(__MIPS) |
| 166 | add_default_target_arch(mips) |
| 167 | endif() |
| 168 | endmacro() |
| 169 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 170 | # Detect whether the current target platform is 32-bit or 64-bit, and setup |
| 171 | # the correct commandline flags needed to attempt to target 32-bit and 64-bit. |
| 172 | if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND |
| 173 | NOT CMAKE_SIZEOF_VOID_P EQUAL 8) |
| 174 | message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.") |
| 175 | endif() |
| 176 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 177 | # Generate the COMPILER_RT_SUPPORTED_ARCH list. |
| 178 | if(ANDROID) |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 179 | # Examine compiler output to determine target architecture. |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 180 | detect_target_arch() |
| 181 | set(COMPILER_RT_OS_SUFFIX "-android") |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 182 | elseif(NOT APPLE) # Supported archs for Apple platforms are generated later |
| 183 | if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64") |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 184 | if(NOT MSVC) |
| 185 | test_target_arch(x86_64 "" "-m64") |
Pirama Arumuga Nainar | 7c91505 | 2015-04-08 08:58:29 -0700 | [diff] [blame] | 186 | # FIXME: We build runtimes for both i686 and i386, as "clang -m32" may |
| 187 | # target different variant than "$CMAKE_C_COMPILER -m32". This part should |
| 188 | # be gone after we resolve PR14109. |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 189 | test_target_arch(i686 __i686__ "-m32") |
Pirama Arumuga Nainar | 7c91505 | 2015-04-08 08:58:29 -0700 | [diff] [blame] | 190 | test_target_arch(i386 __i386__ "-m32") |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 191 | else() |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 192 | if (CMAKE_SIZEOF_VOID_P EQUAL 4) |
| 193 | test_target_arch(i386 "" "") |
| 194 | else() |
| 195 | test_target_arch(x86_64 "" "") |
| 196 | endif() |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 197 | endif() |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 198 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "powerpc") |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 199 | TEST_BIG_ENDIAN(HOST_IS_BIG_ENDIAN) |
| 200 | if(HOST_IS_BIG_ENDIAN) |
| 201 | test_target_arch(powerpc64 "" "-m64") |
| 202 | else() |
| 203 | test_target_arch(powerpc64le "" "-m64") |
| 204 | endif() |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 205 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mipsel|mips64el") |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 206 | # Gcc doesn't accept -m32/-m64 so we do the next best thing and use |
| 207 | # -mips32r2/-mips64r2. We don't use -mips1/-mips3 because we want to match |
| 208 | # clang's default CPU's. In the 64-bit case, we must also specify the ABI |
| 209 | # since the default ABI differs between gcc and clang. |
| 210 | # FIXME: Ideally, we would build the N32 library too. |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 211 | test_target_arch(mipsel "" "-mips32r2" "--target=mipsel-linux-gnu") |
| 212 | test_target_arch(mips64el "" "-mips64r2" "--target=mips64el-linux-gnu" "-mabi=n64") |
| 213 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mips") |
| 214 | test_target_arch(mips "" "-mips32r2" "--target=mips-linux-gnu") |
| 215 | test_target_arch(mips64 "" "-mips64r2" "--target=mips64-linux-gnu" "-mabi=n64") |
| 216 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "arm") |
| 217 | test_target_arch(arm "" "-march=armv7-a" "-mfloat-abi=soft") |
| 218 | test_target_arch(armhf "" "-march=armv7-a" "-mfloat-abi=hard") |
| 219 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "aarch32") |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 220 | test_target_arch(aarch32 "" "-march=armv8-a") |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 221 | elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "aarch64") |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 222 | test_target_arch(aarch64 "" "-march=armv8-a") |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 223 | endif() |
| 224 | set(COMPILER_RT_OS_SUFFIX "") |
| 225 | endif() |
| 226 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 227 | # Takes ${ARGN} and puts only supported architectures in @out_var list. |
| 228 | function(filter_available_targets out_var) |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 229 | set(archs ${${out_var}}) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 230 | foreach(arch ${ARGN}) |
| 231 | list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX) |
| 232 | if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch}) |
| 233 | list(APPEND archs ${arch}) |
| 234 | endif() |
| 235 | endforeach() |
| 236 | set(${out_var} ${archs} PARENT_SCOPE) |
| 237 | endfunction() |
| 238 | |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 239 | # Returns a list of architecture specific target cflags in @out_var list. |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 240 | function(get_target_flags_for_arch arch out_var) |
| 241 | list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX) |
| 242 | if(ARCH_INDEX EQUAL -1) |
| 243 | message(FATAL_ERROR "Unsupported architecture: ${arch}") |
| 244 | else() |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 245 | if (NOT APPLE) |
| 246 | set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE) |
| 247 | else() |
| 248 | # This is only called in constructing cflags for tests executing on the |
| 249 | # host. This will need to all be cleaned up to support building tests |
| 250 | # for cross-targeted hardware (i.e. iOS). |
| 251 | set(${out_var} -arch ${arch} PARENT_SCOPE) |
| 252 | endif() |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 253 | endif() |
| 254 | endfunction() |
| 255 | |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 256 | set(ARM64 aarch64) |
| 257 | set(ARM32 arm armhf) |
| 258 | set(X86 i386 i686) |
| 259 | set(X86_64 x86_64) |
| 260 | set(MIPS32 mips mipsel) |
| 261 | set(MIPS64 mips64 mips64el) |
| 262 | set(PPC64 powerpc64 powerpc64le) |
| 263 | |
| 264 | if(APPLE) |
| 265 | set(ARM64 arm64) |
| 266 | set(ARM32 armv7 armv7s) |
| 267 | set(X86_64 x86_64 x86_64h) |
| 268 | endif() |
| 269 | |
| 270 | set(ALL_BUILTIN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} |
| 271 | ${MIPS32} ${MIPS64}) |
| 272 | set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64} |
| 273 | ${ARM32} ${ARM64} ${MIPS32} ${MIPS64}) |
| 274 | set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} |
| 275 | ${MIPS32} ${MIPS64} ${PPC64}) |
| 276 | set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64}) |
| 277 | set(ALL_LSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64}) |
| 278 | set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64}) |
| 279 | set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64} |
| 280 | ${MIPS32} ${MIPS64}) |
| 281 | set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64}) |
| 282 | set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} |
| 283 | ${MIPS32} ${MIPS64} ${PPC64}) |
| 284 | set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64}) |
| 285 | set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64}) |
| 286 | |
| 287 | if(APPLE) |
| 288 | include(CompilerRTDarwinUtils) |
| 289 | |
| 290 | # On Darwin if /usr/include doesn't exist, the user probably has Xcode but not |
| 291 | # the command line tools. If this is the case, we need to find the OS X |
| 292 | # sysroot to pass to clang. |
| 293 | if(NOT EXISTS /usr/include) |
| 294 | execute_process(COMMAND xcodebuild -version -sdk macosx Path |
| 295 | OUTPUT_VARIABLE OSX_SYSROOT |
| 296 | ERROR_QUIET |
| 297 | OUTPUT_STRIP_TRAILING_WHITESPACE) |
| 298 | set(OSX_SYSROOT_FLAG "-isysroot${OSX_SYSROOT}") |
| 299 | endif() |
| 300 | |
| 301 | option(COMPILER_RT_ENABLE_IOS "Enable building for iOS - Experimental" Off) |
| 302 | |
| 303 | find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx) |
| 304 | find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator) |
| 305 | find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos) |
| 306 | |
| 307 | # Note: In order to target x86_64h on OS X the minimum deployment target must |
| 308 | # be 10.8 or higher. |
| 309 | set(SANITIZER_COMMON_SUPPORTED_OS osx) |
| 310 | set(BUILTIN_SUPPORTED_OS osx) |
| 311 | set(PROFILE_SUPPORTED_OS osx) |
| 312 | set(TSAN_SUPPORTED_OS osx) |
| 313 | if(NOT SANITIZER_MIN_OSX_VERSION) |
| 314 | string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)" |
| 315 | MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}") |
| 316 | if(MACOSX_VERSION_MIN_FLAG) |
| 317 | set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}") |
| 318 | elseif(CMAKE_OSX_DEPLOYMENT_TARGET) |
| 319 | set(SANITIZER_MIN_OSX_VERSION ${CMAKE_OSX_DEPLOYMENT_TARGET}) |
| 320 | else() |
| 321 | set(SANITIZER_MIN_OSX_VERSION 10.9) |
| 322 | endif() |
| 323 | if(SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.7") |
| 324 | message(FATAL_ERROR "Too old OS X version: ${SANITIZER_MIN_OSX_VERSION}") |
| 325 | endif() |
| 326 | endif() |
| 327 | |
| 328 | # We're setting the flag manually for each target OS |
| 329 | set(CMAKE_OSX_DEPLOYMENT_TARGET "") |
| 330 | |
| 331 | set(DARWIN_COMMON_CFLAGS -stdlib=libc++) |
| 332 | set(DARWIN_COMMON_LINKFLAGS |
| 333 | -stdlib=libc++ |
| 334 | -lc++ |
| 335 | -lc++abi) |
| 336 | |
| 337 | set(DARWIN_osx_CFLAGS |
| 338 | ${DARWIN_COMMON_CFLAGS} |
| 339 | -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION}) |
| 340 | set(DARWIN_osx_LINKFLAGS |
| 341 | ${DARWIN_COMMON_LINKFLAGS} |
| 342 | -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION}) |
| 343 | set(DARWIN_osx_BUILTIN_MIN_VER 10.5) |
| 344 | set(DARWIN_osx_BUILTIN_MIN_VER_FLAG |
| 345 | -mmacosx-version-min=${DARWIN_osx_BUILTIN_MIN_VER}) |
| 346 | |
| 347 | if(DARWIN_osx_SYSROOT) |
| 348 | list(APPEND DARWIN_osx_CFLAGS -isysroot ${DARWIN_osx_SYSROOT}) |
| 349 | list(APPEND DARWIN_osx_LINKFLAGS -isysroot ${DARWIN_osx_SYSROOT}) |
| 350 | endif() |
| 351 | |
| 352 | # Figure out which arches to use for each OS |
| 353 | darwin_get_toolchain_supported_archs(toolchain_arches) |
| 354 | message(STATUS "Toolchain supported arches: ${toolchain_arches}") |
| 355 | |
| 356 | if(NOT MACOSX_VERSION_MIN_FLAG) |
| 357 | darwin_test_archs(osx |
| 358 | DARWIN_osx_ARCHS |
| 359 | ${toolchain_arches}) |
| 360 | message(STATUS "OSX supported arches: ${DARWIN_osx_ARCHS}") |
| 361 | foreach(arch ${DARWIN_osx_ARCHS}) |
| 362 | list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) |
| 363 | set(CAN_TARGET_${arch} 1) |
| 364 | endforeach() |
| 365 | |
| 366 | # Need to build a 10.4 compatible libclang_rt |
| 367 | set(DARWIN_10.4_SYSROOT ${DARWIN_osx_SYSROOT}) |
| 368 | set(DARWIN_10.4_BUILTIN_MIN_VER 10.4) |
| 369 | set(DARWIN_10.4_BUILTIN_MIN_VER_FLAG |
| 370 | -mmacosx-version-min=${DARWIN_10.4_BUILTIN_MIN_VER}) |
| 371 | set(DARWIN_10.4_SKIP_CC_KEXT On) |
| 372 | darwin_test_archs(10.4 |
| 373 | DARWIN_10.4_ARCHS |
| 374 | ${toolchain_arches}) |
| 375 | message(STATUS "OSX 10.4 supported arches: ${DARWIN_10.4_ARCHS}") |
| 376 | if(DARWIN_10.4_ARCHS) |
| 377 | # don't include the Haswell slice in the 10.4 compatibility library |
| 378 | list(REMOVE_ITEM DARWIN_10.4_ARCHS x86_64h) |
| 379 | list(APPEND BUILTIN_SUPPORTED_OS 10.4) |
| 380 | endif() |
| 381 | |
| 382 | if(DARWIN_iossim_SYSROOT) |
| 383 | set(DARWIN_iossim_CFLAGS |
| 384 | ${DARWIN_COMMON_CFLAGS} |
| 385 | -mios-simulator-version-min=7.0 |
| 386 | -isysroot ${DARWIN_iossim_SYSROOT}) |
| 387 | set(DARWIN_iossim_LINKFLAGS |
| 388 | ${DARWIN_COMMON_LINKFLAGS} |
| 389 | -mios-simulator-version-min=7.0 |
| 390 | -isysroot ${DARWIN_iossim_SYSROOT}) |
| 391 | set(DARWIN_iossim_BUILTIN_MIN_VER 6.0) |
| 392 | set(DARWIN_iossim_BUILTIN_MIN_VER_FLAG |
| 393 | -mios-simulator-version-min=${DARWIN_iossim_BUILTIN_MIN_VER}) |
| 394 | |
| 395 | set(DARWIN_iossim_SKIP_CC_KEXT On) |
| 396 | darwin_test_archs(iossim |
| 397 | DARWIN_iossim_ARCHS |
| 398 | ${toolchain_arches}) |
| 399 | message(STATUS "iOS Simulator supported arches: ${DARWIN_iossim_ARCHS}") |
| 400 | if(DARWIN_iossim_ARCHS) |
| 401 | list(APPEND SANITIZER_COMMON_SUPPORTED_OS iossim) |
| 402 | list(APPEND BUILTIN_SUPPORTED_OS iossim) |
| 403 | list(APPEND PROFILE_SUPPORTED_OS iossim) |
| 404 | endif() |
| 405 | foreach(arch ${DARWIN_iossim_ARCHS}) |
| 406 | list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) |
| 407 | set(CAN_TARGET_${arch} 1) |
| 408 | endforeach() |
| 409 | endif() |
| 410 | |
| 411 | if(DARWIN_ios_SYSROOT AND COMPILER_RT_ENABLE_IOS) |
| 412 | set(DARWIN_ios_CFLAGS |
| 413 | ${DARWIN_COMMON_CFLAGS} |
| 414 | -miphoneos-version-min=7.0 |
| 415 | -isysroot ${DARWIN_ios_SYSROOT}) |
| 416 | set(DARWIN_ios_LINKFLAGS |
| 417 | ${DARWIN_COMMON_LINKFLAGS} |
| 418 | -miphoneos-version-min=7.0 |
| 419 | -isysroot ${DARWIN_ios_SYSROOT}) |
| 420 | set(DARWIN_ios_BUILTIN_MIN_VER 6.0) |
| 421 | set(DARWIN_ios_BUILTIN_MIN_VER_FLAG |
| 422 | -miphoneos-version-min=${DARWIN_ios_BUILTIN_MIN_VER}) |
| 423 | |
| 424 | darwin_test_archs(ios |
| 425 | DARWIN_ios_ARCHS |
| 426 | ${toolchain_arches}) |
| 427 | message(STATUS "iOS supported arches: ${DARWIN_ios_ARCHS}") |
| 428 | if(DARWIN_ios_ARCHS) |
| 429 | list(APPEND SANITIZER_COMMON_SUPPORTED_OS ios) |
| 430 | list(APPEND BUILTIN_SUPPORTED_OS ios) |
| 431 | list(APPEND PROFILE_SUPPORTED_OS ios) |
| 432 | endif() |
| 433 | foreach(arch ${DARWIN_ios_ARCHS}) |
| 434 | list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) |
| 435 | set(CAN_TARGET_${arch} 1) |
| 436 | endforeach() |
| 437 | endif() |
| 438 | endif() |
| 439 | |
| 440 | # for list_union |
| 441 | include(CompilerRTUtils) |
| 442 | |
| 443 | list_union(BUILTIN_SUPPORTED_ARCH ALL_BUILTIN_SUPPORTED_ARCH toolchain_arches) |
| 444 | |
| 445 | list_union(SANITIZER_COMMON_SUPPORTED_ARCH |
| 446 | ALL_SANITIZER_COMMON_SUPPORTED_ARCH |
| 447 | COMPILER_RT_SUPPORTED_ARCH |
| 448 | ) |
| 449 | set(LSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH}) |
| 450 | set(UBSAN_COMMON_SUPPORTED_ARCH ${SANITIZER_COMMON_SUPPORTED_ARCH}) |
| 451 | list_union(ASAN_SUPPORTED_ARCH |
| 452 | ALL_ASAN_SUPPORTED_ARCH |
| 453 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 454 | list_union(DFSAN_SUPPORTED_ARCH |
| 455 | ALL_DFSAN_SUPPORTED_ARCH |
| 456 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 457 | list_union(LSAN_SUPPORTED_ARCH |
| 458 | ALL_LSAN_SUPPORTED_ARCH |
| 459 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 460 | list_union(MSAN_SUPPORTED_ARCH |
| 461 | ALL_MSAN_SUPPORTED_ARCH |
| 462 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 463 | list_union(PROFILE_SUPPORTED_ARCH |
| 464 | ALL_PROFILE_SUPPORTED_ARCH |
| 465 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 466 | list_union(TSAN_SUPPORTED_ARCH |
| 467 | ALL_TSAN_SUPPORTED_ARCH |
| 468 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 469 | list_union(UBSAN_SUPPORTED_ARCH |
| 470 | ALL_UBSAN_SUPPORTED_ARCH |
| 471 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 472 | list_union(SAFESTACK_SUPPORTED_ARCH |
| 473 | ALL_SAFESTACK_SUPPORTED_ARCH |
| 474 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 475 | list_union(CFI_SUPPORTED_ARCH |
| 476 | ALL_CFI_SUPPORTED_ARCH |
| 477 | SANITIZER_COMMON_SUPPORTED_ARCH) |
| 478 | else() |
| 479 | # Architectures supported by compiler-rt libraries. |
| 480 | filter_available_targets(BUILTIN_SUPPORTED_ARCH |
| 481 | ${ALL_BUILTIN_SUPPORTED_ARCH}) |
| 482 | filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH |
| 483 | ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH}) |
| 484 | # LSan and UBSan common files should be available on all architectures |
| 485 | # supported by other sanitizers (even if they build into dummy object files). |
| 486 | filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH |
| 487 | ${SANITIZER_COMMON_SUPPORTED_ARCH}) |
| 488 | filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH |
| 489 | ${SANITIZER_COMMON_SUPPORTED_ARCH}) |
| 490 | filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH}) |
| 491 | filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH}) |
| 492 | filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH}) |
| 493 | filter_available_targets(MSAN_SUPPORTED_ARCH ${ALL_MSAN_SUPPORTED_ARCH}) |
| 494 | filter_available_targets(PROFILE_SUPPORTED_ARCH ${ALL_PROFILE_SUPPORTED_ARCH}) |
| 495 | filter_available_targets(TSAN_SUPPORTED_ARCH ${ALL_TSAN_SUPPORTED_ARCH}) |
| 496 | filter_available_targets(UBSAN_SUPPORTED_ARCH ${ALL_UBSAN_SUPPORTED_ARCH}) |
| 497 | filter_available_targets(SAFESTACK_SUPPORTED_ARCH |
| 498 | ${ALL_SAFESTACK_SUPPORTED_ARCH}) |
| 499 | filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH}) |
| 500 | endif() |
| 501 | |
| 502 | message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}") |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 503 | |
| 504 | if(ANDROID) |
| 505 | set(OS_NAME "Android") |
| 506 | else() |
| 507 | set(OS_NAME "${CMAKE_SYSTEM_NAME}") |
| 508 | endif() |
| 509 | |
| 510 | if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND |
| 511 | (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD" OR |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 512 | (OS_NAME MATCHES "Windows" AND MSVC))) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 513 | set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE) |
| 514 | else() |
| 515 | set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE) |
| 516 | endif() |
| 517 | |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 518 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND |
| 519 | (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4)) |
| 520 | set(COMPILER_RT_HAS_INTERCEPTION TRUE) |
| 521 | else() |
| 522 | set(COMPILER_RT_HAS_INTERCEPTION FALSE) |
| 523 | endif() |
| 524 | |
| 525 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND |
| 526 | (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4)) |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 527 | set(COMPILER_RT_HAS_ASAN TRUE) |
| 528 | else() |
| 529 | set(COMPILER_RT_HAS_ASAN FALSE) |
| 530 | endif() |
| 531 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 532 | if (OS_NAME MATCHES "Linux|FreeBSD|Windows") |
| 533 | set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE) |
| 534 | else() |
| 535 | set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE) |
| 536 | endif() |
| 537 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 538 | # TODO: Add builtins support. |
| 539 | |
| 540 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND |
| 541 | OS_NAME MATCHES "Linux") |
| 542 | set(COMPILER_RT_HAS_DFSAN TRUE) |
| 543 | else() |
| 544 | set(COMPILER_RT_HAS_DFSAN FALSE) |
| 545 | endif() |
| 546 | |
| 547 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 548 | OS_NAME MATCHES "Linux|FreeBSD") |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 549 | set(COMPILER_RT_HAS_LSAN TRUE) |
| 550 | else() |
| 551 | set(COMPILER_RT_HAS_LSAN FALSE) |
| 552 | endif() |
| 553 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 554 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND |
| 555 | OS_NAME MATCHES "Linux") |
| 556 | set(COMPILER_RT_HAS_MSAN TRUE) |
| 557 | else() |
| 558 | set(COMPILER_RT_HAS_MSAN FALSE) |
| 559 | endif() |
| 560 | |
| 561 | if (PROFILE_SUPPORTED_ARCH AND |
| 562 | OS_NAME MATCHES "Darwin|Linux|FreeBSD") |
| 563 | set(COMPILER_RT_HAS_PROFILE TRUE) |
| 564 | else() |
| 565 | set(COMPILER_RT_HAS_PROFILE FALSE) |
| 566 | endif() |
| 567 | |
| 568 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 569 | OS_NAME MATCHES "Darwin|Linux|FreeBSD") |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 570 | set(COMPILER_RT_HAS_TSAN TRUE) |
| 571 | else() |
| 572 | set(COMPILER_RT_HAS_TSAN FALSE) |
| 573 | endif() |
| 574 | |
| 575 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 576 | OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows") |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 577 | set(COMPILER_RT_HAS_UBSAN TRUE) |
| 578 | else() |
| 579 | set(COMPILER_RT_HAS_UBSAN FALSE) |
| 580 | endif() |
| 581 | |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 582 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND |
Pirama Arumuga Nainar | cdce50b | 2015-07-01 12:26:56 -0700 | [diff] [blame] | 583 | OS_NAME MATCHES "Darwin|Linux|FreeBSD") |
| 584 | set(COMPILER_RT_HAS_SAFESTACK TRUE) |
| 585 | else() |
| 586 | set(COMPILER_RT_HAS_SAFESTACK FALSE) |
| 587 | endif() |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 588 | |
| 589 | if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND |
| 590 | OS_NAME MATCHES "Linux") |
| 591 | set(COMPILER_RT_HAS_CFI TRUE) |
| 592 | else() |
| 593 | set(COMPILER_RT_HAS_CFI FALSE) |
| 594 | endif() |