Import prebuilt clang toolchain for linux.
diff --git a/linux-x64/clang/lib64/cmake/llvm/AddLLVM.cmake b/linux-x64/clang/lib64/cmake/llvm/AddLLVM.cmake
new file mode 100644
index 0000000..2f47010
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/AddLLVM.cmake
@@ -0,0 +1,1655 @@
+include(LLVMProcessSources)
+include(LLVM-Config)
+include(DetermineGCCCompatible)
+
+function(llvm_update_compile_flags name)
+ get_property(sources TARGET ${name} PROPERTY SOURCES)
+ if("${sources}" MATCHES "\\.c(;|$)")
+ set(update_src_props ON)
+ endif()
+
+ # LLVM_REQUIRES_EH is an internal flag that individual targets can use to
+ # force EH
+ if(LLVM_REQUIRES_EH OR LLVM_ENABLE_EH)
+ if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI))
+ message(AUTHOR_WARNING "Exception handling requires RTTI. Enabling RTTI for ${name}")
+ set(LLVM_REQUIRES_RTTI ON)
+ endif()
+ if(MSVC)
+ list(APPEND LLVM_COMPILE_FLAGS "/EHsc")
+ endif()
+ else()
+ if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
+ list(APPEND LLVM_COMPILE_FLAGS "-fno-exceptions")
+ elseif(MSVC)
+ list(APPEND LLVM_COMPILE_DEFINITIONS _HAS_EXCEPTIONS=0)
+ list(APPEND LLVM_COMPILE_FLAGS "/EHs-c-")
+ endif()
+ endif()
+
+ # LLVM_REQUIRES_RTTI is an internal flag that individual
+ # targets can use to force RTTI
+ set(LLVM_CONFIG_HAS_RTTI YES CACHE INTERNAL "")
+ if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI))
+ set(LLVM_CONFIG_HAS_RTTI NO CACHE INTERNAL "")
+ list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_RTTI=0)
+ if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
+ list(APPEND LLVM_COMPILE_FLAGS "-fno-rtti")
+ elseif (MSVC)
+ list(APPEND LLVM_COMPILE_FLAGS "/GR-")
+ endif ()
+ elseif(MSVC)
+ list(APPEND LLVM_COMPILE_FLAGS "/GR")
+ endif()
+
+ # Assume that;
+ # - LLVM_COMPILE_FLAGS is list.
+ # - PROPERTY COMPILE_FLAGS is string.
+ string(REPLACE ";" " " target_compile_flags " ${LLVM_COMPILE_FLAGS}")
+
+ if(update_src_props)
+ foreach(fn ${sources})
+ get_filename_component(suf ${fn} EXT)
+ if("${suf}" STREQUAL ".cpp")
+ set_property(SOURCE ${fn} APPEND_STRING PROPERTY
+ COMPILE_FLAGS "${target_compile_flags}")
+ endif()
+ endforeach()
+ else()
+ # Update target props, since all sources are C++.
+ set_property(TARGET ${name} APPEND_STRING PROPERTY
+ COMPILE_FLAGS "${target_compile_flags}")
+ endif()
+
+ set_property(TARGET ${name} APPEND PROPERTY COMPILE_DEFINITIONS ${LLVM_COMPILE_DEFINITIONS})
+endfunction()
+
+function(add_llvm_symbol_exports target_name export_file)
+ if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ set(native_export_file "${target_name}.exports")
+ add_custom_command(OUTPUT ${native_export_file}
+ COMMAND sed -e "s/^/_/" < ${export_file} > ${native_export_file}
+ DEPENDS ${export_file}
+ VERBATIM
+ COMMENT "Creating export file for ${target_name}")
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-exported_symbols_list,${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
+ elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-bE:${export_file}")
+ elseif(LLVM_HAVE_LINK_VERSION_SCRIPT)
+ # Gold and BFD ld require a version script rather than a plain list.
+ set(native_export_file "${target_name}.exports")
+ # FIXME: Don't write the "local:" line on OpenBSD.
+ # in the export file, also add a linker script to version LLVM symbols (form: LLVM_N.M)
+ add_custom_command(OUTPUT ${native_export_file}
+ COMMAND echo "LLVM_${LLVM_VERSION_MAJOR} {" > ${native_export_file}
+ COMMAND grep -q "[[:alnum:]]" ${export_file} && echo " global:" >> ${native_export_file} || :
+ COMMAND sed -e "s/$/;/" -e "s/^/ /" < ${export_file} >> ${native_export_file}
+ COMMAND echo " local: *;" >> ${native_export_file}
+ COMMAND echo "};" >> ${native_export_file}
+ DEPENDS ${export_file}
+ VERBATIM
+ COMMENT "Creating export file for ${target_name}")
+ if (${LLVM_LINKER_IS_SOLARISLD})
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-M,${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
+ else()
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
+ endif()
+ else()
+ set(native_export_file "${target_name}.def")
+
+ add_custom_command(OUTPUT ${native_export_file}
+ COMMAND ${PYTHON_EXECUTABLE} -c "import sys;print(''.join(['EXPORTS\\n']+sys.stdin.readlines(),))"
+ < ${export_file} > ${native_export_file}
+ DEPENDS ${export_file}
+ VERBATIM
+ COMMENT "Creating export file for ${target_name}")
+ set(export_file_linker_flag "${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
+ if(MSVC)
+ set(export_file_linker_flag "/DEF:\"${export_file_linker_flag}\"")
+ endif()
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " ${export_file_linker_flag}")
+ endif()
+
+ add_custom_target(${target_name}_exports DEPENDS ${native_export_file})
+ set_target_properties(${target_name}_exports PROPERTIES FOLDER "Misc")
+
+ get_property(srcs TARGET ${target_name} PROPERTY SOURCES)
+ foreach(src ${srcs})
+ get_filename_component(extension ${src} EXT)
+ if(extension STREQUAL ".cpp")
+ set(first_source_file ${src})
+ break()
+ endif()
+ endforeach()
+
+ # Force re-linking when the exports file changes. Actually, it
+ # forces recompilation of the source file. The LINK_DEPENDS target
+ # property only works for makefile-based generators.
+ # FIXME: This is not safe because this will create the same target
+ # ${native_export_file} in several different file:
+ # - One where we emitted ${target_name}_exports
+ # - One where we emitted the build command for the following object.
+ # set_property(SOURCE ${first_source_file} APPEND PROPERTY
+ # OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${native_export_file})
+
+ set_property(DIRECTORY APPEND
+ PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${native_export_file})
+
+ add_dependencies(${target_name} ${target_name}_exports)
+
+ # Add dependency to *_exports later -- CMake issue 14747
+ list(APPEND LLVM_COMMON_DEPENDS ${target_name}_exports)
+ set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} PARENT_SCOPE)
+endfunction(add_llvm_symbol_exports)
+
+if(NOT WIN32 AND NOT APPLE)
+ # Detect what linker we have here
+ if( LLVM_USE_LINKER )
+ set(command ${CMAKE_C_COMPILER} -fuse-ld=${LLVM_USE_LINKER} -Wl,--version)
+ else()
+ set(command ${CMAKE_C_COMPILER} -Wl,--version)
+ endif()
+ execute_process(
+ COMMAND ${command}
+ OUTPUT_VARIABLE stdout
+ ERROR_VARIABLE stderr
+ )
+ set(LLVM_LINKER_DETECTED ON)
+ if("${stdout}" MATCHES "GNU gold")
+ set(LLVM_LINKER_IS_GOLD ON)
+ message(STATUS "Linker detection: GNU Gold")
+ elseif("${stdout}" MATCHES "^LLD")
+ set(LLVM_LINKER_IS_LLD ON)
+ message(STATUS "Linker detection: LLD")
+ elseif("${stdout}" MATCHES "GNU ld")
+ set(LLVM_LINKER_IS_GNULD ON)
+ message(STATUS "Linker detection: GNU ld")
+ elseif("${stderr}" MATCHES "Solaris Link Editors" OR
+ "${stdout}" MATCHES "Solaris Link Editors")
+ set(LLVM_LINKER_IS_SOLARISLD ON)
+ message(STATUS "Linker detection: Solaris ld")
+ else()
+ set(LLVM_LINKER_DETECTED OFF)
+ message(STATUS "Linker detection: unknown")
+ endif()
+endif()
+
+function(add_link_opts target_name)
+ # Don't use linker optimizations in debug builds since it slows down the
+ # linker in a context where the optimizations are not important.
+ if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+
+ # Pass -O3 to the linker. This enabled different optimizations on different
+ # linkers.
+ if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin|SunOS|AIX" OR WIN32))
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-O3")
+ endif()
+
+ if(LLVM_LINKER_IS_GOLD)
+ # With gold gc-sections is always safe.
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,--gc-sections")
+ # Note that there is a bug with -Wl,--icf=safe so it is not safe
+ # to enable. See https://sourceware.org/bugzilla/show_bug.cgi?id=17704.
+ endif()
+
+ if(NOT LLVM_NO_DEAD_STRIP)
+ if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ # ld64's implementation of -dead_strip breaks tools that use plugins.
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-dead_strip")
+ elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-z -Wl,discard-unused=sections")
+ elseif(NOT WIN32 AND NOT LLVM_LINKER_IS_GOLD)
+ # Object files are compiled with -ffunction-data-sections.
+ # Versions of bfd ld < 2.23.1 have a bug in --gc-sections that breaks
+ # tools that use plugins. Always pass --gc-sections once we require
+ # a newer linker.
+ set_property(TARGET ${target_name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,--gc-sections")
+ endif()
+ endif()
+ endif()
+endfunction(add_link_opts)
+
+# Set each output directory according to ${CMAKE_CONFIGURATION_TYPES}.
+# Note: Don't set variables CMAKE_*_OUTPUT_DIRECTORY any more,
+# or a certain builder, for eaxample, msbuild.exe, would be confused.
+function(set_output_directory target)
+ cmake_parse_arguments(ARG "" "BINARY_DIR;LIBRARY_DIR" "" ${ARGN})
+
+ # module_dir -- corresponding to LIBRARY_OUTPUT_DIRECTORY.
+ # It affects output of add_library(MODULE).
+ if(WIN32 OR CYGWIN)
+ # DLL platform
+ set(module_dir ${ARG_BINARY_DIR})
+ else()
+ set(module_dir ${ARG_LIBRARY_DIR})
+ endif()
+ if(NOT "${CMAKE_CFG_INTDIR}" STREQUAL ".")
+ foreach(build_mode ${CMAKE_CONFIGURATION_TYPES})
+ string(TOUPPER "${build_mode}" CONFIG_SUFFIX)
+ if(ARG_BINARY_DIR)
+ string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} bi ${ARG_BINARY_DIR})
+ set_target_properties(${target} PROPERTIES "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${bi})
+ endif()
+ if(ARG_LIBRARY_DIR)
+ string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} li ${ARG_LIBRARY_DIR})
+ set_target_properties(${target} PROPERTIES "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${li})
+ endif()
+ if(module_dir)
+ string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} mi ${module_dir})
+ set_target_properties(${target} PROPERTIES "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${mi})
+ endif()
+ endforeach()
+ else()
+ if(ARG_BINARY_DIR)
+ set_target_properties(${target} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${ARG_BINARY_DIR})
+ endif()
+ if(ARG_LIBRARY_DIR)
+ set_target_properties(${target} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${ARG_LIBRARY_DIR})
+ endif()
+ if(module_dir)
+ set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${module_dir})
+ endif()
+ endif()
+endfunction()
+
+# If on Windows and building with MSVC, add the resource script containing the
+# VERSIONINFO data to the project. This embeds version resource information
+# into the output .exe or .dll.
+# TODO: Enable for MinGW Windows builds too.
+#
+function(add_windows_version_resource_file OUT_VAR)
+ set(sources ${ARGN})
+ if (MSVC AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+ set(resource_file ${LLVM_SOURCE_DIR}/resources/windows_version_resource.rc)
+ if(EXISTS ${resource_file})
+ set(sources ${sources} ${resource_file})
+ source_group("Resource Files" ${resource_file})
+ set(windows_resource_file ${resource_file} PARENT_SCOPE)
+ endif()
+ endif(MSVC AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+
+ set(${OUT_VAR} ${sources} PARENT_SCOPE)
+endfunction(add_windows_version_resource_file)
+
+# set_windows_version_resource_properties(name resource_file...
+# VERSION_MAJOR int
+# Optional major version number (defaults to LLVM_VERSION_MAJOR)
+# VERSION_MINOR int
+# Optional minor version number (defaults to LLVM_VERSION_MINOR)
+# VERSION_PATCHLEVEL int
+# Optional patchlevel version number (defaults to LLVM_VERSION_PATCH)
+# VERSION_STRING
+# Optional version string (defaults to PACKAGE_VERSION)
+# PRODUCT_NAME
+# Optional product name string (defaults to "LLVM")
+# )
+function(set_windows_version_resource_properties name resource_file)
+ cmake_parse_arguments(ARG
+ ""
+ "VERSION_MAJOR;VERSION_MINOR;VERSION_PATCHLEVEL;VERSION_STRING;PRODUCT_NAME"
+ ""
+ ${ARGN})
+
+ if (NOT DEFINED ARG_VERSION_MAJOR)
+ set(ARG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
+ endif()
+
+ if (NOT DEFINED ARG_VERSION_MINOR)
+ set(ARG_VERSION_MINOR ${LLVM_VERSION_MINOR})
+ endif()
+
+ if (NOT DEFINED ARG_VERSION_PATCHLEVEL)
+ set(ARG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
+ endif()
+
+ if (NOT DEFINED ARG_VERSION_STRING)
+ set(ARG_VERSION_STRING ${PACKAGE_VERSION})
+ endif()
+
+ if (NOT DEFINED ARG_PRODUCT_NAME)
+ set(ARG_PRODUCT_NAME "LLVM")
+ endif()
+
+ set_property(SOURCE ${resource_file}
+ PROPERTY COMPILE_FLAGS /nologo)
+ set_property(SOURCE ${resource_file}
+ PROPERTY COMPILE_DEFINITIONS
+ "RC_VERSION_FIELD_1=${ARG_VERSION_MAJOR}"
+ "RC_VERSION_FIELD_2=${ARG_VERSION_MINOR}"
+ "RC_VERSION_FIELD_3=${ARG_VERSION_PATCHLEVEL}"
+ "RC_VERSION_FIELD_4=0"
+ "RC_FILE_VERSION=\"${ARG_VERSION_STRING}\""
+ "RC_INTERNAL_NAME=\"${name}\""
+ "RC_PRODUCT_NAME=\"${ARG_PRODUCT_NAME}\""
+ "RC_PRODUCT_VERSION=\"${ARG_VERSION_STRING}\"")
+endfunction(set_windows_version_resource_properties)
+
+# llvm_add_library(name sources...
+# SHARED;STATIC
+# STATIC by default w/o BUILD_SHARED_LIBS.
+# SHARED by default w/ BUILD_SHARED_LIBS.
+# OBJECT
+# Also create an OBJECT library target. Default if STATIC && SHARED.
+# MODULE
+# Target ${name} might not be created on unsupported platforms.
+# Check with "if(TARGET ${name})".
+# DISABLE_LLVM_LINK_LLVM_DYLIB
+# Do not link this library to libLLVM, even if
+# LLVM_LINK_LLVM_DYLIB is enabled.
+# OUTPUT_NAME name
+# Corresponds to OUTPUT_NAME in target properties.
+# DEPENDS targets...
+# Same semantics as add_dependencies().
+# LINK_COMPONENTS components...
+# Same as the variable LLVM_LINK_COMPONENTS.
+# LINK_LIBS lib_targets...
+# Same semantics as target_link_libraries().
+# ADDITIONAL_HEADERS
+# May specify header files for IDE generators.
+# SONAME
+# Should set SONAME link flags and create symlinks
+# PLUGIN_TOOL
+# The tool (i.e. cmake target) that this plugin will link against
+# )
+function(llvm_add_library name)
+ cmake_parse_arguments(ARG
+ "MODULE;SHARED;STATIC;OBJECT;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME"
+ "OUTPUT_NAME;PLUGIN_TOOL"
+ "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS"
+ ${ARGN})
+ list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
+ if(ARG_ADDITIONAL_HEADERS)
+ # Pass through ADDITIONAL_HEADERS.
+ set(ARG_ADDITIONAL_HEADERS ADDITIONAL_HEADERS ${ARG_ADDITIONAL_HEADERS})
+ endif()
+ if(ARG_OBJLIBS)
+ set(ALL_FILES ${ARG_OBJLIBS})
+ else()
+ llvm_process_sources(ALL_FILES ${ARG_UNPARSED_ARGUMENTS} ${ARG_ADDITIONAL_HEADERS})
+ endif()
+
+ if(ARG_MODULE)
+ if(ARG_SHARED OR ARG_STATIC)
+ message(WARNING "MODULE with SHARED|STATIC doesn't make sense.")
+ endif()
+ # Plugins that link against a tool are allowed even when plugins in general are not
+ if(NOT LLVM_ENABLE_PLUGINS AND NOT (ARG_PLUGIN_TOOL AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS))
+ message(STATUS "${name} ignored -- Loadable modules not supported on this platform.")
+ return()
+ endif()
+ else()
+ if(ARG_PLUGIN_TOOL)
+ message(WARNING "PLUGIN_TOOL without MODULE doesn't make sense.")
+ endif()
+ if(BUILD_SHARED_LIBS AND NOT ARG_STATIC)
+ set(ARG_SHARED TRUE)
+ endif()
+ if(NOT ARG_SHARED)
+ set(ARG_STATIC TRUE)
+ endif()
+ endif()
+
+ # Generate objlib
+ if((ARG_SHARED AND ARG_STATIC) OR ARG_OBJECT)
+ # Generate an obj library for both targets.
+ set(obj_name "obj.${name}")
+ add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL
+ ${ALL_FILES}
+ )
+ llvm_update_compile_flags(${obj_name})
+ set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>")
+
+ # Do add_dependencies(obj) later due to CMake issue 14747.
+ list(APPEND objlibs ${obj_name})
+
+ set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
+ endif()
+
+ if(ARG_SHARED AND ARG_STATIC)
+ # static
+ set(name_static "${name}_static")
+ if(ARG_OUTPUT_NAME)
+ set(output_name OUTPUT_NAME "${ARG_OUTPUT_NAME}")
+ endif()
+ # DEPENDS has been appended to LLVM_COMMON_LIBS.
+ llvm_add_library(${name_static} STATIC
+ ${output_name}
+ OBJLIBS ${ALL_FILES} # objlib
+ LINK_LIBS ${ARG_LINK_LIBS}
+ LINK_COMPONENTS ${ARG_LINK_COMPONENTS}
+ )
+ # FIXME: Add name_static to anywhere in TARGET ${name}'s PROPERTY.
+ set(ARG_STATIC)
+ endif()
+
+ if(ARG_MODULE)
+ add_library(${name} MODULE ${ALL_FILES})
+ llvm_setup_rpath(${name})
+ elseif(ARG_SHARED)
+ add_windows_version_resource_file(ALL_FILES ${ALL_FILES})
+ add_library(${name} SHARED ${ALL_FILES})
+
+ llvm_setup_rpath(${name})
+
+ else()
+ add_library(${name} STATIC ${ALL_FILES})
+ endif()
+
+ setup_dependency_debugging(${name} ${LLVM_COMMON_DEPENDS})
+
+ if(DEFINED windows_resource_file)
+ set_windows_version_resource_properties(${name} ${windows_resource_file})
+ set(windows_resource_file ${windows_resource_file} PARENT_SCOPE)
+ endif()
+
+ set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
+ # $<TARGET_OBJECTS> doesn't require compile flags.
+ if(NOT obj_name)
+ llvm_update_compile_flags(${name})
+ endif()
+ add_link_opts( ${name} )
+ if(ARG_OUTPUT_NAME)
+ set_target_properties(${name}
+ PROPERTIES
+ OUTPUT_NAME ${ARG_OUTPUT_NAME}
+ )
+ endif()
+
+ if(ARG_MODULE)
+ set_target_properties(${name} PROPERTIES
+ PREFIX ""
+ SUFFIX ${LLVM_PLUGIN_EXT}
+ )
+ endif()
+
+ if(ARG_SHARED)
+ if(WIN32)
+ set_target_properties(${name} PROPERTIES
+ PREFIX ""
+ )
+ endif()
+
+ # Set SOVERSION on shared libraries that lack explicit SONAME
+ # specifier, on *nix systems that are not Darwin.
+ if(UNIX AND NOT APPLE AND NOT ARG_SONAME)
+ set_target_properties(${name}
+ PROPERTIES
+ # Since 4.0.0, the ABI version is indicated by the major version
+ SOVERSION ${LLVM_VERSION_MAJOR}
+ VERSION ${LLVM_VERSION_MAJOR}${LLVM_VERSION_SUFFIX})
+ endif()
+ endif()
+
+ if(ARG_MODULE OR ARG_SHARED)
+ # Do not add -Dname_EXPORTS to the command-line when building files in this
+ # target. Doing so is actively harmful for the modules build because it
+ # creates extra module variants, and not useful because we don't use these
+ # macros.
+ set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" )
+
+ if (LLVM_EXPORTED_SYMBOL_FILE)
+ add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} )
+ endif()
+ endif()
+
+ if(ARG_SHARED AND UNIX)
+ if(NOT APPLE AND ARG_SONAME)
+ get_target_property(output_name ${name} OUTPUT_NAME)
+ if(${output_name} STREQUAL "output_name-NOTFOUND")
+ set(output_name ${name})
+ endif()
+ set(library_name ${output_name}-${LLVM_VERSION_MAJOR}${LLVM_VERSION_SUFFIX})
+ set(api_name ${output_name}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX})
+ set_target_properties(${name} PROPERTIES OUTPUT_NAME ${library_name})
+ llvm_install_library_symlink(${api_name} ${library_name} SHARED
+ COMPONENT ${name}
+ ALWAYS_GENERATE)
+ llvm_install_library_symlink(${output_name} ${library_name} SHARED
+ COMPONENT ${name}
+ ALWAYS_GENERATE)
+ endif()
+ endif()
+
+ if(ARG_MODULE AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS AND ARG_PLUGIN_TOOL AND (WIN32 OR CYGWIN))
+ # On DLL platforms symbols are imported from the tool by linking against it.
+ set(llvm_libs ${ARG_PLUGIN_TOOL})
+ elseif (DEFINED LLVM_LINK_COMPONENTS OR DEFINED ARG_LINK_COMPONENTS)
+ if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
+ set(llvm_libs LLVM)
+ else()
+ llvm_map_components_to_libnames(llvm_libs
+ ${ARG_LINK_COMPONENTS}
+ ${LLVM_LINK_COMPONENTS}
+ )
+ endif()
+ else()
+ # Components have not been defined explicitly in CMake, so add the
+ # dependency information for this library as defined by LLVMBuild.
+ #
+ # It would be nice to verify that we have the dependencies for this library
+ # name, but using get_property(... SET) doesn't suffice to determine if a
+ # property has been set to an empty value.
+ get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name})
+ endif()
+
+ if(ARG_STATIC)
+ set(libtype INTERFACE)
+ else()
+ # We can use PRIVATE since SO knows its dependent libs.
+ set(libtype PRIVATE)
+ endif()
+
+ target_link_libraries(${name} ${libtype}
+ ${ARG_LINK_LIBS}
+ ${lib_deps}
+ ${llvm_libs}
+ )
+
+ if(LLVM_COMMON_DEPENDS)
+ add_dependencies(${name} ${LLVM_COMMON_DEPENDS})
+ # Add dependencies also to objlibs.
+ # CMake issue 14747 -- add_dependencies() might be ignored to objlib's user.
+ foreach(objlib ${objlibs})
+ add_dependencies(${objlib} ${LLVM_COMMON_DEPENDS})
+ endforeach()
+ endif()
+
+ if(ARG_SHARED OR ARG_MODULE)
+ llvm_externalize_debuginfo(${name})
+ endif()
+endfunction()
+
+function(add_llvm_install_targets target)
+ cmake_parse_arguments(ARG "" "COMPONENT;PREFIX" "DEPENDS" ${ARGN})
+ if(ARG_COMPONENT)
+ set(component_option -DCMAKE_INSTALL_COMPONENT="${ARG_COMPONENT}")
+ endif()
+ if(ARG_PREFIX)
+ set(prefix_option -DCMAKE_INSTALL_PREFIX="${ARG_PREFIX}")
+ endif()
+
+ add_custom_target(${target}
+ DEPENDS ${ARG_DEPENDS}
+ COMMAND "${CMAKE_COMMAND}"
+ ${component_option}
+ ${prefix_option}
+ -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
+ USES_TERMINAL)
+ add_custom_target(${target}-stripped
+ DEPENDS ${ARG_DEPENDS}
+ COMMAND "${CMAKE_COMMAND}"
+ ${component_option}
+ ${prefix_option}
+ -DCMAKE_INSTALL_DO_STRIP=1
+ -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
+ USES_TERMINAL)
+endfunction()
+
+macro(add_llvm_library name)
+ cmake_parse_arguments(ARG
+ "SHARED;BUILDTREE_ONLY"
+ ""
+ ""
+ ${ARGN})
+ if( BUILD_SHARED_LIBS OR ARG_SHARED )
+ llvm_add_library(${name} SHARED ${ARG_UNPARSED_ARGUMENTS})
+ else()
+ llvm_add_library(${name} ${ARG_UNPARSED_ARGUMENTS})
+ endif()
+
+ # Libraries that are meant to only be exposed via the build tree only are
+ # never installed and are only exported as a target in the special build tree
+ # config file.
+ if (NOT ARG_BUILDTREE_ONLY)
+ set_property( GLOBAL APPEND PROPERTY LLVM_LIBS ${name} )
+ endif()
+
+ if( EXCLUDE_FROM_ALL )
+ set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
+ elseif(ARG_BUILDTREE_ONLY)
+ set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name})
+ else()
+ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO" OR
+ (LLVM_LINK_LLVM_DYLIB AND ${name} STREQUAL "LLVM"))
+ set(install_dir lib${LLVM_LIBDIR_SUFFIX})
+ if(ARG_SHARED OR BUILD_SHARED_LIBS)
+ if(WIN32 OR CYGWIN OR MINGW)
+ set(install_type RUNTIME)
+ set(install_dir bin)
+ else()
+ set(install_type LIBRARY)
+ endif()
+ else()
+ set(install_type ARCHIVE)
+ endif()
+
+ if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+ NOT LLVM_DISTRIBUTION_COMPONENTS)
+ set(export_to_llvmexports EXPORT LLVMExports)
+ set_property(GLOBAL PROPERTY LLVM_HAS_EXPORTS True)
+ endif()
+
+ install(TARGETS ${name}
+ ${export_to_llvmexports}
+ ${install_type} DESTINATION ${install_dir}
+ COMPONENT ${name})
+
+ if (NOT CMAKE_CONFIGURATION_TYPES)
+ add_llvm_install_targets(install-${name}
+ DEPENDS ${name}
+ COMPONENT ${name})
+ endif()
+ endif()
+ set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
+ endif()
+ set_target_properties(${name} PROPERTIES FOLDER "Libraries")
+endmacro(add_llvm_library name)
+
+macro(add_llvm_loadable_module name)
+ llvm_add_library(${name} MODULE ${ARGN})
+ if(NOT TARGET ${name})
+ # Add empty "phony" target
+ add_custom_target(${name})
+ else()
+ if( EXCLUDE_FROM_ALL )
+ set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
+ else()
+ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+ if(WIN32 OR CYGWIN)
+ # DLL platform
+ set(dlldir "bin")
+ else()
+ set(dlldir "lib${LLVM_LIBDIR_SUFFIX}")
+ endif()
+
+ if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+ NOT LLVM_DISTRIBUTION_COMPONENTS)
+ set(export_to_llvmexports EXPORT LLVMExports)
+ set_property(GLOBAL PROPERTY LLVM_HAS_EXPORTS True)
+ endif()
+
+ install(TARGETS ${name}
+ ${export_to_llvmexports}
+ LIBRARY DESTINATION ${dlldir}
+ ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
+ endif()
+ set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
+ endif()
+ endif()
+
+ set_target_properties(${name} PROPERTIES FOLDER "Loadable modules")
+endmacro(add_llvm_loadable_module name)
+
+
+macro(add_llvm_executable name)
+ cmake_parse_arguments(ARG "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO;NO_INSTALL_RPATH" "" "DEPENDS" ${ARGN})
+ llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} )
+
+ list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
+
+ # Generate objlib
+ if(LLVM_ENABLE_OBJLIB)
+ # Generate an obj library for both targets.
+ set(obj_name "obj.${name}")
+ add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL
+ ${ALL_FILES}
+ )
+ llvm_update_compile_flags(${obj_name})
+ set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>")
+
+ set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries")
+ endif()
+
+ add_windows_version_resource_file(ALL_FILES ${ALL_FILES})
+
+ if(XCODE)
+ # Note: the dummy.cpp source file provides no definitions. However,
+ # it forces Xcode to properly link the static library.
+ list(APPEND ALL_FILES "${LLVM_MAIN_SRC_DIR}/cmake/dummy.cpp")
+ endif()
+
+ if( EXCLUDE_FROM_ALL )
+ add_executable(${name} EXCLUDE_FROM_ALL ${ALL_FILES})
+ else()
+ add_executable(${name} ${ALL_FILES})
+ endif()
+
+ setup_dependency_debugging(${name} ${LLVM_COMMON_DEPENDS})
+
+ if(NOT ARG_NO_INSTALL_RPATH)
+ llvm_setup_rpath(${name})
+ endif()
+
+ if(DEFINED windows_resource_file)
+ set_windows_version_resource_properties(${name} ${windows_resource_file})
+ endif()
+
+ # $<TARGET_OBJECTS> doesn't require compile flags.
+ if(NOT LLVM_ENABLE_OBJLIB)
+ llvm_update_compile_flags(${name})
+ endif()
+ add_link_opts( ${name} )
+
+ # Do not add -Dname_EXPORTS to the command-line when building files in this
+ # target. Doing so is actively harmful for the modules build because it
+ # creates extra module variants, and not useful because we don't use these
+ # macros.
+ set_target_properties( ${name} PROPERTIES DEFINE_SYMBOL "" )
+
+ if (LLVM_EXPORTED_SYMBOL_FILE)
+ add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} )
+ endif(LLVM_EXPORTED_SYMBOL_FILE)
+
+ if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
+ set(USE_SHARED USE_SHARED)
+ endif()
+
+ set(EXCLUDE_FROM_ALL OFF)
+ set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
+ llvm_config( ${name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} )
+ if( LLVM_COMMON_DEPENDS )
+ add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} )
+ endif( LLVM_COMMON_DEPENDS )
+
+ if(NOT ARG_IGNORE_EXTERNALIZE_DEBUGINFO)
+ llvm_externalize_debuginfo(${name})
+ endif()
+ if (LLVM_PTHREAD_LIB)
+ # libpthreads overrides some standard library symbols, so main
+ # executable must be linked with it in order to provide consistent
+ # API for all shared libaries loaded by this executable.
+ target_link_libraries(${name} PRIVATE ${LLVM_PTHREAD_LIB})
+ endif()
+endmacro(add_llvm_executable name)
+
+function(export_executable_symbols target)
+ if (LLVM_EXPORTED_SYMBOL_FILE)
+ # The symbol file should contain the symbols we want the executable to
+ # export
+ set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
+ elseif (LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
+ # Extract the symbols to export from the static libraries that the
+ # executable links against.
+ set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
+ set(exported_symbol_file ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${target}.symbols)
+ # We need to consider not just the direct link dependencies, but also the
+ # transitive link dependencies. Do this by starting with the set of direct
+ # dependencies, then the dependencies of those dependencies, and so on.
+ get_target_property(new_libs ${target} LINK_LIBRARIES)
+ set(link_libs ${new_libs})
+ while(NOT "${new_libs}" STREQUAL "")
+ foreach(lib ${new_libs})
+ if(TARGET ${lib})
+ get_target_property(lib_type ${lib} TYPE)
+ if("${lib_type}" STREQUAL "STATIC_LIBRARY")
+ list(APPEND static_libs ${lib})
+ else()
+ list(APPEND other_libs ${lib})
+ endif()
+ get_target_property(transitive_libs ${lib} INTERFACE_LINK_LIBRARIES)
+ foreach(transitive_lib ${transitive_libs})
+ list(FIND link_libs ${transitive_lib} idx)
+ if(TARGET ${transitive_lib} AND idx EQUAL -1)
+ list(APPEND newer_libs ${transitive_lib})
+ list(APPEND link_libs ${transitive_lib})
+ endif()
+ endforeach(transitive_lib)
+ endif()
+ endforeach(lib)
+ set(new_libs ${newer_libs})
+ set(newer_libs "")
+ endwhile()
+ if (MSVC)
+ set(mangling microsoft)
+ else()
+ set(mangling itanium)
+ endif()
+ add_custom_command(OUTPUT ${exported_symbol_file}
+ COMMAND ${PYTHON_EXECUTABLE} ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py --mangling=${mangling} ${static_libs} -o ${exported_symbol_file}
+ WORKING_DIRECTORY ${LLVM_LIBRARY_OUTPUT_INTDIR}
+ DEPENDS ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py ${static_libs}
+ VERBATIM
+ COMMENT "Generating export list for ${target}")
+ add_llvm_symbol_exports( ${target} ${exported_symbol_file} )
+ # If something links against this executable then we want a
+ # transitive link against only the libraries whose symbols
+ # we aren't exporting.
+ set_target_properties(${target} PROPERTIES INTERFACE_LINK_LIBRARIES "${other_libs}")
+ # The default import library suffix that cmake uses for cygwin/mingw is
+ # ".dll.a", but for clang.exe that causes a collision with libclang.dll,
+ # where the import libraries of both get named libclang.dll.a. Use a suffix
+ # of ".exe.a" to avoid this.
+ if(CYGWIN OR MINGW)
+ set_target_properties(${target} PROPERTIES IMPORT_SUFFIX ".exe.a")
+ endif()
+ elseif(NOT (WIN32 OR CYGWIN))
+ # On Windows auto-exporting everything doesn't work because of the limit on
+ # the size of the exported symbol table, but on other platforms we can do
+ # it without any trouble.
+ set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)
+ if (APPLE)
+ set_property(TARGET ${target} APPEND_STRING PROPERTY
+ LINK_FLAGS " -rdynamic")
+ endif()
+ endif()
+endfunction()
+
+if(NOT LLVM_TOOLCHAIN_TOOLS)
+ set (LLVM_TOOLCHAIN_TOOLS
+ llvm-ar
+ llvm-ranlib
+ llvm-lib
+ llvm-objdump
+ )
+endif()
+
+macro(add_llvm_tool name)
+ if( NOT LLVM_BUILD_TOOLS )
+ set(EXCLUDE_FROM_ALL ON)
+ endif()
+ add_llvm_executable(${name} ${ARGN})
+
+ if ( ${name} IN_LIST LLVM_TOOLCHAIN_TOOLS OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+ if( LLVM_BUILD_TOOLS )
+ if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+ NOT LLVM_DISTRIBUTION_COMPONENTS)
+ set(export_to_llvmexports EXPORT LLVMExports)
+ set_property(GLOBAL PROPERTY LLVM_HAS_EXPORTS True)
+ endif()
+
+ install(TARGETS ${name}
+ ${export_to_llvmexports}
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
+ COMPONENT ${name})
+
+ if (NOT CMAKE_CONFIGURATION_TYPES)
+ add_llvm_install_targets(install-${name}
+ DEPENDS ${name}
+ COMPONENT ${name})
+ endif()
+ endif()
+ endif()
+ if( LLVM_BUILD_TOOLS )
+ set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
+ endif()
+ set_target_properties(${name} PROPERTIES FOLDER "Tools")
+endmacro(add_llvm_tool name)
+
+
+macro(add_llvm_example name)
+ if( NOT LLVM_BUILD_EXAMPLES )
+ set(EXCLUDE_FROM_ALL ON)
+ endif()
+ add_llvm_executable(${name} ${ARGN})
+ if( LLVM_BUILD_EXAMPLES )
+ install(TARGETS ${name} RUNTIME DESTINATION examples)
+ endif()
+ set_target_properties(${name} PROPERTIES FOLDER "Examples")
+endmacro(add_llvm_example name)
+
+# This is a macro that is used to create targets for executables that are needed
+# for development, but that are not intended to be installed by default.
+macro(add_llvm_utility name)
+ if ( NOT LLVM_BUILD_UTILS )
+ set(EXCLUDE_FROM_ALL ON)
+ endif()
+
+ add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
+ set_target_properties(${name} PROPERTIES FOLDER "Utils")
+ if( LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS )
+ install (TARGETS ${name}
+ RUNTIME DESTINATION ${LLVM_UTILS_INSTALL_DIR}
+ COMPONENT ${name})
+ if (NOT CMAKE_CONFIGURATION_TYPES)
+ add_llvm_install_targets(install-${name}
+ DEPENDS ${name}
+ COMPONENT ${name})
+ endif()
+ endif()
+endmacro(add_llvm_utility name)
+
+macro(add_llvm_fuzzer name)
+ cmake_parse_arguments(ARG "" "DUMMY_MAIN" "" ${ARGN})
+ if( LLVM_LIB_FUZZING_ENGINE )
+ set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN})
+ add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS})
+ target_link_libraries(${name} PRIVATE ${LLVM_LIB_FUZZING_ENGINE})
+ set_target_properties(${name} PROPERTIES FOLDER "Fuzzers")
+ elseif( LLVM_USE_SANITIZE_COVERAGE )
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer")
+ set(LLVM_OPTIONAL_SOURCES ${ARG_DUMMY_MAIN})
+ add_llvm_executable(${name} ${ARG_UNPARSED_ARGUMENTS})
+ set_target_properties(${name} PROPERTIES FOLDER "Fuzzers")
+ elseif( ARG_DUMMY_MAIN )
+ add_llvm_executable(${name} ${ARG_DUMMY_MAIN} ${ARG_UNPARSED_ARGUMENTS})
+ set_target_properties(${name} PROPERTIES FOLDER "Fuzzers")
+ endif()
+endmacro()
+
+macro(add_llvm_target target_name)
+ include_directories(BEFORE
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR})
+ add_llvm_library(LLVM${target_name} ${ARGN})
+ set( CURRENT_LLVM_TARGET LLVM${target_name} )
+endmacro(add_llvm_target)
+
+function(canonicalize_tool_name name output)
+ string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" nameStrip ${name})
+ string(REPLACE "-" "_" nameUNDERSCORE ${nameStrip})
+ string(TOUPPER ${nameUNDERSCORE} nameUPPER)
+ set(${output} "${nameUPPER}" PARENT_SCOPE)
+endfunction(canonicalize_tool_name)
+
+# Custom add_subdirectory wrapper
+# Takes in a project name (i.e. LLVM), the subdirectory name, and an optional
+# path if it differs from the name.
+macro(add_llvm_subdirectory project type name)
+ set(add_llvm_external_dir "${ARGN}")
+ if("${add_llvm_external_dir}" STREQUAL "")
+ set(add_llvm_external_dir ${name})
+ endif()
+ canonicalize_tool_name(${name} nameUPPER)
+ if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}/CMakeLists.txt)
+ # Treat it as in-tree subproject.
+ option(${project}_${type}_${nameUPPER}_BUILD
+ "Whether to build ${name} as part of ${project}" On)
+ mark_as_advanced(${project}_${type}_${name}_BUILD)
+ if(${project}_${type}_${nameUPPER}_BUILD)
+ add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir} ${add_llvm_external_dir})
+ # Don't process it in add_llvm_implicit_projects().
+ set(${project}_${type}_${nameUPPER}_BUILD OFF)
+ endif()
+ else()
+ set(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR
+ "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}"
+ CACHE PATH "Path to ${name} source directory")
+ set(${project}_${type}_${nameUPPER}_BUILD_DEFAULT ON)
+ if(NOT LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR OR NOT EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR})
+ set(${project}_${type}_${nameUPPER}_BUILD_DEFAULT OFF)
+ endif()
+ if("${LLVM_EXTERNAL_${nameUPPER}_BUILD}" STREQUAL "OFF")
+ set(${project}_${type}_${nameUPPER}_BUILD_DEFAULT OFF)
+ endif()
+ option(${project}_${type}_${nameUPPER}_BUILD
+ "Whether to build ${name} as part of LLVM"
+ ${${project}_${type}_${nameUPPER}_BUILD_DEFAULT})
+ if (${project}_${type}_${nameUPPER}_BUILD)
+ if(EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR})
+ add_subdirectory(${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR} ${add_llvm_external_dir})
+ elseif(NOT "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" STREQUAL "")
+ message(WARNING "Nonexistent directory for ${name}: ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}")
+ endif()
+ # FIXME: It'd be redundant.
+ set(${project}_${type}_${nameUPPER}_BUILD Off)
+ endif()
+ endif()
+endmacro()
+
+# Add external project that may want to be built as part of llvm such as Clang,
+# lld, and Polly. This adds two options. One for the source directory of the
+# project, which defaults to ${CMAKE_CURRENT_SOURCE_DIR}/${name}. Another to
+# enable or disable building it with everything else.
+# Additional parameter can be specified as the name of directory.
+macro(add_llvm_external_project name)
+ add_llvm_subdirectory(LLVM TOOL ${name} ${ARGN})
+endmacro()
+
+macro(add_llvm_tool_subdirectory name)
+ add_llvm_external_project(${name})
+endmacro(add_llvm_tool_subdirectory)
+
+function(get_project_name_from_src_var var output)
+ string(REGEX MATCH "LLVM_EXTERNAL_(.*)_SOURCE_DIR"
+ MACHED_TOOL "${var}")
+ if(MACHED_TOOL)
+ set(${output} ${CMAKE_MATCH_1} PARENT_SCOPE)
+ else()
+ set(${output} PARENT_SCOPE)
+ endif()
+endfunction()
+
+function(create_subdirectory_options project type)
+ file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*")
+ foreach(dir ${sub-dirs})
+ if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt")
+ canonicalize_tool_name(${dir} name)
+ option(${project}_${type}_${name}_BUILD
+ "Whether to build ${name} as part of ${project}" On)
+ mark_as_advanced(${project}_${type}_${name}_BUILD)
+ endif()
+ endforeach()
+endfunction(create_subdirectory_options)
+
+function(create_llvm_tool_options)
+ create_subdirectory_options(LLVM TOOL)
+endfunction(create_llvm_tool_options)
+
+function(llvm_add_implicit_projects project)
+ set(list_of_implicit_subdirs "")
+ file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*")
+ foreach(dir ${sub-dirs})
+ if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt")
+ canonicalize_tool_name(${dir} name)
+ if (${project}_TOOL_${name}_BUILD)
+ get_filename_component(fn "${dir}" NAME)
+ list(APPEND list_of_implicit_subdirs "${fn}")
+ endif()
+ endif()
+ endforeach()
+
+ foreach(external_proj ${list_of_implicit_subdirs})
+ add_llvm_subdirectory(${project} TOOL "${external_proj}" ${ARGN})
+ endforeach()
+endfunction(llvm_add_implicit_projects)
+
+function(add_llvm_implicit_projects)
+ llvm_add_implicit_projects(LLVM)
+endfunction(add_llvm_implicit_projects)
+
+# Generic support for adding a unittest.
+function(add_unittest test_suite test_name)
+ if( NOT LLVM_BUILD_TESTS )
+ set(EXCLUDE_FROM_ALL ON)
+ endif()
+
+ # Our current version of gtest does not properly recognize C++11 support
+ # with MSVC, so it falls back to tr1 / experimental classes. Since LLVM
+ # itself requires C++11, we can safely force it on unconditionally so that
+ # we don't have to fight with the buggy gtest check.
+ add_definitions(-DGTEST_LANG_CXX11=1)
+ add_definitions(-DGTEST_HAS_TR1_TUPLE=0)
+
+ include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include)
+ include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock/include)
+ if (NOT LLVM_ENABLE_THREADS)
+ list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_PTHREAD=0)
+ endif ()
+
+ if (SUPPORTS_VARIADIC_MACROS_FLAG)
+ list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros")
+ endif ()
+ # Some parts of gtest rely on this GNU extension, don't warn on it.
+ if(SUPPORTS_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS_FLAG)
+ list(APPEND LLVM_COMPILE_FLAGS "-Wno-gnu-zero-variadic-macro-arguments")
+ endif()
+
+ set(LLVM_REQUIRES_RTTI OFF)
+
+ list(APPEND LLVM_LINK_COMPONENTS Support) # gtest needs it for raw_ostream
+ add_llvm_executable(${test_name} IGNORE_EXTERNALIZE_DEBUGINFO NO_INSTALL_RPATH ${ARGN})
+ set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
+ set_output_directory(${test_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir})
+ # libpthreads overrides some standard library symbols, so main
+ # executable must be linked with it in order to provide consistent
+ # API for all shared libaries loaded by this executable.
+ target_link_libraries(${test_name} PRIVATE gtest_main gtest ${LLVM_PTHREAD_LIB})
+
+ add_dependencies(${test_suite} ${test_name})
+ get_target_property(test_suite_folder ${test_suite} FOLDER)
+ if (NOT ${test_suite_folder} STREQUAL "NOTFOUND")
+ set_property(TARGET ${test_name} PROPERTY FOLDER "${test_suite_folder}")
+ endif ()
+endfunction()
+
+function(llvm_add_go_executable binary pkgpath)
+ cmake_parse_arguments(ARG "ALL" "" "DEPENDS;GOFLAGS" ${ARGN})
+
+ if(LLVM_BINDINGS MATCHES "go")
+ # FIXME: This should depend only on the libraries Go needs.
+ get_property(llvmlibs GLOBAL PROPERTY LLVM_LIBS)
+ set(binpath ${CMAKE_BINARY_DIR}/bin/${binary}${CMAKE_EXECUTABLE_SUFFIX})
+ set(cc "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
+ set(cxx "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
+ set(cppflags "")
+ get_property(include_dirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
+ foreach(d ${include_dirs})
+ set(cppflags "${cppflags} -I${d}")
+ endforeach(d)
+ set(ldflags "${CMAKE_EXE_LINKER_FLAGS}")
+ add_custom_command(OUTPUT ${binpath}
+ COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" "packages=${LLVM_GO_PACKAGES}"
+ ${ARG_GOFLAGS} build -o ${binpath} ${pkgpath}
+ DEPENDS llvm-config ${CMAKE_BINARY_DIR}/bin/llvm-go${CMAKE_EXECUTABLE_SUFFIX}
+ ${llvmlibs} ${ARG_DEPENDS}
+ COMMENT "Building Go executable ${binary}"
+ VERBATIM)
+ if (ARG_ALL)
+ add_custom_target(${binary} ALL DEPENDS ${binpath})
+ else()
+ add_custom_target(${binary} DEPENDS ${binpath})
+ endif()
+ endif()
+endfunction()
+
+# This function canonicalize the CMake variables passed by names
+# from CMake boolean to 0/1 suitable for passing into Python or C++,
+# in place.
+function(llvm_canonicalize_cmake_booleans)
+ foreach(var ${ARGN})
+ if(${var})
+ set(${var} 1 PARENT_SCOPE)
+ else()
+ set(${var} 0 PARENT_SCOPE)
+ endif()
+ endforeach()
+endfunction(llvm_canonicalize_cmake_booleans)
+
+macro(set_llvm_build_mode)
+ # Configuration-time: See Unit/lit.site.cfg.in
+ if (CMAKE_CFG_INTDIR STREQUAL ".")
+ set(LLVM_BUILD_MODE ".")
+ else ()
+ set(LLVM_BUILD_MODE "%(build_mode)s")
+ endif ()
+endmacro()
+
+# This function provides an automatic way to 'configure'-like generate a file
+# based on a set of common and custom variables, specifically targeting the
+# variables needed for the 'lit.site.cfg' files. This function bundles the
+# common variables that any Lit instance is likely to need, and custom
+# variables can be passed in.
+function(configure_lit_site_cfg site_in site_out)
+ cmake_parse_arguments(ARG "" "" "MAIN_CONFIG;OUTPUT_MAPPING" ${ARGN})
+
+ if ("${ARG_MAIN_CONFIG}" STREQUAL "")
+ get_filename_component(INPUT_DIR ${site_in} DIRECTORY)
+ set(ARG_MAIN_CONFIG "${INPUT_DIR}/lit.cfg")
+ endif()
+ if ("${ARG_OUTPUT_MAPPING}" STREQUAL "")
+ set(ARG_OUTPUT_MAPPING "${site_out}")
+ endif()
+
+ foreach(c ${LLVM_TARGETS_TO_BUILD})
+ set(TARGETS_BUILT "${TARGETS_BUILT} ${c}")
+ endforeach(c)
+ set(TARGETS_TO_BUILD ${TARGETS_BUILT})
+
+ set(SHLIBEXT "${LTDL_SHLIB_EXT}")
+
+ set_llvm_build_mode()
+
+ # They below might not be the build tree but provided binary tree.
+ set(LLVM_SOURCE_DIR ${LLVM_MAIN_SRC_DIR})
+ set(LLVM_BINARY_DIR ${LLVM_BINARY_DIR})
+ string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLVM_TOOLS_DIR "${LLVM_TOOLS_BINARY_DIR}")
+ string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLVM_LIBS_DIR "${LLVM_LIBRARY_DIR}")
+
+ # SHLIBDIR points the build tree.
+ string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" SHLIBDIR "${LLVM_SHLIB_OUTPUT_INTDIR}")
+
+ set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
+ # FIXME: "ENABLE_SHARED" doesn't make sense, since it is used just for
+ # plugins. We may rename it.
+ if(LLVM_ENABLE_PLUGINS)
+ set(ENABLE_SHARED "1")
+ else()
+ set(ENABLE_SHARED "0")
+ endif()
+
+ if(LLVM_ENABLE_ASSERTIONS AND NOT MSVC_IDE)
+ set(ENABLE_ASSERTIONS "1")
+ else()
+ set(ENABLE_ASSERTIONS "0")
+ endif()
+
+ set(HOST_OS ${CMAKE_SYSTEM_NAME})
+ set(HOST_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+
+ set(HOST_CC "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
+ set(HOST_CXX "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
+ set(HOST_LDFLAGS "${CMAKE_EXE_LINKER_FLAGS}")
+
+ set(LIT_SITE_CFG_IN_HEADER "## Autogenerated from ${site_in}\n## Do not edit!")
+
+ # Override config_target_triple (and the env)
+ if(LLVM_TARGET_TRIPLE_ENV)
+ # This is expanded into the heading.
+ string(CONCAT LIT_SITE_CFG_IN_HEADER "${LIT_SITE_CFG_IN_HEADER}\n\n"
+ "import os\n"
+ "target_env = \"${LLVM_TARGET_TRIPLE_ENV}\"\n"
+ "config.target_triple = config.environment[target_env] = os.environ.get(target_env, \"${TARGET_TRIPLE}\")\n"
+ )
+
+ # This is expanded to; config.target_triple = ""+config.target_triple+""
+ set(TARGET_TRIPLE "\"+config.target_triple+\"")
+ endif()
+
+ string(CONCAT LIT_SITE_CFG_IN_FOOTER
+ "import lit.llvm\n"
+ "lit.llvm.initialize(lit_config, config)\n")
+
+ configure_file(${site_in} ${site_out} @ONLY)
+ if (EXISTS "${ARG_MAIN_CONFIG}")
+ set(PYTHON_STATEMENT "map_config('${ARG_MAIN_CONFIG}', '${site_out}')")
+ get_property(LLVM_LIT_CONFIG_MAP GLOBAL PROPERTY LLVM_LIT_CONFIG_MAP)
+ set(LLVM_LIT_CONFIG_MAP "${LLVM_LIT_CONFIG_MAP}\n${PYTHON_STATEMENT}")
+ set_property(GLOBAL PROPERTY LLVM_LIT_CONFIG_MAP ${LLVM_LIT_CONFIG_MAP})
+ endif()
+endfunction()
+
+function(dump_all_cmake_variables)
+ get_cmake_property(_variableNames VARIABLES)
+ foreach (_variableName ${_variableNames})
+ message(STATUS "${_variableName}=${${_variableName}}")
+ endforeach()
+endfunction()
+
+function(get_llvm_lit_path base_dir file_name)
+ cmake_parse_arguments(ARG "ALLOW_EXTERNAL" "" "" ${ARGN})
+
+ if (ARG_ALLOW_EXTERNAL)
+ set(LLVM_DEFAULT_EXTERNAL_LIT "${LLVM_EXTERNAL_LIT}")
+ set (LLVM_EXTERNAL_LIT "" CACHE STRING "Command used to spawn lit")
+ if ("${LLVM_EXTERNAL_LIT}" STREQUAL "")
+ set(LLVM_EXTERNAL_LIT "${LLVM_DEFAULT_EXTERNAL_LIT}")
+ endif()
+
+ if (NOT "${LLVM_EXTERNAL_LIT}" STREQUAL "")
+ if (EXISTS ${LLVM_EXTERNAL_LIT})
+ get_filename_component(LIT_FILE_NAME ${LLVM_EXTERNAL_LIT} NAME)
+ get_filename_component(LIT_BASE_DIR ${LLVM_EXTERNAL_LIT} DIRECTORY)
+ set(${file_name} ${LIT_FILE_NAME} PARENT_SCOPE)
+ set(${base_dir} ${LIT_BASE_DIR} PARENT_SCOPE)
+ return()
+ else()
+ message(WARN "LLVM_EXTERNAL_LIT set to ${LLVM_EXTERNAL_LIT}, but the path does not exist.")
+ endif()
+ endif()
+ endif()
+
+ set(lit_file_name "llvm-lit")
+ if (WIN32 AND NOT CYGWIN)
+ # llvm-lit needs suffix.py for multiprocess to find a main module.
+ set(lit_file_name "${lit_file_name}.py")
+ endif ()
+ set(${file_name} ${lit_file_name} PARENT_SCOPE)
+
+ get_property(LLVM_LIT_BASE_DIR GLOBAL PROPERTY LLVM_LIT_BASE_DIR)
+ if (NOT "${LLVM_LIT_BASE_DIR}" STREQUAL "")
+ set(${base_dir} ${LLVM_LIT_BASE_DIR} PARENT_SCOPE)
+ endif()
+
+ # Allow individual projects to provide an override
+ if (NOT "${LLVM_LIT_OUTPUT_DIR}" STREQUAL "")
+ set(LLVM_LIT_BASE_DIR ${LLVM_LIT_OUTPUT_DIR})
+ elseif(NOT "${LLVM_RUNTIME_OUTPUT_INTDIR}" STREQUAL "")
+ set(LLVM_LIT_BASE_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
+ else()
+ set(LLVM_LIT_BASE_DIR "")
+ endif()
+
+ # Cache this so we don't have to do it again and have subsequent calls
+ # potentially disagree on the value.
+ set_property(GLOBAL PROPERTY LLVM_LIT_BASE_DIR ${LLVM_LIT_BASE_DIR})
+ set(${base_dir} ${LLVM_LIT_BASE_DIR} PARENT_SCOPE)
+endfunction()
+
+# A raw function to create a lit target. This is used to implement the testuite
+# management functions.
+function(add_lit_target target comment)
+ cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
+ set(LIT_ARGS "${ARG_ARGS} ${LLVM_LIT_ARGS}")
+ separate_arguments(LIT_ARGS)
+ if (NOT CMAKE_CFG_INTDIR STREQUAL ".")
+ list(APPEND LIT_ARGS --param build_mode=${CMAKE_CFG_INTDIR})
+ endif ()
+
+ # Get the path to the lit to *run* tests with. This can be overriden by
+ # the user by specifying -DLLVM_EXTERNAL_LIT=<path-to-lit.py>
+ get_llvm_lit_path(
+ lit_base_dir
+ lit_file_name
+ ALLOW_EXTERNAL
+ )
+
+ set(LIT_COMMAND "${PYTHON_EXECUTABLE};${lit_base_dir}/${lit_file_name}")
+ list(APPEND LIT_COMMAND ${LIT_ARGS})
+ foreach(param ${ARG_PARAMS})
+ list(APPEND LIT_COMMAND --param ${param})
+ endforeach()
+ if (ARG_UNPARSED_ARGUMENTS)
+ add_custom_target(${target}
+ COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS}
+ COMMENT "${comment}"
+ USES_TERMINAL
+ )
+ else()
+ add_custom_target(${target}
+ COMMAND ${CMAKE_COMMAND} -E echo "${target} does nothing, no tools built.")
+ message(STATUS "${target} does nothing.")
+ endif()
+ if (ARG_DEPENDS)
+ add_dependencies(${target} ${ARG_DEPENDS})
+ endif()
+
+ # Tests should be excluded from "Build Solution".
+ set_target_properties(${target} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
+endfunction()
+
+# A function to add a set of lit test suites to be driven through 'check-*' targets.
+function(add_lit_testsuite target comment)
+ cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
+
+ # EXCLUDE_FROM_ALL excludes the test ${target} out of check-all.
+ if(NOT EXCLUDE_FROM_ALL)
+ # Register the testsuites, params and depends for the global check rule.
+ set_property(GLOBAL APPEND PROPERTY LLVM_LIT_TESTSUITES ${ARG_UNPARSED_ARGUMENTS})
+ set_property(GLOBAL APPEND PROPERTY LLVM_LIT_PARAMS ${ARG_PARAMS})
+ set_property(GLOBAL APPEND PROPERTY LLVM_LIT_DEPENDS ${ARG_DEPENDS})
+ set_property(GLOBAL APPEND PROPERTY LLVM_LIT_EXTRA_ARGS ${ARG_ARGS})
+ endif()
+
+ # Produce a specific suffixed check rule.
+ add_lit_target(${target} ${comment}
+ ${ARG_UNPARSED_ARGUMENTS}
+ PARAMS ${ARG_PARAMS}
+ DEPENDS ${ARG_DEPENDS}
+ ARGS ${ARG_ARGS}
+ )
+endfunction()
+
+function(add_lit_testsuites project directory)
+ if (NOT CMAKE_CONFIGURATION_TYPES)
+ cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
+
+ # Search recursively for test directories by assuming anything not
+ # in a directory called Inputs contains tests.
+ file(GLOB_RECURSE to_process LIST_DIRECTORIES true ${directory}/*)
+ foreach(lit_suite ${to_process})
+ if(NOT IS_DIRECTORY ${lit_suite})
+ continue()
+ endif()
+ string(FIND ${lit_suite} Inputs is_inputs)
+ string(FIND ${lit_suite} Output is_output)
+ if (NOT (is_inputs EQUAL -1 AND is_output EQUAL -1))
+ continue()
+ endif()
+
+ # Create a check- target for the directory.
+ string(REPLACE ${directory} "" name_slash ${lit_suite})
+ if (name_slash)
+ string(REPLACE "/" "-" name_slash ${name_slash})
+ string(REPLACE "\\" "-" name_dashes ${name_slash})
+ string(TOLOWER "${project}${name_dashes}" name_var)
+ add_lit_target("check-${name_var}" "Running lit suite ${lit_suite}"
+ ${lit_suite}
+ PARAMS ${ARG_PARAMS}
+ DEPENDS ${ARG_DEPENDS}
+ ARGS ${ARG_ARGS}
+ )
+ endif()
+ endforeach()
+ endif()
+endfunction()
+
+function(llvm_install_library_symlink name dest type)
+ cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
+ foreach(path ${CMAKE_MODULE_PATH})
+ if(EXISTS ${path}/LLVMInstallSymlink.cmake)
+ set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
+ break()
+ endif()
+ endforeach()
+
+ set(component ${ARG_COMPONENT})
+ if(NOT component)
+ set(component ${name})
+ endif()
+
+ set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX})
+ set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX})
+
+ set(output_dir lib${LLVM_LIBDIR_SUFFIX})
+ if(WIN32 AND "${type}" STREQUAL "SHARED")
+ set(output_dir bin)
+ endif()
+
+ install(SCRIPT ${INSTALL_SYMLINK}
+ CODE "install_symlink(${full_name} ${full_dest} ${output_dir})"
+ COMPONENT ${component})
+
+ if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
+ add_llvm_install_targets(install-${name}
+ DEPENDS ${name} ${dest} install-${dest}
+ COMPONENT ${name})
+ endif()
+endfunction()
+
+function(llvm_install_symlink name dest)
+ cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
+ foreach(path ${CMAKE_MODULE_PATH})
+ if(EXISTS ${path}/LLVMInstallSymlink.cmake)
+ set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
+ break()
+ endif()
+ endforeach()
+
+ if(ARG_COMPONENT)
+ set(component ${ARG_COMPONENT})
+ else()
+ if(ARG_ALWAYS_GENERATE)
+ set(component ${dest})
+ else()
+ set(component ${name})
+ endif()
+ endif()
+
+ set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
+ set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
+
+ install(SCRIPT ${INSTALL_SYMLINK}
+ CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
+ COMPONENT ${component})
+
+ if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
+ add_llvm_install_targets(install-${name}
+ DEPENDS ${name} ${dest} install-${dest}
+ COMPONENT ${name})
+ endif()
+endfunction()
+
+function(add_llvm_tool_symlink link_name target)
+ cmake_parse_arguments(ARG "ALWAYS_GENERATE" "OUTPUT_DIR" "" ${ARGN})
+ set(dest_binary "$<TARGET_FILE:${target}>")
+
+ # This got a bit gross... For multi-configuration generators the target
+ # properties return the resolved value of the string, not the build system
+ # expression. To reconstruct the platform-agnostic path we have to do some
+ # magic. First we grab one of the types, and a type-specific path. Then from
+ # the type-specific path we find the last occurrence of the type in the path,
+ # and replace it with CMAKE_CFG_INTDIR. This allows the build step to be type
+ # agnostic again.
+ if(NOT ARG_OUTPUT_DIR)
+ # If you're not overriding the OUTPUT_DIR, we can make the link relative in
+ # the same directory.
+ if(CMAKE_HOST_UNIX)
+ set(dest_binary "$<TARGET_FILE_NAME:${target}>")
+ endif()
+ if(CMAKE_CONFIGURATION_TYPES)
+ list(GET CMAKE_CONFIGURATION_TYPES 0 first_type)
+ string(TOUPPER ${first_type} first_type_upper)
+ set(first_type_suffix _${first_type_upper})
+ endif()
+ get_target_property(target_type ${target} TYPE)
+ if(${target_type} STREQUAL "STATIC_LIBRARY")
+ get_target_property(ARG_OUTPUT_DIR ${target} ARCHIVE_OUTPUT_DIRECTORY${first_type_suffix})
+ elseif(UNIX AND ${target_type} STREQUAL "SHARED_LIBRARY")
+ get_target_property(ARG_OUTPUT_DIR ${target} LIBRARY_OUTPUT_DIRECTORY${first_type_suffix})
+ else()
+ get_target_property(ARG_OUTPUT_DIR ${target} RUNTIME_OUTPUT_DIRECTORY${first_type_suffix})
+ endif()
+ if(CMAKE_CONFIGURATION_TYPES)
+ string(FIND "${ARG_OUTPUT_DIR}" "/${first_type}/" type_start REVERSE)
+ string(SUBSTRING "${ARG_OUTPUT_DIR}" 0 ${type_start} path_prefix)
+ string(SUBSTRING "${ARG_OUTPUT_DIR}" ${type_start} -1 path_suffix)
+ string(REPLACE "/${first_type}/" "/${CMAKE_CFG_INTDIR}/"
+ path_suffix ${path_suffix})
+ set(ARG_OUTPUT_DIR ${path_prefix}${path_suffix})
+ endif()
+ endif()
+
+ if(CMAKE_HOST_UNIX)
+ set(LLVM_LINK_OR_COPY create_symlink)
+ else()
+ set(LLVM_LINK_OR_COPY copy)
+ endif()
+
+ set(output_path "${ARG_OUTPUT_DIR}/${link_name}${CMAKE_EXECUTABLE_SUFFIX}")
+
+ set(target_name ${link_name})
+ if(TARGET ${link_name})
+ set(target_name ${link_name}-link)
+ endif()
+
+
+ if(ARG_ALWAYS_GENERATE)
+ set_property(DIRECTORY APPEND PROPERTY
+ ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary})
+ add_custom_command(TARGET ${target} POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}")
+ else()
+ add_custom_command(OUTPUT ${output_path}
+ COMMAND ${CMAKE_COMMAND} -E ${LLVM_LINK_OR_COPY} "${dest_binary}" "${output_path}"
+ DEPENDS ${target})
+ add_custom_target(${target_name} ALL DEPENDS ${target} ${output_path})
+ set_target_properties(${target_name} PROPERTIES FOLDER Tools)
+
+ # Make sure both the link and target are toolchain tools
+ if (${link_name} IN_LIST LLVM_TOOLCHAIN_TOOLS AND ${target} IN_LIST LLVM_TOOLCHAIN_TOOLS)
+ set(TOOL_IS_TOOLCHAIN ON)
+ endif()
+
+ if ((TOOL_IS_TOOLCHAIN OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) AND LLVM_BUILD_TOOLS)
+ llvm_install_symlink(${link_name} ${target})
+ endif()
+ endif()
+endfunction()
+
+function(llvm_externalize_debuginfo name)
+ if(NOT LLVM_EXTERNALIZE_DEBUGINFO)
+ return()
+ endif()
+
+ if(NOT LLVM_EXTERNALIZE_DEBUGINFO_SKIP_STRIP)
+ if(APPLE)
+ set(strip_command COMMAND xcrun strip -Sxl $<TARGET_FILE:${name}>)
+ else()
+ set(strip_command COMMAND strip -gx $<TARGET_FILE:${name}>)
+ endif()
+ endif()
+
+ if(APPLE)
+ if(CMAKE_CXX_FLAGS MATCHES "-flto"
+ OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
+
+ set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o)
+ set_property(TARGET ${name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-object_path_lto,${lto_object}")
+ endif()
+ add_custom_command(TARGET ${name} POST_BUILD
+ COMMAND xcrun dsymutil $<TARGET_FILE:${name}>
+ ${strip_command}
+ )
+ else()
+ add_custom_command(TARGET ${name} POST_BUILD
+ COMMAND objcopy --only-keep-debug $<TARGET_FILE:${name}> $<TARGET_FILE:${name}>.debug
+ ${strip_command} -R .gnu_debuglink
+ COMMAND objcopy --add-gnu-debuglink=$<TARGET_FILE:${name}>.debug $<TARGET_FILE:${name}>
+ )
+ endif()
+endfunction()
+
+function(llvm_setup_rpath name)
+ if(CMAKE_INSTALL_RPATH)
+ return()
+ endif()
+
+ if(LLVM_INSTALL_PREFIX AND NOT (LLVM_INSTALL_PREFIX STREQUAL CMAKE_INSTALL_PREFIX))
+ set(extra_libdir ${LLVM_LIBRARY_DIR})
+ elseif(LLVM_BUILD_LIBRARY_DIR)
+ set(extra_libdir ${LLVM_LIBRARY_DIR})
+ endif()
+
+ if (APPLE)
+ set(_install_name_dir INSTALL_NAME_DIR "@rpath")
+ set(_install_rpath "@loader_path/../lib" ${extra_libdir})
+ elseif(UNIX)
+ set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
+ if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
+ set_property(TARGET ${name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-z,origin ")
+ endif()
+ if(LLVM_LINKER_IS_GNULD)
+ # $ORIGIN is not interpreted at link time by ld.bfd
+ set_property(TARGET ${name} APPEND_STRING PROPERTY
+ LINK_FLAGS " -Wl,-rpath-link,${LLVM_LIBRARY_OUTPUT_INTDIR} ")
+ endif()
+ else()
+ return()
+ endif()
+
+ set_target_properties(${name} PROPERTIES
+ BUILD_WITH_INSTALL_RPATH On
+ INSTALL_RPATH "${_install_rpath}"
+ ${_install_name_dir})
+endfunction()
+
+function(setup_dependency_debugging name)
+ if(NOT LLVM_DEPENDENCY_DEBUGGING)
+ return()
+ endif()
+
+ if("intrinsics_gen" IN_LIST ARGN)
+ return()
+ endif()
+
+ set(deny_attributes_gen "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Attributes.gen\"))")
+ set(deny_intrinsics_gen "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Intrinsics.gen\"))")
+
+ set(sandbox_command "sandbox-exec -p '(version 1) (allow default) ${deny_attributes_gen} ${deny_intrinsics_gen}'")
+ set_target_properties(${name} PROPERTIES RULE_LAUNCH_COMPILE ${sandbox_command})
+endfunction()
+
+# Figure out if we can track VC revisions.
+function(find_first_existing_file out_var)
+ foreach(file ${ARGN})
+ if(EXISTS "${file}")
+ set(${out_var} "${file}" PARENT_SCOPE)
+ return()
+ endif()
+ endforeach()
+endfunction()
+
+macro(find_first_existing_vc_file out_var path)
+ find_program(git_executable NAMES git git.exe git.cmd)
+ # Run from a subdirectory to force git to print an absolute path.
+ execute_process(COMMAND ${git_executable} rev-parse --git-dir
+ WORKING_DIRECTORY ${path}/cmake
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_dir
+ ERROR_QUIET)
+ if(git_result EQUAL 0)
+ string(STRIP "${git_dir}" git_dir)
+ set(${out_var} "${git_dir}/logs/HEAD")
+ # some branchless cases (e.g. 'repo') may not yet have .git/logs/HEAD
+ if (NOT EXISTS "${git_dir}/logs/HEAD")
+ file(WRITE "${git_dir}/logs/HEAD" "")
+ endif()
+ else()
+ find_first_existing_file(${out_var}
+ "${path}/.svn/wc.db" # SVN 1.7
+ "${path}/.svn/entries" # SVN 1.6
+ )
+ endif()
+endmacro()
diff --git a/linux-x64/clang/lib64/cmake/llvm/AddLLVMDefinitions.cmake b/linux-x64/clang/lib64/cmake/llvm/AddLLVMDefinitions.cmake
new file mode 100644
index 0000000..dab1623
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/AddLLVMDefinitions.cmake
@@ -0,0 +1,17 @@
+# There is no clear way of keeping track of compiler command-line
+# options chosen via `add_definitions', so we need our own method for
+# using it on tools/llvm-config/CMakeLists.txt.
+
+# Beware that there is no implementation of remove_llvm_definitions.
+
+macro(add_llvm_definitions)
+ # We don't want no semicolons on LLVM_DEFINITIONS:
+ foreach(arg ${ARGN})
+ if(DEFINED LLVM_DEFINITIONS)
+ set(LLVM_DEFINITIONS "${LLVM_DEFINITIONS} ${arg}")
+ else()
+ set(LLVM_DEFINITIONS ${arg})
+ endif()
+ endforeach(arg)
+ add_definitions( ${ARGN} )
+endmacro(add_llvm_definitions)
diff --git a/linux-x64/clang/lib64/cmake/llvm/AddOCaml.cmake b/linux-x64/clang/lib64/cmake/llvm/AddOCaml.cmake
new file mode 100644
index 0000000..02bab68
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/AddOCaml.cmake
@@ -0,0 +1,224 @@
+# CMake build rules for the OCaml language.
+# Assumes FindOCaml is used.
+# http://ocaml.org/
+#
+# Example usage:
+#
+# add_ocaml_library(pkg_a OCAML mod_a OCAMLDEP pkg_b C mod_a_stubs PKG ctypes LLVM core)
+#
+# Unnamed parameters:
+#
+# * Library name.
+#
+# Named parameters:
+#
+# OCAML OCaml module names. Imply presence of a corresponding .ml and .mli files.
+# OCAMLDEP Names of libraries this library depends on.
+# C C stub sources. Imply presence of a corresponding .c file.
+# CFLAGS Additional arguments passed when compiling C stubs.
+# PKG Names of ocamlfind packages this library depends on.
+# LLVM Names of LLVM libraries this library depends on.
+# NOCOPY Do not automatically copy sources (.c, .ml, .mli) from the source directory,
+# e.g. if they are generated.
+#
+
+function(add_ocaml_library name)
+ CMAKE_PARSE_ARGUMENTS(ARG "NOCOPY" "" "OCAML;OCAMLDEP;C;CFLAGS;PKG;LLVM" ${ARGN})
+
+ set(src ${CMAKE_CURRENT_SOURCE_DIR})
+ set(bin ${CMAKE_CURRENT_BINARY_DIR})
+
+ set(ocaml_pkgs)
+ foreach( ocaml_pkg ${ARG_PKG} )
+ list(APPEND ocaml_pkgs "-package" "${ocaml_pkg}")
+ endforeach()
+
+ set(sources)
+
+ set(ocaml_inputs)
+
+ set(ocaml_outputs "${bin}/${name}.cma")
+ if( ARG_C )
+ list(APPEND ocaml_outputs
+ "${bin}/lib${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+ if ( BUILD_SHARED_LIBS )
+ list(APPEND ocaml_outputs
+ "${bin}/dll${name}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+ endif()
+ endif()
+ if( HAVE_OCAMLOPT )
+ list(APPEND ocaml_outputs
+ "${bin}/${name}.cmxa"
+ "${bin}/${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+ endif()
+
+ set(ocaml_flags "-lstdc++" "-ldopt" "-L${LLVM_LIBRARY_DIR}"
+ "-ccopt" "-L\\$CAMLORIGIN/../.."
+ "-ccopt" "-Wl,-rpath,\\$CAMLORIGIN/../.."
+ ${ocaml_pkgs})
+
+ foreach( ocaml_dep ${ARG_OCAMLDEP} )
+ get_target_property(dep_ocaml_flags "ocaml_${ocaml_dep}" OCAML_FLAGS)
+ list(APPEND ocaml_flags ${dep_ocaml_flags})
+ endforeach()
+
+ if( NOT BUILD_SHARED_LIBS )
+ list(APPEND ocaml_flags "-custom")
+ endif()
+
+ explicit_map_components_to_libraries(llvm_libs ${ARG_LLVM})
+ foreach( llvm_lib ${llvm_libs} )
+ list(APPEND ocaml_flags "-l${llvm_lib}" )
+ endforeach()
+
+ get_property(system_libs TARGET LLVMSupport PROPERTY LLVM_SYSTEM_LIBS)
+ foreach(system_lib ${system_libs})
+ if (system_lib MATCHES "^-")
+ # If it's an option, pass it without changes.
+ list(APPEND ocaml_flags "${system_lib}" )
+ else()
+ # Otherwise assume it's a library name we need to link with.
+ list(APPEND ocaml_flags "-l${system_lib}" )
+ endif()
+ endforeach()
+
+ string(REPLACE ";" " " ARG_CFLAGS "${ARG_CFLAGS}")
+ set(c_flags "${ARG_CFLAGS} ${LLVM_DEFINITIONS}")
+ foreach( include_dir ${LLVM_INCLUDE_DIR} ${LLVM_MAIN_INCLUDE_DIR} )
+ set(c_flags "${c_flags} -I${include_dir}")
+ endforeach()
+ # include -D/-UNDEBUG to match dump function visibility
+ # regex from HandleLLVMOptions.cmake
+ string(REGEX MATCH "(^| )[/-][UD] *NDEBUG($| )" flag_matches
+ "${CMAKE_C_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${CMAKE_C_FLAGS}")
+ set(c_flags "${c_flags} ${flag_matches}")
+
+ foreach( ocaml_file ${ARG_OCAML} )
+ list(APPEND sources "${ocaml_file}.mli" "${ocaml_file}.ml")
+
+ list(APPEND ocaml_inputs "${bin}/${ocaml_file}.mli" "${bin}/${ocaml_file}.ml")
+
+ list(APPEND ocaml_outputs "${bin}/${ocaml_file}.cmi" "${bin}/${ocaml_file}.cmo")
+ if( HAVE_OCAMLOPT )
+ list(APPEND ocaml_outputs
+ "${bin}/${ocaml_file}.cmx"
+ "${bin}/${ocaml_file}${CMAKE_C_OUTPUT_EXTENSION}")
+ endif()
+ endforeach()
+
+ foreach( c_file ${ARG_C} )
+ list(APPEND sources "${c_file}.c")
+
+ list(APPEND c_inputs "${bin}/${c_file}.c")
+ list(APPEND c_outputs "${bin}/${c_file}${CMAKE_C_OUTPUT_EXTENSION}")
+ endforeach()
+
+ if( NOT ARG_NOCOPY )
+ foreach( source ${sources} )
+ add_custom_command(
+ OUTPUT "${bin}/${source}"
+ COMMAND "${CMAKE_COMMAND}" "-E" "copy" "${src}/${source}" "${bin}"
+ DEPENDS "${src}/${source}"
+ COMMENT "Copying ${source} to build area")
+ endforeach()
+ endif()
+
+ foreach( c_input ${c_inputs} )
+ get_filename_component(basename "${c_input}" NAME_WE)
+ add_custom_command(
+ OUTPUT "${basename}${CMAKE_C_OUTPUT_EXTENSION}"
+ COMMAND "${OCAMLFIND}" "ocamlc" "-c" "${c_input}" -ccopt ${c_flags}
+ DEPENDS "${c_input}"
+ COMMENT "Building OCaml stub object file ${basename}${CMAKE_C_OUTPUT_EXTENSION}"
+ VERBATIM)
+ endforeach()
+
+ set(ocaml_params)
+ foreach( ocaml_input ${ocaml_inputs} ${c_outputs})
+ get_filename_component(filename "${ocaml_input}" NAME)
+ list(APPEND ocaml_params "${filename}")
+ endforeach()
+
+ if( APPLE )
+ set(ocaml_rpath "@executable_path/../../../lib${LLVM_LIBDIR_SUFFIX}")
+ elseif( UNIX )
+ set(ocaml_rpath "\\$ORIGIN/../../../lib${LLVM_LIBDIR_SUFFIX}")
+ endif()
+ list(APPEND ocaml_flags "-ldopt" "-Wl,-rpath,${ocaml_rpath}")
+
+ add_custom_command(
+ OUTPUT ${ocaml_outputs}
+ COMMAND "${OCAMLFIND}" "ocamlmklib" "-o" "${name}" ${ocaml_flags} ${ocaml_params}
+ DEPENDS ${ocaml_inputs} ${c_outputs}
+ COMMENT "Building OCaml library ${name}"
+ VERBATIM)
+
+ add_custom_command(
+ OUTPUT "${bin}/${name}.odoc"
+ COMMAND "${OCAMLFIND}" "ocamldoc"
+ "-I" "${bin}"
+ "-I" "${LLVM_LIBRARY_DIR}/ocaml/llvm/"
+ "-dump" "${bin}/${name}.odoc"
+ ${ocaml_pkgs} ${ocaml_inputs}
+ DEPENDS ${ocaml_inputs} ${ocaml_outputs}
+ COMMENT "Building OCaml documentation for ${name}"
+ VERBATIM)
+
+ add_custom_target("ocaml_${name}" ALL DEPENDS ${ocaml_outputs} "${bin}/${name}.odoc")
+
+ set_target_properties("ocaml_${name}" PROPERTIES
+ OCAML_FLAGS "-I;${bin}")
+ set_target_properties("ocaml_${name}" PROPERTIES
+ OCAML_ODOC "${bin}/${name}.odoc")
+
+ foreach( ocaml_dep ${ARG_OCAMLDEP} )
+ add_dependencies("ocaml_${name}" "ocaml_${ocaml_dep}")
+ endforeach()
+
+ if( NOT LLVM_OCAML_OUT_OF_TREE )
+ foreach( llvm_lib ${llvm_libs} )
+ add_dependencies("ocaml_${name}" "${llvm_lib}")
+ endforeach()
+ endif()
+
+ add_dependencies("ocaml_all" "ocaml_${name}")
+
+ set(install_files)
+ set(install_shlibs)
+ foreach( ocaml_output ${ocaml_inputs} ${ocaml_outputs} )
+ get_filename_component(ext "${ocaml_output}" EXT)
+
+ if( NOT (ext STREQUAL ".cmo" OR
+ ext STREQUAL ".ml" OR
+ ext STREQUAL CMAKE_C_OUTPUT_EXTENSION OR
+ ext STREQUAL CMAKE_SHARED_LIBRARY_SUFFIX) )
+ list(APPEND install_files "${ocaml_output}")
+ elseif( ext STREQUAL CMAKE_SHARED_LIBRARY_SUFFIX)
+ list(APPEND install_shlibs "${ocaml_output}")
+ endif()
+ endforeach()
+
+ install(FILES ${install_files}
+ DESTINATION "${LLVM_OCAML_INSTALL_PATH}/llvm")
+ install(FILES ${install_shlibs}
+ PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
+ GROUP_READ GROUP_EXECUTE
+ WORLD_READ WORLD_EXECUTE
+ DESTINATION "${LLVM_OCAML_INSTALL_PATH}/stublibs")
+
+ foreach( install_file ${install_files} ${install_shlibs} )
+ get_filename_component(filename "${install_file}" NAME)
+ add_custom_command(TARGET "ocaml_${name}" POST_BUILD
+ COMMAND "${CMAKE_COMMAND}" "-E" "copy" "${install_file}"
+ "${LLVM_LIBRARY_DIR}/ocaml/llvm/"
+ COMMENT "Copying OCaml library component ${filename} to intermediate area"
+ VERBATIM)
+ add_dependencies("ocaml_${name}" ocaml_make_directory)
+ endforeach()
+endfunction()
+
+add_custom_target(ocaml_make_directory
+ COMMAND "${CMAKE_COMMAND}" "-E" "make_directory" "${LLVM_LIBRARY_DIR}/ocaml/llvm")
+add_custom_target("ocaml_all")
+set_target_properties(ocaml_all PROPERTIES FOLDER "Misc")
+set_target_properties(ocaml_make_directory PROPERTIES FOLDER "Misc")
diff --git a/linux-x64/clang/lib64/cmake/llvm/AddSphinxTarget.cmake b/linux-x64/clang/lib64/cmake/llvm/AddSphinxTarget.cmake
new file mode 100644
index 0000000..22e3dcb
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/AddSphinxTarget.cmake
@@ -0,0 +1,90 @@
+
+# Create sphinx target
+if (LLVM_ENABLE_SPHINX)
+ message(STATUS "Sphinx enabled.")
+ find_package(Sphinx REQUIRED)
+ if (LLVM_BUILD_DOCS AND NOT TARGET sphinx)
+ add_custom_target(sphinx ALL)
+ endif()
+else()
+ message(STATUS "Sphinx disabled.")
+endif()
+
+
+# Handy function for creating the different Sphinx targets.
+#
+# ``builder`` should be one of the supported builders used by
+# the sphinx-build command.
+#
+# ``project`` should be the project name
+function (add_sphinx_target builder project)
+ set(SPHINX_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/${builder}")
+ set(SPHINX_DOC_TREE_DIR "${CMAKE_CURRENT_BINARY_DIR}/_doctrees-${project}-${builder}")
+ set(SPHINX_TARGET_NAME docs-${project}-${builder})
+
+ if (SPHINX_WARNINGS_AS_ERRORS)
+ set(SPHINX_WARNINGS_AS_ERRORS_FLAG "-W")
+ else()
+ set(SPHINX_WARNINGS_AS_ERRORS_FLAG "")
+ endif()
+
+ add_custom_target(${SPHINX_TARGET_NAME}
+ COMMAND ${SPHINX_EXECUTABLE}
+ -b ${builder}
+ -d "${SPHINX_DOC_TREE_DIR}"
+ -q # Quiet: no output other than errors and warnings.
+ ${SPHINX_WARNINGS_AS_ERRORS_FLAG} # Treat warnings as errors if requested
+ "${CMAKE_CURRENT_SOURCE_DIR}" # Source
+ "${SPHINX_BUILD_DIR}" # Output
+ COMMENT
+ "Generating ${builder} Sphinx documentation for ${project} into \"${SPHINX_BUILD_DIR}\"")
+
+ # When "clean" target is run, remove the Sphinx build directory
+ set_property(DIRECTORY APPEND PROPERTY
+ ADDITIONAL_MAKE_CLEAN_FILES
+ "${SPHINX_BUILD_DIR}")
+
+ # We need to remove ${SPHINX_DOC_TREE_DIR} when make clean is run
+ # but we should only add this path once
+ get_property(_CURRENT_MAKE_CLEAN_FILES
+ DIRECTORY PROPERTY ADDITIONAL_MAKE_CLEAN_FILES)
+ list(FIND _CURRENT_MAKE_CLEAN_FILES "${SPHINX_DOC_TREE_DIR}" _INDEX)
+ if (_INDEX EQUAL -1)
+ set_property(DIRECTORY APPEND PROPERTY
+ ADDITIONAL_MAKE_CLEAN_FILES
+ "${SPHINX_DOC_TREE_DIR}")
+ endif()
+
+ if (LLVM_BUILD_DOCS)
+ add_dependencies(sphinx ${SPHINX_TARGET_NAME})
+
+ # Handle installation
+ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+ if (builder STREQUAL man)
+ if (CMAKE_INSTALL_MANDIR)
+ set(INSTALL_MANDIR ${CMAKE_INSTALL_MANDIR}/)
+ else()
+ set(INSTALL_MANDIR share/man/)
+ endif()
+ # FIXME: We might not ship all the tools that these man pages describe
+ install(DIRECTORY "${SPHINX_BUILD_DIR}/" # Slash indicates contents of
+ COMPONENT "${project}-sphinx-man"
+ DESTINATION ${INSTALL_MANDIR}man1)
+
+ elseif (builder STREQUAL html)
+ string(TOUPPER "${project}" project_upper)
+ set(${project_upper}_INSTALL_SPHINX_HTML_DIR "share/doc/${project}/html"
+ CACHE STRING "HTML documentation install directory for ${project}")
+
+ # '/.' indicates: copy the contents of the directory directly into
+ # the specified destination, without recreating the last component
+ # of ${SPHINX_BUILD_DIR} implicitly.
+ install(DIRECTORY "${SPHINX_BUILD_DIR}/."
+ COMPONENT "${project}-sphinx-html"
+ DESTINATION "${${project_upper}_INSTALL_SPHINX_HTML_DIR}")
+ else()
+ message(WARNING Installation of ${builder} not supported)
+ endif()
+ endif()
+ endif()
+endfunction()
diff --git a/linux-x64/clang/lib64/cmake/llvm/CheckAtomic.cmake b/linux-x64/clang/lib64/cmake/llvm/CheckAtomic.cmake
new file mode 100644
index 0000000..9a4cdf1
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/CheckAtomic.cmake
@@ -0,0 +1,106 @@
+# atomic builtins are required for threading support.
+
+INCLUDE(CheckCXXSourceCompiles)
+INCLUDE(CheckLibraryExists)
+
+# Sometimes linking against libatomic is required for atomic ops, if
+# the platform doesn't support lock-free atomics.
+
+function(check_working_cxx_atomics varname)
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11")
+ CHECK_CXX_SOURCE_COMPILES("
+#include <atomic>
+std::atomic<int> x;
+int main() {
+ return x;
+}
+" ${varname})
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction(check_working_cxx_atomics)
+
+function(check_working_cxx_atomics64 varname)
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(CMAKE_REQUIRED_FLAGS "-std=c++11 ${CMAKE_REQUIRED_FLAGS}")
+ CHECK_CXX_SOURCE_COMPILES("
+#include <atomic>
+#include <cstdint>
+std::atomic<uint64_t> x (0);
+int main() {
+ uint64_t i = x.load(std::memory_order_relaxed);
+ return 0;
+}
+" ${varname})
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction(check_working_cxx_atomics64)
+
+
+# This isn't necessary on MSVC, so avoid command-line switch annoyance
+# by only running on GCC-like hosts.
+if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
+ # First check if atomics work without the library.
+ check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITHOUT_LIB)
+ # If not, check if the library exists, and atomics work with it.
+ if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
+ check_library_exists(atomic __atomic_fetch_add_4 "" HAVE_LIBATOMIC)
+ if( HAVE_LIBATOMIC )
+ list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+ check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
+ if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
+ message(FATAL_ERROR "Host compiler must support std::atomic!")
+ endif()
+ else()
+ message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
+ endif()
+ endif()
+endif()
+
+# Check for 64 bit atomic operations.
+if(MSVC)
+ set(HAVE_CXX_ATOMICS64_WITHOUT_LIB True)
+else()
+ check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+endif()
+
+# If not, check if the library exists, and atomics work with it.
+if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+ check_library_exists(atomic __atomic_load_8 "" HAVE_CXX_LIBATOMICS64)
+ if(HAVE_CXX_LIBATOMICS64)
+ list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+ check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITH_LIB)
+ if (NOT HAVE_CXX_ATOMICS64_WITH_LIB)
+ message(FATAL_ERROR "Host compiler must support std::atomic!")
+ endif()
+ else()
+ message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
+ endif()
+endif()
+
+## TODO: This define is only used for the legacy atomic operations in
+## llvm's Atomic.h, which should be replaced. Other code simply
+## assumes C++11 <atomic> works.
+CHECK_CXX_SOURCE_COMPILES("
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+int main() {
+#ifdef _MSC_VER
+ volatile LONG val = 1;
+ MemoryBarrier();
+ InterlockedCompareExchange(&val, 0, 1);
+ InterlockedIncrement(&val);
+ InterlockedDecrement(&val);
+#else
+ volatile unsigned long val = 1;
+ __sync_synchronize();
+ __sync_val_compare_and_swap(&val, 1, 0);
+ __sync_add_and_fetch(&val, 1);
+ __sync_sub_and_fetch(&val, 1);
+#endif
+ return 0;
+ }
+" LLVM_HAS_ATOMICS)
+
+if( NOT LLVM_HAS_ATOMICS )
+ message(STATUS "Warning: LLVM will be built thread-unsafe because atomic builtins are missing")
+endif()
diff --git a/linux-x64/clang/lib64/cmake/llvm/CheckCompilerVersion.cmake b/linux-x64/clang/lib64/cmake/llvm/CheckCompilerVersion.cmake
new file mode 100644
index 0000000..adf500a
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/CheckCompilerVersion.cmake
@@ -0,0 +1,52 @@
+# Check if the host compiler is new enough. LLVM requires at least GCC 4.8,
+# MSVC 2015 (Update 3), or Clang 3.1.
+
+include(CheckCXXSourceCompiles)
+
+if(NOT DEFINED LLVM_COMPILER_CHECKED)
+ set(LLVM_COMPILER_CHECKED ON)
+
+ if(NOT LLVM_FORCE_USE_OLD_TOOLCHAIN)
+ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
+ message(FATAL_ERROR "Host GCC version must be at least 4.8!")
+ endif()
+ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.1)
+ message(FATAL_ERROR "Host Clang version must be at least 3.1!")
+ endif()
+
+ if (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")
+ if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 19.0)
+ message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=19.0")
+ endif()
+ set(CLANG_CL 1)
+ elseif(NOT LLVM_ENABLE_LIBCXX)
+ # Otherwise, test that we aren't using too old of a version of libstdc++
+ # with the Clang compiler. This is tricky as there is no real way to
+ # check the version of libstdc++ directly. Instead we test for a known
+ # bug in libstdc++4.6 that is fixed in libstdc++4.7.
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(OLD_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++0x")
+ check_cxx_source_compiles("
+#include <atomic>
+std::atomic<float> x(0.0f);
+int main() { return (float)x; }"
+ LLVM_NO_OLD_LIBSTDCXX)
+ if(NOT LLVM_NO_OLD_LIBSTDCXX)
+ message(FATAL_ERROR "Host Clang must be able to find libstdc++4.8 or newer!")
+ endif()
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+ set(CMAKE_REQUIRED_LIBRARIES ${OLD_CMAKE_REQUIRED_LIBRARIES})
+ endif()
+ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0)
+ message(FATAL_ERROR "Host Visual Studio must be at least 2015")
+ elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.00.24213.1)
+ message(WARNING "Host Visual Studio should at least be 2015 Update 3 (MSVC 19.00.24213.1)"
+ " due to miscompiles from earlier versions")
+ endif()
+ endif()
+ endif()
+endif()
diff --git a/linux-x64/clang/lib64/cmake/llvm/CheckLinkerFlag.cmake b/linux-x64/clang/lib64/cmake/llvm/CheckLinkerFlag.cmake
new file mode 100644
index 0000000..fe9d01a
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/CheckLinkerFlag.cmake
@@ -0,0 +1,6 @@
+include(CheckCXXCompilerFlag)
+
+function(check_linker_flag flag out_var)
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}")
+ check_cxx_compiler_flag("" ${out_var})
+endfunction()
diff --git a/linux-x64/clang/lib64/cmake/llvm/ChooseMSVCCRT.cmake b/linux-x64/clang/lib64/cmake/llvm/ChooseMSVCCRT.cmake
new file mode 100644
index 0000000..0e6e1aa
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/ChooseMSVCCRT.cmake
@@ -0,0 +1,106 @@
+# The macro choose_msvc_crt() takes a list of possible
+# C runtimes to choose from, in the form of compiler flags,
+# to present to the user. (MTd for /MTd, etc)
+#
+# The macro is invoked at the end of the file.
+#
+# CMake already sets CRT flags in the CMAKE_CXX_FLAGS_* and
+# CMAKE_C_FLAGS_* variables by default. To let the user
+# override that for each build type:
+# 1. Detect which CRT is already selected, and reflect this in
+# LLVM_USE_CRT_* so the user can have a better idea of what
+# changes they're making.
+# 2. Replace the flags in both variables with the new flag via a regex.
+# 3. set() the variables back into the cache so the changes
+# are user-visible.
+
+### Helper macros: ###
+macro(make_crt_regex regex crts)
+ set(${regex} "")
+ foreach(crt ${${crts}})
+ # Trying to match the beginning or end of the string with stuff
+ # like [ ^]+ didn't work, so use a bunch of parentheses instead.
+ set(${regex} "${${regex}}|(^| +)/${crt}($| +)")
+ endforeach(crt)
+ string(REGEX REPLACE "^\\|" "" ${regex} "${${regex}}")
+endmacro(make_crt_regex)
+
+macro(get_current_crt crt_current regex flagsvar)
+ # Find the selected-by-CMake CRT for each build type, if any.
+ # Strip off the leading slash and any whitespace.
+ string(REGEX MATCH "${${regex}}" ${crt_current} "${${flagsvar}}")
+ string(REPLACE "/" " " ${crt_current} "${${crt_current}}")
+ string(STRIP "${${crt_current}}" ${crt_current})
+endmacro(get_current_crt)
+
+# Replaces or adds a flag to a variable.
+# Expects 'flag' to be padded with spaces.
+macro(set_flag_in_var flagsvar regex flag)
+ string(REGEX MATCH "${${regex}}" current_flag "${${flagsvar}}")
+ if("${current_flag}" STREQUAL "")
+ set(${flagsvar} "${${flagsvar}}${${flag}}")
+ else()
+ string(REGEX REPLACE "${${regex}}" "${${flag}}" ${flagsvar} "${${flagsvar}}")
+ endif()
+ string(STRIP "${${flagsvar}}" ${flagsvar})
+ # Make sure this change gets reflected in the cache/gui.
+ # CMake requires the docstring parameter whenever set() touches the cache,
+ # so get the existing docstring and re-use that.
+ get_property(flagsvar_docs CACHE ${flagsvar} PROPERTY HELPSTRING)
+ set(${flagsvar} "${${flagsvar}}" CACHE STRING "${flagsvar_docs}" FORCE)
+endmacro(set_flag_in_var)
+
+
+macro(choose_msvc_crt MSVC_CRT)
+ if(LLVM_USE_CRT)
+ message(FATAL_ERROR
+ "LLVM_USE_CRT is deprecated. Use the CMAKE_BUILD_TYPE-specific
+variables (LLVM_USE_CRT_DEBUG, etc) instead.")
+ endif()
+
+ make_crt_regex(MSVC_CRT_REGEX ${MSVC_CRT})
+
+ foreach(build_type ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE})
+ string(TOUPPER "${build_type}" build)
+ if (NOT LLVM_USE_CRT_${build})
+ get_current_crt(LLVM_USE_CRT_${build}
+ MSVC_CRT_REGEX
+ CMAKE_CXX_FLAGS_${build})
+ set(LLVM_USE_CRT_${build}
+ "${LLVM_USE_CRT_${build}}"
+ CACHE STRING "Specify VC++ CRT to use for ${build_type} configurations."
+ FORCE)
+ set_property(CACHE LLVM_USE_CRT_${build}
+ PROPERTY STRINGS ;${${MSVC_CRT}})
+ endif(NOT LLVM_USE_CRT_${build})
+ endforeach(build_type)
+
+ foreach(build_type ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE})
+ string(TOUPPER "${build_type}" build)
+ if ("${LLVM_USE_CRT_${build}}" STREQUAL "")
+ set(flag_string " ")
+ else()
+ set(flag_string " /${LLVM_USE_CRT_${build}} ")
+ list(FIND ${MSVC_CRT} ${LLVM_USE_CRT_${build}} idx)
+ if (idx LESS 0)
+ message(FATAL_ERROR
+ "Invalid value for LLVM_USE_CRT_${build}: ${LLVM_USE_CRT_${build}}. Valid options are one of: ${${MSVC_CRT}}")
+ endif (idx LESS 0)
+ message(STATUS "Using ${build_type} VC++ CRT: ${LLVM_USE_CRT_${build}}")
+ endif()
+ foreach(lang C CXX)
+ set_flag_in_var(CMAKE_${lang}_FLAGS_${build} MSVC_CRT_REGEX flag_string)
+ endforeach(lang)
+ endforeach(build_type)
+endmacro(choose_msvc_crt MSVC_CRT)
+
+
+# List of valid CRTs for MSVC
+set(MSVC_CRT
+ MD
+ MDd
+ MT
+ MTd)
+
+choose_msvc_crt(MSVC_CRT)
+
diff --git a/linux-x64/clang/lib64/cmake/llvm/CrossCompile.cmake b/linux-x64/clang/lib64/cmake/llvm/CrossCompile.cmake
new file mode 100644
index 0000000..b239816
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/CrossCompile.cmake
@@ -0,0 +1,69 @@
+function(llvm_create_cross_target_internal target_name toolchain buildtype)
+
+ if(NOT DEFINED LLVM_${target_name}_BUILD)
+ set(LLVM_${target_name}_BUILD "${CMAKE_BINARY_DIR}/${target_name}")
+ set(LLVM_${target_name}_BUILD ${LLVM_${target_name}_BUILD} PARENT_SCOPE)
+ message(STATUS "Setting native build dir to " ${LLVM_${target_name}_BUILD})
+ endif(NOT DEFINED LLVM_${target_name}_BUILD)
+
+ if (EXISTS ${LLVM_MAIN_SRC_DIR}/cmake/platforms/${toolchain}.cmake)
+ set(CROSS_TOOLCHAIN_FLAGS_INIT
+ -DCMAKE_TOOLCHAIN_FILE=\"${LLVM_MAIN_SRC_DIR}/cmake/platforms/${toolchain}.cmake\")
+ else()
+ set(CROSS_TOOLCHAIN_FLAGS_INIT
+ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+ )
+ endif()
+ set(CROSS_TOOLCHAIN_FLAGS_${target_name} ${CROSS_TOOLCHAIN_FLAGS_INIT}
+ CACHE STRING "Toolchain configuration for ${target_name}")
+
+ if (buildtype)
+ set(build_type_flags "-DCMAKE_BUILD_TYPE=${buildtype}")
+ endif()
+ if (LLVM_USE_LINKER AND NOT CMAKE_CROSSCOMPILING)
+ set(linker_flag "-DLLVM_USE_LINKER=${LLVM_USE_LINKER}")
+ endif()
+ if (LLVM_EXTERNAL_CLANG_SOURCE_DIR)
+ # Propagate LLVM_EXTERNAL_CLANG_SOURCE_DIR so that clang-tblgen can be built
+ set(external_clang_dir "-DLLVM_EXTERNAL_CLANG_SOURCE_DIR=${LLVM_EXTERNAL_CLANG_SOURCE_DIR}")
+ endif()
+
+ add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}
+ COMMAND ${CMAKE_COMMAND} -E make_directory ${LLVM_${target_name}_BUILD}
+ COMMENT "Creating ${LLVM_${target_name}_BUILD}...")
+
+ add_custom_target(CREATE_LLVM_${target_name}
+ DEPENDS ${LLVM_${target_name}_BUILD})
+
+ # Escape semicolons in the targets list so that cmake doesn't expand
+ # them to spaces.
+ string(REPLACE ";" "$<SEMICOLON>" targets_to_build_arg
+ "${LLVM_TARGETS_TO_BUILD}")
+ string(REPLACE ";" "$<SEMICOLON>" experimental_targets_to_build_arg
+ "${LLVM_EXPERIMENTAL_TARGETS_TO_BUILD}")
+
+ add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}/CMakeCache.txt
+ COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
+ -DCMAKE_MAKE_PROGRAM="${CMAKE_MAKE_PROGRAM}"
+ ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR}
+ -DLLVM_TARGET_IS_CROSSCOMPILE_HOST=TRUE
+ -DLLVM_TARGETS_TO_BUILD="${targets_to_build_arg}"
+ -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="${experimental_targets_to_build_arg}"
+ -DLLVM_DEFAULT_TARGET_TRIPLE="${TARGET_TRIPLE}"
+ -DLLVM_TARGET_ARCH="${LLVM_TARGET_ARCH}"
+ ${build_type_flags} ${linker_flag} ${external_clang_dir}
+ WORKING_DIRECTORY ${LLVM_${target_name}_BUILD}
+ DEPENDS CREATE_LLVM_${target_name}
+ COMMENT "Configuring ${target_name} LLVM...")
+
+ add_custom_target(CONFIGURE_LLVM_${target_name}
+ DEPENDS ${LLVM_${target_name}_BUILD}/CMakeCache.txt)
+
+endfunction()
+
+function(llvm_create_cross_target target_name sysroot)
+ llvm_create_cross_target_internal(${target_name} ${sysroot} ${CMAKE_BUILD_TYPE})
+endfunction()
+
+llvm_create_cross_target_internal(NATIVE "" Release)
diff --git a/linux-x64/clang/lib64/cmake/llvm/DetermineGCCCompatible.cmake b/linux-x64/clang/lib64/cmake/llvm/DetermineGCCCompatible.cmake
new file mode 100644
index 0000000..1369ebe
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/DetermineGCCCompatible.cmake
@@ -0,0 +1,13 @@
+# Determine if the compiler has GCC-compatible command-line syntax.
+
+if(NOT DEFINED LLVM_COMPILER_IS_GCC_COMPATIBLE)
+ if(CMAKE_COMPILER_IS_GNUCXX)
+ set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON)
+ elseif( MSVC )
+ set(LLVM_COMPILER_IS_GCC_COMPATIBLE OFF)
+ elseif( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
+ set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON)
+ elseif( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel" )
+ set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON)
+ endif()
+endif()
diff --git a/linux-x64/clang/lib64/cmake/llvm/FindOCaml.cmake b/linux-x64/clang/lib64/cmake/llvm/FindOCaml.cmake
new file mode 100644
index 0000000..8eba212
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/FindOCaml.cmake
@@ -0,0 +1,103 @@
+# CMake find_package() module for the OCaml language.
+# Assumes ocamlfind will be used for compilation.
+# http://ocaml.org/
+#
+# Example usage:
+#
+# find_package(OCaml)
+#
+# If successful, the following variables will be defined:
+# OCAMLFIND
+# OCAML_VERSION
+# OCAML_STDLIB_PATH
+# HAVE_OCAMLOPT
+#
+# Also provides find_ocamlfind_package() macro.
+#
+# Example usage:
+#
+# find_ocamlfind_package(ctypes)
+#
+# In any case, the following variables are defined:
+#
+# HAVE_OCAML_${pkg}
+#
+# If successful, the following variables will be defined:
+#
+# OCAML_${pkg}_VERSION
+
+include( FindPackageHandleStandardArgs )
+
+find_program(OCAMLFIND
+ NAMES ocamlfind)
+
+if( OCAMLFIND )
+ execute_process(
+ COMMAND ${OCAMLFIND} ocamlc -version
+ OUTPUT_VARIABLE OCAML_VERSION
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+ execute_process(
+ COMMAND ${OCAMLFIND} ocamlc -where
+ OUTPUT_VARIABLE OCAML_STDLIB_PATH
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+ execute_process(
+ COMMAND ${OCAMLFIND} ocamlc -version
+ OUTPUT_QUIET
+ RESULT_VARIABLE find_ocaml_result)
+ if( find_ocaml_result EQUAL 0 )
+ set(HAVE_OCAMLOPT TRUE)
+ else()
+ set(HAVE_OCAMLOPT FALSE)
+ endif()
+endif()
+
+find_package_handle_standard_args( OCaml DEFAULT_MSG
+ OCAMLFIND
+ OCAML_VERSION
+ OCAML_STDLIB_PATH)
+
+mark_as_advanced(
+ OCAMLFIND)
+
+function(find_ocamlfind_package pkg)
+ CMAKE_PARSE_ARGUMENTS(ARG "OPTIONAL" "VERSION" "" ${ARGN})
+
+ execute_process(
+ COMMAND "${OCAMLFIND}" "query" "${pkg}" "-format" "%v"
+ RESULT_VARIABLE result
+ OUTPUT_VARIABLE version
+ ERROR_VARIABLE error
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ ERROR_STRIP_TRAILING_WHITESPACE)
+
+ if( NOT result EQUAL 0 AND NOT ARG_OPTIONAL )
+ message(FATAL_ERROR ${error})
+ endif()
+
+ if( result EQUAL 0 )
+ set(found TRUE)
+ else()
+ set(found FALSE)
+ endif()
+
+ if( found AND ARG_VERSION )
+ if( version VERSION_LESS ARG_VERSION AND ARG_OPTIONAL )
+ # If it's optional and the constraint is not satisfied, pretend
+ # it wasn't found.
+ set(found FALSE)
+ elseif( version VERSION_LESS ARG_VERSION )
+ message(FATAL_ERROR
+ "ocamlfind package ${pkg} should have version ${ARG_VERSION} or newer")
+ endif()
+ endif()
+
+ string(TOUPPER ${pkg} pkg)
+
+ set(HAVE_OCAML_${pkg} ${found}
+ PARENT_SCOPE)
+
+ set(OCAML_${pkg}_VERSION ${version}
+ PARENT_SCOPE)
+endfunction()
diff --git a/linux-x64/clang/lib64/cmake/llvm/FindSphinx.cmake b/linux-x64/clang/lib64/cmake/llvm/FindSphinx.cmake
new file mode 100644
index 0000000..9d252e8
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/FindSphinx.cmake
@@ -0,0 +1,27 @@
+# CMake find_package() Module for Sphinx documentation generator
+# http://sphinx-doc.org/
+#
+# Example usage:
+#
+# find_package(Sphinx)
+#
+# If successful the following variables will be defined
+# SPHINX_FOUND
+# SPHINX_EXECUTABLE
+
+find_program(SPHINX_EXECUTABLE
+ NAMES sphinx-build sphinx-build2
+ DOC "Path to sphinx-build executable")
+
+# Handle REQUIRED and QUIET arguments
+# this will also set SPHINX_FOUND to true if SPHINX_EXECUTABLE exists
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Sphinx
+ "Failed to locate sphinx-build executable"
+ SPHINX_EXECUTABLE)
+
+# Provide options for controlling different types of output
+option(SPHINX_OUTPUT_HTML "Output standalone HTML files" ON)
+option(SPHINX_OUTPUT_MAN "Output man pages" ON)
+
+option(SPHINX_WARNINGS_AS_ERRORS "When building documentation treat warnings as errors" ON)
diff --git a/linux-x64/clang/lib64/cmake/llvm/GenerateVersionFromCVS.cmake b/linux-x64/clang/lib64/cmake/llvm/GenerateVersionFromCVS.cmake
new file mode 100644
index 0000000..6b1c719
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/GenerateVersionFromCVS.cmake
@@ -0,0 +1,39 @@
+# CMake project that writes Subversion revision information to a header.
+#
+# Input variables:
+# SRC - Source directory
+# HEADER_FILE - The header file to write
+#
+# The output header will contain macros FIRST_REPOSITORY and FIRST_REVISION,
+# and SECOND_REPOSITORY and SECOND_REVISION if requested, where "FIRST" and
+# "SECOND" are substituted with the names specified in the input variables.
+
+
+
+# Chop off cmake/modules/GetSVN.cmake
+get_filename_component(LLVM_DIR "${CMAKE_SCRIPT_MODE_FILE}" PATH)
+get_filename_component(LLVM_DIR "${LLVM_DIR}" PATH)
+get_filename_component(LLVM_DIR "${LLVM_DIR}" PATH)
+
+set(CMAKE_MODULE_PATH
+ ${CMAKE_MODULE_PATH}
+ "${LLVM_DIR}/cmake/modules")
+include(VersionFromVCS)
+
+# Handle strange terminals
+set(ENV{TERM} "dumb")
+
+function(append_info name path)
+ add_version_info_from_vcs(REVISION ${path})
+ string(STRIP "${REVISION}" REVISION)
+ file(APPEND "${HEADER_FILE}.txt"
+ "#define ${name} \"${REVISION}\"\n")
+endfunction()
+
+append_info(${NAME} "${SOURCE_DIR}")
+
+# Copy the file only if it has changed.
+execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
+ "${HEADER_FILE}.txt" "${HEADER_FILE}")
+file(REMOVE "${HEADER_FILE}.txt")
+
diff --git a/linux-x64/clang/lib64/cmake/llvm/GetSVN.cmake b/linux-x64/clang/lib64/cmake/llvm/GetSVN.cmake
new file mode 100644
index 0000000..f729395
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/GetSVN.cmake
@@ -0,0 +1,141 @@
+# CMake project that writes Subversion revision information to a header.
+#
+# Input variables:
+# SOURCE_DIRS - A list of source directories.
+# NAMES - A list of macro prefixes for each of the source directories.
+# HEADER_FILE - The header file to write
+#
+# The output header will contain macros <NAME>_REPOSITORY and <NAME>_REVISION,
+# where "<NAME>" and is substituted with the names specified in the input
+# variables, for each of the SOURCE_DIRS given.
+
+# Chop off cmake/modules/GetSVN.cmake
+get_filename_component(LLVM_DIR "${CMAKE_SCRIPT_MODE_FILE}" PATH)
+get_filename_component(LLVM_DIR "${LLVM_DIR}" PATH)
+get_filename_component(LLVM_DIR "${LLVM_DIR}" PATH)
+
+# Handle strange terminals
+set(ENV{TERM} "dumb")
+
+macro(get_source_info_svn path revision repository)
+ # If svn is a bat file, find_program(Subversion) doesn't find it.
+ # Explicitly search for that here; Subversion_SVN_EXECUTABLE will override
+ # the find_program call in FindSubversion.cmake.
+ find_program(Subversion_SVN_EXECUTABLE NAMES svn svn.bat)
+
+ # FindSubversion does not work with symlinks. See PR 8437
+ if (NOT IS_SYMLINK "${path}")
+ find_package(Subversion)
+ endif()
+ if (Subversion_FOUND)
+ subversion_wc_info( ${path} Project )
+ if (Project_WC_REVISION)
+ set(${revision} ${Project_WC_REVISION} PARENT_SCOPE)
+ endif()
+ if (Project_WC_URL)
+ set(${repository} ${Project_WC_URL} PARENT_SCOPE)
+ endif()
+ endif()
+endmacro()
+
+macro(get_source_info_git_svn path revision repository)
+ find_program(git_executable NAMES git git.exe git.cmd)
+ if (git_executable)
+ execute_process(COMMAND ${git_executable} svn info
+ WORKING_DIRECTORY ${path}
+ TIMEOUT 5
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_output)
+ if (git_result EQUAL 0)
+ string(REGEX REPLACE "^(.*\n)?Revision: ([^\n]+).*"
+ "\\2" git_svn_rev "${git_output}")
+ set(${revision} ${git_svn_rev} PARENT_SCOPE)
+ string(REGEX REPLACE "^(.*\n)?URL: ([^\n]+).*"
+ "\\2" git_url "${git_output}")
+ set(${repository} ${git_url} PARENT_SCOPE)
+ endif()
+ endif()
+endmacro()
+
+macro(get_source_info_git path revision repository)
+ find_program(git_executable NAMES git git.exe git.cmd)
+ if (git_executable)
+ execute_process(COMMAND ${git_executable} log -1 --pretty=format:%H
+ WORKING_DIRECTORY ${path}
+ TIMEOUT 5
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_output)
+ if (git_result EQUAL 0)
+ set(${revision} ${git_output} PARENT_SCOPE)
+ endif()
+ execute_process(COMMAND ${git_executable} remote -v
+ WORKING_DIRECTORY ${path}
+ TIMEOUT 5
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_output)
+ if (git_result EQUAL 0)
+ string(REGEX REPLACE "^(.*\n)?[^ \t]+[ \t]+([^ \t\n]+)[ \t]+\\(fetch\\).*"
+ "\\2" git_url "${git_output}")
+ set(${repository} "${git_url}" PARENT_SCOPE)
+ endif()
+ endif()
+endmacro()
+
+function(get_source_info path revision repository)
+ if (EXISTS "${path}/.svn")
+ get_source_info_svn("${path}" revision repository)
+ elseif (EXISTS "${path}/.git/svn/refs")
+ get_source_info_git_svn("${path}" revision repository)
+ elseif (EXISTS "${path}/.git")
+ get_source_info_git("${path}" revision repository)
+ endif()
+endfunction()
+
+function(append_info name path)
+ get_source_info("${path}" revision repository)
+ string(STRIP "${revision}" revision)
+ string(STRIP "${repository}" repository)
+ file(APPEND "${HEADER_FILE}.txt"
+ "#define ${name}_REVISION \"${revision}\"\n")
+ file(APPEND "${HEADER_FILE}.txt"
+ "#define ${name}_REPOSITORY \"${repository}\"\n")
+endfunction()
+
+function(validate_inputs source_dirs names)
+ list(LENGTH source_dirs source_dirs_length)
+ list(LENGTH names names_length)
+ if (NOT source_dirs_length EQUAL names_length)
+ message(FATAL_ERROR
+ "GetSVN.cmake takes two arguments: a list of source directories, "
+ "and a list of names. Expected two lists must be of equal length, "
+ "but got ${source_dirs_length} source directories and "
+ "${names_length} names.")
+ endif()
+endfunction()
+
+if (DEFINED SOURCE_DIRS AND DEFINED NAMES)
+ validate_inputs("${SOURCE_DIRS}" "${NAMES}")
+
+ list(LENGTH SOURCE_DIRS source_dirs_length)
+ math(EXPR source_dirs_max_index ${source_dirs_length}-1)
+ foreach(index RANGE ${source_dirs_max_index})
+ list(GET SOURCE_DIRS ${index} source_dir)
+ list(GET NAMES ${index} name)
+ append_info(${name} ${source_dir})
+ endforeach()
+endif()
+
+# Allow -DFIRST_SOURCE_DIR arguments until Clang migrates to the new
+# -DSOURCE_DIRS argument.
+if(DEFINED FIRST_SOURCE_DIR)
+ append_info(${FIRST_NAME} "${FIRST_SOURCE_DIR}")
+ if(DEFINED SECOND_SOURCE_DIR)
+ append_info(${SECOND_NAME} "${SECOND_SOURCE_DIR}")
+ endif()
+endif()
+
+# Copy the file only if it has changed.
+execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
+ "${HEADER_FILE}.txt" "${HEADER_FILE}")
+file(REMOVE "${HEADER_FILE}.txt")
+
diff --git a/linux-x64/clang/lib64/cmake/llvm/HandleLLVMOptions.cmake b/linux-x64/clang/lib64/cmake/llvm/HandleLLVMOptions.cmake
new file mode 100644
index 0000000..86ce0bb
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/HandleLLVMOptions.cmake
@@ -0,0 +1,885 @@
+# This CMake module is responsible for interpreting the user defined LLVM_
+# options and executing the appropriate CMake commands to realize the users'
+# selections.
+
+# This is commonly needed so make sure it's defined before we include anything
+# else.
+string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
+
+include(CheckCompilerVersion)
+include(HandleLLVMStdlib)
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+
+if(CMAKE_LINKER MATCHES "lld-link.exe" OR (WIN32 AND LLVM_USE_LINKER STREQUAL "lld"))
+ set(LINKER_IS_LLD_LINK TRUE)
+else()
+ set(LINKER_IS_LLD_LINK FALSE)
+endif()
+
+set(LLVM_ENABLE_LTO OFF CACHE STRING "Build LLVM with LTO. May be specified as Thin or Full to use a particular kind of LTO")
+string(TOUPPER "${LLVM_ENABLE_LTO}" uppercase_LLVM_ENABLE_LTO)
+
+# Ninja Job Pool support
+# The following only works with the Ninja generator in CMake >= 3.0.
+set(LLVM_PARALLEL_COMPILE_JOBS "" CACHE STRING
+ "Define the maximum number of concurrent compilation jobs.")
+if(LLVM_PARALLEL_COMPILE_JOBS)
+ if(NOT CMAKE_MAKE_PROGRAM MATCHES "ninja")
+ message(WARNING "Job pooling is only available with Ninja generators.")
+ else()
+ set_property(GLOBAL APPEND PROPERTY JOB_POOLS compile_job_pool=${LLVM_PARALLEL_COMPILE_JOBS})
+ set(CMAKE_JOB_POOL_COMPILE compile_job_pool)
+ endif()
+endif()
+
+set(LLVM_PARALLEL_LINK_JOBS "" CACHE STRING
+ "Define the maximum number of concurrent link jobs.")
+if(CMAKE_MAKE_PROGRAM MATCHES "ninja")
+ if(NOT LLVM_PARALLEL_LINK_JOBS AND uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")
+ message(STATUS "ThinLTO provides its own parallel linking - limiting parallel link jobs to 2.")
+ set(LLVM_PARALLEL_LINK_JOBS "2")
+ endif()
+ if(LLVM_PARALLEL_LINK_JOBS)
+ set_property(GLOBAL APPEND PROPERTY JOB_POOLS link_job_pool=${LLVM_PARALLEL_LINK_JOBS})
+ set(CMAKE_JOB_POOL_LINK link_job_pool)
+ endif()
+elseif(LLVM_PARALLEL_LINK_JOBS)
+ message(WARNING "Job pooling is only available with Ninja generators.")
+endif()
+
+if (LINKER_IS_LLD_LINK)
+ # Pass /MANIFEST:NO so that CMake doesn't run mt.exe on our binaries. Adding
+ # manifests with mt.exe breaks LLD's symbol tables and takes as much time as
+ # the link. See PR24476.
+ append("/MANIFEST:NO"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+endif()
+
+if( LLVM_ENABLE_ASSERTIONS )
+ # MSVC doesn't like _DEBUG on release builds. See PR 4379.
+ if( NOT MSVC )
+ add_definitions( -D_DEBUG )
+ endif()
+ # On non-Debug builds cmake automatically defines NDEBUG, so we
+ # explicitly undefine it:
+ if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
+ add_definitions( -UNDEBUG )
+ # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
+ foreach (flags_var_to_scrub
+ CMAKE_CXX_FLAGS_RELEASE
+ CMAKE_CXX_FLAGS_RELWITHDEBINFO
+ CMAKE_CXX_FLAGS_MINSIZEREL
+ CMAKE_C_FLAGS_RELEASE
+ CMAKE_C_FLAGS_RELWITHDEBINFO
+ CMAKE_C_FLAGS_MINSIZEREL)
+ string (REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " "
+ "${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
+ endforeach()
+ endif()
+endif()
+
+if(LLVM_ENABLE_EXPENSIVE_CHECKS)
+ add_definitions(-DEXPENSIVE_CHECKS)
+ add_definitions(-D_GLIBCXX_DEBUG)
+endif()
+
+string(TOUPPER "${LLVM_ABI_BREAKING_CHECKS}" uppercase_LLVM_ABI_BREAKING_CHECKS)
+
+if( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "WITH_ASSERTS" )
+ if( LLVM_ENABLE_ASSERTIONS )
+ set( LLVM_ENABLE_ABI_BREAKING_CHECKS 1 )
+ endif()
+elseif( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "FORCE_ON" )
+ set( LLVM_ENABLE_ABI_BREAKING_CHECKS 1 )
+elseif( uppercase_LLVM_ABI_BREAKING_CHECKS STREQUAL "FORCE_OFF" )
+ # We don't need to do anything special to turn off ABI breaking checks.
+elseif( NOT DEFINED LLVM_ABI_BREAKING_CHECKS )
+ # Treat LLVM_ABI_BREAKING_CHECKS like "FORCE_OFF" when it has not been
+ # defined.
+else()
+ message(FATAL_ERROR "Unknown value for LLVM_ABI_BREAKING_CHECKS: \"${LLVM_ABI_BREAKING_CHECKS}\"!")
+endif()
+
+if( LLVM_REVERSE_ITERATION )
+ set( LLVM_ENABLE_REVERSE_ITERATION 1 )
+endif()
+
+if(WIN32)
+ set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)
+ if(CYGWIN)
+ set(LLVM_ON_WIN32 0)
+ set(LLVM_ON_UNIX 1)
+ else(CYGWIN)
+ set(LLVM_ON_WIN32 1)
+ set(LLVM_ON_UNIX 0)
+ endif(CYGWIN)
+else(WIN32)
+ if(UNIX)
+ set(LLVM_ON_WIN32 0)
+ set(LLVM_ON_UNIX 1)
+ if(APPLE OR ${CMAKE_SYSTEM_NAME} MATCHES "AIX")
+ set(LLVM_HAVE_LINK_VERSION_SCRIPT 0)
+ else()
+ set(LLVM_HAVE_LINK_VERSION_SCRIPT 1)
+ endif()
+ else(UNIX)
+ MESSAGE(SEND_ERROR "Unable to determine platform")
+ endif(UNIX)
+endif(WIN32)
+
+set(EXEEXT ${CMAKE_EXECUTABLE_SUFFIX})
+set(LTDL_SHLIB_EXT ${CMAKE_SHARED_LIBRARY_SUFFIX})
+
+# We use *.dylib rather than *.so on darwin.
+set(LLVM_PLUGIN_EXT ${CMAKE_SHARED_LIBRARY_SUFFIX})
+
+if(APPLE)
+ if(LLVM_ENABLE_LLD AND LLVM_ENABLE_LTO)
+ message(FATAL_ERROR "lld does not support LTO on Darwin")
+ endif()
+ # Darwin-specific linker flags for loadable modules.
+ set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-flat_namespace -Wl,-undefined -Wl,suppress")
+endif()
+
+# Pass -Wl,-z,defs. This makes sure all symbols are defined. Otherwise a DSO
+# build might work on ELF but fail on MachO/COFF.
+if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin" OR WIN32 OR CYGWIN OR
+ ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR
+ ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD") AND
+ NOT LLVM_USE_SANITIZER)
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs")
+endif()
+
+# Pass -Wl,-z,nodelete. This makes sure our shared libraries are not unloaded
+# by dlclose(). We need that since the CLI API relies on cross-references
+# between global objects which became horribly broken when one of the libraries
+# is unloaded.
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,nodelete")
+endif()
+
+
+function(append value)
+ foreach(variable ${ARGN})
+ set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
+ endforeach(variable)
+endfunction()
+
+function(append_if condition value)
+ if (${condition})
+ foreach(variable ${ARGN})
+ set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
+ endforeach(variable)
+ endif()
+endfunction()
+
+macro(add_flag_if_supported flag name)
+ check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")
+ append_if("C_SUPPORTS_${name}" "${flag}" CMAKE_C_FLAGS)
+ check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")
+ append_if("CXX_SUPPORTS_${name}" "${flag}" CMAKE_CXX_FLAGS)
+endmacro()
+
+function(add_flag_or_print_warning flag name)
+ check_c_compiler_flag("-Werror ${flag}" "C_SUPPORTS_${name}")
+ check_cxx_compiler_flag("-Werror ${flag}" "CXX_SUPPORTS_${name}")
+ if (C_SUPPORTS_${name} AND CXX_SUPPORTS_${name})
+ message(STATUS "Building with ${flag}")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
+ set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${flag}" PARENT_SCOPE)
+ else()
+ message(WARNING "${flag} is not supported.")
+ endif()
+endfunction()
+
+if( LLVM_ENABLE_LLD )
+ if ( LLVM_USE_LINKER )
+ message(FATAL_ERROR "LLVM_ENABLE_LLD and LLVM_USE_LINKER can't be set at the same time")
+ endif()
+ set(LLVM_USE_LINKER "lld")
+endif()
+
+if( LLVM_USE_LINKER )
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fuse-ld=${LLVM_USE_LINKER}")
+ check_cxx_source_compiles("int main() { return 0; }" CXX_SUPPORTS_CUSTOM_LINKER)
+ if ( NOT CXX_SUPPORTS_CUSTOM_LINKER )
+ message(FATAL_ERROR "Host compiler does not support '-fuse-ld=${LLVM_USE_LINKER}'")
+ endif()
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+ append("-fuse-ld=${LLVM_USE_LINKER}"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+endif()
+
+if( LLVM_ENABLE_PIC )
+ if( XCODE )
+ # Xcode has -mdynamic-no-pic on by default, which overrides -fPIC. I don't
+ # know how to disable this, so just force ENABLE_PIC off for now.
+ message(WARNING "-fPIC not supported with Xcode.")
+ elseif( WIN32 OR CYGWIN)
+ # On Windows all code is PIC. MinGW warns if -fPIC is used.
+ else()
+ add_flag_or_print_warning("-fPIC" FPIC)
+ endif()
+endif()
+
+if(NOT WIN32 AND NOT CYGWIN)
+ # MinGW warns if -fvisibility-inlines-hidden is used.
+ check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)
+ append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS)
+endif()
+
+if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
+ # TODO: support other platforms and toolchains.
+ if( LLVM_BUILD_32_BITS )
+ message(STATUS "Building 32 bits executables and libraries.")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -m32")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -m32")
+ set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -m32")
+
+ # FIXME: CMAKE_SIZEOF_VOID_P is still 8
+ add_definitions(-D_LARGEFILE_SOURCE)
+ add_definitions(-D_FILE_OFFSET_BITS=64)
+ endif( LLVM_BUILD_32_BITS )
+endif( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 )
+
+# If building on a GNU specific 32-bit system, make sure off_t is 64 bits
+# so that off_t can stored offset > 2GB.
+# Android until version N (API 24) doesn't support it.
+if (ANDROID AND (ANDROID_NATIVE_API_LEVEL LESS 24))
+ set(LLVM_FORCE_SMALLFILE_FOR_ANDROID TRUE)
+endif()
+if( CMAKE_SIZEOF_VOID_P EQUAL 4 AND NOT LLVM_FORCE_SMALLFILE_FOR_ANDROID)
+ # FIXME: It isn't handled in LLVM_BUILD_32_BITS.
+ add_definitions( -D_LARGEFILE_SOURCE )
+ add_definitions( -D_FILE_OFFSET_BITS=64 )
+endif()
+
+if( XCODE )
+ # For Xcode enable several build settings that correspond to
+ # many warnings that are on by default in Clang but are
+ # not enabled for historical reasons. For versions of Xcode
+ # that do not support these options they will simply
+ # be ignored.
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_RETURN_TYPE "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_NEWLINE "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VALUE "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VARIABLE "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_SIGN_COMPARE "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_FUNCTION "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNINITIALIZED_AUTOS "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_BOOL_CONVERSION "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_EMPTY_BODY "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_INT_CONVERSION "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_CONSTANT_CONVERSION "YES")
+ set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_NON_VIRTUAL_DESTRUCTOR "YES")
+endif()
+
+# On Win32 using MS tools, provide an option to set the number of parallel jobs
+# to use.
+if( MSVC_IDE )
+ set(LLVM_COMPILER_JOBS "0" CACHE STRING
+ "Number of parallel compiler jobs. 0 means use all processors. Default is 0.")
+ if( NOT LLVM_COMPILER_JOBS STREQUAL "1" )
+ if( LLVM_COMPILER_JOBS STREQUAL "0" )
+ add_definitions( /MP )
+ else()
+ message(STATUS "Number of parallel compiler jobs set to " ${LLVM_COMPILER_JOBS})
+ add_definitions( /MP${LLVM_COMPILER_JOBS} )
+ endif()
+ else()
+ message(STATUS "Parallel compilation disabled")
+ endif()
+endif()
+
+# set stack reserved size to ~10MB
+if(MSVC)
+ # CMake previously automatically set this value for MSVC builds, but the
+ # behavior was changed in CMake 2.8.11 (Issue 12437) to use the MSVC default
+ # value (1 MB) which is not enough for us in tasks such as parsing recursive
+ # C++ templates in Clang.
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:10000000")
+elseif(MINGW) # FIXME: Also cygwin?
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,16777216")
+
+ # Pass -mbig-obj to mingw gas on Win64. COFF has a 2**16 section limit, and
+ # on Win64, every COMDAT function creates at least 3 sections: .text, .pdata,
+ # and .xdata.
+ if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+ append("-Wa,-mbig-obj" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+endif()
+
+if( MSVC )
+ if( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0 )
+ # For MSVC 2013, disable iterator null pointer checking in debug mode,
+ # especially so std::equal(nullptr, nullptr, nullptr) will not assert.
+ add_definitions("-D_DEBUG_POINTER_IMPL=")
+ endif()
+
+ include(ChooseMSVCCRT)
+
+ if( MSVC11 )
+ add_definitions(-D_VARIADIC_MAX=10)
+ endif()
+
+ # Add definitions that make MSVC much less annoying.
+ add_definitions(
+ # For some reason MS wants to deprecate a bunch of standard functions...
+ -D_CRT_SECURE_NO_DEPRECATE
+ -D_CRT_SECURE_NO_WARNINGS
+ -D_CRT_NONSTDC_NO_DEPRECATE
+ -D_CRT_NONSTDC_NO_WARNINGS
+ -D_SCL_SECURE_NO_DEPRECATE
+ -D_SCL_SECURE_NO_WARNINGS
+ )
+
+ # Tell MSVC to use the Unicode version of the Win32 APIs instead of ANSI.
+ add_definitions(
+ -DUNICODE
+ -D_UNICODE
+ )
+
+ if (LLVM_ENABLE_WERROR)
+ append("/WX" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif (LLVM_ENABLE_WERROR)
+
+ append("/Zc:inline" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
+ # Allow users to request PDBs in release mode. CMake offeres the
+ # RelWithDebInfo configuration, but it uses different optimization settings
+ # (/Ob1 vs /Ob2 or -O2 vs -O3). LLVM provides this flag so that users can get
+ # PDBs without changing codegen.
+ option(LLVM_ENABLE_PDB OFF)
+ if (LLVM_ENABLE_PDB AND uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
+ append("/Zi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ # /DEBUG disables linker GC and ICF, but we want those in Release mode.
+ append("/DEBUG /OPT:REF /OPT:ICF"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS
+ CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+
+ # /Zc:strictStrings is incompatible with VS12's (Visual Studio 2013's)
+ # debug mode headers. Instead of only enabling them in VS2013's debug mode,
+ # we'll just enable them for Visual Studio 2015 (VS 14, MSVC_VERSION 1900)
+ # and up.
+ if (NOT (MSVC_VERSION LESS 1900))
+ # Disable string literal const->non-const type conversion.
+ # "When specified, the compiler requires strict const-qualification
+ # conformance for pointers initialized by using string literals."
+ append("/Zc:strictStrings" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif(NOT (MSVC_VERSION LESS 1900))
+
+ # "Generate Intrinsic Functions".
+ append("/Oi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+
+ # "Enforce type conversion rules".
+ append("/Zc:rvalueCast" CMAKE_CXX_FLAGS)
+
+ if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT LLVM_ENABLE_LTO)
+ # clang-cl and cl by default produce non-deterministic binaries because
+ # link.exe /incremental requires a timestamp in the .obj file. clang-cl
+ # has the flag /Brepro to force deterministic binaries. We want to pass that
+ # whenever you're building with clang unless you're passing /incremental
+ # or using LTO (/Brepro with LTO would result in a warning about the flag
+ # being unused, because we're not generating object files).
+ # This checks CMAKE_CXX_COMPILER_ID in addition to check_cxx_compiler_flag()
+ # because cl.exe does not emit an error on flags it doesn't understand,
+ # letting check_cxx_compiler_flag() claim it understands all flags.
+ check_cxx_compiler_flag("/Brepro" SUPPORTS_BREPRO)
+ if (SUPPORTS_BREPRO)
+ # Check if /INCREMENTAL is passed to the linker and complain that it
+ # won't work with /Brepro.
+ string(TOUPPER "${CMAKE_EXE_LINKER_FLAGS}" upper_exe_flags)
+ string(TOUPPER "${CMAKE_MODULE_LINKER_FLAGS}" upper_module_flags)
+ string(TOUPPER "${CMAKE_SHARED_LINKER_FLAGS}" upper_shared_flags)
+
+ string(FIND "${upper_exe_flags} ${upper_module_flags} ${upper_shared_flags}"
+ "/INCREMENTAL" linker_flag_idx)
+
+ if (${linker_flag_idx} GREATER -1)
+ message(WARNING "/Brepro not compatible with /INCREMENTAL linking - builds will be non-deterministic")
+ else()
+ append("/Brepro" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+ endif()
+ endif()
+
+elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
+ append_if(LLVM_ENABLE_WERROR "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ append_if(LLVM_ENABLE_WERROR "-Wno-error" CMAKE_REQUIRED_FLAGS)
+ add_flag_if_supported("-Werror=date-time" WERROR_DATE_TIME)
+ add_flag_if_supported("-Werror=unguarded-availability-new" WERROR_UNGUARDED_AVAILABILITY_NEW)
+ if (LLVM_ENABLE_CXX1Y)
+ check_cxx_compiler_flag("-std=c++1y" CXX_SUPPORTS_CXX1Y)
+ append_if(CXX_SUPPORTS_CXX1Y "-std=c++1y" CMAKE_CXX_FLAGS)
+ elseif(LLVM_ENABLE_CXX1Z)
+ check_cxx_compiler_flag("-std=c++1z" CXX_SUPPORTS_CXX1Z)
+ append_if(CXX_SUPPORTS_CXX1Z "-std=c++1z" CMAKE_CXX_FLAGS)
+ else()
+ check_cxx_compiler_flag("-std=c++11" CXX_SUPPORTS_CXX11)
+ if (CXX_SUPPORTS_CXX11)
+ if (CYGWIN OR MINGW)
+ # MinGW and Cygwin are a bit stricter and lack things like
+ # 'strdup', 'stricmp', etc in c++11 mode.
+ append("-std=gnu++11" CMAKE_CXX_FLAGS)
+ else()
+ append("-std=c++11" CMAKE_CXX_FLAGS)
+ endif()
+ else()
+ message(FATAL_ERROR "LLVM requires C++11 support but the '-std=c++11' flag isn't supported.")
+ endif()
+ endif()
+ if (LLVM_ENABLE_MODULES)
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(module_flags "-fmodules -fmodules-cache-path=${PROJECT_BINARY_DIR}/module.cache")
+ if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ # On Darwin -fmodules does not imply -fcxx-modules.
+ set(module_flags "${module_flags} -fcxx-modules")
+ endif()
+ if (LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY)
+ set(module_flags "${module_flags} -Xclang -fmodules-local-submodule-visibility")
+ endif()
+ if (LLVM_ENABLE_MODULE_DEBUGGING AND
+ ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR
+ (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))
+ set(module_flags "${module_flags} -gmodules")
+ endif()
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${module_flags}")
+
+ # Check that we can build code with modules enabled, and that repeatedly
+ # including <cassert> still manages to respect NDEBUG properly.
+ CHECK_CXX_SOURCE_COMPILES("#undef NDEBUG
+ #include <cassert>
+ #define NDEBUG
+ #include <cassert>
+ int main() { assert(this code is not compiled); }"
+ CXX_SUPPORTS_MODULES)
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+ if (CXX_SUPPORTS_MODULES)
+ append("${module_flags}" CMAKE_CXX_FLAGS)
+ else()
+ message(FATAL_ERROR "LLVM_ENABLE_MODULES is not supported by this compiler")
+ endif()
+ endif(LLVM_ENABLE_MODULES)
+endif( MSVC )
+
+if (MSVC)
+ if (NOT CLANG_CL)
+ set(msvc_warning_flags
+ # Disabled warnings.
+ -wd4141 # Suppress ''modifier' : used more than once' (because of __forceinline combined with inline)
+ -wd4146 # Suppress 'unary minus operator applied to unsigned type, result still unsigned'
+ -wd4180 # Suppress 'qualifier applied to function type has no meaning; ignored'
+ -wd4244 # Suppress ''argument' : conversion from 'type1' to 'type2', possible loss of data'
+ -wd4258 # Suppress ''var' : definition from the for loop is ignored; the definition from the enclosing scope is used'
+ -wd4267 # Suppress ''var' : conversion from 'size_t' to 'type', possible loss of data'
+ -wd4291 # Suppress ''declaration' : no matching operator delete found; memory will not be freed if initialization throws an exception'
+ -wd4345 # Suppress 'behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized'
+ -wd4351 # Suppress 'new behavior: elements of array 'array' will be default initialized'
+ -wd4355 # Suppress ''this' : used in base member initializer list'
+ -wd4456 # Suppress 'declaration of 'var' hides local variable'
+ -wd4457 # Suppress 'declaration of 'var' hides function parameter'
+ -wd4458 # Suppress 'declaration of 'var' hides class member'
+ -wd4459 # Suppress 'declaration of 'var' hides global declaration'
+ -wd4503 # Suppress ''identifier' : decorated name length exceeded, name was truncated'
+ -wd4624 # Suppress ''derived class' : destructor could not be generated because a base class destructor is inaccessible'
+ -wd4722 # Suppress 'function' : destructor never returns, potential memory leak
+ -wd4800 # Suppress ''type' : forcing value to bool 'true' or 'false' (performance warning)'
+ -wd4100 # Suppress 'unreferenced formal parameter'
+ -wd4127 # Suppress 'conditional expression is constant'
+ -wd4512 # Suppress 'assignment operator could not be generated'
+ -wd4505 # Suppress 'unreferenced local function has been removed'
+ -wd4610 # Suppress '<class> can never be instantiated'
+ -wd4510 # Suppress 'default constructor could not be generated'
+ -wd4702 # Suppress 'unreachable code'
+ -wd4245 # Suppress 'signed/unsigned mismatch'
+ -wd4706 # Suppress 'assignment within conditional expression'
+ -wd4310 # Suppress 'cast truncates constant value'
+ -wd4701 # Suppress 'potentially uninitialized local variable'
+ -wd4703 # Suppress 'potentially uninitialized local pointer variable'
+ -wd4389 # Suppress 'signed/unsigned mismatch'
+ -wd4611 # Suppress 'interaction between '_setjmp' and C++ object destruction is non-portable'
+ -wd4805 # Suppress 'unsafe mix of type <type> and type <type> in operation'
+ -wd4204 # Suppress 'nonstandard extension used : non-constant aggregate initializer'
+ -wd4577 # Suppress 'noexcept used with no exception handling mode specified; termination on exception is not guaranteed'
+ -wd4091 # Suppress 'typedef: ignored on left of '' when no variable is declared'
+ # C4592 is disabled because of false positives in Visual Studio 2015
+ # Update 1. Re-evaluate the usefulness of this diagnostic with Update 2.
+ -wd4592 # Suppress ''var': symbol will be dynamically initialized (implementation limitation)
+ -wd4319 # Suppress ''operator' : zero extending 'type' to 'type' of greater size'
+
+ # Ideally, we'd like this warning to be enabled, but MSVC 2013 doesn't
+ # support the 'aligned' attribute in the way that clang sources requires (for
+ # any code that uses the LLVM_ALIGNAS macro), so this is must be disabled to
+ # avoid unwanted alignment warnings.
+ # When we switch to requiring a version of MSVC that supports the 'alignas'
+ # specifier (MSVC 2015?) this warning can be re-enabled.
+ -wd4324 # Suppress 'structure was padded due to __declspec(align())'
+
+ # Promoted warnings.
+ -w14062 # Promote 'enumerator in switch of enum is not handled' to level 1 warning.
+
+ # Promoted warnings to errors.
+ -we4238 # Promote 'nonstandard extension used : class rvalue used as lvalue' to error.
+ )
+ endif(NOT CLANG_CL)
+
+ # Enable warnings
+ if (LLVM_ENABLE_WARNINGS)
+ # Put /W4 in front of all the -we flags. cl.exe doesn't care, but for
+ # clang-cl having /W4 after the -we flags will re-enable the warnings
+ # disabled by -we.
+ set(msvc_warning_flags "/W4 ${msvc_warning_flags}")
+ # CMake appends /W3 by default, and having /W3 followed by /W4 will result in
+ # cl : Command line warning D9025 : overriding '/W3' with '/W4'. Since this is
+ # a command line warning and not a compiler warning, it cannot be suppressed except
+ # by fixing the command line.
+ string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+ string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+ if (LLVM_ENABLE_PEDANTIC)
+ # No MSVC equivalent available
+ endif (LLVM_ENABLE_PEDANTIC)
+ endif (LLVM_ENABLE_WARNINGS)
+
+ foreach(flag ${msvc_warning_flags})
+ append("${flag}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endforeach(flag)
+endif (MSVC)
+
+if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))
+
+ # Don't add -Wall for clang-cl, because it maps -Wall to -Weverything for
+ # MSVC compatibility. /W4 is added above instead.
+ if (NOT CLANG_CL)
+ append("-Wall" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+
+ append("-W -Wno-unused-parameter -Wwrite-strings" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ append("-Wcast-qual" CMAKE_CXX_FLAGS)
+
+ # Turn off missing field initializer warnings for gcc to avoid noise from
+ # false positives with empty {}. Turn them on otherwise (they're off by
+ # default for clang).
+ check_cxx_compiler_flag("-Wmissing-field-initializers" CXX_SUPPORTS_MISSING_FIELD_INITIALIZERS_FLAG)
+ if (CXX_SUPPORTS_MISSING_FIELD_INITIALIZERS_FLAG)
+ if (CMAKE_COMPILER_IS_GNUCXX)
+ append("-Wno-missing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ else()
+ append("-Wmissing-field-initializers" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+ endif()
+
+ if (LLVM_ENABLE_PEDANTIC AND LLVM_COMPILER_IS_GCC_COMPATIBLE)
+ append("-pedantic" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ append("-Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+
+ add_flag_if_supported("-Wcovered-switch-default" COVERED_SWITCH_DEFAULT_FLAG)
+ append_if(USE_NO_UNINITIALIZED "-Wno-uninitialized" CMAKE_CXX_FLAGS)
+ append_if(USE_NO_MAYBE_UNINITIALIZED "-Wno-maybe-uninitialized" CMAKE_CXX_FLAGS)
+
+ # Check if -Wnon-virtual-dtor warns even though the class is marked final.
+ # If it does, don't add it. So it won't be added on clang 3.4 and older.
+ # This also catches cases when -Wnon-virtual-dtor isn't supported by
+ # the compiler at all. This flag is not activated for gcc since it will
+ # incorrectly identify a protected non-virtual base when there is a friend
+ # declaration. Don't activate this in general on Windows as this warning has
+ # too many false positives on COM-style classes, which are destroyed with
+ # Release() (PR32286).
+ if (NOT CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11 -Werror=non-virtual-dtor")
+ CHECK_CXX_SOURCE_COMPILES("class base {public: virtual void anchor();protected: ~base();};
+ class derived final : public base { public: ~derived();};
+ int main() { return 0; }"
+ CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR)
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+ append_if(CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR
+ "-Wnon-virtual-dtor" CMAKE_CXX_FLAGS)
+ endif()
+
+ # Enable -Wdelete-non-virtual-dtor if available.
+ add_flag_if_supported("-Wdelete-non-virtual-dtor" DELETE_NON_VIRTUAL_DTOR_FLAG)
+
+ # Check if -Wcomment is OK with an // comment ending with '\' if the next
+ # line is also a // comment.
+ set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror -Wcomment")
+ CHECK_C_SOURCE_COMPILES("// \\\\\\n//\\nint main() {return 0;}"
+ C_WCOMMENT_ALLOWS_LINE_WRAP)
+ set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+ if (NOT C_WCOMMENT_ALLOWS_LINE_WRAP)
+ append("-Wno-comment" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+
+ # Enable -Wstring-conversion to catch misuse of string literals.
+ add_flag_if_supported("-Wstring-conversion" STRING_CONVERSION_FLAG)
+endif (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))
+
+if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT LLVM_ENABLE_WARNINGS)
+ append("-w" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+endif()
+
+macro(append_common_sanitizer_flags)
+ if (NOT MSVC)
+ # Append -fno-omit-frame-pointer and turn on debug info to get better
+ # stack traces.
+ add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER)
+ if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
+ NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
+ add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY)
+ endif()
+ # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
+ if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+ add_flag_if_supported("-O1" O1)
+ endif()
+ elseif (CLANG_CL)
+ # Keep frame pointers around.
+ append("/Oy-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ if (LINKER_IS_LLD_LINK)
+ # Use DWARF debug info with LLD.
+ append("-gdwarf" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ else()
+ # Enable codeview otherwise.
+ append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+ # Always ask the linker to produce symbols with asan.
+ append("-debug" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+endmacro()
+
+# Turn on sanitizers if necessary.
+if(LLVM_USE_SANITIZER)
+ if (LLVM_ON_UNIX)
+ if (LLVM_USE_SANITIZER STREQUAL "Address")
+ append_common_sanitizer_flags()
+ append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ elseif (LLVM_USE_SANITIZER MATCHES "Memory(WithOrigins)?")
+ append_common_sanitizer_flags()
+ append("-fsanitize=memory" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ if(LLVM_USE_SANITIZER STREQUAL "MemoryWithOrigins")
+ append("-fsanitize-memory-track-origins" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+ elseif (LLVM_USE_SANITIZER STREQUAL "Undefined")
+ append_common_sanitizer_flags()
+ append("-fsanitize=undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all"
+ CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ set(BLACKLIST_FILE "${CMAKE_SOURCE_DIR}/utils/sanitizers/ubsan_blacklist.txt")
+ if (EXISTS "${BLACKLIST_FILE}")
+ append("-fsanitize-blacklist=${BLACKLIST_FILE}"
+ CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+ elseif (LLVM_USE_SANITIZER STREQUAL "Thread")
+ append_common_sanitizer_flags()
+ append("-fsanitize=thread" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ elseif (LLVM_USE_SANITIZER STREQUAL "Address;Undefined" OR
+ LLVM_USE_SANITIZER STREQUAL "Undefined;Address")
+ append_common_sanitizer_flags()
+ append("-fsanitize=address,undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all"
+ CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ elseif (LLVM_USE_SANITIZER STREQUAL "Leaks")
+ append_common_sanitizer_flags()
+ append("-fsanitize=leak" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ else()
+ message(FATAL_ERROR "Unsupported value of LLVM_USE_SANITIZER: ${LLVM_USE_SANITIZER}")
+ endif()
+ elseif(MSVC)
+ if (LLVM_USE_SANITIZER STREQUAL "Address")
+ append_common_sanitizer_flags()
+ append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ else()
+ message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${LLVM_USE_SANITIZER}")
+ endif()
+ else()
+ message(FATAL_ERROR "LLVM_USE_SANITIZER is not supported on this platform.")
+ endif()
+ if (LLVM_USE_SANITIZER MATCHES "(Undefined;)?Address(;Undefined)?")
+ add_flag_if_supported("-fsanitize-address-use-after-scope"
+ FSANITIZE_USE_AFTER_SCOPE_FLAG)
+ endif()
+ if (LLVM_USE_SANITIZE_COVERAGE)
+ append("-fsanitize=fuzzer-no-link" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+ endif()
+endif()
+
+# Turn on -gsplit-dwarf if requested
+if(LLVM_USE_SPLIT_DWARF)
+ add_definitions("-gsplit-dwarf")
+endif()
+
+add_definitions( -D__STDC_CONSTANT_MACROS )
+add_definitions( -D__STDC_FORMAT_MACROS )
+add_definitions( -D__STDC_LIMIT_MACROS )
+
+# clang doesn't print colored diagnostics when invoked from Ninja
+if (UNIX AND
+ CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND
+ CMAKE_GENERATOR STREQUAL "Ninja")
+ append("-fcolor-diagnostics" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+endif()
+
+# lld doesn't print colored diagnostics when invoked from Ninja
+if (UNIX AND CMAKE_GENERATOR STREQUAL "Ninja")
+ include(CheckLinkerFlag)
+ check_linker_flag("-Wl,--color-diagnostics" LINKER_SUPPORTS_COLOR_DIAGNOSTICS)
+ append_if(LINKER_SUPPORTS_COLOR_DIAGNOSTICS "-Wl,--color-diagnostics"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+endif()
+
+# Add flags for add_dead_strip().
+# FIXME: With MSVS, consider compiling with /Gy and linking with /OPT:REF?
+# But MinSizeRel seems to add that automatically, so maybe disable these
+# flags instead if LLVM_NO_DEAD_STRIP is set.
+if(NOT CYGWIN AND NOT WIN32)
+ if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND
+ NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+ check_c_compiler_flag("-Werror -fno-function-sections" C_SUPPORTS_FNO_FUNCTION_SECTIONS)
+ if (C_SUPPORTS_FNO_FUNCTION_SECTIONS)
+ # Don't add -ffunction-section if it can be disabled with -fno-function-sections.
+ # Doing so will break sanitizers.
+ add_flag_if_supported("-ffunction-sections" FFUNCTION_SECTIONS)
+ endif()
+ add_flag_if_supported("-fdata-sections" FDATA_SECTIONS)
+ endif()
+endif()
+
+if(MSVC)
+ # Remove flags here, for exceptions and RTTI.
+ # Each target property or source property should be responsible to control
+ # them.
+ # CL.EXE complains to override flags like "/GR /GR-".
+ string(REGEX REPLACE "(^| ) */EH[-cs]+ *( |$)" "\\1 \\2" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+ string(REGEX REPLACE "(^| ) */GR-? *( |$)" "\\1 \\2" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+endif()
+
+# Provide public options to globally control RTTI and EH
+option(LLVM_ENABLE_EH "Enable Exception handling" OFF)
+option(LLVM_ENABLE_RTTI "Enable run time type information" OFF)
+if(LLVM_ENABLE_EH AND NOT LLVM_ENABLE_RTTI)
+ message(FATAL_ERROR "Exception handling requires RTTI. You must set LLVM_ENABLE_RTTI to ON")
+endif()
+
+option(LLVM_ENABLE_IR_PGO "Build LLVM and tools with IR PGO instrumentation (deprecated)" Off)
+mark_as_advanced(LLVM_ENABLE_IR_PGO)
+
+set(LLVM_BUILD_INSTRUMENTED OFF CACHE STRING "Build LLVM and tools with PGO instrumentation. May be specified as IR or Frontend")
+mark_as_advanced(LLVM_BUILD_INSTRUMENTED)
+string(TOUPPER "${LLVM_BUILD_INSTRUMENTED}" uppercase_LLVM_BUILD_INSTRUMENTED)
+
+if (LLVM_BUILD_INSTRUMENTED)
+ if (LLVM_ENABLE_IR_PGO OR uppercase_LLVM_BUILD_INSTRUMENTED STREQUAL "IR")
+ append("-fprofile-generate='${LLVM_PROFILE_DATA_DIR}'"
+ CMAKE_CXX_FLAGS
+ CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS
+ CMAKE_SHARED_LINKER_FLAGS)
+ else()
+ append("-fprofile-instr-generate='${LLVM_PROFILE_FILE_PATTERN}'"
+ CMAKE_CXX_FLAGS
+ CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS
+ CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+endif()
+
+option(LLVM_BUILD_INSTRUMENTED_COVERAGE "Build LLVM and tools with Code Coverage instrumentation" Off)
+mark_as_advanced(LLVM_BUILD_INSTRUMENTED_COVERAGE)
+append_if(LLVM_BUILD_INSTRUMENTED_COVERAGE "-fprofile-instr-generate='${LLVM_PROFILE_FILE_PATTERN}' -fcoverage-mapping"
+ CMAKE_CXX_FLAGS
+ CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS
+ CMAKE_SHARED_LINKER_FLAGS)
+
+if (LLVM_BUILD_INSTRUMENTED AND LLVM_BUILD_INSTRUMENTED_COVERAGE)
+ message(FATAL_ERROR "LLVM_BUILD_INSTRUMENTED and LLVM_BUILD_INSTRUMENTED_COVERAGE cannot both be specified")
+endif()
+
+if(LLVM_ENABLE_LTO AND LLVM_ON_WIN32 AND NOT LINKER_IS_LLD_LINK)
+ message(FATAL_ERROR "When compiling for Windows, LLVM_ENABLE_LTO requires using lld as the linker (point CMAKE_LINKER at lld-link.exe)")
+endif()
+if(uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")
+ append("-flto=thin" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+ if(NOT LINKER_IS_LLD_LINK)
+ append("-flto=thin" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+ # If the linker supports it, enable the lto cache. This improves initial build
+ # time a little since we re-link a lot of the same objects, and significantly
+ # improves incremental build time.
+ # FIXME: We should move all this logic into the clang driver.
+ if(APPLE)
+ append("-Wl,-cache_path_lto,${PROJECT_BINARY_DIR}/lto.cache"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ elseif(UNIX AND LLVM_USE_LINKER STREQUAL "lld")
+ append("-Wl,--thinlto-cache-dir=${PROJECT_BINARY_DIR}/lto.cache"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ elseif(LLVM_USE_LINKER STREQUAL "gold")
+ append("-Wl,--plugin-opt,cache-dir=${PROJECT_BINARY_DIR}/lto.cache"
+ CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+elseif(uppercase_LLVM_ENABLE_LTO STREQUAL "FULL")
+ append("-flto=full" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+ if(NOT LINKER_IS_LLD_LINK)
+ append("-flto=full" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+elseif(LLVM_ENABLE_LTO)
+ append("-flto" CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+ if(NOT LINKER_IS_LLD_LINK)
+ append("-flto" CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+ endif()
+endif()
+
+# This option makes utils/extract_symbols.py be used to determine the list of
+# symbols to export from LLVM tools. This is necessary when using MSVC if you
+# want to allow plugins, though note that the plugin has to explicitly link
+# against (exactly one) tool so we can't unilaterally turn on
+# LLVM_ENABLE_PLUGINS when it's enabled.
+option(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS "Export symbols from LLVM tools so that plugins can import them" OFF)
+if(BUILD_SHARED_LIBS AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
+ message(FATAL_ERROR "BUILD_SHARED_LIBS not compatible with LLVM_EXPORT_SYMBOLS_FOR_PLUGINS")
+endif()
+if(LLVM_LINK_LLVM_DYLIB AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
+ message(FATAL_ERROR "LLVM_LINK_LLVM_DYLIB not compatible with LLVM_EXPORT_SYMBOLS_FOR_PLUGINS")
+endif()
+
+# Plugin support
+# FIXME: Make this configurable.
+if(WIN32 OR CYGWIN)
+ if(BUILD_SHARED_LIBS OR LLVM_BUILD_LLVM_DYLIB)
+ set(LLVM_ENABLE_PLUGINS ON)
+ else()
+ set(LLVM_ENABLE_PLUGINS OFF)
+ endif()
+else()
+ set(LLVM_ENABLE_PLUGINS ON)
+endif()
+
+set(LLVM_ENABLE_IDE_default OFF)
+if (XCODE OR MSVC_IDE OR CMAKE_EXTRA_GENERATOR)
+ set(LLVM_ENABLE_IDE_default ON)
+endif()
+option(LLVM_ENABLE_IDE "Generate targets and process sources for use with an IDE"
+ ${LLVM_ENABLE_IDE_default})
+
+function(get_compile_definitions)
+ get_directory_property(top_dir_definitions DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS)
+ foreach(definition ${top_dir_definitions})
+ if(DEFINED result)
+ string(APPEND result " -D${definition}")
+ else()
+ set(result "-D${definition}")
+ endif()
+ endforeach()
+ set(LLVM_DEFINITIONS "${result}" PARENT_SCOPE)
+endfunction()
+get_compile_definitions()
+
+option(LLVM_FORCE_ENABLE_STATS "Enable statistics collection for builds that wouldn't normally enable it" OFF)
diff --git a/linux-x64/clang/lib64/cmake/llvm/HandleLLVMStdlib.cmake b/linux-x64/clang/lib64/cmake/llvm/HandleLLVMStdlib.cmake
new file mode 100644
index 0000000..c0512ac
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/HandleLLVMStdlib.cmake
@@ -0,0 +1,30 @@
+# This CMake module is responsible for setting the standard library to libc++
+# if the user has requested it.
+
+include(DetermineGCCCompatible)
+
+if(NOT DEFINED LLVM_STDLIB_HANDLED)
+ set(LLVM_STDLIB_HANDLED ON)
+
+ function(append value)
+ foreach(variable ${ARGN})
+ set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
+ endforeach(variable)
+ endfunction()
+
+ include(CheckCXXCompilerFlag)
+ if(LLVM_ENABLE_LIBCXX)
+ if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
+ check_cxx_compiler_flag("-stdlib=libc++" CXX_SUPPORTS_STDLIB)
+ if(CXX_SUPPORTS_STDLIB)
+ append("-stdlib=libc++"
+ CMAKE_CXX_FLAGS CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS
+ CMAKE_MODULE_LINKER_FLAGS)
+ else()
+ message(WARNING "Can't specify libc++ with '-stdlib='")
+ endif()
+ else()
+ message(WARNING "Not sure how to specify libc++ for this compiler")
+ endif()
+ endif()
+endif()
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVM-Config.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVM-Config.cmake
new file mode 100644
index 0000000..10fd526
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVM-Config.cmake
@@ -0,0 +1,320 @@
+function(get_system_libs return_var)
+ message(AUTHOR_WARNING "get_system_libs no longer needed")
+ set(${return_var} "" PARENT_SCOPE)
+endfunction()
+
+
+function(link_system_libs target)
+ message(AUTHOR_WARNING "link_system_libs no longer needed")
+endfunction()
+
+# is_llvm_target_library(
+# library
+# Name of the LLVM library to check
+# return_var
+# Output variable name
+# ALL_TARGETS;INCLUDED_TARGETS;OMITTED_TARGETS
+# ALL_TARGETS - default looks at the full list of known targets
+# INCLUDED_TARGETS - looks only at targets being configured
+# OMITTED_TARGETS - looks only at targets that are not being configured
+# )
+function(is_llvm_target_library library return_var)
+ cmake_parse_arguments(ARG "ALL_TARGETS;INCLUDED_TARGETS;OMITTED_TARGETS" "" "" ${ARGN})
+ # Sets variable `return_var' to ON if `library' corresponds to a
+ # LLVM supported target. To OFF if it doesn't.
+ set(${return_var} OFF PARENT_SCOPE)
+ string(TOUPPER "${library}" capitalized_lib)
+ if(ARG_INCLUDED_TARGETS)
+ string(TOUPPER "${LLVM_TARGETS_TO_BUILD}" targets)
+ elseif(ARG_OMITTED_TARGETS)
+ set(omitted_targets ${LLVM_ALL_TARGETS})
+ list(REMOVE_ITEM omitted_targets ${LLVM_TARGETS_TO_BUILD})
+ string(TOUPPER "${omitted_targets}" targets)
+ else()
+ string(TOUPPER "${LLVM_ALL_TARGETS}" targets)
+ endif()
+ foreach(t ${targets})
+ if( capitalized_lib STREQUAL t OR
+ capitalized_lib STREQUAL "${t}" OR
+ capitalized_lib STREQUAL "${t}DESC" OR
+ capitalized_lib STREQUAL "${t}CODEGEN" OR
+ capitalized_lib STREQUAL "${t}ASMPARSER" OR
+ capitalized_lib STREQUAL "${t}ASMPRINTER" OR
+ capitalized_lib STREQUAL "${t}DISASSEMBLER" OR
+ capitalized_lib STREQUAL "${t}INFO" OR
+ capitalized_lib STREQUAL "${t}UTILS" )
+ set(${return_var} ON PARENT_SCOPE)
+ break()
+ endif()
+ endforeach()
+endfunction(is_llvm_target_library)
+
+function(is_llvm_target_specifier library return_var)
+ is_llvm_target_library(${library} ${return_var} ${ARGN})
+ string(TOUPPER "${library}" capitalized_lib)
+ if(NOT ${return_var})
+ if( capitalized_lib STREQUAL "ALLTARGETSASMPARSERS" OR
+ capitalized_lib STREQUAL "ALLTARGETSDESCS" OR
+ capitalized_lib STREQUAL "ALLTARGETSDISASSEMBLERS" OR
+ capitalized_lib STREQUAL "ALLTARGETSINFOS" OR
+ capitalized_lib STREQUAL "NATIVE" OR
+ capitalized_lib STREQUAL "NATIVECODEGEN" )
+ set(${return_var} ON PARENT_SCOPE)
+ endif()
+ endif()
+endfunction()
+
+macro(llvm_config executable)
+ cmake_parse_arguments(ARG "USE_SHARED" "" "" ${ARGN})
+ set(link_components ${ARG_UNPARSED_ARGUMENTS})
+
+ if(USE_SHARED)
+ # If USE_SHARED is specified, then we link against libLLVM,
+ # but also against the component libraries below. This is
+ # done in case libLLVM does not contain all of the components
+ # the target requires.
+ #
+ # Strip LLVM_DYLIB_COMPONENTS out of link_components.
+ # To do this, we need special handling for "all", since that
+ # may imply linking to libraries that are not included in
+ # libLLVM.
+
+ if (DEFINED link_components AND DEFINED LLVM_DYLIB_COMPONENTS)
+ if("${LLVM_DYLIB_COMPONENTS}" STREQUAL "all")
+ set(link_components "")
+ else()
+ list(REMOVE_ITEM link_components ${LLVM_DYLIB_COMPONENTS})
+ endif()
+ endif()
+
+ target_link_libraries(${executable} PRIVATE LLVM)
+ endif()
+
+ explicit_llvm_config(${executable} ${link_components})
+endmacro(llvm_config)
+
+
+function(explicit_llvm_config executable)
+ set( link_components ${ARGN} )
+
+ llvm_map_components_to_libnames(LIBRARIES ${link_components})
+ get_target_property(t ${executable} TYPE)
+ if(t STREQUAL "STATIC_LIBRARY")
+ target_link_libraries(${executable} INTERFACE ${LIBRARIES})
+ elseif(t STREQUAL "EXECUTABLE" OR t STREQUAL "SHARED_LIBRARY" OR t STREQUAL "MODULE_LIBRARY")
+ target_link_libraries(${executable} PRIVATE ${LIBRARIES})
+ else()
+ # Use plain form for legacy user.
+ target_link_libraries(${executable} ${LIBRARIES})
+ endif()
+endfunction(explicit_llvm_config)
+
+
+# This is Deprecated
+function(llvm_map_components_to_libraries OUT_VAR)
+ message(AUTHOR_WARNING "Using llvm_map_components_to_libraries() is deprecated. Use llvm_map_components_to_libnames() instead")
+ explicit_map_components_to_libraries(result ${ARGN})
+ set( ${OUT_VAR} ${result} ${sys_result} PARENT_SCOPE )
+endfunction(llvm_map_components_to_libraries)
+
+# This is a variant intended for the final user:
+# Map LINK_COMPONENTS to actual libnames.
+function(llvm_map_components_to_libnames out_libs)
+ set( link_components ${ARGN} )
+ if(NOT LLVM_AVAILABLE_LIBS)
+ # Inside LLVM itself available libs are in a global property.
+ get_property(LLVM_AVAILABLE_LIBS GLOBAL PROPERTY LLVM_LIBS)
+ endif()
+ string(TOUPPER "${LLVM_AVAILABLE_LIBS}" capitalized_libs)
+
+ get_property(LLVM_TARGETS_CONFIGURED GLOBAL PROPERTY LLVM_TARGETS_CONFIGURED)
+
+ # Generally in our build system we avoid order-dependence. Unfortunately since
+ # not all targets create the same set of libraries we actually need to ensure
+ # that all build targets associated with a target are added before we can
+ # process target dependencies.
+ if(NOT LLVM_TARGETS_CONFIGURED)
+ foreach(c ${link_components})
+ is_llvm_target_specifier(${c} iltl_result ALL_TARGETS)
+ if(iltl_result)
+ message(FATAL_ERROR "Specified target library before target registration is complete.")
+ endif()
+ endforeach()
+ endif()
+
+ # Expand some keywords:
+ list(FIND LLVM_TARGETS_TO_BUILD "${LLVM_NATIVE_ARCH}" have_native_backend)
+ list(FIND link_components "engine" engine_required)
+ if( NOT engine_required EQUAL -1 )
+ list(FIND LLVM_TARGETS_WITH_JIT "${LLVM_NATIVE_ARCH}" have_jit)
+ if( NOT have_native_backend EQUAL -1 AND NOT have_jit EQUAL -1 )
+ list(APPEND link_components "jit")
+ list(APPEND link_components "native")
+ else()
+ list(APPEND link_components "interpreter")
+ endif()
+ endif()
+ list(FIND link_components "native" native_required)
+ if( NOT native_required EQUAL -1 )
+ if( NOT have_native_backend EQUAL -1 )
+ list(APPEND link_components ${LLVM_NATIVE_ARCH})
+ endif()
+ endif()
+
+ # Translate symbolic component names to real libraries:
+ foreach(c ${link_components})
+ # add codegen, asmprinter, asmparser, disassembler
+ list(FIND LLVM_TARGETS_TO_BUILD ${c} idx)
+ if( NOT idx LESS 0 )
+ if( TARGET LLVM${c}CodeGen )
+ list(APPEND expanded_components "LLVM${c}CodeGen")
+ else()
+ if( TARGET LLVM${c} )
+ list(APPEND expanded_components "LLVM${c}")
+ else()
+ message(FATAL_ERROR "Target ${c} is not in the set of libraries.")
+ endif()
+ endif()
+ if( TARGET LLVM${c}AsmParser )
+ list(APPEND expanded_components "LLVM${c}AsmParser")
+ endif()
+ if( TARGET LLVM${c}AsmPrinter )
+ list(APPEND expanded_components "LLVM${c}AsmPrinter")
+ endif()
+ if( TARGET LLVM${c}Desc )
+ list(APPEND expanded_components "LLVM${c}Desc")
+ endif()
+ if( TARGET LLVM${c}Disassembler )
+ list(APPEND expanded_components "LLVM${c}Disassembler")
+ endif()
+ if( TARGET LLVM${c}Info )
+ list(APPEND expanded_components "LLVM${c}Info")
+ endif()
+ if( TARGET LLVM${c}Utils )
+ list(APPEND expanded_components "LLVM${c}Utils")
+ endif()
+ elseif( c STREQUAL "native" )
+ # already processed
+ elseif( c STREQUAL "nativecodegen" )
+ list(APPEND expanded_components "LLVM${LLVM_NATIVE_ARCH}CodeGen")
+ if( TARGET LLVM${LLVM_NATIVE_ARCH}Desc )
+ list(APPEND expanded_components "LLVM${LLVM_NATIVE_ARCH}Desc")
+ endif()
+ if( TARGET LLVM${LLVM_NATIVE_ARCH}Info )
+ list(APPEND expanded_components "LLVM${LLVM_NATIVE_ARCH}Info")
+ endif()
+ elseif( c STREQUAL "backend" )
+ # same case as in `native'.
+ elseif( c STREQUAL "engine" )
+ # already processed
+ elseif( c STREQUAL "all" )
+ list(APPEND expanded_components ${LLVM_AVAILABLE_LIBS})
+ elseif( c STREQUAL "AllTargetsAsmPrinters" )
+ # Link all the asm printers from all the targets
+ foreach(t ${LLVM_TARGETS_TO_BUILD})
+ if( TARGET LLVM${t}AsmPrinter )
+ list(APPEND expanded_components "LLVM${t}AsmPrinter")
+ endif()
+ endforeach(t)
+ elseif( c STREQUAL "AllTargetsAsmParsers" )
+ # Link all the asm parsers from all the targets
+ foreach(t ${LLVM_TARGETS_TO_BUILD})
+ if( TARGET LLVM${t}AsmParser )
+ list(APPEND expanded_components "LLVM${t}AsmParser")
+ endif()
+ endforeach(t)
+ elseif( c STREQUAL "AllTargetsDescs" )
+ # Link all the descs from all the targets
+ foreach(t ${LLVM_TARGETS_TO_BUILD})
+ if( TARGET LLVM${t}Desc )
+ list(APPEND expanded_components "LLVM${t}Desc")
+ endif()
+ endforeach(t)
+ elseif( c STREQUAL "AllTargetsDisassemblers" )
+ # Link all the disassemblers from all the targets
+ foreach(t ${LLVM_TARGETS_TO_BUILD})
+ if( TARGET LLVM${t}Disassembler )
+ list(APPEND expanded_components "LLVM${t}Disassembler")
+ endif()
+ endforeach(t)
+ elseif( c STREQUAL "AllTargetsInfos" )
+ # Link all the infos from all the targets
+ foreach(t ${LLVM_TARGETS_TO_BUILD})
+ if( TARGET LLVM${t}Info )
+ list(APPEND expanded_components "LLVM${t}Info")
+ endif()
+ endforeach(t)
+ else( NOT idx LESS 0 )
+ # Canonize the component name:
+ string(TOUPPER "${c}" capitalized)
+ list(FIND capitalized_libs LLVM${capitalized} lib_idx)
+ if( lib_idx LESS 0 )
+ # The component is unknown. Maybe is an omitted target?
+ is_llvm_target_library(${c} iltl_result OMITTED_TARGETS)
+ if(iltl_result)
+ # A missing library to a directly referenced omitted target would be bad.
+ message(FATAL_ERROR "Library '${c}' is a direct reference to a target library for an omitted target.")
+ else()
+ # If it is not an omitted target we should assume it is a component
+ # that hasn't yet been processed by CMake. Missing components will
+ # cause errors later in the configuration, so we can safely assume
+ # that this is valid here.
+ list(APPEND expanded_components LLVM${c})
+ endif()
+ else( lib_idx LESS 0 )
+ list(GET LLVM_AVAILABLE_LIBS ${lib_idx} canonical_lib)
+ list(APPEND expanded_components ${canonical_lib})
+ endif( lib_idx LESS 0 )
+ endif( NOT idx LESS 0 )
+ endforeach(c)
+
+ set(${out_libs} ${expanded_components} PARENT_SCOPE)
+endfunction()
+
+# Perform a post-order traversal of the dependency graph.
+# This duplicates the algorithm used by llvm-config, originally
+# in tools/llvm-config/llvm-config.cpp, function ComputeLibsForComponents.
+function(expand_topologically name required_libs visited_libs)
+ list(FIND visited_libs ${name} found)
+ if( found LESS 0 )
+ list(APPEND visited_libs ${name})
+ set(visited_libs ${visited_libs} PARENT_SCOPE)
+
+ get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name})
+ foreach( lib_dep ${lib_deps} )
+ expand_topologically(${lib_dep} "${required_libs}" "${visited_libs}")
+ set(required_libs ${required_libs} PARENT_SCOPE)
+ set(visited_libs ${visited_libs} PARENT_SCOPE)
+ endforeach()
+
+ list(APPEND required_libs ${name})
+ set(required_libs ${required_libs} PARENT_SCOPE)
+ endif()
+endfunction()
+
+# Expand dependencies while topologically sorting the list of libraries:
+function(llvm_expand_dependencies out_libs)
+ set(expanded_components ${ARGN})
+
+ set(required_libs)
+ set(visited_libs)
+ foreach( lib ${expanded_components} )
+ expand_topologically(${lib} "${required_libs}" "${visited_libs}")
+ endforeach()
+
+ list(REVERSE required_libs)
+ set(${out_libs} ${required_libs} PARENT_SCOPE)
+endfunction()
+
+function(explicit_map_components_to_libraries out_libs)
+ llvm_map_components_to_libnames(link_libs ${ARGN})
+ llvm_expand_dependencies(expanded_components ${link_libs})
+ # Return just the libraries included in this build:
+ set(result)
+ foreach(c ${expanded_components})
+ if( TARGET ${c} )
+ set(result ${result} ${c})
+ endif()
+ endforeach(c)
+ set(${out_libs} ${result} PARENT_SCOPE)
+endfunction(explicit_map_components_to_libraries)
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMConfig.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMConfig.cmake
new file mode 100644
index 0000000..c0dbbf6
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMConfig.cmake
@@ -0,0 +1,181 @@
+# This file provides information and services to the final user.
+
+
+# Compute the installation prefix from this LLVMConfig.cmake file location.
+get_filename_component(LLVM_INSTALL_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(LLVM_INSTALL_PREFIX "${LLVM_INSTALL_PREFIX}" PATH)
+get_filename_component(LLVM_INSTALL_PREFIX "${LLVM_INSTALL_PREFIX}" PATH)
+get_filename_component(LLVM_INSTALL_PREFIX "${LLVM_INSTALL_PREFIX}" PATH)
+
+set(LLVM_VERSION_MAJOR 7)
+set(LLVM_VERSION_MINOR 0)
+set(LLVM_VERSION_PATCH 2)
+set(LLVM_PACKAGE_VERSION 7.0.2svn)
+
+set(LLVM_BUILD_TYPE Release)
+
+set(LLVM_COMMON_DEPENDS )
+
+set(LLVM_AVAILABLE_LIBS LLVMDemangle;LLVMSupport;LLVMTableGen;LLVMCore;LLVMFuzzMutate;LLVMIRReader;LLVMCodeGen;LLVMSelectionDAG;LLVMAsmPrinter;LLVMMIRParser;LLVMGlobalISel;LLVMBinaryFormat;LLVMBitReader;LLVMBitWriter;LLVMTransformUtils;LLVMInstrumentation;LLVMAggressiveInstCombine;LLVMInstCombine;LLVMScalarOpts;LLVMipo;LLVMVectorize;LLVMObjCARCOpts;LLVMCoroutines;LLVMLinker;LLVMAnalysis;LLVMLTO;LLVMMC;LLVMMCParser;LLVMMCDisassembler;LLVMObject;LLVMObjectYAML;LLVMOption;LLVMDebugInfoDWARF;LLVMDebugInfoMSF;LLVMDebugInfoCodeView;LLVMDebugInfoPDB;LLVMSymbolize;LLVMExecutionEngine;LLVMInterpreter;LLVMMCJIT;LLVMOrcJIT;LLVMRuntimeDyld;LLVMTarget;LLVMAArch64CodeGen;LLVMAArch64Info;LLVMAArch64AsmParser;LLVMAArch64Disassembler;LLVMAArch64AsmPrinter;LLVMAArch64Desc;LLVMAArch64Utils;LLVMARMCodeGen;LLVMARMInfo;LLVMARMAsmParser;LLVMARMDisassembler;LLVMARMAsmPrinter;LLVMARMDesc;LLVMARMUtils;LLVMBPFCodeGen;LLVMBPFAsmParser;LLVMBPFDisassembler;LLVMBPFAsmPrinter;LLVMBPFInfo;LLVMBPFDesc;LLVMX86CodeGen;LLVMX86AsmParser;LLVMX86Disassembler;LLVMX86AsmPrinter;LLVMX86Desc;LLVMX86Info;LLVMX86Utils;LLVMAsmParser;LLVMLineEditor;LLVMProfileData;LLVMCoverage;LLVMPasses;LLVMDlltoolDriver;LLVMLibDriver;LLVMXRay;LLVMWindowsManifest;LTO;LLVM)
+
+set(LLVM_DYLIB_COMPONENTS all)
+
+set(LLVM_ALL_TARGETS AArch64;AMDGPU;ARM;BPF;Hexagon;Lanai;Mips;MSP430;NVPTX;PowerPC;Sparc;SystemZ;X86;XCore)
+
+set(LLVM_TARGETS_TO_BUILD AArch64;ARM;BPF;X86)
+
+set(LLVM_TARGETS_WITH_JIT X86;PowerPC;AArch64;ARM;Mips;SystemZ)
+
+
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMDemangle )
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMSupport LLVMDemangle)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMTableGen LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMCore LLVMBinaryFormat;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMFuzzMutate LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCore;LLVMScalarOpts;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMIRReader LLVMAsmParser;LLVMBitReader;LLVMCore;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMCodeGen LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCore;LLVMMC;LLVMProfileData;LLVMScalarOpts;LLVMSupport;LLVMTarget;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMSelectionDAG LLVMAnalysis;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSupport;LLVMTarget;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAsmPrinter LLVMAnalysis;LLVMBinaryFormat;LLVMCodeGen;LLVMCore;LLVMDebugInfoCodeView;LLVMDebugInfoMSF;LLVMMC;LLVMMCParser;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMMIRParser LLVMAsmParser;LLVMBinaryFormat;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMGlobalISel LLVMAnalysis;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSupport;LLVMTarget;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBinaryFormat LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBitReader LLVMCore;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBitWriter LLVMAnalysis;LLVMCore;LLVMMC;LLVMObject;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMTransformUtils LLVMAnalysis;LLVMCore;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMInstrumentation LLVMAnalysis;LLVMCore;LLVMMC;LLVMProfileData;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAggressiveInstCombine LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMInstCombine LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMScalarOpts LLVMAggressiveInstCombine;LLVMAnalysis;LLVMCore;LLVMInstCombine;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMipo LLVMAggressiveInstCombine;LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCore;LLVMIRReader;LLVMInstCombine;LLVMInstrumentation;LLVMLinker;LLVMObject;LLVMProfileData;LLVMScalarOpts;LLVMSupport;LLVMTransformUtils;LLVMVectorize)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMVectorize LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMObjCARCOpts LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMCoroutines LLVMAnalysis;LLVMCore;LLVMScalarOpts;LLVMSupport;LLVMTransformUtils;LLVMipo)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMLinker LLVMCore;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAnalysis LLVMBinaryFormat;LLVMCore;LLVMObject;LLVMProfileData;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMLTO LLVMAggressiveInstCombine;LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCodeGen;LLVMCore;LLVMInstCombine;LLVMLinker;LLVMMC;LLVMObjCARCOpts;LLVMObject;LLVMPasses;LLVMScalarOpts;LLVMSupport;LLVMTarget;LLVMTransformUtils;LLVMipo)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMMC LLVMDebugInfoCodeView;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMMCParser LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMMCDisassembler LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMObject LLVMBinaryFormat;LLVMBitReader;LLVMCore;LLVMMC;LLVMMCParser;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMObjectYAML LLVMDebugInfoCodeView;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMOption LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMDebugInfoDWARF LLVMBinaryFormat;LLVMMC;LLVMObject;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMDebugInfoMSF LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMDebugInfoCodeView LLVMDebugInfoMSF;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMDebugInfoPDB LLVMDebugInfoCodeView;LLVMDebugInfoMSF;LLVMObject;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMSymbolize LLVMDebugInfoDWARF;LLVMDebugInfoPDB;LLVMDemangle;LLVMObject;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMExecutionEngine LLVMCore;LLVMMC;LLVMObject;LLVMRuntimeDyld;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMInterpreter LLVMCodeGen;LLVMCore;LLVMExecutionEngine;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMMCJIT LLVMCore;LLVMExecutionEngine;LLVMObject;LLVMRuntimeDyld;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMOrcJIT LLVMCore;LLVMExecutionEngine;LLVMObject;LLVMRuntimeDyld;LLVMSupport;LLVMTransformUtils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMRuntimeDyld LLVMMC;LLVMObject;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMTarget LLVMAnalysis;LLVMCore;LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64CodeGen LLVMAArch64AsmPrinter;LLVMAArch64Desc;LLVMAArch64Info;LLVMAArch64Utils;LLVMAnalysis;LLVMAsmPrinter;LLVMCodeGen;LLVMCore;LLVMGlobalISel;LLVMMC;LLVMScalarOpts;LLVMSelectionDAG;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64Info LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64AsmParser LLVMAArch64Desc;LLVMAArch64Info;LLVMAArch64Utils;LLVMMC;LLVMMCParser;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64Disassembler LLVMAArch64Desc;LLVMAArch64Info;LLVMAArch64Utils;LLVMMC;LLVMMCDisassembler;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64AsmPrinter LLVMAArch64Utils;LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64Desc LLVMAArch64AsmPrinter;LLVMAArch64Info;LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAArch64Utils LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMCodeGen LLVMARMAsmPrinter;LLVMARMDesc;LLVMARMInfo;LLVMARMUtils;LLVMAnalysis;LLVMAsmPrinter;LLVMCodeGen;LLVMCore;LLVMGlobalISel;LLVMMC;LLVMScalarOpts;LLVMSelectionDAG;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMInfo LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMAsmParser LLVMARMDesc;LLVMARMInfo;LLVMARMUtils;LLVMMC;LLVMMCParser;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMDisassembler LLVMARMDesc;LLVMARMInfo;LLVMARMUtils;LLVMMCDisassembler;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMAsmPrinter LLVMARMUtils;LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMDesc LLVMARMAsmPrinter;LLVMARMInfo;LLVMMC;LLVMMCDisassembler;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMARMUtils LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBPFCodeGen LLVMAsmPrinter;LLVMBPFAsmPrinter;LLVMBPFDesc;LLVMBPFInfo;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSelectionDAG;LLVMSupport;LLVMTarget)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBPFAsmParser LLVMBPFDesc;LLVMBPFInfo;LLVMMC;LLVMMCParser;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBPFDisassembler LLVMBPFInfo;LLVMMCDisassembler;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBPFAsmPrinter LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBPFInfo LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMBPFDesc LLVMBPFAsmPrinter;LLVMBPFInfo;LLVMMC;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86CodeGen LLVMAnalysis;LLVMAsmPrinter;LLVMCodeGen;LLVMCore;LLVMGlobalISel;LLVMMC;LLVMSelectionDAG;LLVMSupport;LLVMTarget;LLVMX86AsmPrinter;LLVMX86Desc;LLVMX86Info;LLVMX86Utils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86AsmParser LLVMMC;LLVMMCParser;LLVMSupport;LLVMX86AsmPrinter;LLVMX86Desc;LLVMX86Info)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86Disassembler LLVMMCDisassembler;LLVMSupport;LLVMX86Info)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86AsmPrinter LLVMMC;LLVMSupport;LLVMX86Utils)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86Desc LLVMMC;LLVMMCDisassembler;LLVMObject;LLVMSupport;LLVMX86AsmPrinter;LLVMX86Info)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86Info LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMX86Utils LLVMCore;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMAsmParser LLVMBinaryFormat;LLVMCore;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMLineEditor LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMProfileData LLVMCore;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMCoverage LLVMCore;LLVMObject;LLVMProfileData;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMPasses LLVMAggressiveInstCombine;LLVMAnalysis;LLVMCodeGen;LLVMCore;LLVMInstCombine;LLVMInstrumentation;LLVMScalarOpts;LLVMSupport;LLVMTarget;LLVMTransformUtils;LLVMVectorize;LLVMipo)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMDlltoolDriver LLVMObject;LLVMOption;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMLibDriver LLVMBinaryFormat;LLVMObject;LLVMOption;LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMXRay )
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVMWindowsManifest LLVMSupport)
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LTO )
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_LLVM )
+
+set(TARGET_TRIPLE "x86_64-unknown-linux-gnu")
+
+set(LLVM_ABI_BREAKING_CHECKS WITH_ASSERTS)
+
+set(LLVM_ENABLE_ASSERTIONS OFF)
+
+set(LLVM_ENABLE_EH OFF)
+
+set(LLVM_ENABLE_RTTI OFF)
+
+set(LLVM_ENABLE_TERMINFO OFF)
+
+set(LLVM_ENABLE_THREADS ON)
+
+set(LLVM_ENABLE_ZLIB ON)
+
+set(LLVM_LIBXML2_ENABLED 0)
+
+set(LLVM_ENABLE_DIA_SDK 0)
+
+set(LLVM_NATIVE_ARCH X86)
+
+set(LLVM_ENABLE_PIC ON)
+
+set(LLVM_BUILD_32_BITS OFF)
+
+if (NOT "-lpthread" STREQUAL "")
+ set(LLVM_PTHREAD_LIB "-lpthread")
+endif()
+
+set(LLVM_ENABLE_PLUGINS ON)
+set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS OFF)
+set(LLVM_PLUGIN_EXT .so)
+
+set(LLVM_ON_UNIX 1)
+set(LLVM_ON_WIN32 0)
+
+set(LLVM_LIBDIR_SUFFIX 64)
+
+set(LLVM_INCLUDE_DIRS "${LLVM_INSTALL_PREFIX}/include")
+set(LLVM_LIBRARY_DIRS "${LLVM_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}")
+
+# These variables are duplicated, but they must match the LLVM variables of the
+# same name. The variables ending in "S" could some day become lists, and are
+# preserved for convention and compatibility.
+set(LLVM_INCLUDE_DIR "${LLVM_INSTALL_PREFIX}/include")
+set(LLVM_LIBRARY_DIR "${LLVM_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}")
+
+set(LLVM_DEFINITIONS "-D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS")
+set(LLVM_CMAKE_DIR "${LLVM_INSTALL_PREFIX}/lib64/cmake/llvm")
+set(LLVM_BINARY_DIR "${LLVM_INSTALL_PREFIX}")
+set(LLVM_TOOLS_BINARY_DIR "${LLVM_INSTALL_PREFIX}/bin")
+set(LLVM_TOOLS_INSTALL_DIR "bin")
+set(LLVM_HAVE_OPT_VIEWER_MODULES 0)
+
+if(NOT TARGET LLVMSupport)
+ set(LLVM_EXPORTED_TARGETS "LLVMDemangle;LLVMSupport;LLVMTableGen;llvm-tblgen;LLVMCore;LLVMFuzzMutate;LLVMIRReader;LLVMCodeGen;LLVMSelectionDAG;LLVMAsmPrinter;LLVMMIRParser;LLVMGlobalISel;LLVMBinaryFormat;LLVMBitReader;LLVMBitWriter;LLVMTransformUtils;LLVMInstrumentation;LLVMAggressiveInstCombine;LLVMInstCombine;LLVMScalarOpts;LLVMipo;LLVMVectorize;LLVMHello;LLVMObjCARCOpts;LLVMCoroutines;LLVMLinker;LLVMAnalysis;LLVMLTO;LLVMMC;LLVMMCParser;LLVMMCDisassembler;LLVMObject;LLVMObjectYAML;LLVMOption;LLVMDebugInfoDWARF;LLVMDebugInfoMSF;LLVMDebugInfoCodeView;LLVMDebugInfoPDB;LLVMSymbolize;LLVMExecutionEngine;LLVMInterpreter;LLVMMCJIT;LLVMOrcJIT;LLVMRuntimeDyld;LLVMTarget;LLVMAArch64CodeGen;LLVMAArch64Info;LLVMAArch64AsmParser;LLVMAArch64Disassembler;LLVMAArch64AsmPrinter;LLVMAArch64Desc;LLVMAArch64Utils;LLVMARMCodeGen;LLVMARMInfo;LLVMARMAsmParser;LLVMARMDisassembler;LLVMARMAsmPrinter;LLVMARMDesc;LLVMARMUtils;LLVMBPFCodeGen;LLVMBPFAsmParser;LLVMBPFDisassembler;LLVMBPFAsmPrinter;LLVMBPFInfo;LLVMBPFDesc;LLVMX86CodeGen;LLVMX86AsmParser;LLVMX86Disassembler;LLVMX86AsmPrinter;LLVMX86Desc;LLVMX86Info;LLVMX86Utils;LLVMAsmParser;LLVMLineEditor;LLVMProfileData;LLVMCoverage;LLVMPasses;LLVMDlltoolDriver;LLVMLibDriver;LLVMXRay;LLVMWindowsManifest;LTO;LLVMgold;llvm-ar;llvm-config;llvm-lto;llvm-profdata;clang-tblgen;bugpoint;BugpointPasses;dsymutil;llc;lli;llvm-as;llvm-bcanalyzer;llvm-c-test;llvm-cat;llvm-cfi-verify;llvm-cov;llvm-cvtres;llvm-cxxdump;llvm-cxxfilt;llvm-diff;llvm-dis;llvm-dwarfdump;llvm-dwp;llvm-extract;llvm-link;llvm-lto2;llvm-mc;llvm-mca;llvm-mcmarkup;llvm-modextract;llvm-mt;llvm-nm;llvm-objcopy;llvm-objdump;llvm-opt-report;llvm-pdbutil;llvm-rc;llvm-readobj;llvm-rtdyld;LLVM;llvm-size;llvm-split;llvm-stress;llvm-strings;llvm-symbolizer;llvm-xray;obj2yaml;opt;sancov;sanstats;verify-uselistorder;yaml2obj")
+ include("${LLVM_CMAKE_DIR}/LLVMExports.cmake")
+
+endif()
+
+# By creating intrinsics_gen here, subprojects that depend on LLVM's
+# tablegen-generated headers can always depend on this target whether building
+# in-tree with LLVM or not.
+if(NOT TARGET intrinsics_gen)
+ add_custom_target(intrinsics_gen)
+endif()
+
+set_property(GLOBAL PROPERTY LLVM_TARGETS_CONFIGURED On)
+include(${LLVM_CMAKE_DIR}/LLVM-Config.cmake)
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMConfigVersion.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMConfigVersion.cmake
new file mode 100644
index 0000000..239f608
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMConfigVersion.cmake
@@ -0,0 +1,13 @@
+set(PACKAGE_VERSION "7.0.2svn")
+
+# LLVM is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("7.0" VERSION_EQUAL
+ "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+ AND NOT "2" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+ set(PACKAGE_VERSION_COMPATIBLE 1)
+ if("2" VERSION_EQUAL
+ "${PACKAGE_FIND_VERSION_PATCH}")
+ set(PACKAGE_VERSION_EXACT 1)
+ endif()
+endif()
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMExports-release.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMExports-release.cmake
new file mode 100644
index 0000000..ef8112e
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMExports-release.cmake
@@ -0,0 +1,1299 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "LLVMDemangle" for configuration "Release"
+set_property(TARGET LLVMDemangle APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMDemangle PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMDemangle.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMDemangle )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMDemangle "${_IMPORT_PREFIX}/lib64/libLLVMDemangle.a" )
+
+# Import target "LLVMSupport" for configuration "Release"
+set_property(TARGET LLVMSupport APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMSupport PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C;CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMSupport.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMSupport )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMSupport "${_IMPORT_PREFIX}/lib64/libLLVMSupport.a" )
+
+# Import target "LLVMTableGen" for configuration "Release"
+set_property(TARGET LLVMTableGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMTableGen PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMTableGen.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMTableGen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMTableGen "${_IMPORT_PREFIX}/lib64/libLLVMTableGen.a" )
+
+# Import target "llvm-tblgen" for configuration "Release"
+set_property(TARGET llvm-tblgen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-tblgen PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-tblgen"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-tblgen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-tblgen "${_IMPORT_PREFIX}/bin/llvm-tblgen" )
+
+# Import target "LLVMCore" for configuration "Release"
+set_property(TARGET LLVMCore APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMCore PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMCore.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMCore )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMCore "${_IMPORT_PREFIX}/lib64/libLLVMCore.a" )
+
+# Import target "LLVMFuzzMutate" for configuration "Release"
+set_property(TARGET LLVMFuzzMutate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMFuzzMutate PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMFuzzMutate.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMFuzzMutate )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMFuzzMutate "${_IMPORT_PREFIX}/lib64/libLLVMFuzzMutate.a" )
+
+# Import target "LLVMIRReader" for configuration "Release"
+set_property(TARGET LLVMIRReader APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMIRReader PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMIRReader.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMIRReader )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMIRReader "${_IMPORT_PREFIX}/lib64/libLLVMIRReader.a" )
+
+# Import target "LLVMCodeGen" for configuration "Release"
+set_property(TARGET LLVMCodeGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMCodeGen PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMCodeGen.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMCodeGen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMCodeGen "${_IMPORT_PREFIX}/lib64/libLLVMCodeGen.a" )
+
+# Import target "LLVMSelectionDAG" for configuration "Release"
+set_property(TARGET LLVMSelectionDAG APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMSelectionDAG PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMSelectionDAG.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMSelectionDAG )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMSelectionDAG "${_IMPORT_PREFIX}/lib64/libLLVMSelectionDAG.a" )
+
+# Import target "LLVMAsmPrinter" for configuration "Release"
+set_property(TARGET LLVMAsmPrinter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAsmPrinter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAsmPrinter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAsmPrinter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAsmPrinter "${_IMPORT_PREFIX}/lib64/libLLVMAsmPrinter.a" )
+
+# Import target "LLVMMIRParser" for configuration "Release"
+set_property(TARGET LLVMMIRParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMMIRParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMMIRParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMMIRParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMMIRParser "${_IMPORT_PREFIX}/lib64/libLLVMMIRParser.a" )
+
+# Import target "LLVMGlobalISel" for configuration "Release"
+set_property(TARGET LLVMGlobalISel APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMGlobalISel PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMGlobalISel.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMGlobalISel )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMGlobalISel "${_IMPORT_PREFIX}/lib64/libLLVMGlobalISel.a" )
+
+# Import target "LLVMBinaryFormat" for configuration "Release"
+set_property(TARGET LLVMBinaryFormat APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBinaryFormat PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBinaryFormat.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBinaryFormat )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBinaryFormat "${_IMPORT_PREFIX}/lib64/libLLVMBinaryFormat.a" )
+
+# Import target "LLVMBitReader" for configuration "Release"
+set_property(TARGET LLVMBitReader APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBitReader PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBitReader.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBitReader )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBitReader "${_IMPORT_PREFIX}/lib64/libLLVMBitReader.a" )
+
+# Import target "LLVMBitWriter" for configuration "Release"
+set_property(TARGET LLVMBitWriter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBitWriter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBitWriter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBitWriter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBitWriter "${_IMPORT_PREFIX}/lib64/libLLVMBitWriter.a" )
+
+# Import target "LLVMTransformUtils" for configuration "Release"
+set_property(TARGET LLVMTransformUtils APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMTransformUtils PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMTransformUtils.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMTransformUtils )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMTransformUtils "${_IMPORT_PREFIX}/lib64/libLLVMTransformUtils.a" )
+
+# Import target "LLVMInstrumentation" for configuration "Release"
+set_property(TARGET LLVMInstrumentation APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMInstrumentation PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMInstrumentation.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMInstrumentation )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMInstrumentation "${_IMPORT_PREFIX}/lib64/libLLVMInstrumentation.a" )
+
+# Import target "LLVMAggressiveInstCombine" for configuration "Release"
+set_property(TARGET LLVMAggressiveInstCombine APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAggressiveInstCombine PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAggressiveInstCombine.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAggressiveInstCombine )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAggressiveInstCombine "${_IMPORT_PREFIX}/lib64/libLLVMAggressiveInstCombine.a" )
+
+# Import target "LLVMInstCombine" for configuration "Release"
+set_property(TARGET LLVMInstCombine APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMInstCombine PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMInstCombine.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMInstCombine )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMInstCombine "${_IMPORT_PREFIX}/lib64/libLLVMInstCombine.a" )
+
+# Import target "LLVMScalarOpts" for configuration "Release"
+set_property(TARGET LLVMScalarOpts APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMScalarOpts PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMScalarOpts.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMScalarOpts )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMScalarOpts "${_IMPORT_PREFIX}/lib64/libLLVMScalarOpts.a" )
+
+# Import target "LLVMipo" for configuration "Release"
+set_property(TARGET LLVMipo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMipo PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMipo.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMipo )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMipo "${_IMPORT_PREFIX}/lib64/libLLVMipo.a" )
+
+# Import target "LLVMVectorize" for configuration "Release"
+set_property(TARGET LLVMVectorize APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMVectorize PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMVectorize.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMVectorize )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMVectorize "${_IMPORT_PREFIX}/lib64/libLLVMVectorize.a" )
+
+# Import target "LLVMHello" for configuration "Release"
+set_property(TARGET LLVMHello APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMHello PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/LLVMHello.so"
+ IMPORTED_NO_SONAME_RELEASE "TRUE"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMHello )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMHello "${_IMPORT_PREFIX}/lib64/LLVMHello.so" )
+
+# Import target "LLVMObjCARCOpts" for configuration "Release"
+set_property(TARGET LLVMObjCARCOpts APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMObjCARCOpts PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMObjCARCOpts.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMObjCARCOpts )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMObjCARCOpts "${_IMPORT_PREFIX}/lib64/libLLVMObjCARCOpts.a" )
+
+# Import target "LLVMCoroutines" for configuration "Release"
+set_property(TARGET LLVMCoroutines APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMCoroutines PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMCoroutines.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMCoroutines )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMCoroutines "${_IMPORT_PREFIX}/lib64/libLLVMCoroutines.a" )
+
+# Import target "LLVMLinker" for configuration "Release"
+set_property(TARGET LLVMLinker APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMLinker PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMLinker.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMLinker )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMLinker "${_IMPORT_PREFIX}/lib64/libLLVMLinker.a" )
+
+# Import target "LLVMAnalysis" for configuration "Release"
+set_property(TARGET LLVMAnalysis APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAnalysis PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAnalysis.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAnalysis )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAnalysis "${_IMPORT_PREFIX}/lib64/libLLVMAnalysis.a" )
+
+# Import target "LLVMLTO" for configuration "Release"
+set_property(TARGET LLVMLTO APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMLTO PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMLTO.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMLTO )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMLTO "${_IMPORT_PREFIX}/lib64/libLLVMLTO.a" )
+
+# Import target "LLVMMC" for configuration "Release"
+set_property(TARGET LLVMMC APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMMC PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMMC.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMMC )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMMC "${_IMPORT_PREFIX}/lib64/libLLVMMC.a" )
+
+# Import target "LLVMMCParser" for configuration "Release"
+set_property(TARGET LLVMMCParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMMCParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMMCParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMMCParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMMCParser "${_IMPORT_PREFIX}/lib64/libLLVMMCParser.a" )
+
+# Import target "LLVMMCDisassembler" for configuration "Release"
+set_property(TARGET LLVMMCDisassembler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMMCDisassembler PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMMCDisassembler.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMMCDisassembler )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMMCDisassembler "${_IMPORT_PREFIX}/lib64/libLLVMMCDisassembler.a" )
+
+# Import target "LLVMObject" for configuration "Release"
+set_property(TARGET LLVMObject APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMObject PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMObject.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMObject )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMObject "${_IMPORT_PREFIX}/lib64/libLLVMObject.a" )
+
+# Import target "LLVMObjectYAML" for configuration "Release"
+set_property(TARGET LLVMObjectYAML APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMObjectYAML PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMObjectYAML.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMObjectYAML )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMObjectYAML "${_IMPORT_PREFIX}/lib64/libLLVMObjectYAML.a" )
+
+# Import target "LLVMOption" for configuration "Release"
+set_property(TARGET LLVMOption APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMOption PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMOption.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMOption )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMOption "${_IMPORT_PREFIX}/lib64/libLLVMOption.a" )
+
+# Import target "LLVMDebugInfoDWARF" for configuration "Release"
+set_property(TARGET LLVMDebugInfoDWARF APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMDebugInfoDWARF PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoDWARF.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMDebugInfoDWARF )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMDebugInfoDWARF "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoDWARF.a" )
+
+# Import target "LLVMDebugInfoMSF" for configuration "Release"
+set_property(TARGET LLVMDebugInfoMSF APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMDebugInfoMSF PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoMSF.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMDebugInfoMSF )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMDebugInfoMSF "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoMSF.a" )
+
+# Import target "LLVMDebugInfoCodeView" for configuration "Release"
+set_property(TARGET LLVMDebugInfoCodeView APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMDebugInfoCodeView PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoCodeView.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMDebugInfoCodeView )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMDebugInfoCodeView "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoCodeView.a" )
+
+# Import target "LLVMDebugInfoPDB" for configuration "Release"
+set_property(TARGET LLVMDebugInfoPDB APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMDebugInfoPDB PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoPDB.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMDebugInfoPDB )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMDebugInfoPDB "${_IMPORT_PREFIX}/lib64/libLLVMDebugInfoPDB.a" )
+
+# Import target "LLVMSymbolize" for configuration "Release"
+set_property(TARGET LLVMSymbolize APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMSymbolize PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMSymbolize.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMSymbolize )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMSymbolize "${_IMPORT_PREFIX}/lib64/libLLVMSymbolize.a" )
+
+# Import target "LLVMExecutionEngine" for configuration "Release"
+set_property(TARGET LLVMExecutionEngine APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMExecutionEngine PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMExecutionEngine.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMExecutionEngine )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMExecutionEngine "${_IMPORT_PREFIX}/lib64/libLLVMExecutionEngine.a" )
+
+# Import target "LLVMInterpreter" for configuration "Release"
+set_property(TARGET LLVMInterpreter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMInterpreter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMInterpreter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMInterpreter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMInterpreter "${_IMPORT_PREFIX}/lib64/libLLVMInterpreter.a" )
+
+# Import target "LLVMMCJIT" for configuration "Release"
+set_property(TARGET LLVMMCJIT APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMMCJIT PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMMCJIT.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMMCJIT )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMMCJIT "${_IMPORT_PREFIX}/lib64/libLLVMMCJIT.a" )
+
+# Import target "LLVMOrcJIT" for configuration "Release"
+set_property(TARGET LLVMOrcJIT APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMOrcJIT PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMOrcJIT.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMOrcJIT )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMOrcJIT "${_IMPORT_PREFIX}/lib64/libLLVMOrcJIT.a" )
+
+# Import target "LLVMRuntimeDyld" for configuration "Release"
+set_property(TARGET LLVMRuntimeDyld APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMRuntimeDyld PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMRuntimeDyld.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMRuntimeDyld )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMRuntimeDyld "${_IMPORT_PREFIX}/lib64/libLLVMRuntimeDyld.a" )
+
+# Import target "LLVMTarget" for configuration "Release"
+set_property(TARGET LLVMTarget APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMTarget PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMTarget.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMTarget )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMTarget "${_IMPORT_PREFIX}/lib64/libLLVMTarget.a" )
+
+# Import target "LLVMAArch64CodeGen" for configuration "Release"
+set_property(TARGET LLVMAArch64CodeGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64CodeGen PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64CodeGen.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64CodeGen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64CodeGen "${_IMPORT_PREFIX}/lib64/libLLVMAArch64CodeGen.a" )
+
+# Import target "LLVMAArch64Info" for configuration "Release"
+set_property(TARGET LLVMAArch64Info APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64Info PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Info.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64Info )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64Info "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Info.a" )
+
+# Import target "LLVMAArch64AsmParser" for configuration "Release"
+set_property(TARGET LLVMAArch64AsmParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64AsmParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64AsmParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64AsmParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64AsmParser "${_IMPORT_PREFIX}/lib64/libLLVMAArch64AsmParser.a" )
+
+# Import target "LLVMAArch64Disassembler" for configuration "Release"
+set_property(TARGET LLVMAArch64Disassembler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64Disassembler PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Disassembler.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64Disassembler )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64Disassembler "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Disassembler.a" )
+
+# Import target "LLVMAArch64AsmPrinter" for configuration "Release"
+set_property(TARGET LLVMAArch64AsmPrinter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64AsmPrinter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64AsmPrinter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64AsmPrinter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64AsmPrinter "${_IMPORT_PREFIX}/lib64/libLLVMAArch64AsmPrinter.a" )
+
+# Import target "LLVMAArch64Desc" for configuration "Release"
+set_property(TARGET LLVMAArch64Desc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64Desc PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Desc.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64Desc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64Desc "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Desc.a" )
+
+# Import target "LLVMAArch64Utils" for configuration "Release"
+set_property(TARGET LLVMAArch64Utils APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAArch64Utils PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Utils.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAArch64Utils )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAArch64Utils "${_IMPORT_PREFIX}/lib64/libLLVMAArch64Utils.a" )
+
+# Import target "LLVMARMCodeGen" for configuration "Release"
+set_property(TARGET LLVMARMCodeGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMCodeGen PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMCodeGen.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMCodeGen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMCodeGen "${_IMPORT_PREFIX}/lib64/libLLVMARMCodeGen.a" )
+
+# Import target "LLVMARMInfo" for configuration "Release"
+set_property(TARGET LLVMARMInfo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMInfo PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMInfo.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMInfo )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMInfo "${_IMPORT_PREFIX}/lib64/libLLVMARMInfo.a" )
+
+# Import target "LLVMARMAsmParser" for configuration "Release"
+set_property(TARGET LLVMARMAsmParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMAsmParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMAsmParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMAsmParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMAsmParser "${_IMPORT_PREFIX}/lib64/libLLVMARMAsmParser.a" )
+
+# Import target "LLVMARMDisassembler" for configuration "Release"
+set_property(TARGET LLVMARMDisassembler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMDisassembler PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMDisassembler.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMDisassembler )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMDisassembler "${_IMPORT_PREFIX}/lib64/libLLVMARMDisassembler.a" )
+
+# Import target "LLVMARMAsmPrinter" for configuration "Release"
+set_property(TARGET LLVMARMAsmPrinter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMAsmPrinter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMAsmPrinter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMAsmPrinter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMAsmPrinter "${_IMPORT_PREFIX}/lib64/libLLVMARMAsmPrinter.a" )
+
+# Import target "LLVMARMDesc" for configuration "Release"
+set_property(TARGET LLVMARMDesc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMDesc PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMDesc.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMDesc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMDesc "${_IMPORT_PREFIX}/lib64/libLLVMARMDesc.a" )
+
+# Import target "LLVMARMUtils" for configuration "Release"
+set_property(TARGET LLVMARMUtils APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMARMUtils PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMARMUtils.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMARMUtils )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMARMUtils "${_IMPORT_PREFIX}/lib64/libLLVMARMUtils.a" )
+
+# Import target "LLVMBPFCodeGen" for configuration "Release"
+set_property(TARGET LLVMBPFCodeGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBPFCodeGen PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBPFCodeGen.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBPFCodeGen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBPFCodeGen "${_IMPORT_PREFIX}/lib64/libLLVMBPFCodeGen.a" )
+
+# Import target "LLVMBPFAsmParser" for configuration "Release"
+set_property(TARGET LLVMBPFAsmParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBPFAsmParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBPFAsmParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBPFAsmParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBPFAsmParser "${_IMPORT_PREFIX}/lib64/libLLVMBPFAsmParser.a" )
+
+# Import target "LLVMBPFDisassembler" for configuration "Release"
+set_property(TARGET LLVMBPFDisassembler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBPFDisassembler PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBPFDisassembler.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBPFDisassembler )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBPFDisassembler "${_IMPORT_PREFIX}/lib64/libLLVMBPFDisassembler.a" )
+
+# Import target "LLVMBPFAsmPrinter" for configuration "Release"
+set_property(TARGET LLVMBPFAsmPrinter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBPFAsmPrinter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBPFAsmPrinter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBPFAsmPrinter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBPFAsmPrinter "${_IMPORT_PREFIX}/lib64/libLLVMBPFAsmPrinter.a" )
+
+# Import target "LLVMBPFInfo" for configuration "Release"
+set_property(TARGET LLVMBPFInfo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBPFInfo PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBPFInfo.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBPFInfo )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBPFInfo "${_IMPORT_PREFIX}/lib64/libLLVMBPFInfo.a" )
+
+# Import target "LLVMBPFDesc" for configuration "Release"
+set_property(TARGET LLVMBPFDesc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMBPFDesc PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMBPFDesc.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMBPFDesc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMBPFDesc "${_IMPORT_PREFIX}/lib64/libLLVMBPFDesc.a" )
+
+# Import target "LLVMX86CodeGen" for configuration "Release"
+set_property(TARGET LLVMX86CodeGen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86CodeGen PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86CodeGen.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86CodeGen )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86CodeGen "${_IMPORT_PREFIX}/lib64/libLLVMX86CodeGen.a" )
+
+# Import target "LLVMX86AsmParser" for configuration "Release"
+set_property(TARGET LLVMX86AsmParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86AsmParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86AsmParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86AsmParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86AsmParser "${_IMPORT_PREFIX}/lib64/libLLVMX86AsmParser.a" )
+
+# Import target "LLVMX86Disassembler" for configuration "Release"
+set_property(TARGET LLVMX86Disassembler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86Disassembler PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86Disassembler.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86Disassembler )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86Disassembler "${_IMPORT_PREFIX}/lib64/libLLVMX86Disassembler.a" )
+
+# Import target "LLVMX86AsmPrinter" for configuration "Release"
+set_property(TARGET LLVMX86AsmPrinter APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86AsmPrinter PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86AsmPrinter.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86AsmPrinter )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86AsmPrinter "${_IMPORT_PREFIX}/lib64/libLLVMX86AsmPrinter.a" )
+
+# Import target "LLVMX86Desc" for configuration "Release"
+set_property(TARGET LLVMX86Desc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86Desc PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86Desc.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86Desc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86Desc "${_IMPORT_PREFIX}/lib64/libLLVMX86Desc.a" )
+
+# Import target "LLVMX86Info" for configuration "Release"
+set_property(TARGET LLVMX86Info APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86Info PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86Info.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86Info )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86Info "${_IMPORT_PREFIX}/lib64/libLLVMX86Info.a" )
+
+# Import target "LLVMX86Utils" for configuration "Release"
+set_property(TARGET LLVMX86Utils APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMX86Utils PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMX86Utils.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMX86Utils )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMX86Utils "${_IMPORT_PREFIX}/lib64/libLLVMX86Utils.a" )
+
+# Import target "LLVMAsmParser" for configuration "Release"
+set_property(TARGET LLVMAsmParser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMAsmParser PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMAsmParser.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMAsmParser )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMAsmParser "${_IMPORT_PREFIX}/lib64/libLLVMAsmParser.a" )
+
+# Import target "LLVMLineEditor" for configuration "Release"
+set_property(TARGET LLVMLineEditor APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMLineEditor PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMLineEditor.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMLineEditor )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMLineEditor "${_IMPORT_PREFIX}/lib64/libLLVMLineEditor.a" )
+
+# Import target "LLVMProfileData" for configuration "Release"
+set_property(TARGET LLVMProfileData APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMProfileData PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMProfileData.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMProfileData )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMProfileData "${_IMPORT_PREFIX}/lib64/libLLVMProfileData.a" )
+
+# Import target "LLVMCoverage" for configuration "Release"
+set_property(TARGET LLVMCoverage APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMCoverage PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMCoverage.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMCoverage )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMCoverage "${_IMPORT_PREFIX}/lib64/libLLVMCoverage.a" )
+
+# Import target "LLVMPasses" for configuration "Release"
+set_property(TARGET LLVMPasses APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMPasses PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMPasses.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMPasses )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMPasses "${_IMPORT_PREFIX}/lib64/libLLVMPasses.a" )
+
+# Import target "LLVMDlltoolDriver" for configuration "Release"
+set_property(TARGET LLVMDlltoolDriver APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMDlltoolDriver PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMDlltoolDriver.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMDlltoolDriver )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMDlltoolDriver "${_IMPORT_PREFIX}/lib64/libLLVMDlltoolDriver.a" )
+
+# Import target "LLVMLibDriver" for configuration "Release"
+set_property(TARGET LLVMLibDriver APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMLibDriver PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMLibDriver.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMLibDriver )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMLibDriver "${_IMPORT_PREFIX}/lib64/libLLVMLibDriver.a" )
+
+# Import target "LLVMXRay" for configuration "Release"
+set_property(TARGET LLVMXRay APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMXRay PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMXRay.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMXRay )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMXRay "${_IMPORT_PREFIX}/lib64/libLLVMXRay.a" )
+
+# Import target "LLVMWindowsManifest" for configuration "Release"
+set_property(TARGET LLVMWindowsManifest APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMWindowsManifest PROPERTIES
+ IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVMWindowsManifest.a"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMWindowsManifest )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMWindowsManifest "${_IMPORT_PREFIX}/lib64/libLLVMWindowsManifest.a" )
+
+# Import target "LTO" for configuration "Release"
+set_property(TARGET LTO APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LTO PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLTO.so.7svn"
+ IMPORTED_SONAME_RELEASE "libLTO.so.7"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LTO )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LTO "${_IMPORT_PREFIX}/lib64/libLTO.so.7svn" )
+
+# Import target "LLVMgold" for configuration "Release"
+set_property(TARGET LLVMgold APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVMgold PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/LLVMgold.so"
+ IMPORTED_NO_SONAME_RELEASE "TRUE"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVMgold )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVMgold "${_IMPORT_PREFIX}/lib64/LLVMgold.so" )
+
+# Import target "llvm-ar" for configuration "Release"
+set_property(TARGET llvm-ar APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-ar PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-ar"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-ar )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-ar "${_IMPORT_PREFIX}/bin/llvm-ar" )
+
+# Import target "llvm-config" for configuration "Release"
+set_property(TARGET llvm-config APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-config PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-config"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-config )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-config "${_IMPORT_PREFIX}/bin/llvm-config" )
+
+# Import target "llvm-lto" for configuration "Release"
+set_property(TARGET llvm-lto APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-lto PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-lto"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-lto )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-lto "${_IMPORT_PREFIX}/bin/llvm-lto" )
+
+# Import target "llvm-profdata" for configuration "Release"
+set_property(TARGET llvm-profdata APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-profdata PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-profdata"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-profdata )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-profdata "${_IMPORT_PREFIX}/bin/llvm-profdata" )
+
+# Import target "bugpoint" for configuration "Release"
+set_property(TARGET bugpoint APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(bugpoint PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/bugpoint"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS bugpoint )
+list(APPEND _IMPORT_CHECK_FILES_FOR_bugpoint "${_IMPORT_PREFIX}/bin/bugpoint" )
+
+# Import target "BugpointPasses" for configuration "Release"
+set_property(TARGET BugpointPasses APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(BugpointPasses PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/BugpointPasses.so"
+ IMPORTED_NO_SONAME_RELEASE "TRUE"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS BugpointPasses )
+list(APPEND _IMPORT_CHECK_FILES_FOR_BugpointPasses "${_IMPORT_PREFIX}/lib64/BugpointPasses.so" )
+
+# Import target "dsymutil" for configuration "Release"
+set_property(TARGET dsymutil APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(dsymutil PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/dsymutil"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS dsymutil )
+list(APPEND _IMPORT_CHECK_FILES_FOR_dsymutil "${_IMPORT_PREFIX}/bin/dsymutil" )
+
+# Import target "llc" for configuration "Release"
+set_property(TARGET llc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llc PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llc"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llc "${_IMPORT_PREFIX}/bin/llc" )
+
+# Import target "lli" for configuration "Release"
+set_property(TARGET lli APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(lli PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/lli"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS lli )
+list(APPEND _IMPORT_CHECK_FILES_FOR_lli "${_IMPORT_PREFIX}/bin/lli" )
+
+# Import target "llvm-as" for configuration "Release"
+set_property(TARGET llvm-as APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-as PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-as"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-as )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-as "${_IMPORT_PREFIX}/bin/llvm-as" )
+
+# Import target "llvm-bcanalyzer" for configuration "Release"
+set_property(TARGET llvm-bcanalyzer APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-bcanalyzer PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-bcanalyzer"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-bcanalyzer )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-bcanalyzer "${_IMPORT_PREFIX}/bin/llvm-bcanalyzer" )
+
+# Import target "llvm-c-test" for configuration "Release"
+set_property(TARGET llvm-c-test APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-c-test PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-c-test"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-c-test )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-c-test "${_IMPORT_PREFIX}/bin/llvm-c-test" )
+
+# Import target "llvm-cat" for configuration "Release"
+set_property(TARGET llvm-cat APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-cat PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-cat"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-cat )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-cat "${_IMPORT_PREFIX}/bin/llvm-cat" )
+
+# Import target "llvm-cfi-verify" for configuration "Release"
+set_property(TARGET llvm-cfi-verify APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-cfi-verify PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-cfi-verify"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-cfi-verify )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-cfi-verify "${_IMPORT_PREFIX}/bin/llvm-cfi-verify" )
+
+# Import target "llvm-cov" for configuration "Release"
+set_property(TARGET llvm-cov APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-cov PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-cov"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-cov )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-cov "${_IMPORT_PREFIX}/bin/llvm-cov" )
+
+# Import target "llvm-cvtres" for configuration "Release"
+set_property(TARGET llvm-cvtres APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-cvtres PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-cvtres"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-cvtres )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-cvtres "${_IMPORT_PREFIX}/bin/llvm-cvtres" )
+
+# Import target "llvm-cxxdump" for configuration "Release"
+set_property(TARGET llvm-cxxdump APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-cxxdump PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-cxxdump"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-cxxdump )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-cxxdump "${_IMPORT_PREFIX}/bin/llvm-cxxdump" )
+
+# Import target "llvm-cxxfilt" for configuration "Release"
+set_property(TARGET llvm-cxxfilt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-cxxfilt PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-cxxfilt"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-cxxfilt )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-cxxfilt "${_IMPORT_PREFIX}/bin/llvm-cxxfilt" )
+
+# Import target "llvm-diff" for configuration "Release"
+set_property(TARGET llvm-diff APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-diff PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-diff"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-diff )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-diff "${_IMPORT_PREFIX}/bin/llvm-diff" )
+
+# Import target "llvm-dis" for configuration "Release"
+set_property(TARGET llvm-dis APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-dis PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-dis"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-dis )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-dis "${_IMPORT_PREFIX}/bin/llvm-dis" )
+
+# Import target "llvm-dwarfdump" for configuration "Release"
+set_property(TARGET llvm-dwarfdump APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-dwarfdump PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-dwarfdump"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-dwarfdump )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-dwarfdump "${_IMPORT_PREFIX}/bin/llvm-dwarfdump" )
+
+# Import target "llvm-dwp" for configuration "Release"
+set_property(TARGET llvm-dwp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-dwp PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-dwp"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-dwp )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-dwp "${_IMPORT_PREFIX}/bin/llvm-dwp" )
+
+# Import target "llvm-extract" for configuration "Release"
+set_property(TARGET llvm-extract APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-extract PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-extract"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-extract )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-extract "${_IMPORT_PREFIX}/bin/llvm-extract" )
+
+# Import target "llvm-link" for configuration "Release"
+set_property(TARGET llvm-link APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-link PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-link"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-link )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-link "${_IMPORT_PREFIX}/bin/llvm-link" )
+
+# Import target "llvm-lto2" for configuration "Release"
+set_property(TARGET llvm-lto2 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-lto2 PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-lto2"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-lto2 )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-lto2 "${_IMPORT_PREFIX}/bin/llvm-lto2" )
+
+# Import target "llvm-mc" for configuration "Release"
+set_property(TARGET llvm-mc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-mc PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-mc"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-mc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-mc "${_IMPORT_PREFIX}/bin/llvm-mc" )
+
+# Import target "llvm-mca" for configuration "Release"
+set_property(TARGET llvm-mca APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-mca PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-mca"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-mca )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-mca "${_IMPORT_PREFIX}/bin/llvm-mca" )
+
+# Import target "llvm-mcmarkup" for configuration "Release"
+set_property(TARGET llvm-mcmarkup APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-mcmarkup PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-mcmarkup"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-mcmarkup )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-mcmarkup "${_IMPORT_PREFIX}/bin/llvm-mcmarkup" )
+
+# Import target "llvm-modextract" for configuration "Release"
+set_property(TARGET llvm-modextract APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-modextract PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-modextract"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-modextract )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-modextract "${_IMPORT_PREFIX}/bin/llvm-modextract" )
+
+# Import target "llvm-mt" for configuration "Release"
+set_property(TARGET llvm-mt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-mt PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-mt"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-mt )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-mt "${_IMPORT_PREFIX}/bin/llvm-mt" )
+
+# Import target "llvm-nm" for configuration "Release"
+set_property(TARGET llvm-nm APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-nm PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-nm"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-nm )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-nm "${_IMPORT_PREFIX}/bin/llvm-nm" )
+
+# Import target "llvm-objcopy" for configuration "Release"
+set_property(TARGET llvm-objcopy APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-objcopy PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-objcopy"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-objcopy )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-objcopy "${_IMPORT_PREFIX}/bin/llvm-objcopy" )
+
+# Import target "llvm-objdump" for configuration "Release"
+set_property(TARGET llvm-objdump APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-objdump PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-objdump"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-objdump )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-objdump "${_IMPORT_PREFIX}/bin/llvm-objdump" )
+
+# Import target "llvm-opt-report" for configuration "Release"
+set_property(TARGET llvm-opt-report APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-opt-report PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-opt-report"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-opt-report )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-opt-report "${_IMPORT_PREFIX}/bin/llvm-opt-report" )
+
+# Import target "llvm-pdbutil" for configuration "Release"
+set_property(TARGET llvm-pdbutil APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-pdbutil PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-pdbutil"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-pdbutil )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-pdbutil "${_IMPORT_PREFIX}/bin/llvm-pdbutil" )
+
+# Import target "llvm-rc" for configuration "Release"
+set_property(TARGET llvm-rc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-rc PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-rc"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-rc )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-rc "${_IMPORT_PREFIX}/bin/llvm-rc" )
+
+# Import target "llvm-readobj" for configuration "Release"
+set_property(TARGET llvm-readobj APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-readobj PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-readobj"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-readobj )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-readobj "${_IMPORT_PREFIX}/bin/llvm-readobj" )
+
+# Import target "llvm-rtdyld" for configuration "Release"
+set_property(TARGET llvm-rtdyld APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-rtdyld PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-rtdyld"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-rtdyld )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-rtdyld "${_IMPORT_PREFIX}/bin/llvm-rtdyld" )
+
+# Import target "LLVM" for configuration "Release"
+set_property(TARGET LLVM APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(LLVM PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libLLVM-7svn.so"
+ IMPORTED_SONAME_RELEASE "libLLVM-7svn.so"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS LLVM )
+list(APPEND _IMPORT_CHECK_FILES_FOR_LLVM "${_IMPORT_PREFIX}/lib64/libLLVM-7svn.so" )
+
+# Import target "llvm-size" for configuration "Release"
+set_property(TARGET llvm-size APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-size PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-size"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-size )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-size "${_IMPORT_PREFIX}/bin/llvm-size" )
+
+# Import target "llvm-split" for configuration "Release"
+set_property(TARGET llvm-split APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-split PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-split"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-split )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-split "${_IMPORT_PREFIX}/bin/llvm-split" )
+
+# Import target "llvm-stress" for configuration "Release"
+set_property(TARGET llvm-stress APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-stress PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-stress"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-stress )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-stress "${_IMPORT_PREFIX}/bin/llvm-stress" )
+
+# Import target "llvm-strings" for configuration "Release"
+set_property(TARGET llvm-strings APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-strings PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-strings"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-strings )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-strings "${_IMPORT_PREFIX}/bin/llvm-strings" )
+
+# Import target "llvm-symbolizer" for configuration "Release"
+set_property(TARGET llvm-symbolizer APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-symbolizer PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-symbolizer"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-symbolizer )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-symbolizer "${_IMPORT_PREFIX}/bin/llvm-symbolizer" )
+
+# Import target "llvm-xray" for configuration "Release"
+set_property(TARGET llvm-xray APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(llvm-xray PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/llvm-xray"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS llvm-xray )
+list(APPEND _IMPORT_CHECK_FILES_FOR_llvm-xray "${_IMPORT_PREFIX}/bin/llvm-xray" )
+
+# Import target "obj2yaml" for configuration "Release"
+set_property(TARGET obj2yaml APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(obj2yaml PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/obj2yaml"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS obj2yaml )
+list(APPEND _IMPORT_CHECK_FILES_FOR_obj2yaml "${_IMPORT_PREFIX}/bin/obj2yaml" )
+
+# Import target "opt" for configuration "Release"
+set_property(TARGET opt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(opt PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/opt"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS opt )
+list(APPEND _IMPORT_CHECK_FILES_FOR_opt "${_IMPORT_PREFIX}/bin/opt" )
+
+# Import target "sancov" for configuration "Release"
+set_property(TARGET sancov APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(sancov PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/sancov"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS sancov )
+list(APPEND _IMPORT_CHECK_FILES_FOR_sancov "${_IMPORT_PREFIX}/bin/sancov" )
+
+# Import target "sanstats" for configuration "Release"
+set_property(TARGET sanstats APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(sanstats PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/sanstats"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS sanstats )
+list(APPEND _IMPORT_CHECK_FILES_FOR_sanstats "${_IMPORT_PREFIX}/bin/sanstats" )
+
+# Import target "verify-uselistorder" for configuration "Release"
+set_property(TARGET verify-uselistorder APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(verify-uselistorder PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/verify-uselistorder"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS verify-uselistorder )
+list(APPEND _IMPORT_CHECK_FILES_FOR_verify-uselistorder "${_IMPORT_PREFIX}/bin/verify-uselistorder" )
+
+# Import target "yaml2obj" for configuration "Release"
+set_property(TARGET yaml2obj APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(yaml2obj PROPERTIES
+ IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/yaml2obj"
+ )
+
+list(APPEND _IMPORT_CHECK_TARGETS yaml2obj )
+list(APPEND _IMPORT_CHECK_FILES_FOR_yaml2obj "${_IMPORT_PREFIX}/bin/yaml2obj" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMExports.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMExports.cmake
new file mode 100644
index 0000000..4959009
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMExports.cmake
@@ -0,0 +1,807 @@
+# Generated by CMake 3.6.0-rc2
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5)
+ message(FATAL_ERROR "CMake >= 2.6.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.6)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_targetsDefined)
+set(_targetsNotDefined)
+set(_expectedTargets)
+foreach(_expectedTarget LLVMDemangle LLVMSupport LLVMTableGen llvm-tblgen LLVMCore LLVMFuzzMutate LLVMIRReader LLVMCodeGen LLVMSelectionDAG LLVMAsmPrinter LLVMMIRParser LLVMGlobalISel LLVMBinaryFormat LLVMBitReader LLVMBitWriter LLVMTransformUtils LLVMInstrumentation LLVMAggressiveInstCombine LLVMInstCombine LLVMScalarOpts LLVMipo LLVMVectorize LLVMHello LLVMObjCARCOpts LLVMCoroutines LLVMLinker LLVMAnalysis LLVMLTO LLVMMC LLVMMCParser LLVMMCDisassembler LLVMObject LLVMObjectYAML LLVMOption LLVMDebugInfoDWARF LLVMDebugInfoMSF LLVMDebugInfoCodeView LLVMDebugInfoPDB LLVMSymbolize LLVMExecutionEngine LLVMInterpreter LLVMMCJIT LLVMOrcJIT LLVMRuntimeDyld LLVMTarget LLVMAArch64CodeGen LLVMAArch64Info LLVMAArch64AsmParser LLVMAArch64Disassembler LLVMAArch64AsmPrinter LLVMAArch64Desc LLVMAArch64Utils LLVMARMCodeGen LLVMARMInfo LLVMARMAsmParser LLVMARMDisassembler LLVMARMAsmPrinter LLVMARMDesc LLVMARMUtils LLVMBPFCodeGen LLVMBPFAsmParser LLVMBPFDisassembler LLVMBPFAsmPrinter LLVMBPFInfo LLVMBPFDesc LLVMX86CodeGen LLVMX86AsmParser LLVMX86Disassembler LLVMX86AsmPrinter LLVMX86Desc LLVMX86Info LLVMX86Utils LLVMAsmParser LLVMLineEditor LLVMProfileData LLVMCoverage LLVMPasses LLVMDlltoolDriver LLVMLibDriver LLVMXRay LLVMWindowsManifest LTO LLVMgold llvm-ar llvm-config llvm-lto llvm-profdata bugpoint BugpointPasses dsymutil llc lli llvm-as llvm-bcanalyzer llvm-c-test llvm-cat llvm-cfi-verify llvm-cov llvm-cvtres llvm-cxxdump llvm-cxxfilt llvm-diff llvm-dis llvm-dwarfdump llvm-dwp llvm-extract llvm-link llvm-lto2 llvm-mc llvm-mca llvm-mcmarkup llvm-modextract llvm-mt llvm-nm llvm-objcopy llvm-objdump llvm-opt-report llvm-pdbutil llvm-rc llvm-readobj llvm-rtdyld LLVM llvm-size llvm-split llvm-stress llvm-strings llvm-symbolizer llvm-xray obj2yaml opt sancov sanstats verify-uselistorder yaml2obj)
+ list(APPEND _expectedTargets ${_expectedTarget})
+ if(NOT TARGET ${_expectedTarget})
+ list(APPEND _targetsNotDefined ${_expectedTarget})
+ endif()
+ if(TARGET ${_expectedTarget})
+ list(APPEND _targetsDefined ${_expectedTarget})
+ endif()
+endforeach()
+if("${_targetsDefined}" STREQUAL "${_expectedTargets}")
+ unset(_targetsDefined)
+ unset(_targetsNotDefined)
+ unset(_expectedTargets)
+ set(CMAKE_IMPORT_FILE_VERSION)
+ cmake_policy(POP)
+ return()
+endif()
+if(NOT "${_targetsDefined}" STREQUAL "")
+ message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n")
+endif()
+unset(_targetsDefined)
+unset(_targetsNotDefined)
+unset(_expectedTargets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+
+# Create imported target LLVMDemangle
+add_library(LLVMDemangle STATIC IMPORTED)
+
+# Create imported target LLVMSupport
+add_library(LLVMSupport STATIC IMPORTED)
+
+set_target_properties(LLVMSupport PROPERTIES
+ INTERFACE_LINK_LIBRARIES "z;rt;dl;-lpthread;m;LLVMDemangle"
+)
+
+# Create imported target LLVMTableGen
+add_library(LLVMTableGen STATIC IMPORTED)
+
+set_target_properties(LLVMTableGen PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target llvm-tblgen
+add_executable(llvm-tblgen IMPORTED)
+
+# Create imported target LLVMCore
+add_library(LLVMCore STATIC IMPORTED)
+
+set_target_properties(LLVMCore PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBinaryFormat;LLVMSupport"
+)
+
+# Create imported target LLVMFuzzMutate
+add_library(LLVMFuzzMutate STATIC IMPORTED)
+
+set_target_properties(LLVMFuzzMutate PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCore;LLVMScalarOpts;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMIRReader
+add_library(LLVMIRReader STATIC IMPORTED)
+
+set_target_properties(LLVMIRReader PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAsmParser;LLVMBitReader;LLVMCore;LLVMSupport"
+)
+
+# Create imported target LLVMCodeGen
+add_library(LLVMCodeGen STATIC IMPORTED)
+
+set_target_properties(LLVMCodeGen PROPERTIES
+ INTERFACE_LINK_LIBRARIES "-lpthread;LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCore;LLVMMC;LLVMProfileData;LLVMScalarOpts;LLVMSupport;LLVMTarget;LLVMTransformUtils"
+)
+
+# Create imported target LLVMSelectionDAG
+add_library(LLVMSelectionDAG STATIC IMPORTED)
+
+set_target_properties(LLVMSelectionDAG PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSupport;LLVMTarget;LLVMTransformUtils"
+)
+
+# Create imported target LLVMAsmPrinter
+add_library(LLVMAsmPrinter STATIC IMPORTED)
+
+set_target_properties(LLVMAsmPrinter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMBinaryFormat;LLVMCodeGen;LLVMCore;LLVMDebugInfoCodeView;LLVMDebugInfoMSF;LLVMMC;LLVMMCParser;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMMIRParser
+add_library(LLVMMIRParser STATIC IMPORTED)
+
+set_target_properties(LLVMMIRParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAsmParser;LLVMBinaryFormat;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMGlobalISel
+add_library(LLVMGlobalISel STATIC IMPORTED)
+
+set_target_properties(LLVMGlobalISel PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSupport;LLVMTarget;LLVMTransformUtils"
+)
+
+# Create imported target LLVMBinaryFormat
+add_library(LLVMBinaryFormat STATIC IMPORTED)
+
+set_target_properties(LLVMBinaryFormat PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMBitReader
+add_library(LLVMBitReader STATIC IMPORTED)
+
+set_target_properties(LLVMBitReader PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMSupport"
+)
+
+# Create imported target LLVMBitWriter
+add_library(LLVMBitWriter STATIC IMPORTED)
+
+set_target_properties(LLVMBitWriter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMMC;LLVMObject;LLVMSupport"
+)
+
+# Create imported target LLVMTransformUtils
+add_library(LLVMTransformUtils STATIC IMPORTED)
+
+set_target_properties(LLVMTransformUtils PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMSupport"
+)
+
+# Create imported target LLVMInstrumentation
+add_library(LLVMInstrumentation STATIC IMPORTED)
+
+set_target_properties(LLVMInstrumentation PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMMC;LLVMProfileData;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMAggressiveInstCombine
+add_library(LLVMAggressiveInstCombine STATIC IMPORTED)
+
+set_target_properties(LLVMAggressiveInstCombine PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMInstCombine
+add_library(LLVMInstCombine STATIC IMPORTED)
+
+set_target_properties(LLVMInstCombine PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMScalarOpts
+add_library(LLVMScalarOpts STATIC IMPORTED)
+
+set_target_properties(LLVMScalarOpts PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAggressiveInstCombine;LLVMAnalysis;LLVMCore;LLVMInstCombine;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMipo
+add_library(LLVMipo STATIC IMPORTED)
+
+set_target_properties(LLVMipo PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAggressiveInstCombine;LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCore;LLVMIRReader;LLVMInstCombine;LLVMInstrumentation;LLVMLinker;LLVMObject;LLVMProfileData;LLVMScalarOpts;LLVMSupport;LLVMTransformUtils;LLVMVectorize"
+)
+
+# Create imported target LLVMVectorize
+add_library(LLVMVectorize STATIC IMPORTED)
+
+set_target_properties(LLVMVectorize PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMHello
+add_library(LLVMHello MODULE IMPORTED)
+
+# Create imported target LLVMObjCARCOpts
+add_library(LLVMObjCARCOpts STATIC IMPORTED)
+
+set_target_properties(LLVMObjCARCOpts PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMCoroutines
+add_library(LLVMCoroutines STATIC IMPORTED)
+
+set_target_properties(LLVMCoroutines PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMScalarOpts;LLVMSupport;LLVMTransformUtils;LLVMipo"
+)
+
+# Create imported target LLVMLinker
+add_library(LLVMLinker STATIC IMPORTED)
+
+set_target_properties(LLVMLinker PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMAnalysis
+add_library(LLVMAnalysis STATIC IMPORTED)
+
+set_target_properties(LLVMAnalysis PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBinaryFormat;LLVMCore;LLVMObject;LLVMProfileData;LLVMSupport"
+)
+
+# Create imported target LLVMLTO
+add_library(LLVMLTO STATIC IMPORTED)
+
+set_target_properties(LLVMLTO PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAggressiveInstCombine;LLVMAnalysis;LLVMBitReader;LLVMBitWriter;LLVMCodeGen;LLVMCore;LLVMInstCombine;LLVMLinker;LLVMMC;LLVMObjCARCOpts;LLVMObject;LLVMPasses;LLVMScalarOpts;LLVMSupport;LLVMTarget;LLVMTransformUtils;LLVMipo"
+)
+
+# Create imported target LLVMMC
+add_library(LLVMMC STATIC IMPORTED)
+
+set_target_properties(LLVMMC PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMDebugInfoCodeView;LLVMSupport"
+)
+
+# Create imported target LLVMMCParser
+add_library(LLVMMCParser STATIC IMPORTED)
+
+set_target_properties(LLVMMCParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMMCDisassembler
+add_library(LLVMMCDisassembler STATIC IMPORTED)
+
+set_target_properties(LLVMMCDisassembler PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMObject
+add_library(LLVMObject STATIC IMPORTED)
+
+set_target_properties(LLVMObject PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBinaryFormat;LLVMBitReader;LLVMCore;LLVMMC;LLVMMCParser;LLVMSupport"
+)
+
+# Create imported target LLVMObjectYAML
+add_library(LLVMObjectYAML STATIC IMPORTED)
+
+set_target_properties(LLVMObjectYAML PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMDebugInfoCodeView;LLVMSupport"
+)
+
+# Create imported target LLVMOption
+add_library(LLVMOption STATIC IMPORTED)
+
+set_target_properties(LLVMOption PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMDebugInfoDWARF
+add_library(LLVMDebugInfoDWARF STATIC IMPORTED)
+
+set_target_properties(LLVMDebugInfoDWARF PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBinaryFormat;LLVMMC;LLVMObject;LLVMSupport"
+)
+
+# Create imported target LLVMDebugInfoMSF
+add_library(LLVMDebugInfoMSF STATIC IMPORTED)
+
+set_target_properties(LLVMDebugInfoMSF PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMDebugInfoCodeView
+add_library(LLVMDebugInfoCodeView STATIC IMPORTED)
+
+set_target_properties(LLVMDebugInfoCodeView PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMDebugInfoMSF;LLVMSupport"
+)
+
+# Create imported target LLVMDebugInfoPDB
+add_library(LLVMDebugInfoPDB STATIC IMPORTED)
+
+set_target_properties(LLVMDebugInfoPDB PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMDebugInfoCodeView;LLVMDebugInfoMSF;LLVMObject;LLVMSupport"
+)
+
+# Create imported target LLVMSymbolize
+add_library(LLVMSymbolize STATIC IMPORTED)
+
+set_target_properties(LLVMSymbolize PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMDebugInfoDWARF;LLVMDebugInfoPDB;LLVMDemangle;LLVMObject;LLVMSupport"
+)
+
+# Create imported target LLVMExecutionEngine
+add_library(LLVMExecutionEngine STATIC IMPORTED)
+
+set_target_properties(LLVMExecutionEngine PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMMC;LLVMObject;LLVMRuntimeDyld;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMInterpreter
+add_library(LLVMInterpreter STATIC IMPORTED)
+
+set_target_properties(LLVMInterpreter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCodeGen;LLVMCore;LLVMExecutionEngine;LLVMSupport"
+)
+
+# Create imported target LLVMMCJIT
+add_library(LLVMMCJIT STATIC IMPORTED)
+
+set_target_properties(LLVMMCJIT PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMExecutionEngine;LLVMObject;LLVMRuntimeDyld;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMOrcJIT
+add_library(LLVMOrcJIT STATIC IMPORTED)
+
+set_target_properties(LLVMOrcJIT PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMExecutionEngine;LLVMObject;LLVMRuntimeDyld;LLVMSupport;LLVMTransformUtils"
+)
+
+# Create imported target LLVMRuntimeDyld
+add_library(LLVMRuntimeDyld STATIC IMPORTED)
+
+set_target_properties(LLVMRuntimeDyld PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMObject;LLVMSupport"
+)
+
+# Create imported target LLVMTarget
+add_library(LLVMTarget STATIC IMPORTED)
+
+set_target_properties(LLVMTarget PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMCore;LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMAArch64CodeGen
+add_library(LLVMAArch64CodeGen STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64CodeGen PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAArch64AsmPrinter;LLVMAArch64Desc;LLVMAArch64Info;LLVMAArch64Utils;LLVMAnalysis;LLVMAsmPrinter;LLVMCodeGen;LLVMCore;LLVMGlobalISel;LLVMMC;LLVMScalarOpts;LLVMSelectionDAG;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMAArch64Info
+add_library(LLVMAArch64Info STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64Info PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMAArch64AsmParser
+add_library(LLVMAArch64AsmParser STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64AsmParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAArch64Desc;LLVMAArch64Info;LLVMAArch64Utils;LLVMMC;LLVMMCParser;LLVMSupport"
+)
+
+# Create imported target LLVMAArch64Disassembler
+add_library(LLVMAArch64Disassembler STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64Disassembler PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAArch64Desc;LLVMAArch64Info;LLVMAArch64Utils;LLVMMC;LLVMMCDisassembler;LLVMSupport"
+)
+
+# Create imported target LLVMAArch64AsmPrinter
+add_library(LLVMAArch64AsmPrinter STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64AsmPrinter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAArch64Utils;LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMAArch64Desc
+add_library(LLVMAArch64Desc STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64Desc PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAArch64AsmPrinter;LLVMAArch64Info;LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMAArch64Utils
+add_library(LLVMAArch64Utils STATIC IMPORTED)
+
+set_target_properties(LLVMAArch64Utils PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMARMCodeGen
+add_library(LLVMARMCodeGen STATIC IMPORTED)
+
+set_target_properties(LLVMARMCodeGen PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMARMAsmPrinter;LLVMARMDesc;LLVMARMInfo;LLVMARMUtils;LLVMAnalysis;LLVMAsmPrinter;LLVMCodeGen;LLVMCore;LLVMGlobalISel;LLVMMC;LLVMScalarOpts;LLVMSelectionDAG;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMARMInfo
+add_library(LLVMARMInfo STATIC IMPORTED)
+
+set_target_properties(LLVMARMInfo PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMARMAsmParser
+add_library(LLVMARMAsmParser STATIC IMPORTED)
+
+set_target_properties(LLVMARMAsmParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMARMDesc;LLVMARMInfo;LLVMARMUtils;LLVMMC;LLVMMCParser;LLVMSupport"
+)
+
+# Create imported target LLVMARMDisassembler
+add_library(LLVMARMDisassembler STATIC IMPORTED)
+
+set_target_properties(LLVMARMDisassembler PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMARMDesc;LLVMARMInfo;LLVMARMUtils;LLVMMCDisassembler;LLVMSupport"
+)
+
+# Create imported target LLVMARMAsmPrinter
+add_library(LLVMARMAsmPrinter STATIC IMPORTED)
+
+set_target_properties(LLVMARMAsmPrinter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMARMUtils;LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMARMDesc
+add_library(LLVMARMDesc STATIC IMPORTED)
+
+set_target_properties(LLVMARMDesc PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMARMAsmPrinter;LLVMARMInfo;LLVMMC;LLVMMCDisassembler;LLVMSupport"
+)
+
+# Create imported target LLVMARMUtils
+add_library(LLVMARMUtils STATIC IMPORTED)
+
+set_target_properties(LLVMARMUtils PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMBPFCodeGen
+add_library(LLVMBPFCodeGen STATIC IMPORTED)
+
+set_target_properties(LLVMBPFCodeGen PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAsmPrinter;LLVMBPFAsmPrinter;LLVMBPFDesc;LLVMBPFInfo;LLVMCodeGen;LLVMCore;LLVMMC;LLVMSelectionDAG;LLVMSupport;LLVMTarget"
+)
+
+# Create imported target LLVMBPFAsmParser
+add_library(LLVMBPFAsmParser STATIC IMPORTED)
+
+set_target_properties(LLVMBPFAsmParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBPFDesc;LLVMBPFInfo;LLVMMC;LLVMMCParser;LLVMSupport"
+)
+
+# Create imported target LLVMBPFDisassembler
+add_library(LLVMBPFDisassembler STATIC IMPORTED)
+
+set_target_properties(LLVMBPFDisassembler PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBPFInfo;LLVMMCDisassembler;LLVMSupport"
+)
+
+# Create imported target LLVMBPFAsmPrinter
+add_library(LLVMBPFAsmPrinter STATIC IMPORTED)
+
+set_target_properties(LLVMBPFAsmPrinter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMBPFInfo
+add_library(LLVMBPFInfo STATIC IMPORTED)
+
+set_target_properties(LLVMBPFInfo PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMBPFDesc
+add_library(LLVMBPFDesc STATIC IMPORTED)
+
+set_target_properties(LLVMBPFDesc PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBPFAsmPrinter;LLVMBPFInfo;LLVMMC;LLVMSupport"
+)
+
+# Create imported target LLVMX86CodeGen
+add_library(LLVMX86CodeGen STATIC IMPORTED)
+
+set_target_properties(LLVMX86CodeGen PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAnalysis;LLVMAsmPrinter;LLVMCodeGen;LLVMCore;LLVMGlobalISel;LLVMMC;LLVMSelectionDAG;LLVMSupport;LLVMTarget;LLVMX86AsmPrinter;LLVMX86Desc;LLVMX86Info;LLVMX86Utils"
+)
+
+# Create imported target LLVMX86AsmParser
+add_library(LLVMX86AsmParser STATIC IMPORTED)
+
+set_target_properties(LLVMX86AsmParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMMCParser;LLVMSupport;LLVMX86AsmPrinter;LLVMX86Desc;LLVMX86Info"
+)
+
+# Create imported target LLVMX86Disassembler
+add_library(LLVMX86Disassembler STATIC IMPORTED)
+
+set_target_properties(LLVMX86Disassembler PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMCDisassembler;LLVMSupport;LLVMX86Info"
+)
+
+# Create imported target LLVMX86AsmPrinter
+add_library(LLVMX86AsmPrinter STATIC IMPORTED)
+
+set_target_properties(LLVMX86AsmPrinter PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMSupport;LLVMX86Utils"
+)
+
+# Create imported target LLVMX86Desc
+add_library(LLVMX86Desc STATIC IMPORTED)
+
+set_target_properties(LLVMX86Desc PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMMC;LLVMMCDisassembler;LLVMObject;LLVMSupport;LLVMX86AsmPrinter;LLVMX86Info"
+)
+
+# Create imported target LLVMX86Info
+add_library(LLVMX86Info STATIC IMPORTED)
+
+set_target_properties(LLVMX86Info PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LLVMX86Utils
+add_library(LLVMX86Utils STATIC IMPORTED)
+
+set_target_properties(LLVMX86Utils PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMSupport"
+)
+
+# Create imported target LLVMAsmParser
+add_library(LLVMAsmParser STATIC IMPORTED)
+
+set_target_properties(LLVMAsmParser PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBinaryFormat;LLVMCore;LLVMSupport"
+)
+
+# Create imported target LLVMLineEditor
+add_library(LLVMLineEditor STATIC IMPORTED)
+
+set_target_properties(LLVMLineEditor PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport;LLVMSupport"
+)
+
+# Create imported target LLVMProfileData
+add_library(LLVMProfileData STATIC IMPORTED)
+
+set_target_properties(LLVMProfileData PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMSupport"
+)
+
+# Create imported target LLVMCoverage
+add_library(LLVMCoverage STATIC IMPORTED)
+
+set_target_properties(LLVMCoverage PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMCore;LLVMObject;LLVMProfileData;LLVMSupport"
+)
+
+# Create imported target LLVMPasses
+add_library(LLVMPasses STATIC IMPORTED)
+
+set_target_properties(LLVMPasses PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMAggressiveInstCombine;LLVMAnalysis;LLVMCodeGen;LLVMCore;LLVMInstCombine;LLVMInstrumentation;LLVMScalarOpts;LLVMSupport;LLVMTarget;LLVMTransformUtils;LLVMVectorize;LLVMipo"
+)
+
+# Create imported target LLVMDlltoolDriver
+add_library(LLVMDlltoolDriver STATIC IMPORTED)
+
+set_target_properties(LLVMDlltoolDriver PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMObject;LLVMOption;LLVMSupport"
+)
+
+# Create imported target LLVMLibDriver
+add_library(LLVMLibDriver STATIC IMPORTED)
+
+set_target_properties(LLVMLibDriver PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMBinaryFormat;LLVMObject;LLVMOption;LLVMSupport"
+)
+
+# Create imported target LLVMXRay
+add_library(LLVMXRay STATIC IMPORTED)
+
+set_target_properties(LLVMXRay PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport;LLVMObject"
+)
+
+# Create imported target LLVMWindowsManifest
+add_library(LLVMWindowsManifest STATIC IMPORTED)
+
+set_target_properties(LLVMWindowsManifest PROPERTIES
+ INTERFACE_LINK_LIBRARIES "LLVMSupport"
+)
+
+# Create imported target LTO
+add_library(LTO SHARED IMPORTED)
+
+# Create imported target LLVMgold
+add_library(LLVMgold MODULE IMPORTED)
+
+# Create imported target llvm-ar
+add_executable(llvm-ar IMPORTED)
+
+# Create imported target llvm-config
+add_executable(llvm-config IMPORTED)
+
+# Create imported target llvm-lto
+add_executable(llvm-lto IMPORTED)
+
+# Create imported target llvm-profdata
+add_executable(llvm-profdata IMPORTED)
+
+# Create imported target bugpoint
+add_executable(bugpoint IMPORTED)
+set_property(TARGET bugpoint PROPERTY ENABLE_EXPORTS 1)
+
+# Create imported target BugpointPasses
+add_library(BugpointPasses MODULE IMPORTED)
+
+# Create imported target dsymutil
+add_executable(dsymutil IMPORTED)
+
+# Create imported target llc
+add_executable(llc IMPORTED)
+set_property(TARGET llc PROPERTY ENABLE_EXPORTS 1)
+
+# Create imported target lli
+add_executable(lli IMPORTED)
+set_property(TARGET lli PROPERTY ENABLE_EXPORTS 1)
+
+# Create imported target llvm-as
+add_executable(llvm-as IMPORTED)
+
+# Create imported target llvm-bcanalyzer
+add_executable(llvm-bcanalyzer IMPORTED)
+
+# Create imported target llvm-c-test
+add_executable(llvm-c-test IMPORTED)
+
+# Create imported target llvm-cat
+add_executable(llvm-cat IMPORTED)
+
+# Create imported target llvm-cfi-verify
+add_executable(llvm-cfi-verify IMPORTED)
+
+# Create imported target llvm-cov
+add_executable(llvm-cov IMPORTED)
+
+# Create imported target llvm-cvtres
+add_executable(llvm-cvtres IMPORTED)
+
+# Create imported target llvm-cxxdump
+add_executable(llvm-cxxdump IMPORTED)
+
+# Create imported target llvm-cxxfilt
+add_executable(llvm-cxxfilt IMPORTED)
+
+# Create imported target llvm-diff
+add_executable(llvm-diff IMPORTED)
+
+# Create imported target llvm-dis
+add_executable(llvm-dis IMPORTED)
+
+# Create imported target llvm-dwarfdump
+add_executable(llvm-dwarfdump IMPORTED)
+
+# Create imported target llvm-dwp
+add_executable(llvm-dwp IMPORTED)
+
+# Create imported target llvm-extract
+add_executable(llvm-extract IMPORTED)
+
+# Create imported target llvm-link
+add_executable(llvm-link IMPORTED)
+
+# Create imported target llvm-lto2
+add_executable(llvm-lto2 IMPORTED)
+
+# Create imported target llvm-mc
+add_executable(llvm-mc IMPORTED)
+
+# Create imported target llvm-mca
+add_executable(llvm-mca IMPORTED)
+
+# Create imported target llvm-mcmarkup
+add_executable(llvm-mcmarkup IMPORTED)
+
+# Create imported target llvm-modextract
+add_executable(llvm-modextract IMPORTED)
+
+# Create imported target llvm-mt
+add_executable(llvm-mt IMPORTED)
+
+# Create imported target llvm-nm
+add_executable(llvm-nm IMPORTED)
+
+# Create imported target llvm-objcopy
+add_executable(llvm-objcopy IMPORTED)
+
+# Create imported target llvm-objdump
+add_executable(llvm-objdump IMPORTED)
+
+# Create imported target llvm-opt-report
+add_executable(llvm-opt-report IMPORTED)
+
+# Create imported target llvm-pdbutil
+add_executable(llvm-pdbutil IMPORTED)
+
+# Create imported target llvm-rc
+add_executable(llvm-rc IMPORTED)
+
+# Create imported target llvm-readobj
+add_executable(llvm-readobj IMPORTED)
+
+# Create imported target llvm-rtdyld
+add_executable(llvm-rtdyld IMPORTED)
+
+# Create imported target LLVM
+add_library(LLVM SHARED IMPORTED)
+
+# Create imported target llvm-size
+add_executable(llvm-size IMPORTED)
+
+# Create imported target llvm-split
+add_executable(llvm-split IMPORTED)
+
+# Create imported target llvm-stress
+add_executable(llvm-stress IMPORTED)
+set_property(TARGET llvm-stress PROPERTY ENABLE_EXPORTS 1)
+
+# Create imported target llvm-strings
+add_executable(llvm-strings IMPORTED)
+
+# Create imported target llvm-symbolizer
+add_executable(llvm-symbolizer IMPORTED)
+
+# Create imported target llvm-xray
+add_executable(llvm-xray IMPORTED)
+
+# Create imported target obj2yaml
+add_executable(obj2yaml IMPORTED)
+
+# Create imported target opt
+add_executable(opt IMPORTED)
+set_property(TARGET opt PROPERTY ENABLE_EXPORTS 1)
+
+# Create imported target sancov
+add_executable(sancov IMPORTED)
+
+# Create imported target sanstats
+add_executable(sanstats IMPORTED)
+
+# Create imported target verify-uselistorder
+add_executable(verify-uselistorder IMPORTED)
+
+# Create imported target yaml2obj
+add_executable(yaml2obj IMPORTED)
+
+if(CMAKE_VERSION VERSION_LESS 2.8.12)
+ message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.")
+endif()
+
+# Load information for each installed configuration.
+get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+file(GLOB CONFIG_FILES "${_DIR}/LLVMExports-*.cmake")
+foreach(f ${CONFIG_FILES})
+ include(${f})
+endforeach()
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(target ${_IMPORT_CHECK_TARGETS} )
+ foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} )
+ if(NOT EXISTS "${file}" )
+ message(FATAL_ERROR "The imported target \"${target}\" references the file
+ \"${file}\"
+but this file does not exist. Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+ \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+ endif()
+ endforeach()
+ unset(_IMPORT_CHECK_FILES_FOR_${target})
+endforeach()
+unset(_IMPORT_CHECK_TARGETS)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMExternalProjectUtils.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMExternalProjectUtils.cmake
new file mode 100644
index 0000000..619550b
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMExternalProjectUtils.cmake
@@ -0,0 +1,230 @@
+include(ExternalProject)
+
+# llvm_ExternalProject_BuildCmd(out_var target)
+# Utility function for constructing command lines for external project targets
+function(llvm_ExternalProject_BuildCmd out_var target bin_dir)
+ cmake_parse_arguments(ARG "" "CONFIGURATION" "" ${ARGN})
+ if(NOT ARG_CONFIGURATION)
+ set(ARG_CONFIGURATION "$<CONFIGURATION>")
+ endif()
+ if (CMAKE_GENERATOR MATCHES "Make")
+ # Use special command for Makefiles to support parallelism.
+ set(${out_var} "$(MAKE)" "-C" "${bin_dir}" "${target}" PARENT_SCOPE)
+ else()
+ set(${out_var} ${CMAKE_COMMAND} --build ${bin_dir} --target ${target}
+ --config ${ARG_CONFIGURATION} PARENT_SCOPE)
+ endif()
+endfunction()
+
+# llvm_ExternalProject_Add(name source_dir ...
+# USE_TOOLCHAIN
+# Use just-built tools (see TOOLCHAIN_TOOLS)
+# EXCLUDE_FROM_ALL
+# Exclude this project from the all target
+# NO_INSTALL
+# Don't generate install targets for this project
+# ALWAYS_CLEAN
+# Always clean the sub-project before building
+# CMAKE_ARGS arguments...
+# Optional cmake arguments to pass when configuring the project
+# TOOLCHAIN_TOOLS targets...
+# Targets for toolchain tools (defaults to clang;lld)
+# DEPENDS targets...
+# Targets that this project depends on
+# EXTRA_TARGETS targets...
+# Extra targets in the subproject to generate targets for
+# PASSTHROUGH_PREFIXES prefix...
+# Extra variable prefixes (name is always included) to pass down
+# )
+function(llvm_ExternalProject_Add name source_dir)
+ cmake_parse_arguments(ARG
+ "USE_TOOLCHAIN;EXCLUDE_FROM_ALL;NO_INSTALL;ALWAYS_CLEAN"
+ "SOURCE_DIR"
+ "CMAKE_ARGS;TOOLCHAIN_TOOLS;RUNTIME_LIBRARIES;DEPENDS;EXTRA_TARGETS;PASSTHROUGH_PREFIXES"
+ ${ARGN})
+ canonicalize_tool_name(${name} nameCanon)
+ if(NOT ARG_TOOLCHAIN_TOOLS)
+ set(ARG_TOOLCHAIN_TOOLS clang lld)
+ if(NOT APPLE AND NOT WIN32)
+ list(APPEND ARG_TOOLCHAIN_TOOLS llvm-ar llvm-ranlib)
+ endif()
+ endif()
+ foreach(tool ${ARG_TOOLCHAIN_TOOLS})
+ if(TARGET ${tool})
+ list(APPEND TOOLCHAIN_TOOLS ${tool})
+ list(APPEND TOOLCHAIN_BINS $<TARGET_FILE:${tool}>)
+ endif()
+ endforeach()
+
+ if(NOT ARG_RUNTIME_LIBRARIES)
+ set(ARG_RUNTIME_LIBRARIES compiler-rt libcxx)
+ endif()
+ foreach(lib ${ARG_RUNTIME_LIBRARIES})
+ if(TARGET ${lib})
+ list(APPEND RUNTIME_LIBRARIES ${lib})
+ endif()
+ endforeach()
+
+ if(ARG_ALWAYS_CLEAN)
+ set(always_clean clean)
+ endif()
+
+ list(FIND TOOLCHAIN_TOOLS clang FOUND_CLANG)
+ if(FOUND_CLANG GREATER -1)
+ set(CLANG_IN_TOOLCHAIN On)
+ endif()
+
+ if(RUNTIME_LIBRARIES AND CLANG_IN_TOOLCHAIN)
+ list(APPEND TOOLCHAIN_BINS ${RUNTIME_LIBRARIES})
+ endif()
+
+ set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/${name}-stamps/)
+ set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${name}-bins/)
+
+ add_custom_target(${name}-clear
+ COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR}
+ COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR}
+ COMMENT "Clobbering ${name} build and stamp directories"
+ USES_TERMINAL
+ )
+
+ # Find all variables that start with a prefix and propagate them through
+ get_cmake_property(variableNames VARIABLES)
+
+ list(APPEND ARG_PASSTHROUGH_PREFIXES ${nameCanon})
+ foreach(prefix ${ARG_PASSTHROUGH_PREFIXES})
+ foreach(variableName ${variableNames})
+ if(variableName MATCHES "^${prefix}")
+ string(REPLACE ";" "|" value "${${variableName}}")
+ list(APPEND PASSTHROUGH_VARIABLES
+ -D${variableName}=${value})
+ endif()
+ endforeach()
+ endforeach()
+
+ if(ARG_USE_TOOLCHAIN AND NOT CMAKE_CROSSCOMPILING)
+ if(CLANG_IN_TOOLCHAIN)
+ set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
+ -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++)
+ endif()
+ if(llvm-ar IN_LIST TOOLCHAIN_TOOLS)
+ list(APPEND compiler_args -DCMAKE_AR=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ar)
+ endif()
+ if(llvm-ranlib IN_LIST TOOLCHAIN_TOOLS)
+ list(APPEND compiler_args -DCMAKE_RANLIB=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-ranlib)
+ endif()
+ list(APPEND ARG_DEPENDS ${TOOLCHAIN_TOOLS})
+ endif()
+
+ add_custom_command(
+ OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp
+ DEPENDS ${ARG_DEPENDS}
+ COMMAND ${CMAKE_COMMAND} -E touch ${BINARY_DIR}/CMakeCache.txt
+ COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_DIR}/${name}-mkdir
+ COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp
+ COMMENT "Clobbering bootstrap build and stamp directories"
+ )
+
+ add_custom_target(${name}-clobber
+ DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp)
+
+ if(ARG_EXCLUDE_FROM_ALL)
+ set(exclude EXCLUDE_FROM_ALL 1)
+ endif()
+
+ if(CMAKE_SYSROOT)
+ set(sysroot_arg -DCMAKE_SYSROOT=${CMAKE_SYSROOT})
+ endif()
+
+ if(CMAKE_CROSSCOMPILING)
+ set(compiler_args -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+ -DCMAKE_AR=${CMAKE_AR}
+ -DCMAKE_RANLIB=${CMAKE_RANLIB})
+ set(llvm_config_path ${LLVM_CONFIG_PATH})
+ else()
+ set(llvm_config_path "$<TARGET_FILE:llvm-config>")
+ endif()
+
+ ExternalProject_Add(${name}
+ DEPENDS ${ARG_DEPENDS} llvm-config
+ ${name}-clobber
+ PREFIX ${CMAKE_BINARY_DIR}/projects/${name}
+ SOURCE_DIR ${source_dir}
+ STAMP_DIR ${STAMP_DIR}
+ BINARY_DIR ${BINARY_DIR}
+ ${exclude}
+ CMAKE_ARGS ${${nameCanon}_CMAKE_ARGS}
+ ${compiler_args}
+ -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
+ ${sysroot_arg}
+ -DLLVM_BINARY_DIR=${PROJECT_BINARY_DIR}
+ -DLLVM_CONFIG_PATH=${llvm_config_path}
+ -DLLVM_ENABLE_WERROR=${LLVM_ENABLE_WERROR}
+ -DLLVM_HOST_TRIPLE=${LLVM_HOST_TRIPLE}
+ -DLLVM_HAVE_LINK_VERSION_SCRIPT=${LLVM_HAVE_LINK_VERSION_SCRIPT}
+ -DPACKAGE_VERSION=${PACKAGE_VERSION}
+ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+ -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
+ -DCMAKE_EXPORT_COMPILE_COMMANDS=1
+ ${ARG_CMAKE_ARGS}
+ ${PASSTHROUGH_VARIABLES}
+ INSTALL_COMMAND ""
+ STEP_TARGETS configure build
+ BUILD_ALWAYS 1
+ USES_TERMINAL_CONFIGURE 1
+ USES_TERMINAL_BUILD 1
+ USES_TERMINAL_INSTALL 1
+ LIST_SEPARATOR |
+ )
+
+ if(ARG_USE_TOOLCHAIN)
+ set(force_deps DEPENDS ${TOOLCHAIN_BINS})
+ endif()
+
+ llvm_ExternalProject_BuildCmd(run_clean clean ${BINARY_DIR})
+ ExternalProject_Add_Step(${name} clean
+ COMMAND ${run_clean}
+ COMMENT "Cleaning ${name}..."
+ DEPENDEES configure
+ ${force_deps}
+ WORKING_DIRECTORY ${BINARY_DIR}
+ EXCLUDE_FROM_MAIN 1
+ USES_TERMINAL 1
+ )
+ ExternalProject_Add_StepTargets(${name} clean)
+
+ if(ARG_USE_TOOLCHAIN)
+ add_dependencies(${name}-clean ${name}-clobber)
+ set_target_properties(${name}-clean PROPERTIES
+ SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp)
+ endif()
+
+ if(NOT ARG_NO_INSTALL)
+ install(CODE "execute_process\(COMMAND \${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=\${CMAKE_INSTALL_PREFIX} -P ${BINARY_DIR}/cmake_install.cmake \)"
+ COMPONENT ${name})
+
+ add_llvm_install_targets(install-${name}
+ DEPENDS ${name}
+ COMPONENT ${name})
+ endif()
+
+ # Add top-level targets
+ foreach(target ${ARG_EXTRA_TARGETS})
+ string(REPLACE ":" ";" target_list ${target})
+ list(GET target_list 0 target)
+ list(LENGTH target_list target_list_len)
+ if(${target_list_len} GREATER 1)
+ list(GET target_list 1 target_name)
+ else()
+ set(target_name "${target}")
+ endif()
+ llvm_ExternalProject_BuildCmd(build_runtime_cmd ${target} ${BINARY_DIR})
+ add_custom_target(${target_name}
+ COMMAND ${build_runtime_cmd}
+ DEPENDS ${name}-configure
+ WORKING_DIRECTORY ${BINARY_DIR}
+ VERBATIM
+ USES_TERMINAL)
+ endforeach()
+endfunction()
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMInstallSymlink.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMInstallSymlink.cmake
new file mode 100644
index 0000000..1a04de9
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMInstallSymlink.cmake
@@ -0,0 +1,21 @@
+# We need to execute this script at installation time because the
+# DESTDIR environment variable may be unset at configuration time.
+# See PR8397.
+
+function(install_symlink name target outdir)
+ if(CMAKE_HOST_UNIX)
+ set(LINK_OR_COPY create_symlink)
+ set(DESTDIR $ENV{DESTDIR})
+ else()
+ set(LINK_OR_COPY copy)
+ endif()
+
+ set(bindir "${DESTDIR}${CMAKE_INSTALL_PREFIX}/${outdir}/")
+
+ message("Creating ${name}")
+
+ execute_process(
+ COMMAND "${CMAKE_COMMAND}" -E ${LINK_OR_COPY} "${target}" "${name}"
+ WORKING_DIRECTORY "${bindir}")
+
+endfunction()
diff --git a/linux-x64/clang/lib64/cmake/llvm/LLVMProcessSources.cmake b/linux-x64/clang/lib64/cmake/llvm/LLVMProcessSources.cmake
new file mode 100644
index 0000000..f65f31d
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/LLVMProcessSources.cmake
@@ -0,0 +1,111 @@
+include(AddFileDependencies)
+include(CMakeParseArguments)
+
+function(llvm_replace_compiler_option var old new)
+ # Replaces a compiler option or switch `old' in `var' by `new'.
+ # If `old' is not in `var', appends `new' to `var'.
+ # Example: llvm_replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O3" "-O2")
+ # If the option already is on the variable, don't add it:
+ if( "${${var}}" MATCHES "(^| )${new}($| )" )
+ set(n "")
+ else()
+ set(n "${new}")
+ endif()
+ if( "${${var}}" MATCHES "(^| )${old}($| )" )
+ string( REGEX REPLACE "(^| )${old}($| )" " ${n} " ${var} "${${var}}" )
+ else()
+ set( ${var} "${${var}} ${n}" )
+ endif()
+ set( ${var} "${${var}}" PARENT_SCOPE )
+endfunction(llvm_replace_compiler_option)
+
+macro(add_td_sources srcs)
+ file(GLOB tds *.td)
+ if( tds )
+ source_group("TableGen descriptions" FILES ${tds})
+ set_source_files_properties(${tds} PROPERTIES HEADER_FILE_ONLY ON)
+ list(APPEND ${srcs} ${tds})
+ endif()
+endmacro(add_td_sources)
+
+function(add_header_files_for_glob hdrs_out glob)
+ file(GLOB hds ${glob})
+ set(${hdrs_out} ${hds} PARENT_SCOPE)
+endfunction(add_header_files_for_glob)
+
+function(find_all_header_files hdrs_out additional_headerdirs)
+ add_header_files_for_glob(hds *.h)
+ list(APPEND all_headers ${hds})
+
+ foreach(additional_dir ${additional_headerdirs})
+ add_header_files_for_glob(hds "${additional_dir}/*.h")
+ list(APPEND all_headers ${hds})
+ add_header_files_for_glob(hds "${additional_dir}/*.inc")
+ list(APPEND all_headers ${hds})
+ endforeach(additional_dir)
+
+ set( ${hdrs_out} ${all_headers} PARENT_SCOPE )
+endfunction(find_all_header_files)
+
+
+function(llvm_process_sources OUT_VAR)
+ cmake_parse_arguments(ARG "" "" "ADDITIONAL_HEADERS;ADDITIONAL_HEADER_DIRS" ${ARGN})
+ set(sources ${ARG_UNPARSED_ARGUMENTS})
+ llvm_check_source_file_list( ${sources} )
+ if( LLVM_ENABLE_IDE )
+ # This adds .td and .h files to the Visual Studio solution:
+ add_td_sources(sources)
+ find_all_header_files(hdrs "${ARG_ADDITIONAL_HEADER_DIRS}")
+ if (hdrs)
+ set_source_files_properties(${hdrs} PROPERTIES HEADER_FILE_ONLY ON)
+ endif()
+ set_source_files_properties(${ARG_ADDITIONAL_HEADERS} PROPERTIES HEADER_FILE_ONLY ON)
+ list(APPEND sources ${ARG_ADDITIONAL_HEADERS} ${hdrs})
+ endif()
+
+ set( ${OUT_VAR} ${sources} PARENT_SCOPE )
+endfunction(llvm_process_sources)
+
+
+function(llvm_check_source_file_list)
+ cmake_parse_arguments(ARG "" "SOURCE_DIR" "" ${ARGN})
+ foreach(l ${ARG_UNPARSED_ARGUMENTS})
+ get_filename_component(fp ${l} REALPATH)
+ list(APPEND listed ${fp})
+ endforeach()
+
+ if(ARG_SOURCE_DIR)
+ file(GLOB globbed
+ "${ARG_SOURCE_DIR}/*.c" "${ARG_SOURCE_DIR}/*.cpp")
+ else()
+ file(GLOB globbed *.c *.cpp)
+ endif()
+
+ foreach(g ${globbed})
+ get_filename_component(fn ${g} NAME)
+ if(ARG_SOURCE_DIR)
+ set(entry "${g}")
+ else()
+ set(entry "${fn}")
+ endif()
+ get_filename_component(gp ${g} REALPATH)
+
+ # Don't reject hidden files. Some editors create backups in the
+ # same directory as the file.
+ if (NOT "${fn}" MATCHES "^\\.")
+ list(FIND LLVM_OPTIONAL_SOURCES ${entry} idx)
+ if( idx LESS 0 )
+ list(FIND listed ${gp} idx)
+ if( idx LESS 0 )
+ if(ARG_SOURCE_DIR)
+ set(fn_relative "${ARG_SOURCE_DIR}/${fn}")
+ else()
+ set(fn_relative "${fn}")
+ endif()
+ message(SEND_ERROR "Found unknown source file ${fn_relative}
+Please update ${CMAKE_CURRENT_LIST_FILE}\n")
+ endif()
+ endif()
+ endif()
+ endforeach()
+endfunction(llvm_check_source_file_list)
diff --git a/linux-x64/clang/lib64/cmake/llvm/TableGen.cmake b/linux-x64/clang/lib64/cmake/llvm/TableGen.cmake
new file mode 100644
index 0000000..d1afcb4
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/TableGen.cmake
@@ -0,0 +1,183 @@
+# LLVM_TARGET_DEFINITIONS must contain the name of the .td file to process.
+# Extra parameters for `tblgen' may come after `ofn' parameter.
+# Adds the name of the generated file to TABLEGEN_OUTPUT.
+
+include(LLVMExternalProjectUtils)
+
+if(LLVM_MAIN_INCLUDE_DIR)
+ set(LLVM_TABLEGEN_FLAGS -I ${LLVM_MAIN_INCLUDE_DIR})
+endif()
+
+function(tablegen project ofn)
+ # Validate calling context.
+ if(NOT ${project}_TABLEGEN_EXE)
+ message(FATAL_ERROR "${project}_TABLEGEN_EXE not set")
+ endif()
+
+ # Use depfile instead of globbing arbitrary *.td(s)
+ # DEPFILE is available for Ninja Generator with CMake>=3.7.
+ if(CMAKE_GENERATOR STREQUAL "Ninja" AND NOT CMAKE_VERSION VERSION_LESS 3.7)
+ # Make output path relative to build.ninja, assuming located on
+ # ${CMAKE_BINARY_DIR}.
+ # CMake emits build targets as relative paths but Ninja doesn't identify
+ # absolute path (in *.d) as relative path (in build.ninja)
+ # Note that tblgen is executed on ${CMAKE_BINARY_DIR} as working directory.
+ file(RELATIVE_PATH ofn_rel
+ ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/${ofn})
+ set(additional_cmdline
+ -o ${ofn_rel}.tmp
+ -d ${ofn_rel}.d
+ WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+ DEPFILE ${CMAKE_CURRENT_BINARY_DIR}/${ofn}.d
+ )
+ set(local_tds)
+ set(global_tds)
+ else()
+ file(GLOB local_tds "*.td")
+ file(GLOB_RECURSE global_tds "${LLVM_MAIN_INCLUDE_DIR}/llvm/*.td")
+ set(additional_cmdline
+ -o ${CMAKE_CURRENT_BINARY_DIR}/${ofn}.tmp
+ )
+ endif()
+
+ if (IS_ABSOLUTE ${LLVM_TARGET_DEFINITIONS})
+ set(LLVM_TARGET_DEFINITIONS_ABSOLUTE ${LLVM_TARGET_DEFINITIONS})
+ else()
+ set(LLVM_TARGET_DEFINITIONS_ABSOLUTE
+ ${CMAKE_CURRENT_SOURCE_DIR}/${LLVM_TARGET_DEFINITIONS})
+ endif()
+ if (LLVM_ENABLE_DAGISEL_COV)
+ list(FIND ARGN "-gen-dag-isel" idx)
+ if( NOT idx EQUAL -1 )
+ list(APPEND LLVM_TABLEGEN_FLAGS "-instrument-coverage")
+ endif()
+ endif()
+ if (LLVM_ENABLE_GISEL_COV)
+ list(FIND ARGN "-gen-global-isel" idx)
+ if( NOT idx EQUAL -1 )
+ list(APPEND LLVM_TABLEGEN_FLAGS "-instrument-gisel-coverage")
+ list(APPEND LLVM_TABLEGEN_FLAGS "-gisel-coverage-file=${LLVM_GISEL_COV_PREFIX}all")
+ endif()
+ endif()
+
+ # We need both _TABLEGEN_TARGET and _TABLEGEN_EXE in the DEPENDS list
+ # (both the target and the file) to have .inc files rebuilt on
+ # a tablegen change, as cmake does not propagate file-level dependencies
+ # of custom targets. See the following ticket for more information:
+ # https://cmake.org/Bug/view.php?id=15858
+ # The dependency on both, the target and the file, produces the same
+ # dependency twice in the result file when
+ # ("${${project}_TABLEGEN_TARGET}" STREQUAL "${${project}_TABLEGEN_EXE}")
+ # but lets us having smaller and cleaner code here.
+ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${ofn}.tmp
+ # Generate tablegen output in a temporary file.
+ COMMAND ${${project}_TABLEGEN_EXE} ${ARGN} -I ${CMAKE_CURRENT_SOURCE_DIR}
+ ${LLVM_TABLEGEN_FLAGS}
+ ${LLVM_TARGET_DEFINITIONS_ABSOLUTE}
+ ${additional_cmdline}
+ # The file in LLVM_TARGET_DEFINITIONS may be not in the current
+ # directory and local_tds may not contain it, so we must
+ # explicitly list it here:
+ DEPENDS ${${project}_TABLEGEN_TARGET} ${${project}_TABLEGEN_EXE}
+ ${local_tds} ${global_tds}
+ ${LLVM_TARGET_DEFINITIONS_ABSOLUTE}
+ COMMENT "Building ${ofn}..."
+ )
+ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
+ # Only update the real output file if there are any differences.
+ # This prevents recompilation of all the files depending on it if there
+ # aren't any.
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different
+ ${CMAKE_CURRENT_BINARY_DIR}/${ofn}.tmp
+ ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
+ DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${ofn}.tmp
+ COMMENT "Updating ${ofn}..."
+ )
+
+ # `make clean' must remove all those generated files:
+ set_property(DIRECTORY APPEND
+ PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${ofn}.tmp ${ofn})
+
+ set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn} PARENT_SCOPE)
+ set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${ofn} PROPERTIES
+ GENERATED 1)
+endfunction()
+
+# Creates a target for publicly exporting tablegen dependencies.
+function(add_public_tablegen_target target)
+ if(NOT TABLEGEN_OUTPUT)
+ message(FATAL_ERROR "Requires tablegen() definitions as TABLEGEN_OUTPUT.")
+ endif()
+ add_custom_target(${target}
+ DEPENDS ${TABLEGEN_OUTPUT})
+ if(LLVM_COMMON_DEPENDS)
+ add_dependencies(${target} ${LLVM_COMMON_DEPENDS})
+ endif()
+ set_target_properties(${target} PROPERTIES FOLDER "Tablegenning")
+ set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} ${target} PARENT_SCOPE)
+endfunction()
+
+macro(add_tablegen target project)
+ set(${target}_OLD_LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS})
+ set(LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS} TableGen)
+
+ # CMake-3.9 doesn't let compilation units depend on their dependent libraries.
+ if(NOT (CMAKE_GENERATOR STREQUAL "Ninja" AND NOT CMAKE_VERSION VERSION_LESS 3.9) AND NOT XCODE)
+ # FIXME: It leaks to user, callee of add_tablegen.
+ set(LLVM_ENABLE_OBJLIB ON)
+ endif()
+
+ add_llvm_executable(${target} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
+ set(LLVM_LINK_COMPONENTS ${${target}_OLD_LLVM_LINK_COMPONENTS})
+
+ set(${project}_TABLEGEN "${target}" CACHE
+ STRING "Native TableGen executable. Saves building one when cross-compiling.")
+
+ # Upgrade existing LLVM_TABLEGEN setting.
+ if(${project} STREQUAL LLVM)
+ if(${LLVM_TABLEGEN} STREQUAL tblgen)
+ set(LLVM_TABLEGEN "${target}" CACHE
+ STRING "Native TableGen executable. Saves building one when cross-compiling."
+ FORCE)
+ endif()
+ endif()
+
+ # Effective tblgen executable to be used:
+ set(${project}_TABLEGEN_EXE ${${project}_TABLEGEN} PARENT_SCOPE)
+ set(${project}_TABLEGEN_TARGET ${${project}_TABLEGEN} PARENT_SCOPE)
+
+ if(LLVM_USE_HOST_TOOLS)
+ if( ${${project}_TABLEGEN} STREQUAL "${target}" )
+ if (NOT CMAKE_CONFIGURATION_TYPES)
+ set(${project}_TABLEGEN_EXE "${LLVM_NATIVE_BUILD}/bin/${target}")
+ else()
+ set(${project}_TABLEGEN_EXE "${LLVM_NATIVE_BUILD}/Release/bin/${target}")
+ endif()
+ set(${project}_TABLEGEN_EXE ${${project}_TABLEGEN_EXE} PARENT_SCOPE)
+
+ llvm_ExternalProject_BuildCmd(tblgen_build_cmd ${target}
+ ${LLVM_NATIVE_BUILD}
+ CONFIGURATION Release)
+ add_custom_command(OUTPUT ${${project}_TABLEGEN_EXE}
+ COMMAND ${tblgen_build_cmd}
+ DEPENDS CONFIGURE_LLVM_NATIVE ${target}
+ WORKING_DIRECTORY ${LLVM_NATIVE_BUILD}
+ COMMENT "Building native TableGen..."
+ USES_TERMINAL)
+ add_custom_target(${project}-tablegen-host DEPENDS ${${project}_TABLEGEN_EXE})
+ set(${project}_TABLEGEN_TARGET ${project}-tablegen-host PARENT_SCOPE)
+ endif()
+ endif()
+
+ if (${project} STREQUAL LLVM AND NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+ if(${target} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
+ NOT LLVM_DISTRIBUTION_COMPONENTS)
+ set(export_to_llvmexports EXPORT LLVMExports)
+ endif()
+
+ install(TARGETS ${target}
+ ${export_to_llvmexports}
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR})
+ endif()
+ set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${target})
+endmacro()
diff --git a/linux-x64/clang/lib64/cmake/llvm/VersionFromVCS.cmake b/linux-x64/clang/lib64/cmake/llvm/VersionFromVCS.cmake
new file mode 100644
index 0000000..552fe77
--- /dev/null
+++ b/linux-x64/clang/lib64/cmake/llvm/VersionFromVCS.cmake
@@ -0,0 +1,92 @@
+# Adds version control information to the variable VERS. For
+# determining the Version Control System used (if any) it inspects the
+# existence of certain subdirectories under SOURCE_DIR (if provided as an
+# extra argument, otherwise uses CMAKE_CURRENT_SOURCE_DIR).
+
+function(add_version_info_from_vcs VERS)
+ SET(SOURCE_DIR ${ARGV1})
+ if("${SOURCE_DIR}" STREQUAL "")
+ SET(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ endif()
+ string(REPLACE "svn" "" result "${${VERS}}")
+ if( EXISTS "${SOURCE_DIR}/.svn" )
+ set(result "${result}svn")
+ # FindSubversion does not work with symlinks. See PR 8437
+ if( NOT IS_SYMLINK "${SOURCE_DIR}" )
+ find_package(Subversion)
+ endif()
+ if( Subversion_FOUND )
+ subversion_wc_info( ${SOURCE_DIR} Project )
+ if( Project_WC_REVISION )
+ set(SVN_REVISION ${Project_WC_REVISION} PARENT_SCOPE)
+ set(result "${result}-r${Project_WC_REVISION}")
+ endif()
+ if( Project_WC_URL )
+ set(LLVM_REPOSITORY ${Project_WC_URL} PARENT_SCOPE)
+ endif()
+ endif()
+ else()
+ find_program(git_executable NAMES git git.exe git.cmd)
+
+ if( git_executable )
+ # Run from a subdirectory to force git to print an absoute path.
+ execute_process(COMMAND ${git_executable} rev-parse --git-dir
+ WORKING_DIRECTORY ${SOURCE_DIR}/cmake
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_dir
+ ERROR_QUIET)
+ if(git_result EQUAL 0)
+ # Try to get a ref-id
+ string(STRIP "${git_dir}" git_dir)
+ set(result "${result}git")
+ if( EXISTS ${git_dir}/svn )
+ # Get the repository URL
+ execute_process(COMMAND
+ ${git_executable} svn info
+ WORKING_DIRECTORY ${SOURCE_DIR}
+ TIMEOUT 5
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_output
+ ERROR_QUIET)
+ if( git_result EQUAL 0 )
+ string(REGEX MATCH "URL: ([^ \n]*)" svn_url ${git_output})
+ if(svn_url)
+ set(LLVM_REPOSITORY ${CMAKE_MATCH_1} PARENT_SCOPE)
+ endif()
+ endif()
+
+ # Get the svn revision number for this git commit if one exists.
+ execute_process(COMMAND ${git_executable} svn find-rev HEAD
+ WORKING_DIRECTORY ${SOURCE_DIR}
+ TIMEOUT 5
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_head_svn_rev_number
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+ if( git_result EQUAL 0 AND git_output)
+ set(SVN_REVISION ${git_head_svn_rev_number} PARENT_SCOPE)
+ set(git_svn_rev "-svn-${git_head_svn_rev_number}")
+ else()
+ set(git_svn_rev "")
+ endif()
+ endif()
+
+ # Get the git ref id
+ execute_process(COMMAND
+ ${git_executable} rev-parse --short HEAD
+ WORKING_DIRECTORY ${SOURCE_DIR}
+ TIMEOUT 5
+ RESULT_VARIABLE git_result
+ OUTPUT_VARIABLE git_ref_id
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+ if( git_result EQUAL 0 )
+ set(GIT_COMMIT ${git_ref_id} PARENT_SCOPE)
+ set(result "${result}${git_svn_rev}-${git_ref_id}")
+ else()
+ set(result "${result}${git_svn_rev}")
+ endif()
+ endif()
+ endif()
+ endif()
+ set(${VERS} ${result} PARENT_SCOPE)
+endfunction(add_version_info_from_vcs)