1include(GNUInstallDirs) 2include(LLVMDistributionSupport) 3include(LLVMProcessSources) 4include(LLVM-Config) 5include(DetermineGCCCompatible) 6 7function(llvm_update_compile_flags name) 8 get_property(sources TARGET ${name} PROPERTY SOURCES) 9 if("${sources}" MATCHES "\\.c(;|$)") 10 set(update_src_props ON) 11 endif() 12 13 list(APPEND LLVM_COMPILE_CFLAGS " ${LLVM_COMPILE_FLAGS}") 14 15 # LLVM_REQUIRES_EH is an internal flag that individual targets can use to 16 # force EH 17 if(LLVM_REQUIRES_EH OR LLVM_ENABLE_EH) 18 if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI)) 19 message(AUTHOR_WARNING "Exception handling requires RTTI. Enabling RTTI for ${name}") 20 set(LLVM_REQUIRES_RTTI ON) 21 endif() 22 if(MSVC) 23 list(APPEND LLVM_COMPILE_FLAGS "/EHsc") 24 endif() 25 else() 26 if(LLVM_COMPILER_IS_GCC_COMPATIBLE) 27 list(APPEND LLVM_COMPILE_FLAGS "-fno-exceptions") 28 if(NOT LLVM_ENABLE_UNWIND_TABLES) 29 list(APPEND LLVM_COMPILE_FLAGS "-fno-unwind-tables") 30 list(APPEND LLVM_COMPILE_FLAGS "-fno-asynchronous-unwind-tables") 31 endif() 32 elseif(MSVC) 33 list(APPEND LLVM_COMPILE_DEFINITIONS _HAS_EXCEPTIONS=0) 34 list(APPEND LLVM_COMPILE_FLAGS "/EHs-c-") 35 elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL") 36 list(APPEND LLVM_COMPILE_FLAGS "-qnoeh") 37 endif() 38 endif() 39 40 # LLVM_REQUIRES_RTTI is an internal flag that individual 41 # targets can use to force RTTI 42 set(LLVM_CONFIG_HAS_RTTI YES CACHE INTERNAL "") 43 if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI)) 44 set(LLVM_CONFIG_HAS_RTTI NO CACHE INTERNAL "") 45 list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_RTTI=0) 46 if (LLVM_COMPILER_IS_GCC_COMPATIBLE) 47 list(APPEND LLVM_COMPILE_FLAGS "-fno-rtti") 48 elseif (MSVC) 49 list(APPEND LLVM_COMPILE_FLAGS "/GR-") 50 elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL") 51 list(APPEND LLVM_COMPILE_FLAGS "-qnortti") 52 endif () 53 elseif(MSVC) 54 list(APPEND LLVM_COMPILE_FLAGS "/GR") 55 endif() 56 57 # Assume that; 58 # - LLVM_COMPILE_FLAGS is list. 59 # - PROPERTY COMPILE_FLAGS is string. 60 string(REPLACE ";" " " target_compile_flags " ${LLVM_COMPILE_FLAGS}") 61 string(REPLACE ";" " " target_compile_cflags " ${LLVM_COMPILE_CFLAGS}") 62 63 if(update_src_props) 64 foreach(fn ${sources}) 65 get_filename_component(suf ${fn} EXT) 66 if("${suf}" STREQUAL ".cpp") 67 set_property(SOURCE ${fn} APPEND_STRING PROPERTY 68 COMPILE_FLAGS "${target_compile_flags}") 69 endif() 70 if("${suf}" STREQUAL ".c") 71 set_property(SOURCE ${fn} APPEND_STRING PROPERTY 72 COMPILE_FLAGS "${target_compile_cflags}") 73 endif() 74 endforeach() 75 else() 76 # Update target props, since all sources are C++. 77 set_property(TARGET ${name} APPEND_STRING PROPERTY 78 COMPILE_FLAGS "${target_compile_flags}") 79 endif() 80 81 set_property(TARGET ${name} APPEND PROPERTY COMPILE_DEFINITIONS ${LLVM_COMPILE_DEFINITIONS}) 82endfunction() 83 84function(add_llvm_symbol_exports target_name export_file) 85 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") 86 set(native_export_file "${target_name}.exports") 87 add_custom_command(OUTPUT ${native_export_file} 88 COMMAND sed -e "s/^/_/" < ${export_file} > ${native_export_file} 89 DEPENDS ${export_file} 90 VERBATIM 91 COMMENT "Creating export file for ${target_name}") 92 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 93 LINK_FLAGS " -Wl,-exported_symbols_list,\"${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}\"") 94 elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX") 95 # FIXME: `-Wl,-bE:` bypasses whatever handling there is in the build 96 # compiler driver to defer to the specified export list. 97 set(native_export_file "${export_file}") 98 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 99 LINK_FLAGS " -Wl,-bE:${export_file}") 100 elseif(LLVM_HAVE_LINK_VERSION_SCRIPT) 101 # Gold and BFD ld require a version script rather than a plain list. 102 set(native_export_file "${target_name}.exports") 103 # FIXME: Don't write the "local:" line on OpenBSD. 104 # in the export file, also add a linker script to version LLVM symbols (form: LLVM_N.M) 105 add_custom_command(OUTPUT ${native_export_file} 106 COMMAND echo "LLVM_${LLVM_VERSION_MAJOR} {" > ${native_export_file} 107 COMMAND grep -q "[[:alnum:]]" ${export_file} && echo " global:" >> ${native_export_file} || : 108 COMMAND sed -e "s/$/;/" -e "s/^/ /" < ${export_file} >> ${native_export_file} 109 COMMAND echo " local: *;" >> ${native_export_file} 110 COMMAND echo "};" >> ${native_export_file} 111 DEPENDS ${export_file} 112 VERBATIM 113 COMMENT "Creating export file for ${target_name}") 114 if (${LLVM_LINKER_IS_SOLARISLD}) 115 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 116 LINK_FLAGS " -Wl,-M,\"${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}\"") 117 else() 118 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 119 LINK_FLAGS " -Wl,--version-script,\"${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}\"") 120 endif() 121 else() 122 set(native_export_file "${target_name}.def") 123 124 add_custom_command(OUTPUT ${native_export_file} 125 COMMAND "${Python3_EXECUTABLE}" -c "import sys;print(''.join(['EXPORTS\\n']+sys.stdin.readlines(),))" 126 < ${export_file} > ${native_export_file} 127 DEPENDS ${export_file} 128 VERBATIM 129 COMMENT "Creating export file for ${target_name}") 130 set(export_file_linker_flag "${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}") 131 if(MSVC) 132 set(export_file_linker_flag "/DEF:\"${export_file_linker_flag}\"") 133 endif() 134 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 135 LINK_FLAGS " ${export_file_linker_flag}") 136 endif() 137 138 add_custom_target(${target_name}_exports DEPENDS ${native_export_file}) 139 set_target_properties(${target_name}_exports PROPERTIES FOLDER "Misc") 140 141 get_property(srcs TARGET ${target_name} PROPERTY SOURCES) 142 foreach(src ${srcs}) 143 get_filename_component(extension ${src} EXT) 144 if(extension STREQUAL ".cpp") 145 set(first_source_file ${src}) 146 break() 147 endif() 148 endforeach() 149 150 # Force re-linking when the exports file changes. Actually, it 151 # forces recompilation of the source file. The LINK_DEPENDS target 152 # property only works for makefile-based generators. 153 # FIXME: This is not safe because this will create the same target 154 # ${native_export_file} in several different file: 155 # - One where we emitted ${target_name}_exports 156 # - One where we emitted the build command for the following object. 157 # set_property(SOURCE ${first_source_file} APPEND PROPERTY 158 # OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}) 159 160 set_property(DIRECTORY APPEND 161 PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${native_export_file}) 162 163 add_dependencies(${target_name} ${target_name}_exports) 164 165 # Add dependency to *_exports later -- CMake issue 14747 166 list(APPEND LLVM_COMMON_DEPENDS ${target_name}_exports) 167 set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} PARENT_SCOPE) 168endfunction(add_llvm_symbol_exports) 169 170if (NOT DEFINED LLVM_LINKER_DETECTED AND NOT WIN32) 171 # Detect what linker we have here. 172 if(APPLE) 173 # Linkers with ld64-compatible flags. 174 set(version_flag "-Wl,-v") 175 else() 176 # Linkers with BFD ld-compatible flags. 177 set(version_flag "-Wl,--version") 178 endif() 179 180 if (CMAKE_HOST_WIN32) 181 set(DEVNULL "NUL") 182 else() 183 set(DEVNULL "/dev/null") 184 endif() 185 186 if(LLVM_USE_LINKER) 187 set(command ${CMAKE_C_COMPILER} -fuse-ld=${LLVM_USE_LINKER} ${version_flag} -o ${DEVNULL}) 188 else() 189 separate_arguments(flags UNIX_COMMAND "${CMAKE_EXE_LINKER_FLAGS}") 190 set(command ${CMAKE_C_COMPILER} ${flags} ${version_flag} -o ${DEVNULL}) 191 endif() 192 execute_process( 193 COMMAND ${command} 194 OUTPUT_VARIABLE stdout 195 ERROR_VARIABLE stderr 196 ) 197 198 if(APPLE) 199 if("${stderr}" MATCHES "PROJECT:ld64") 200 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 201 set(LLVM_LINKER_IS_LD64 YES CACHE INTERNAL "") 202 message(STATUS "Linker detection: ld64") 203 elseif("${stderr}" MATCHES "^LLD" OR 204 "${stdout}" MATCHES "^LLD") 205 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 206 set(LLVM_LINKER_IS_LLD YES CACHE INTERNAL "") 207 message(STATUS "Linker detection: lld") 208 else() 209 set(LLVM_LINKER_DETECTED NO CACHE INTERNAL "") 210 message(STATUS "Linker detection: unknown") 211 endif() 212 else() 213 if("${stdout}" MATCHES "^mold") 214 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 215 message(STATUS "Linker detection: mold") 216 elseif("${stdout}" MATCHES "GNU gold") 217 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 218 set(LLVM_LINKER_IS_GOLD YES CACHE INTERNAL "") 219 message(STATUS "Linker detection: GNU Gold") 220 elseif("${stdout}" MATCHES "^LLD") 221 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 222 set(LLVM_LINKER_IS_LLD YES CACHE INTERNAL "") 223 message(STATUS "Linker detection: LLD") 224 elseif("${stdout}" MATCHES "GNU ld") 225 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 226 set(LLVM_LINKER_IS_GNULD YES CACHE INTERNAL "") 227 message(STATUS "Linker detection: GNU ld") 228 elseif("${stderr}" MATCHES "Solaris Link Editors" OR 229 "${stdout}" MATCHES "Solaris Link Editors") 230 set(LLVM_LINKER_DETECTED YES CACHE INTERNAL "") 231 set(LLVM_LINKER_IS_SOLARISLD YES CACHE INTERNAL "") 232 message(STATUS "Linker detection: Solaris ld") 233 else() 234 set(LLVM_LINKER_DETECTED NO CACHE INTERNAL "") 235 message(STATUS "Linker detection: unknown") 236 endif() 237 endif() 238endif() 239 240function(add_link_opts target_name) 241 get_llvm_distribution(${target_name} in_distribution in_distribution_var) 242 if(NOT in_distribution) 243 # Don't LTO optimize targets that aren't part of any distribution. 244 if (LLVM_ENABLE_LTO) 245 # We may consider avoiding LTO altogether by using -fembed-bitcode 246 # and teaching the linker to select machine code from .o files, see 247 # https://lists.llvm.org/pipermail/llvm-dev/2021-April/149843.html 248 if((UNIX OR MINGW) AND LINKER_IS_LLD) 249 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 250 LINK_FLAGS " -Wl,--lto-O0") 251 elseif(LINKER_IS_LLD_LINK) 252 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 253 LINK_FLAGS " /opt:lldlto=0") 254 elseif(APPLE AND NOT uppercase_LLVM_ENABLE_LTO STREQUAL "THIN") 255 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 256 LINK_FLAGS " -Wl,-mllvm,-O0") 257 endif() 258 endif() 259 endif() 260 261 # Don't use linker optimizations in debug builds since it slows down the 262 # linker in a context where the optimizations are not important. 263 if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") 264 if(NOT LLVM_NO_DEAD_STRIP) 265 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") 266 # ld64's implementation of -dead_strip breaks tools that use plugins. 267 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 268 LINK_FLAGS " -Wl,-dead_strip") 269 elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS") 270 # Support for ld -z discard-unused=sections was only added in 271 # Solaris 11.4. 272 include(LLVMCheckLinkerFlag) 273 llvm_check_linker_flag(CXX "-Wl,-z,discard-unused=sections" LINKER_SUPPORTS_Z_DISCARD_UNUSED) 274 if (LINKER_SUPPORTS_Z_DISCARD_UNUSED) 275 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 276 LINK_FLAGS " -Wl,-z,discard-unused=sections") 277 endif() 278 elseif(NOT MSVC AND NOT CMAKE_SYSTEM_NAME MATCHES "AIX|OS390") 279 # TODO Revisit this later on z/OS. 280 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 281 LINK_FLAGS " -Wl,--gc-sections") 282 endif() 283 else() #LLVM_NO_DEAD_STRIP 284 if(${CMAKE_SYSTEM_NAME} MATCHES "AIX") 285 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 286 LINK_FLAGS " -Wl,-bnogc") 287 endif() 288 endif() 289 endif() 290 291 if(ARG_SUPPORT_PLUGINS AND ${CMAKE_SYSTEM_NAME} MATCHES "AIX") 292 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 293 LINK_FLAGS " -Wl,-brtl") 294 endif() 295endfunction(add_link_opts) 296 297# Set each output directory according to ${CMAKE_CONFIGURATION_TYPES}. 298# Note: Don't set variables CMAKE_*_OUTPUT_DIRECTORY any more, 299# or a certain builder, for eaxample, msbuild.exe, would be confused. 300function(set_output_directory target) 301 cmake_parse_arguments(ARG "" "BINARY_DIR;LIBRARY_DIR" "" ${ARGN}) 302 303 # module_dir -- corresponding to LIBRARY_OUTPUT_DIRECTORY. 304 # It affects output of add_library(MODULE). 305 if(WIN32 OR CYGWIN) 306 # DLL platform 307 set(module_dir ${ARG_BINARY_DIR}) 308 else() 309 set(module_dir ${ARG_LIBRARY_DIR}) 310 endif() 311 if(NOT "${CMAKE_CFG_INTDIR}" STREQUAL ".") 312 foreach(build_mode ${CMAKE_CONFIGURATION_TYPES}) 313 string(TOUPPER "${build_mode}" CONFIG_SUFFIX) 314 if(ARG_BINARY_DIR) 315 string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} bi ${ARG_BINARY_DIR}) 316 set_target_properties(${target} PROPERTIES "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${bi}) 317 endif() 318 if(ARG_LIBRARY_DIR) 319 string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} li ${ARG_LIBRARY_DIR}) 320 set_target_properties(${target} PROPERTIES "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${li}) 321 endif() 322 if(module_dir) 323 string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} mi ${module_dir}) 324 set_target_properties(${target} PROPERTIES "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${mi}) 325 endif() 326 endforeach() 327 else() 328 if(ARG_BINARY_DIR) 329 set_target_properties(${target} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${ARG_BINARY_DIR}) 330 endif() 331 if(ARG_LIBRARY_DIR) 332 set_target_properties(${target} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${ARG_LIBRARY_DIR}) 333 endif() 334 if(module_dir) 335 set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${module_dir}) 336 endif() 337 endif() 338endfunction() 339 340# If on Windows and building with MSVC, add the resource script containing the 341# VERSIONINFO data to the project. This embeds version resource information 342# into the output .exe or .dll. 343# TODO: Enable for MinGW Windows builds too. 344# 345function(add_windows_version_resource_file OUT_VAR) 346 set(sources ${ARGN}) 347 if (MSVC AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") 348 set(resource_file ${LLVM_SOURCE_DIR}/resources/windows_version_resource.rc) 349 if(EXISTS ${resource_file}) 350 set(sources ${sources} ${resource_file}) 351 source_group("Resource Files" ${resource_file}) 352 set(windows_resource_file ${resource_file} PARENT_SCOPE) 353 endif() 354 endif(MSVC AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") 355 356 set(${OUT_VAR} ${sources} PARENT_SCOPE) 357endfunction(add_windows_version_resource_file) 358 359# set_windows_version_resource_properties(name resource_file... 360# VERSION_MAJOR int 361# Optional major version number (defaults to LLVM_VERSION_MAJOR) 362# VERSION_MINOR int 363# Optional minor version number (defaults to LLVM_VERSION_MINOR) 364# VERSION_PATCHLEVEL int 365# Optional patchlevel version number (defaults to LLVM_VERSION_PATCH) 366# VERSION_STRING 367# Optional version string (defaults to PACKAGE_VERSION) 368# PRODUCT_NAME 369# Optional product name string (defaults to "LLVM") 370# ) 371function(set_windows_version_resource_properties name resource_file) 372 cmake_parse_arguments(ARG 373 "" 374 "VERSION_MAJOR;VERSION_MINOR;VERSION_PATCHLEVEL;VERSION_STRING;PRODUCT_NAME" 375 "" 376 ${ARGN}) 377 378 if (NOT DEFINED ARG_VERSION_MAJOR) 379 set(ARG_VERSION_MAJOR ${LLVM_VERSION_MAJOR}) 380 endif() 381 382 if (NOT DEFINED ARG_VERSION_MINOR) 383 set(ARG_VERSION_MINOR ${LLVM_VERSION_MINOR}) 384 endif() 385 386 if (NOT DEFINED ARG_VERSION_PATCHLEVEL) 387 set(ARG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH}) 388 endif() 389 390 if (NOT DEFINED ARG_VERSION_STRING) 391 set(ARG_VERSION_STRING ${PACKAGE_VERSION}) 392 endif() 393 394 if (NOT DEFINED ARG_PRODUCT_NAME) 395 set(ARG_PRODUCT_NAME "LLVM") 396 endif() 397 398 set_property(SOURCE ${resource_file} 399 PROPERTY COMPILE_FLAGS /nologo) 400 set_property(SOURCE ${resource_file} 401 PROPERTY COMPILE_DEFINITIONS 402 "RC_VERSION_FIELD_1=${ARG_VERSION_MAJOR}" 403 "RC_VERSION_FIELD_2=${ARG_VERSION_MINOR}" 404 "RC_VERSION_FIELD_3=${ARG_VERSION_PATCHLEVEL}" 405 "RC_VERSION_FIELD_4=0" 406 "RC_FILE_VERSION=\"${ARG_VERSION_STRING}\"" 407 "RC_INTERNAL_NAME=\"${name}\"" 408 "RC_PRODUCT_NAME=\"${ARG_PRODUCT_NAME}\"" 409 "RC_PRODUCT_VERSION=\"${ARG_VERSION_STRING}\"") 410endfunction(set_windows_version_resource_properties) 411 412# llvm_add_library(name sources... 413# SHARED;STATIC 414# STATIC by default w/o BUILD_SHARED_LIBS. 415# SHARED by default w/ BUILD_SHARED_LIBS. 416# OBJECT 417# Also create an OBJECT library target. Default if STATIC && SHARED. 418# MODULE 419# Target ${name} might not be created on unsupported platforms. 420# Check with "if(TARGET ${name})". 421# DISABLE_LLVM_LINK_LLVM_DYLIB 422# Do not link this library to libLLVM, even if 423# LLVM_LINK_LLVM_DYLIB is enabled. 424# OUTPUT_NAME name 425# Corresponds to OUTPUT_NAME in target properties. 426# DEPENDS targets... 427# Same semantics as add_dependencies(). 428# LINK_COMPONENTS components... 429# Same as the variable LLVM_LINK_COMPONENTS. 430# LINK_LIBS lib_targets... 431# Same semantics as target_link_libraries(). 432# ADDITIONAL_HEADERS 433# May specify header files for IDE generators. 434# SONAME 435# Should set SONAME link flags and create symlinks 436# NO_INSTALL_RPATH 437# Suppress default RPATH settings in shared libraries. 438# PLUGIN_TOOL 439# The tool (i.e. cmake target) that this plugin will link against 440# COMPONENT_LIB 441# This is used to specify that this is a component library of 442# LLVM which means that the source resides in llvm/lib/ and it is a 443# candidate for inclusion into libLLVM.so. 444# ) 445function(llvm_add_library name) 446 cmake_parse_arguments(ARG 447 "MODULE;SHARED;STATIC;OBJECT;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME;NO_INSTALL_RPATH;COMPONENT_LIB" 448 "OUTPUT_NAME;PLUGIN_TOOL;ENTITLEMENTS;BUNDLE_PATH" 449 "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS" 450 ${ARGN}) 451 list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS}) 452 if(ARG_ADDITIONAL_HEADERS) 453 # Pass through ADDITIONAL_HEADERS. 454 set(ARG_ADDITIONAL_HEADERS ADDITIONAL_HEADERS ${ARG_ADDITIONAL_HEADERS}) 455 endif() 456 if(ARG_OBJLIBS) 457 set(ALL_FILES ${ARG_OBJLIBS}) 458 else() 459 llvm_process_sources(ALL_FILES ${ARG_UNPARSED_ARGUMENTS} ${ARG_ADDITIONAL_HEADERS}) 460 endif() 461 462 if(ARG_MODULE) 463 if(ARG_SHARED OR ARG_STATIC) 464 message(WARNING "MODULE with SHARED|STATIC doesn't make sense.") 465 endif() 466 # Plugins that link against a tool are allowed even when plugins in general are not 467 if(NOT LLVM_ENABLE_PLUGINS AND NOT (ARG_PLUGIN_TOOL AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)) 468 message(STATUS "${name} ignored -- Loadable modules not supported on this platform.") 469 return() 470 endif() 471 else() 472 if(ARG_PLUGIN_TOOL) 473 message(WARNING "PLUGIN_TOOL without MODULE doesn't make sense.") 474 endif() 475 if(BUILD_SHARED_LIBS AND NOT ARG_STATIC) 476 set(ARG_SHARED TRUE) 477 endif() 478 if(NOT ARG_SHARED) 479 set(ARG_STATIC TRUE) 480 endif() 481 endif() 482 483 # Generate objlib 484 if((ARG_SHARED AND ARG_STATIC) OR ARG_OBJECT) 485 # Generate an obj library for both targets. 486 set(obj_name "obj.${name}") 487 add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL 488 ${ALL_FILES} 489 ) 490 llvm_update_compile_flags(${obj_name}) 491 if(CMAKE_GENERATOR STREQUAL "Xcode") 492 set(DUMMY_FILE ${CMAKE_CURRENT_BINARY_DIR}/Dummy.c) 493 file(WRITE ${DUMMY_FILE} "// This file intentionally empty\n") 494 set_property(SOURCE ${DUMMY_FILE} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-empty-translation-unit") 495 endif() 496 set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>" ${DUMMY_FILE}) 497 498 # Do add_dependencies(obj) later due to CMake issue 14747. 499 list(APPEND objlibs ${obj_name}) 500 501 # Bring in the target include directories from our original target. 502 target_include_directories(${obj_name} PRIVATE $<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>) 503 504 set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries") 505 if(ARG_DEPENDS) 506 add_dependencies(${obj_name} ${ARG_DEPENDS}) 507 endif() 508 # Treat link libraries like PUBLIC dependencies. LINK_LIBS might 509 # result in generating header files. Add a dependendency so that 510 # the generated header is created before this object library. 511 if(ARG_LINK_LIBS) 512 cmake_parse_arguments(LINK_LIBS_ARG 513 "" 514 "" 515 "PUBLIC;PRIVATE" 516 ${ARG_LINK_LIBS}) 517 foreach(link_lib ${LINK_LIBS_ARG_PUBLIC}) 518 if(LLVM_PTHREAD_LIB) 519 # Can't specify a dependence on -lpthread 520 if(NOT ${link_lib} STREQUAL ${LLVM_PTHREAD_LIB}) 521 add_dependencies(${obj_name} ${link_lib}) 522 endif() 523 else() 524 add_dependencies(${obj_name} ${link_lib}) 525 endif() 526 endforeach() 527 endif() 528 endif() 529 530 if(ARG_SHARED AND ARG_STATIC) 531 # static 532 set(name_static "${name}_static") 533 if(ARG_OUTPUT_NAME) 534 set(output_name OUTPUT_NAME "${ARG_OUTPUT_NAME}") 535 endif() 536 # DEPENDS has been appended to LLVM_COMMON_LIBS. 537 llvm_add_library(${name_static} STATIC 538 ${output_name} 539 OBJLIBS ${ALL_FILES} # objlib 540 LINK_LIBS ${ARG_LINK_LIBS} 541 LINK_COMPONENTS ${ARG_LINK_COMPONENTS} 542 ) 543 544 # Bring in the target link info from our original target. 545 target_link_directories(${name_static} PRIVATE $<TARGET_PROPERTY:${name},LINK_DIRECTORIES>) 546 target_link_libraries(${name_static} PRIVATE $<TARGET_PROPERTY:${name},LINK_LIBRARIES>) 547 548 # FIXME: Add name_static to anywhere in TARGET ${name}'s PROPERTY. 549 set(ARG_STATIC) 550 endif() 551 552 if(ARG_MODULE) 553 add_library(${name} MODULE ${ALL_FILES}) 554 elseif(ARG_SHARED) 555 add_windows_version_resource_file(ALL_FILES ${ALL_FILES}) 556 add_library(${name} SHARED ${ALL_FILES}) 557 else() 558 add_library(${name} STATIC ${ALL_FILES}) 559 endif() 560 561 if(ARG_COMPONENT_LIB) 562 set_target_properties(${name} PROPERTIES LLVM_COMPONENT TRUE) 563 set_property(GLOBAL APPEND PROPERTY LLVM_COMPONENT_LIBS ${name}) 564 endif() 565 566 if(NOT ARG_NO_INSTALL_RPATH) 567 if(ARG_MODULE OR ARG_SHARED) 568 llvm_setup_rpath(${name}) 569 endif() 570 endif() 571 572 setup_dependency_debugging(${name} ${LLVM_COMMON_DEPENDS}) 573 574 if(DEFINED windows_resource_file) 575 set_windows_version_resource_properties(${name} ${windows_resource_file}) 576 set(windows_resource_file ${windows_resource_file} PARENT_SCOPE) 577 endif() 578 579 set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) 580 # $<TARGET_OBJECTS> doesn't require compile flags. 581 if(NOT obj_name) 582 llvm_update_compile_flags(${name}) 583 endif() 584 add_link_opts( ${name} ) 585 if(ARG_OUTPUT_NAME) 586 set_target_properties(${name} 587 PROPERTIES 588 OUTPUT_NAME ${ARG_OUTPUT_NAME} 589 ) 590 endif() 591 592 if(ARG_MODULE) 593 set_target_properties(${name} PROPERTIES 594 PREFIX "" 595 SUFFIX ${LLVM_PLUGIN_EXT} 596 ) 597 endif() 598 599 if(ARG_SHARED) 600 if(MSVC) 601 set_target_properties(${name} PROPERTIES 602 PREFIX "" 603 ) 604 endif() 605 606 # Set SOVERSION on shared libraries that lack explicit SONAME 607 # specifier, on *nix systems that are not Darwin. 608 if(UNIX AND NOT APPLE AND NOT ARG_SONAME) 609 set_target_properties(${name} 610 PROPERTIES 611 # Since 4.0.0, the ABI version is indicated by the major version 612 SOVERSION ${LLVM_VERSION_MAJOR}${LLVM_VERSION_SUFFIX} 613 VERSION ${LLVM_VERSION_MAJOR}${LLVM_VERSION_SUFFIX}) 614 endif() 615 endif() 616 617 if(ARG_MODULE OR ARG_SHARED) 618 # Do not add -Dname_EXPORTS to the command-line when building files in this 619 # target. Doing so is actively harmful for the modules build because it 620 # creates extra module variants, and not useful because we don't use these 621 # macros. 622 set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" ) 623 624 if (LLVM_EXPORTED_SYMBOL_FILE) 625 add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} ) 626 endif() 627 endif() 628 629 if(ARG_SHARED) 630 if(NOT APPLE AND ARG_SONAME) 631 get_target_property(output_name ${name} OUTPUT_NAME) 632 if(${output_name} STREQUAL "output_name-NOTFOUND") 633 set(output_name ${name}) 634 endif() 635 set(library_name ${output_name}-${LLVM_VERSION_MAJOR}${LLVM_VERSION_SUFFIX}) 636 set(api_name ${output_name}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX}) 637 set_target_properties(${name} PROPERTIES OUTPUT_NAME ${library_name}) 638 if(UNIX) 639 llvm_install_library_symlink(${api_name} ${library_name} SHARED 640 COMPONENT ${name}) 641 llvm_install_library_symlink(${output_name} ${library_name} SHARED 642 COMPONENT ${name}) 643 endif() 644 endif() 645 endif() 646 647 if(ARG_STATIC) 648 set(libtype PUBLIC) 649 else() 650 # We can use PRIVATE since SO knows its dependent libs. 651 set(libtype PRIVATE) 652 endif() 653 654 if(ARG_MODULE AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS AND ARG_PLUGIN_TOOL AND (WIN32 OR CYGWIN)) 655 # On DLL platforms symbols are imported from the tool by linking against it. 656 set(llvm_libs ${ARG_PLUGIN_TOOL}) 657 elseif (NOT ARG_COMPONENT_LIB) 658 if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB) 659 set(llvm_libs LLVM) 660 else() 661 llvm_map_components_to_libnames(llvm_libs 662 ${ARG_LINK_COMPONENTS} 663 ${LLVM_LINK_COMPONENTS} 664 ) 665 endif() 666 else() 667 # Components have not been defined explicitly in CMake, so add the 668 # dependency information for this library through their name, and let 669 # LLVMBuildResolveComponentsLink resolve the mapping. 670 # 671 # It would be nice to verify that we have the dependencies for this library 672 # name, but using get_property(... SET) doesn't suffice to determine if a 673 # property has been set to an empty value. 674 set_property(TARGET ${name} PROPERTY LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS} ${LLVM_LINK_COMPONENTS}) 675 676 # This property is an internal property only used to make sure the 677 # link step applied in LLVMBuildResolveComponentsLink uses the same 678 # property as the target_link_libraries call below. 679 set_property(TARGET ${name} PROPERTY LLVM_LIBTYPE ${libtype}) 680 endif() 681 682 target_link_libraries(${name} ${libtype} 683 ${ARG_LINK_LIBS} 684 ${lib_deps} 685 ${llvm_libs} 686 ) 687 688 if(LLVM_COMMON_DEPENDS) 689 add_dependencies(${name} ${LLVM_COMMON_DEPENDS}) 690 # Add dependencies also to objlibs. 691 # CMake issue 14747 -- add_dependencies() might be ignored to objlib's user. 692 foreach(objlib ${objlibs}) 693 add_dependencies(${objlib} ${LLVM_COMMON_DEPENDS}) 694 endforeach() 695 endif() 696 697 if(ARG_SHARED OR ARG_MODULE) 698 llvm_externalize_debuginfo(${name}) 699 llvm_codesign(${name} ENTITLEMENTS ${ARG_ENTITLEMENTS} BUNDLE_PATH ${ARG_BUNDLE_PATH}) 700 endif() 701 # clang and newer versions of ninja use high-resolutions timestamps, 702 # but older versions of libtool on Darwin don't, so the archive will 703 # often get an older timestamp than the last object that was added 704 # or updated. To fix this, we add a custom command to touch archive 705 # after it's been built so that ninja won't rebuild it unnecessarily 706 # the next time it's run. 707 if(ARG_STATIC AND LLVM_TOUCH_STATIC_LIBRARIES) 708 add_custom_command(TARGET ${name} 709 POST_BUILD 710 COMMAND touch ${LLVM_LIBRARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX} 711 ) 712 endif() 713endfunction() 714 715function(add_llvm_install_targets target) 716 cmake_parse_arguments(ARG "" "COMPONENT;PREFIX;SYMLINK" "DEPENDS" ${ARGN}) 717 if(ARG_COMPONENT) 718 set(component_option -DCMAKE_INSTALL_COMPONENT="${ARG_COMPONENT}") 719 endif() 720 if(ARG_PREFIX) 721 set(prefix_option -DCMAKE_INSTALL_PREFIX="${ARG_PREFIX}") 722 endif() 723 724 set(file_dependencies) 725 set(target_dependencies) 726 foreach(dependency ${ARG_DEPENDS}) 727 if(TARGET ${dependency}) 728 list(APPEND target_dependencies ${dependency}) 729 else() 730 list(APPEND file_dependencies ${dependency}) 731 endif() 732 endforeach() 733 734 add_custom_target(${target} 735 DEPENDS ${file_dependencies} 736 COMMAND "${CMAKE_COMMAND}" 737 ${component_option} 738 ${prefix_option} 739 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake" 740 USES_TERMINAL) 741 set_target_properties(${target} PROPERTIES FOLDER "Component Install Targets") 742 add_custom_target(${target}-stripped 743 DEPENDS ${file_dependencies} 744 COMMAND "${CMAKE_COMMAND}" 745 ${component_option} 746 ${prefix_option} 747 -DCMAKE_INSTALL_DO_STRIP=1 748 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake" 749 USES_TERMINAL) 750 set_target_properties(${target}-stripped PROPERTIES FOLDER "Component Install Targets (Stripped)") 751 if(target_dependencies) 752 add_dependencies(${target} ${target_dependencies}) 753 add_dependencies(${target}-stripped ${target_dependencies}) 754 endif() 755 756 if(ARG_SYMLINK) 757 add_dependencies(${target} install-${ARG_SYMLINK}) 758 add_dependencies(${target}-stripped install-${ARG_SYMLINK}-stripped) 759 endif() 760endfunction() 761 762# Define special targets that behave like a component group. They don't have any 763# source attached but other components can add themselves to them. If the 764# component supports is a Target and it supports JIT compilation, HAS_JIT must 765# be passed. One can use ADD_TO_COMPONENT option from add_llvm_component_library 766# to link extra component into an existing group. 767function(add_llvm_component_group name) 768 cmake_parse_arguments(ARG "HAS_JIT" "" "LINK_COMPONENTS" ${ARGN}) 769 add_custom_target(${name}) 770 if(ARG_HAS_JIT) 771 set_property(TARGET ${name} PROPERTY COMPONENT_HAS_JIT ON) 772 endif() 773 if(ARG_LINK_COMPONENTS) 774 set_property(TARGET ${name} PROPERTY LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS}) 775 endif() 776endfunction() 777 778# An LLVM component is a cmake target with the following cmake properties 779# eventually set: 780# - LLVM_COMPONENT_NAME: the name of the component, which can be the name of 781# the associated library or the one specified through COMPONENT_NAME 782# - LLVM_LINK_COMPONENTS: a list of component this component depends on 783# - COMPONENT_HAS_JIT: (only for group component) whether this target group 784# supports JIT compilation 785# Additionnaly, the ADD_TO_COMPONENT <component> option make it possible to add this 786# component to the LLVM_LINK_COMPONENTS of <component>. 787function(add_llvm_component_library name) 788 cmake_parse_arguments(ARG 789 "" 790 "COMPONENT_NAME;ADD_TO_COMPONENT" 791 "" 792 ${ARGN}) 793 add_llvm_library(${name} COMPONENT_LIB ${ARG_UNPARSED_ARGUMENTS}) 794 string(REGEX REPLACE "^LLVM" "" component_name ${name}) 795 set_property(TARGET ${name} PROPERTY LLVM_COMPONENT_NAME ${component_name}) 796 797 if(ARG_COMPONENT_NAME) 798 set_property(GLOBAL PROPERTY LLVM_COMPONENT_NAME_${ARG_COMPONENT_NAME} ${component_name}) 799 endif() 800 801 if(ARG_ADD_TO_COMPONENT) 802 set_property(TARGET ${ARG_ADD_TO_COMPONENT} APPEND PROPERTY LLVM_LINK_COMPONENTS ${component_name}) 803 endif() 804 805endfunction() 806 807macro(add_llvm_library name) 808 cmake_parse_arguments(ARG 809 "SHARED;BUILDTREE_ONLY;MODULE;INSTALL_WITH_TOOLCHAIN" 810 "" 811 "" 812 ${ARGN}) 813 if(ARG_MODULE) 814 llvm_add_library(${name} MODULE ${ARG_UNPARSED_ARGUMENTS}) 815 elseif( BUILD_SHARED_LIBS OR ARG_SHARED ) 816 llvm_add_library(${name} SHARED ${ARG_UNPARSED_ARGUMENTS}) 817 else() 818 llvm_add_library(${name} ${ARG_UNPARSED_ARGUMENTS}) 819 endif() 820 821 # Libraries that are meant to only be exposed via the build tree only are 822 # never installed and are only exported as a target in the special build tree 823 # config file. 824 if (NOT ARG_BUILDTREE_ONLY AND NOT ARG_MODULE) 825 set_property( GLOBAL APPEND PROPERTY LLVM_LIBS ${name} ) 826 set(in_llvm_libs YES) 827 endif() 828 829 if (ARG_MODULE AND NOT TARGET ${name}) 830 # Add empty "phony" target 831 add_custom_target(${name}) 832 elseif( EXCLUDE_FROM_ALL ) 833 set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON) 834 elseif(ARG_BUILDTREE_ONLY) 835 set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name}) 836 else() 837 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ARG_INSTALL_WITH_TOOLCHAIN) 838 if(in_llvm_libs) 839 set(umbrella UMBRELLA llvm-libraries) 840 else() 841 set(umbrella) 842 endif() 843 844 get_target_export_arg(${name} LLVM export_to_llvmexports ${umbrella}) 845 install(TARGETS ${name} 846 ${export_to_llvmexports} 847 LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT ${name} 848 ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT ${name} 849 RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT ${name}) 850 851 if (NOT LLVM_ENABLE_IDE) 852 add_llvm_install_targets(install-${name} 853 DEPENDS ${name} 854 COMPONENT ${name}) 855 endif() 856 endif() 857 set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name}) 858 endif() 859 if (ARG_MODULE) 860 set_target_properties(${name} PROPERTIES FOLDER "Loadable modules") 861 else() 862 set_target_properties(${name} PROPERTIES FOLDER "Libraries") 863 endif() 864endmacro(add_llvm_library name) 865 866macro(add_llvm_executable name) 867 cmake_parse_arguments(ARG 868 "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO;NO_INSTALL_RPATH;SUPPORT_PLUGINS;GENERATE_DRIVER" 869 "ENTITLEMENTS;BUNDLE_PATH" 870 "DEPENDS" 871 ${ARGN}) 872 873 llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} ) 874 875 list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS}) 876 877 # Generate objlib 878 if(LLVM_ENABLE_OBJLIB OR ARG_GENERATE_DRIVER) 879 # Generate an obj library for both targets. 880 set(obj_name "obj.${name}") 881 add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL 882 ${ALL_FILES} 883 ) 884 llvm_update_compile_flags(${obj_name}) 885 set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>") 886 if(ARG_DEPENDS) 887 add_dependencies(${obj_name} ${ARG_DEPENDS}) 888 endif() 889 890 set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries") 891 endif() 892 893 if (ARG_GENERATE_DRIVER) 894 string(REPLACE "-" "_" TOOL_NAME ${name}) 895 configure_file( 896 ${LLVM_MAIN_SRC_DIR}/cmake/driver-template.cpp.in 897 ${CMAKE_CURRENT_BINARY_DIR}/${name}-driver.cpp) 898 899 list(APPEND ALL_FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}-driver.cpp) 900 901 set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_COMPONENTS ${LLVM_LINK_COMPONENTS}) 902 set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_DEPS ${ARG_DEPENDS} ${LLVM_COMMON_DEPENDS}) 903 set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_OBJLIBS "${obj_name}") 904 905 set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_TOOLS ${name}) 906 target_link_libraries(${obj_name} ${LLVM_PTHREAD_LIB}) 907 llvm_config(${obj_name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} ) 908 endif() 909 910 add_windows_version_resource_file(ALL_FILES ${ALL_FILES}) 911 912 if(XCODE) 913 # Note: the dummy.cpp source file provides no definitions. However, 914 # it forces Xcode to properly link the static library. 915 list(APPEND ALL_FILES "${LLVM_MAIN_SRC_DIR}/cmake/dummy.cpp") 916 endif() 917 918 if( EXCLUDE_FROM_ALL ) 919 add_executable(${name} EXCLUDE_FROM_ALL ${ALL_FILES}) 920 else() 921 add_executable(${name} ${ALL_FILES}) 922 endif() 923 924 setup_dependency_debugging(${name} ${LLVM_COMMON_DEPENDS}) 925 926 if(NOT ARG_NO_INSTALL_RPATH) 927 llvm_setup_rpath(${name}) 928 elseif(NOT "${LLVM_LOCAL_RPATH}" STREQUAL "") 929 # Enable BUILD_WITH_INSTALL_RPATH unless CMAKE_BUILD_RPATH is set. 930 if("${CMAKE_BUILD_RPATH}" STREQUAL "") 931 set_property(TARGET ${name} PROPERTY BUILD_WITH_INSTALL_RPATH ON) 932 endif() 933 934 set_property(TARGET ${name} PROPERTY INSTALL_RPATH "${LLVM_LOCAL_RPATH}") 935 endif() 936 937 if(DEFINED windows_resource_file) 938 set_windows_version_resource_properties(${name} ${windows_resource_file}) 939 endif() 940 941 # $<TARGET_OBJECTS> doesn't require compile flags. 942 if(NOT LLVM_ENABLE_OBJLIB) 943 llvm_update_compile_flags(${name}) 944 endif() 945 946 if (ARG_SUPPORT_PLUGINS AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "AIX") 947 set(LLVM_NO_DEAD_STRIP On) 948 endif() 949 950 add_link_opts( ${name} ) 951 952 # Do not add -Dname_EXPORTS to the command-line when building files in this 953 # target. Doing so is actively harmful for the modules build because it 954 # creates extra module variants, and not useful because we don't use these 955 # macros. 956 set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" ) 957 958 if (LLVM_EXPORTED_SYMBOL_FILE) 959 add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} ) 960 endif(LLVM_EXPORTED_SYMBOL_FILE) 961 962 if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB) 963 set(USE_SHARED USE_SHARED) 964 endif() 965 966 set(EXCLUDE_FROM_ALL OFF) 967 set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) 968 llvm_config( ${name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} ) 969 if( LLVM_COMMON_DEPENDS ) 970 add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} ) 971 foreach(objlib ${obj_name}) 972 add_dependencies(${objlib} ${LLVM_COMMON_DEPENDS}) 973 endforeach() 974 endif( LLVM_COMMON_DEPENDS ) 975 976 if(NOT ARG_IGNORE_EXTERNALIZE_DEBUGINFO) 977 llvm_externalize_debuginfo(${name}) 978 endif() 979 if (LLVM_PTHREAD_LIB) 980 # libpthreads overrides some standard library symbols, so main 981 # executable must be linked with it in order to provide consistent 982 # API for all shared libaries loaded by this executable. 983 target_link_libraries(${name} PRIVATE ${LLVM_PTHREAD_LIB}) 984 endif() 985 986 llvm_codesign(${name} ENTITLEMENTS ${ARG_ENTITLEMENTS} BUNDLE_PATH ${ARG_BUNDLE_PATH}) 987endmacro(add_llvm_executable name) 988 989# add_llvm_pass_plugin(name [NO_MODULE] ...) 990# Add ${name} as an llvm plugin. 991# If option LLVM_${name_upper}_LINK_INTO_TOOLS is set to ON, the plugin is registered statically. 992# Otherwise a pluggable shared library is registered. 993# 994# If NO_MODULE is specified, when option LLVM_${name_upper}_LINK_INTO_TOOLS is set to OFF, 995# only an object library is built, and no module is built. This is specific to the Polly use case. 996# 997# The SUBPROJECT argument contains the LLVM project the plugin belongs 998# to. If set, the plugin will link statically by default it if the 999# project was enabled. 1000function(add_llvm_pass_plugin name) 1001 cmake_parse_arguments(ARG 1002 "NO_MODULE" "SUBPROJECT" "" 1003 ${ARGN}) 1004 1005 string(TOUPPER ${name} name_upper) 1006 1007 # Enable the plugin by default if it was explicitly enabled by the user. 1008 # Note: If was set to "all", LLVM's CMakeLists.txt replaces it with a 1009 # list of all projects, counting as explicitly enabled. 1010 set(link_into_tools_default OFF) 1011 if (ARG_SUBPROJECT AND LLVM_TOOL_${name_upper}_BUILD) 1012 set(link_into_tools_default ON) 1013 endif() 1014 option(LLVM_${name_upper}_LINK_INTO_TOOLS "Statically link ${name} into tools (if available)" ${link_into_tools_default}) 1015 1016 # If we statically link the plugin, don't use llvm dylib because we're going 1017 # to be part of it. 1018 if(LLVM_${name_upper}_LINK_INTO_TOOLS) 1019 list(APPEND ARG_UNPARSED_ARGUMENTS DISABLE_LLVM_LINK_LLVM_DYLIB) 1020 endif() 1021 1022 if(LLVM_${name_upper}_LINK_INTO_TOOLS) 1023 list(REMOVE_ITEM ARG_UNPARSED_ARGUMENTS BUILDTREE_ONLY) 1024 # process_llvm_pass_plugins takes care of the actual linking, just create an 1025 # object library as of now 1026 add_llvm_library(${name} OBJECT ${ARG_UNPARSED_ARGUMENTS}) 1027 target_compile_definitions(${name} PRIVATE LLVM_${name_upper}_LINK_INTO_TOOLS) 1028 set_property(TARGET ${name} APPEND PROPERTY COMPILE_DEFINITIONS LLVM_LINK_INTO_TOOLS) 1029 if (TARGET intrinsics_gen) 1030 add_dependencies(obj.${name} intrinsics_gen) 1031 endif() 1032 if (TARGET omp_gen) 1033 add_dependencies(obj.${name} omp_gen) 1034 endif() 1035 if (TARGET acc_gen) 1036 add_dependencies(obj.${name} acc_gen) 1037 endif() 1038 set_property(GLOBAL APPEND PROPERTY LLVM_STATIC_EXTENSIONS ${name}) 1039 elseif(NOT ARG_NO_MODULE) 1040 add_llvm_library(${name} MODULE ${ARG_UNPARSED_ARGUMENTS}) 1041 else() 1042 add_llvm_library(${name} OBJECT ${ARG_UNPARSED_ARGUMENTS}) 1043 endif() 1044 message(STATUS "Registering ${name} as a pass plugin (static build: ${LLVM_${name_upper}_LINK_INTO_TOOLS})") 1045 1046endfunction(add_llvm_pass_plugin) 1047 1048# process_llvm_pass_plugins([GEN_CONFIG]) 1049# 1050# Correctly set lib dependencies between plugins and tools, based on tools 1051# registered with the ENABLE_PLUGINS option. 1052# 1053# if GEN_CONFIG option is set, also generate X Macro file for extension 1054# handling. It provides a HANDLE_EXTENSION(extension_namespace, ExtensionProject) 1055# call for each extension allowing client code to define 1056# HANDLE_EXTENSION to have a specific code be run for each extension. 1057# 1058function(process_llvm_pass_plugins) 1059 cmake_parse_arguments(ARG 1060 "GEN_CONFIG" "" "" 1061 ${ARGN}) 1062 1063 if(ARG_GEN_CONFIG) 1064 get_property(LLVM_STATIC_EXTENSIONS GLOBAL PROPERTY LLVM_STATIC_EXTENSIONS) 1065 else() 1066 include(LLVMConfigExtensions) 1067 endif() 1068 1069 # Add static plugins to the Extension component 1070 foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS}) 1071 set_property(TARGET LLVMExtensions APPEND PROPERTY LINK_LIBRARIES ${llvm_extension}) 1072 set_property(TARGET LLVMExtensions APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${llvm_extension}) 1073 endforeach() 1074 1075 # Eventually generate the extension headers, and store config to a cmake file 1076 # for usage in third-party configuration. 1077 if(ARG_GEN_CONFIG) 1078 1079 ## Part 1: Extension header to be included whenever we need extension 1080 # processing. 1081 set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm) 1082 set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}") 1083 file(WRITE 1084 "${llvm_cmake_builddir}/LLVMConfigExtensions.cmake" 1085 "set(LLVM_STATIC_EXTENSIONS ${LLVM_STATIC_EXTENSIONS})") 1086 install(FILES 1087 ${llvm_cmake_builddir}/LLVMConfigExtensions.cmake 1088 DESTINATION ${LLVM_INSTALL_PACKAGE_DIR} 1089 COMPONENT cmake-exports) 1090 1091 set(ExtensionDef "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def") 1092 file(WRITE "${ExtensionDef}.tmp" "//extension handlers\n") 1093 foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS}) 1094 file(APPEND "${ExtensionDef}.tmp" "HANDLE_EXTENSION(${llvm_extension})\n") 1095 endforeach() 1096 file(APPEND "${ExtensionDef}.tmp" "#undef HANDLE_EXTENSION\n") 1097 1098 # only replace if there's an actual change 1099 execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different 1100 "${ExtensionDef}.tmp" 1101 "${ExtensionDef}") 1102 file(REMOVE "${ExtensionDef}.tmp") 1103 1104 ## Part 2: Extension header that captures each extension dependency, to be 1105 # used by llvm-config. 1106 set(ExtensionDeps "${LLVM_BINARY_DIR}/tools/llvm-config/ExtensionDependencies.inc") 1107 1108 # Max needed to correctly size the required library array. 1109 set(llvm_plugin_max_deps_length 0) 1110 foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS}) 1111 get_property(llvm_plugin_deps TARGET ${llvm_extension} PROPERTY LINK_LIBRARIES) 1112 list(LENGTH llvm_plugin_deps llvm_plugin_deps_length) 1113 if(llvm_plugin_deps_length GREATER llvm_plugin_max_deps_length) 1114 set(llvm_plugin_max_deps_length ${llvm_plugin_deps_length}) 1115 endif() 1116 endforeach() 1117 1118 list(LENGTH LLVM_STATIC_EXTENSIONS llvm_static_extension_count) 1119 file(WRITE 1120 "${ExtensionDeps}.tmp" 1121 "#include <array>\n\ 1122 struct ExtensionDescriptor {\n\ 1123 const char* Name;\n\ 1124 const char* RequiredLibraries[1 + 1 + ${llvm_plugin_max_deps_length}];\n\ 1125 };\n\ 1126 std::array<ExtensionDescriptor, ${llvm_static_extension_count}> AvailableExtensions{\n") 1127 1128 foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS}) 1129 get_property(llvm_plugin_deps TARGET ${llvm_extension} PROPERTY LINK_LIBRARIES) 1130 1131 file(APPEND "${ExtensionDeps}.tmp" "ExtensionDescriptor{\"${llvm_extension}\", {") 1132 foreach(llvm_plugin_dep ${llvm_plugin_deps}) 1133 # Turn library dependency back to component name, if possible. 1134 # That way llvm-config can avoid redundant dependencies. 1135 STRING(REGEX REPLACE "^-l" "" plugin_dep_name ${llvm_plugin_dep}) 1136 STRING(REGEX MATCH "^LLVM" is_llvm_library ${plugin_dep_name}) 1137 if(is_llvm_library) 1138 STRING(REGEX REPLACE "^LLVM" "" plugin_dep_name ${plugin_dep_name}) 1139 STRING(TOLOWER ${plugin_dep_name} plugin_dep_name) 1140 endif() 1141 file(APPEND "${ExtensionDeps}.tmp" "\"${plugin_dep_name}\", ") 1142 endforeach() 1143 1144 # Self + mandatory trailing null, because the number of RequiredLibraries differs between extensions. 1145 file(APPEND "${ExtensionDeps}.tmp" \"${llvm_extension}\", "nullptr}},\n") 1146 endforeach() 1147 file(APPEND "${ExtensionDeps}.tmp" "};\n") 1148 1149 # only replace if there's an actual change 1150 execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different 1151 "${ExtensionDeps}.tmp" 1152 "${ExtensionDeps}") 1153 file(REMOVE "${ExtensionDeps}.tmp") 1154 endif() 1155endfunction() 1156 1157function(export_executable_symbols target) 1158 if (LLVM_EXPORTED_SYMBOL_FILE) 1159 # The symbol file should contain the symbols we want the executable to 1160 # export 1161 set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1) 1162 elseif (LLVM_EXPORT_SYMBOLS_FOR_PLUGINS) 1163 # Extract the symbols to export from the static libraries that the 1164 # executable links against. 1165 set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1) 1166 set(exported_symbol_file ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${target}.symbols) 1167 # We need to consider not just the direct link dependencies, but also the 1168 # transitive link dependencies. Do this by starting with the set of direct 1169 # dependencies, then the dependencies of those dependencies, and so on. 1170 get_target_property(new_libs ${target} LINK_LIBRARIES) 1171 set(link_libs ${new_libs}) 1172 while(NOT "${new_libs}" STREQUAL "") 1173 foreach(lib ${new_libs}) 1174 if(TARGET ${lib}) 1175 get_target_property(lib_type ${lib} TYPE) 1176 if("${lib_type}" STREQUAL "STATIC_LIBRARY") 1177 list(APPEND static_libs ${lib}) 1178 else() 1179 list(APPEND other_libs ${lib}) 1180 endif() 1181 get_target_property(transitive_libs ${lib} INTERFACE_LINK_LIBRARIES) 1182 foreach(transitive_lib ${transitive_libs}) 1183 list(FIND link_libs ${transitive_lib} idx) 1184 if(TARGET ${transitive_lib} AND idx EQUAL -1) 1185 list(APPEND newer_libs ${transitive_lib}) 1186 list(APPEND link_libs ${transitive_lib}) 1187 endif() 1188 endforeach(transitive_lib) 1189 endif() 1190 endforeach(lib) 1191 set(new_libs ${newer_libs}) 1192 set(newer_libs "") 1193 endwhile() 1194 list(REMOVE_DUPLICATES static_libs) 1195 if (MSVC) 1196 set(mangling microsoft) 1197 else() 1198 set(mangling itanium) 1199 endif() 1200 add_custom_command(OUTPUT ${exported_symbol_file} 1201 COMMAND "${Python3_EXECUTABLE}" ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py ${LLVM_EXTRACT_SYMBOLS_FLAGS} --mangling=${mangling} ${static_libs} -o ${exported_symbol_file} 1202 WORKING_DIRECTORY ${LLVM_LIBRARY_OUTPUT_INTDIR} 1203 DEPENDS ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py ${static_libs} 1204 VERBATIM 1205 COMMENT "Generating export list for ${target}") 1206 add_llvm_symbol_exports( ${target} ${exported_symbol_file} ) 1207 # If something links against this executable then we want a 1208 # transitive link against only the libraries whose symbols 1209 # we aren't exporting. 1210 set_target_properties(${target} PROPERTIES INTERFACE_LINK_LIBRARIES "${other_libs}") 1211 # The default import library suffix that cmake uses for cygwin/mingw is 1212 # ".dll.a", but for clang.exe that causes a collision with libclang.dll, 1213 # where the import libraries of both get named libclang.dll.a. Use a suffix 1214 # of ".exe.a" to avoid this. 1215 if(CYGWIN OR MINGW) 1216 set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".exe.a") 1217 endif() 1218 elseif(NOT (WIN32 OR CYGWIN)) 1219 # On Windows auto-exporting everything doesn't work because of the limit on 1220 # the size of the exported symbol table, but on other platforms we can do 1221 # it without any trouble. 1222 set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1) 1223 if (APPLE) 1224 set_property(TARGET ${target} APPEND_STRING PROPERTY 1225 LINK_FLAGS " -rdynamic") 1226 endif() 1227 endif() 1228endfunction() 1229 1230# Export symbols if LLVM plugins are enabled. 1231function(export_executable_symbols_for_plugins target) 1232 if(LLVM_ENABLE_PLUGINS OR LLVM_EXPORT_SYMBOLS_FOR_PLUGINS) 1233 export_executable_symbols(${target}) 1234 endif() 1235endfunction() 1236 1237if(NOT LLVM_TOOLCHAIN_TOOLS) 1238 set (LLVM_TOOLCHAIN_TOOLS 1239 llvm-ar 1240 llvm-cov 1241 llvm-cxxfilt 1242 llvm-dwp 1243 llvm-ranlib 1244 llvm-lib 1245 llvm-ml 1246 llvm-nm 1247 llvm-objcopy 1248 llvm-objdump 1249 llvm-pdbutil 1250 llvm-rc 1251 llvm-readobj 1252 llvm-size 1253 llvm-strings 1254 llvm-strip 1255 llvm-profdata 1256 llvm-symbolizer 1257 # symlink version of some of above tools that are enabled by 1258 # LLVM_INSTALL_BINUTILS_SYMLINKS. 1259 addr2line 1260 ar 1261 c++filt 1262 ranlib 1263 nm 1264 objcopy 1265 objdump 1266 readelf 1267 size 1268 strings 1269 strip 1270 ) 1271endif() 1272 1273macro(add_llvm_tool name) 1274 if( NOT LLVM_BUILD_TOOLS ) 1275 set(EXCLUDE_FROM_ALL ON) 1276 endif() 1277 add_llvm_executable(${name} ${ARGN}) 1278 1279 if ( ${name} IN_LIST LLVM_TOOLCHAIN_TOOLS OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) 1280 if( LLVM_BUILD_TOOLS ) 1281 get_target_export_arg(${name} LLVM export_to_llvmexports) 1282 install(TARGETS ${name} 1283 ${export_to_llvmexports} 1284 RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR} 1285 COMPONENT ${name}) 1286 1287 if (NOT LLVM_ENABLE_IDE) 1288 add_llvm_install_targets(install-${name} 1289 DEPENDS ${name} 1290 COMPONENT ${name}) 1291 endif() 1292 endif() 1293 endif() 1294 if( LLVM_BUILD_TOOLS ) 1295 set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name}) 1296 endif() 1297 set_target_properties(${name} PROPERTIES FOLDER "Tools") 1298endmacro(add_llvm_tool name) 1299 1300 1301macro(add_llvm_example name) 1302 if( NOT LLVM_BUILD_EXAMPLES ) 1303 set(EXCLUDE_FROM_ALL ON) 1304 endif() 1305 add_llvm_executable(${name} ${ARGN}) 1306 if( LLVM_BUILD_EXAMPLES ) 1307 install(TARGETS ${name} RUNTIME DESTINATION "${LLVM_EXAMPLES_INSTALL_DIR}") 1308 endif() 1309 set_target_properties(${name} PROPERTIES FOLDER "Examples") 1310endmacro(add_llvm_example name) 1311 1312macro(add_llvm_example_library name) 1313 if( NOT LLVM_BUILD_EXAMPLES ) 1314 set(EXCLUDE_FROM_ALL ON) 1315 add_llvm_library(${name} BUILDTREE_ONLY ${ARGN}) 1316 else() 1317 add_llvm_library(${name} ${ARGN}) 1318 endif() 1319 1320 set_target_properties(${name} PROPERTIES FOLDER "Examples") 1321endmacro(add_llvm_example_library name) 1322 1323# This is a macro that is used to create targets for executables that are needed 1324# for development, but that are not intended to be installed by default. 1325macro(add_llvm_utility name) 1326 if ( NOT LLVM_BUILD_UTILS ) 1327 set(EXCLUDE_FROM_ALL ON) 1328 endif() 1329 1330 add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN}) 1331 set_target_properties(${name} PROPERTIES FOLDER "Utils") 1332 if ( ${name} IN_LIST LLVM_TOOLCHAIN_UTILITIES OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) 1333 if (LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS) 1334 get_target_export_arg(${name} LLVM export_to_llvmexports) 1335 install(TARGETS ${name} 1336 ${export_to_llvmexports} 1337 RUNTIME DESTINATION ${LLVM_UTILS_INSTALL_DIR} 1338 COMPONENT ${name}) 1339 1340 if (NOT LLVM_ENABLE_IDE) 1341 add_llvm_install_targets(install-${name} 1342 DEPENDS ${name} 1343 COMPONENT ${name}) 1344 endif() 1345 set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name}) 1346 elseif(LLVM_BUILD_UTILS) 1347 set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name}) 1348 endif() 1349 endif() 1350endmacro(add_llvm_utility name) 1351 1352macro(add_llvm_fuzzer name) 1353 cmake_parse_arguments(ARG "" "DUMMY_MAIN" "" ${ARGN}) 1354 if( LLVM_LIB_FUZZING_ENGINE ) 1355 set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN}) 1356 add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS}) 1357 target_link_libraries(${name} PRIVATE ${LLVM_LIB_FUZZING_ENGINE}) 1358 set_target_properties(${name} PROPERTIES FOLDER "Fuzzers") 1359 elseif( LLVM_USE_SANITIZE_COVERAGE ) 1360 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer") 1361 set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN}) 1362 add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS}) 1363 set_target_properties(${name} PROPERTIES FOLDER "Fuzzers") 1364 elseif( ARG_DUMMY_MAIN ) 1365 add_llvm_executable(${name} ${ARG_DUMMY_MAIN} ${ARG_UNPARSED_ARGUMENTS}) 1366 set_target_properties(${name} PROPERTIES FOLDER "Fuzzers") 1367 endif() 1368endmacro() 1369 1370macro(add_llvm_target target_name) 1371 include_directories(BEFORE 1372 ${CMAKE_CURRENT_BINARY_DIR} 1373 ${CMAKE_CURRENT_SOURCE_DIR}) 1374 add_llvm_component_library(LLVM${target_name} ${ARGN}) 1375 set( CURRENT_LLVM_TARGET LLVM${target_name} ) 1376endmacro(add_llvm_target) 1377 1378function(canonicalize_tool_name name output) 1379 string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" nameStrip ${name}) 1380 string(REPLACE "-" "_" nameUNDERSCORE ${nameStrip}) 1381 string(TOUPPER ${nameUNDERSCORE} nameUPPER) 1382 set(${output} "${nameUPPER}" PARENT_SCOPE) 1383endfunction(canonicalize_tool_name) 1384 1385# Custom add_subdirectory wrapper 1386# Takes in a project name (i.e. LLVM), the subdirectory name, and an optional 1387# path if it differs from the name. 1388function(add_llvm_subdirectory project type name) 1389 set(add_llvm_external_dir "${ARGN}") 1390 if("${add_llvm_external_dir}" STREQUAL "") 1391 set(add_llvm_external_dir ${name}) 1392 endif() 1393 canonicalize_tool_name(${name} nameUPPER) 1394 set(canonical_full_name ${project}_${type}_${nameUPPER}) 1395 get_property(already_processed GLOBAL PROPERTY ${canonical_full_name}_PROCESSED) 1396 if(already_processed) 1397 return() 1398 endif() 1399 set_property(GLOBAL PROPERTY ${canonical_full_name}_PROCESSED YES) 1400 1401 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}/CMakeLists.txt) 1402 # Treat it as in-tree subproject. 1403 option(${canonical_full_name}_BUILD 1404 "Whether to build ${name} as part of ${project}" On) 1405 mark_as_advanced(${project}_${type}_${name}_BUILD) 1406 if(${canonical_full_name}_BUILD) 1407 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir} ${add_llvm_external_dir}) 1408 endif() 1409 else() 1410 set(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR 1411 "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" 1412 CACHE PATH "Path to ${name} source directory") 1413 set(${canonical_full_name}_BUILD_DEFAULT ON) 1414 if(NOT LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR OR NOT EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}) 1415 set(${canonical_full_name}_BUILD_DEFAULT OFF) 1416 endif() 1417 if("${LLVM_EXTERNAL_${nameUPPER}_BUILD}" STREQUAL "OFF") 1418 set(${canonical_full_name}_BUILD_DEFAULT OFF) 1419 endif() 1420 option(${canonical_full_name}_BUILD 1421 "Whether to build ${name} as part of LLVM" 1422 ${${canonical_full_name}_BUILD_DEFAULT}) 1423 if (${canonical_full_name}_BUILD) 1424 if(EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}) 1425 add_subdirectory(${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR} ${add_llvm_external_dir}) 1426 elseif(NOT "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" STREQUAL "") 1427 message(WARNING "Nonexistent directory for ${name}: ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}") 1428 endif() 1429 endif() 1430 endif() 1431endfunction() 1432 1433# Add external project that may want to be built as part of llvm such as Clang, 1434# lld, and Polly. This adds two options. One for the source directory of the 1435# project, which defaults to ${CMAKE_CURRENT_SOURCE_DIR}/${name}. Another to 1436# enable or disable building it with everything else. 1437# Additional parameter can be specified as the name of directory. 1438macro(add_llvm_external_project name) 1439 add_llvm_subdirectory(LLVM TOOL ${name} ${ARGN}) 1440endmacro() 1441 1442macro(add_llvm_tool_subdirectory name) 1443 add_llvm_external_project(${name}) 1444endmacro(add_llvm_tool_subdirectory) 1445 1446function(get_project_name_from_src_var var output) 1447 string(REGEX MATCH "LLVM_EXTERNAL_(.*)_SOURCE_DIR" 1448 MACHED_TOOL "${var}") 1449 if(MACHED_TOOL) 1450 set(${output} ${CMAKE_MATCH_1} PARENT_SCOPE) 1451 else() 1452 set(${output} PARENT_SCOPE) 1453 endif() 1454endfunction() 1455 1456function(create_subdirectory_options project type) 1457 file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*") 1458 foreach(dir ${sub-dirs}) 1459 if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt") 1460 canonicalize_tool_name(${dir} name) 1461 option(${project}_${type}_${name}_BUILD 1462 "Whether to build ${name} as part of ${project}" On) 1463 mark_as_advanced(${project}_${type}_${name}_BUILD) 1464 endif() 1465 endforeach() 1466endfunction(create_subdirectory_options) 1467 1468function(create_llvm_tool_options) 1469 create_subdirectory_options(LLVM TOOL) 1470endfunction(create_llvm_tool_options) 1471 1472function(llvm_add_implicit_projects project) 1473 set(list_of_implicit_subdirs "") 1474 file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*") 1475 foreach(dir ${sub-dirs}) 1476 if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt") 1477 canonicalize_tool_name(${dir} name) 1478 # I don't like special casing things by order, but the llvm-driver ends up 1479 # linking the object libraries from all the tools that opt-in, so adding 1480 # it separately at the end is probably the simplest case. 1481 if("${name}" STREQUAL "LLVM_DRIVER") 1482 continue() 1483 endif() 1484 if (${project}_TOOL_${name}_BUILD) 1485 get_filename_component(fn "${dir}" NAME) 1486 list(APPEND list_of_implicit_subdirs "${fn}") 1487 endif() 1488 endif() 1489 endforeach() 1490 1491 foreach(external_proj ${list_of_implicit_subdirs}) 1492 add_llvm_subdirectory(${project} TOOL "${external_proj}" ${ARGN}) 1493 endforeach() 1494endfunction(llvm_add_implicit_projects) 1495 1496function(add_llvm_implicit_projects) 1497 llvm_add_implicit_projects(LLVM) 1498endfunction(add_llvm_implicit_projects) 1499 1500# Generic support for adding a unittest. 1501function(add_unittest test_suite test_name) 1502 if( NOT LLVM_BUILD_TESTS ) 1503 set(EXCLUDE_FROM_ALL ON) 1504 endif() 1505 1506 if (SUPPORTS_VARIADIC_MACROS_FLAG) 1507 list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros") 1508 endif () 1509 # Some parts of gtest rely on this GNU extension, don't warn on it. 1510 if(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG) 1511 list(APPEND LLVM_COMPILE_FLAGS "-Wno-gnu-zero-variadic-macro-arguments") 1512 endif() 1513 1514 if (NOT DEFINED LLVM_REQUIRES_RTTI) 1515 set(LLVM_REQUIRES_RTTI OFF) 1516 endif() 1517 1518 list(APPEND LLVM_LINK_COMPONENTS Support) # gtest needs it for raw_ostream 1519 add_llvm_executable(${test_name} IGNORE_EXTERNALIZE_DEBUGINFO NO_INSTALL_RPATH ${ARGN}) 1520 1521 # The runtime benefits of LTO don't outweight the compile time costs for tests. 1522 if(LLVM_ENABLE_LTO) 1523 if((UNIX OR MINGW) AND LINKER_IS_LLD) 1524 set_property(TARGET ${test_name} APPEND_STRING PROPERTY 1525 LINK_FLAGS " -Wl,--lto-O0") 1526 elseif(LINKER_IS_LLD_LINK) 1527 set_property(TARGET ${test_name} APPEND_STRING PROPERTY 1528 LINK_FLAGS " /opt:lldlto=0") 1529 elseif(APPLE AND NOT uppercase_LLVM_ENABLE_LTO STREQUAL "THIN") 1530 set_property(TARGET ${target_name} APPEND_STRING PROPERTY 1531 LINK_FLAGS " -Wl,-mllvm,-O0") 1532 endif() 1533 endif() 1534 1535 set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}) 1536 set_output_directory(${test_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir}) 1537 # libpthreads overrides some standard library symbols, so main 1538 # executable must be linked with it in order to provide consistent 1539 # API for all shared libaries loaded by this executable. 1540 target_link_libraries(${test_name} PRIVATE llvm_gtest_main llvm_gtest ${LLVM_PTHREAD_LIB}) 1541 1542 add_dependencies(${test_suite} ${test_name}) 1543 get_target_property(test_suite_folder ${test_suite} FOLDER) 1544 if (test_suite_folder) 1545 set_property(TARGET ${test_name} PROPERTY FOLDER "${test_suite_folder}") 1546 endif () 1547endfunction() 1548 1549# Use for test binaries that call llvm::getInputFileDirectory(). Use of this 1550# is discouraged. 1551function(add_unittest_with_input_files test_suite test_name) 1552 set(LLVM_UNITTEST_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) 1553 configure_file( 1554 ${LLVM_MAIN_SRC_DIR}/unittests/unittest.cfg.in 1555 ${CMAKE_CURRENT_BINARY_DIR}/llvm.srcdir.txt) 1556 1557 add_unittest(${test_suite} ${test_name} ${ARGN}) 1558endfunction() 1559 1560# Generic support for adding a benchmark. 1561function(add_benchmark benchmark_name) 1562 if( NOT LLVM_BUILD_BENCHMARKS ) 1563 set(EXCLUDE_FROM_ALL ON) 1564 endif() 1565 1566 add_llvm_executable(${benchmark_name} IGNORE_EXTERNALIZE_DEBUGINFO NO_INSTALL_RPATH ${ARGN}) 1567 set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}) 1568 set_output_directory(${benchmark_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir}) 1569 set_property(TARGET ${benchmark_name} PROPERTY FOLDER "Utils") 1570 target_link_libraries(${benchmark_name} PRIVATE benchmark) 1571endfunction() 1572 1573# This function canonicalize the CMake variables passed by names 1574# from CMake boolean to 0/1 suitable for passing into Python or C++, 1575# in place. 1576function(llvm_canonicalize_cmake_booleans) 1577 foreach(var ${ARGN}) 1578 if(${var}) 1579 set(${var} 1 PARENT_SCOPE) 1580 else() 1581 set(${var} 0 PARENT_SCOPE) 1582 endif() 1583 endforeach() 1584endfunction(llvm_canonicalize_cmake_booleans) 1585 1586macro(set_llvm_build_mode) 1587 # Configuration-time: See Unit/lit.site.cfg.in 1588 if (CMAKE_CFG_INTDIR STREQUAL ".") 1589 set(LLVM_BUILD_MODE ".") 1590 else () 1591 set(LLVM_BUILD_MODE "%(build_mode)s") 1592 endif () 1593endmacro() 1594 1595# Takes a list of path names in pathlist and a base directory, and returns 1596# a list of paths relative to the base directory in out_pathlist. 1597# Paths that are on a different drive than the basedir (on Windows) or that 1598# contain symlinks are returned absolute. 1599# Use with LLVM_LIT_PATH_FUNCTION below. 1600function(make_paths_relative out_pathlist basedir pathlist) 1601 # Passing ARG_PATH_VALUES as-is to execute_process() makes cmake strip 1602 # empty list entries. So escape the ;s in the list and do the splitting 1603 # ourselves. cmake has no relpath function, so use Python for that. 1604 string(REPLACE ";" "\\;" pathlist_escaped "${pathlist}") 1605 execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "\n 1606import os, sys\n 1607base = sys.argv[1] 1608def haslink(p):\n 1609 if not p or p == os.path.dirname(p): return False\n 1610 return os.path.islink(p) or haslink(os.path.dirname(p))\n 1611def relpath(p):\n 1612 if not p: return ''\n 1613 if os.path.splitdrive(p)[0] != os.path.splitdrive(base)[0]: return p\n 1614 if haslink(p) or haslink(base): return p\n 1615 return os.path.relpath(p, base)\n 1616if len(sys.argv) < 3: sys.exit(0)\n 1617sys.stdout.write(';'.join(relpath(p) for p in sys.argv[2].split(';')))" 1618 ${basedir} 1619 ${pathlist_escaped} 1620 OUTPUT_VARIABLE pathlist_relative 1621 ERROR_VARIABLE error 1622 RESULT_VARIABLE result) 1623 if (NOT result EQUAL 0) 1624 message(FATAL_ERROR "make_paths_relative() failed due to error '${result}', with stderr\n${error}") 1625 endif() 1626 set(${out_pathlist} "${pathlist_relative}" PARENT_SCOPE) 1627endfunction() 1628 1629# Converts a file that's relative to the current python file to an absolute 1630# path. Since this uses __file__, it has to be emitted into python files that 1631# use it and can't be in a lit module. Use with make_paths_relative(). 1632string(CONCAT LLVM_LIT_PATH_FUNCTION 1633 "# Allow generated file to be relocatable.\n" 1634 "from pathlib import Path\n" 1635 "def path(p):\n" 1636 " if not p: return ''\n" 1637 " return str((Path(__file__).parent / p).resolve())\n" 1638 ) 1639 1640# This function provides an automatic way to 'configure'-like generate a file 1641# based on a set of common and custom variables, specifically targeting the 1642# variables needed for the 'lit.site.cfg' files. This function bundles the 1643# common variables that any Lit instance is likely to need, and custom 1644# variables can be passed in. 1645# The keyword PATHS is followed by a list of cmake variable names that are 1646# mentioned as `path("@varname@")` in the lit.cfg.py.in file. Variables in that 1647# list are treated as paths that are relative to the directory the generated 1648# lit.cfg.py file is in, and the `path()` function converts the relative 1649# path back to absolute form. This makes it possible to move a build directory 1650# containing lit.cfg.py files from one machine to another. 1651function(configure_lit_site_cfg site_in site_out) 1652 cmake_parse_arguments(ARG "" "" "MAIN_CONFIG;PATHS" ${ARGN}) 1653 1654 if ("${ARG_MAIN_CONFIG}" STREQUAL "") 1655 get_filename_component(INPUT_DIR ${site_in} DIRECTORY) 1656 set(ARG_MAIN_CONFIG "${INPUT_DIR}/lit.cfg") 1657 endif() 1658 1659 foreach(c ${LLVM_TARGETS_TO_BUILD}) 1660 set(TARGETS_BUILT "${TARGETS_BUILT} ${c}") 1661 endforeach(c) 1662 set(TARGETS_TO_BUILD ${TARGETS_BUILT}) 1663 1664 set(SHLIBEXT "${LTDL_SHLIB_EXT}") 1665 1666 set_llvm_build_mode() 1667 1668 # For standalone builds of subprojects, these might not be the build tree but 1669 # a provided binary tree. 1670 set(LLVM_SOURCE_DIR ${LLVM_MAIN_SRC_DIR}) 1671 set(LLVM_BINARY_DIR ${LLVM_BINARY_DIR}) 1672 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLVM_TOOLS_DIR "${LLVM_TOOLS_BINARY_DIR}") 1673 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLVM_LIBS_DIR "${LLVM_LIBRARY_DIR}") 1674 # Like LLVM_{TOOLS,LIBS}_DIR, but pointing at the build tree. 1675 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" CURRENT_TOOLS_DIR "${LLVM_RUNTIME_OUTPUT_INTDIR}") 1676 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" CURRENT_LIBS_DIR "${LLVM_LIBRARY_OUTPUT_INTDIR}") 1677 string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" SHLIBDIR "${LLVM_SHLIB_OUTPUT_INTDIR}") 1678 1679 # FIXME: "ENABLE_SHARED" doesn't make sense, since it is used just for 1680 # plugins. We may rename it. 1681 if(LLVM_ENABLE_PLUGINS) 1682 set(ENABLE_SHARED "1") 1683 else() 1684 set(ENABLE_SHARED "0") 1685 endif() 1686 1687 if(LLVM_ENABLE_ASSERTIONS) 1688 set(ENABLE_ASSERTIONS "1") 1689 else() 1690 set(ENABLE_ASSERTIONS "0") 1691 endif() 1692 1693 set(HOST_OS ${CMAKE_SYSTEM_NAME}) 1694 set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR}) 1695 1696 set(HOST_CC "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}") 1697 set(HOST_CXX "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}") 1698 set(HOST_LDFLAGS "${CMAKE_EXE_LINKER_FLAGS}") 1699 1700 string(CONCAT LIT_SITE_CFG_IN_HEADER 1701 "# Autogenerated from ${site_in}\n# Do not edit!\n\n" 1702 "${LLVM_LIT_PATH_FUNCTION}" 1703 ) 1704 1705 # Override config_target_triple (and the env) 1706 if(LLVM_TARGET_TRIPLE_ENV) 1707 # This is expanded into the heading. 1708 string(CONCAT LIT_SITE_CFG_IN_HEADER "${LIT_SITE_CFG_IN_HEADER}" 1709 "import os\n" 1710 "target_env = \"${LLVM_TARGET_TRIPLE_ENV}\"\n" 1711 "config.target_triple = config.environment[target_env] = os.environ.get(target_env, \"${LLVM_TARGET_TRIPLE}\")\n" 1712 ) 1713 1714 # This is expanded to; config.target_triple = ""+config.target_triple+"" 1715 set(LLVM_TARGET_TRIPLE "\"+config.target_triple+\"") 1716 endif() 1717 1718 if (ARG_PATHS) 1719 # Walk ARG_PATHS and collect the current value of the variables in there. 1720 # list(APPEND) ignores empty elements exactly if the list is empty, 1721 # so start the list with a dummy element and drop it, to make sure that 1722 # even empty values make it into the values list. 1723 set(ARG_PATH_VALUES "dummy") 1724 foreach(path ${ARG_PATHS}) 1725 list(APPEND ARG_PATH_VALUES "${${path}}") 1726 endforeach() 1727 list(REMOVE_AT ARG_PATH_VALUES 0) 1728 1729 get_filename_component(OUTPUT_DIR ${site_out} DIRECTORY) 1730 make_paths_relative( 1731 ARG_PATH_VALUES_RELATIVE "${OUTPUT_DIR}" "${ARG_PATH_VALUES}") 1732 1733 list(LENGTH ARG_PATHS len_paths) 1734 list(LENGTH ARG_PATH_VALUES len_path_values) 1735 list(LENGTH ARG_PATH_VALUES_RELATIVE len_path_value_rels) 1736 if ((NOT ${len_paths} EQUAL ${len_path_values}) OR 1737 (NOT ${len_paths} EQUAL ${len_path_value_rels})) 1738 message(SEND_ERROR "PATHS lengths got confused") 1739 endif() 1740 1741 # Transform variables mentioned in ARG_PATHS to relative paths for 1742 # the configure_file() call. Variables are copied to subscopeds by cmake, 1743 # so this only modifies the local copy of the variables. 1744 math(EXPR arg_path_limit "${len_paths} - 1") 1745 foreach(i RANGE ${arg_path_limit}) 1746 list(GET ARG_PATHS ${i} val1) 1747 list(GET ARG_PATH_VALUES_RELATIVE ${i} val2) 1748 set(${val1} ${val2}) 1749 endforeach() 1750 endif() 1751 1752 configure_file(${site_in} ${site_out} @ONLY) 1753 1754 if (EXISTS "${ARG_MAIN_CONFIG}") 1755 # Remember main config / generated site config for llvm-lit.in. 1756 get_property(LLVM_LIT_CONFIG_FILES GLOBAL PROPERTY LLVM_LIT_CONFIG_FILES) 1757 list(APPEND LLVM_LIT_CONFIG_FILES "${ARG_MAIN_CONFIG}" "${site_out}") 1758 set_property(GLOBAL PROPERTY LLVM_LIT_CONFIG_FILES ${LLVM_LIT_CONFIG_FILES}) 1759 endif() 1760endfunction() 1761 1762function(dump_all_cmake_variables) 1763 get_cmake_property(_variableNames VARIABLES) 1764 foreach (_variableName ${_variableNames}) 1765 message(STATUS "${_variableName}=${${_variableName}}") 1766 endforeach() 1767endfunction() 1768 1769function(get_llvm_lit_path base_dir file_name) 1770 cmake_parse_arguments(ARG "ALLOW_EXTERNAL" "" "" ${ARGN}) 1771 1772 if (ARG_ALLOW_EXTERNAL) 1773 set (LLVM_EXTERNAL_LIT "" CACHE STRING "Command used to spawn lit") 1774 if ("${LLVM_EXTERNAL_LIT}" STREQUAL "") 1775 set(LLVM_EXTERNAL_LIT "${LLVM_DEFAULT_EXTERNAL_LIT}") 1776 endif() 1777 1778 if (NOT "${LLVM_EXTERNAL_LIT}" STREQUAL "") 1779 if (EXISTS ${LLVM_EXTERNAL_LIT}) 1780 get_filename_component(LIT_FILE_NAME ${LLVM_EXTERNAL_LIT} NAME) 1781 get_filename_component(LIT_BASE_DIR ${LLVM_EXTERNAL_LIT} DIRECTORY) 1782 set(${file_name} ${LIT_FILE_NAME} PARENT_SCOPE) 1783 set(${base_dir} ${LIT_BASE_DIR} PARENT_SCOPE) 1784 return() 1785 elseif (NOT DEFINED CACHE{LLVM_EXTERNAL_LIT_MISSING_WARNED_ONCE}) 1786 message(WARNING "LLVM_EXTERNAL_LIT set to ${LLVM_EXTERNAL_LIT}, but the path does not exist.") 1787 set(LLVM_EXTERNAL_LIT_MISSING_WARNED_ONCE YES CACHE INTERNAL "") 1788 endif() 1789 endif() 1790 endif() 1791 1792 set(lit_file_name "llvm-lit") 1793 if (CMAKE_HOST_WIN32 AND NOT CYGWIN) 1794 # llvm-lit needs suffix.py for multiprocess to find a main module. 1795 set(lit_file_name "${lit_file_name}.py") 1796 endif () 1797 set(${file_name} ${lit_file_name} PARENT_SCOPE) 1798 1799 get_property(LLVM_LIT_BASE_DIR GLOBAL PROPERTY LLVM_LIT_BASE_DIR) 1800 if (NOT "${LLVM_LIT_BASE_DIR}" STREQUAL "") 1801 set(${base_dir} ${LLVM_LIT_BASE_DIR} PARENT_SCOPE) 1802 endif() 1803 1804 # Allow individual projects to provide an override 1805 if (NOT "${LLVM_LIT_OUTPUT_DIR}" STREQUAL "") 1806 set(LLVM_LIT_BASE_DIR ${LLVM_LIT_OUTPUT_DIR}) 1807 elseif(NOT "${LLVM_RUNTIME_OUTPUT_INTDIR}" STREQUAL "") 1808 set(LLVM_LIT_BASE_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR}) 1809 else() 1810 set(LLVM_LIT_BASE_DIR "") 1811 endif() 1812 1813 # Cache this so we don't have to do it again and have subsequent calls 1814 # potentially disagree on the value. 1815 set_property(GLOBAL PROPERTY LLVM_LIT_BASE_DIR ${LLVM_LIT_BASE_DIR}) 1816 set(${base_dir} ${LLVM_LIT_BASE_DIR} PARENT_SCOPE) 1817endfunction() 1818 1819# A raw function to create a lit target. This is used to implement the testuite 1820# management functions. 1821function(add_lit_target target comment) 1822 cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN}) 1823 set(LIT_ARGS "${ARG_ARGS} ${LLVM_LIT_ARGS}") 1824 separate_arguments(LIT_ARGS) 1825 if (NOT CMAKE_CFG_INTDIR STREQUAL ".") 1826 list(APPEND LIT_ARGS --param build_mode=${CMAKE_CFG_INTDIR}) 1827 endif () 1828 1829 # Get the path to the lit to *run* tests with. This can be overriden by 1830 # the user by specifying -DLLVM_EXTERNAL_LIT=<path-to-lit.py> 1831 get_llvm_lit_path( 1832 lit_base_dir 1833 lit_file_name 1834 ALLOW_EXTERNAL 1835 ) 1836 1837 set(LIT_COMMAND "${Python3_EXECUTABLE};${lit_base_dir}/${lit_file_name}") 1838 list(APPEND LIT_COMMAND ${LIT_ARGS}) 1839 foreach(param ${ARG_PARAMS}) 1840 list(APPEND LIT_COMMAND --param ${param}) 1841 endforeach() 1842 if (ARG_UNPARSED_ARGUMENTS) 1843 add_custom_target(${target} 1844 COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS} 1845 COMMENT "${comment}" 1846 USES_TERMINAL 1847 ) 1848 else() 1849 add_custom_target(${target} 1850 COMMAND ${CMAKE_COMMAND} -E echo "${target} does nothing, no tools built.") 1851 message(STATUS "${target} does nothing.") 1852 endif() 1853 1854 if (ARG_DEPENDS) 1855 add_dependencies(${target} ${ARG_DEPENDS}) 1856 endif() 1857 1858 # Tests should be excluded from "Build Solution". 1859 set_target_properties(${target} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON) 1860endfunction() 1861 1862# Convert a target name like check-clang to a variable name like CLANG. 1863function(umbrella_lit_testsuite_var target outvar) 1864 if (NOT target MATCHES "^check-") 1865 message(FATAL_ERROR "umbrella lit suites must be check-*, not '${target}'") 1866 endif() 1867 string(SUBSTRING "${target}" 6 -1 var) 1868 string(REPLACE "-" "_" var ${var}) 1869 string(TOUPPER "${var}" var) 1870 set(${outvar} "${var}" PARENT_SCOPE) 1871endfunction() 1872 1873# Start recording all lit test suites for a combined 'check-foo' target. 1874# The recording continues until umbrella_lit_testsuite_end() creates the target. 1875function(umbrella_lit_testsuite_begin target) 1876 umbrella_lit_testsuite_var(${target} name) 1877 set_property(GLOBAL APPEND PROPERTY LLVM_LIT_UMBRELLAS ${name}) 1878endfunction() 1879 1880# Create a combined 'check-foo' target for a set of related test suites. 1881# It runs all suites added since the matching umbrella_lit_testsuite_end() call. 1882# Tests marked EXCLUDE_FROM_CHECK_ALL are not gathered. 1883function(umbrella_lit_testsuite_end target) 1884 umbrella_lit_testsuite_var(${target} name) 1885 1886 get_property(testsuites GLOBAL PROPERTY LLVM_${name}_LIT_TESTSUITES) 1887 get_property(params GLOBAL PROPERTY LLVM_${name}_LIT_PARAMS) 1888 get_property(depends GLOBAL PROPERTY LLVM_${name}_LIT_DEPENDS) 1889 get_property(extra_args GLOBAL PROPERTY LLVM_${name}_LIT_EXTRA_ARGS) 1890 # Additional test targets are not gathered, but may be set externally. 1891 get_property(additional_test_targets 1892 GLOBAL PROPERTY LLVM_${name}_ADDITIONAL_TEST_TARGETS) 1893 1894 string(TOLOWER ${name} name) 1895 add_lit_target(${target} 1896 "Running ${name} regression tests" 1897 ${testsuites} 1898 PARAMS ${params} 1899 DEPENDS ${depends} ${additional_test_targets} 1900 ARGS ${extra_args} 1901 ) 1902endfunction() 1903 1904# A function to add a set of lit test suites to be driven through 'check-*' targets. 1905function(add_lit_testsuite target comment) 1906 cmake_parse_arguments(ARG "EXCLUDE_FROM_CHECK_ALL" "" "PARAMS;DEPENDS;ARGS" ${ARGN}) 1907 1908 # EXCLUDE_FROM_ALL excludes the test ${target} out of check-all. 1909 if(NOT ARG_EXCLUDE_FROM_CHECK_ALL) 1910 get_property(gather_names GLOBAL PROPERTY LLVM_LIT_UMBRELLAS) 1911 foreach(name ${gather_names}) 1912 # Register the testsuites, params and depends for the umbrella check rule. 1913 set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_TESTSUITES ${ARG_UNPARSED_ARGUMENTS}) 1914 set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_PARAMS ${ARG_PARAMS}) 1915 set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_DEPENDS ${ARG_DEPENDS}) 1916 set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_EXTRA_ARGS ${ARG_ARGS}) 1917 endforeach() 1918 endif() 1919 1920 # Produce a specific suffixed check rule. 1921 add_lit_target(${target} ${comment} 1922 ${ARG_UNPARSED_ARGUMENTS} 1923 PARAMS ${ARG_PARAMS} 1924 DEPENDS ${ARG_DEPENDS} 1925 ARGS ${ARG_ARGS} 1926 ) 1927endfunction() 1928 1929function(add_lit_testsuites project directory) 1930 if (NOT LLVM_ENABLE_IDE) 1931 cmake_parse_arguments(ARG "EXCLUDE_FROM_CHECK_ALL" "FOLDER" "PARAMS;DEPENDS;ARGS" ${ARGN}) 1932 1933 if (NOT ARG_FOLDER) 1934 set(ARG_FOLDER "Test Subdirectories") 1935 endif() 1936 1937 # Search recursively for test directories by assuming anything not 1938 # in a directory called Inputs contains tests. 1939 file(GLOB_RECURSE to_process LIST_DIRECTORIES true ${directory}/*) 1940 foreach(lit_suite ${to_process}) 1941 if(NOT IS_DIRECTORY ${lit_suite}) 1942 continue() 1943 endif() 1944 string(FIND ${lit_suite} Inputs is_inputs) 1945 string(FIND ${lit_suite} Output is_output) 1946 if (NOT (is_inputs EQUAL -1 AND is_output EQUAL -1)) 1947 continue() 1948 endif() 1949 1950 # Create a check- target for the directory. 1951 string(REPLACE ${directory} "" name_slash ${lit_suite}) 1952 if (name_slash) 1953 string(REPLACE "/" "-" name_slash ${name_slash}) 1954 string(REPLACE "\\" "-" name_dashes ${name_slash}) 1955 string(TOLOWER "${project}${name_dashes}" name_var) 1956 add_lit_target("check-${name_var}" "Running lit suite ${lit_suite}" 1957 ${lit_suite} 1958 ${EXCLUDE_FROM_CHECK_ALL} 1959 PARAMS ${ARG_PARAMS} 1960 DEPENDS ${ARG_DEPENDS} 1961 ARGS ${ARG_ARGS} 1962 ) 1963 set_target_properties(check-${name_var} PROPERTIES FOLDER ${ARG_FOLDER}) 1964 endif() 1965 endforeach() 1966 endif() 1967endfunction() 1968 1969function(llvm_install_library_symlink name dest type) 1970 cmake_parse_arguments(ARG "" "COMPONENT" "" ${ARGN}) 1971 foreach(path ${CMAKE_MODULE_PATH}) 1972 if(EXISTS ${path}/LLVMInstallSymlink.cmake) 1973 set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake) 1974 break() 1975 endif() 1976 endforeach() 1977 1978 set(component ${ARG_COMPONENT}) 1979 if(NOT component) 1980 set(component ${name}) 1981 endif() 1982 1983 set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX}) 1984 set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX}) 1985 1986 set(output_dir lib${LLVM_LIBDIR_SUFFIX}) 1987 if(WIN32 AND "${type}" STREQUAL "SHARED") 1988 set(output_dir bin) 1989 endif() 1990 1991 install(SCRIPT ${INSTALL_SYMLINK} 1992 CODE "install_symlink(${full_name} ${full_dest} ${output_dir})" 1993 COMPONENT ${component}) 1994 1995endfunction() 1996 1997function(llvm_install_symlink name dest) 1998 cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN}) 1999 foreach(path ${CMAKE_MODULE_PATH}) 2000 if(EXISTS ${path}/LLVMInstallSymlink.cmake) 2001 set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake) 2002 break() 2003 endif() 2004 endforeach() 2005 2006 if(ARG_COMPONENT) 2007 set(component ${ARG_COMPONENT}) 2008 else() 2009 if(ARG_ALWAYS_GENERATE) 2010 set(component ${dest}) 2011 else() 2012 set(component ${name}) 2013 endif() 2014 endif() 2015 2016 set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX}) 2017 set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX}) 2018 2019 install(SCRIPT ${INSTALL_SYMLINK} 2020 CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})" 2021 COMPONENT ${component}) 2022 2023 if (NOT LLVM_ENABLE_IDE AND NOT ARG_ALWAYS_GENERATE) 2024 add_llvm_install_targets(install-${name} 2025 DEPENDS ${name} ${dest} 2026 COMPONENT ${name} 2027 SYMLINK ${dest}) 2028 endif() 2029endfunction() 2030 2031function(add_llvm_tool_symlink link_name target) 2032 cmake_parse_arguments(ARG "ALWAYS_GENERATE" "OUTPUT_DIR" "" ${ARGN}) 2033 2034 get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS) 2035 2036 if (${target} IN_LIST LLVM_DRIVER_TOOLS) 2037 string(REPLACE "-" "_" tool_entry ${target}) 2038 string(REPLACE "-" "_" key ${link_name}) 2039 string(REPLACE "llvm-" "" tool_name ${link_name}) 2040 set_property(GLOBAL APPEND_STRING PROPERTY 2041 LLVM_EXTRA_DRIVER_ENTRIES "LLVM_DRIVER_TOOL(\"${tool_name}\", ${tool_entry})\n") 2042 endif() 2043 set(dest_binary "$<TARGET_FILE:${target}>") 2044 2045 # This got a bit gross... For multi-configuration generators the target 2046 # properties return the resolved value of the string, not the build system 2047 # expression. To reconstruct the platform-agnostic path we have to do some 2048 # magic. First we grab one of the types, and a type-specific path. Then from 2049 # the type-specific path we find the last occurrence of the type in the path, 2050 # and replace it with CMAKE_CFG_INTDIR. This allows the build step to be type 2051 # agnostic again. 2052 if(NOT ARG_OUTPUT_DIR) 2053 # If you're not overriding the OUTPUT_DIR, we can make the link relative in 2054 # the same directory. 2055 if(CMAKE_HOST_UNIX) 2056 set(dest_binary "$<TARGET_FILE_NAME:${target}>") 2057 endif() 2058 if(CMAKE_CONFIGURATION_TYPES) 2059 list(GET CMAKE_CONFIGURATION_TYPES 0 first_type) 2060 string(TOUPPER ${first_type} first_type_upper) 2061 set(first_type_suffix _${first_type_upper}) 2062 endif() 2063 get_target_property(target_type ${target} TYPE) 2064 if(${target_type} STREQUAL "STATIC_LIBRARY") 2065 get_target_property(ARG_OUTPUT_DIR ${target} ARCHIVE_OUTPUT_DIRECTORY${first_type_suffix}) 2066 elseif(UNIX AND ${target_type} STREQUAL "SHARED_LIBRARY") 2067 get_target_property(ARG_OUTPUT_DIR ${target} LIBRARY_OUTPUT_DIRECTORY${first_type_suffix}) 2068 else() 2069 get_target_property(ARG_OUTPUT_DIR ${target} RUNTIME_OUTPUT_DIRECTORY${first_type_suffix}) 2070 endif() 2071 if(CMAKE_CONFIGURATION_TYPES) 2072 string(FIND "${ARG_OUTPUT_DIR}" "/${first_type}/" type_start REVERSE) 2073 string(SUBSTRING "${ARG_OUTPUT_DIR}" 0 ${type_start} path_prefix) 2074 string(SUBSTRING "${ARG_OUTPUT_DIR}" ${type_start} -1 path_suffix) 2075 string(REPLACE "/${first_type}/" "/${CMAKE_CFG_INTDIR}/" 2076 path_suffix ${path_suffix}) 2077 set(ARG_OUTPUT_DIR ${path_prefix}${path_suffix}) 2078 endif() 2079 endif() 2080 2081 if(CMAKE_HOST_UNIX) 2082 set(LLVM_LINK_OR_COPY create_symlink) 2083 else() 2084 set(LLVM_LINK_OR_COPY copy) 2085 endif() 2086 2087 set(output_path "${ARG_OUTPUT_DIR}/${link_name}${CMAKE_EXECUTABLE_SUFFIX}") 2088 2089 set(target_name ${link_name}) 2090 if(TARGET ${link_name}) 2091 set(target_name ${link_name}-link) 2092 endif() 2093 2094 2095 if(ARG_ALWAYS_GENERATE) 2096 set_property(DIRECTORY APPEND PROPERTY 2097 ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary}) 2098 add_custom_command(TARGET ${target} POST_BUILD 2099 COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}") 2100 else() 2101 add_custom_command(OUTPUT ${output_path} 2102 COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}" 2103 DEPENDS ${target}) 2104 add_custom_target(${target_name} ALL DEPENDS ${target} ${output_path}) 2105 set_target_properties(${target_name} PROPERTIES FOLDER Tools) 2106 2107 # Make sure both the link and target are toolchain tools 2108 if (${link_name} IN_LIST LLVM_TOOLCHAIN_TOOLS AND ${target} IN_LIST LLVM_TOOLCHAIN_TOOLS) 2109 set(TOOL_IS_TOOLCHAIN ON) 2110 endif() 2111 2112 if ((TOOL_IS_TOOLCHAIN OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) AND LLVM_BUILD_TOOLS) 2113 llvm_install_symlink(${link_name} ${target}) 2114 endif() 2115 endif() 2116endfunction() 2117 2118function(llvm_externalize_debuginfo name) 2119 if(NOT LLVM_EXTERNALIZE_DEBUGINFO) 2120 return() 2121 endif() 2122 2123 if(NOT LLVM_EXTERNALIZE_DEBUGINFO_SKIP_STRIP) 2124 if(APPLE) 2125 if(NOT CMAKE_STRIP) 2126 set(CMAKE_STRIP xcrun strip) 2127 endif() 2128 set(strip_command COMMAND ${CMAKE_STRIP} -S -x $<TARGET_FILE:${name}>) 2129 else() 2130 set(strip_command COMMAND ${CMAKE_STRIP} -g -x $<TARGET_FILE:${name}>) 2131 endif() 2132 endif() 2133 2134 if(APPLE) 2135 if(LLVM_EXTERNALIZE_DEBUGINFO_EXTENSION) 2136 set(file_ext ${LLVM_EXTERNALIZE_DEBUGINFO_EXTENSION}) 2137 else() 2138 set(file_ext dSYM) 2139 endif() 2140 2141 set(output_name "$<TARGET_FILE_NAME:${name}>.${file_ext}") 2142 2143 if(LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR) 2144 set(output_path "-o=${LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR}/${output_name}") 2145 else() 2146 set(output_path "-o=${output_name}") 2147 endif() 2148 2149 if(CMAKE_CXX_FLAGS MATCHES "-flto" 2150 OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto") 2151 2152 set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o) 2153 set_property(TARGET ${name} APPEND_STRING PROPERTY 2154 LINK_FLAGS " -Wl,-object_path_lto,${lto_object}") 2155 endif() 2156 if(NOT CMAKE_DSYMUTIL) 2157 set(CMAKE_DSYMUTIL xcrun dsymutil) 2158 endif() 2159 add_custom_command(TARGET ${name} POST_BUILD 2160 COMMAND ${CMAKE_DSYMUTIL} ${output_path} $<TARGET_FILE:${name}> 2161 ${strip_command} 2162 ) 2163 else() 2164 add_custom_command(TARGET ${name} POST_BUILD 2165 COMMAND ${CMAKE_OBJCOPY} --only-keep-debug $<TARGET_FILE:${name}> $<TARGET_FILE:${name}>.debug 2166 ${strip_command} -R .gnu_debuglink 2167 COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE:${name}>.debug $<TARGET_FILE:${name}> 2168 ) 2169 endif() 2170endfunction() 2171 2172# Usage: llvm_codesign(name [FORCE] [ENTITLEMENTS file] [BUNDLE_PATH path]) 2173function(llvm_codesign name) 2174 cmake_parse_arguments(ARG "FORCE" "ENTITLEMENTS;BUNDLE_PATH" "" ${ARGN}) 2175 2176 if(NOT LLVM_CODESIGNING_IDENTITY) 2177 return() 2178 endif() 2179 2180 if(CMAKE_GENERATOR STREQUAL "Xcode") 2181 set_target_properties(${name} PROPERTIES 2182 XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ${LLVM_CODESIGNING_IDENTITY} 2183 ) 2184 if(DEFINED ARG_ENTITLEMENTS) 2185 set_target_properties(${name} PROPERTIES 2186 XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS ${ARG_ENTITLEMENTS} 2187 ) 2188 endif() 2189 elseif(APPLE AND CMAKE_HOST_SYSTEM_NAME MATCHES Darwin) 2190 if(NOT CMAKE_CODESIGN) 2191 set(CMAKE_CODESIGN xcrun codesign) 2192 endif() 2193 if(NOT CMAKE_CODESIGN_ALLOCATE) 2194 execute_process( 2195 COMMAND xcrun -f codesign_allocate 2196 OUTPUT_STRIP_TRAILING_WHITESPACE 2197 OUTPUT_VARIABLE CMAKE_CODESIGN_ALLOCATE 2198 ) 2199 endif() 2200 if(DEFINED ARG_ENTITLEMENTS) 2201 set(pass_entitlements --entitlements ${ARG_ENTITLEMENTS}) 2202 endif() 2203 2204 if (NOT ARG_BUNDLE_PATH) 2205 set(ARG_BUNDLE_PATH $<TARGET_FILE:${name}>) 2206 endif() 2207 2208 # ld64 now always codesigns the binaries it creates. Apply the force arg 2209 # unconditionally so that we can - for example - add entitlements to the 2210 # targets that need it. 2211 set(force_flag "-f") 2212 2213 add_custom_command( 2214 TARGET ${name} POST_BUILD 2215 COMMAND ${CMAKE_COMMAND} -E 2216 env CODESIGN_ALLOCATE=${CMAKE_CODESIGN_ALLOCATE} 2217 ${CMAKE_CODESIGN} -s ${LLVM_CODESIGNING_IDENTITY} 2218 ${pass_entitlements} ${force_flag} ${ARG_BUNDLE_PATH} 2219 ) 2220 endif() 2221endfunction() 2222 2223function(llvm_setup_rpath name) 2224 if(CMAKE_INSTALL_RPATH) 2225 return() 2226 endif() 2227 2228 if(LLVM_INSTALL_PREFIX AND NOT (LLVM_INSTALL_PREFIX STREQUAL CMAKE_INSTALL_PREFIX)) 2229 set(extra_libdir ${LLVM_LIBRARY_DIR}) 2230 elseif(LLVM_BUILD_LIBRARY_DIR) 2231 set(extra_libdir ${LLVM_LIBRARY_DIR}) 2232 endif() 2233 2234 if (APPLE) 2235 set(_install_name_dir INSTALL_NAME_DIR "@rpath") 2236 set(_install_rpath "@loader_path/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir}) 2237 elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX" AND BUILD_SHARED_LIBS) 2238 # $ORIGIN is not interpreted at link time by aix ld. 2239 # Since BUILD_SHARED_LIBS is only recommended for use by developers, 2240 # hardcode the rpath to build/install lib dir first in this mode. 2241 # FIXME: update this when there is better solution. 2242 set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir}) 2243 elseif(UNIX) 2244 set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir}) 2245 if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)") 2246 set_property(TARGET ${name} APPEND_STRING PROPERTY 2247 LINK_FLAGS " -Wl,-z,origin ") 2248 endif() 2249 if(LLVM_LINKER_IS_GNULD) 2250 # $ORIGIN is not interpreted at link time by ld.bfd 2251 set_property(TARGET ${name} APPEND_STRING PROPERTY 2252 LINK_FLAGS " -Wl,-rpath-link,${LLVM_LIBRARY_OUTPUT_INTDIR} ") 2253 endif() 2254 else() 2255 return() 2256 endif() 2257 2258 # Enable BUILD_WITH_INSTALL_RPATH unless CMAKE_BUILD_RPATH is set. 2259 if("${CMAKE_BUILD_RPATH}" STREQUAL "") 2260 set_property(TARGET ${name} PROPERTY BUILD_WITH_INSTALL_RPATH ON) 2261 endif() 2262 2263 set_target_properties(${name} PROPERTIES 2264 INSTALL_RPATH "${_install_rpath}" 2265 ${_install_name_dir}) 2266endfunction() 2267 2268function(setup_dependency_debugging name) 2269 if(NOT LLVM_DEPENDENCY_DEBUGGING) 2270 return() 2271 endif() 2272 2273 if("intrinsics_gen" IN_LIST ARGN) 2274 return() 2275 endif() 2276 2277 set(deny_attributes_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Attributes.inc\"))") 2278 set(deny_intrinsics_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Intrinsics.inc\"))") 2279 2280 set(sandbox_command "sandbox-exec -p '(version 1) (allow default) ${deny_attributes_inc} ${deny_intrinsics_inc}'") 2281 set_target_properties(${name} PROPERTIES RULE_LAUNCH_COMPILE ${sandbox_command}) 2282endfunction() 2283 2284# If the sources at the given `path` are under version control, set `out_var` 2285# to the the path of a file which will be modified when the VCS revision 2286# changes, attempting to create that file if it does not exist; if no such 2287# file exists and one cannot be created, instead set `out_var` to the 2288# empty string. 2289# 2290# If the sources are not under version control, do not define `out_var`. 2291function(find_first_existing_vc_file path out_var) 2292 if(NOT EXISTS "${path}") 2293 return() 2294 endif() 2295 find_package(Git) 2296 if(GIT_FOUND) 2297 execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --git-dir 2298 WORKING_DIRECTORY ${path} 2299 RESULT_VARIABLE git_result 2300 OUTPUT_VARIABLE git_output 2301 ERROR_QUIET) 2302 if(git_result EQUAL 0) 2303 string(STRIP "${git_output}" git_output) 2304 get_filename_component(git_dir ${git_output} ABSOLUTE BASE_DIR ${path}) 2305 # Some branchless cases (e.g. 'repo') may not yet have .git/logs/HEAD 2306 if (NOT EXISTS "${git_dir}/logs/HEAD") 2307 execute_process(COMMAND ${CMAKE_COMMAND} -E touch HEAD 2308 WORKING_DIRECTORY "${git_dir}/logs" 2309 RESULT_VARIABLE touch_head_result 2310 ERROR_QUIET) 2311 if (NOT touch_head_result EQUAL 0) 2312 set(${out_var} "" PARENT_SCOPE) 2313 return() 2314 endif() 2315 endif() 2316 set(${out_var} "${git_dir}/logs/HEAD" PARENT_SCOPE) 2317 endif() 2318 endif() 2319endfunction() 2320