1include(GNUInstallDirs)
2include(LLVMDistributionSupport)
3include(LLVMProcessSources)
4include(LLVM-Config)
5include(DetermineGCCCompatible)
6
7function(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})
84endfunction()
85
86function(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)
183endfunction(add_llvm_symbol_exports)
184
185if (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()
254endif()
255
256function(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" AND LLVM_LINKER_IS_SOLARISLD)
286        # Support for ld -z discard-unused=sections was only added in
287        # Solaris 11.4.  GNU ld ignores it, but warns every time.
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()
311endfunction(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.
316function(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()
354endfunction()
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#
361function(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)
373endfunction(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#   )
387function(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}\"")
442endfunction(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#   )
477function(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  add_custom_linker_flags(${name})
730
731  if(ARG_SHARED OR ARG_MODULE)
732    llvm_externalize_debuginfo(${name})
733    llvm_codesign(${name} ENTITLEMENTS ${ARG_ENTITLEMENTS} BUNDLE_PATH ${ARG_BUNDLE_PATH})
734  endif()
735  # clang and newer versions of ninja use high-resolutions timestamps,
736  # but older versions of libtool on Darwin don't, so the archive will
737  # often get an older timestamp than the last object that was added
738  # or updated.  To fix this, we add a custom command to touch archive
739  # after it's been built so that ninja won't rebuild it unnecessarily
740  # the next time it's run.
741  if(ARG_STATIC AND LLVM_TOUCH_STATIC_LIBRARIES)
742    add_custom_command(TARGET ${name}
743      POST_BUILD
744      COMMAND touch ${LLVM_LIBRARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}
745      )
746  endif()
747endfunction()
748
749function(add_llvm_install_targets target)
750  cmake_parse_arguments(ARG "" "COMPONENT;PREFIX;SYMLINK" "DEPENDS" ${ARGN})
751  if(ARG_COMPONENT)
752    set(component_option -DCMAKE_INSTALL_COMPONENT="${ARG_COMPONENT}")
753  endif()
754  if(ARG_PREFIX)
755    set(prefix_option -DCMAKE_INSTALL_PREFIX="${ARG_PREFIX}")
756  endif()
757
758  set(file_dependencies)
759  set(target_dependencies)
760  foreach(dependency ${ARG_DEPENDS})
761    if(TARGET ${dependency})
762      list(APPEND target_dependencies ${dependency})
763    else()
764      list(APPEND file_dependencies ${dependency})
765    endif()
766  endforeach()
767
768  add_custom_target(${target}
769                    DEPENDS ${file_dependencies}
770                    COMMAND "${CMAKE_COMMAND}"
771                            ${component_option}
772                            ${prefix_option}
773                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
774                    USES_TERMINAL)
775  set_target_properties(${target} PROPERTIES FOLDER "Component Install Targets")
776  add_custom_target(${target}-stripped
777                    DEPENDS ${file_dependencies}
778                    COMMAND "${CMAKE_COMMAND}"
779                            ${component_option}
780                            ${prefix_option}
781                            -DCMAKE_INSTALL_DO_STRIP=1
782                            -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
783                    USES_TERMINAL)
784  set_target_properties(${target}-stripped PROPERTIES FOLDER "Component Install Targets (Stripped)")
785  if(target_dependencies)
786    add_dependencies(${target} ${target_dependencies})
787    add_dependencies(${target}-stripped ${target_dependencies})
788  endif()
789
790  if(ARG_SYMLINK)
791    add_dependencies(${target} install-${ARG_SYMLINK})
792    add_dependencies(${target}-stripped install-${ARG_SYMLINK}-stripped)
793  endif()
794endfunction()
795
796# Define special targets that behave like a component group. They don't have any
797# source attached but other components can add themselves to them. If the
798# component supports is a Target and it supports JIT compilation, HAS_JIT must
799# be passed. One can use ADD_TO_COMPONENT option from add_llvm_component_library
800# to link extra component into an existing group.
801function(add_llvm_component_group name)
802  cmake_parse_arguments(ARG "HAS_JIT" "" "LINK_COMPONENTS" ${ARGN})
803  add_custom_target(${name})
804  if(ARG_HAS_JIT)
805    set_property(TARGET ${name} PROPERTY COMPONENT_HAS_JIT ON)
806  endif()
807  if(ARG_LINK_COMPONENTS)
808    set_property(TARGET ${name} PROPERTY LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS})
809  endif()
810endfunction()
811
812# An LLVM component is a cmake target with the following cmake properties
813# eventually set:
814#   - LLVM_COMPONENT_NAME: the name of the component, which can be the name of
815#     the associated library or the one specified through COMPONENT_NAME
816#   - LLVM_LINK_COMPONENTS: a list of component this component depends on
817#   - COMPONENT_HAS_JIT: (only for group component) whether this target group
818#     supports JIT compilation
819# Additionnaly, the ADD_TO_COMPONENT <component> option make it possible to add this
820# component to the LLVM_LINK_COMPONENTS of <component>.
821function(add_llvm_component_library name)
822  cmake_parse_arguments(ARG
823    ""
824    "COMPONENT_NAME;ADD_TO_COMPONENT"
825    ""
826    ${ARGN})
827  add_llvm_library(${name} COMPONENT_LIB ${ARG_UNPARSED_ARGUMENTS})
828  string(REGEX REPLACE "^LLVM" "" component_name ${name})
829  set_property(TARGET ${name} PROPERTY LLVM_COMPONENT_NAME ${component_name})
830
831  if(ARG_COMPONENT_NAME)
832    set_property(GLOBAL PROPERTY LLVM_COMPONENT_NAME_${ARG_COMPONENT_NAME} ${component_name})
833  endif()
834
835  if(ARG_ADD_TO_COMPONENT)
836    set_property(TARGET ${ARG_ADD_TO_COMPONENT} APPEND PROPERTY LLVM_LINK_COMPONENTS ${component_name})
837  endif()
838
839endfunction()
840
841macro(add_llvm_library name)
842  cmake_parse_arguments(ARG
843    "SHARED;BUILDTREE_ONLY;MODULE;INSTALL_WITH_TOOLCHAIN"
844    ""
845    ""
846    ${ARGN})
847  if(ARG_MODULE)
848    llvm_add_library(${name} MODULE ${ARG_UNPARSED_ARGUMENTS})
849  elseif( BUILD_SHARED_LIBS OR ARG_SHARED )
850    llvm_add_library(${name} SHARED ${ARG_UNPARSED_ARGUMENTS})
851  else()
852    llvm_add_library(${name} ${ARG_UNPARSED_ARGUMENTS})
853  endif()
854
855  # Libraries that are meant to only be exposed via the build tree only are
856  # never installed and are only exported as a target in the special build tree
857  # config file.
858  if (NOT ARG_BUILDTREE_ONLY AND NOT ARG_MODULE)
859    set_property( GLOBAL APPEND PROPERTY LLVM_LIBS ${name} )
860    set(in_llvm_libs YES)
861  endif()
862
863  if (ARG_MODULE AND NOT TARGET ${name})
864    # Add empty "phony" target
865    add_custom_target(${name})
866  elseif( EXCLUDE_FROM_ALL )
867    set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
868  elseif(ARG_BUILDTREE_ONLY)
869    set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name})
870  else()
871    if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ARG_INSTALL_WITH_TOOLCHAIN)
872      if(in_llvm_libs)
873        set(umbrella UMBRELLA llvm-libraries)
874      else()
875        set(umbrella)
876      endif()
877
878      get_target_export_arg(${name} LLVM export_to_llvmexports ${umbrella})
879      install(TARGETS ${name}
880              ${export_to_llvmexports}
881              LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT ${name}
882              ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT ${name}
883              RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT ${name})
884
885      if (NOT LLVM_ENABLE_IDE)
886        add_llvm_install_targets(install-${name}
887                                 DEPENDS ${name}
888                                 COMPONENT ${name})
889      endif()
890    endif()
891    set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
892  endif()
893  if (ARG_MODULE)
894    set_target_properties(${name} PROPERTIES FOLDER "Loadable modules")
895  else()
896    set_target_properties(${name} PROPERTIES FOLDER "Libraries")
897  endif()
898endmacro(add_llvm_library name)
899
900macro(generate_llvm_objects name)
901  cmake_parse_arguments(ARG "GENERATE_DRIVER" "" "DEPENDS" ${ARGN})
902
903  llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} )
904
905  list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
906
907  # Generate objlib
908  if(LLVM_ENABLE_OBJLIB OR (ARG_GENERATE_DRIVER AND LLVM_TOOL_LLVM_DRIVER_BUILD))
909    # Generate an obj library for both targets.
910    set(obj_name "obj.${name}")
911    add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL
912      ${ALL_FILES}
913      )
914    llvm_update_compile_flags(${obj_name})
915    set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>")
916    if(ARG_DEPENDS)
917      add_dependencies(${obj_name} ${ARG_DEPENDS})
918    endif()
919
920    set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
921  endif()
922
923  if (ARG_GENERATE_DRIVER)
924    string(REPLACE "-" "_" TOOL_NAME ${name})
925    foreach(path ${CMAKE_MODULE_PATH})
926      if(EXISTS ${path}/llvm-driver-template.cpp.in)
927        configure_file(
928          ${path}/llvm-driver-template.cpp.in
929          ${CMAKE_CURRENT_BINARY_DIR}/${name}-driver.cpp)
930        break()
931      endif()
932    endforeach()
933
934    list(APPEND ALL_FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}-driver.cpp)
935
936    if (LLVM_TOOL_LLVM_DRIVER_BUILD
937        AND (NOT LLVM_DISTRIBUTION_COMPONENTS OR ${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS)
938       )
939      set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_COMPONENTS ${LLVM_LINK_COMPONENTS})
940      set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_DEPS ${ARG_DEPENDS} ${LLVM_COMMON_DEPENDS})
941      set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_OBJLIBS "${obj_name}")
942
943      set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_TOOLS ${name})
944      set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_TOOL_ALIASES_${name} ${name})
945      target_link_libraries(${obj_name} ${LLVM_PTHREAD_LIB})
946      llvm_config(${obj_name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} )
947    endif()
948  endif()
949endmacro()
950
951macro(add_llvm_executable name)
952  cmake_parse_arguments(ARG
953    "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO;NO_INSTALL_RPATH;SUPPORT_PLUGINS"
954    "ENTITLEMENTS;BUNDLE_PATH"
955    ""
956    ${ARGN})
957  generate_llvm_objects(${name} ${ARG_UNPARSED_ARGUMENTS})
958  add_windows_version_resource_file(ALL_FILES ${ALL_FILES})
959
960  if(XCODE)
961    # Note: the dummy.cpp source file provides no definitions. However,
962    # it forces Xcode to properly link the static library.
963    list(APPEND ALL_FILES "${LLVM_MAIN_SRC_DIR}/cmake/dummy.cpp")
964  endif()
965
966  if( EXCLUDE_FROM_ALL )
967    add_executable(${name} EXCLUDE_FROM_ALL ${ALL_FILES})
968  else()
969    add_executable(${name} ${ALL_FILES})
970  endif()
971
972  setup_dependency_debugging(${name} ${LLVM_COMMON_DEPENDS})
973
974  if(NOT ARG_NO_INSTALL_RPATH)
975    llvm_setup_rpath(${name})
976  elseif(NOT "${LLVM_LOCAL_RPATH}" STREQUAL "")
977    # Enable BUILD_WITH_INSTALL_RPATH unless CMAKE_BUILD_RPATH is set.
978    if("${CMAKE_BUILD_RPATH}" STREQUAL "")
979      set_property(TARGET ${name} PROPERTY BUILD_WITH_INSTALL_RPATH ON)
980    endif()
981
982    set_property(TARGET ${name} PROPERTY INSTALL_RPATH "${LLVM_LOCAL_RPATH}")
983  endif()
984
985  if(DEFINED windows_resource_file)
986    set_windows_version_resource_properties(${name} ${windows_resource_file})
987  endif()
988
989  # $<TARGET_OBJECTS> doesn't require compile flags.
990  if(NOT LLVM_ENABLE_OBJLIB)
991    llvm_update_compile_flags(${name})
992  endif()
993
994  if (ARG_SUPPORT_PLUGINS AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "AIX")
995    set(LLVM_NO_DEAD_STRIP On)
996  endif()
997
998  add_link_opts( ${name} )
999
1000  # Do not add -Dname_EXPORTS to the command-line when building files in this
1001  # target. Doing so is actively harmful for the modules build because it
1002  # creates extra module variants, and not useful because we don't use these
1003  # macros.
1004  set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" )
1005
1006  if (LLVM_EXPORTED_SYMBOL_FILE)
1007    add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} )
1008  endif(LLVM_EXPORTED_SYMBOL_FILE)
1009
1010  if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
1011    set(USE_SHARED USE_SHARED)
1012  endif()
1013
1014  set(EXCLUDE_FROM_ALL OFF)
1015  set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
1016  llvm_config( ${name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} )
1017  if( LLVM_COMMON_DEPENDS )
1018    add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} )
1019    foreach(objlib ${obj_name})
1020      add_dependencies(${objlib} ${LLVM_COMMON_DEPENDS})
1021    endforeach()
1022  endif( LLVM_COMMON_DEPENDS )
1023
1024  add_custom_linker_flags(${name})
1025
1026  if(NOT ARG_IGNORE_EXTERNALIZE_DEBUGINFO)
1027    llvm_externalize_debuginfo(${name})
1028  endif()
1029  if (LLVM_PTHREAD_LIB)
1030    # libpthreads overrides some standard library symbols, so main
1031    # executable must be linked with it in order to provide consistent
1032    # API for all shared libaries loaded by this executable.
1033    target_link_libraries(${name} PRIVATE ${LLVM_PTHREAD_LIB})
1034  endif()
1035
1036  if(HAVE_LLVM_LIBC)
1037    target_link_libraries(${name} PRIVATE llvmlibc)
1038  endif()
1039
1040  llvm_codesign(${name} ENTITLEMENTS ${ARG_ENTITLEMENTS} BUNDLE_PATH ${ARG_BUNDLE_PATH})
1041endmacro(add_llvm_executable name)
1042
1043# add_llvm_pass_plugin(name [NO_MODULE] ...)
1044#   Add ${name} as an llvm plugin.
1045#   If option LLVM_${name_upper}_LINK_INTO_TOOLS is set to ON, the plugin is registered statically.
1046#   Otherwise a pluggable shared library is registered.
1047#
1048#   If NO_MODULE is specified, when option LLVM_${name_upper}_LINK_INTO_TOOLS is set to OFF,
1049#   only an object library is built, and no module is built. This is specific to the Polly use case.
1050#
1051#   The SUBPROJECT argument contains the LLVM project the plugin belongs
1052#   to. If set, the plugin will link statically by default it if the
1053#   project was enabled.
1054function(add_llvm_pass_plugin name)
1055  cmake_parse_arguments(ARG
1056    "NO_MODULE" "SUBPROJECT" ""
1057    ${ARGN})
1058
1059  string(TOUPPER ${name} name_upper)
1060
1061  # Enable the plugin by default if it was explicitly enabled by the user.
1062  # Note: If was set to "all", LLVM's CMakeLists.txt replaces it with a
1063  # list of all projects, counting as explicitly enabled.
1064  set(link_into_tools_default OFF)
1065  if (ARG_SUBPROJECT AND LLVM_TOOL_${name_upper}_BUILD)
1066    set(link_into_tools_default ON)
1067  endif()
1068  option(LLVM_${name_upper}_LINK_INTO_TOOLS "Statically link ${name} into tools (if available)" ${link_into_tools_default})
1069
1070  # If we statically link the plugin, don't use llvm dylib because we're going
1071  # to be part of it.
1072  if(LLVM_${name_upper}_LINK_INTO_TOOLS)
1073      list(APPEND ARG_UNPARSED_ARGUMENTS DISABLE_LLVM_LINK_LLVM_DYLIB)
1074  endif()
1075
1076  if(LLVM_${name_upper}_LINK_INTO_TOOLS)
1077    list(REMOVE_ITEM ARG_UNPARSED_ARGUMENTS BUILDTREE_ONLY)
1078    # process_llvm_pass_plugins takes care of the actual linking, just create an
1079    # object library as of now
1080    add_llvm_library(${name} OBJECT ${ARG_UNPARSED_ARGUMENTS})
1081    target_compile_definitions(${name} PRIVATE LLVM_${name_upper}_LINK_INTO_TOOLS)
1082    set_property(TARGET ${name} APPEND PROPERTY COMPILE_DEFINITIONS LLVM_LINK_INTO_TOOLS)
1083    if (TARGET intrinsics_gen)
1084      add_dependencies(obj.${name} intrinsics_gen)
1085    endif()
1086    if (TARGET omp_gen)
1087      add_dependencies(obj.${name} omp_gen)
1088    endif()
1089    if (TARGET acc_gen)
1090      add_dependencies(obj.${name} acc_gen)
1091    endif()
1092    set_property(GLOBAL APPEND PROPERTY LLVM_STATIC_EXTENSIONS ${name})
1093  elseif(NOT ARG_NO_MODULE)
1094    add_llvm_library(${name} MODULE ${ARG_UNPARSED_ARGUMENTS})
1095  else()
1096    add_llvm_library(${name} OBJECT ${ARG_UNPARSED_ARGUMENTS})
1097  endif()
1098  message(STATUS "Registering ${name} as a pass plugin (static build: ${LLVM_${name_upper}_LINK_INTO_TOOLS})")
1099
1100endfunction(add_llvm_pass_plugin)
1101
1102# process_llvm_pass_plugins([GEN_CONFIG])
1103#
1104# Correctly set lib dependencies between plugins and tools, based on tools
1105# registered with the ENABLE_PLUGINS option.
1106#
1107# if GEN_CONFIG option is set, also generate X Macro file for extension
1108# handling. It provides a HANDLE_EXTENSION(extension_namespace, ExtensionProject)
1109# call for each extension allowing client code to define
1110# HANDLE_EXTENSION to have a specific code be run for each extension.
1111#
1112function(process_llvm_pass_plugins)
1113  cmake_parse_arguments(ARG
1114      "GEN_CONFIG" "" ""
1115    ${ARGN})
1116
1117  if(ARG_GEN_CONFIG)
1118      get_property(LLVM_STATIC_EXTENSIONS GLOBAL PROPERTY LLVM_STATIC_EXTENSIONS)
1119  else()
1120      include(LLVMConfigExtensions)
1121  endif()
1122
1123  # Add static plugins to the Extension component
1124  foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
1125      set_property(TARGET LLVMExtensions APPEND PROPERTY LINK_LIBRARIES ${llvm_extension})
1126      set_property(TARGET LLVMExtensions APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${llvm_extension})
1127  endforeach()
1128
1129  # Eventually generate the extension headers, and store config to a cmake file
1130  # for usage in third-party configuration.
1131  if(ARG_GEN_CONFIG)
1132
1133      ## Part 1: Extension header to be included whenever we need extension
1134      #  processing.
1135      if(NOT DEFINED LLVM_INSTALL_PACKAGE_DIR)
1136          message(FATAL_ERROR "LLVM_INSTALL_PACKAGE_DIR must be defined and writable. GEN_CONFIG should only be passe when building LLVM proper.")
1137      endif()
1138      # LLVM_INSTALL_PACKAGE_DIR might be absolute, so don't reuse below.
1139      string(REPLACE "${CMAKE_CFG_INTDIR}" "." llvm_cmake_builddir "${LLVM_LIBRARY_DIR}")
1140      set(llvm_cmake_builddir "${llvm_cmake_builddir}/cmake/llvm")
1141      file(WRITE
1142          "${llvm_cmake_builddir}/LLVMConfigExtensions.cmake"
1143          "set(LLVM_STATIC_EXTENSIONS ${LLVM_STATIC_EXTENSIONS})")
1144      install(FILES
1145          ${llvm_cmake_builddir}/LLVMConfigExtensions.cmake
1146          DESTINATION ${LLVM_INSTALL_PACKAGE_DIR}
1147          COMPONENT cmake-exports)
1148
1149      set(ExtensionDef "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def")
1150      file(WRITE "${ExtensionDef}.tmp" "//extension handlers\n")
1151      foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
1152          file(APPEND "${ExtensionDef}.tmp" "HANDLE_EXTENSION(${llvm_extension})\n")
1153      endforeach()
1154      file(APPEND "${ExtensionDef}.tmp" "#undef HANDLE_EXTENSION\n")
1155
1156      # only replace if there's an actual change
1157      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
1158          "${ExtensionDef}.tmp"
1159          "${ExtensionDef}")
1160      file(REMOVE "${ExtensionDef}.tmp")
1161
1162      ## Part 2: Extension header that captures each extension dependency, to be
1163      #  used by llvm-config.
1164      set(ExtensionDeps "${LLVM_BINARY_DIR}/tools/llvm-config/ExtensionDependencies.inc")
1165
1166      # Max needed to correctly size the required library array.
1167      set(llvm_plugin_max_deps_length 0)
1168      foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
1169        get_property(llvm_plugin_deps TARGET ${llvm_extension} PROPERTY LINK_LIBRARIES)
1170        list(LENGTH llvm_plugin_deps llvm_plugin_deps_length)
1171        if(llvm_plugin_deps_length GREATER llvm_plugin_max_deps_length)
1172            set(llvm_plugin_max_deps_length ${llvm_plugin_deps_length})
1173        endif()
1174      endforeach()
1175
1176      list(LENGTH LLVM_STATIC_EXTENSIONS llvm_static_extension_count)
1177      file(WRITE
1178          "${ExtensionDeps}.tmp"
1179          "#include <array>\n\
1180           struct ExtensionDescriptor {\n\
1181              const char* Name;\n\
1182              const char* RequiredLibraries[1 + 1 + ${llvm_plugin_max_deps_length}];\n\
1183           };\n\
1184           std::array<ExtensionDescriptor, ${llvm_static_extension_count}> AvailableExtensions{\n")
1185
1186      foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
1187        get_property(llvm_plugin_deps TARGET ${llvm_extension} PROPERTY LINK_LIBRARIES)
1188
1189        file(APPEND "${ExtensionDeps}.tmp" "ExtensionDescriptor{\"${llvm_extension}\", {")
1190        foreach(llvm_plugin_dep ${llvm_plugin_deps})
1191            # Turn library dependency back to component name, if possible.
1192            # That way llvm-config can avoid redundant dependencies.
1193            STRING(REGEX REPLACE "^-l" ""  plugin_dep_name ${llvm_plugin_dep})
1194            STRING(REGEX MATCH "^LLVM" is_llvm_library ${plugin_dep_name})
1195            if(is_llvm_library)
1196                STRING(REGEX REPLACE "^LLVM" ""  plugin_dep_name ${plugin_dep_name})
1197                STRING(TOLOWER ${plugin_dep_name} plugin_dep_name)
1198            endif()
1199            file(APPEND "${ExtensionDeps}.tmp" "\"${plugin_dep_name}\", ")
1200        endforeach()
1201
1202        # Self + mandatory trailing null, because the number of RequiredLibraries differs between extensions.
1203        file(APPEND "${ExtensionDeps}.tmp" \"${llvm_extension}\", "nullptr}},\n")
1204      endforeach()
1205      file(APPEND "${ExtensionDeps}.tmp" "};\n")
1206
1207      # only replace if there's an actual change
1208      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
1209          "${ExtensionDeps}.tmp"
1210          "${ExtensionDeps}")
1211      file(REMOVE "${ExtensionDeps}.tmp")
1212  endif()
1213endfunction()
1214
1215function(export_executable_symbols target)
1216  if (LLVM_EXPORTED_SYMBOL_FILE)
1217    # The symbol file should contain the symbols we want the executable to
1218    # export
1219    set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
1220  elseif (LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
1221    # Extract the symbols to export from the static libraries that the
1222    # executable links against.
1223    set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
1224    set(exported_symbol_file ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${target}.symbols)
1225    # We need to consider not just the direct link dependencies, but also the
1226    # transitive link dependencies. Do this by starting with the set of direct
1227    # dependencies, then the dependencies of those dependencies, and so on.
1228    get_target_property(new_libs ${target} LINK_LIBRARIES)
1229    set(link_libs ${new_libs})
1230    while(NOT "${new_libs}" STREQUAL "")
1231      foreach(lib ${new_libs})
1232        if(TARGET ${lib})
1233          get_target_property(lib_type ${lib} TYPE)
1234          if("${lib_type}" STREQUAL "STATIC_LIBRARY")
1235            list(APPEND static_libs ${lib})
1236          else()
1237            list(APPEND other_libs ${lib})
1238          endif()
1239          get_target_property(transitive_libs ${lib} INTERFACE_LINK_LIBRARIES)
1240          foreach(transitive_lib ${transitive_libs})
1241            if(TARGET ${transitive_lib} AND NOT ${transitive_lib} IN_LIST link_libs)
1242              list(APPEND newer_libs ${transitive_lib})
1243              list(APPEND link_libs ${transitive_lib})
1244            endif()
1245          endforeach(transitive_lib)
1246        endif()
1247      endforeach(lib)
1248      set(new_libs ${newer_libs})
1249      set(newer_libs "")
1250    endwhile()
1251    list(REMOVE_DUPLICATES static_libs)
1252    if (MSVC)
1253      set(mangling microsoft)
1254    else()
1255      set(mangling itanium)
1256    endif()
1257    get_host_tool_path(llvm-nm LLVM_NM llvm_nm_exe llvm_nm_target)
1258    get_host_tool_path(llvm-readobj LLVM_READOBJ llvm_readobj_exe llvm_readobj_target)
1259    add_custom_command(OUTPUT ${exported_symbol_file}
1260                       COMMAND "${Python3_EXECUTABLE}"
1261                         ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py
1262                         --mangling=${mangling} ${static_libs}
1263                         -o ${exported_symbol_file}
1264                         --nm=${llvm_nm_exe}
1265                         --readobj=${llvm_readobj_exe}
1266                       WORKING_DIRECTORY ${LLVM_LIBRARY_OUTPUT_INTDIR}
1267                       DEPENDS ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py
1268                         ${static_libs} ${llvm_nm_target} ${llvm_readobj_target}
1269                       VERBATIM
1270                       COMMENT "Generating export list for ${target}")
1271    add_llvm_symbol_exports( ${target} ${exported_symbol_file} )
1272    # If something links against this executable then we want a
1273    # transitive link against only the libraries whose symbols
1274    # we aren't exporting.
1275    set_target_properties(${target} PROPERTIES INTERFACE_LINK_LIBRARIES "${other_libs}")
1276    # The default import library suffix that cmake uses for cygwin/mingw is
1277    # ".dll.a", but for clang.exe that causes a collision with libclang.dll,
1278    # where the import libraries of both get named libclang.dll.a. Use a suffix
1279    # of ".exe.a" to avoid this.
1280    if(CYGWIN OR MINGW)
1281      set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".exe.a")
1282    endif()
1283  elseif(NOT (WIN32 OR CYGWIN))
1284    # On Windows auto-exporting everything doesn't work because of the limit on
1285    # the size of the exported symbol table, but on other platforms we can do
1286    # it without any trouble.
1287    set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
1288    # CMake doesn't set CMAKE_EXE_EXPORTS_${lang}_FLAG on Solaris, so
1289    # ENABLE_EXPORTS has no effect.  While Solaris ld defaults to -rdynamic
1290    # behaviour, GNU ld needs it.
1291    if (APPLE OR ${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
1292      set_property(TARGET ${target} APPEND_STRING PROPERTY
1293        LINK_FLAGS " -rdynamic")
1294    endif()
1295  endif()
1296endfunction()
1297
1298# Export symbols if LLVM plugins are enabled.
1299function(export_executable_symbols_for_plugins target)
1300  if(LLVM_ENABLE_PLUGINS OR LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
1301    export_executable_symbols(${target})
1302  endif()
1303endfunction()
1304
1305if(NOT LLVM_TOOLCHAIN_TOOLS)
1306  set (LLVM_TOOLCHAIN_TOOLS
1307    llvm-ar
1308    llvm-cov
1309    llvm-cxxfilt
1310    llvm-dlltool
1311    llvm-dwp
1312    llvm-ranlib
1313    llvm-lib
1314    llvm-mca
1315    llvm-ml
1316    llvm-nm
1317    llvm-objcopy
1318    llvm-objdump
1319    llvm-pdbutil
1320    llvm-rc
1321    llvm-readobj
1322    llvm-size
1323    llvm-strings
1324    llvm-strip
1325    llvm-profdata
1326    llvm-symbolizer
1327    # symlink version of some of above tools that are enabled by
1328    # LLVM_INSTALL_BINUTILS_SYMLINKS.
1329    addr2line
1330    ar
1331    c++filt
1332    ranlib
1333    nm
1334    objcopy
1335    objdump
1336    readelf
1337    size
1338    strings
1339    strip
1340    )
1341  # Build llvm-mt if libxml2 is enabled. Can be used by runtimes.
1342  if (LLVM_ENABLE_LIBXML2)
1343    list(APPEND LLVM_TOOLCHAIN_TOOLS llvm-mt)
1344  endif()
1345endif()
1346
1347macro(llvm_add_tool project name)
1348  cmake_parse_arguments(ARG "DEPENDS;GENERATE_DRIVER" "" "" ${ARGN})
1349  if( NOT LLVM_BUILD_TOOLS )
1350    set(EXCLUDE_FROM_ALL ON)
1351  endif()
1352  if(ARG_GENERATE_DRIVER
1353     AND LLVM_TOOL_LLVM_DRIVER_BUILD
1354     AND (NOT LLVM_DISTRIBUTION_COMPONENTS OR ${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS)
1355    )
1356    generate_llvm_objects(${name} ${ARGN})
1357    add_custom_target(${name} DEPENDS llvm-driver)
1358  else()
1359    add_llvm_executable(${name} ${ARGN})
1360
1361    if ( ${name} IN_LIST LLVM_TOOLCHAIN_TOOLS OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
1362      if( LLVM_BUILD_TOOLS )
1363        get_target_export_arg(${name} LLVM export_to_llvmexports)
1364        install(TARGETS ${name}
1365                ${export_to_llvmexports}
1366                RUNTIME DESTINATION ${${project}_TOOLS_INSTALL_DIR}
1367                COMPONENT ${name})
1368
1369        if (NOT LLVM_ENABLE_IDE)
1370          add_llvm_install_targets(install-${name}
1371                                  DEPENDS ${name}
1372                                  COMPONENT ${name})
1373        endif()
1374      endif()
1375    endif()
1376    if( LLVM_BUILD_TOOLS )
1377      set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
1378    endif()
1379    set_target_properties(${name} PROPERTIES FOLDER "Tools")
1380  endif()
1381endmacro(llvm_add_tool project name)
1382
1383macro(add_llvm_tool name)
1384  llvm_add_tool(LLVM ${ARGV})
1385endmacro()
1386
1387
1388macro(add_llvm_example name)
1389  if( NOT LLVM_BUILD_EXAMPLES )
1390    set(EXCLUDE_FROM_ALL ON)
1391  endif()
1392  add_llvm_executable(${name} ${ARGN})
1393  if( LLVM_BUILD_EXAMPLES )
1394    install(TARGETS ${name} RUNTIME DESTINATION "${LLVM_EXAMPLES_INSTALL_DIR}")
1395  endif()
1396  set_target_properties(${name} PROPERTIES FOLDER "Examples")
1397endmacro(add_llvm_example name)
1398
1399macro(add_llvm_example_library name)
1400  if( NOT LLVM_BUILD_EXAMPLES )
1401    set(EXCLUDE_FROM_ALL ON)
1402    add_llvm_library(${name} BUILDTREE_ONLY ${ARGN})
1403  else()
1404    add_llvm_library(${name} ${ARGN})
1405  endif()
1406
1407  set_target_properties(${name} PROPERTIES FOLDER "Examples")
1408endmacro(add_llvm_example_library name)
1409
1410# This is a macro that is used to create targets for executables that are needed
1411# for development, but that are not intended to be installed by default.
1412macro(add_llvm_utility name)
1413  if ( NOT LLVM_BUILD_UTILS )
1414    set(EXCLUDE_FROM_ALL ON)
1415  endif()
1416
1417  add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
1418  set_target_properties(${name} PROPERTIES FOLDER "Utils")
1419  if ( ${name} IN_LIST LLVM_TOOLCHAIN_UTILITIES OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
1420    if (LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS)
1421      get_target_export_arg(${name} LLVM export_to_llvmexports)
1422      install(TARGETS ${name}
1423              ${export_to_llvmexports}
1424              RUNTIME DESTINATION ${LLVM_UTILS_INSTALL_DIR}
1425              COMPONENT ${name})
1426
1427      if (NOT LLVM_ENABLE_IDE)
1428        add_llvm_install_targets(install-${name}
1429                                 DEPENDS ${name}
1430                                 COMPONENT ${name})
1431      endif()
1432      set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
1433    elseif(LLVM_BUILD_UTILS)
1434      set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name})
1435    endif()
1436  endif()
1437endmacro(add_llvm_utility name)
1438
1439macro(add_llvm_fuzzer name)
1440  cmake_parse_arguments(ARG "" "DUMMY_MAIN" "" ${ARGN})
1441  if( LLVM_LIB_FUZZING_ENGINE )
1442    set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN})
1443    add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS})
1444    target_link_libraries(${name} PRIVATE ${LLVM_LIB_FUZZING_ENGINE})
1445    set_target_properties(${name} PROPERTIES FOLDER "Fuzzers")
1446  elseif( LLVM_USE_SANITIZE_COVERAGE )
1447    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer")
1448    set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN})
1449    add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS})
1450    set_target_properties(${name} PROPERTIES FOLDER "Fuzzers")
1451  elseif( ARG_DUMMY_MAIN )
1452    add_llvm_executable(${name} ${ARG_DUMMY_MAIN} ${ARG_UNPARSED_ARGUMENTS})
1453    set_target_properties(${name} PROPERTIES FOLDER "Fuzzers")
1454  endif()
1455endmacro()
1456
1457macro(add_llvm_target target_name)
1458  include_directories(BEFORE
1459    ${CMAKE_CURRENT_BINARY_DIR}
1460    ${CMAKE_CURRENT_SOURCE_DIR})
1461  add_llvm_component_library(LLVM${target_name} ${ARGN})
1462  set( CURRENT_LLVM_TARGET LLVM${target_name} )
1463endmacro(add_llvm_target)
1464
1465function(canonicalize_tool_name name output)
1466  string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" nameStrip ${name})
1467  string(REPLACE "-" "_" nameUNDERSCORE ${nameStrip})
1468  string(TOUPPER ${nameUNDERSCORE} nameUPPER)
1469  set(${output} "${nameUPPER}" PARENT_SCOPE)
1470endfunction(canonicalize_tool_name)
1471
1472# Custom add_subdirectory wrapper
1473# Takes in a project name (i.e. LLVM), the subdirectory name, and an optional
1474# path if it differs from the name.
1475function(add_llvm_subdirectory project type name)
1476  set(add_llvm_external_dir "${ARGN}")
1477  if("${add_llvm_external_dir}" STREQUAL "")
1478    set(add_llvm_external_dir ${name})
1479  endif()
1480  canonicalize_tool_name(${name} nameUPPER)
1481  set(canonical_full_name ${project}_${type}_${nameUPPER})
1482  get_property(already_processed GLOBAL PROPERTY ${canonical_full_name}_PROCESSED)
1483  if(already_processed)
1484    return()
1485  endif()
1486  set_property(GLOBAL PROPERTY ${canonical_full_name}_PROCESSED YES)
1487
1488  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}/CMakeLists.txt)
1489    # Treat it as in-tree subproject.
1490    option(${canonical_full_name}_BUILD
1491           "Whether to build ${name} as part of ${project}" On)
1492    mark_as_advanced(${project}_${type}_${name}_BUILD)
1493    if(${canonical_full_name}_BUILD)
1494      add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir} ${add_llvm_external_dir})
1495    endif()
1496  else()
1497    set(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR
1498      "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}"
1499      CACHE PATH "Path to ${name} source directory")
1500    set(${canonical_full_name}_BUILD_DEFAULT ON)
1501    if(NOT LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR OR NOT EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR})
1502      set(${canonical_full_name}_BUILD_DEFAULT OFF)
1503    endif()
1504    if("${LLVM_EXTERNAL_${nameUPPER}_BUILD}" STREQUAL "OFF")
1505      set(${canonical_full_name}_BUILD_DEFAULT OFF)
1506    endif()
1507    option(${canonical_full_name}_BUILD
1508      "Whether to build ${name} as part of LLVM"
1509      ${${canonical_full_name}_BUILD_DEFAULT})
1510    if (${canonical_full_name}_BUILD)
1511      if(EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR})
1512        add_subdirectory(${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR} ${add_llvm_external_dir})
1513      elseif(NOT "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" STREQUAL "")
1514        message(WARNING "Nonexistent directory for ${name}: ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}")
1515      endif()
1516    endif()
1517  endif()
1518endfunction()
1519
1520# Add external project that may want to be built as part of llvm such as Clang,
1521# lld, and Polly. This adds two options. One for the source directory of the
1522# project, which defaults to ${CMAKE_CURRENT_SOURCE_DIR}/${name}. Another to
1523# enable or disable building it with everything else.
1524# Additional parameter can be specified as the name of directory.
1525macro(add_llvm_external_project name)
1526  add_llvm_subdirectory(LLVM TOOL ${name} ${ARGN})
1527endmacro()
1528
1529macro(add_llvm_tool_subdirectory name)
1530  add_llvm_external_project(${name})
1531endmacro(add_llvm_tool_subdirectory)
1532
1533macro(add_custom_linker_flags name)
1534  if (LLVM_${name}_LINKER_FLAGS)
1535    message(DEBUG "Applying ${LLVM_${name}_LINKER_FLAGS} to ${name}")
1536    target_link_options(${name} PRIVATE ${LLVM_${name}_LINKER_FLAGS})
1537  endif()
1538endmacro()
1539
1540function(get_project_name_from_src_var var output)
1541  string(REGEX MATCH "LLVM_EXTERNAL_(.*)_SOURCE_DIR"
1542         MACHED_TOOL "${var}")
1543  if(MACHED_TOOL)
1544    set(${output} ${CMAKE_MATCH_1} PARENT_SCOPE)
1545  else()
1546    set(${output} PARENT_SCOPE)
1547  endif()
1548endfunction()
1549
1550function(create_subdirectory_options project type)
1551  file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*")
1552  foreach(dir ${sub-dirs})
1553    if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt")
1554      canonicalize_tool_name(${dir} name)
1555      option(${project}_${type}_${name}_BUILD
1556           "Whether to build ${name} as part of ${project}" On)
1557      mark_as_advanced(${project}_${type}_${name}_BUILD)
1558    endif()
1559  endforeach()
1560endfunction(create_subdirectory_options)
1561
1562function(create_llvm_tool_options)
1563  create_subdirectory_options(LLVM TOOL)
1564endfunction(create_llvm_tool_options)
1565
1566function(llvm_add_implicit_projects project)
1567  set(list_of_implicit_subdirs "")
1568  file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*")
1569  foreach(dir ${sub-dirs})
1570    if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt")
1571      canonicalize_tool_name(${dir} name)
1572      # I don't like special casing things by order, but the llvm-driver ends up
1573      # linking the object libraries from all the tools that opt-in, so adding
1574      # it separately at the end is probably the simplest case.
1575      if("${name}" STREQUAL "LLVM_DRIVER")
1576        continue()
1577      endif()
1578      if (${project}_TOOL_${name}_BUILD)
1579        get_filename_component(fn "${dir}" NAME)
1580        list(APPEND list_of_implicit_subdirs "${fn}")
1581      endif()
1582    endif()
1583  endforeach()
1584
1585  foreach(external_proj ${list_of_implicit_subdirs})
1586    add_llvm_subdirectory(${project} TOOL "${external_proj}" ${ARGN})
1587  endforeach()
1588endfunction(llvm_add_implicit_projects)
1589
1590function(add_llvm_implicit_projects)
1591  llvm_add_implicit_projects(LLVM)
1592endfunction(add_llvm_implicit_projects)
1593
1594# Generic support for adding a unittest.
1595function(add_unittest test_suite test_name)
1596  if( NOT LLVM_BUILD_TESTS )
1597    set(EXCLUDE_FROM_ALL ON)
1598  endif()
1599
1600  if (SUPPORTS_VARIADIC_MACROS_FLAG)
1601    list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros")
1602  endif ()
1603  # Some parts of gtest rely on this GNU extension, don't warn on it.
1604  if(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG)
1605    list(APPEND LLVM_COMPILE_FLAGS "-Wno-gnu-zero-variadic-macro-arguments")
1606  endif()
1607
1608  if (NOT DEFINED LLVM_REQUIRES_RTTI)
1609    set(LLVM_REQUIRES_RTTI OFF)
1610  endif()
1611
1612  list(APPEND LLVM_LINK_COMPONENTS Support) # gtest needs it for raw_ostream
1613  add_llvm_executable(${test_name} IGNORE_EXTERNALIZE_DEBUGINFO NO_INSTALL_RPATH ${ARGN})
1614
1615  # The runtime benefits of LTO don't outweight the compile time costs for tests.
1616  if(LLVM_ENABLE_LTO)
1617    if((UNIX OR MINGW) AND LINKER_IS_LLD)
1618      set_property(TARGET ${test_name} APPEND_STRING PROPERTY
1619                    LINK_FLAGS " -Wl,--lto-O0")
1620    elseif(LINKER_IS_LLD_LINK)
1621      set_property(TARGET ${test_name} APPEND_STRING PROPERTY
1622                    LINK_FLAGS " /opt:lldlto=0")
1623    elseif(APPLE AND NOT uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")
1624      set_property(TARGET ${target_name} APPEND_STRING PROPERTY
1625                    LINK_FLAGS " -Wl,-mllvm,-O0")
1626    endif()
1627  endif()
1628
1629  target_link_options(${test_name} PRIVATE "${LLVM_UNITTEST_LINK_FLAGS}")
1630
1631  set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
1632  set_output_directory(${test_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir})
1633  # libpthreads overrides some standard library symbols, so main
1634  # executable must be linked with it in order to provide consistent
1635  # API for all shared libaries loaded by this executable.
1636  target_link_libraries(${test_name} PRIVATE llvm_gtest_main llvm_gtest ${LLVM_PTHREAD_LIB})
1637
1638  add_dependencies(${test_suite} ${test_name})
1639  get_target_property(test_suite_folder ${test_suite} FOLDER)
1640  if (test_suite_folder)
1641    set_property(TARGET ${test_name} PROPERTY FOLDER "${test_suite_folder}")
1642  endif ()
1643endfunction()
1644
1645# Use for test binaries that call llvm::getInputFileDirectory(). Use of this
1646# is discouraged.
1647function(add_unittest_with_input_files test_suite test_name)
1648  set(LLVM_UNITTEST_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
1649  configure_file(
1650    ${LLVM_MAIN_SRC_DIR}/unittests/unittest.cfg.in
1651    ${CMAKE_CURRENT_BINARY_DIR}/llvm.srcdir.txt)
1652
1653  add_unittest(${test_suite} ${test_name} ${ARGN})
1654endfunction()
1655
1656# Generic support for adding a benchmark.
1657function(add_benchmark benchmark_name)
1658  if( NOT LLVM_BUILD_BENCHMARKS )
1659    set(EXCLUDE_FROM_ALL ON)
1660  endif()
1661
1662  add_llvm_executable(${benchmark_name} IGNORE_EXTERNALIZE_DEBUGINFO NO_INSTALL_RPATH ${ARGN})
1663  set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
1664  set_output_directory(${benchmark_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir})
1665  set_property(TARGET ${benchmark_name} PROPERTY FOLDER "Utils")
1666  target_link_libraries(${benchmark_name} PRIVATE benchmark)
1667endfunction()
1668
1669# This function canonicalize the CMake variables passed by names
1670# from CMake boolean to 0/1 suitable for passing into Python or C++,
1671# in place.
1672function(llvm_canonicalize_cmake_booleans)
1673  foreach(var ${ARGN})
1674    if(${var})
1675      set(${var} 1 PARENT_SCOPE)
1676    else()
1677      set(${var} 0 PARENT_SCOPE)
1678    endif()
1679  endforeach()
1680endfunction(llvm_canonicalize_cmake_booleans)
1681
1682macro(set_llvm_build_mode)
1683  # Configuration-time: See Unit/lit.site.cfg.in
1684  if (CMAKE_CFG_INTDIR STREQUAL ".")
1685    set(LLVM_BUILD_MODE ".")
1686  else ()
1687    set(LLVM_BUILD_MODE "%(build_mode)s")
1688  endif ()
1689endmacro()
1690
1691# Takes a list of path names in pathlist and a base directory, and returns
1692# a list of paths relative to the base directory in out_pathlist.
1693# Paths that are on a different drive than the basedir (on Windows) or that
1694# contain symlinks are returned absolute.
1695# Use with LLVM_LIT_PATH_FUNCTION below.
1696function(make_paths_relative out_pathlist basedir pathlist)
1697  # Passing ARG_PATH_VALUES as-is to execute_process() makes cmake strip
1698  # empty list entries. So escape the ;s in the list and do the splitting
1699  # ourselves. cmake has no relpath function, so use Python for that.
1700  string(REPLACE ";" "\\;" pathlist_escaped "${pathlist}")
1701  execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "\n
1702import os, sys\n
1703base = sys.argv[1]
1704def haslink(p):\n
1705    if not p or p == os.path.dirname(p): return False\n
1706    return os.path.islink(p) or haslink(os.path.dirname(p))\n
1707def relpath(p):\n
1708    if not p: return ''\n
1709    if os.path.splitdrive(p)[0] != os.path.splitdrive(base)[0]: return p\n
1710    if haslink(p) or haslink(base): return p\n
1711    return os.path.relpath(p, base)\n
1712if len(sys.argv) < 3: sys.exit(0)\n
1713sys.stdout.write(';'.join(relpath(p) for p in sys.argv[2].split(';')))"
1714    ${basedir}
1715    ${pathlist_escaped}
1716    OUTPUT_VARIABLE pathlist_relative
1717    ERROR_VARIABLE error
1718    RESULT_VARIABLE result)
1719  if (NOT result EQUAL 0)
1720    message(FATAL_ERROR "make_paths_relative() failed due to error '${result}', with stderr\n${error}")
1721  endif()
1722  set(${out_pathlist} "${pathlist_relative}" PARENT_SCOPE)
1723endfunction()
1724
1725# Converts a file that's relative to the current python file to an absolute
1726# path. Since this uses __file__, it has to be emitted into python files that
1727# use it and can't be in a lit module. Use with make_paths_relative().
1728string(CONCAT LLVM_LIT_PATH_FUNCTION
1729  "# Allow generated file to be relocatable.\n"
1730  "import os\n"
1731  "import platform\n"
1732  "def path(p):\n"
1733  "    if not p: return ''\n"
1734  "    # Follows lit.util.abs_path_preserve_drive, which cannot be imported here.\n"
1735  "    if platform.system() == 'Windows':\n"
1736  "        return os.path.abspath(os.path.join(os.path.dirname(__file__), p))\n"
1737  "    else:\n"
1738  "        return os.path.realpath(os.path.join(os.path.dirname(__file__), p))\n"
1739  )
1740
1741# This function provides an automatic way to 'configure'-like generate a file
1742# based on a set of common and custom variables, specifically targeting the
1743# variables needed for the 'lit.site.cfg' files. This function bundles the
1744# common variables that any Lit instance is likely to need, and custom
1745# variables can be passed in.
1746# The keyword PATHS is followed by a list of cmake variable names that are
1747# mentioned as `path("@varname@")` in the lit.cfg.py.in file. Variables in that
1748# list are treated as paths that are relative to the directory the generated
1749# lit.cfg.py file is in, and the `path()` function converts the relative
1750# path back to absolute form. This makes it possible to move a build directory
1751# containing lit.cfg.py files from one machine to another.
1752function(configure_lit_site_cfg site_in site_out)
1753  cmake_parse_arguments(ARG "" "" "MAIN_CONFIG;PATHS" ${ARGN})
1754
1755  if ("${ARG_MAIN_CONFIG}" STREQUAL "")
1756    get_filename_component(INPUT_DIR ${site_in} DIRECTORY)
1757    set(ARG_MAIN_CONFIG "${INPUT_DIR}/lit.cfg")
1758  endif()
1759
1760  foreach(c ${LLVM_TARGETS_TO_BUILD})
1761    set(TARGETS_BUILT "${TARGETS_BUILT} ${c}")
1762  endforeach(c)
1763  set(TARGETS_TO_BUILD ${TARGETS_BUILT})
1764
1765  set(SHLIBEXT "${LTDL_SHLIB_EXT}")
1766
1767  set_llvm_build_mode()
1768
1769  # For standalone builds of subprojects, these might not be the build tree but
1770  # a provided binary tree.
1771  set(LLVM_SOURCE_DIR ${LLVM_MAIN_SRC_DIR})
1772  set(LLVM_BINARY_DIR ${LLVM_BINARY_DIR})
1773  string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLVM_TOOLS_DIR "${LLVM_TOOLS_BINARY_DIR}")
1774  string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLVM_LIBS_DIR  "${LLVM_LIBRARY_DIR}")
1775  # Like LLVM_{TOOLS,LIBS}_DIR, but pointing at the build tree.
1776  string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" CURRENT_TOOLS_DIR "${LLVM_RUNTIME_OUTPUT_INTDIR}")
1777  string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" CURRENT_LIBS_DIR  "${LLVM_LIBRARY_OUTPUT_INTDIR}")
1778  string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" SHLIBDIR "${LLVM_SHLIB_OUTPUT_INTDIR}")
1779
1780  # FIXME: "ENABLE_SHARED" doesn't make sense, since it is used just for
1781  # plugins. We may rename it.
1782  if(LLVM_ENABLE_PLUGINS)
1783    set(ENABLE_SHARED "1")
1784  else()
1785    set(ENABLE_SHARED "0")
1786  endif()
1787
1788  if(LLVM_ENABLE_ASSERTIONS)
1789    set(ENABLE_ASSERTIONS "1")
1790  else()
1791    set(ENABLE_ASSERTIONS "0")
1792  endif()
1793
1794  set(HOST_OS ${CMAKE_SYSTEM_NAME})
1795  set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR})
1796
1797  set(HOST_CC "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
1798  set(HOST_CXX "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
1799  set(HOST_LDFLAGS "${CMAKE_EXE_LINKER_FLAGS}")
1800
1801  string(CONCAT LIT_SITE_CFG_IN_HEADER
1802    "# Autogenerated from ${site_in}\n# Do not edit!\n\n"
1803    "${LLVM_LIT_PATH_FUNCTION}"
1804    )
1805
1806  # Override config_target_triple (and the env)
1807  if(LLVM_TARGET_TRIPLE_ENV)
1808    # This is expanded into the heading.
1809    string(CONCAT LIT_SITE_CFG_IN_HEADER "${LIT_SITE_CFG_IN_HEADER}"
1810      "import os\n"
1811      "target_env = \"${LLVM_TARGET_TRIPLE_ENV}\"\n"
1812      "config.target_triple = config.environment[target_env] = os.environ.get(target_env, \"${LLVM_TARGET_TRIPLE}\")\n"
1813      )
1814
1815    # This is expanded to; config.target_triple = ""+config.target_triple+""
1816    set(LLVM_TARGET_TRIPLE "\"+config.target_triple+\"")
1817  endif()
1818
1819  if (ARG_PATHS)
1820    # Walk ARG_PATHS and collect the current value of the variables in there.
1821    # list(APPEND) ignores empty elements exactly if the list is empty,
1822    # so start the list with a dummy element and drop it, to make sure that
1823    # even empty values make it into the values list.
1824    set(ARG_PATH_VALUES "dummy")
1825    foreach(path ${ARG_PATHS})
1826      list(APPEND ARG_PATH_VALUES "${${path}}")
1827    endforeach()
1828    list(REMOVE_AT ARG_PATH_VALUES 0)
1829
1830    get_filename_component(OUTPUT_DIR ${site_out} DIRECTORY)
1831    make_paths_relative(
1832        ARG_PATH_VALUES_RELATIVE "${OUTPUT_DIR}" "${ARG_PATH_VALUES}")
1833
1834    list(LENGTH ARG_PATHS len_paths)
1835    list(LENGTH ARG_PATH_VALUES len_path_values)
1836    list(LENGTH ARG_PATH_VALUES_RELATIVE len_path_value_rels)
1837    if ((NOT ${len_paths} EQUAL ${len_path_values}) OR
1838        (NOT ${len_paths} EQUAL ${len_path_value_rels}))
1839      message(SEND_ERROR "PATHS lengths got confused")
1840    endif()
1841
1842    # Transform variables mentioned in ARG_PATHS to relative paths for
1843    # the configure_file() call. Variables are copied to subscopeds by cmake,
1844    # so this only modifies the local copy of the variables.
1845    math(EXPR arg_path_limit "${len_paths} - 1")
1846    foreach(i RANGE ${arg_path_limit})
1847      list(GET ARG_PATHS ${i} val1)
1848      list(GET ARG_PATH_VALUES_RELATIVE ${i} val2)
1849      set(${val1} ${val2})
1850    endforeach()
1851  endif()
1852
1853  configure_file(${site_in} ${site_out} @ONLY)
1854
1855  if (EXISTS "${ARG_MAIN_CONFIG}")
1856    # Remember main config / generated site config for llvm-lit.in.
1857    get_property(LLVM_LIT_CONFIG_FILES GLOBAL PROPERTY LLVM_LIT_CONFIG_FILES)
1858    list(APPEND LLVM_LIT_CONFIG_FILES "${ARG_MAIN_CONFIG}" "${site_out}")
1859    set_property(GLOBAL PROPERTY LLVM_LIT_CONFIG_FILES ${LLVM_LIT_CONFIG_FILES})
1860  endif()
1861endfunction()
1862
1863function(dump_all_cmake_variables)
1864  get_cmake_property(_variableNames VARIABLES)
1865  foreach (_variableName ${_variableNames})
1866    message(STATUS "${_variableName}=${${_variableName}}")
1867  endforeach()
1868endfunction()
1869
1870function(get_llvm_lit_path base_dir file_name)
1871  cmake_parse_arguments(ARG "ALLOW_EXTERNAL" "" "" ${ARGN})
1872
1873  if (ARG_ALLOW_EXTERNAL)
1874    set (LLVM_EXTERNAL_LIT "" CACHE STRING "Command used to spawn lit")
1875    if ("${LLVM_EXTERNAL_LIT}" STREQUAL "")
1876      set(LLVM_EXTERNAL_LIT "${LLVM_DEFAULT_EXTERNAL_LIT}")
1877    endif()
1878
1879    if (NOT "${LLVM_EXTERNAL_LIT}" STREQUAL "")
1880      if (EXISTS ${LLVM_EXTERNAL_LIT})
1881        get_filename_component(LIT_FILE_NAME ${LLVM_EXTERNAL_LIT} NAME)
1882        get_filename_component(LIT_BASE_DIR ${LLVM_EXTERNAL_LIT} DIRECTORY)
1883        set(${file_name} ${LIT_FILE_NAME} PARENT_SCOPE)
1884        set(${base_dir} ${LIT_BASE_DIR} PARENT_SCOPE)
1885        return()
1886      elseif (NOT DEFINED CACHE{LLVM_EXTERNAL_LIT_MISSING_WARNED_ONCE})
1887        message(WARNING "LLVM_EXTERNAL_LIT set to ${LLVM_EXTERNAL_LIT}, but the path does not exist.")
1888        set(LLVM_EXTERNAL_LIT_MISSING_WARNED_ONCE YES CACHE INTERNAL "")
1889      endif()
1890    endif()
1891  endif()
1892
1893  set(lit_file_name "llvm-lit")
1894  if (CMAKE_HOST_WIN32 AND NOT CYGWIN)
1895    # llvm-lit needs suffix.py for multiprocess to find a main module.
1896    set(lit_file_name "${lit_file_name}.py")
1897  endif ()
1898  set(${file_name} ${lit_file_name} PARENT_SCOPE)
1899
1900  get_property(LLVM_LIT_BASE_DIR GLOBAL PROPERTY LLVM_LIT_BASE_DIR)
1901  if (NOT "${LLVM_LIT_BASE_DIR}" STREQUAL "")
1902    set(${base_dir} ${LLVM_LIT_BASE_DIR} PARENT_SCOPE)
1903  endif()
1904
1905  # Allow individual projects to provide an override
1906  if (NOT "${LLVM_LIT_OUTPUT_DIR}" STREQUAL "")
1907    set(LLVM_LIT_BASE_DIR ${LLVM_LIT_OUTPUT_DIR})
1908  elseif(NOT "${LLVM_RUNTIME_OUTPUT_INTDIR}" STREQUAL "")
1909    set(LLVM_LIT_BASE_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
1910  else()
1911    set(LLVM_LIT_BASE_DIR "")
1912  endif()
1913
1914  # Cache this so we don't have to do it again and have subsequent calls
1915  # potentially disagree on the value.
1916  set_property(GLOBAL PROPERTY LLVM_LIT_BASE_DIR ${LLVM_LIT_BASE_DIR})
1917  set(${base_dir} ${LLVM_LIT_BASE_DIR} PARENT_SCOPE)
1918endfunction()
1919
1920# A raw function to create a lit target. This is used to implement the testuite
1921# management functions.
1922function(add_lit_target target comment)
1923  cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
1924  set(LIT_ARGS "${ARG_ARGS} ${LLVM_LIT_ARGS}")
1925  separate_arguments(LIT_ARGS)
1926  if (NOT CMAKE_CFG_INTDIR STREQUAL ".")
1927    list(APPEND LIT_ARGS --param build_mode=${CMAKE_CFG_INTDIR})
1928  endif ()
1929
1930  # Get the path to the lit to *run* tests with.  This can be overriden by
1931  # the user by specifying -DLLVM_EXTERNAL_LIT=<path-to-lit.py>
1932  get_llvm_lit_path(
1933    lit_base_dir
1934    lit_file_name
1935    ALLOW_EXTERNAL
1936    )
1937
1938  set(LIT_COMMAND "${Python3_EXECUTABLE};${lit_base_dir}/${lit_file_name}")
1939  list(APPEND LIT_COMMAND ${LIT_ARGS})
1940  foreach(param ${ARG_PARAMS})
1941    list(APPEND LIT_COMMAND --param ${param})
1942  endforeach()
1943  if (ARG_UNPARSED_ARGUMENTS)
1944    add_custom_target(${target}
1945      COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS}
1946      COMMENT "${comment}"
1947      USES_TERMINAL
1948      )
1949  else()
1950    add_custom_target(${target}
1951      COMMAND ${CMAKE_COMMAND} -E echo "${target} does nothing, no tools built.")
1952    message(STATUS "${target} does nothing.")
1953  endif()
1954
1955  if (ARG_DEPENDS)
1956    add_dependencies(${target} ${ARG_DEPENDS})
1957  endif()
1958
1959  # Tests should be excluded from "Build Solution".
1960  set_target_properties(${target} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
1961endfunction()
1962
1963# Convert a target name like check-clang to a variable name like CLANG.
1964function(umbrella_lit_testsuite_var target outvar)
1965  if (NOT target MATCHES "^check-")
1966    message(FATAL_ERROR "umbrella lit suites must be check-*, not '${target}'")
1967  endif()
1968  string(SUBSTRING "${target}" 6 -1 var)
1969  string(REPLACE "-" "_" var ${var})
1970  string(TOUPPER "${var}" var)
1971  set(${outvar} "${var}" PARENT_SCOPE)
1972endfunction()
1973
1974# Start recording all lit test suites for a combined 'check-foo' target.
1975# The recording continues until umbrella_lit_testsuite_end() creates the target.
1976function(umbrella_lit_testsuite_begin target)
1977  umbrella_lit_testsuite_var(${target} name)
1978  set_property(GLOBAL APPEND PROPERTY LLVM_LIT_UMBRELLAS ${name})
1979endfunction()
1980
1981# Create a combined 'check-foo' target for a set of related test suites.
1982# It runs all suites added since the matching umbrella_lit_testsuite_end() call.
1983# Tests marked EXCLUDE_FROM_CHECK_ALL are not gathered.
1984function(umbrella_lit_testsuite_end target)
1985  umbrella_lit_testsuite_var(${target} name)
1986
1987  get_property(testsuites GLOBAL PROPERTY LLVM_${name}_LIT_TESTSUITES)
1988  get_property(params GLOBAL PROPERTY LLVM_${name}_LIT_PARAMS)
1989  get_property(depends GLOBAL PROPERTY LLVM_${name}_LIT_DEPENDS)
1990  get_property(extra_args GLOBAL PROPERTY LLVM_${name}_LIT_EXTRA_ARGS)
1991  # Additional test targets are not gathered, but may be set externally.
1992  get_property(additional_test_targets
1993               GLOBAL PROPERTY LLVM_${name}_ADDITIONAL_TEST_TARGETS)
1994
1995  string(TOLOWER ${name} name)
1996  add_lit_target(${target}
1997    "Running ${name} regression tests"
1998    ${testsuites}
1999    PARAMS ${params}
2000    DEPENDS ${depends} ${additional_test_targets}
2001    ARGS ${extra_args}
2002    )
2003endfunction()
2004
2005# A function to add a set of lit test suites to be driven through 'check-*' targets.
2006function(add_lit_testsuite target comment)
2007  cmake_parse_arguments(ARG "EXCLUDE_FROM_CHECK_ALL" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
2008
2009  # EXCLUDE_FROM_ALL excludes the test ${target} out of check-all.
2010  if(NOT ARG_EXCLUDE_FROM_CHECK_ALL)
2011    get_property(gather_names GLOBAL PROPERTY LLVM_LIT_UMBRELLAS)
2012    foreach(name ${gather_names})
2013    # Register the testsuites, params and depends for the umbrella check rule.
2014      set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_TESTSUITES ${ARG_UNPARSED_ARGUMENTS})
2015      set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_PARAMS ${ARG_PARAMS})
2016      set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_DEPENDS ${ARG_DEPENDS})
2017      set_property(GLOBAL APPEND PROPERTY LLVM_${name}_LIT_EXTRA_ARGS ${ARG_ARGS})
2018    endforeach()
2019  endif()
2020
2021  # Produce a specific suffixed check rule.
2022  add_lit_target(${target} ${comment}
2023    ${ARG_UNPARSED_ARGUMENTS}
2024    PARAMS ${ARG_PARAMS}
2025    DEPENDS ${ARG_DEPENDS}
2026    ARGS ${ARG_ARGS}
2027    )
2028endfunction()
2029
2030function(add_lit_testsuites project directory)
2031  if (NOT LLVM_ENABLE_IDE)
2032    cmake_parse_arguments(ARG "EXCLUDE_FROM_CHECK_ALL" "FOLDER" "PARAMS;DEPENDS;ARGS" ${ARGN})
2033
2034    if (NOT ARG_FOLDER)
2035      set(ARG_FOLDER "Test Subdirectories")
2036    endif()
2037
2038    # Search recursively for test directories by assuming anything not
2039    # in a directory called Inputs contains tests.
2040    file(GLOB_RECURSE to_process LIST_DIRECTORIES true ${directory}/*)
2041    foreach(lit_suite ${to_process})
2042      if(NOT IS_DIRECTORY ${lit_suite})
2043        continue()
2044      endif()
2045      string(FIND ${lit_suite} Inputs is_inputs)
2046      string(FIND ${lit_suite} Output is_output)
2047      if (NOT (is_inputs EQUAL -1 AND is_output EQUAL -1))
2048        continue()
2049      endif()
2050
2051      # Create a check- target for the directory.
2052      string(REPLACE ${directory} "" name_slash ${lit_suite})
2053      if (name_slash)
2054        string(REPLACE "/" "-" name_slash ${name_slash})
2055        string(REPLACE "\\" "-" name_dashes ${name_slash})
2056        string(TOLOWER "${project}${name_dashes}" name_var)
2057        add_lit_target("check-${name_var}" "Running lit suite ${lit_suite}"
2058          ${lit_suite}
2059          ${EXCLUDE_FROM_CHECK_ALL}
2060          PARAMS ${ARG_PARAMS}
2061          DEPENDS ${ARG_DEPENDS}
2062          ARGS ${ARG_ARGS}
2063        )
2064        set_target_properties(check-${name_var} PROPERTIES FOLDER ${ARG_FOLDER})
2065      endif()
2066    endforeach()
2067  endif()
2068endfunction()
2069
2070function(llvm_install_library_symlink name dest type)
2071  cmake_parse_arguments(ARG "" "COMPONENT" "" ${ARGN})
2072  foreach(path ${CMAKE_MODULE_PATH})
2073    if(EXISTS ${path}/LLVMInstallSymlink.cmake)
2074      set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
2075      break()
2076    endif()
2077  endforeach()
2078
2079  set(component ${ARG_COMPONENT})
2080  if(NOT component)
2081    set(component ${name})
2082  endif()
2083
2084  set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX})
2085  set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX})
2086
2087  if(LLVM_USE_SYMLINKS)
2088    set(LLVM_LINK_OR_COPY create_symlink)
2089  else()
2090    set(LLVM_LINK_OR_COPY copy)
2091  endif()
2092
2093  set(output_dir lib${LLVM_LIBDIR_SUFFIX})
2094  if(WIN32 AND "${type}" STREQUAL "SHARED")
2095    set(output_dir "${CMAKE_INSTALL_BINDIR}")
2096  endif()
2097
2098  install(SCRIPT ${INSTALL_SYMLINK}
2099          CODE "install_symlink(\"${full_name}\" \"${full_dest}\" \"${output_dir}\" \"${LLVM_LINK_OR_COPY}\")"
2100          COMPONENT ${component})
2101
2102endfunction()
2103
2104function(llvm_install_symlink project name dest)
2105  get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS)
2106  if(LLVM_TOOL_LLVM_DRIVER_BUILD
2107     AND ${dest} IN_LIST LLVM_DRIVER_TOOLS
2108     AND (NOT LLVM_DISTRIBUTION_COMPONENTS OR ${dest} IN_LIST LLVM_DISTRIBUTION_COMPONENTS)
2109    )
2110    return()
2111  endif()
2112  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
2113  foreach(path ${CMAKE_MODULE_PATH})
2114    if(EXISTS ${path}/LLVMInstallSymlink.cmake)
2115      set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
2116      break()
2117    endif()
2118  endforeach()
2119
2120  if(ARG_COMPONENT)
2121    set(component ${ARG_COMPONENT})
2122  else()
2123    if(ARG_ALWAYS_GENERATE)
2124      set(component ${dest})
2125    else()
2126      set(component ${name})
2127    endif()
2128  endif()
2129
2130  set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
2131  set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
2132  if (${dest} STREQUAL "llvm-driver")
2133    set(full_dest llvm${CMAKE_EXECUTABLE_SUFFIX})
2134  endif()
2135
2136  if(LLVM_USE_SYMLINKS)
2137    set(LLVM_LINK_OR_COPY create_symlink)
2138  else()
2139    set(LLVM_LINK_OR_COPY copy)
2140  endif()
2141
2142  set(output_dir "${${project}_TOOLS_INSTALL_DIR}")
2143
2144  install(SCRIPT ${INSTALL_SYMLINK}
2145          CODE "install_symlink(\"${full_name}\" \"${full_dest}\" \"${output_dir}\" \"${LLVM_LINK_OR_COPY}\")"
2146          COMPONENT ${component})
2147
2148  if (NOT LLVM_ENABLE_IDE AND NOT ARG_ALWAYS_GENERATE)
2149    add_llvm_install_targets(install-${name}
2150                             DEPENDS ${name} ${dest}
2151                             COMPONENT ${component}
2152                             SYMLINK ${dest})
2153  endif()
2154endfunction()
2155
2156function(llvm_add_tool_symlink project link_name target)
2157  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "OUTPUT_DIR" "" ${ARGN})
2158
2159  get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS)
2160
2161  if (${target} IN_LIST LLVM_DRIVER_TOOLS)
2162    set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_TOOL_ALIASES_${target} ${link_name})
2163  endif()
2164  set(dest_binary "$<TARGET_FILE:${target}>")
2165
2166  # This got a bit gross... For multi-configuration generators the target
2167  # properties return the resolved value of the string, not the build system
2168  # expression. To reconstruct the platform-agnostic path we have to do some
2169  # magic. First we grab one of the types, and a type-specific path. Then from
2170  # the type-specific path we find the last occurrence of the type in the path,
2171  # and replace it with CMAKE_CFG_INTDIR. This allows the build step to be type
2172  # agnostic again.
2173  if(NOT ARG_OUTPUT_DIR)
2174    # If you're not overriding the OUTPUT_DIR, we can make the link relative in
2175    # the same directory.
2176    if(LLVM_USE_SYMLINKS)
2177      set(dest_binary "$<TARGET_FILE_NAME:${target}>")
2178    endif()
2179    if(CMAKE_CONFIGURATION_TYPES)
2180      list(GET CMAKE_CONFIGURATION_TYPES 0 first_type)
2181      string(TOUPPER ${first_type} first_type_upper)
2182      set(first_type_suffix _${first_type_upper})
2183    endif()
2184    get_target_property(target_type ${target} TYPE)
2185    if(${target_type} STREQUAL "STATIC_LIBRARY")
2186      get_target_property(ARG_OUTPUT_DIR ${target} ARCHIVE_OUTPUT_DIRECTORY${first_type_suffix})
2187    elseif(UNIX AND ${target_type} STREQUAL "SHARED_LIBRARY")
2188      get_target_property(ARG_OUTPUT_DIR ${target} LIBRARY_OUTPUT_DIRECTORY${first_type_suffix})
2189    else()
2190      get_target_property(ARG_OUTPUT_DIR ${target} RUNTIME_OUTPUT_DIRECTORY${first_type_suffix})
2191    endif()
2192    if(CMAKE_CONFIGURATION_TYPES)
2193      string(FIND "${ARG_OUTPUT_DIR}" "/${first_type}/" type_start REVERSE)
2194      string(SUBSTRING "${ARG_OUTPUT_DIR}" 0 ${type_start} path_prefix)
2195      string(SUBSTRING "${ARG_OUTPUT_DIR}" ${type_start} -1 path_suffix)
2196      string(REPLACE "/${first_type}/" "/${CMAKE_CFG_INTDIR}/"
2197             path_suffix ${path_suffix})
2198      set(ARG_OUTPUT_DIR ${path_prefix}${path_suffix})
2199    endif()
2200  endif()
2201
2202  if(LLVM_USE_SYMLINKS)
2203    set(LLVM_LINK_OR_COPY create_symlink)
2204  else()
2205    set(LLVM_LINK_OR_COPY copy)
2206  endif()
2207
2208  set(output_path "${ARG_OUTPUT_DIR}/${link_name}${CMAKE_EXECUTABLE_SUFFIX}")
2209
2210  set(target_name ${link_name})
2211  if(TARGET ${link_name})
2212    set(target_name ${link_name}-link)
2213  endif()
2214
2215
2216  if(ARG_ALWAYS_GENERATE)
2217    set_property(DIRECTORY APPEND PROPERTY
2218      ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary})
2219    add_custom_command(TARGET ${target} POST_BUILD
2220      COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}")
2221  else()
2222    add_custom_command(OUTPUT ${output_path}
2223                     COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}"
2224                     DEPENDS ${target})
2225
2226    # TODO: Make use of generator expressions below once CMake 3.19 or higher is the minimum supported version.
2227    set(should_build_all)
2228    get_target_property(target_excluded_from_all ${target} EXCLUDE_FROM_ALL)
2229    if (NOT target_excluded_from_all)
2230      set(should_build_all ALL)
2231    endif()
2232    add_custom_target(${target_name} ${should_build_all} DEPENDS ${target} ${output_path})
2233    set_target_properties(${target_name} PROPERTIES FOLDER Tools)
2234
2235    # Make sure both the link and target are toolchain tools
2236    if (${link_name} IN_LIST LLVM_TOOLCHAIN_TOOLS AND ${target} IN_LIST LLVM_TOOLCHAIN_TOOLS)
2237      set(TOOL_IS_TOOLCHAIN ON)
2238    endif()
2239
2240    if ((TOOL_IS_TOOLCHAIN OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) AND LLVM_BUILD_TOOLS)
2241      llvm_install_symlink("${project}" ${link_name} ${target})
2242    endif()
2243  endif()
2244endfunction()
2245
2246function(add_llvm_tool_symlink link_name target)
2247  llvm_add_tool_symlink(LLVM ${ARGV})
2248endfunction()
2249
2250function(llvm_externalize_debuginfo name)
2251  if(NOT LLVM_EXTERNALIZE_DEBUGINFO)
2252    return()
2253  endif()
2254
2255  if(NOT LLVM_EXTERNALIZE_DEBUGINFO_SKIP_STRIP)
2256    if(APPLE)
2257      if(NOT CMAKE_STRIP)
2258        set(CMAKE_STRIP xcrun strip)
2259      endif()
2260      set(strip_command COMMAND ${CMAKE_STRIP} -S -x $<TARGET_FILE:${name}>)
2261    else()
2262      set(strip_command COMMAND ${CMAKE_STRIP} -g -x $<TARGET_FILE:${name}>)
2263    endif()
2264  endif()
2265
2266  if(APPLE)
2267    if(LLVM_EXTERNALIZE_DEBUGINFO_EXTENSION)
2268      set(file_ext ${LLVM_EXTERNALIZE_DEBUGINFO_EXTENSION})
2269    else()
2270      set(file_ext dSYM)
2271    endif()
2272
2273    set(output_name "$<TARGET_FILE_NAME:${name}>.${file_ext}")
2274
2275    if(LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR)
2276      set(output_path "-o=${LLVM_EXTERNALIZE_DEBUGINFO_OUTPUT_DIR}/${output_name}")
2277    else()
2278      set(output_path "-o=${output_name}")
2279    endif()
2280
2281    if(CMAKE_CXX_FLAGS MATCHES "-flto"
2282      OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
2283
2284      set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o)
2285      set_property(TARGET ${name} APPEND_STRING PROPERTY
2286        LINK_FLAGS " -Wl,-object_path_lto,${lto_object}")
2287    endif()
2288    if(NOT CMAKE_DSYMUTIL)
2289      set(CMAKE_DSYMUTIL xcrun dsymutil)
2290    endif()
2291    add_custom_command(TARGET ${name} POST_BUILD
2292      COMMAND ${CMAKE_DSYMUTIL} ${output_path} $<TARGET_FILE:${name}>
2293      ${strip_command}
2294      )
2295  else()
2296    add_custom_command(TARGET ${name} POST_BUILD
2297      COMMAND ${CMAKE_OBJCOPY} --only-keep-debug $<TARGET_FILE:${name}> $<TARGET_FILE:${name}>.debug
2298      ${strip_command} -R .gnu_debuglink
2299      COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE:${name}>.debug $<TARGET_FILE:${name}>
2300      )
2301  endif()
2302endfunction()
2303
2304# Usage: llvm_codesign(name [FORCE] [ENTITLEMENTS file] [BUNDLE_PATH path])
2305function(llvm_codesign name)
2306  cmake_parse_arguments(ARG "FORCE" "ENTITLEMENTS;BUNDLE_PATH" "" ${ARGN})
2307
2308  if(NOT LLVM_CODESIGNING_IDENTITY)
2309    return()
2310  endif()
2311
2312  if(CMAKE_GENERATOR STREQUAL "Xcode")
2313    set_target_properties(${name} PROPERTIES
2314      XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ${LLVM_CODESIGNING_IDENTITY}
2315    )
2316    if(DEFINED ARG_ENTITLEMENTS)
2317      set_target_properties(${name} PROPERTIES
2318        XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS ${ARG_ENTITLEMENTS}
2319      )
2320    endif()
2321  elseif(APPLE AND CMAKE_HOST_SYSTEM_NAME MATCHES Darwin)
2322    if(NOT CMAKE_CODESIGN)
2323      set(CMAKE_CODESIGN xcrun codesign)
2324    endif()
2325    if(NOT CMAKE_CODESIGN_ALLOCATE)
2326      execute_process(
2327        COMMAND xcrun -f codesign_allocate
2328        OUTPUT_STRIP_TRAILING_WHITESPACE
2329        OUTPUT_VARIABLE CMAKE_CODESIGN_ALLOCATE
2330      )
2331    endif()
2332    if(DEFINED ARG_ENTITLEMENTS)
2333      set(pass_entitlements --entitlements ${ARG_ENTITLEMENTS})
2334    endif()
2335
2336    if (NOT ARG_BUNDLE_PATH)
2337      set(ARG_BUNDLE_PATH $<TARGET_FILE:${name}>)
2338    endif()
2339
2340    # ld64 now always codesigns the binaries it creates. Apply the force arg
2341    # unconditionally so that we can - for example - add entitlements to the
2342    # targets that need it.
2343    set(force_flag "-f")
2344
2345    add_custom_command(
2346      TARGET ${name} POST_BUILD
2347      COMMAND ${CMAKE_COMMAND} -E
2348              env CODESIGN_ALLOCATE=${CMAKE_CODESIGN_ALLOCATE}
2349              ${CMAKE_CODESIGN} -s ${LLVM_CODESIGNING_IDENTITY}
2350              ${pass_entitlements} ${force_flag} ${ARG_BUNDLE_PATH}
2351    )
2352  endif()
2353endfunction()
2354
2355function(llvm_setup_rpath name)
2356  if(CMAKE_INSTALL_RPATH)
2357    return()
2358  endif()
2359
2360  if(LLVM_INSTALL_PREFIX AND NOT (LLVM_INSTALL_PREFIX STREQUAL CMAKE_INSTALL_PREFIX))
2361    set(extra_libdir ${LLVM_LIBRARY_DIR})
2362  elseif(LLVM_BUILD_LIBRARY_DIR)
2363    set(extra_libdir ${LLVM_LIBRARY_DIR})
2364  endif()
2365
2366  if (APPLE)
2367    set(_install_name_dir INSTALL_NAME_DIR "@rpath")
2368    set(_install_rpath "@loader_path/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
2369  elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX" AND BUILD_SHARED_LIBS)
2370    # $ORIGIN is not interpreted at link time by aix ld.
2371    # Since BUILD_SHARED_LIBS is only recommended for use by developers,
2372    # hardcode the rpath to build/install lib dir first in this mode.
2373    # FIXME: update this when there is better solution.
2374    set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
2375  elseif(UNIX)
2376    set(_build_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
2377    set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}")
2378    if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
2379      set_property(TARGET ${name} APPEND_STRING PROPERTY
2380                   LINK_FLAGS " -Wl,-z,origin ")
2381    endif()
2382    if(LLVM_LINKER_IS_GNULD AND NOT ${LLVM_LIBRARY_OUTPUT_INTDIR} STREQUAL "")
2383      # $ORIGIN is not interpreted at link time by ld.bfd
2384      set_property(TARGET ${name} APPEND_STRING PROPERTY
2385                   LINK_FLAGS " -Wl,-rpath-link,${LLVM_LIBRARY_OUTPUT_INTDIR} ")
2386    endif()
2387  else()
2388    return()
2389  endif()
2390
2391  # Enable BUILD_WITH_INSTALL_RPATH unless CMAKE_BUILD_RPATH is set and not
2392  # building for macOS or AIX, as those platforms seemingly require it.
2393  # On AIX, the tool chain doesn't support modifying rpaths/libpaths for XCOFF
2394  # on install at the moment, so BUILD_WITH_INSTALL_RPATH is required.
2395  if("${CMAKE_BUILD_RPATH}" STREQUAL "")
2396    if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin|AIX")
2397      set_property(TARGET ${name} PROPERTY BUILD_WITH_INSTALL_RPATH ON)
2398    else()
2399      set_property(TARGET ${name} APPEND PROPERTY BUILD_RPATH "${_build_rpath}")
2400    endif()
2401  endif()
2402
2403  set_target_properties(${name} PROPERTIES
2404                        INSTALL_RPATH "${_install_rpath}"
2405                        ${_install_name_dir})
2406endfunction()
2407
2408function(setup_dependency_debugging name)
2409  if(NOT LLVM_DEPENDENCY_DEBUGGING)
2410    return()
2411  endif()
2412
2413  if("intrinsics_gen" IN_LIST ARGN)
2414    return()
2415  endif()
2416
2417  set(deny_attributes_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Attributes.inc\"))")
2418  set(deny_intrinsics_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Intrinsics.inc\"))")
2419
2420  set(sandbox_command "sandbox-exec -p '(version 1) (allow default) ${deny_attributes_inc} ${deny_intrinsics_inc}'")
2421  set_target_properties(${name} PROPERTIES RULE_LAUNCH_COMPILE ${sandbox_command})
2422endfunction()
2423
2424# If the sources at the given `path` are under version control, set `out_var`
2425# to the the path of a file which will be modified when the VCS revision
2426# changes, attempting to create that file if it does not exist; if no such
2427# file exists and one cannot be created, instead set `out_var` to the
2428# empty string.
2429#
2430# If the sources are not under version control, do not define `out_var`.
2431function(find_first_existing_vc_file path out_var)
2432  if(NOT EXISTS "${path}")
2433    return()
2434  endif()
2435  find_package(Git)
2436  if(GIT_FOUND)
2437    execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --git-dir
2438      WORKING_DIRECTORY ${path}
2439      RESULT_VARIABLE git_result
2440      OUTPUT_VARIABLE git_output
2441      ERROR_QUIET)
2442    if(git_result EQUAL 0)
2443      string(STRIP "${git_output}" git_output)
2444      get_filename_component(git_dir ${git_output} ABSOLUTE BASE_DIR ${path})
2445      # Some branchless cases (e.g. 'repo') may not yet have .git/logs/HEAD
2446      if (NOT EXISTS "${git_dir}/logs/HEAD")
2447        execute_process(COMMAND ${CMAKE_COMMAND} -E touch HEAD
2448          WORKING_DIRECTORY "${git_dir}/logs"
2449          RESULT_VARIABLE touch_head_result
2450          ERROR_QUIET)
2451        if (NOT touch_head_result EQUAL 0)
2452          set(${out_var} "" PARENT_SCOPE)
2453          return()
2454        endif()
2455      endif()
2456      set(${out_var} "${git_dir}/logs/HEAD" PARENT_SCOPE)
2457    endif()
2458  endif()
2459endfunction()
2460
2461function(get_host_tool_path tool_name setting_name exe_var_name target_var_name)
2462  set(${setting_name}_DEFAULT "")
2463
2464  if(LLVM_NATIVE_TOOL_DIR)
2465    if(EXISTS "${LLVM_NATIVE_TOOL_DIR}/${tool_name}${LLVM_HOST_EXECUTABLE_SUFFIX}")
2466      set(${setting_name}_DEFAULT "${LLVM_NATIVE_TOOL_DIR}/${tool_name}${LLVM_HOST_EXECUTABLE_SUFFIX}")
2467    endif()
2468  endif()
2469
2470  set(${setting_name} "${${setting_name}_DEFAULT}" CACHE
2471    STRING "Host ${tool_name} executable. Saves building if cross-compiling.")
2472
2473  if(${setting_name})
2474    set(exe_name ${${setting_name}})
2475    set(target_name "")
2476  elseif(LLVM_USE_HOST_TOOLS)
2477    get_native_tool_path(${tool_name} exe_name)
2478    set(target_name ${exe_name})
2479  else()
2480    set(exe_name $<TARGET_FILE:${tool_name}>)
2481    set(target_name ${tool_name})
2482  endif()
2483  set(${exe_var_name} "${exe_name}" CACHE STRING "")
2484  set(${target_var_name} "${target_name}" CACHE STRING "")
2485endfunction()
2486
2487function(setup_host_tool tool_name setting_name exe_var_name target_var_name)
2488  get_host_tool_path(${tool_name} ${setting_name} ${exe_var_name} ${target_var_name})
2489  # Set up a native tool build if necessary
2490  if(LLVM_USE_HOST_TOOLS AND NOT ${setting_name})
2491    build_native_tool(${tool_name} exe_name DEPENDS ${tool_name})
2492    add_custom_target(${target_var_name} DEPENDS ${exe_name})
2493  endif()
2494endfunction()
2495
2496# Adds the unittests folder if gtest is available.
2497function(llvm_add_unittests tests_added)
2498  if (EXISTS ${LLVM_THIRD_PARTY_DIR}/unittest/googletest/include/gtest/gtest.h)
2499    add_subdirectory(unittests)
2500    set(${tests_added} ON PARENT_SCOPE)
2501  else()
2502    message(WARNING "gtest not found, unittests will not be available")
2503  endif()
2504endfunction()
2505