summaryrefslogtreecommitdiff
path: root/cmake/modules
diff options
context:
space:
mode:
Diffstat (limited to 'cmake/modules')
-rwxr-xr-xcmake/modules/AddLLVM.cmake190
-rw-r--r--cmake/modules/AddOCaml.cmake8
-rw-r--r--cmake/modules/CMakeLists.txt5
-rw-r--r--cmake/modules/CheckAtomic.cmake37
-rw-r--r--cmake/modules/CheckCompilerVersion.cmake52
-rw-r--r--cmake/modules/CrossCompile.cmake2
-rw-r--r--cmake/modules/GenerateVersionFromCVS.cmake39
-rw-r--r--cmake/modules/GetHostTriple.cmake2
-rw-r--r--cmake/modules/HandleLLVMOptions.cmake191
-rw-r--r--cmake/modules/LLVMConfig.cmake.in9
-rw-r--r--cmake/modules/LLVMExternalProjectUtils.cmake90
-rw-r--r--cmake/modules/Makefile151
-rw-r--r--cmake/modules/TableGen.cmake2
-rw-r--r--cmake/modules/VersionFromVCS.cmake42
14 files changed, 468 insertions, 352 deletions
diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake
index a829751eca8f4..26e439600140c 100755
--- a/cmake/modules/AddLLVM.cmake
+++ b/cmake/modules/AddLLVM.cmake
@@ -8,9 +8,9 @@ function(llvm_update_compile_flags name)
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) AND NOT CLANG_CL)
+ # 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)
@@ -328,11 +328,13 @@ endfunction(set_windows_version_resource_properties)
# 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"
+ "OUTPUT_NAME;PLUGIN_TOOL"
"ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS"
${ARGN})
list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
@@ -350,11 +352,15 @@ function(llvm_add_library name)
if(ARG_SHARED OR ARG_STATIC)
message(WARNING "MODULE with SHARED|STATIC doesn't make sense.")
endif()
- if(NOT LLVM_ENABLE_PLUGINS)
+ # 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()
@@ -468,7 +474,10 @@ function(llvm_add_library name)
endif()
endif()
- if (DEFINED LLVM_LINK_COMPONENTS OR DEFINED ARG_LINK_COMPONENTS)
+ 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()
@@ -487,27 +496,18 @@ function(llvm_add_library name)
get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name})
endif()
- if(CMAKE_VERSION VERSION_LESS 2.8.12)
- # Link libs w/o keywords, assuming PUBLIC.
- target_link_libraries(${name}
- ${ARG_LINK_LIBS}
- ${lib_deps}
- ${llvm_libs}
- )
- elseif(ARG_STATIC)
- target_link_libraries(${name} INTERFACE
- ${ARG_LINK_LIBS}
- ${lib_deps}
- ${llvm_libs}
- )
+ if(ARG_STATIC)
+ set(libtype INTERFACE)
else()
# We can use PRIVATE since SO knows its dependent libs.
- target_link_libraries(${name} PRIVATE
+ set(libtype PRIVATE)
+ endif()
+
+ target_link_libraries(${name} ${libtype}
${ARG_LINK_LIBS}
${lib_deps}
${llvm_libs}
)
- endif()
if(LLVM_COMMON_DEPENDS)
add_dependencies(${name} ${LLVM_COMMON_DEPENDS})
@@ -670,10 +670,78 @@ macro(add_llvm_executable name)
if(NOT ARG_IGNORE_EXTERNALIZE_DEBUGINFO)
llvm_externalize_debuginfo(${name})
endif()
+ if (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} ${PTHREAD_LIB})
+ endif()
endmacro(add_llvm_executable name)
function(export_executable_symbols target)
- if (NOT MSVC) # MSVC's linker doesn't support exporting all symbols.
+ 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
@@ -702,7 +770,7 @@ macro(add_llvm_tool name)
if( LLVM_BUILD_TOOLS )
install(TARGETS ${name}
EXPORT LLVMExports
- RUNTIME DESTINATION bin
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
COMPONENT ${name})
if (NOT CMAKE_CONFIGURATION_TYPES)
@@ -732,11 +800,16 @@ macro(add_llvm_example name)
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 )
+ if( LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS )
install (TARGETS ${name}
RUNTIME DESTINATION bin
COMPONENT ${name})
@@ -767,8 +840,8 @@ function(canonicalize_tool_name name output)
endfunction(canonicalize_tool_name)
# Custom add_subdirectory wrapper
-# Takes in a project name (i.e. LLVM), the the subdirectory name, and an
-# and an optional path if it differs from the name.
+# 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 "")
@@ -850,13 +923,13 @@ function(create_llvm_tool_options)
create_subdirectory_options(LLVM TOOL)
endfunction(create_llvm_tool_options)
-function(add_llvm_implicit_projects)
+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 (LLVM_TOOL_${name}_BUILD)
+ if (${project}_TOOL_${name}_BUILD)
get_filename_component(fn "${dir}" NAME)
list(APPEND list_of_implicit_subdirs "${fn}")
endif()
@@ -864,8 +937,12 @@ function(add_llvm_implicit_projects)
endforeach()
foreach(external_proj ${list_of_implicit_subdirs})
- add_llvm_external_project("${external_proj}")
+ 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.
@@ -889,7 +966,10 @@ function(add_unittest test_suite test_name)
add_llvm_executable(${test_name} IGNORE_EXTERNALIZE_DEBUGINFO ${ARGN})
set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
set_output_directory(${test_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir})
- target_link_libraries(${test_name} gtest_main gtest)
+ # 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} gtest_main gtest ${PTHREAD_LIB})
add_dependencies(${test_suite} ${test_name})
get_target_property(test_suite_folder ${test_suite} FOLDER)
@@ -913,13 +993,8 @@ function(llvm_add_go_executable binary pkgpath)
set(cppflags "${cppflags} -I${d}")
endforeach(d)
set(ldflags "${CMAKE_EXE_LINKER_FLAGS}")
- if (LLVM_LINK_LLVM_DYLIB)
- set(linkmode "dylib")
- else()
- set(linkmode "component-libs")
- endif()
add_custom_command(OUTPUT ${binpath}
- COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" "linkmode=${linkmode}"
+ COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}"
${ARG_GOFLAGS} build -o ${binpath} ${pkgpath}
DEPENDS llvm-config ${CMAKE_BINARY_DIR}/bin/llvm-go${CMAKE_EXECUTABLE_SUFFIX}
${llvmlibs} ${ARG_DEPENDS}
@@ -984,6 +1059,8 @@ function(configure_lit_site_cfg input output)
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 ${input}\n## Do not edit!")
+
configure_file(${input} ${output} @ONLY)
endfunction()
@@ -1009,7 +1086,7 @@ function(add_lit_target target comment)
add_custom_target(${target}
COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS}
COMMENT "${comment}"
- ${cmake_3_2_USES_TERMINAL}
+ USES_TERMINAL
)
else()
add_custom_target(${target}
@@ -1049,21 +1126,27 @@ endfunction()
function(add_lit_testsuites project directory)
if (NOT CMAKE_CONFIGURATION_TYPES)
cmake_parse_arguments(ARG "" "" "PARAMS;DEPENDS;ARGS" ${ARGN})
- file(GLOB_RECURSE litCfg ${directory}/lit*.cfg)
- set(lit_suites)
- foreach(f ${litCfg})
- get_filename_component(dir ${f} DIRECTORY)
- set(lit_suites ${lit_suites} ${dir})
- endforeach()
- list(REMOVE_DUPLICATES lit_suites)
- foreach(dir ${lit_suites})
- string(REPLACE ${directory} "" name_slash ${dir})
+
+ # 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)
+ if (NOT is_inputs 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 ${dir}"
- ${dir}
+ add_lit_target("check-${name_var}" "Running lit suite ${lit_suite}"
+ ${lit_suite}
PARAMS ${ARG_PARAMS}
DEPENDS ${ARG_DEPENDS}
ARGS ${ARG_ARGS}
@@ -1127,7 +1210,7 @@ function(llvm_install_symlink name dest)
set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
install(SCRIPT ${INSTALL_SYMLINK}
- CODE "install_symlink(${full_name} ${full_dest} bin)"
+ CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
COMPONENT ${component})
if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
@@ -1186,6 +1269,10 @@ function(llvm_externalize_debuginfo name)
return()
endif()
+ if(NOT LLVM_EXTERNALIZE_DEBUGINFO_SKIP_STRIP)
+ set(strip_command COMMAND xcrun strip -Sxl $<TARGET_FILE:${name}>)
+ endif()
+
if(APPLE)
if(CMAKE_CXX_FLAGS MATCHES "-flto"
OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto")
@@ -1196,7 +1283,8 @@ function(llvm_externalize_debuginfo name)
endif()
add_custom_command(TARGET ${name} POST_BUILD
COMMAND xcrun dsymutil $<TARGET_FILE:${name}>
- COMMAND xcrun strip -Sl $<TARGET_FILE:${name}>)
+ ${strip_command}
+ )
else()
message(FATAL_ERROR "LLVM_EXTERNALIZE_DEBUGINFO isn't implemented for non-darwin platforms!")
endif()
diff --git a/cmake/modules/AddOCaml.cmake b/cmake/modules/AddOCaml.cmake
index 8b33332d07bcd..e3dd1d840772c 100644
--- a/cmake/modules/AddOCaml.cmake
+++ b/cmake/modules/AddOCaml.cmake
@@ -73,7 +73,13 @@ function(add_ocaml_library name)
get_property(system_libs TARGET LLVMSupport PROPERTY LLVM_SYSTEM_LIBS)
foreach(system_lib ${system_libs})
- list(APPEND ocaml_flags "-l${system_lib}" )
+ 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}")
diff --git a/cmake/modules/CMakeLists.txt b/cmake/modules/CMakeLists.txt
index 5f3f255628d66..826dd366359db 100644
--- a/cmake/modules/CMakeLists.txt
+++ b/cmake/modules/CMakeLists.txt
@@ -1,4 +1,4 @@
-set(LLVM_INSTALL_PACKAGE_DIR share/llvm/cmake)
+set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
get_property(LLVM_EXPORTS GLOBAL PROPERTY LLVM_EXPORTS)
@@ -29,6 +29,7 @@ set(LLVM_CONFIG_LIBRARY_DIRS
"${LLVM_LIBRARY_DIR}"
)
set(LLVM_CONFIG_CMAKE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+set(LLVM_CONFIG_BINARY_DIR "${LLVM_BINARY_DIR}")
set(LLVM_CONFIG_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}")
set(LLVM_CONFIG_EXPORTS_FILE "${llvm_cmake_builddir}/LLVMExports.cmake")
configure_file(
@@ -60,6 +61,7 @@ endforeach(p)
set(LLVM_CONFIG_INCLUDE_DIRS "\${LLVM_INSTALL_PREFIX}/include")
set(LLVM_CONFIG_LIBRARY_DIRS "\${LLVM_INSTALL_PREFIX}/lib\${LLVM_LIBDIR_SUFFIX}")
set(LLVM_CONFIG_CMAKE_DIR "\${LLVM_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
+set(LLVM_CONFIG_BINARY_DIR "\${LLVM_INSTALL_PREFIX}")
set(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}/bin")
set(LLVM_CONFIG_EXPORTS_FILE "\${LLVM_CMAKE_DIR}/LLVMExports.cmake")
configure_file(
@@ -90,6 +92,5 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
PATTERN LLVMConfigVersion.cmake EXCLUDE
PATTERN LLVM-Config.cmake EXCLUDE
PATTERN GetHostTriple.cmake EXCLUDE
- PATTERN VersionFromVCS.cmake EXCLUDE
PATTERN CheckAtomic.cmake EXCLUDE)
endif()
diff --git a/cmake/modules/CheckAtomic.cmake b/cmake/modules/CheckAtomic.cmake
index 551de6ade84c0..dcf021b8fddaf 100644
--- a/cmake/modules/CheckAtomic.cmake
+++ b/cmake/modules/CheckAtomic.cmake
@@ -18,6 +18,22 @@ int main() {
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)
@@ -38,6 +54,27 @@ if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
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.
diff --git a/cmake/modules/CheckCompilerVersion.cmake b/cmake/modules/CheckCompilerVersion.cmake
new file mode 100644
index 0000000000000..08900a4599e9a
--- /dev/null
+++ b/cmake/modules/CheckCompilerVersion.cmake
@@ -0,0 +1,52 @@
+# Check if the host compiler is new enough. LLVM requires at least GCC 4.7,
+# MSVC 2013, 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.7)
+ message(FATAL_ERROR "Host GCC version must be at least 4.7!")
+ 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 18.0)
+ message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=18.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 "-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.7 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 18.0)
+ message(FATAL_ERROR "Host Visual Studio must be at least 2013")
+ elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.31101)
+ message(WARNING "Host Visual Studio should at least be 2013 Update 4 (MSVC 18.0.31101)"
+ " due to miscompiles from earlier versions")
+ endif()
+ endif()
+ endif()
+endif()
diff --git a/cmake/modules/CrossCompile.cmake b/cmake/modules/CrossCompile.cmake
index c136dfaa612e0..9c598a6a07b0f 100644
--- a/cmake/modules/CrossCompile.cmake
+++ b/cmake/modules/CrossCompile.cmake
@@ -1,4 +1,4 @@
-function(llvm_create_cross_target_internal target_name toochain buildtype)
+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}")
diff --git a/cmake/modules/GenerateVersionFromCVS.cmake b/cmake/modules/GenerateVersionFromCVS.cmake
new file mode 100644
index 0000000000000..6b1c719834667
--- /dev/null
+++ b/cmake/modules/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/cmake/modules/GetHostTriple.cmake b/cmake/modules/GetHostTriple.cmake
index 671a8ce7d7ce2..5de710c7ede0b 100644
--- a/cmake/modules/GetHostTriple.cmake
+++ b/cmake/modules/GetHostTriple.cmake
@@ -15,7 +15,7 @@ function( get_host_triple var )
set( value "i686-pc-mingw32" )
endif()
else( MSVC )
- set(config_guess ${LLVM_MAIN_SRC_DIR}/autoconf/config.guess)
+ set(config_guess ${LLVM_MAIN_SRC_DIR}/cmake/config.guess)
execute_process(COMMAND sh ${config_guess}
RESULT_VARIABLE TT_RV
OUTPUT_VARIABLE TT_OUT
diff --git a/cmake/modules/HandleLLVMOptions.cmake b/cmake/modules/HandleLLVMOptions.cmake
index 6db258ff66a15..22b4408b1ac0f 100644
--- a/cmake/modules/HandleLLVMOptions.cmake
+++ b/cmake/modules/HandleLLVMOptions.cmake
@@ -6,53 +6,19 @@
# else.
string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
+include(CheckCompilerVersion)
include(HandleLLVMStdlib)
include(AddLLVMDefinitions)
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
-if(NOT LLVM_FORCE_USE_OLD_TOOLCHAIN)
- if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
- if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
- message(FATAL_ERROR "Host GCC version must be at least 4.7!")
- 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 18.0)
- message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=18.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 "-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.7 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 18.0)
- message(FATAL_ERROR "Host Visual Studio must be at least 2013")
- elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.31101)
- message(WARNING "Host Visual Studio should at least be 2013 Update 4 (MSVC 18.0.31101)"
- " due to miscompiles from earlier versions")
- endif()
- endif()
+if (CMAKE_LINKER MATCHES "lld-link.exe")
+ # 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 )
@@ -78,6 +44,11 @@ if( LLVM_ENABLE_ASSERTIONS )
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" )
@@ -195,7 +166,8 @@ 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.")
- add_llvm_definitions( -m32 )
+ 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")
@@ -255,14 +227,12 @@ if( MSVC )
include(ChooseMSVCCRT)
- if( NOT (${CMAKE_VERSION} VERSION_LESS 2.8.11) )
- # set stack reserved size to ~10MB
- # 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")
- endif()
+ # set stack reserved size to ~10MB
+ # 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")
if( MSVC11 )
add_llvm_definitions(-D_VARIADIC_MAX=10)
@@ -279,6 +249,12 @@ if( MSVC )
-D_SCL_SECURE_NO_WARNINGS
)
+ # Tell MSVC to use the Unicode version of the Win32 APIs instead of ANSI.
+ add_llvm_definitions(
+ -DUNICODE
+ -D_UNICODE
+ )
+
set(msvc_warning_flags
# Disabled warnings.
-wd4141 # Suppress ''modifier' : used more than once' (because of __forceinline combined with inline)
@@ -320,6 +296,7 @@ if( MSVC )
# 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
@@ -328,7 +305,7 @@ if( MSVC )
# 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.
@@ -363,17 +340,32 @@ if( MSVC )
append("/Zc:inline" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
- if (NOT LLVM_ENABLE_TIMESTAMPS AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+ # /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")
# 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, so pass that when
- # LLVM_ENABLE_TIMESTAMPS is turned off.
+ # has the flag /Brepro to force deterministic binaries. We want to pass that
+ # whenever you're building with clang unless you're passing /incremental.
# 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)
- append_if(SUPPORTS_BREPRO "/Brepro" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
-
if (SUPPORTS_BREPRO)
# Check if /INCREMENTAL is passed to the linker and complain that it
# won't work with /Brepro.
@@ -381,14 +373,13 @@ if( MSVC )
string(TOUPPER "${CMAKE_MODULE_LINKER_FLAGS}" upper_module_flags)
string(TOUPPER "${CMAKE_SHARED_LINKER_FLAGS}" upper_shared_flags)
- string(FIND "${upper_exe_flags}" "/INCREMENTAL" exe_index)
- string(FIND "${upper_module_flags}" "/INCREMENTAL" module_index)
- string(FIND "${upper_shared_flags}" "/INCREMENTAL" shared_index)
+ string(FIND "${upper_exe_flags} ${upper_module_flags} ${upper_shared_flags}"
+ "/INCREMENTAL" linker_flag_idx)
- if (${exe_index} GREATER -1 OR
- ${module_index} GREATER -1 OR
- ${shared_index} GREATER -1)
- message(FATAL_ERROR "LLVM_ENABLE_TIMESTAMPS not compatible with /INCREMENTAL linking")
+ 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()
@@ -454,9 +445,7 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
endif()
endif (LLVM_ENABLE_WARNINGS)
append_if(LLVM_ENABLE_WERROR "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
- if (NOT LLVM_ENABLE_TIMESTAMPS)
- add_flag_if_supported("-Werror=date-time" WERROR_DATE_TIME)
- endif ()
+ add_flag_if_supported("-Werror=date-time" WERROR_DATE_TIME)
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)
@@ -476,7 +465,21 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
endif()
if (LLVM_ENABLE_MODULES)
set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
- set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fmodules")
+ set(module_flags "-fmodules -fmodules-cache-path=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
@@ -487,8 +490,7 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
CXX_SUPPORTS_MODULES)
set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
if (CXX_SUPPORTS_MODULES)
- append_if(CXX_SUPPORTS_MODULES "-fmodules" CMAKE_C_FLAGS)
- append_if(CXX_SUPPORTS_MODULES "-fmodules -fcxx-modules" CMAKE_CXX_FLAGS)
+ append("${module_flags}" CMAKE_CXX_FLAGS)
else()
message(FATAL_ERROR "LLVM_ENABLE_MODULES is not supported by this compiler")
endif()
@@ -514,10 +516,6 @@ macro(append_common_sanitizer_flags)
if (CMAKE_LINKER MATCHES "lld-link.exe")
# Use DWARF debug info with LLD.
append("-gdwarf" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
- # Pass /MANIFEST:NO so that CMake doesn't run mt.exe on our binaries.
- # Adding manifests with mt.exe breaks LLD's symbol tables. See PR24476.
- append("/MANIFEST:NO"
- CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
else()
# Enable codeview otherwise.
append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
@@ -580,7 +578,7 @@ add_llvm_definitions( -D__STDC_LIMIT_MACROS )
# clang doesn't print colored diagnostics when invoked from Ninja
if (UNIX AND
- CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND
+ CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND
CMAKE_GENERATOR STREQUAL "Ninja")
append("-fcolor-diagnostics" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
@@ -602,15 +600,6 @@ if(NOT CYGWIN AND NOT WIN32)
endif()
endif()
-if(CYGWIN OR MINGW)
- # Prune --out-implib from executables. It doesn't make sense even
- # with --export-all-symbols.
- string(REGEX REPLACE "-Wl,--out-implib,[^ ]+ " " "
- CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_LINK_EXECUTABLE}")
- string(REGEX REPLACE "-Wl,--out-implib,[^ ]+ " " "
- CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE}")
-endif()
-
if(MSVC)
# Remove flags here, for exceptions and RTTI.
# Each target property or source property should be responsible to control
@@ -629,12 +618,46 @@ endif()
option(LLVM_BUILD_INSTRUMENTED "Build LLVM and tools with PGO instrumentation (experimental)" Off)
mark_as_advanced(LLVM_BUILD_INSTRUMENTED)
-append_if(LLVM_BUILD_INSTRUMENTED "-fprofile-instr-generate"
+append_if(LLVM_BUILD_INSTRUMENTED "-fprofile-instr-generate='${LLVM_PROFILE_FILE_PATTERN}'"
+ CMAKE_CXX_FLAGS
+ CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS
+ CMAKE_SHARED_LINKER_FLAGS)
+
+option(LLVM_BUILD_INSTRUMENTED_COVERAGE "Build LLVM and tools with Code Coverage instrumentation (experimental)" 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)
+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)
+if(uppercase_LLVM_ENABLE_LTO STREQUAL "THIN")
+ append("-flto=thin" CMAKE_CXX_FLAGS CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+elseif(uppercase_LLVM_ENABLE_LTO STREQUAL "FULL")
+ append("-flto=full" CMAKE_CXX_FLAGS CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+elseif(LLVM_ENABLE_LTO)
+ append("-flto" CMAKE_CXX_FLAGS CMAKE_C_FLAGS
+ CMAKE_EXE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
+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)
diff --git a/cmake/modules/LLVMConfig.cmake.in b/cmake/modules/LLVMConfig.cmake.in
index 6855c44225432..492a43d9ebc17 100644
--- a/cmake/modules/LLVMConfig.cmake.in
+++ b/cmake/modules/LLVMConfig.cmake.in
@@ -7,6 +7,8 @@ set(LLVM_VERSION_MINOR @LLVM_VERSION_MINOR@)
set(LLVM_VERSION_PATCH @LLVM_VERSION_PATCH@)
set(LLVM_PACKAGE_VERSION @PACKAGE_VERSION@)
+set(LLVM_BUILD_TYPE @CMAKE_BUILD_TYPE@)
+
set(LLVM_COMMON_DEPENDS @LLVM_COMMON_DEPENDS@)
set(LLVM_AVAILABLE_LIBS @LLVM_AVAILABLE_LIBS@)
@@ -39,7 +41,10 @@ set(LLVM_NATIVE_ARCH @LLVM_NATIVE_ARCH@)
set(LLVM_ENABLE_PIC @LLVM_ENABLE_PIC@)
+set(LLVM_BUILD_32_BITS @LLVM_BUILD_32_BITS@)
+
set(LLVM_ENABLE_PLUGINS @LLVM_ENABLE_PLUGINS@)
+set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS @LLVM_EXPORT_SYMBOLS_FOR_PLUGINS@)
set(LLVM_PLUGIN_EXT @LLVM_PLUGIN_EXT@)
set(LLVM_ON_UNIX @LLVM_ON_UNIX@)
@@ -49,11 +54,15 @@ set(LLVM_LIBDIR_SUFFIX @LLVM_LIBDIR_SUFFIX@)
set(LLVM_INCLUDE_DIRS "@LLVM_CONFIG_INCLUDE_DIRS@")
set(LLVM_LIBRARY_DIRS "@LLVM_CONFIG_LIBRARY_DIRS@")
+set(LLVM_LIBRARY_DIR "@LLVM_CONFIG_LIBRARY_DIRS@")
set(LLVM_DEFINITIONS "@LLVM_DEFINITIONS@")
set(LLVM_CMAKE_DIR "@LLVM_CONFIG_CMAKE_DIR@")
+set(LLVM_BINARY_DIR "@LLVM_CONFIG_BINARY_DIR@")
set(LLVM_TOOLS_BINARY_DIR "@LLVM_CONFIG_TOOLS_BINARY_DIR@")
+set(LLVM_TOOLS_INSTALL_DIR "@LLVM_TOOLS_INSTALL_DIR@")
if(NOT TARGET LLVMSupport)
+ set(LLVM_EXPORTED_TARGETS "@LLVM_EXPORTS@")
include("@LLVM_CONFIG_EXPORTS_FILE@")
endif()
diff --git a/cmake/modules/LLVMExternalProjectUtils.cmake b/cmake/modules/LLVMExternalProjectUtils.cmake
index c2d9f530c200e..3e7355d4d6b2c 100644
--- a/cmake/modules/LLVMExternalProjectUtils.cmake
+++ b/cmake/modules/LLVMExternalProjectUtils.cmake
@@ -2,12 +2,12 @@ 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)
+function(llvm_ExternalProject_BuildCmd out_var target bin_dir)
if (CMAKE_GENERATOR MATCHES "Make")
# Use special command for Makefiles to support parallelism.
- set(${out_var} "$(MAKE)" "${target}" PARENT_SCOPE)
+ set(${out_var} "$(MAKE)" "-C" "${BINARY_DIR}" "${target}" PARENT_SCOPE)
else()
- set(${out_var} ${CMAKE_COMMAND} --build . --target ${target}
+ set(${out_var} ${CMAKE_COMMAND} --build ${bin_dir} --target ${target}
--config $<CONFIGURATION> PARENT_SCOPE)
endif()
endfunction()
@@ -19,6 +19,8 @@ endfunction()
# 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...
@@ -27,11 +29,15 @@ endfunction()
# 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"
+ cmake_parse_arguments(ARG
+ "USE_TOOLCHAIN;EXCLUDE_FROM_ALL;NO_INSTALL;ALWAYS_CLEAN"
"SOURCE_DIR"
- "CMAKE_ARGS;TOOLCHAIN_TOOLS;RUNTIME_LIBRARIES;DEPENDS;EXTRA_TARGETS" ${ARGN})
+ "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)
@@ -52,6 +58,10 @@ function(llvm_ExternalProject_Add name source_dir)
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)
@@ -61,23 +71,6 @@ function(llvm_ExternalProject_Add name source_dir)
list(APPEND TOOLCHAIN_BINS ${RUNTIME_LIBRARIES})
endif()
- if(CMAKE_VERSION VERSION_GREATER 3.1.0)
- set(cmake_3_1_EXCLUDE_FROM_ALL EXCLUDE_FROM_ALL 1)
- endif()
-
- if(CMAKE_VERSION VERSION_GREATER 3.3.20150708)
- set(cmake_3_4_USES_TERMINAL_OPTIONS
- USES_TERMINAL_CONFIGURE 1
- USES_TERMINAL_BUILD 1
- USES_TERMINAL_INSTALL 1
- )
- set(cmake_3_4_USES_TERMINAL USES_TERMINAL 1)
- endif()
-
- if(CMAKE_VERSION VERSION_GREATER 3.1.20141116)
- set(cmake_3_2_USES_TERMINAL USES_TERMINAL)
- endif()
-
set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/${name}-stamps/)
set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${name}-bins/)
@@ -85,18 +78,21 @@ function(llvm_ExternalProject_Add name source_dir)
COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR}
COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR}
COMMENT "Clobbering ${name} build and stamp directories"
- ${cmake_3_2_USES_TERMINAL}
+ USES_TERMINAL
)
- # Find all variables that start with COMPILER_RT and populate a variable with
- # them.
+ # Find all variables that start with a prefix and propagate them through
get_cmake_property(variableNames VARIABLES)
- foreach(variableName ${variableNames})
- if(variableName MATCHES "^${nameCanon}")
- string(REPLACE ";" "\;" value "${${variableName}}")
- list(APPEND PASSTHROUGH_VARIABLES
- -D${variableName}=${value})
- endif()
+
+ 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)
@@ -120,7 +116,7 @@ function(llvm_ExternalProject_Add name source_dir)
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp)
if(ARG_EXCLUDE_FROM_ALL)
- set(exclude ${cmake_3_1_EXCLUDE_FROM_ALL})
+ set(exclude EXCLUDE_FROM_ALL 1)
endif()
ExternalProject_Add(${name}
@@ -134,33 +130,35 @@ function(llvm_ExternalProject_Add name source_dir)
CMAKE_ARGS ${${nameCanon}_CMAKE_ARGS}
${compiler_args}
-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
+ -DLLVM_BINARY_DIR=${PROJECT_BINARY_DIR}
+ -DLLVM_CONFIG_PATH=$<TARGET_FILE:llvm-config>
+ -DLLVM_ENABLE_WERROR=${LLVM_ENABLE_WERROR}
+ -DPACKAGE_VERSION=${PACKAGE_VERSION}
+ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+ -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
${ARG_CMAKE_ARGS}
${PASSTHROUGH_VARIABLES}
INSTALL_COMMAND ""
STEP_TARGETS configure build
- ${cmake_3_4_USES_TERMINAL_OPTIONS}
+ BUILD_ALWAYS 1
+ USES_TERMINAL_CONFIGURE 1
+ USES_TERMINAL_BUILD 1
+ USES_TERMINAL_INSTALL 1
)
if(ARG_USE_TOOLCHAIN)
- ExternalProject_Add_Step(${name} force-rebuild
- COMMENT "Forcing rebuild becaues tools have changed"
- DEPENDERS configure
- DEPENDS ${TOOLCHAIN_BINS}
- ${cmake_3_4_USES_TERMINAL} )
- endif()
-
- if(ARG_USE_TOOLCHAIN)
set(force_deps DEPENDS ${TOOLCHAIN_BINS})
endif()
- llvm_ExternalProject_BuildCmd(run_clean clean)
+ 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}
- ${cmake_3_4_USES_TERMINAL}
+ EXCLUDE_FROM_MAIN 1
+ USES_TERMINAL 1
)
ExternalProject_Add_StepTargets(${name} clean)
@@ -179,17 +177,17 @@ function(llvm_ExternalProject_Add name source_dir)
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=${name}
-P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
- ${cmake_3_2_USES_TERMINAL})
+ USES_TERMINAL)
endif()
# Add top-level targets
foreach(target ${ARG_EXTRA_TARGETS})
- llvm_ExternalProject_BuildCmd(build_runtime_cmd ${target})
+ llvm_ExternalProject_BuildCmd(build_runtime_cmd ${target} ${BINARY_DIR})
add_custom_target(${target}
COMMAND ${build_runtime_cmd}
DEPENDS ${name}-configure
WORKING_DIRECTORY ${BINARY_DIR}
VERBATIM
- ${cmake_3_2_USES_TERMINAL})
+ USES_TERMINAL)
endforeach()
endfunction()
diff --git a/cmake/modules/Makefile b/cmake/modules/Makefile
deleted file mode 100644
index abfda93b210fe..0000000000000
--- a/cmake/modules/Makefile
+++ /dev/null
@@ -1,151 +0,0 @@
-##===- cmake/modules/Makefile ------------------------------*- Makefile -*-===##
-#
-# The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-LEVEL = ../..
-
-include $(LEVEL)/Makefile.common
-
-PROJ_cmake := $(DESTDIR)$(PROJ_prefix)/share/llvm/cmake
-
-ifeq ($(DISABLE_ASSERTIONS),1)
- LLVM_ENABLE_ASSERTIONS := 0
-else
- LLVM_ENABLE_ASSERTIONS := 1
-endif
-
-ifeq ($(ENABLE_ABI_BREAKING_CHECKS),1)
- LLVM_ABI_BREAKING_CHECKS := FORCE_ON
-else
- LLVM_ABI_BREAKING_CHECKS := FORCE_OFF
-endif
-
-ifeq ($(REQUIRES_EH),1)
- LLVM_ENABLE_EH := 1
-else
- LLVM_ENABLE_EH := 0
-endif
-
-ifeq ($(REQUIRES_RTTI),1)
- LLVM_ENABLE_RTTI := 1
-else
- LLVM_ENABLE_RTTI := 0
-endif
-
-ifndef LLVM_LIBS_TO_EXPORT
-$(error LLVM_LIBS_TO_EXPORT cannot be empty)
-endif
-
-OBJMODS := LLVMConfig.cmake LLVMConfigVersion.cmake LLVMExports.cmake
-
-LLVM_CONFIG_CODE := \
-\# Compute the CMake directory from the LLVMConfig.cmake file location.\n\
-get_filename_component(_LLVM_CMAKE_DIR "$${CMAKE_CURRENT_LIST_FILE}" PATH)\n\
-\# Compute the installation prefix from the LLVMConfig.cmake file location.\n\
-get_filename_component(LLVM_INSTALL_PREFIX "$${CMAKE_CURRENT_LIST_FILE}" PATH)\n
-
-# Compute number of levels (typically 3 - ``share/llvm/cmake/``) to PROJ_prefix
-# from PROJ_cmake, then emit the appropriate number of calls to
-# get_filename_components(). Note this assumes there are no spaces in the
-# cmake_path_suffix variable.
-cmake_path_suffix := $(subst $(PROJ_prefix),,$(subst $(DESTDIR),,$(PROJ_cmake)))
-cmake_path_dirs := $(subst /, ,$(cmake_path_suffix))
-LLVM_CONFIG_CODE += $(foreach __not_used,$(cmake_path_dirs),get_filename_component(LLVM_INSTALL_PREFIX "$${LLVM_INSTALL_PREFIX}" PATH)\n)
-
-LLVM_CONFIG_CODE += set(_LLVM_LIBRARY_DIR "$${LLVM_INSTALL_PREFIX}\/lib")
-
-$(PROJ_OBJ_DIR)/LLVMConfig.cmake: LLVMConfig.cmake.in Makefile $(LLVMBuildCMakeFrag)
- $(Echo) 'Generating LLVM CMake package config file'
- $(Verb) ( \
- cat $< | sed \
- -e 's/@LLVM_CONFIG_CODE@/$(LLVM_CONFIG_CODE)/' \
- -e 's/@LLVM_VERSION_MAJOR@/'"$(LLVM_VERSION_MAJOR)"'/' \
- -e 's/@LLVM_VERSION_MINOR@/'"$(LLVM_VERSION_MINOR)"'/' \
- -e 's/@LLVM_VERSION_PATCH@/'"$(LLVM_VERSION_PATCH)"'/' \
- -e 's/@PACKAGE_VERSION@/'"$(LLVMVersion)"'/' \
- -e 's/@LLVM_COMMON_DEPENDS@//' \
- -e 's/@LLVM_AVAILABLE_LIBS@/'"$(LLVM_LIBS_TO_EXPORT)"'/' \
- -e 's/@LLVM_ALL_TARGETS@/'"$(ALL_TARGETS)"'/' \
- -e 's/@LLVM_TARGETS_TO_BUILD@/'"$(TARGETS_TO_BUILD)"'/' \
- -e 's/@LLVM_TARGETS_WITH_JIT@/'"$(TARGETS_WITH_JIT)"'/' \
- -e 's/@TARGET_TRIPLE@/'"$(TARGET_TRIPLE)"'/' \
- -e 's/@LLVM_ABI_BREAKING_CHECKS@/'"$(LLVM_ABI_BREAKING_CHECKS)"'/' \
- -e 's/@LLVM_ENABLE_ASSERTIONS@/'"$(LLVM_ENABLE_ASSERTIONS)"'/' \
- -e 's/@LLVM_ENABLE_EH@/'"$(LLVM_ENABLE_EH)"'/' \
- -e 's/@LLVM_ENABLE_RTTI@/'"$(LLVM_ENABLE_RTTI)"'/' \
- -e 's/@LLVM_ENABLE_TERMINFO@/'"$(ENABLE_TERMINFO)"'/' \
- -e 's/@LLVM_ENABLE_THREADS@/'"$(ENABLE_THREADS)"'/' \
- -e 's/@LLVM_ENABLE_ZLIB@/'"$(ENABLE_ZLIB)"'/' \
- -e 's/@LLVM_NATIVE_ARCH@/'"$(LLVM_NATIVE_ARCH)"'/' \
- -e 's/@LLVM_ENABLE_PIC@/'"$(ENABLE_PIC)"'/' \
- -e 's/@LLVM_ON_UNIX@/'"$(LLVM_ON_UNIX)"'/' \
- -e 's/@LLVM_ON_WIN32@/'"$(LLVM_ON_WIN32)"'/' \
- -e 's/@LLVM_LIBDIR_SUFFIX@//' \
- -e 's#@LLVM_CONFIG_INCLUDE_DIRS@#$${LLVM_INSTALL_PREFIX}/include#' \
- -e 's#@LLVM_CONFIG_LIBRARY_DIRS@#$${_LLVM_LIBRARY_DIR}#' \
- -e 's#@LLVM_CONFIG_CMAKE_DIR@#$${_LLVM_CMAKE_DIR}#' \
- -e 's#@LLVM_CONFIG_TOOLS_BINARY_DIR@#$${LLVM_INSTALL_PREFIX}/bin#' \
- -e 's/@LLVM_CONFIG_EXPORTS_FILE@/$${LLVM_CMAKE_DIR}\/LLVMExports.cmake/' \
- -e 's/@all_llvm_lib_deps@//' \
- && \
- ( grep '^set_property.*LLVMBUILD_LIB_DEPS_' "$(LLVMBuildCMakeFrag)" | \
- grep -v LLVMBUILD_LIB_DEPS_gtest ) && \
- echo 'unset(_LLVM_CMAKE_DIR)' && \
- echo 'unset(_LLVM_LIBRARY_DIR)' \
- ) > $@
-
-$(PROJ_OBJ_DIR)/LLVMConfigVersion.cmake: LLVMConfigVersion.cmake.in Makefile
- $(Echo) 'Generating LLVM CMake package version file'
- $(Verb) cat $< | sed \
- -e 's/@PACKAGE_VERSION@/'"$(LLVMVersion)"'/' \
- -e 's/@LLVM_VERSION_MAJOR@/'"$(LLVM_VERSION_MAJOR)"'/' \
- -e 's/@LLVM_VERSION_MINOR@/'"$(LLVM_VERSION_MINOR)"'/' \
- -e 's/@LLVM_VERSION_PATCH@/'"$(LLVM_VERSION_PATCH)"'/' \
- > $@
-
-$(PROJ_OBJ_DIR)/LLVMExports.cmake: $(LLVMBuildCMakeExportsFrag) Makefile
- $(Echo) 'Generating LLVM CMake target exports file'
- $(Verb) ( \
- echo '# LLVM CMake target exports. Do not include directly.' && \
- for lib in $(LLVM_LIBS_TO_EXPORT); do \
- echo 'add_library('"$$lib"' STATIC IMPORTED)' && \
- echo 'set_property(TARGET '"$$lib"' PROPERTY IMPORTED_LOCATION "$${_LLVM_LIBRARY_DIR}/'lib$$lib.a'")' ; \
- done && \
- cat "$(LLVMBuildCMakeExportsFrag)" && \
- echo 'set_property(TARGET LLVMSupport APPEND PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES '"$(subst -l,,$(LIBS))"')' \
- ) > $@
-
-all-local:: $(addprefix $(PROJ_OBJ_DIR)/, $(OBJMODS))
-
-SKIPSRCMODS := \
- CheckAtomic.cmake \
- GetHostTriple.cmake \
- LLVMBuildExports.cmake \
- LLVMConfig.cmake \
- LLVMConfigVersion.cmake \
- LLVMExports.cmake \
- VersionFromVCS.cmake
-
-SRCMODS := $(notdir $(wildcard $(PROJ_SRC_DIR)/*.cmake))
-SRCMODS := $(filter-out $(SKIPSRCMODS),$(SRCMODS))
-INSTSRCMODS := $(addprefix $(PROJ_cmake)/, $(SRCMODS))
-INSTOBJMODS := $(addprefix $(PROJ_cmake)/, $(OBJMODS))
-
-$(PROJ_cmake):
- $(Echo) Making install directory: $@
- $(Verb) $(MKDIR) $@
-
-$(INSTSRCMODS): $(PROJ_cmake)/%.cmake: $(PROJ_SRC_DIR)/%.cmake | $(PROJ_cmake)
- $(Echo) Installing cmake modules: $(notdir $<)
- $(Verb) $(DataInstall) $< $(PROJ_cmake)
-
-$(INSTOBJMODS): $(PROJ_cmake)/%.cmake: $(PROJ_OBJ_DIR)/%.cmake | $(PROJ_cmake)
- $(Echo) Installing cmake modules: $(notdir $<)
- $(Verb) $(DataInstall) $< $(PROJ_cmake)
-
-install-local:: $(INSTSRCMODS) $(INSTOBJMODS)
diff --git a/cmake/modules/TableGen.cmake b/cmake/modules/TableGen.cmake
index fca7d1bda4b36..c88ee3fc196b5 100644
--- a/cmake/modules/TableGen.cmake
+++ b/cmake/modules/TableGen.cmake
@@ -141,7 +141,7 @@ macro(add_tablegen target project)
if (${project} STREQUAL LLVM AND NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
install(TARGETS ${target}
EXPORT LLVMExports
- RUNTIME DESTINATION bin)
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR})
endif()
set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${target})
endmacro()
diff --git a/cmake/modules/VersionFromVCS.cmake b/cmake/modules/VersionFromVCS.cmake
index 26314d4126d2f..8d56b66fa4781 100644
--- a/cmake/modules/VersionFromVCS.cmake
+++ b/cmake/modules/VersionFromVCS.cmake
@@ -1,45 +1,57 @@
# 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 CMAKE_CURRENT_SOURCE_DIR.
+# 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 "${CMAKE_CURRENT_SOURCE_DIR}/.svn" )
+ if( EXISTS "${SOURCE_DIR}/.svn" )
set(result "${result}svn")
# FindSubversion does not work with symlinks. See PR 8437
- if( NOT IS_SYMLINK "${CMAKE_CURRENT_SOURCE_DIR}" )
+ if( NOT IS_SYMLINK "${SOURCE_DIR}" )
find_package(Subversion)
endif()
if( Subversion_FOUND )
- subversion_wc_info( ${CMAKE_CURRENT_SOURCE_DIR} Project )
+ 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()
- elseif( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git )
+ elseif( EXISTS ${SOURCE_DIR}/.git )
set(result "${result}git")
# Try to get a ref-id
- if( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git/svn )
+ if( EXISTS ${SOURCE_DIR}/.git/svn )
find_program(git_executable NAMES git git.exe git.cmd)
if( git_executable )
set(is_git_svn_rev_exact false)
- execute_process(COMMAND ${git_executable} svn log --limit=1 --oneline
- WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ execute_process(COMMAND
+ ${git_executable} svn info
+ WORKING_DIRECTORY ${SOURCE_DIR}
TIMEOUT 5
RESULT_VARIABLE git_result
OUTPUT_VARIABLE git_output)
if( git_result EQUAL 0 )
- string(REGEX MATCH r[0-9]+ git_svn_rev ${git_output})
- string(LENGTH "${git_svn_rev}" rev_length)
- math(EXPR rev_length "${rev_length}-1")
- string(SUBSTRING "${git_svn_rev}" 1 ${rev_length} git_svn_rev_number)
+ string(REGEX MATCH "URL: ([^ \n]*)" svn_url ${git_output})
+ if(svn_url)
+ set(LLVM_REPOSITORY ${CMAKE_MATCH_1} PARENT_SCOPE)
+ endif()
+
+ string(REGEX REPLACE "^(.*\n)?Revision: ([^\n]+).*"
+ "\\2" git_svn_rev_number "${git_output}")
set(SVN_REVISION ${git_svn_rev_number} PARENT_SCOPE)
set(git_svn_rev "-svn-${git_svn_rev}")
# Determine if the HEAD points directly at a subversion revision.
execute_process(COMMAND ${git_executable} svn find-rev HEAD
- WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ WORKING_DIRECTORY ${SOURCE_DIR}
TIMEOUT 5
RESULT_VARIABLE git_result
OUTPUT_VARIABLE git_output)
@@ -54,10 +66,11 @@ function(add_version_info_from_vcs VERS)
endif()
execute_process(COMMAND
${git_executable} rev-parse --short HEAD
- WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ WORKING_DIRECTORY ${SOURCE_DIR}
TIMEOUT 5
RESULT_VARIABLE git_result
OUTPUT_VARIABLE git_output)
+
if( git_result EQUAL 0 AND NOT is_git_svn_rev_exact )
string(STRIP "${git_output}" git_ref_id)
set(GIT_COMMIT ${git_ref_id} PARENT_SCOPE)
@@ -65,6 +78,7 @@ function(add_version_info_from_vcs VERS)
else()
set(result "${result}${git_svn_rev}")
endif()
+
endif()
endif()
endif()
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-17 01:19:09 +0000