cmake/modules/AddLLVM.cmake

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