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