llvm/cmake/modules/AddLLVM.cmake

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