1include(LLVMProcessSources)
2include(LLVM-Config)
3include(DetermineGCCCompatible)
4
5function(llvm_update_compile_flags name)
6  get_property(sources TARGET ${name} PROPERTY SOURCES)
7  if("${sources}" MATCHES "\\.c(;|$)")
8    set(update_src_props ON)
9  endif()
10
11  # LLVM_REQUIRES_EH is an internal flag that individual
12  # targets can use to force EH
13  if((LLVM_REQUIRES_EH OR LLVM_ENABLE_EH) AND NOT CLANG_CL)
14    if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI))
15      message(AUTHOR_WARNING "Exception handling requires RTTI. Enabling RTTI for ${name}")
16      set(LLVM_REQUIRES_RTTI ON)
17    endif()
18  else()
19    if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
20      list(APPEND LLVM_COMPILE_FLAGS "-fno-exceptions")
21    elseif(MSVC)
22      list(APPEND LLVM_COMPILE_DEFINITIONS _HAS_EXCEPTIONS=0)
23      list(APPEND LLVM_COMPILE_FLAGS "/EHs-c-")
24    endif()
25    if (CLANG_CL)
26      # FIXME: Remove this once clang-cl supports SEH
27      list(APPEND LLVM_COMPILE_DEFINITIONS "GTEST_HAS_SEH=0")
28    endif()
29  endif()
30
31  # LLVM_REQUIRES_RTTI is an internal flag that individual
32  # targets can use to force RTTI
33  if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI))
34    list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_RTTI=0)
35    if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
36      list(APPEND LLVM_COMPILE_FLAGS "-fno-rtti")
37    elseif (MSVC)
38      list(APPEND LLVM_COMPILE_FLAGS "/GR-")
39    endif ()
40  endif()
41
42  # Assume that;
43  #   - LLVM_COMPILE_FLAGS is list.
44  #   - PROPERTY COMPILE_FLAGS is string.
45  string(REPLACE ";" " " target_compile_flags " ${LLVM_COMPILE_FLAGS}")
46
47  if(update_src_props)
48    foreach(fn ${sources})
49      get_filename_component(suf ${fn} EXT)
50      if("${suf}" STREQUAL ".cpp")
51        set_property(SOURCE ${fn} APPEND_STRING PROPERTY
52          COMPILE_FLAGS "${target_compile_flags}")
53      endif()
54    endforeach()
55  else()
56    # Update target props, since all sources are C++.
57    set_property(TARGET ${name} APPEND_STRING PROPERTY
58      COMPILE_FLAGS "${target_compile_flags}")
59  endif()
60
61  set_property(TARGET ${name} APPEND PROPERTY COMPILE_DEFINITIONS ${LLVM_COMPILE_DEFINITIONS})
62endfunction()
63
64function(add_llvm_symbol_exports target_name export_file)
65  if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
66    set(native_export_file "${target_name}.exports")
67    add_custom_command(OUTPUT ${native_export_file}
68      COMMAND sed -e "s/^/_/" < ${export_file} > ${native_export_file}
69      DEPENDS ${export_file}
70      VERBATIM
71      COMMENT "Creating export file for ${target_name}")
72    set_property(TARGET ${target_name} APPEND_STRING PROPERTY
73                 LINK_FLAGS " -Wl,-exported_symbols_list,${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
74  elseif(LLVM_HAVE_LINK_VERSION_SCRIPT)
75    # Gold and BFD ld require a version script rather than a plain list.
76    set(native_export_file "${target_name}.exports")
77    # FIXME: Don't write the "local:" line on OpenBSD.
78    add_custom_command(OUTPUT ${native_export_file}
79      COMMAND echo "{" > ${native_export_file}
80      COMMAND grep -q "[[:alnum:]]" ${export_file} && echo "  global:" >> ${native_export_file} || :
81      COMMAND sed -e "s/$/;/" -e "s/^/    /" < ${export_file} >> ${native_export_file}
82      COMMAND echo "  local: *;" >> ${native_export_file}
83      COMMAND echo "};" >> ${native_export_file}
84      DEPENDS ${export_file}
85      VERBATIM
86      COMMENT "Creating export file for ${target_name}")
87    if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
88      set_property(TARGET ${target_name} APPEND_STRING PROPERTY
89                   LINK_FLAGS "  -Wl,-M,${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
90    else()
91      set_property(TARGET ${target_name} APPEND_STRING PROPERTY
92                   LINK_FLAGS "  -Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
93    endif()
94  else()
95    set(native_export_file "${target_name}.def")
96
97    add_custom_command(OUTPUT ${native_export_file}
98      COMMAND ${PYTHON_EXECUTABLE} -c "import sys;print(''.join(['EXPORTS\\n']+sys.stdin.readlines(),))"
99        < ${export_file} > ${native_export_file}
100      DEPENDS ${export_file}
101      VERBATIM
102      COMMENT "Creating export file for ${target_name}")
103    set(export_file_linker_flag "${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
104    if(MSVC)
105      set(export_file_linker_flag "/DEF:\"${export_file_linker_flag}\"")
106    endif()
107    set_property(TARGET ${target_name} APPEND_STRING PROPERTY
108                 LINK_FLAGS " ${export_file_linker_flag}")
109  endif()
110
111  add_custom_target(${target_name}_exports DEPENDS ${native_export_file})
112  set_target_properties(${target_name}_exports PROPERTIES FOLDER "Misc")
113
114  get_property(srcs TARGET ${target_name} PROPERTY SOURCES)
115  foreach(src ${srcs})
116    get_filename_component(extension ${src} EXT)
117    if(extension STREQUAL ".cpp")
118      set(first_source_file ${src})
119      break()
120    endif()
121  endforeach()
122
123  # Force re-linking when the exports file changes. Actually, it
124  # forces recompilation of the source file. The LINK_DEPENDS target
125  # property only works for makefile-based generators.
126  # FIXME: This is not safe because this will create the same target
127  # ${native_export_file} in several different file:
128  # - One where we emitted ${target_name}_exports
129  # - One where we emitted the build command for the following object.
130  # set_property(SOURCE ${first_source_file} APPEND PROPERTY
131  #   OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${native_export_file})
132
133  set_property(DIRECTORY APPEND
134    PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${native_export_file})
135
136  add_dependencies(${target_name} ${target_name}_exports)
137
138  # Add dependency to *_exports later -- CMake issue 14747
139  list(APPEND LLVM_COMMON_DEPENDS ${target_name}_exports)
140  set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} PARENT_SCOPE)
141endfunction(add_llvm_symbol_exports)
142
143if(NOT WIN32 AND NOT APPLE)
144  execute_process(
145    COMMAND ${CMAKE_C_COMPILER} -Wl,--version
146    OUTPUT_VARIABLE stdout
147    ERROR_QUIET
148    )
149  if("${stdout}" MATCHES "GNU gold")
150    set(LLVM_LINKER_IS_GOLD ON)
151  endif()
152endif()
153
154function(add_link_opts target_name)
155  # Don't use linker optimizations in debug builds since it slows down the
156  # linker in a context where the optimizations are not important.
157  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
158
159    # Pass -O3 to the linker. This enabled different optimizations on different
160    # linkers.
161    if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin|SunOS" OR WIN32))
162      set_property(TARGET ${target_name} APPEND_STRING PROPERTY
163                   LINK_FLAGS " -Wl,-O3")
164    endif()
165
166    if(LLVM_LINKER_IS_GOLD)
167      # With gold gc-sections is always safe.
168      set_property(TARGET ${target_name} APPEND_STRING PROPERTY
169                   LINK_FLAGS " -Wl,--gc-sections")
170      # Note that there is a bug with -Wl,--icf=safe so it is not safe
171      # to enable. See https://sourceware.org/bugzilla/show_bug.cgi?id=17704.
172    endif()
173
174    if(NOT LLVM_NO_DEAD_STRIP)
175      if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
176        # ld64's implementation of -dead_strip breaks tools that use plugins.
177        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
178                     LINK_FLAGS " -Wl,-dead_strip")
179      elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
180        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
181                     LINK_FLAGS " -Wl,-z -Wl,discard-unused=sections")
182      elseif(NOT WIN32 AND NOT LLVM_LINKER_IS_GOLD)
183        # Object files are compiled with -ffunction-data-sections.
184        # Versions of bfd ld < 2.23.1 have a bug in --gc-sections that breaks
185        # tools that use plugins. Always pass --gc-sections once we require
186        # a newer linker.
187        set_property(TARGET ${target_name} APPEND_STRING PROPERTY
188                     LINK_FLAGS " -Wl,--gc-sections")
189      endif()
190    endif()
191  endif()
192endfunction(add_link_opts)
193
194# Set each output directory according to ${CMAKE_CONFIGURATION_TYPES}.
195# Note: Don't set variables CMAKE_*_OUTPUT_DIRECTORY any more,
196# or a certain builder, for eaxample, msbuild.exe, would be confused.
197function(set_output_directory target)
198  cmake_parse_arguments(ARG "" "BINARY_DIR;LIBRARY_DIR;" "" ${ARGN})
199
200  # module_dir -- corresponding to LIBRARY_OUTPUT_DIRECTORY.
201  # It affects output of add_library(MODULE).
202  if(WIN32 OR CYGWIN)
203    # DLL platform
204    set(module_dir ${ARG_BINARY_DIR})
205  else()
206    set(module_dir ${ARG_LIBRARY_DIR})
207  endif()
208  if(NOT "${CMAKE_CFG_INTDIR}" STREQUAL ".")
209    foreach(build_mode ${CMAKE_CONFIGURATION_TYPES})
210      string(TOUPPER "${build_mode}" CONFIG_SUFFIX)
211      if(ARG_BINARY_DIR)
212        string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} bi ${ARG_BINARY_DIR})
213        set_target_properties(${target} PROPERTIES "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${bi})
214      endif()
215      if(ARG_LIBRARY_DIR)
216        string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} li ${ARG_LIBRARY_DIR})
217        set_target_properties(${target} PROPERTIES "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${li})
218      endif()
219      if(module_dir)
220        string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} mi ${module_dir})
221        set_target_properties(${target} PROPERTIES "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${mi})
222      endif()
223    endforeach()
224  else()
225    if(ARG_BINARY_DIR)
226      set_target_properties(${target} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${ARG_BINARY_DIR})
227    endif()
228    if(ARG_LIBRARY_DIR)
229      set_target_properties(${target} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${ARG_LIBRARY_DIR})
230    endif()
231    if(module_dir)
232      set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${module_dir})
233    endif()
234  endif()
235endfunction()
236
237# If on Windows and building with MSVC, add the resource script containing the
238# VERSIONINFO data to the project.  This embeds version resource information
239# into the output .exe or .dll.
240# TODO: Enable for MinGW Windows builds too.
241#
242function(add_windows_version_resource_file OUT_VAR)
243  set(sources ${ARGN})
244  if (MSVC)
245    set(resource_file ${LLVM_SOURCE_DIR}/resources/windows_version_resource.rc)
246    if(EXISTS ${resource_file})
247      set(sources ${sources} ${resource_file})
248      source_group("Resource Files" ${resource_file})
249      set(windows_resource_file ${resource_file} PARENT_SCOPE)
250    endif()
251  endif(MSVC)
252
253  set(${OUT_VAR} ${sources} PARENT_SCOPE)
254endfunction(add_windows_version_resource_file)
255
256# set_windows_version_resource_properties(name resource_file...
257#   VERSION_MAJOR int
258#     Optional major version number (defaults to LLVM_VERSION_MAJOR)
259#   VERSION_MINOR int
260#     Optional minor version number (defaults to LLVM_VERSION_MINOR)
261#   VERSION_PATCHLEVEL int
262#     Optional patchlevel version number (defaults to LLVM_VERSION_PATCH)
263#   VERSION_STRING
264#     Optional version string (defaults to PACKAGE_VERSION)
265#   PRODUCT_NAME
266#     Optional product name string (defaults to "LLVM")
267#   )
268function(set_windows_version_resource_properties name resource_file)
269  cmake_parse_arguments(ARG
270    ""
271    "VERSION_MAJOR;VERSION_MINOR;VERSION_PATCHLEVEL;VERSION_STRING;PRODUCT_NAME"
272    ""
273    ${ARGN})
274
275  if (NOT DEFINED ARG_VERSION_MAJOR)
276    set(ARG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
277  endif()
278
279  if (NOT DEFINED ARG_VERSION_MINOR)
280    set(ARG_VERSION_MINOR ${LLVM_VERSION_MINOR})
281  endif()
282
283  if (NOT DEFINED ARG_VERSION_PATCHLEVEL)
284    set(ARG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
285  endif()
286
287  if (NOT DEFINED ARG_VERSION_STRING)
288    set(ARG_VERSION_STRING ${PACKAGE_VERSION})
289  endif()
290
291  if (NOT DEFINED ARG_PRODUCT_NAME)
292    set(ARG_PRODUCT_NAME "LLVM")
293  endif()
294
295  set_property(SOURCE ${resource_file}
296               PROPERTY COMPILE_FLAGS /nologo)
297  set_property(SOURCE ${resource_file}
298               PROPERTY COMPILE_DEFINITIONS
299               "RC_VERSION_FIELD_1=${ARG_VERSION_MAJOR}"
300               "RC_VERSION_FIELD_2=${ARG_VERSION_MINOR}"
301               "RC_VERSION_FIELD_3=${ARG_VERSION_PATCHLEVEL}"
302               "RC_VERSION_FIELD_4=0"
303               "RC_FILE_VERSION=\"${ARG_VERSION_STRING}\""
304               "RC_INTERNAL_NAME=\"${name}\""
305               "RC_PRODUCT_NAME=\"${ARG_PRODUCT_NAME}\""
306               "RC_PRODUCT_VERSION=\"${ARG_VERSION_STRING}\"")
307endfunction(set_windows_version_resource_properties)
308
309# llvm_add_library(name sources...
310#   SHARED;STATIC
311#     STATIC by default w/o BUILD_SHARED_LIBS.
312#     SHARED by default w/  BUILD_SHARED_LIBS.
313#   MODULE
314#     Target ${name} might not be created on unsupported platforms.
315#     Check with "if(TARGET ${name})".
316#   DISABLE_LLVM_LINK_LLVM_DYLIB
317#     Do not link this library to libLLVM, even if
318#     LLVM_LINK_LLVM_DYLIB is enabled.
319#   OUTPUT_NAME name
320#     Corresponds to OUTPUT_NAME in target properties.
321#   DEPENDS targets...
322#     Same semantics as add_dependencies().
323#   LINK_COMPONENTS components...
324#     Same as the variable LLVM_LINK_COMPONENTS.
325#   LINK_LIBS lib_targets...
326#     Same semantics as target_link_libraries().
327#   ADDITIONAL_HEADERS
328#     May specify header files for IDE generators.
329#   )
330function(llvm_add_library name)
331  cmake_parse_arguments(ARG
332    "MODULE;SHARED;STATIC;DISABLE_LLVM_LINK_LLVM_DYLIB"
333    "OUTPUT_NAME"
334    "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS"
335    ${ARGN})
336  list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
337  if(ARG_ADDITIONAL_HEADERS)
338    # Pass through ADDITIONAL_HEADERS.
339    set(ARG_ADDITIONAL_HEADERS ADDITIONAL_HEADERS ${ARG_ADDITIONAL_HEADERS})
340  endif()
341  if(ARG_OBJLIBS)
342    set(ALL_FILES ${ARG_OBJLIBS})
343  else()
344    llvm_process_sources(ALL_FILES ${ARG_UNPARSED_ARGUMENTS} ${ARG_ADDITIONAL_HEADERS})
345  endif()
346
347  if(ARG_MODULE)
348    if(ARG_SHARED OR ARG_STATIC)
349      message(WARNING "MODULE with SHARED|STATIC doesn't make sense.")
350    endif()
351    if(NOT LLVM_ENABLE_PLUGINS)
352      message(STATUS "${name} ignored -- Loadable modules not supported on this platform.")
353      return()
354    endif()
355  else()
356    if(BUILD_SHARED_LIBS AND NOT ARG_STATIC)
357      set(ARG_SHARED TRUE)
358    endif()
359    if(NOT ARG_SHARED)
360      set(ARG_STATIC TRUE)
361    endif()
362  endif()
363
364  # Generate objlib
365  if(ARG_SHARED AND ARG_STATIC)
366    # Generate an obj library for both targets.
367    set(obj_name "obj.${name}")
368    add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL
369      ${ALL_FILES}
370      )
371    llvm_update_compile_flags(${obj_name})
372    set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>")
373
374    # Do add_dependencies(obj) later due to CMake issue 14747.
375    list(APPEND objlibs ${obj_name})
376
377    set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
378  endif()
379
380  if(ARG_SHARED AND ARG_STATIC)
381    # static
382    set(name_static "${name}_static")
383    if(ARG_OUTPUT_NAME)
384      set(output_name OUTPUT_NAME "${ARG_OUTPUT_NAME}")
385    endif()
386    # DEPENDS has been appended to LLVM_COMMON_LIBS.
387    llvm_add_library(${name_static} STATIC
388      ${output_name}
389      OBJLIBS ${ALL_FILES} # objlib
390      LINK_LIBS ${ARG_LINK_LIBS}
391      LINK_COMPONENTS ${ARG_LINK_COMPONENTS}
392      )
393    # FIXME: Add name_static to anywhere in TARGET ${name}'s PROPERTY.
394    set(ARG_STATIC)
395  endif()
396
397  if(ARG_MODULE)
398    add_library(${name} MODULE ${ALL_FILES})
399  elseif(ARG_SHARED)
400    add_windows_version_resource_file(ALL_FILES ${ALL_FILES})
401    add_library(${name} SHARED ${ALL_FILES})
402  else()
403    add_library(${name} STATIC ${ALL_FILES})
404  endif()
405
406  if(DEFINED windows_resource_file)
407    set_windows_version_resource_properties(${name} ${windows_resource_file})
408    set(windows_resource_file ${windows_resource_file} PARENT_SCOPE)
409  endif()
410
411  set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
412  # $<TARGET_OBJECTS> doesn't require compile flags.
413  if(NOT obj_name)
414    llvm_update_compile_flags(${name})
415  endif()
416  add_link_opts( ${name} )
417  if(ARG_OUTPUT_NAME)
418    set_target_properties(${name}
419      PROPERTIES
420      OUTPUT_NAME ${ARG_OUTPUT_NAME}
421      )
422  endif()
423
424  if(ARG_MODULE)
425    set_target_properties(${name} PROPERTIES
426      PREFIX ""
427      SUFFIX ${LLVM_PLUGIN_EXT}
428      )
429  endif()
430
431  if(ARG_SHARED)
432    if(WIN32)
433      set_target_properties(${name} PROPERTIES
434        PREFIX ""
435        )
436    endif()
437
438    set_target_properties(${name}
439      PROPERTIES
440      SOVERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}
441      VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX})
442  endif()
443
444  if(ARG_MODULE OR ARG_SHARED)
445    # Do not add -Dname_EXPORTS to the command-line when building files in this
446    # target. Doing so is actively harmful for the modules build because it
447    # creates extra module variants, and not useful because we don't use these
448    # macros.
449    set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" )
450
451    if (LLVM_EXPORTED_SYMBOL_FILE)
452      add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} )
453    endif()
454  endif()
455
456  # Add the explicit dependency information for this library.
457  #
458  # It would be nice to verify that we have the dependencies for this library
459  # name, but using get_property(... SET) doesn't suffice to determine if a
460  # property has been set to an empty value.
461  get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name})
462
463  if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_STATIC AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
464    set(llvm_libs LLVM)
465  else()
466    llvm_map_components_to_libnames(llvm_libs
467      ${ARG_LINK_COMPONENTS}
468      ${LLVM_LINK_COMPONENTS}
469      )
470  endif()
471
472  if(CMAKE_VERSION VERSION_LESS 2.8.12)
473    # Link libs w/o keywords, assuming PUBLIC.
474    target_link_libraries(${name}
475      ${ARG_LINK_LIBS}
476      ${lib_deps}
477      ${llvm_libs}
478      )
479  elseif(ARG_STATIC)
480    target_link_libraries(${name} INTERFACE
481      ${ARG_LINK_LIBS}
482      ${lib_deps}
483      ${llvm_libs}
484      )
485  else()
486    # We can use PRIVATE since SO knows its dependent libs.
487    target_link_libraries(${name} PRIVATE
488      ${ARG_LINK_LIBS}
489      ${lib_deps}
490      ${llvm_libs}
491      )
492  endif()
493
494  if(LLVM_COMMON_DEPENDS)
495    add_dependencies(${name} ${LLVM_COMMON_DEPENDS})
496    # Add dependencies also to objlibs.
497    # CMake issue 14747 --  add_dependencies() might be ignored to objlib's user.
498    foreach(objlib ${objlibs})
499      add_dependencies(${objlib} ${LLVM_COMMON_DEPENDS})
500    endforeach()
501  endif()
502endfunction()
503
504macro(add_llvm_library name)
505  cmake_parse_arguments(ARG
506    "SHARED"
507    ""
508    ""
509    ${ARGN})
510  if( BUILD_SHARED_LIBS )
511    llvm_add_library(${name} SHARED ${ARGN})
512  else()
513    llvm_add_library(${name} ${ARGN})
514  endif()
515  # The gtest libraries should not be installed or exported as a target
516  if ("${name}" STREQUAL gtest OR "${name}" STREQUAL gtest_main)
517    set(_is_gtest TRUE)
518  else()
519    set(_is_gtest FALSE)
520    set_property( GLOBAL APPEND PROPERTY LLVM_LIBS ${name} )
521  endif()
522
523  if( EXCLUDE_FROM_ALL )
524    set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
525  elseif(NOT _is_gtest)
526    if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO")
527      if(ARG_SHARED OR BUILD_SHARED_LIBS)
528        if(WIN32 OR CYGWIN)
529          set(install_type RUNTIME)
530        else()
531          set(install_type LIBRARY)
532        endif()
533      else()
534        set(install_type ARCHIVE)
535      endif()
536
537      install(TARGETS ${name}
538            EXPORT LLVMExports
539            ${install_type} DESTINATION lib${LLVM_LIBDIR_SUFFIX}
540            COMPONENT ${name})
541
542      if (NOT CMAKE_CONFIGURATION_TYPES)
543        add_custom_target(install-${name}
544                          DEPENDS ${name}
545                          COMMAND "${CMAKE_COMMAND}"
546                                  -DCMAKE_INSTALL_COMPONENT=${name}
547                                  -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
548      endif()
549    endif()
550    set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
551  endif()
552  set_target_properties(${name} PROPERTIES FOLDER "Libraries")
553endmacro(add_llvm_library name)
554
555macro(add_llvm_loadable_module name)
556  llvm_add_library(${name} MODULE ${ARGN})
557  if(NOT TARGET ${name})
558    # Add empty "phony" target
559    add_custom_target(${name})
560  else()
561    if( EXCLUDE_FROM_ALL )
562      set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
563    else()
564      if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
565        if(WIN32 OR CYGWIN)
566          # DLL platform
567          set(dlldir "bin")
568        else()
569          set(dlldir "lib${LLVM_LIBDIR_SUFFIX}")
570        endif()
571        install(TARGETS ${name}
572          EXPORT LLVMExports
573          LIBRARY DESTINATION ${dlldir}
574          ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
575      endif()
576      set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
577    endif()
578  endif()
579
580  set_target_properties(${name} PROPERTIES FOLDER "Loadable modules")
581endmacro(add_llvm_loadable_module name)
582
583
584macro(add_llvm_executable name)
585  cmake_parse_arguments(ARG "DISABLE_LLVM_LINK_LLVM_DYLIB" "" "" ${ARGN})
586  llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} )
587
588  # Generate objlib
589  if(LLVM_ENABLE_OBJLIB)
590    # Generate an obj library for both targets.
591    set(obj_name "obj.${name}")
592    add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL
593      ${ALL_FILES}
594      )
595    llvm_update_compile_flags(${obj_name})
596    set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>")
597
598    set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
599  endif()
600
601  add_windows_version_resource_file(ALL_FILES ${ALL_FILES})
602
603  if(XCODE)
604    # Note: the dummy.cpp source file provides no definitions. However,
605    # it forces Xcode to properly link the static library.
606    list(APPEND ALL_FILES "${LLVM_MAIN_SRC_DIR}/cmake/dummy.cpp")
607  endif()
608
609  if( EXCLUDE_FROM_ALL )
610    add_executable(${name} EXCLUDE_FROM_ALL ${ALL_FILES})
611  else()
612    add_executable(${name} ${ALL_FILES})
613  endif()
614
615  if(DEFINED windows_resource_file)
616    set_windows_version_resource_properties(${name} ${windows_resource_file})
617  endif()
618
619  # $<TARGET_OBJECTS> doesn't require compile flags.
620  if(NOT LLVM_ENABLE_OBJLIB)
621    llvm_update_compile_flags(${name})
622  endif()
623  add_link_opts( ${name} )
624
625  # Do not add -Dname_EXPORTS to the command-line when building files in this
626  # target. Doing so is actively harmful for the modules build because it
627  # creates extra module variants, and not useful because we don't use these
628  # macros.
629  set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" )
630
631  if (LLVM_EXPORTED_SYMBOL_FILE)
632    add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} )
633  endif(LLVM_EXPORTED_SYMBOL_FILE)
634
635  if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
636    set(USE_SHARED USE_SHARED)
637  endif()
638
639  set(EXCLUDE_FROM_ALL OFF)
640  set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
641  llvm_config( ${name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} )
642  if( LLVM_COMMON_DEPENDS )
643    add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} )
644  endif( LLVM_COMMON_DEPENDS )
645endmacro(add_llvm_executable name)
646
647function(export_executable_symbols target)
648  if (NOT MSVC) # MSVC's linker doesn't support exporting all symbols.
649    set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
650  endif()
651endfunction()
652
653if(NOT LLVM_TOOLCHAIN_TOOLS)
654  set (LLVM_TOOLCHAIN_TOOLS
655    llvm-ar
656    llvm-ranlib
657    llvm-lib
658    llvm-objdump
659    )
660endif()
661
662macro(add_llvm_tool name)
663  if( NOT LLVM_BUILD_TOOLS )
664    set(EXCLUDE_FROM_ALL ON)
665  endif()
666  add_llvm_executable(${name} ${ARGN})
667
668  list(FIND LLVM_TOOLCHAIN_TOOLS ${name} LLVM_IS_${name}_TOOLCHAIN_TOOL)
669  if (LLVM_IS_${name}_TOOLCHAIN_TOOL GREATER -1 OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
670    if( LLVM_BUILD_TOOLS )
671      install(TARGETS ${name}
672              EXPORT LLVMExports
673              RUNTIME DESTINATION bin
674              COMPONENT ${name})
675
676      if (NOT CMAKE_CONFIGURATION_TYPES)
677        add_custom_target(install-${name}
678                          DEPENDS ${name}
679                          COMMAND "${CMAKE_COMMAND}"
680                                  -DCMAKE_INSTALL_COMPONENT=${name}
681                                  -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
682      endif()
683    endif()
684  endif()
685  if( LLVM_BUILD_TOOLS )
686    set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
687  endif()
688  set_target_properties(${name} PROPERTIES FOLDER "Tools")
689endmacro(add_llvm_tool name)
690
691
692macro(add_llvm_example name)
693  if( NOT LLVM_BUILD_EXAMPLES )
694    set(EXCLUDE_FROM_ALL ON)
695  endif()
696  add_llvm_executable(${name} ${ARGN})
697  if( LLVM_BUILD_EXAMPLES )
698    install(TARGETS ${name} RUNTIME DESTINATION examples)
699  endif()
700  set_target_properties(${name} PROPERTIES FOLDER "Examples")
701endmacro(add_llvm_example name)
702
703
704macro(add_llvm_utility name)
705  add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
706  set_target_properties(${name} PROPERTIES FOLDER "Utils")
707  if( LLVM_INSTALL_UTILS )
708    install (TARGETS ${name}
709      RUNTIME DESTINATION bin
710      COMPONENT ${name})
711    if (NOT CMAKE_CONFIGURATION_TYPES)
712      add_custom_target(install-${name}
713                        DEPENDS ${name}
714                        COMMAND "${CMAKE_COMMAND}"
715                                -DCMAKE_INSTALL_COMPONENT=${name}
716                                -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
717    endif()
718  endif()
719endmacro(add_llvm_utility name)
720
721
722macro(add_llvm_target target_name)
723  include_directories(BEFORE
724    ${CMAKE_CURRENT_BINARY_DIR}
725    ${CMAKE_CURRENT_SOURCE_DIR})
726  add_llvm_library(LLVM${target_name} ${ARGN})
727  set( CURRENT_LLVM_TARGET LLVM${target_name} )
728endmacro(add_llvm_target)
729
730function(canonicalize_tool_name name output)
731  string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" nameStrip ${name})
732  string(REPLACE "-" "_" nameUNDERSCORE ${nameStrip})
733  string(TOUPPER ${nameUNDERSCORE} nameUPPER)
734  set(${output} "${nameUPPER}" PARENT_SCOPE)
735endfunction(canonicalize_tool_name)
736
737# Add external project that may want to be built as part of llvm such as Clang,
738# lld, and Polly. This adds two options. One for the source directory of the
739# project, which defaults to ${CMAKE_CURRENT_SOURCE_DIR}/${name}. Another to
740# enable or disable building it with everything else.
741# Additional parameter can be specified as the name of directory.
742macro(add_llvm_external_project name)
743  set(add_llvm_external_dir "${ARGN}")
744  if("${add_llvm_external_dir}" STREQUAL "")
745    set(add_llvm_external_dir ${name})
746  endif()
747  canonicalize_tool_name(${name} nameUPPER)
748  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}/CMakeLists.txt)
749    # Treat it as in-tree subproject.
750    option(LLVM_TOOL_${nameUPPER}_BUILD
751           "Whether to build ${name} as part of LLVM" On)
752    mark_as_advanced(LLVM_TOOL_${name}_BUILD)
753    if(LLVM_TOOL_${nameUPPER}_BUILD)
754      add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir} ${add_llvm_external_dir})
755      # Don't process it in add_llvm_implicit_projects().
756      set(LLVM_TOOL_${nameUPPER}_BUILD OFF)
757    endif()
758  else()
759    set(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR
760      "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}"
761      CACHE PATH "Path to ${name} source directory")
762    set(LLVM_TOOL_${nameUPPER}_BUILD_DEFAULT ON)
763    if(NOT LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR OR NOT EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR})
764      set(LLVM_TOOL_${nameUPPER}_BUILD_DEFAULT OFF)
765    endif()
766    if("${LLVM_EXTERNAL_${nameUPPER}_BUILD}" STREQUAL "OFF")
767      set(LLVM_TOOL_${nameUPPER}_BUILD_DEFAULT OFF)
768    endif()
769    option(LLVM_TOOL_${nameUPPER}_BUILD
770      "Whether to build ${name} as part of LLVM"
771      ${LLVM_TOOL_${nameUPPER}_BUILD_DEFAULT})
772    if (LLVM_TOOL_${nameUPPER}_BUILD)
773      if(EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR})
774        add_subdirectory(${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR} ${add_llvm_external_dir})
775      elseif(NOT "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" STREQUAL "")
776        message(WARNING "Nonexistent directory for ${name}: ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}")
777      endif()
778      # FIXME: It'd be redundant.
779      set(LLVM_TOOL_${nameUPPER}_BUILD Off)
780    endif()
781  endif()
782endmacro(add_llvm_external_project)
783
784macro(add_llvm_tool_subdirectory name)
785  add_llvm_external_project(${name})
786endmacro(add_llvm_tool_subdirectory)
787
788function(get_project_name_from_src_var var output)
789  string(REGEX MATCH "LLVM_EXTERNAL_(.*)_SOURCE_DIR"
790         MACHED_TOOL "${var}")
791  if(MACHED_TOOL)
792    set(${output} ${CMAKE_MATCH_1} PARENT_SCOPE)
793  else()
794    set(${output} PARENT_SCOPE)
795  endif()
796endfunction()
797
798function(create_llvm_tool_options)
799  file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*")
800  foreach(dir ${sub-dirs})
801    if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt")
802      canonicalize_tool_name(${dir} name)
803      option(LLVM_TOOL_${name}_BUILD
804           "Whether to build ${name} as part of LLVM" On)
805      mark_as_advanced(LLVM_TOOL_${name}_BUILD)
806    endif()
807  endforeach()
808endfunction(create_llvm_tool_options)
809
810function(add_llvm_implicit_projects)
811  set(list_of_implicit_subdirs "")
812  file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*")
813  foreach(dir ${sub-dirs})
814    if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt")
815      canonicalize_tool_name(${dir} name)
816      if (LLVM_TOOL_${name}_BUILD)
817        get_filename_component(fn "${dir}" NAME)
818        list(APPEND list_of_implicit_subdirs "${fn}")
819      endif()
820    endif()
821  endforeach()
822
823  foreach(external_proj ${list_of_implicit_subdirs})
824    add_llvm_external_project("${external_proj}")
825  endforeach()
826endfunction(add_llvm_implicit_projects)
827
828# Generic support for adding a unittest.
829function(add_unittest test_suite test_name)
830  if( NOT LLVM_BUILD_TESTS )
831    set(EXCLUDE_FROM_ALL ON)
832  endif()
833
834  include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include)
835  if (NOT LLVM_ENABLE_THREADS)
836    list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_PTHREAD=0)
837  endif ()
838
839  if (SUPPORTS_NO_VARIADIC_MACROS_FLAG)
840    list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros")
841  endif ()
842
843  set(LLVM_REQUIRES_RTTI OFF)
844
845  add_llvm_executable(${test_name} ${ARGN})
846  set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
847  set_output_directory(${test_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir})
848  target_link_libraries(${test_name}
849    gtest
850    gtest_main
851    LLVMSupport # gtest needs it for raw_ostream.
852    )
853
854  add_dependencies(${test_suite} ${test_name})
855  get_target_property(test_suite_folder ${test_suite} FOLDER)
856  if (NOT ${test_suite_folder} STREQUAL "NOTFOUND")
857    set_property(TARGET ${test_name} PROPERTY FOLDER "${test_suite_folder}")
858  endif ()
859endfunction()
860
861function(llvm_add_go_executable binary pkgpath)
862  cmake_parse_arguments(ARG "ALL" "" "DEPENDS;GOFLAGS" ${ARGN})
863
864  if(LLVM_BINDINGS MATCHES "go")
865    # FIXME: This should depend only on the libraries Go needs.
866    get_property(llvmlibs GLOBAL PROPERTY LLVM_LIBS)
867    set(binpath ${CMAKE_BINARY_DIR}/bin/${binary}${CMAKE_EXECUTABLE_SUFFIX})
868    set(cc "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
869    set(cxx "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
870    set(cppflags "")
871    get_property(include_dirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
872    foreach(d ${include_dirs})
873      set(cppflags "${cppflags} -I${d}")
874    endforeach(d)
875    set(ldflags "${CMAKE_EXE_LINKER_FLAGS}")
876    if (LLVM_LINK_LLVM_DYLIB)
877      set(linkmode "dylib")
878    else()
879      set(linkmode "component-libs")
880    endif()
881    add_custom_command(OUTPUT ${binpath}
882      COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" "linkmode=${linkmode}"
883              ${ARG_GOFLAGS} build -o ${binpath} ${pkgpath}
884      DEPENDS llvm-config ${CMAKE_BINARY_DIR}/bin/llvm-go${CMAKE_EXECUTABLE_SUFFIX}
885              ${llvmlibs} ${ARG_DEPENDS}
886      COMMENT "Building Go executable ${binary}"
887      VERBATIM)
888    if (ARG_ALL)
889      add_custom_target(${binary} ALL DEPENDS ${binpath})
890    else()
891      add_custom_target(${binary} DEPENDS ${binpath})
892    endif()
893  endif()
894endfunction()
895
896# This function provides an automatic way to 'configure'-like generate a file
897# based on a set of common and custom variables, specifically targeting the
898# variables needed for the 'lit.site.cfg' files. This function bundles the
899# common variables that any Lit instance is likely to need, and custom
900# variables can be passed in.
901function(configure_lit_site_cfg input output)
902  foreach(c ${LLVM_TARGETS_TO_BUILD})
903    set(TARGETS_BUILT "${TARGETS_BUILT} ${c}")
904  endforeach(c)
905  set(TARGETS_TO_BUILD ${TARGETS_BUILT})
906
907  set(SHLIBEXT "${LTDL_SHLIB_EXT}")
908
909  # Configuration-time: See Unit/lit.site.cfg.in
910  if (CMAKE_CFG_INTDIR STREQUAL ".")
911    set(LLVM_BUILD_MODE ".")
912  else ()
913    set(LLVM_BUILD_MODE "%(build_mode)s")
914  endif ()
915
916  # They below might not be the build tree but provided binary tree.
917  set(LLVM_SOURCE_DIR ${LLVM_MAIN_SRC_DIR})
918  set(LLVM_BINARY_DIR ${LLVM_BINARY_DIR})
919  string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLVM_TOOLS_DIR ${LLVM_TOOLS_BINARY_DIR})
920  string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLVM_LIBS_DIR  ${LLVM_LIBRARY_DIR})
921
922  # SHLIBDIR points the build tree.
923  string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} SHLIBDIR "${LLVM_SHLIB_OUTPUT_INTDIR}")
924
925  set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
926  # FIXME: "ENABLE_SHARED" doesn't make sense, since it is used just for
927  # plugins. We may rename it.
928  if(LLVM_ENABLE_PLUGINS)
929    set(ENABLE_SHARED "1")
930  else()
931    set(ENABLE_SHARED "0")
932  endif()
933
934  if(LLVM_ENABLE_ASSERTIONS AND NOT MSVC_IDE)
935    set(ENABLE_ASSERTIONS "1")
936  else()
937    set(ENABLE_ASSERTIONS "0")
938  endif()
939
940  set(HOST_OS ${CMAKE_SYSTEM_NAME})
941  set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR})
942
943  set(HOST_CC "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
944  set(HOST_CXX "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
945  set(HOST_LDFLAGS "${CMAKE_EXE_LINKER_FLAGS}")
946
947  configure_file(${input} ${output} @ONLY)
948endfunction()
949
950# A raw function to create a lit target. This is used to implement the testuite
951# management functions.
952function(add_lit_target target comment)
953  cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
954  set(LIT_ARGS "${ARG_ARGS} ${LLVM_LIT_ARGS}")
955  separate_arguments(LIT_ARGS)
956  if (NOT CMAKE_CFG_INTDIR STREQUAL ".")
957    list(APPEND LIT_ARGS --param build_mode=${CMAKE_CFG_INTDIR})
958  endif ()
959  if (LLVM_MAIN_SRC_DIR)
960    set (LIT_COMMAND ${PYTHON_EXECUTABLE} ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
961  else()
962    find_program(LIT_COMMAND llvm-lit)
963  endif ()
964  list(APPEND LIT_COMMAND ${LIT_ARGS})
965  foreach(param ${ARG_PARAMS})
966    list(APPEND LIT_COMMAND --param ${param})
967  endforeach()
968  if (ARG_UNPARSED_ARGUMENTS)
969    add_custom_target(${target}
970      COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS}
971      COMMENT "${comment}"
972      ${cmake_3_2_USES_TERMINAL}
973      )
974  else()
975    add_custom_target(${target}
976      COMMAND ${CMAKE_COMMAND} -E echo "${target} does nothing, no tools built.")
977    message(STATUS "${target} does nothing.")
978  endif()
979  if (ARG_DEPENDS)
980    add_dependencies(${target} ${ARG_DEPENDS})
981  endif()
982
983  # Tests should be excluded from "Build Solution".
984  set_target_properties(${target} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
985endfunction()
986
987# A function to add a set of lit test suites to be driven through 'check-*' targets.
988function(add_lit_testsuite target comment)
989  cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
990
991  # EXCLUDE_FROM_ALL excludes the test ${target} out of check-all.
992  if(NOT EXCLUDE_FROM_ALL)
993    # Register the testsuites, params and depends for the global check rule.
994    set_property(GLOBAL APPEND PROPERTY LLVM_LIT_TESTSUITES ${ARG_UNPARSED_ARGUMENTS})
995    set_property(GLOBAL APPEND PROPERTY LLVM_LIT_PARAMS ${ARG_PARAMS})
996    set_property(GLOBAL APPEND PROPERTY LLVM_LIT_DEPENDS ${ARG_DEPENDS})
997    set_property(GLOBAL APPEND PROPERTY LLVM_LIT_EXTRA_ARGS ${ARG_ARGS})
998  endif()
999
1000  # Produce a specific suffixed check rule.
1001  add_lit_target(${target} ${comment}
1002    ${ARG_UNPARSED_ARGUMENTS}
1003    PARAMS ${ARG_PARAMS}
1004    DEPENDS ${ARG_DEPENDS}
1005    ARGS ${ARG_ARGS}
1006    )
1007endfunction()
1008
1009function(add_lit_testsuites project directory)
1010  if (NOT CMAKE_CONFIGURATION_TYPES)
1011    cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
1012    file(GLOB_RECURSE litCfg ${directory}/lit*.cfg)
1013    set(lit_suites)
1014    foreach(f ${litCfg})
1015      get_filename_component(dir ${f} DIRECTORY)
1016      set(lit_suites ${lit_suites} ${dir})
1017    endforeach()
1018    list(REMOVE_DUPLICATES lit_suites)
1019    foreach(dir ${lit_suites})
1020      string(REPLACE ${directory} "" name_slash ${dir})
1021      if (name_slash)
1022        string(REPLACE "/" "-" name_slash ${name_slash})
1023        string(REPLACE "\\" "-" name_dashes ${name_slash})
1024        string(TOLOWER "${project}${name_dashes}" name_var)
1025        add_lit_target("check-${name_var}" "Running lit suite ${dir}"
1026          ${dir}
1027          PARAMS ${ARG_PARAMS}
1028          DEPENDS ${ARG_DEPENDS}
1029          ARGS ${ARG_ARGS}
1030        )
1031      endif()
1032    endforeach()
1033  endif()
1034endfunction()
1035
1036function(llvm_install_symlink name dest)
1037  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
1038  foreach(path ${CMAKE_MODULE_PATH})
1039    if(EXISTS ${path}/LLVMInstallSymlink.cmake)
1040      set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
1041      break()
1042    endif()
1043  endforeach()
1044
1045  if(ARG_ALWAYS_GENERATE)
1046    set(component ${dest})
1047  else()
1048    set(component ${name})
1049  endif()
1050
1051  install(SCRIPT ${INSTALL_SYMLINK}
1052          CODE "install_symlink(${name} ${dest})"
1053          COMPONENT ${component})
1054
1055  if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
1056    add_custom_target(install-${name}
1057                      DEPENDS ${name} ${dest} install-${dest}
1058                      COMMAND "${CMAKE_COMMAND}"
1059                              -DCMAKE_INSTALL_COMPONENT=${name}
1060                              -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
1061  endif()
1062endfunction()
1063
1064function(add_llvm_tool_symlink name dest)
1065  cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
1066  if(UNIX)
1067    set(LLVM_LINK_OR_COPY create_symlink)
1068    set(dest_binary "${dest}${CMAKE_EXECUTABLE_SUFFIX}")
1069  else()
1070    set(LLVM_LINK_OR_COPY copy)
1071    set(dest_binary "${LLVM_RUNTIME_OUTPUT_INTDIR}/${dest}${CMAKE_EXECUTABLE_SUFFIX}")
1072  endif()
1073
1074  set(output_path "${LLVM_RUNTIME_OUTPUT_INTDIR}/${name}${CMAKE_EXECUTABLE_SUFFIX}")
1075
1076  if(ARG_ALWAYS_GENERATE)
1077    set_property(DIRECTORY APPEND PROPERTY
1078      ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary})
1079    add_custom_command(TARGET ${dest} POST_BUILD
1080      COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}")
1081  else()
1082    add_custom_command(OUTPUT ${output_path}
1083                     COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}"
1084                     DEPENDS ${dest})
1085    add_custom_target(${name} ALL DEPENDS ${output_path})
1086    set_target_properties(${name} PROPERTIES FOLDER Tools)
1087
1088    # Make sure the parent tool is a toolchain tool, otherwise exclude this tool
1089    list(FIND LLVM_TOOLCHAIN_TOOLS ${dest} LLVM_IS_${dest}_TOOLCHAIN_TOOL)
1090    if (NOT LLVM_IS_${dest}_TOOLCHAIN_TOOL GREATER -1)
1091      set(LLVM_IS_${name}_TOOLCHAIN_TOOL ${LLVM_IS_${dest}_TOOLCHAIN_TOOL})
1092    else()
1093      list(FIND LLVM_TOOLCHAIN_TOOLS ${name} LLVM_IS_${name}_TOOLCHAIN_TOOL)
1094    endif()
1095
1096    # LLVM_IS_${name}_TOOLCHAIN_TOOL will only be greater than -1 if both this
1097    # tool and its parent tool are in LLVM_TOOLCHAIN_TOOLS
1098    if (LLVM_IS_${name}_TOOLCHAIN_TOOL GREATER -1 OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
1099      if( LLVM_BUILD_TOOLS )
1100        llvm_install_symlink(${name} ${dest})
1101      endif()
1102    endif()
1103  endif()
1104endfunction()
1105
1106