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)
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_FLAGS "/GR-")
endif ()
+ elseif(MSVC)
+ list(APPEND LLVM_COMPILE_FLAGS "/GR")
endif()
# Assume that;
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 "{" > ${native_export_file}
+ COMMAND echo "LLVM_${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR} {" > ${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}
DEPENDS ${export_file}
VERBATIM
COMMENT "Creating export file for ${target_name}")
- if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
+ 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()
endfunction(add_llvm_symbol_exports)
if(NOT WIN32 AND NOT APPLE)
+ # Detect what linker we have here
execute_process(
COMMAND ${CMAKE_C_COMPILER} -Wl,--version
OUTPUT_VARIABLE stdout
- ERROR_QUIET
+ 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")
+ 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()
# Pass -O3 to the linker. This enabled different optimizations on different
# linkers.
- if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin|SunOS" OR WIN32))
+ if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin|SunOS|AIX" OR WIN32))
set_property(TARGET ${target_name} APPEND_STRING PROPERTY
LINK_FLAGS " -Wl,-O3")
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})
# 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})".
# 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;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME"
- "OUTPUT_NAME"
+ "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_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()
endif()
# Generate objlib
- if(ARG_SHARED AND ARG_STATIC)
+ 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
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)
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_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX})
+ endif()
endif()
if(ARG_MODULE OR ARG_SHARED)
endif()
endif()
- # Add the explicit dependency information for this library.
- #
- # 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})
+ 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_MINOR}${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 (LLVM_LINK_LLVM_DYLIB AND NOT ARG_STATIC AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB)
- set(llvm_libs LLVM)
+ 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()
- llvm_map_components_to_libnames(llvm_libs
- ${ARG_LINK_COMPONENTS}
- ${LLVM_LINK_COMPONENTS}
- )
+ # 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(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})
add_dependencies(${objlib} ${LLVM_COMMON_DEPENDS})
endforeach()
endif()
+
+ if(ARG_SHARED OR ARG_MODULE)
+ llvm_externalize_debuginfo(${name})
+ endif()
endfunction()
macro(add_llvm_library name)
cmake_parse_arguments(ARG
- "SHARED;SONAME"
+ "SHARED;BUILDTREE_ONLY"
""
""
${ARGN})
- if( BUILD_SHARED_LIBS )
- llvm_add_library(${name} SHARED ${ARGN})
+ if( BUILD_SHARED_LIBS OR ARG_SHARED )
+ llvm_add_library(${name} SHARED ${ARG_UNPARSED_ARGUMENTS})
else()
- llvm_add_library(${name} ${ARGN})
+ llvm_add_library(${name} ${ARG_UNPARSED_ARGUMENTS})
endif()
- # The gtest libraries should not be installed or exported as a target
- if ("${name}" STREQUAL gtest OR "${name}" STREQUAL gtest_main)
- set(_is_gtest TRUE)
- else()
- set(_is_gtest FALSE)
+
+ # 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(NOT _is_gtest)
- if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO")
+ 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)
+ if(WIN32 OR CYGWIN OR MINGW)
set(install_type RUNTIME)
+ set(install_dir bin)
else()
set(install_type LIBRARY)
endif()
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 LLVMExports
- ${install_type} DESTINATION lib${LLVM_LIBDIR_SUFFIX}
- COMPONENT ${name})
+ ${export_to_llvmexports}
+ ${install_type} DESTINATION ${install_dir}
+ COMPONENT ${name})
if (NOT CMAKE_CONFIGURATION_TYPES)
add_custom_target(install-${name}
-DCMAKE_INSTALL_COMPONENT=${name}
-P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
endif()
- if(ARG_SHARED AND UNIX)
- if(NOT APPLE AND ARG_SONAME)
- set(library_name ${name}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}${LLVM_VERSION_SUFFIX})
- set(api_name ${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(${name} ${library_name} SHARED
- COMPONENT ${name}
- ALWAYS_GENERATE)
- endif()
- endif()
endif()
set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
endif()
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 LLVMExports
- LIBRARY DESTINATION ${dlldir}
- ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
+ ${export_to_llvmexports}
+ LIBRARY DESTINATION ${dlldir}
+ ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
endif()
set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
endif()
macro(add_llvm_executable name)
- cmake_parse_arguments(ARG "DISABLE_LLVM_LINK_LLVM_DYLIB" "" "" ${ARGN})
+ 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.
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()
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} ${LLVM_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
+ LINK_FLAGS " -rdynamic")
+ endif()
endif()
endfunction()
endif()
add_llvm_executable(${name} ${ARGN})
- list(FIND LLVM_TOOLCHAIN_TOOLS ${name} LLVM_IS_${name}_TOOLCHAIN_TOOL)
- if (LLVM_IS_${name}_TOOLCHAIN_TOOL GREATER -1 OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
+ 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 LLVMExports
- RUNTIME DESTINATION bin
+ ${export_to_llvmexports}
+ RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
COMPONENT ${name})
if (NOT CMAKE_CONFIGURATION_TYPES)
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
+ RUNTIME DESTINATION ${LLVM_UTILS_INSTALL_DIR}
COMPONENT ${name})
if (NOT CMAKE_CONFIGURATION_TYPES)
add_custom_target(install-${name}
endif()
endmacro(add_llvm_utility name)
+macro(add_llvm_fuzzer name)
+ cmake_parse_arguments(ARG "" "DUMMY_MAIN" "" ${ARGN})
+ if( 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
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 "")
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()
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.
endif()
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_NO_VARIADIC_MACROS_FLAG)
+ 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)
- add_llvm_executable(${test_name} ${ARGN})
+ 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})
- target_link_libraries(${test_name}
- gtest
- gtest_main
- LLVMSupport # gtest needs it for raw_ostream.
- )
+ # 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 ${LLVM_PTHREAD_LIB})
add_dependencies(${test_suite} ${test_name})
get_target_property(test_suite_folder ${test_suite} FOLDER)
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}" "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}
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)
+
# 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 input output)
+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)
# 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})
+ 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}")
+ 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
set(HOST_CXX "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
set(HOST_LDFLAGS "${CMAKE_EXE_LINKER_FLAGS}")
- configure_file(${input} ${output} @ONLY)
+ 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
if (NOT CMAKE_CFG_INTDIR STREQUAL ".")
list(APPEND LIT_ARGS --param build_mode=${CMAKE_CFG_INTDIR})
endif ()
- if (LLVM_MAIN_SRC_DIR)
- set (LIT_COMMAND ${PYTHON_EXECUTABLE} ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)
- else()
- find_program(LIT_COMMAND llvm-lit)
- 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})
add_custom_target(${target}
COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS}
COMMENT "${comment}"
- ${cmake_3_2_USES_TERMINAL}
+ USES_TERMINAL
)
else()
add_custom_target(${target}
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)
+ 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 ${dir}"
- ${dir}
+ add_lit_target("check-${name_var}" "Running lit suite ${lit_suite}"
+ ${lit_suite}
PARAMS ${ARG_PARAMS}
DEPENDS ${ARG_DEPENDS}
ARGS ${ARG_ARGS}
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)
+ set(output_dir lib${LLVM_LIBDIR_SUFFIX})
if(WIN32 AND "${type}" STREQUAL "SHARED")
set(output_dir bin)
endif()
endfunction()
function(llvm_install_symlink name dest)
- cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
+ cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
foreach(path ${CMAKE_MODULE_PATH})
if(EXISTS ${path}/LLVMInstallSymlink.cmake)
set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake)
endif()
endforeach()
- if(ARG_ALWAYS_GENERATE)
- set(component ${dest})
+ if(ARG_COMPONENT)
+ set(component ${ARG_COMPONENT})
else()
- set(component ${name})
+ 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} bin)"
+ CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
COMPONENT ${component})
if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE)
endif()
endfunction()
-function(add_llvm_tool_symlink name dest)
- cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN})
+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(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(UNIX)
set(LLVM_LINK_OR_COPY create_symlink)
- set(dest_binary "${dest}${CMAKE_EXECUTABLE_SUFFIX}")
else()
set(LLVM_LINK_OR_COPY copy)
- set(dest_binary "${LLVM_RUNTIME_OUTPUT_INTDIR}/${dest}${CMAKE_EXECUTABLE_SUFFIX}")
endif()
- set(output_path "${LLVM_RUNTIME_OUTPUT_INTDIR}/${name}${CMAKE_EXECUTABLE_SUFFIX}")
+ 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 ${dest} POST_BUILD
+ 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 ${dest})
- add_custom_target(${name} ALL DEPENDS ${output_path})
- set_target_properties(${name} PROPERTIES FOLDER Tools)
-
- # Make sure the parent tool is a toolchain tool, otherwise exclude this tool
- list(FIND LLVM_TOOLCHAIN_TOOLS ${dest} LLVM_IS_${dest}_TOOLCHAIN_TOOL)
- if (NOT LLVM_IS_${dest}_TOOLCHAIN_TOOL GREATER -1)
- set(LLVM_IS_${name}_TOOLCHAIN_TOOL ${LLVM_IS_${dest}_TOOLCHAIN_TOOL})
+ 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()
- list(FIND LLVM_TOOLCHAIN_TOOLS ${name} LLVM_IS_${name}_TOOLCHAIN_TOOL)
+ set(strip_command COMMAND strip -gx $<TARGET_FILE:${name}>)
endif()
+ endif()
- # LLVM_IS_${name}_TOOLCHAIN_TOOL will only be greater than -1 if both this
- # tool and its parent tool are in LLVM_TOOLCHAIN_TOOLS
- if (LLVM_IS_${name}_TOOLCHAIN_TOOL GREATER -1 OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
- if( LLVM_BUILD_TOOLS )
- llvm_install_symlink(${name} ${dest})
- 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 ")
+ elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND NOT LLVM_LINKER_IS_GOLD)
+ # $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()
OSDN Git Service
