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