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