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