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