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