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