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