diff options
Diffstat (limited to 'cmake/modules')
| -rwxr-xr-x | cmake/modules/AddLLVM.cmake | 428 | ||||
| -rw-r--r-- | cmake/modules/AddLLVMDefinitions.cmake | 6 | ||||
| -rw-r--r-- | cmake/modules/CrossCompile.cmake | 2 | ||||
| -rw-r--r-- | cmake/modules/DetermineGCCCompatible.cmake | 11 | ||||
| -rw-r--r-- | cmake/modules/HandleLLVMOptions.cmake | 125 | ||||
| -rw-r--r-- | cmake/modules/HandleLLVMStdlib.cmake | 10 | ||||
| -rwxr-xr-x | cmake/modules/LLVM-Config.cmake | 18 | ||||
| -rw-r--r-- | cmake/modules/LLVMConfig.cmake.in | 5 | ||||
| -rw-r--r-- | cmake/modules/LLVMExternalProjectUtils.cmake | 195 | ||||
| -rw-r--r-- | cmake/modules/LLVMInstallSymlink.cmake | 21 | ||||
| -rw-r--r-- | cmake/modules/Makefile | 19 | ||||
| -rw-r--r-- | cmake/modules/TableGen.cmake | 24 |
12 files changed, 717 insertions, 147 deletions
diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake index 45f6746948d2..bed81b28426e 100755 --- a/cmake/modules/AddLLVM.cmake +++ b/cmake/modules/AddLLVM.cmake @@ -1,5 +1,6 @@ include(LLVMProcessSources) include(LLVM-Config) +include(DetermineGCCCompatible) function(llvm_update_compile_flags name) get_property(sources TARGET ${name} PROPERTY SOURCES) @@ -21,15 +22,13 @@ function(llvm_update_compile_flags name) list(APPEND LLVM_COMPILE_DEFINITIONS _HAS_EXCEPTIONS=0) list(APPEND LLVM_COMPILE_FLAGS "/EHs-c-") endif() - if (CLANG_CL) - # FIXME: Remove this once clang-cl supports SEH - list(APPEND LLVM_COMPILE_DEFINITIONS "GTEST_HAS_SEH=0") - endif() endif() # LLVM_REQUIRES_RTTI is an internal flag that individual # targets can use to force RTTI + set(LLVM_CONFIG_HAS_RTTI YES CACHE INTERNAL "") if(NOT (LLVM_REQUIRES_RTTI OR LLVM_ENABLE_RTTI)) + set(LLVM_CONFIG_HAS_RTTI NO CACHE INTERNAL "") list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_RTTI=0) if (LLVM_COMPILER_IS_GCC_COMPATIBLE) list(APPEND LLVM_COMPILE_FLAGS "-fno-rtti") @@ -41,7 +40,7 @@ function(llvm_update_compile_flags name) # Assume that; # - LLVM_COMPILE_FLAGS is list. # - PROPERTY COMPILE_FLAGS is string. - string(REPLACE ";" " " target_compile_flags "${LLVM_COMPILE_FLAGS}") + string(REPLACE ";" " " target_compile_flags " ${LLVM_COMPILE_FLAGS}") if(update_src_props) foreach(fn ${sources}) @@ -193,34 +192,43 @@ 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 bindir libdir) - # Do nothing if *_OUTPUT_INTDIR is empty. - if("${bindir}" STREQUAL "") - return() - endif() +function(set_output_directory target) + cmake_parse_arguments(ARG "" "BINARY_DIR;LIBRARY_DIR" "" ${ARGN}) - # moddir -- corresponding to LIBRARY_OUTPUT_DIRECTORY. + # module_dir -- corresponding to LIBRARY_OUTPUT_DIRECTORY. # It affects output of add_library(MODULE). if(WIN32 OR CYGWIN) # DLL platform - set(moddir ${bindir}) + set(module_dir ${ARG_BINARY_DIR}) else() - set(moddir ${libdir}) + set(module_dir ${ARG_LIBRARY_DIR}) endif() if(NOT "${CMAKE_CFG_INTDIR}" STREQUAL ".") foreach(build_mode ${CMAKE_CONFIGURATION_TYPES}) string(TOUPPER "${build_mode}" CONFIG_SUFFIX) - string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} bi ${bindir}) - string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} li ${libdir}) - string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} mi ${moddir}) - set_target_properties(${target} PROPERTIES "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${bi}) - set_target_properties(${target} PROPERTIES "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${li}) - set_target_properties(${target} PROPERTIES "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${mi}) + if(ARG_BINARY_DIR) + string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} bi ${ARG_BINARY_DIR}) + set_target_properties(${target} PROPERTIES "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${bi}) + endif() + if(ARG_LIBRARY_DIR) + string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} li ${ARG_LIBRARY_DIR}) + set_target_properties(${target} PROPERTIES "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${li}) + endif() + if(module_dir) + string(REPLACE ${CMAKE_CFG_INTDIR} ${build_mode} mi ${module_dir}) + set_target_properties(${target} PROPERTIES "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${mi}) + endif() endforeach() else() - set_target_properties(${target} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${bindir}) - set_target_properties(${target} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${libdir}) - set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${moddir}) + if(ARG_BINARY_DIR) + set_target_properties(${target} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${ARG_BINARY_DIR}) + endif() + if(ARG_LIBRARY_DIR) + set_target_properties(${target} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${ARG_LIBRARY_DIR}) + endif() + if(module_dir) + set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${module_dir}) + endif() endif() endfunction() @@ -303,6 +311,9 @@ endfunction(set_windows_version_resource_properties) # MODULE # Target ${name} might not be created on unsupported platforms. # Check with "if(TARGET ${name})". +# DISABLE_LLVM_LINK_LLVM_DYLIB +# Do not link this library to libLLVM, even if +# LLVM_LINK_LLVM_DYLIB is enabled. # OUTPUT_NAME name # Corresponds to OUTPUT_NAME in target properties. # DEPENDS targets... @@ -313,10 +324,12 @@ endfunction(set_windows_version_resource_properties) # Same semantics as target_link_libraries(). # ADDITIONAL_HEADERS # May specify header files for IDE generators. +# SONAME +# Should set SONAME link flags and create symlinks # ) function(llvm_add_library name) cmake_parse_arguments(ARG - "MODULE;SHARED;STATIC" + "MODULE;SHARED;STATIC;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME" "OUTPUT_NAME" "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS" ${ARGN}) @@ -395,8 +408,11 @@ function(llvm_add_library name) set(windows_resource_file ${windows_resource_file} PARENT_SCOPE) endif() - set_output_directory(${name} ${LLVM_RUNTIME_OUTPUT_INTDIR} ${LLVM_LIBRARY_OUTPUT_INTDIR}) - llvm_update_compile_flags(${name}) + set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) + # $<TARGET_OBJECTS> doesn't require compile flags. + if(NOT obj_name) + llvm_update_compile_flags(${name}) + endif() add_link_opts( ${name} ) if(ARG_OUTPUT_NAME) set_target_properties(${name} @@ -418,11 +434,6 @@ function(llvm_add_library name) PREFIX "" ) endif() - - set_target_properties(${name} - PROPERTIES - SOVERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR} - VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}${LLVM_VERSION_SUFFIX}) endif() if(ARG_MODULE OR ARG_SHARED) @@ -437,6 +448,24 @@ function(llvm_add_library name) endif() endif() + if(ARG_SHARED AND UNIX) + if(NOT APPLE AND ARG_SONAME) + get_target_property(output_name ${name} OUTPUT_NAME) + if(${output_name} STREQUAL "output_name-NOTFOUND") + set(output_name ${name}) + endif() + set(library_name ${output_name}-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_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() + # Add the explicit dependency information for this library. # # It would be nice to verify that we have the dependencies for this library @@ -444,10 +473,14 @@ function(llvm_add_library name) # property has been set to an empty value. get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name}) - llvm_map_components_to_libnames(llvm_libs - ${ARG_LINK_COMPONENTS} - ${LLVM_LINK_COMPONENTS} - ) + if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_STATIC 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() if(CMAKE_VERSION VERSION_LESS 2.8.12) # Link libs w/o keywords, assuming PUBLIC. @@ -479,6 +512,10 @@ function(llvm_add_library name) 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) @@ -504,9 +541,11 @@ macro(add_llvm_library name) set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON) elseif(NOT _is_gtest) if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO") + 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() @@ -516,7 +555,7 @@ macro(add_llvm_library name) install(TARGETS ${name} EXPORT LLVMExports - ${install_type} DESTINATION lib${LLVM_LIBDIR_SUFFIX} + ${install_type} DESTINATION ${install_dir} COMPONENT ${name}) if (NOT CMAKE_CONFIGURATION_TYPES) @@ -562,9 +601,30 @@ endmacro(add_llvm_loadable_module name) macro(add_llvm_executable name) - llvm_process_sources( ALL_FILES ${ARGN} ) + cmake_parse_arguments(ARG "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO" "" "" ${ARGN}) + llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} ) + + # Generate objlib + if(LLVM_ENABLE_OBJLIB) + # Generate an obj library for both targets. + set(obj_name "obj.${name}") + add_library(${obj_name} OBJECT EXCLUDE_FROM_ALL + ${ALL_FILES} + ) + llvm_update_compile_flags(${obj_name}) + set(ALL_FILES "$<TARGET_OBJECTS:${obj_name}>") + + set_target_properties(${obj_name} PROPERTIES FOLDER "Object Libraries") + endif() + add_windows_version_resource_file(ALL_FILES ${ALL_FILES}) + if(XCODE) + # Note: the dummy.cpp source file provides no definitions. However, + # it forces Xcode to properly link the static library. + list(APPEND ALL_FILES "${LLVM_MAIN_SRC_DIR}/cmake/dummy.cpp") + endif() + if( EXCLUDE_FROM_ALL ) add_executable(${name} EXCLUDE_FROM_ALL ${ALL_FILES}) else() @@ -575,7 +635,10 @@ macro(add_llvm_executable name) set_windows_version_resource_properties(${name} ${windows_resource_file}) endif() - llvm_update_compile_flags(${name}) + # $<TARGET_OBJECTS> doesn't require compile flags. + if(NOT LLVM_ENABLE_OBJLIB) + llvm_update_compile_flags(${name}) + endif() add_link_opts( ${name} ) # Do not add -Dname_EXPORTS to the command-line when building files in this @@ -588,25 +651,40 @@ macro(add_llvm_executable name) add_llvm_symbol_exports( ${name} ${LLVM_EXPORTED_SYMBOL_FILE} ) endif(LLVM_EXPORTED_SYMBOL_FILE) + if (LLVM_LINK_LLVM_DYLIB AND NOT ARG_DISABLE_LLVM_LINK_LLVM_DYLIB) + set(USE_SHARED USE_SHARED) + endif() + set(EXCLUDE_FROM_ALL OFF) - set_output_directory(${name} ${LLVM_RUNTIME_OUTPUT_INTDIR} ${LLVM_LIBRARY_OUTPUT_INTDIR}) - llvm_config( ${name} ${LLVM_LINK_COMPONENTS} ) + set_output_directory(${name} BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR} LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) + llvm_config( ${name} ${USE_SHARED} ${LLVM_LINK_COMPONENTS} ) if( LLVM_COMMON_DEPENDS ) add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} ) endif( LLVM_COMMON_DEPENDS ) + + if(NOT ARG_IGNORE_EXTERNALIZE_DEBUGINFO) + llvm_externalize_debuginfo(${name}) + endif() endmacro(add_llvm_executable name) function(export_executable_symbols target) if (NOT MSVC) # MSVC's linker doesn't support exporting all symbols. set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1) + if (APPLE) + set_property(TARGET ${target} APPEND_STRING PROPERTY + LINK_FLAGS " -rdynamic") + endif() endif() endfunction() - -set (LLVM_TOOLCHAIN_TOOLS - llvm-ar - llvm-objdump - ) +if(NOT LLVM_TOOLCHAIN_TOOLS) + set (LLVM_TOOLCHAIN_TOOLS + llvm-ar + llvm-ranlib + llvm-lib + llvm-objdump + ) +endif() macro(add_llvm_tool name) if( NOT LLVM_BUILD_TOOLS ) @@ -651,7 +729,7 @@ endmacro(add_llvm_example name) macro(add_llvm_utility name) - add_llvm_executable(${name} ${ARGN}) + add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN}) set_target_properties(${name} PROPERTIES FOLDER "Utils") if( LLVM_INSTALL_UTILS ) install (TARGETS ${name} @@ -676,56 +754,104 @@ macro(add_llvm_target target_name) set( CURRENT_LLVM_TARGET LLVM${target_name} ) endmacro(add_llvm_target) -# Add external project that may want to be built as part of llvm such as Clang, -# lld, and Polly. This adds two options. One for the source directory of the -# project, which defaults to ${CMAKE_CURRENT_SOURCE_DIR}/${name}. Another to -# enable or disable building it with everything else. -# Additional parameter can be specified as the name of directory. -macro(add_llvm_external_project name) +function(canonicalize_tool_name name output) + string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" nameStrip ${name}) + string(REPLACE "-" "_" nameUNDERSCORE ${nameStrip}) + string(TOUPPER ${nameUNDERSCORE} nameUPPER) + set(${output} "${nameUPPER}" PARENT_SCOPE) +endfunction(canonicalize_tool_name) + +# Custom add_subdirectory wrapper +# Takes in a project name (i.e. LLVM), the the subdirectory name, and an +# and an optional path if it differs from the name. +macro(add_llvm_subdirectory project type name) set(add_llvm_external_dir "${ARGN}") if("${add_llvm_external_dir}" STREQUAL "") set(add_llvm_external_dir ${name}) endif() - list(APPEND LLVM_IMPLICIT_PROJECT_IGNORE "${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}") - string(REPLACE "-" "_" nameUNDERSCORE ${name}) - string(TOUPPER ${nameUNDERSCORE} nameUPPER) - #TODO: Remove this check in a few days once it has circulated through - # buildbots and people's checkouts (cbieneman - July 14, 2015) - if("${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}") - unset(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR CACHE) - endif() - if(NOT LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR) - set(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}") + canonicalize_tool_name(${name} nameUPPER) + if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir}/CMakeLists.txt) + # Treat it as in-tree subproject. + option(${project}_${type}_${nameUPPER}_BUILD + "Whether to build ${name} as part of ${project}" On) + mark_as_advanced(${project}_${type}_${name}_BUILD) + if(${project}_${type}_${nameUPPER}_BUILD) + add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${add_llvm_external_dir} ${add_llvm_external_dir}) + # Don't process it in add_llvm_implicit_projects(). + set(${project}_${type}_${nameUPPER}_BUILD OFF) + endif() else() set(LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR - CACHE PATH "Path to ${name} source directory") - endif() - if (EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}/CMakeLists.txt) - option(LLVM_EXTERNAL_${nameUPPER}_BUILD - "Whether to build ${name} as part of LLVM" ON) - if (LLVM_EXTERNAL_${nameUPPER}_BUILD) - add_subdirectory(${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR} ${add_llvm_external_dir}) + "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" + CACHE PATH "Path to ${name} source directory") + set(${project}_${type}_${nameUPPER}_BUILD_DEFAULT ON) + if(NOT LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR OR NOT EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}) + set(${project}_${type}_${nameUPPER}_BUILD_DEFAULT OFF) + endif() + if("${LLVM_EXTERNAL_${nameUPPER}_BUILD}" STREQUAL "OFF") + set(${project}_${type}_${nameUPPER}_BUILD_DEFAULT OFF) + endif() + option(${project}_${type}_${nameUPPER}_BUILD + "Whether to build ${name} as part of LLVM" + ${${project}_${type}_${nameUPPER}_BUILD_DEFAULT}) + if (${project}_${type}_${nameUPPER}_BUILD) + if(EXISTS ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}) + add_subdirectory(${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR} ${add_llvm_external_dir}) + elseif(NOT "${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}" STREQUAL "") + message(WARNING "Nonexistent directory for ${name}: ${LLVM_EXTERNAL_${nameUPPER}_SOURCE_DIR}") + endif() + # FIXME: It'd be redundant. + set(${project}_${type}_${nameUPPER}_BUILD Off) endif() endif() -endmacro(add_llvm_external_project) +endmacro() + +# Add external project that may want to be built as part of llvm such as Clang, +# lld, and Polly. This adds two options. One for the source directory of the +# project, which defaults to ${CMAKE_CURRENT_SOURCE_DIR}/${name}. Another to +# enable or disable building it with everything else. +# Additional parameter can be specified as the name of directory. +macro(add_llvm_external_project name) + add_llvm_subdirectory(LLVM TOOL ${name} ${ARGN}) +endmacro() macro(add_llvm_tool_subdirectory name) - list(APPEND LLVM_IMPLICIT_PROJECT_IGNORE "${CMAKE_CURRENT_SOURCE_DIR}/${name}") - add_subdirectory(${name}) + add_llvm_external_project(${name}) endmacro(add_llvm_tool_subdirectory) -macro(ignore_llvm_tool_subdirectory name) - list(APPEND LLVM_IMPLICIT_PROJECT_IGNORE "${CMAKE_CURRENT_SOURCE_DIR}/${name}") -endmacro(ignore_llvm_tool_subdirectory) +function(get_project_name_from_src_var var output) + string(REGEX MATCH "LLVM_EXTERNAL_(.*)_SOURCE_DIR" + MACHED_TOOL "${var}") + if(MACHED_TOOL) + set(${output} ${CMAKE_MATCH_1} PARENT_SCOPE) + else() + set(${output} PARENT_SCOPE) + endif() +endfunction() -function(add_llvm_implicit_external_projects) +function(create_subdirectory_options project type) + file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*") + foreach(dir ${sub-dirs}) + if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt") + canonicalize_tool_name(${dir} name) + option(${project}_${type}_${name}_BUILD + "Whether to build ${name} as part of ${project}" On) + mark_as_advanced(${project}_${type}_${name}_BUILD) + endif() + endforeach() +endfunction(create_subdirectory_options) + +function(create_llvm_tool_options) + create_subdirectory_options(LLVM TOOL) +endfunction(create_llvm_tool_options) + +function(add_llvm_implicit_projects) set(list_of_implicit_subdirs "") file(GLOB sub-dirs "${CMAKE_CURRENT_SOURCE_DIR}/*") foreach(dir ${sub-dirs}) - if(IS_DIRECTORY "${dir}") - list(FIND LLVM_IMPLICIT_PROJECT_IGNORE "${dir}" tool_subdir_ignore) - if( tool_subdir_ignore EQUAL -1 - AND EXISTS "${dir}/CMakeLists.txt") + if(IS_DIRECTORY "${dir}" AND EXISTS "${dir}/CMakeLists.txt") + canonicalize_tool_name(${dir} name) + if (LLVM_TOOL_${name}_BUILD) get_filename_component(fn "${dir}" NAME) list(APPEND list_of_implicit_subdirs "${fn}") endif() @@ -735,7 +861,7 @@ function(add_llvm_implicit_external_projects) foreach(external_proj ${list_of_implicit_subdirs}) add_llvm_external_project("${external_proj}") endforeach() -endfunction(add_llvm_implicit_external_projects) +endfunction(add_llvm_implicit_projects) # Generic support for adding a unittest. function(add_unittest test_suite test_name) @@ -754,9 +880,9 @@ function(add_unittest test_suite test_name) set(LLVM_REQUIRES_RTTI OFF) - add_llvm_executable(${test_name} ${ARGN}) + add_llvm_executable(${test_name} IGNORE_EXTERNALIZE_DEBUGINFO ${ARGN}) set(outdir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}) - set_output_directory(${test_name} ${outdir} ${outdir}) + set_output_directory(${test_name} BINARY_DIR ${outdir} LIBRARY_DIR ${outdir}) target_link_libraries(${test_name} gtest gtest_main @@ -785,8 +911,13 @@ 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 "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" + COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" "linkmode=${linkmode}" ${ARG_GOFLAGS} build -o ${binpath} ${pkgpath} DEPENDS llvm-config ${CMAKE_BINARY_DIR}/bin/llvm-go${CMAKE_EXECUTABLE_SUFFIX} ${llvmlibs} ${ARG_DEPENDS} @@ -939,3 +1070,132 @@ function(add_lit_testsuites project directory) endforeach() endif() endfunction() + +function(llvm_install_library_symlink name dest type) + cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN}) + foreach(path ${CMAKE_MODULE_PATH}) + if(EXISTS ${path}/LLVMInstallSymlink.cmake) + set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake) + break() + endif() + endforeach() + + set(component ${ARG_COMPONENT}) + if(NOT component) + set(component ${name}) + endif() + + set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX}) + set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX}) + + set(output_dir lib${LLVM_LIBDIR_SUFFIX}) + if(WIN32 AND "${type}" STREQUAL "SHARED") + set(output_dir bin) + endif() + + install(SCRIPT ${INSTALL_SYMLINK} + CODE "install_symlink(${full_name} ${full_dest} ${output_dir})" + COMPONENT ${component}) + + if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE) + add_custom_target(install-${name} + DEPENDS ${name} ${dest} install-${dest} + COMMAND "${CMAKE_COMMAND}" + -DCMAKE_INSTALL_COMPONENT=${name} + -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") + endif() +endfunction() + +function(llvm_install_symlink name dest) + cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN}) + foreach(path ${CMAKE_MODULE_PATH}) + if(EXISTS ${path}/LLVMInstallSymlink.cmake) + set(INSTALL_SYMLINK ${path}/LLVMInstallSymlink.cmake) + break() + endif() + endforeach() + + if(ARG_ALWAYS_GENERATE) + set(component ${dest}) + else() + set(component ${name}) + 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)" + COMPONENT ${component}) + + if (NOT CMAKE_CONFIGURATION_TYPES AND NOT ARG_ALWAYS_GENERATE) + add_custom_target(install-${name} + DEPENDS ${name} ${dest} install-${dest} + COMMAND "${CMAKE_COMMAND}" + -DCMAKE_INSTALL_COMPONENT=${name} + -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") + endif() +endfunction() + +function(add_llvm_tool_symlink name dest) + cmake_parse_arguments(ARG "ALWAYS_GENERATE" "" "" ${ARGN}) + 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}") + + if(ARG_ALWAYS_GENERATE) + set_property(DIRECTORY APPEND PROPERTY + ADDITIONAL_MAKE_CLEAN_FILES ${dest_binary}) + add_custom_command(TARGET ${dest} 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}) + else() + list(FIND LLVM_TOOLCHAIN_TOOLS ${name} LLVM_IS_${name}_TOOLCHAIN_TOOL) + 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() + endif() + endif() +endfunction() + +function(llvm_externalize_debuginfo name) + if(NOT LLVM_EXTERNALIZE_DEBUGINFO) + return() + 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}> + COMMAND xcrun strip -Sl $<TARGET_FILE:${name}>) + else() + message(FATAL_ERROR "LLVM_EXTERNALIZE_DEBUGINFO isn't implemented for non-darwin platforms!") + endif() +endfunction() diff --git a/cmake/modules/AddLLVMDefinitions.cmake b/cmake/modules/AddLLVMDefinitions.cmake index 33ac9731db5d..dab16236d3e9 100644 --- a/cmake/modules/AddLLVMDefinitions.cmake +++ b/cmake/modules/AddLLVMDefinitions.cmake @@ -7,7 +7,11 @@ macro(add_llvm_definitions) # We don't want no semicolons on LLVM_DEFINITIONS: foreach(arg ${ARGN}) - set(LLVM_DEFINITIONS "${LLVM_DEFINITIONS} ${arg}") + if(DEFINED LLVM_DEFINITIONS) + set(LLVM_DEFINITIONS "${LLVM_DEFINITIONS} ${arg}") + else() + set(LLVM_DEFINITIONS ${arg}) + endif() endforeach(arg) add_definitions( ${ARGN} ) endmacro(add_llvm_definitions) diff --git a/cmake/modules/CrossCompile.cmake b/cmake/modules/CrossCompile.cmake index 76a3078a5440..c136dfaa612e 100644 --- a/cmake/modules/CrossCompile.cmake +++ b/cmake/modules/CrossCompile.cmake @@ -19,6 +19,7 @@ function(llvm_create_cross_target_internal target_name toochain buildtype) add_custom_command(OUTPUT ${LLVM_${target_name}_BUILD}/CMakeCache.txt COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR} + -DLLVM_TARGET_IS_CROSSCOMPILE_HOST=TRUE WORKING_DIRECTORY ${LLVM_${target_name}_BUILD} DEPENDS ${LLVM_${target_name}_BUILD} COMMENT "Configuring ${target_name} LLVM...") @@ -43,6 +44,7 @@ function(llvm_create_cross_target_internal target_name toochain buildtype) execute_process(COMMAND ${CMAKE_COMMAND} ${build_type_flags} -G "${CMAKE_GENERATOR}" -DLLVM_TARGETS_TO_BUILD=${LLVM_TARGETS_TO_BUILD} ${CROSS_TOOLCHAIN_FLAGS_${target_name}} ${CMAKE_SOURCE_DIR} + -DLLVM_TARGET_IS_CROSSCOMPILE_HOST=TRUE WORKING_DIRECTORY ${LLVM_${target_name}_BUILD} ) endif(NOT IS_DIRECTORY ${LLVM_${target_name}_BUILD}) diff --git a/cmake/modules/DetermineGCCCompatible.cmake b/cmake/modules/DetermineGCCCompatible.cmake new file mode 100644 index 000000000000..1bf15fcba72f --- /dev/null +++ b/cmake/modules/DetermineGCCCompatible.cmake @@ -0,0 +1,11 @@ +# Determine if the compiler has GCC-compatible command-line syntax. + +if(NOT DEFINED LLVM_COMPILER_IS_GCC_COMPATIBLE) + if(CMAKE_COMPILER_IS_GNUCXX) + set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON) + elseif( MSVC ) + set(LLVM_COMPILER_IS_GCC_COMPATIBLE OFF) + elseif( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" ) + set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON) + endif() +endif() diff --git a/cmake/modules/HandleLLVMOptions.cmake b/cmake/modules/HandleLLVMOptions.cmake index 4db27033b203..4c5ffe2f7b28 100644 --- a/cmake/modules/HandleLLVMOptions.cmake +++ b/cmake/modules/HandleLLVMOptions.cmake @@ -132,7 +132,8 @@ endif() # Pass -Wl,-z,defs. This makes sure all symbols are defined. Otherwise a DSO # build might work on ELF but fail on MachO/COFF. if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin" OR WIN32 OR CYGWIN OR - ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD") AND + ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR + ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD") AND NOT LLVM_USE_SANITIZER) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs") endif() @@ -166,6 +167,7 @@ function(add_flag_or_print_warning flag name) message(STATUS "Building with ${flag}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE) + set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${flag}" PARENT_SCOPE) else() message(WARNING "${flag} is not supported.") endif() @@ -180,16 +182,15 @@ if( LLVM_ENABLE_PIC ) # On Windows all code is PIC. MinGW warns if -fPIC is used. else() add_flag_or_print_warning("-fPIC" FPIC) - - if( WIN32 OR CYGWIN) - # MinGW warns if -fvisibility-inlines-hidden is used. - else() - check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG) - append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS) - endif() endif() endif() +if(NOT WIN32 AND NOT CYGWIN) + # MinGW warns if -fvisibility-inlines-hidden is used. + check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG) + append_if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG "-fvisibility-inlines-hidden" CMAKE_CXX_FLAGS) +endif() + if( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32 ) # TODO: support other platforms and toolchains. if( LLVM_BUILD_32_BITS ) @@ -246,6 +247,12 @@ if( MSVC_IDE ) endif() if( MSVC ) + if( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0 ) + # For MSVC 2013, disable iterator null pointer checking in debug mode, + # especially so std::equal(nullptr, nullptr, nullptr) will not assert. + add_llvm_definitions("-D_DEBUG_POINTER_IMPL=") + endif() + include(ChooseMSVCCRT) if( NOT (${CMAKE_VERSION} VERSION_LESS 2.8.11) ) @@ -274,6 +281,7 @@ if( MSVC ) set(msvc_warning_flags # Disabled warnings. + -wd4141 # Suppress ''modifier' : used more than once' (because of __forceinline combined with inline) -wd4146 # Suppress 'unary minus operator applied to unsigned type, result still unsigned' -wd4180 # Suppress 'qualifier applied to function type has no meaning; ignored' -wd4244 # Suppress ''argument' : conversion from 'type1' to 'type2', possible loss of data' @@ -307,6 +315,11 @@ if( MSVC ) -wd4611 # Suppress 'interaction between '_setjmp' and C++ object destruction is non-portable' -wd4805 # Suppress 'unsafe mix of type <type> and type <type> in operation' -wd4204 # Suppress 'nonstandard extension used : non-constant aggregate initializer' + -wd4577 # Suppress 'noexcept used with no exception handling mode specified; termination on exception is not guaranteed' + -wd4091 # Suppress 'typedef: ignored on left of '' when no variable is declared' + # C4592 is disabled because of false positives in Visual Studio 2015 + # Update 1. Re-evaluate the usefulness of this diagnostic with Update 2. + -wd4592 # Suppress ''var': symbol will be dynamically initialized (implementation limitation) # 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 @@ -325,7 +338,10 @@ if( MSVC ) # Enable warnings if (LLVM_ENABLE_WARNINGS) - append("/W4" msvc_warning_flags) + # Put /W4 in front of all the -we flags. cl.exe doesn't care, but for + # clang-cl having /W4 after the -we flags will re-enable the warnings + # disabled by -we. + set(msvc_warning_flags "/W4 ${msvc_warning_flags}") # CMake appends /W3 by default, and having /W3 followed by /W4 will result in # cl : Command line warning D9025 : overriding '/W3' with '/W4'. Since this is # a command line warning and not a compiler warning, it cannot be suppressed except @@ -345,6 +361,8 @@ if( MSVC ) append("${flag}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endforeach(flag) + append("/Zc:inline" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + # Disable sized deallocation if the flag is supported. MSVC fails to compile # the operator new overload in User otherwise. check_c_compiler_flag("/WX /Zc:sizedDealloc-" SUPPORTS_SIZED_DEALLOC) @@ -367,7 +385,8 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE ) endif() endif() - append_if(LLVM_ENABLE_PEDANTIC "-pedantic -Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + append_if(LLVM_ENABLE_PEDANTIC "-pedantic" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + append_if(LLVM_ENABLE_PEDANTIC "-Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) add_flag_if_supported("-Wcovered-switch-default" COVERED_SWITCH_DEFAULT_FLAG) append_if(USE_NO_UNINITIALIZED "-Wno-uninitialized" CMAKE_CXX_FLAGS) append_if(USE_NO_MAYBE_UNINITIALIZED "-Wno-maybe-uninitialized" CMAKE_CXX_FLAGS) @@ -375,16 +394,23 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE ) # Check if -Wnon-virtual-dtor warns even though the class is marked final. # If it does, don't add it. So it won't be added on clang 3.4 and older. # This also catches cases when -Wnon-virtual-dtor isn't supported by - # the compiler at all. - set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS}) - set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11 -Werror=non-virtual-dtor") - CHECK_CXX_SOURCE_COMPILES("class base {public: virtual void anchor();protected: ~base();}; - class derived final : public base { public: ~derived();}; - int main() { return 0; }" - CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR) - set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS}) - append_if(CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR - "-Wnon-virtual-dtor" CMAKE_CXX_FLAGS) + # the compiler at all. This flag is not activated for gcc since it will + # incorrectly identify a protected non-virtual base when there is a friend + # declaration. + if (NOT CMAKE_COMPILER_IS_GNUCXX) + set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS}) + set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11 -Werror=non-virtual-dtor") + CHECK_CXX_SOURCE_COMPILES("class base {public: virtual void anchor();protected: ~base();}; + class derived final : public base { public: ~derived();}; + int main() { return 0; }" + CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR) + set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS}) + append_if(CXX_WONT_WARN_ON_FINAL_NONVIRTUALDTOR + "-Wnon-virtual-dtor" CMAKE_CXX_FLAGS) + endif() + + # Enable -Wdelete-non-virtual-dtor if available. + add_flag_if_supported("-Wdelete-non-virtual-dtor" DELETE_NON_VIRTUAL_DTOR_FLAG) # Check if -Wcomment is OK with an // comment ending with '\' if the next # line is also a // comment. @@ -420,7 +446,7 @@ 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 -fcxx-modules") + set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fmodules") # 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 @@ -440,16 +466,34 @@ elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE ) endif( MSVC ) macro(append_common_sanitizer_flags) - # Append -fno-omit-frame-pointer and turn on debug info to get better - # stack traces. - add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER) - if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND - NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO") - add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY) - endif() - # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large. - if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") - add_flag_if_supported("-O1" O1) + if (NOT MSVC) + # Append -fno-omit-frame-pointer and turn on debug info to get better + # stack traces. + add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER) + if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND + NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO") + add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY) + endif() + # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large. + if (uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") + add_flag_if_supported("-O1" O1) + endif() + elseif (CLANG_CL) + # Keep frame pointers around. + append("/Oy-" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + if (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) + endif() + # Always ask the linker to produce symbols with asan. + append("-debug" CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS) endif() endmacro() @@ -478,10 +522,17 @@ if(LLVM_USE_SANITIZER) append("-fsanitize=address,undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) else() - message(WARNING "Unsupported value of LLVM_USE_SANITIZER: ${LLVM_USE_SANITIZER}") + message(FATAL_ERROR "Unsupported value of LLVM_USE_SANITIZER: ${LLVM_USE_SANITIZER}") + endif() + elseif(MSVC) + if (LLVM_USE_SANITIZER STREQUAL "Address") + append_common_sanitizer_flags() + append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + else() + message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${LLVM_USE_SANITIZER}") endif() else() - message(WARNING "LLVM_USE_SANITIZER is not supported on this platform.") + message(FATAL_ERROR "LLVM_USE_SANITIZER is not supported on this platform.") endif() if (LLVM_USE_SANITIZE_COVERAGE) append("-fsanitize-coverage=edge,indirect-calls,8bit-counters,trace-cmp" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) @@ -546,6 +597,14 @@ if(LLVM_ENABLE_EH AND NOT LLVM_ENABLE_RTTI) message(FATAL_ERROR "Exception handling requires RTTI. You must set LLVM_ENABLE_RTTI to ON") endif() +option(LLVM_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" + CMAKE_CXX_FLAGS + CMAKE_C_FLAGS + CMAKE_EXE_LINKER_FLAGS + CMAKE_SHARED_LINKER_FLAGS) + # Plugin support # FIXME: Make this configurable. if(WIN32 OR CYGWIN) diff --git a/cmake/modules/HandleLLVMStdlib.cmake b/cmake/modules/HandleLLVMStdlib.cmake index 66ad078fb66e..b07781c3f290 100644 --- a/cmake/modules/HandleLLVMStdlib.cmake +++ b/cmake/modules/HandleLLVMStdlib.cmake @@ -1,17 +1,11 @@ # This CMake module is responsible for setting the standard library to libc++ # if the user has requested it. +include(DetermineGCCCompatible) + if(NOT DEFINED LLVM_STDLIB_HANDLED) set(LLVM_STDLIB_HANDLED ON) - if(CMAKE_COMPILER_IS_GNUCXX) - set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON) - elseif( MSVC ) - set(LLVM_COMPILER_IS_GCC_COMPATIBLE OFF) - elseif( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" ) - set(LLVM_COMPILER_IS_GCC_COMPATIBLE ON) - endif() - function(append value) foreach(variable ${ARGN}) set(${variable} "${${variable}} ${value}" PARENT_SCOPE) diff --git a/cmake/modules/LLVM-Config.cmake b/cmake/modules/LLVM-Config.cmake index 22ac71451917..aa68b4007602 100755 --- a/cmake/modules/LLVM-Config.cmake +++ b/cmake/modules/LLVM-Config.cmake @@ -31,7 +31,23 @@ endfunction(is_llvm_target_library) macro(llvm_config executable) - explicit_llvm_config(${executable} ${ARGN}) + cmake_parse_arguments(ARG "USE_SHARED" "" "" ${ARGN}) + set(link_components ${ARG_UNPARSED_ARGUMENTS}) + + if(USE_SHARED) + # If USE_SHARED is specified, then we link against libLLVM, + # but also against the component libraries below. This is + # done in case libLLVM does not contain all of the components + # the target requires. + # + # TODO strip LLVM_DYLIB_COMPONENTS out of link_components. + # To do this, we need special handling for "all", since that + # may imply linking to libraries that are not included in + # libLLVM. + target_link_libraries(${executable} LLVM) + endif() + + explicit_llvm_config(${executable} ${link_components}) endmacro(llvm_config) diff --git a/cmake/modules/LLVMConfig.cmake.in b/cmake/modules/LLVMConfig.cmake.in index 5b7789dbc9a1..6855c4422543 100644 --- a/cmake/modules/LLVMConfig.cmake.in +++ b/cmake/modules/LLVMConfig.cmake.in @@ -39,6 +39,9 @@ set(LLVM_NATIVE_ARCH @LLVM_NATIVE_ARCH@) set(LLVM_ENABLE_PIC @LLVM_ENABLE_PIC@) +set(LLVM_ENABLE_PLUGINS @LLVM_ENABLE_PLUGINS@) +set(LLVM_PLUGIN_EXT @LLVM_PLUGIN_EXT@) + set(LLVM_ON_UNIX @LLVM_ON_UNIX@) set(LLVM_ON_WIN32 @LLVM_ON_WIN32@) @@ -46,7 +49,7 @@ 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_DEFINITIONS "-D__STDC_LIMIT_MACROS" "-D__STDC_CONSTANT_MACROS") +set(LLVM_DEFINITIONS "@LLVM_DEFINITIONS@") set(LLVM_CMAKE_DIR "@LLVM_CONFIG_CMAKE_DIR@") set(LLVM_TOOLS_BINARY_DIR "@LLVM_CONFIG_TOOLS_BINARY_DIR@") diff --git a/cmake/modules/LLVMExternalProjectUtils.cmake b/cmake/modules/LLVMExternalProjectUtils.cmake new file mode 100644 index 000000000000..c2d9f530c200 --- /dev/null +++ b/cmake/modules/LLVMExternalProjectUtils.cmake @@ -0,0 +1,195 @@ +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) + if (CMAKE_GENERATOR MATCHES "Make") + # Use special command for Makefiles to support parallelism. + set(${out_var} "$(MAKE)" "${target}" PARENT_SCOPE) + else() + set(${out_var} ${CMAKE_COMMAND} --build . --target ${target} + --config $<CONFIGURATION> PARENT_SCOPE) + endif() +endfunction() + +# llvm_ExternalProject_Add(name source_dir ... +# USE_TOOLCHAIN +# Use just-built tools (see TOOLCHAIN_TOOLS) +# EXCLUDE_FROM_ALL +# Exclude this project from the all target +# NO_INSTALL +# Don't generate install targets for this project +# CMAKE_ARGS arguments... +# Optional cmake arguments to pass when configuring the project +# TOOLCHAIN_TOOLS targets... +# Targets for toolchain tools (defaults to clang;lld) +# DEPENDS targets... +# Targets that this project depends on +# EXTRA_TARGETS targets... +# Extra targets in the subproject to generate targets for +# ) +function(llvm_ExternalProject_Add name source_dir) + cmake_parse_arguments(ARG "USE_TOOLCHAIN;EXCLUDE_FROM_ALL;NO_INSTALL" + "SOURCE_DIR" + "CMAKE_ARGS;TOOLCHAIN_TOOLS;RUNTIME_LIBRARIES;DEPENDS;EXTRA_TARGETS" ${ARGN}) + canonicalize_tool_name(${name} nameCanon) + if(NOT ARG_TOOLCHAIN_TOOLS) + set(ARG_TOOLCHAIN_TOOLS clang lld) + endif() + foreach(tool ${ARG_TOOLCHAIN_TOOLS}) + if(TARGET ${tool}) + list(APPEND TOOLCHAIN_TOOLS ${tool}) + list(APPEND TOOLCHAIN_BINS $<TARGET_FILE:${tool}>) + endif() + endforeach() + + if(NOT ARG_RUNTIME_LIBRARIES) + set(ARG_RUNTIME_LIBRARIES compiler-rt libcxx) + endif() + foreach(lib ${ARG_RUNTIME_LIBRARIES}) + if(TARGET ${lib}) + list(APPEND RUNTIME_LIBRARIES ${lib}) + endif() + endforeach() + + list(FIND TOOLCHAIN_TOOLS clang FOUND_CLANG) + if(FOUND_CLANG GREATER -1) + set(CLANG_IN_TOOLCHAIN On) + endif() + + if(RUNTIME_LIBRARIES AND CLANG_IN_TOOLCHAIN) + list(APPEND TOOLCHAIN_BINS ${RUNTIME_LIBRARIES}) + endif() + + 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/) + + add_custom_target(${name}-clear + COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR} + COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR} + COMMENT "Clobbering ${name} build and stamp directories" + ${cmake_3_2_USES_TERMINAL} + ) + + # Find all variables that start with COMPILER_RT and populate a variable with + # them. + get_cmake_property(variableNames VARIABLES) + foreach(variableName ${variableNames}) + if(variableName MATCHES "^${nameCanon}") + string(REPLACE ";" "\;" value "${${variableName}}") + list(APPEND PASSTHROUGH_VARIABLES + -D${variableName}=${value}) + endif() + endforeach() + + if(ARG_USE_TOOLCHAIN) + if(CLANG_IN_TOOLCHAIN) + set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang + -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++) + endif() + list(APPEND ARG_DEPENDS ${TOOLCHAIN_TOOLS}) + endif() + + add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp + DEPENDS ${ARG_DEPENDS} + COMMAND ${CMAKE_COMMAND} -E touch ${BINARY_DIR}/CMakeCache.txt + COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_DIR}/${name}-mkdir + COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp + COMMENT "Clobbering bootstrap build and stamp directories" + ) + + add_custom_target(${name}-clobber + DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp) + + if(ARG_EXCLUDE_FROM_ALL) + set(exclude ${cmake_3_1_EXCLUDE_FROM_ALL}) + endif() + + ExternalProject_Add(${name} + DEPENDS ${ARG_DEPENDS} + ${name}-clobber + PREFIX ${CMAKE_BINARY_DIR}/projects/${name} + SOURCE_DIR ${source_dir} + STAMP_DIR ${STAMP_DIR} + BINARY_DIR ${BINARY_DIR} + ${exclude} + CMAKE_ARGS ${${nameCanon}_CMAKE_ARGS} + ${compiler_args} + -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} + ${ARG_CMAKE_ARGS} + ${PASSTHROUGH_VARIABLES} + INSTALL_COMMAND "" + STEP_TARGETS configure build + ${cmake_3_4_USES_TERMINAL_OPTIONS} + ) + + 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) + ExternalProject_Add_Step(${name} clean + COMMAND ${run_clean} + COMMENT "Cleaning ${name}..." + DEPENDEES configure + ${force_deps} + WORKING_DIRECTORY ${BINARY_DIR} + ${cmake_3_4_USES_TERMINAL} + ) + ExternalProject_Add_StepTargets(${name} clean) + + if(ARG_USE_TOOLCHAIN) + add_dependencies(${name}-clean ${name}-clobber) + set_target_properties(${name}-clean PROPERTIES + SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp) + endif() + + if(NOT ARG_NO_INSTALL) + install(CODE "execute_process\(COMMAND \${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=\${CMAKE_INSTALL_PREFIX} -P ${BINARY_DIR}/cmake_install.cmake \)" + COMPONENT ${name}) + + add_custom_target(install-${name} + DEPENDS ${name} + COMMAND "${CMAKE_COMMAND}" + -DCMAKE_INSTALL_COMPONENT=${name} + -P "${CMAKE_BINARY_DIR}/cmake_install.cmake" + ${cmake_3_2_USES_TERMINAL}) + endif() + + # Add top-level targets + foreach(target ${ARG_EXTRA_TARGETS}) + llvm_ExternalProject_BuildCmd(build_runtime_cmd ${target}) + add_custom_target(${target} + COMMAND ${build_runtime_cmd} + DEPENDS ${name}-configure + WORKING_DIRECTORY ${BINARY_DIR} + VERBATIM + ${cmake_3_2_USES_TERMINAL}) + endforeach() +endfunction() diff --git a/cmake/modules/LLVMInstallSymlink.cmake b/cmake/modules/LLVMInstallSymlink.cmake new file mode 100644 index 000000000000..482697b06baf --- /dev/null +++ b/cmake/modules/LLVMInstallSymlink.cmake @@ -0,0 +1,21 @@ +# We need to execute this script at installation time because the +# DESTDIR environment variable may be unset at configuration time. +# See PR8397. + +function(install_symlink name target outdir) + if(UNIX) + set(LINK_OR_COPY create_symlink) + set(DESTDIR $ENV{DESTDIR}) + else() + set(LINK_OR_COPY copy) + endif() + + set(bindir "${DESTDIR}${CMAKE_INSTALL_PREFIX}/${outdir}/") + + message("Creating ${name}") + + execute_process( + COMMAND "${CMAKE_COMMAND}" -E ${LINK_OR_COPY} "${target}" "${name}" + WORKING_DIRECTORY "${bindir}") + +endfunction() diff --git a/cmake/modules/Makefile b/cmake/modules/Makefile index f644c45dcd0d..abfda93b210f 100644 --- a/cmake/modules/Makefile +++ b/cmake/modules/Makefile @@ -9,8 +9,6 @@ LEVEL = ../.. -LINK_COMPONENTS := all - include $(LEVEL)/Makefile.common PROJ_cmake := $(DESTDIR)$(PROJ_prefix)/share/llvm/cmake @@ -39,24 +37,9 @@ else LLVM_ENABLE_RTTI := 0 endif -# Don't try to run llvm-config during clean because it won't be available -ifneq ($(MAKECMDGOALS),clean) -LLVM_LIBS_TO_EXPORT := $(subst -l,,$(shell $(LLVM_CONFIG) --libs $(LINK_COMPONENTS) || echo Error)) - -ifeq ($(LLVM_LIBS_TO_EXPORT),Error) -$(error llvm-config --libs failed) -endif - -# Strip out gtest and gtest_main from LLVM_LIBS_TO_EXPORT, these are not -# installed and won't be available from the install tree. -# FIXME: If we used llvm-config from the install tree this wouldn't be -# necessary. -LLVM_LIBS_TO_EXPORT := $(filter-out gtest gtest_main,$(LLVM_LIBS_TO_EXPORT)) - ifndef LLVM_LIBS_TO_EXPORT $(error LLVM_LIBS_TO_EXPORT cannot be empty) endif -endif OBJMODS := LLVMConfig.cmake LLVMConfigVersion.cmake LLVMExports.cmake @@ -135,7 +118,7 @@ $(PROJ_OBJ_DIR)/LLVMExports.cmake: $(LLVMBuildCMakeExportsFrag) Makefile done && \ cat "$(LLVMBuildCMakeExportsFrag)" && \ echo 'set_property(TARGET LLVMSupport APPEND PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES '"$(subst -l,,$(LIBS))"')' \ - ) | grep -v gtest > $@ + ) > $@ all-local:: $(addprefix $(PROJ_OBJ_DIR)/, $(OBJMODS)) diff --git a/cmake/modules/TableGen.cmake b/cmake/modules/TableGen.cmake index 85d720e91fd7..fca7d1bda4b3 100644 --- a/cmake/modules/TableGen.cmake +++ b/cmake/modules/TableGen.cmake @@ -70,9 +70,31 @@ function(add_public_tablegen_target target) set(LLVM_COMMON_DEPENDS ${LLVM_COMMON_DEPENDS} ${target} PARENT_SCOPE) endfunction() +if(LLVM_USE_HOST_TOOLS) + add_custom_command(OUTPUT LIB_LLVMSUPPORT + COMMAND ${CMAKE_COMMAND} --build . --target LLVMSupport --config Release + DEPENDS CONFIGURE_LLVM_NATIVE + WORKING_DIRECTORY ${LLVM_NATIVE_BUILD} + COMMENT "Building libLLVMSupport for native TableGen...") + add_custom_target(NATIVE_LIB_LLVMSUPPORT DEPENDS LIB_LLVMSUPPORT) + + add_custom_command(OUTPUT LIB_LLVMTABLEGEN + COMMAND ${CMAKE_COMMAND} --build . --target LLVMTableGen --config Release + DEPENDS CONFIGURE_LLVM_NATIVE + WORKING_DIRECTORY ${LLVM_NATIVE_BUILD} + COMMENT "Building libLLVMTableGen for native TableGen...") + add_custom_target(NATIVE_LIB_LLVMTABLEGEN DEPENDS LIB_LLVMTABLEGEN) +endif(LLVM_USE_HOST_TOOLS) + macro(add_tablegen target project) set(${target}_OLD_LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS}) set(LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS} TableGen) + + if(NOT XCODE) + # FIXME: It leaks to user, callee of add_tablegen. + set(LLVM_ENABLE_OBJLIB ON) + endif() + add_llvm_utility(${target} ${ARGN}) set(LLVM_LINK_COMPONENTS ${${target}_OLD_LLVM_LINK_COMPONENTS}) @@ -103,7 +125,7 @@ macro(add_tablegen target project) add_custom_command(OUTPUT ${${project}_TABLEGEN_EXE} COMMAND ${CMAKE_COMMAND} --build . --target ${target} --config Release - DEPENDS CONFIGURE_LLVM_NATIVE ${target} + DEPENDS ${target} NATIVE_LIB_LLVMSUPPORT NATIVE_LIB_LLVMTABLEGEN WORKING_DIRECTORY ${LLVM_NATIVE_BUILD} COMMENT "Building native TableGen...") add_custom_target(${project}-tablegen-host DEPENDS ${${project}_TABLEGEN_EXE}) |