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