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(__AVR__ "" __AVR) 157 check_symbol_exists(__aarch64__ "" __AARCH64) 158 check_symbol_exists(__x86_64__ "" __X86_64) 159 check_symbol_exists(__i386__ "" __I386) 160 check_symbol_exists(__mips__ "" __MIPS) 161 check_symbol_exists(__mips64__ "" __MIPS64) 162 check_symbol_exists(__powerpc__ "" __PPC) 163 check_symbol_exists(__powerpc64__ "" __PPC64) 164 check_symbol_exists(__powerpc64le__ "" __PPC64LE) 165 check_symbol_exists(__riscv "" __RISCV) 166 check_symbol_exists(__s390x__ "" __S390X) 167 check_symbol_exists(__sparc "" __SPARC) 168 check_symbol_exists(__sparcv9 "" __SPARCV9) 169 check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32) 170 check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64) 171 check_symbol_exists(__ve__ "" __VE) 172 if(__ARM) 173 add_default_target_arch(arm) 174 elseif(__AVR) 175 add_default_target_arch(avr) 176 elseif(__AARCH64) 177 add_default_target_arch(aarch64) 178 elseif(__X86_64) 179 if(CMAKE_SIZEOF_VOID_P EQUAL "4") 180 add_default_target_arch(x32) 181 elseif(CMAKE_SIZEOF_VOID_P EQUAL "8") 182 add_default_target_arch(x86_64) 183 else() 184 message(FATAL_ERROR "Unsupported pointer size for X86_64") 185 endif() 186 elseif(__I386) 187 add_default_target_arch(i386) 188 elseif(__MIPS64) # must be checked before __MIPS 189 add_default_target_arch(mips64) 190 elseif(__MIPS) 191 add_default_target_arch(mips) 192 elseif(__PPC64) # must be checked before __PPC 193 add_default_target_arch(powerpc64) 194 elseif(__PPC64LE) 195 add_default_target_arch(powerpc64le) 196 elseif(__PPC) 197 add_default_target_arch(powerpc) 198 elseif(__RISCV) 199 if(CMAKE_SIZEOF_VOID_P EQUAL "4") 200 add_default_target_arch(riscv32) 201 elseif(CMAKE_SIZEOF_VOID_P EQUAL "8") 202 add_default_target_arch(riscv64) 203 else() 204 message(FATAL_ERROR "Unsupport XLEN for RISC-V") 205 endif() 206 elseif(__S390X) 207 add_default_target_arch(s390x) 208 elseif(__SPARCV9) 209 add_default_target_arch(sparcv9) 210 elseif(__SPARC) 211 add_default_target_arch(sparc) 212 elseif(__WEBASSEMBLY32) 213 add_default_target_arch(wasm32) 214 elseif(__WEBASSEMBLY64) 215 add_default_target_arch(wasm64) 216 elseif(__VE) 217 add_default_target_arch(ve) 218 endif() 219endmacro() 220 221function(get_compiler_rt_root_source_dir ROOT_DIR_VAR) 222 # Compute the path to the root of the Compiler-RT source tree 223 # regardless of how the project was configured. 224 # 225 # This function is useful because using `${CMAKE_SOURCE_DIR}` 226 # is error prone due to the numerous ways Compiler-RT can be 227 # configured. 228 # 229 # `ROOT_DIR_VAR` - the name of the variable to write the result to. 230 # 231 # TODO(dliew): When CMake min version is 3.17 or newer use 232 # `CMAKE_CURRENT_FUNCTION_LIST_DIR` instead. 233 if ("${ROOT_DIR_VAR}" STREQUAL "") 234 message(FATAL_ERROR "ROOT_DIR_VAR cannot be empty") 235 endif() 236 237 # Compiler-rt supports different source root paths. 238 # Handle each case here. 239 set(PATH_TO_COMPILER_RT_SOURCE_ROOT "") 240 if (DEFINED CompilerRTBuiltins_SOURCE_DIR) 241 # Compiler-RT Builtins standalone build. 242 # `llvm-project/compiler-rt/lib/builtins` 243 set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CompilerRTBuiltins_SOURCE_DIR}/../../") 244 elseif (DEFINED CompilerRTCRT_SOURCE_DIR) 245 # Compiler-RT CRT standalone build. 246 # `llvm-project/compiler-rt/lib/crt` 247 set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CompilerRTCRT_SOURCE_DIR}/../../") 248 elseif(DEFINED CompilerRT_SOURCE_DIR) 249 # Compiler-RT standalone build. 250 # `llvm-project/compiler-rt` 251 set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CompilerRT_SOURCE_DIR}") 252 elseif (EXISTS "${CMAKE_SOURCE_DIR}/../compiler-rt") 253 # In tree build with LLVM as the root project. 254 # See `llvm-project/projects/`. 255 # Assumes monorepo layout. 256 set(PATH_TO_COMPILER_RT_SOURCE_ROOT "${CMAKE_SOURCE_DIR}/../compiler-rt") 257 else() 258 message(FATAL_ERROR "Unhandled Compiler-RT source root configuration.") 259 endif() 260 261 get_filename_component(ROOT_DIR "${PATH_TO_COMPILER_RT_SOURCE_ROOT}" ABSOLUTE) 262 if (NOT EXISTS "${ROOT_DIR}") 263 message(FATAL_ERROR "Path \"${ROOT_DIR}\" doesn't exist") 264 endif() 265 266 # Sanity check: Make sure we can locate the current source file via the 267 # computed path. 268 set(PATH_TO_CURRENT_FILE "${ROOT_DIR}/cmake/Modules/CompilerRTUtils.cmake") 269 if (NOT EXISTS "${PATH_TO_CURRENT_FILE}") 270 message(FATAL_ERROR "Could not find \"${PATH_TO_CURRENT_FILE}\"") 271 endif() 272 273 set("${ROOT_DIR_VAR}" "${ROOT_DIR}" PARENT_SCOPE) 274endfunction() 275 276macro(load_llvm_config) 277 if (NOT LLVM_CONFIG_PATH) 278 find_program(LLVM_CONFIG_PATH "llvm-config" 279 DOC "Path to llvm-config binary") 280 if (NOT LLVM_CONFIG_PATH) 281 message(WARNING "UNSUPPORTED COMPILER-RT CONFIGURATION DETECTED: " 282 "llvm-config not found.\n" 283 "Reconfigure with -DLLVM_CONFIG_PATH=path/to/llvm-config.") 284 endif() 285 endif() 286 287 # Compute path to LLVM sources assuming the monorepo layout. 288 # We don't set `LLVM_MAIN_SRC_DIR` directly to avoid overriding a user provided 289 # CMake cache value. 290 get_compiler_rt_root_source_dir(COMPILER_RT_ROOT_SRC_PATH) 291 get_filename_component(LLVM_MAIN_SRC_DIR_DEFAULT "${COMPILER_RT_ROOT_SRC_PATH}/../llvm" ABSOLUTE) 292 if (NOT EXISTS "${LLVM_MAIN_SRC_DIR_DEFAULT}") 293 # TODO(dliew): Remove this legacy fallback path. 294 message(WARNING 295 "LLVM source tree not found at \"${LLVM_MAIN_SRC_DIR_DEFAULT}\". " 296 "You are not using the monorepo layout. This configuration is DEPRECATED.") 297 endif() 298 299 set(FOUND_LLVM_CMAKE_DIR FALSE) 300 if (LLVM_CONFIG_PATH) 301 execute_process( 302 COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root" "--includedir" 303 RESULT_VARIABLE HAD_ERROR 304 OUTPUT_VARIABLE CONFIG_OUTPUT) 305 if (HAD_ERROR) 306 message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}") 307 endif() 308 string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) 309 list(GET CONFIG_OUTPUT 0 BINARY_DIR) 310 list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR) 311 list(GET CONFIG_OUTPUT 2 LIBRARY_DIR) 312 list(GET CONFIG_OUTPUT 3 MAIN_SRC_DIR) 313 list(GET CONFIG_OUTPUT 4 INCLUDE_DIR) 314 315 set(LLVM_BINARY_DIR ${BINARY_DIR} CACHE PATH "Path to LLVM build tree") 316 set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib") 317 set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin") 318 set(LLVM_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Paths to LLVM headers") 319 320 if (NOT EXISTS "${LLVM_MAIN_SRC_DIR_DEFAULT}") 321 # TODO(dliew): Remove this legacy fallback path. 322 message(WARNING 323 "Consulting llvm-config for the LLVM source path " 324 "as a fallback. This behavior will be removed in the future.") 325 # We don't set `LLVM_MAIN_SRC_DIR` directly to avoid overriding a user 326 # provided CMake cache value. 327 set(LLVM_MAIN_SRC_DIR_DEFAULT "${MAIN_SRC_DIR}") 328 message(STATUS "Using LLVM source path (${LLVM_MAIN_SRC_DIR_DEFAULT}) from llvm-config") 329 endif() 330 331 # Detect if we have the LLVMXRay and TestingSupport library installed and 332 # available from llvm-config. 333 execute_process( 334 COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "xray" 335 RESULT_VARIABLE HAD_ERROR 336 OUTPUT_VARIABLE CONFIG_OUTPUT 337 ERROR_QUIET) 338 if (HAD_ERROR) 339 message(WARNING "llvm-config finding xray failed with status ${HAD_ERROR}") 340 set(COMPILER_RT_HAS_LLVMXRAY FALSE) 341 else() 342 string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) 343 list(GET CONFIG_OUTPUT 0 LDFLAGS) 344 list(GET CONFIG_OUTPUT 1 LIBLIST) 345 file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS) 346 file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST) 347 set(LLVM_XRAY_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMXRay library") 348 set(LLVM_XRAY_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMXRay") 349 set(COMPILER_RT_HAS_LLVMXRAY TRUE) 350 endif() 351 352 set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT FALSE) 353 execute_process( 354 COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "testingsupport" 355 RESULT_VARIABLE HAD_ERROR 356 OUTPUT_VARIABLE CONFIG_OUTPUT 357 ERROR_QUIET) 358 if (HAD_ERROR) 359 message(WARNING "llvm-config finding testingsupport failed with status ${HAD_ERROR}") 360 elseif(COMPILER_RT_INCLUDE_TESTS) 361 string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) 362 list(GET CONFIG_OUTPUT 0 LDFLAGS) 363 list(GET CONFIG_OUTPUT 1 LIBLIST) 364 if (LIBLIST STREQUAL "") 365 message(WARNING "testingsupport library not installed, some tests will be skipped") 366 else() 367 file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS) 368 file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST) 369 set(LLVM_TESTINGSUPPORT_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMTestingSupport library") 370 set(LLVM_TESTINGSUPPORT_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMTestingSupport") 371 set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT TRUE) 372 endif() 373 endif() 374 375 # Make use of LLVM CMake modules. 376 # --cmakedir is supported since llvm r291218 (4.0 release) 377 execute_process( 378 COMMAND ${LLVM_CONFIG_PATH} --cmakedir 379 RESULT_VARIABLE HAD_ERROR 380 OUTPUT_VARIABLE CONFIG_OUTPUT) 381 if(NOT HAD_ERROR) 382 string(STRIP "${CONFIG_OUTPUT}" LLVM_CMAKE_DIR_FROM_LLVM_CONFIG) 383 file(TO_CMAKE_PATH ${LLVM_CMAKE_DIR_FROM_LLVM_CONFIG} LLVM_CMAKE_DIR) 384 else() 385 file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE) 386 set(LLVM_CMAKE_DIR "${LLVM_BINARY_DIR_CMAKE_STYLE}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm") 387 endif() 388 389 set(LLVM_CMAKE_INCLUDE_FILE "${LLVM_CMAKE_DIR}/LLVMConfig.cmake") 390 if (EXISTS "${LLVM_CMAKE_INCLUDE_FILE}") 391 list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}") 392 # Get some LLVM variables from LLVMConfig. 393 include("${LLVM_CMAKE_INCLUDE_FILE}") 394 set(FOUND_LLVM_CMAKE_DIR TRUE) 395 else() 396 set(FOUND_LLVM_CMAKE_DIR FALSE) 397 message(WARNING "LLVM CMake path (${LLVM_CMAKE_INCLUDE_FILE}) reported by llvm-config does not exist") 398 endif() 399 unset(LLVM_CMAKE_INCLUDE_FILE) 400 401 set(LLVM_LIBRARY_OUTPUT_INTDIR 402 ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}) 403 endif() 404 405 # Finally set the cache variable now that `llvm-config` has also had a chance 406 # to set `LLVM_MAIN_SRC_DIR_DEFAULT`. 407 set(LLVM_MAIN_SRC_DIR "${LLVM_MAIN_SRC_DIR_DEFAULT}" CACHE PATH "Path to LLVM source tree") 408 message(STATUS "LLVM_MAIN_SRC_DIR: \"${LLVM_MAIN_SRC_DIR}\"") 409 if (NOT EXISTS "${LLVM_MAIN_SRC_DIR}") 410 # TODO(dliew): Make this a hard error 411 message(WARNING "LLVM_MAIN_SRC_DIR (${LLVM_MAIN_SRC_DIR}) does not exist. " 412 "You can override the inferred path by adding " 413 "`-DLLVM_MAIN_SRC_DIR=<path_to_llvm_src>` to your CMake invocation " 414 "where `<path_to_llvm_src>` is the path to the `llvm` directory in " 415 "the `llvm-project` repo. " 416 "This will be treated as error in the future.") 417 endif() 418 419 if (NOT FOUND_LLVM_CMAKE_DIR) 420 # This configuration tries to configure without the prescence of `LLVMConfig.cmake`. It is 421 # intended for testing purposes (generating the lit test suites) and will likely not support 422 # a build of the runtimes in compiler-rt. 423 include(CompilerRTMockLLVMCMakeConfig) 424 compiler_rt_mock_llvm_cmake_config() 425 endif() 426 427endmacro() 428 429macro(construct_compiler_rt_default_triple) 430 if(COMPILER_RT_DEFAULT_TARGET_ONLY) 431 if(DEFINED COMPILER_RT_DEFAULT_TARGET_TRIPLE) 432 message(FATAL_ERROR "COMPILER_RT_DEFAULT_TARGET_TRIPLE isn't supported when building for default target only") 433 endif() 434 set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${CMAKE_C_COMPILER_TARGET}) 435 else() 436 set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${LLVM_TARGET_TRIPLE} CACHE STRING 437 "Default triple for which compiler-rt runtimes will be built.") 438 endif() 439 440 string(REPLACE "-" ";" LLVM_TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE}) 441 list(GET LLVM_TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH) 442 443 # Map various forms of the architecture names to the canonical forms 444 # (as they are used by clang, see getArchNameForCompilerRTLib). 445 if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "^i.86$") 446 # Android uses i686, but that's remapped at a later stage. 447 set(COMPILER_RT_DEFAULT_TARGET_ARCH "i386") 448 endif() 449 450 # Determine if test target triple is specified explicitly, and doesn't match the 451 # default. 452 if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL LLVM_TARGET_TRIPLE) 453 set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE) 454 else() 455 set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE) 456 endif() 457endmacro() 458 459# Filter out generic versions of routines that are re-implemented in an 460# architecture specific manner. This prevents multiple definitions of the same 461# symbols, making the symbol selection non-deterministic. 462# 463# We follow the convention that a source file that exists in a sub-directory 464# (e.g. `ppc/divtc3.c`) is architecture-specific and that if a generic 465# implementation exists it will be a top-level source file with the same name 466# modulo the file extension (e.g. `divtc3.c`). 467function(filter_builtin_sources inout_var name) 468 set(intermediate ${${inout_var}}) 469 foreach(_file ${intermediate}) 470 get_filename_component(_file_dir ${_file} DIRECTORY) 471 if (NOT "${_file_dir}" STREQUAL "") 472 # Architecture specific file. If a generic version exists, print a notice 473 # and ensure that it is removed from the file list. 474 get_filename_component(_name ${_file} NAME) 475 string(REGEX REPLACE "\\.S$" ".c" _cname "${_name}") 476 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_cname}") 477 message(STATUS "For ${name} builtins preferring ${_file} to ${_cname}") 478 list(REMOVE_ITEM intermediate ${_cname}) 479 endif() 480 endif() 481 endforeach() 482 set(${inout_var} ${intermediate} PARENT_SCOPE) 483endfunction() 484 485function(get_compiler_rt_target arch variable) 486 string(FIND ${COMPILER_RT_DEFAULT_TARGET_TRIPLE} "-" dash_index) 487 string(SUBSTRING ${COMPILER_RT_DEFAULT_TARGET_TRIPLE} ${dash_index} -1 triple_suffix) 488 if(COMPILER_RT_DEFAULT_TARGET_ONLY) 489 # Use exact spelling when building only for the target specified to CMake. 490 set(target "${COMPILER_RT_DEFAULT_TARGET_TRIPLE}") 491 elseif(ANDROID AND ${arch} STREQUAL "i386") 492 set(target "i686${triple_suffix}") 493 else() 494 set(target "${arch}${triple_suffix}") 495 endif() 496 set(${variable} ${target} PARENT_SCOPE) 497endfunction() 498 499function(get_compiler_rt_install_dir arch install_dir) 500 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) 501 get_compiler_rt_target(${arch} target) 502 set(${install_dir} ${COMPILER_RT_INSTALL_LIBRARY_DIR}/${target} PARENT_SCOPE) 503 else() 504 set(${install_dir} ${COMPILER_RT_INSTALL_LIBRARY_DIR} PARENT_SCOPE) 505 endif() 506endfunction() 507 508function(get_compiler_rt_output_dir arch output_dir) 509 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) 510 get_compiler_rt_target(${arch} target) 511 set(${output_dir} ${COMPILER_RT_OUTPUT_LIBRARY_DIR}/${target} PARENT_SCOPE) 512 else() 513 set(${output_dir} ${COMPILER_RT_OUTPUT_LIBRARY_DIR} PARENT_SCOPE) 514 endif() 515endfunction() 516 517# compiler_rt_process_sources( 518# <OUTPUT_VAR> 519# <SOURCE_FILE> ... 520# [ADDITIONAL_HEADERS <header> ...] 521# ) 522# 523# Process the provided sources and write the list of new sources 524# into `<OUTPUT_VAR>`. 525# 526# ADDITIONAL_HEADERS - Adds the supplied header to list of sources for IDEs. 527# 528# This function is very similar to `llvm_process_sources()` but exists here 529# because we need to support standalone builds of compiler-rt. 530function(compiler_rt_process_sources OUTPUT_VAR) 531 cmake_parse_arguments( 532 ARG 533 "" 534 "" 535 "ADDITIONAL_HEADERS" 536 ${ARGN} 537 ) 538 set(sources ${ARG_UNPARSED_ARGUMENTS}) 539 set(headers "") 540 if (XCODE OR MSVC_IDE OR CMAKE_EXTRA_GENERATOR) 541 # For IDEs we need to tell CMake about header files. 542 # Otherwise they won't show up in UI. 543 set(headers ${ARG_ADDITIONAL_HEADERS}) 544 list(LENGTH headers headers_length) 545 if (${headers_length} GREATER 0) 546 set_source_files_properties(${headers} 547 PROPERTIES HEADER_FILE_ONLY ON) 548 endif() 549 endif() 550 set("${OUTPUT_VAR}" ${sources} ${headers} PARENT_SCOPE) 551endfunction() 552 553# Create install targets for a library and its parent component (if specified). 554function(add_compiler_rt_install_targets name) 555 cmake_parse_arguments(ARG "" "PARENT_TARGET" "" ${ARGN}) 556 557 if(ARG_PARENT_TARGET AND NOT TARGET install-${ARG_PARENT_TARGET}) 558 # The parent install target specifies the parent component to scrape up 559 # anything not installed by the individual install targets, and to handle 560 # installation when running the multi-configuration generators. 561 add_custom_target(install-${ARG_PARENT_TARGET} 562 DEPENDS ${ARG_PARENT_TARGET} 563 COMMAND "${CMAKE_COMMAND}" 564 -DCMAKE_INSTALL_COMPONENT=${ARG_PARENT_TARGET} 565 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 566 add_custom_target(install-${ARG_PARENT_TARGET}-stripped 567 DEPENDS ${ARG_PARENT_TARGET} 568 COMMAND "${CMAKE_COMMAND}" 569 -DCMAKE_INSTALL_COMPONENT=${ARG_PARENT_TARGET} 570 -DCMAKE_INSTALL_DO_STRIP=1 571 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 572 set_target_properties(install-${ARG_PARENT_TARGET} PROPERTIES 573 FOLDER "Compiler-RT Misc") 574 set_target_properties(install-${ARG_PARENT_TARGET}-stripped PROPERTIES 575 FOLDER "Compiler-RT Misc") 576 add_dependencies(install-compiler-rt install-${ARG_PARENT_TARGET}) 577 add_dependencies(install-compiler-rt-stripped install-${ARG_PARENT_TARGET}-stripped) 578 endif() 579 580 # We only want to generate per-library install targets if you aren't using 581 # an IDE because the extra targets get cluttered in IDEs. 582 if(NOT CMAKE_CONFIGURATION_TYPES) 583 add_custom_target(install-${name} 584 DEPENDS ${name} 585 COMMAND "${CMAKE_COMMAND}" 586 -DCMAKE_INSTALL_COMPONENT=${name} 587 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 588 add_custom_target(install-${name}-stripped 589 DEPENDS ${name} 590 COMMAND "${CMAKE_COMMAND}" 591 -DCMAKE_INSTALL_COMPONENT=${name} 592 -DCMAKE_INSTALL_DO_STRIP=1 593 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") 594 # If you have a parent target specified, we bind the new install target 595 # to the parent install target. 596 if(LIB_PARENT_TARGET) 597 add_dependencies(install-${LIB_PARENT_TARGET} install-${name}) 598 add_dependencies(install-${LIB_PARENT_TARGET}-stripped install-${name}-stripped) 599 endif() 600 endif() 601endfunction() 602