1include(CMakePushCheckState) 2include(CheckSymbolExists) 3 4# Because compiler-rt spends a lot of time setting up custom compile flags, 5# define a handy helper function for it. The compile flags setting in CMake 6# has serious issues that make its syntax challenging at best. 7function(set_target_compile_flags target) 8 set(argstring "") 9 foreach(arg ${ARGN}) 10 set(argstring "${argstring} ${arg}") 11 endforeach() 12 set_property(TARGET ${target} PROPERTY COMPILE_FLAGS "${argstring}") 13endfunction() 14 15function(set_target_link_flags target) 16 set(argstring "") 17 foreach(arg ${ARGN}) 18 set(argstring "${argstring} ${arg}") 19 endforeach() 20 set_property(TARGET ${target} PROPERTY LINK_FLAGS "${argstring}") 21endfunction() 22 23# Set the variable var_PYBOOL to True if var holds a true-ish string, 24# otherwise set it to False. 25macro(pythonize_bool var) 26 if (${var}) 27 set(${var}_PYBOOL True) 28 else() 29 set(${var}_PYBOOL False) 30 endif() 31endmacro() 32 33# Appends value to all lists in ARGN, if the condition is true. 34macro(append_list_if condition value) 35 if(${condition}) 36 foreach(list ${ARGN}) 37 list(APPEND ${list} ${value}) 38 endforeach() 39 endif() 40endmacro() 41 42# Appends value to all strings in ARGN, if the condition is true. 43macro(append_string_if condition value) 44 if(${condition}) 45 foreach(str ${ARGN}) 46 set(${str} "${${str}} ${value}") 47 endforeach() 48 endif() 49endmacro() 50 51macro(append_rtti_flag polarity list) 52 if(${polarity}) 53 append_list_if(COMPILER_RT_HAS_FRTTI_FLAG -frtti ${list}) 54 append_list_if(COMPILER_RT_HAS_GR_FLAG /GR ${list}) 55 else() 56 append_list_if(COMPILER_RT_HAS_FNO_RTTI_FLAG -fno-rtti ${list}) 57 append_list_if(COMPILER_RT_HAS_GR_FLAG /GR- ${list}) 58 endif() 59endmacro() 60 61macro(list_intersect output input1 input2) 62 set(${output}) 63 foreach(it ${${input1}}) 64 list(FIND ${input2} ${it} index) 65 if( NOT (index EQUAL -1)) 66 list(APPEND ${output} ${it}) 67 endif() 68 endforeach() 69endmacro() 70 71function(list_replace input_list old new) 72 set(replaced_list) 73 foreach(item ${${input_list}}) 74 if(${item} STREQUAL ${old}) 75 list(APPEND replaced_list ${new}) 76 else() 77 list(APPEND replaced_list ${item}) 78 endif() 79 endforeach() 80 set(${input_list} "${replaced_list}" PARENT_SCOPE) 81endfunction() 82 83# Takes ${ARGN} and puts only supported architectures in @out_var list. 84function(filter_available_targets out_var) 85 set(archs ${${out_var}}) 86 foreach(arch ${ARGN}) 87 list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX) 88 if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch}) 89 list(APPEND archs ${arch}) 90 endif() 91 endforeach() 92 set(${out_var} ${archs} PARENT_SCOPE) 93endfunction() 94 95# Add $arch as supported with no additional flags. 96macro(add_default_target_arch arch) 97 set(TARGET_${arch}_CFLAGS "") 98 set(CAN_TARGET_${arch} 1) 99 list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) 100endmacro() 101 102function(check_compile_definition def argstring out_var) 103 if("${def}" STREQUAL "") 104 set(${out_var} TRUE PARENT_SCOPE) 105 return() 106 endif() 107 cmake_push_check_state() 108 set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}") 109 check_symbol_exists(${def} "" ${out_var}) 110 cmake_pop_check_state() 111endfunction() 112 113# test_target_arch(<arch> <def> <target flags...>) 114# Checks if architecture is supported: runs host compiler with provided 115# flags to verify that: 116# 1) <def> is defined (if non-empty) 117# 2) simple file can be successfully built. 118# If successful, saves target flags for this architecture. 119macro(test_target_arch arch def) 120 set(TARGET_${arch}_CFLAGS ${ARGN}) 121 set(TARGET_${arch}_LINK_FLAGS ${ARGN}) 122 set(argstring "") 123 foreach(arg ${ARGN}) 124 set(argstring "${argstring} ${arg}") 125 endforeach() 126 check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF) 127 if(NOT DEFINED CAN_TARGET_${arch}) 128 if(NOT HAS_${arch}_DEF) 129 set(CAN_TARGET_${arch} FALSE) 130 elseif(TEST_COMPILE_ONLY) 131 try_compile_only(CAN_TARGET_${arch} FLAGS ${TARGET_${arch}_CFLAGS}) 132 else() 133 set(FLAG_NO_EXCEPTIONS "") 134 if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG) 135 set(FLAG_NO_EXCEPTIONS " -fno-exceptions ") 136 endif() 137 set(SAVED_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS}) 138 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${argstring}") 139 try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE} 140 COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS} ${FLAG_NO_EXCEPTIONS}" 141 OUTPUT_VARIABLE TARGET_${arch}_OUTPUT) 142 set(CMAKE_EXE_LINKER_FLAGS ${SAVED_CMAKE_EXE_LINKER_FLAGS}) 143 endif() 144 endif() 145 if(${CAN_TARGET_${arch}}) 146 list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) 147 elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" STREQUAL "${arch}" AND 148 COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE) 149 # Bail out if we cannot target the architecture we plan to test. 150 message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}") 151 endif() 152endmacro() 153 154macro(detect_target_arch) 155 check_symbol_exists(__arm__ "" __ARM) 156 check_symbol_exists(__aarch64__ "" __AARCH64) 157 check_symbol_exists(__x86_64__ "" __X86_64) 158 check_symbol_exists(__i386__ "" __I386) 159 check_symbol_exists(__mips__ "" __MIPS) 160 check_symbol_exists(__mips64__ "" __MIPS64) 161 check_symbol_exists(__powerpc64__ "" __PPC64) 162 check_symbol_exists(__powerpc64le__ "" __PPC64LE) 163 check_symbol_exists(__riscv "" __RISCV) 164 check_symbol_exists(__s390x__ "" __S390X) 165 check_symbol_exists(__sparc "" __SPARC) 166 check_symbol_exists(__sparcv9 "" __SPARCV9) 167 check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32) 168 check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64) 169 if(__ARM) 170 add_default_target_arch(arm) 171 elseif(__AARCH64) 172 add_default_target_arch(aarch64) 173 elseif(__X86_64) 174 add_default_target_arch(x86_64) 175 elseif(__I386) 176 add_default_target_arch(i386) 177 elseif(__MIPS64) # must be checked before __MIPS 178 add_default_target_arch(mips64) 179 elseif(__MIPS) 180 add_default_target_arch(mips) 181 elseif(__PPC64) 182 add_default_target_arch(powerpc64) 183 elseif(__PPC64LE) 184 add_default_target_arch(powerpc64le) 185 elseif(__RISCV) 186 if(CMAKE_SIZEOF_VOID_P EQUAL "4") 187 add_default_target_arch(riscv32) 188 elseif(CMAKE_SIZEOF_VOID_P EQUAL "8") 189 add_default_target_arch(riscv64) 190 else() 191 message(FATAL_ERROR "Unsupport XLEN for RISC-V") 192 endif() 193 elseif(__S390X) 194 add_default_target_arch(s390x) 195 elseif(__SPARCV9) 196 add_default_target_arch(sparcv9) 197 elseif(__SPARC) 198 add_default_target_arch(sparc) 199 elseif(__WEBASSEMBLY32) 200 add_default_target_arch(wasm32) 201 elseif(__WEBASSEMBLY64) 202 add_default_target_arch(wasm64) 203 endif() 204endmacro() 205 206macro(load_llvm_config) 207 if (NOT LLVM_CONFIG_PATH) 208 find_program(LLVM_CONFIG_PATH "llvm-config" 209 DOC "Path to llvm-config binary") 210 if (NOT LLVM_CONFIG_PATH) 211 message(WARNING "UNSUPPORTED COMPILER-RT CONFIGURATION DETECTED: " 212 "llvm-config not found.\n" 213 "Reconfigure with -DLLVM_CONFIG_PATH=path/to/llvm-config.") 214 endif() 215 endif() 216 if (LLVM_CONFIG_PATH) 217 execute_process( 218 COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root" "--includedir" 219 RESULT_VARIABLE HAD_ERROR 220 OUTPUT_VARIABLE CONFIG_OUTPUT) 221 if (HAD_ERROR) 222 message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}") 223 endif() 224 string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) 225 list(GET CONFIG_OUTPUT 0 BINARY_DIR) 226 list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR) 227 list(GET CONFIG_OUTPUT 2 LIBRARY_DIR) 228 list(GET CONFIG_OUTPUT 3 MAIN_SRC_DIR) 229 list(GET CONFIG_OUTPUT 4 INCLUDE_DIR) 230 231 set(LLVM_BINARY_DIR ${BINARY_DIR} CACHE PATH "Path to LLVM build tree") 232 set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib") 233 set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree") 234 set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin") 235 set(LLVM_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Paths to LLVM headers") 236 237 # Detect if we have the LLVMXRay and TestingSupport library installed and 238 # available from llvm-config. 239 execute_process( 240 COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "xray" 241 RESULT_VARIABLE HAD_ERROR 242 OUTPUT_VARIABLE CONFIG_OUTPUT 243 ERROR_QUIET) 244 if (HAD_ERROR) 245 message(WARNING "llvm-config finding xray failed with status ${HAD_ERROR}") 246 set(COMPILER_RT_HAS_LLVMXRAY FALSE) 247 else() 248 string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) 249 list(GET CONFIG_OUTPUT 0 LDFLAGS) 250 list(GET CONFIG_OUTPUT 1 LIBLIST) 251 set(LLVM_XRAY_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMXRay library") 252 set(LLVM_XRAY_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMXRay") 253 set(COMPILER_RT_HAS_LLVMXRAY TRUE) 254 endif() 255 256 set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT FALSE) 257 execute_process( 258 COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "testingsupport" 259 RESULT_VARIABLE HAD_ERROR 260 OUTPUT_VARIABLE CONFIG_OUTPUT 261 ERROR_QUIET) 262 if (HAD_ERROR) 263 message(WARNING "llvm-config finding testingsupport failed with status ${HAD_ERROR}") 264 else() 265 string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) 266 list(GET CONFIG_OUTPUT 0 LDFLAGS) 267 list(GET CONFIG_OUTPUT 1 LIBLIST) 268 if (LIBLIST STREQUAL "") 269 message(WARNING "testingsupport library not installed, some tests will be skipped") 270 else() 271 set(LLVM_TESTINGSUPPORT_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMTestingSupport library") 272 set(LLVM_TESTINGSUPPORT_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMTestingSupport") 273 set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT TRUE) 274 endif() 275 endif() 276 277 # Make use of LLVM CMake modules. 278 # --cmakedir is supported since llvm r291218 (4.0 release) 279 execute_process( 280 COMMAND ${LLVM_CONFIG_PATH} --cmakedir 281 RESULT_VARIABLE HAD_ERROR 282 OUTPUT_VARIABLE CONFIG_OUTPUT) 283 if(NOT HAD_ERROR) 284 string(STRIP "${CONFIG_OUTPUT}" LLVM_CMAKE_PATH_FROM_LLVM_CONFIG) 285 file(TO_CMAKE_PATH ${LLVM_CMAKE_PATH_FROM_LLVM_CONFIG} LLVM_CMAKE_PATH) 286 else() 287 file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE) 288 set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR_CMAKE_STYLE}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm") 289 endif() 290 291 list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}") 292 # Get some LLVM variables from LLVMConfig. 293 include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake") 294 295 set(LLVM_LIBRARY_OUTPUT_INTDIR 296 ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}) 297 endif() 298endmacro() 299 300macro(construct_compiler_rt_default_triple) 301 if(COMPILER_RT_DEFAULT_TARGET_ONLY) 302 if(DEFINED COMPILER_RT_DEFAULT_TARGET_TRIPLE) 303 message(FATAL_ERROR "COMPILER_RT_DEFAULT_TARGET_TRIPLE isn't supported when building for default target only") 304 endif() 305 set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${CMAKE_C_COMPILER_TARGET}) 306 else() 307 set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING 308 "Default triple for which compiler-rt runtimes will be built.") 309 endif() 310 311 if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE) 312 # Backwards compatibility: this variable used to be called 313 # COMPILER_RT_TEST_TARGET_TRIPLE. 314 set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${COMPILER_RT_TEST_TARGET_TRIPLE}) 315 endif() 316 317 string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE}) 318 list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH) 319 # Determine if test target triple is specified explicitly, and doesn't match the 320 # default. 321 if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL TARGET_TRIPLE) 322 set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE) 323 else() 324 set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE) 325 endif() 326endmacro() 327 328# Filter out generic versions of routines that are re-implemented in 329# architecture specific manner. This prevents multiple definitions of the 330# same symbols, making the symbol selection non-deterministic. 331function(filter_builtin_sources output_var exclude_or_include excluded_list) 332 if(exclude_or_include STREQUAL "EXCLUDE") 333 set(filter_action GREATER) 334 set(filter_value -1) 335 elseif(exclude_or_include STREQUAL "INCLUDE") 336 set(filter_action LESS) 337 set(filter_value 0) 338 else() 339 message(FATAL_ERROR "filter_builtin_sources called without EXCLUDE|INCLUDE") 340 endif() 341 342 set(intermediate ${ARGN}) 343 foreach (_file ${intermediate}) 344 get_filename_component(_name_we ${_file} NAME_WE) 345 list(FIND ${excluded_list} ${_name_we} _found) 346 if(_found ${filter_action} ${filter_value}) 347 list(REMOVE_ITEM intermediate ${_file}) 348 elseif(${_file} MATCHES ".*/.*\\.S" OR ${_file} MATCHES ".*/.*\\.c") 349 get_filename_component(_name ${_file} NAME) 350 string(REPLACE ".S" ".c" _cname "${_name}") 351 list(REMOVE_ITEM intermediate ${_cname}) 352 endif () 353 endforeach () 354 set(${output_var} ${intermediate} PARENT_SCOPE) 355endfunction() 356 357function(get_compiler_rt_target arch variable) 358 string(FIND ${COMPILER_RT_DEFAULT_TARGET_TRIPLE} "-" dash_index) 359 string(SUBSTRING ${COMPILER_RT_DEFAULT_TARGET_TRIPLE} ${dash_index} -1 triple_suffix) 360 if(COMPILER_RT_DEFAULT_TARGET_ONLY) 361 # Use exact spelling when building only for the target specified to CMake. 362 set(target "${COMPILER_RT_DEFAULT_TARGET_TRIPLE}") 363 elseif(ANDROID AND ${arch} STREQUAL "i386") 364 set(target "i686${COMPILER_RT_OS_SUFFIX}${triple_suffix}") 365 else() 366 set(target "${arch}${triple_suffix}") 367 endif() 368 set(${variable} ${target} PARENT_SCOPE) 369endfunction() 370 371function(get_compiler_rt_install_dir arch install_dir) 372 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) 373 get_compiler_rt_target(${arch} target) 374 set(${install_dir} ${COMPILER_RT_INSTALL_PATH}/lib/${target} PARENT_SCOPE) 375 else() 376 set(${install_dir} ${COMPILER_RT_LIBRARY_INSTALL_DIR} PARENT_SCOPE) 377 endif() 378endfunction() 379 380function(get_compiler_rt_output_dir arch output_dir) 381 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) 382 get_compiler_rt_target(${arch} target) 383 set(${output_dir} ${COMPILER_RT_OUTPUT_DIR}/lib/${target} PARENT_SCOPE) 384 else() 385 set(${output_dir} ${COMPILER_RT_LIBRARY_OUTPUT_DIR} PARENT_SCOPE) 386 endif() 387endfunction() 388 389# compiler_rt_process_sources( 390# <OUTPUT_VAR> 391# <SOURCE_FILE> ... 392# [ADDITIONAL_HEADERS <header> ...] 393# ) 394# 395# Process the provided sources and write the list of new sources 396# into `<OUTPUT_VAR>`. 397# 398# ADDITIONAL_HEADERS - Adds the supplied header to list of sources for IDEs. 399# 400# This function is very similar to `llvm_process_sources()` but exists here 401# because we need to support standalone builds of compiler-rt. 402function(compiler_rt_process_sources OUTPUT_VAR) 403 cmake_parse_arguments( 404 ARG 405 "" 406 "" 407 "ADDITIONAL_HEADERS" 408 ${ARGN} 409 ) 410 set(sources ${ARG_UNPARSED_ARGUMENTS}) 411 set(headers "") 412 if (XCODE OR MSVC_IDE OR CMAKE_EXTRA_GENERATOR) 413 # For IDEs we need to tell CMake about header files. 414 # Otherwise they won't show up in UI. 415 set(headers ${ARG_ADDITIONAL_HEADERS}) 416 list(LENGTH headers headers_length) 417 if (${headers_length} GREATER 0) 418 set_source_files_properties(${headers} 419 PROPERTIES HEADER_FILE_ONLY ON) 420 endif() 421 endif() 422 set("${OUTPUT_VAR}" ${sources} ${headers} PARENT_SCOPE) 423endfunction() 424 425# Create install targets for a library and its parent component (if specified). 426function(add_compiler_rt_install_targets name) 427 cmake_parse_arguments(ARG "" "PARENT_TARGET" "" ${ARGN}) 428 429 if(ARG_PARENT_TARGET AND NOT TARGET install-${ARG_PARENT_TARGET}) 430 # The parent install target specifies the parent component to scrape up 431 # anything not installed by the individual install targets, and to handle 432 # installation when running the multi-configuration generators. 433 add_custom_target(install-${ARG_PARENT_TARGET} 434 DEPENDS ${ARG_PARENT_TARGET} 435 COMMAND "${CMAKE_COMMAND}" 436 -DCMAKE_INSTALL_COMPONENT=${ARG_PARENT_TARGET} 437 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 438 add_custom_target(install-${ARG_PARENT_TARGET}-stripped 439 DEPENDS ${ARG_PARENT_TARGET} 440 COMMAND "${CMAKE_COMMAND}" 441 -DCMAKE_INSTALL_COMPONENT=${ARG_PARENT_TARGET} 442 -DCMAKE_INSTALL_DO_STRIP=1 443 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 444 set_target_properties(install-${ARG_PARENT_TARGET} PROPERTIES 445 FOLDER "Compiler-RT Misc") 446 set_target_properties(install-${ARG_PARENT_TARGET}-stripped PROPERTIES 447 FOLDER "Compiler-RT Misc") 448 add_dependencies(install-compiler-rt install-${ARG_PARENT_TARGET}) 449 add_dependencies(install-compiler-rt-stripped install-${ARG_PARENT_TARGET}-stripped) 450 endif() 451 452 # We only want to generate per-library install targets if you aren't using 453 # an IDE because the extra targets get cluttered in IDEs. 454 if(NOT CMAKE_CONFIGURATION_TYPES) 455 add_custom_target(install-${name} 456 DEPENDS ${name} 457 COMMAND "${CMAKE_COMMAND}" 458 -DCMAKE_INSTALL_COMPONENT=${name} 459 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 460 add_custom_target(install-${name}-stripped 461 DEPENDS ${name} 462 COMMAND "${CMAKE_COMMAND}" 463 -DCMAKE_INSTALL_COMPONENT=${name} 464 -DCMAKE_INSTALL_DO_STRIP=1 465 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 466 # If you have a parent target specified, we bind the new install target 467 # to the parent install target. 468 if(LIB_PARENT_TARGET) 469 add_dependencies(install-${LIB_PARENT_TARGET} install-${name}) 470 add_dependencies(install-${LIB_PARENT_TARGET}-stripped install-${name}-stripped) 471 endif() 472 endif() 473endfunction() 474