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