diff options
Diffstat (limited to 'Modules')
121 files changed, 1696 insertions, 511 deletions
diff --git a/Modules/CMakeASMCompiler.cmake.in b/Modules/CMakeASMCompiler.cmake.in index 1efd9f5..c7dbfae 100644 --- a/Modules/CMakeASMCompiler.cmake.in +++ b/Modules/CMakeASMCompiler.cmake.in @@ -5,6 +5,12 @@ set(CMAKE_ASM@ASM_DIALECT@_COMPILER_AR "@_CMAKE_ASM_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_ASM@ASM_DIALECT@_COMPILER_RANLIB "@_CMAKE_ASM_COMPILER_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER "@CMAKE_ASM_COMPILER_LINKER@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER_ID "@CMAKE_ASM_COMPILER_LINKER_ID@") +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER_VERSION @CMAKE_ASM_COMPILER_LINKER_VERSION@) +set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_ASM_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_MT "@CMAKE_MT@") set(CMAKE_TAPI "@CMAKE_TAPI@") set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LOADED 1) diff --git a/Modules/CMakeCCompiler.cmake.in b/Modules/CMakeCCompiler.cmake.in index 2f0b774..df2a060 100644 --- a/Modules/CMakeCCompiler.cmake.in +++ b/Modules/CMakeCCompiler.cmake.in @@ -26,6 +26,12 @@ set(CMAKE_C_COMPILER_AR "@CMAKE_C_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_C_COMPILER_RANLIB "@CMAKE_C_COMPILER_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_C_COMPILER_LINKER "@CMAKE_C_COMPILER_LINKER@") +set(CMAKE_C_COMPILER_LINKER_ID "@CMAKE_C_COMPILER_LINKER_ID@") +set(CMAKE_C_COMPILER_LINKER_VERSION @CMAKE_C_COMPILER_LINKER_VERSION@) +set(CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_MT "@CMAKE_MT@") set(CMAKE_TAPI "@CMAKE_TAPI@") set(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@) diff --git a/Modules/CMakeCInformation.cmake b/Modules/CMakeCInformation.cmake index 665f309..998e476 100644 --- a/Modules/CMakeCInformation.cmake +++ b/Modules/CMakeCInformation.cmake @@ -67,7 +67,7 @@ if (NOT _INCLUDED_FILE) endif () if(CMAKE_C_SIZEOF_DATA_PTR) - foreach(f ${CMAKE_C_ABI_FILES}) + foreach(f IN LISTS CMAKE_C_ABI_FILES) include(${f}) endforeach() unset(CMAKE_C_ABI_FILES) diff --git a/Modules/CMakeCUDACompiler.cmake.in b/Modules/CMakeCUDACompiler.cmake.in index 3c28c28..3af02a4 100644 --- a/Modules/CMakeCUDACompiler.cmake.in +++ b/Modules/CMakeCUDACompiler.cmake.in @@ -72,5 +72,12 @@ set(CMAKE_CUDA_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_CUDA_IMPLICIT_LINK_FR @_SET_CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT@ set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_CUDA_COMPILER_LINKER "@CMAKE_CUDA_COMPILER_LINKER@") +set(CMAKE_CUDA_COMPILER_LINKER_ID "@CMAKE_CUDA_COMPILER_LINKER_ID@") +set(CMAKE_CUDA_COMPILER_LINKER_VERSION @CMAKE_CUDA_COMPILER_LINKER_VERSION@) +set(CMAKE_CUDA_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_CUDA_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_AR "@CMAKE_AR@") +set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_MT "@CMAKE_MT@") diff --git a/Modules/CMakeCXXCompiler.cmake.in b/Modules/CMakeCXXCompiler.cmake.in index 073a8af..55f1113 100644 --- a/Modules/CMakeCXXCompiler.cmake.in +++ b/Modules/CMakeCXXCompiler.cmake.in @@ -27,6 +27,12 @@ set(CMAKE_CXX_COMPILER_AR "@CMAKE_CXX_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_CXX_COMPILER_RANLIB "@CMAKE_CXX_COMPILER_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_CXX_COMPILER_LINKER "@CMAKE_CXX_COMPILER_LINKER@") +set(CMAKE_CXX_COMPILER_LINKER_ID "@CMAKE_CXX_COMPILER_LINKER_ID@") +set(CMAKE_CXX_COMPILER_LINKER_VERSION @CMAKE_CXX_COMPILER_LINKER_VERSION@) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_MT "@CMAKE_MT@") set(CMAKE_TAPI "@CMAKE_TAPI@") set(CMAKE_COMPILER_IS_GNUCXX @CMAKE_COMPILER_IS_GNUCXX@) @@ -40,7 +46,7 @@ set(CMAKE_CXX_COMPILER_ID_RUN 1) set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) -foreach (lang C OBJC OBJCXX) +foreach (lang IN ITEMS C OBJC OBJCXX) if (CMAKE_${lang}_COMPILER_ID_RUN) foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) diff --git a/Modules/CMakeCXXInformation.cmake b/Modules/CMakeCXXInformation.cmake index 53abf37..3753d18 100644 --- a/Modules/CMakeCXXInformation.cmake +++ b/Modules/CMakeCXXInformation.cmake @@ -66,7 +66,7 @@ if (NOT _INCLUDED_FILE) endif () if(CMAKE_CXX_SIZEOF_DATA_PTR) - foreach(f ${CMAKE_CXX_ABI_FILES}) + foreach(f IN LISTS CMAKE_CXX_ABI_FILES) include(${f}) endforeach() unset(CMAKE_CXX_ABI_FILES) @@ -182,7 +182,7 @@ if(NOT CMAKE_SHARED_MODULE_CXX_FLAGS) endif() # Initialize CXX link type selection flags from C versions. -foreach(type SHARED_LIBRARY SHARED_MODULE EXE) +foreach(type IN ITEMS SHARED_LIBRARY SHARED_MODULE EXE) if(NOT CMAKE_${type}_LINK_STATIC_CXX_FLAGS) set(CMAKE_${type}_LINK_STATIC_CXX_FLAGS ${CMAKE_${type}_LINK_STATIC_C_FLAGS}) diff --git a/Modules/CMakeCompilerIdDetection.cmake b/Modules/CMakeCompilerIdDetection.cmake index 7eb93e2..2817d37 100644 --- a/Modules/CMakeCompilerIdDetection.cmake +++ b/Modules/CMakeCompilerIdDetection.cmake @@ -42,11 +42,6 @@ function(compiler_id_detection outvar lang) # Order is relevant here. For example, compilers which pretend to be # GCC must appear before the actual GCC. - if ("x${lang}" STREQUAL "xCXX") - list(APPEND ordered_compilers - Comeau - ) - endif() list(APPEND ordered_compilers Intel IntelLLVM @@ -85,6 +80,7 @@ function(compiler_id_detection outvar lang) ARMCC AppleClang ARMClang + TIClang ) list(APPEND ordered_compilers Clang diff --git a/Modules/CMakeDetermineASMCompiler.cmake b/Modules/CMakeDetermineASMCompiler.cmake index 6d7d17e..2042e64 100644 --- a/Modules/CMakeDetermineASMCompiler.cmake +++ b/Modules/CMakeDetermineASMCompiler.cmake @@ -102,6 +102,10 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI "-h") set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI "Texas Instruments") + list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TIClang ) + set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TIClang "--version") + set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TIClang "(TI (.*) Clang Compiler)") + list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS IAR) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_IAR ) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_IAR "IAR Assembler") diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake index 8beebc5..73b6cee 100644 --- a/Modules/CMakeDetermineCCompiler.cmake +++ b/Modules/CMakeDetermineCCompiler.cmake @@ -166,6 +166,11 @@ if (NOT _CMAKE_TOOLCHAIN_PREFIX) set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1}) set(_CMAKE_TOOLCHAIN_SUFFIX ${CMAKE_MATCH_4}) set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_6}) + elseif(CMAKE_C_COMPILER_ID MATCHES "TIClang") + if (COMPILER_BASENAME MATCHES "^(.+)?clang(\\.exe)?$") + set(_CMAKE_TOOLCHAIN_PREFIX "${CMAKE_MATCH_1}") + set(_CMAKE_TOOLCHAIN_SUFFIX "${CMAKE_MATCH_2}") + endif() elseif(CMAKE_C_COMPILER_ID MATCHES "Clang") if(CMAKE_C_COMPILER_TARGET) set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_C_COMPILER_TARGET}-) diff --git a/Modules/CMakeDetermineCUDACompiler.cmake b/Modules/CMakeDetermineCUDACompiler.cmake index 6ac4dad..70528da 100644 --- a/Modules/CMakeDetermineCUDACompiler.cmake +++ b/Modules/CMakeDetermineCUDACompiler.cmake @@ -74,10 +74,6 @@ if(NOT CMAKE_CUDA_COMPILER_ID_RUN) set(CMAKE_CUDA_COMPILER_ID_VENDOR_REGEX_Clang "(clang version)") CMAKE_DETERMINE_COMPILER_ID_VENDOR(CUDA "--version") - if(CMAKE_CUDA_COMPILER_ID STREQUAL "Clang" AND WIN32) - message(FATAL_ERROR "Clang with CUDA is not yet supported on Windows. See CMake issue #20776.") - endif() - # Find the CUDA toolkit to get: # - CMAKE_CUDA_COMPILER_TOOLKIT_VERSION # - CMAKE_CUDA_COMPILER_TOOLKIT_ROOT diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake index 40934ec..891ba6e 100644 --- a/Modules/CMakeDetermineCXXCompiler.cmake +++ b/Modules/CMakeDetermineCXXCompiler.cmake @@ -171,6 +171,11 @@ if (NOT _CMAKE_TOOLCHAIN_PREFIX) set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1}) set(_CMAKE_TOOLCHAIN_SUFFIX ${CMAKE_MATCH_3}) set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_5}) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "TIClang") + if (COMPILER_BASENAME MATCHES "^(.+)?clang(\\.exe)?$") + set(_CMAKE_TOOLCHAIN_PREFIX "${CMAKE_MATCH_1}") + set(_CMAKE_TOOLCHAIN_SUFFIX "${CMAKE_MATCH_2}") + endif() elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") if(CMAKE_CXX_COMPILER_TARGET) set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_CXX_COMPILER_TARGET}-) diff --git a/Modules/CMakeDetermineCompiler.cmake b/Modules/CMakeDetermineCompiler.cmake index 3156ca9..fc0b714 100644 --- a/Modules/CMakeDetermineCompiler.cmake +++ b/Modules/CMakeDetermineCompiler.cmake @@ -15,7 +15,7 @@ macro(_cmake_find_compiler lang) set(_${lang}_COMPILER_LIST "${CMAKE_${lang}_COMPILER_LIST}") set(CMAKE_${lang}_COMPILER_LIST "") # Prefer vendors of compilers from reference languages. - foreach(l ${_languages}) + foreach(l IN LISTS _languages) list(APPEND CMAKE_${lang}_COMPILER_LIST ${_${lang}_COMPILER_NAMES_${CMAKE_${l}_COMPILER_ID}}) endforeach() @@ -33,7 +33,7 @@ macro(_cmake_find_compiler lang) # Look for directories containing compilers of reference languages. set(_${lang}_COMPILER_HINTS "${CMAKE_${lang}_COMPILER_HINTS}") - foreach(l ${_languages}) + foreach(l IN LISTS _languages) if(CMAKE_${l}_COMPILER AND IS_ABSOLUTE "${CMAKE_${l}_COMPILER}") get_filename_component(_hint "${CMAKE_${l}_COMPILER}" PATH) if(IS_DIRECTORY "${_hint}") @@ -99,7 +99,7 @@ macro(_cmake_find_compiler lang) if (CMAKE_${lang}_COMPILER MATCHES "^/usr/bin/(.+)$") _query_xcrun("${CMAKE_MATCH_1}" RESULT_VAR xcrun_result) elseif (CMAKE_${lang}_COMPILER STREQUAL "CMAKE_${lang}_COMPILER-NOTFOUND") - foreach(comp ${CMAKE_${lang}_COMPILER_LIST}) + foreach(comp IN LISTS CMAKE_${lang}_COMPILER_LIST) _query_xcrun("${comp}" RESULT_VAR xcrun_result) if(xcrun_result) break() @@ -120,6 +120,10 @@ macro(_cmake_find_compiler_path lang) # CMAKE_${lang}_COMPILER and the rest as CMAKE_${lang}_COMPILER_ARG1 # Otherwise, preserve any existing CMAKE_${lang}_COMPILER_ARG1 that might # have been saved by CMakeDetermine${lang}Compiler in a previous run. + + # Necessary for Windows paths to avoid improper escaping of backslashes + cmake_path(CONVERT "${CMAKE_${lang}_COMPILER}" TO_CMAKE_PATH_LIST CMAKE_${lang}_COMPILER NORMALIZE) + list(LENGTH CMAKE_${lang}_COMPILER _CMAKE_${lang}_COMPILER_LENGTH) if(_CMAKE_${lang}_COMPILER_LENGTH GREATER 1) set(CMAKE_${lang}_COMPILER_ARG1 "${CMAKE_${lang}_COMPILER}") diff --git a/Modules/CMakeDetermineCompilerABI.cmake b/Modules/CMakeDetermineCompilerABI.cmake index efc18f9..012a87c 100644 --- a/Modules/CMakeDetermineCompilerABI.cmake +++ b/Modules/CMakeDetermineCompilerABI.cmake @@ -6,6 +6,7 @@ # This is used internally by CMake and should not be included by user # code. +include(${CMAKE_ROOT}/Modules/Internal/CMakeDetermineLinkerId.cmake) include(${CMAKE_ROOT}/Modules/CMakeParseImplicitIncludeInfo.cmake) include(${CMAKE_ROOT}/Modules/CMakeParseImplicitLinkInfo.cmake) include(${CMAKE_ROOT}/Modules/CMakeParseLibraryArchitecture.cmake) @@ -19,15 +20,19 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src) set(BIN "${CMAKE_PLATFORM_INFO_DIR}/CMakeDetermineCompilerABI_${lang}.bin") set(CMAKE_FLAGS ) set(COMPILE_DEFINITIONS ) + set(LINK_OPTIONS ) if(DEFINED CMAKE_${lang}_VERBOSE_FLAG) - set(CMAKE_FLAGS "-DEXE_LINKER_FLAGS=${CMAKE_${lang}_VERBOSE_FLAG}") + set(LINK_OPTIONS "${CMAKE_${lang}_VERBOSE_FLAG}") set(COMPILE_DEFINITIONS "${CMAKE_${lang}_VERBOSE_FLAG}") endif() if(DEFINED CMAKE_${lang}_VERBOSE_COMPILE_FLAG) set(COMPILE_DEFINITIONS "${CMAKE_${lang}_VERBOSE_COMPILE_FLAG}") endif() + if(DEFINED CMAKE_${lang}_VERBOSE_LINK_FLAG) + list(APPEND LINK_OPTIONS "${CMAKE_${lang}_VERBOSE_LINK_FLAG}") + endif() if(lang MATCHES "^(CUDA|HIP)$") - if(CMAKE_${lang}_ARCHITECTURES STREQUAL "native") + if(CMAKE_CUDA_ARCHITECTURES STREQUAL "native") # We are about to detect the native architectures, so we do # not yet know them. Use all architectures during detection. set(CMAKE_${lang}_ARCHITECTURES "all") @@ -39,6 +44,9 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src) # from which we might detect implicit link libraries. list(APPEND CMAKE_FLAGS "-DCMAKE_${lang}_STANDARD_LIBRARIES=") endif() + list(JOIN LINK_OPTIONS " " LINK_OPTIONS) + list(APPEND CMAKE_FLAGS "-DEXE_LINKER_FLAGS=${LINK_OPTIONS}") + __TestCompiler_setTryCompileTargetType() # Avoid failing ABI detection on warnings. @@ -53,7 +61,6 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src) set(ENV{LC_ALL} C) set(ENV{LC_MESSAGES} C) set(ENV{LANG} C) - try_compile(CMAKE_${lang}_ABI_COMPILED SOURCES ${src} CMAKE_FLAGS ${CMAKE_FLAGS} @@ -146,39 +153,42 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src) set(implicit_libs "${CMAKE_${lang}_IMPLICIT_LINK_LIBRARIES}") set(implicit_fwks "${CMAKE_${lang}_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES}") else() - # Parse implicit linker information for this language, if available. - set(implicit_dirs "") - set(implicit_objs "") - set(implicit_libs "") - set(implicit_fwks "") - if(CMAKE_${lang}_VERBOSE_FLAG) - CMAKE_PARSE_IMPLICIT_LINK_INFO("${OUTPUT}" implicit_libs implicit_dirs implicit_fwks log - "${CMAKE_${lang}_IMPLICIT_OBJECT_REGEX}" - COMPUTE_IMPLICIT_OBJECTS implicit_objs - LANGUAGE ${lang}) - message(CONFIGURE_LOG - "Parsed ${lang} implicit link information:\n${log}\n\n") - endif() - # for VS IDE Intel Fortran we have to figure out the - # implicit link path for the fortran run time using - # a try-compile - if("${lang}" MATCHES "Fortran" - AND "${CMAKE_GENERATOR}" MATCHES "Visual Studio") - message(CHECK_START "Determine Intel Fortran Compiler Implicit Link Path") - # Build a sample project which reports symbols. - try_compile(IFORT_LIB_PATH_COMPILED - PROJECT IntelFortranImplicit - SOURCE_DIR ${CMAKE_ROOT}/Modules/IntelVSImplicitPath - BINARY_DIR ${CMAKE_BINARY_DIR}/CMakeFiles/IntelVSImplicitPath - CMAKE_FLAGS - "-DCMAKE_Fortran_FLAGS:STRING=${CMAKE_Fortran_FLAGS}" - OUTPUT_VARIABLE _output) - file(WRITE - "${CMAKE_BINARY_DIR}/CMakeFiles/IntelVSImplicitPath/output.txt" - "${_output}") - include(${CMAKE_BINARY_DIR}/CMakeFiles/IntelVSImplicitPath/output.cmake OPTIONAL) - message(CHECK_PASS "done") - endif() + # Parse implicit linker information for this language, if available. + set(implicit_dirs "") + set(implicit_objs "") + set(implicit_libs "") + set(implicit_fwks "") + set(compute_artifacts COMPUTE_LINKER linker_tool) + if(CMAKE_${lang}_VERBOSE_FLAG) + list(APPEND compute_artifacts COMPUTE_IMPLICIT_LIBS implicit_libs + COMPUTE_IMPLICIT_DIRS implicit_dirs + COMPUTE_IMPLICIT_FWKS implicit_fwks + COMPUTE_IMPLICIT_OBJECTS implicit_objs) + endif() + cmake_parse_implicit_link_info2("${OUTPUT}" log "${CMAKE_${lang}_IMPLICIT_OBJECT_REGEX}" + ${compute_artifacts} LANGUAGE ${lang}) + message(CONFIGURE_LOG + "Parsed ${lang} implicit link information:\n${log}\n\n") + # for VS IDE Intel Fortran we have to figure out the + # implicit link path for the fortran run time using + # a try-compile + if("${lang}" MATCHES "Fortran" + AND "${CMAKE_GENERATOR}" MATCHES "Visual Studio") + message(CHECK_START "Determine Intel Fortran Compiler Implicit Link Path") + # Build a sample project which reports symbols. + try_compile(IFORT_LIB_PATH_COMPILED + PROJECT IntelFortranImplicit + SOURCE_DIR ${CMAKE_ROOT}/Modules/IntelVSImplicitPath + BINARY_DIR ${CMAKE_BINARY_DIR}/CMakeFiles/IntelVSImplicitPath + CMAKE_FLAGS + "-DCMAKE_Fortran_FLAGS:STRING=${CMAKE_Fortran_FLAGS}" + OUTPUT_VARIABLE _output) + file(WRITE + "${CMAKE_BINARY_DIR}/CMakeFiles/IntelVSImplicitPath/output.txt" + "${_output}") + include(${CMAKE_BINARY_DIR}/CMakeFiles/IntelVSImplicitPath/output.cmake OPTIONAL) + message(CHECK_PASS "done") + endif() endif() # Implicit link libraries cannot be used explicitly for multiple @@ -193,6 +203,12 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src) list(REMOVE_ITEM implicit_dirs $ENV{CMAKE_${lang}_IMPLICIT_LINK_DIRECTORIES_EXCLUDE}) endif() + set(CMAKE_${lang}_COMPILER_LINKER "${linker_tool}" PARENT_SCOPE) + cmake_determine_linker_id(${lang} "${linker_tool}") + set(CMAKE_${lang}_COMPILER_LINKER_ID "${CMAKE_${lang}_COMPILER_LINKER_ID}" PARENT_SCOPE) + set(CMAKE_${lang}_COMPILER_LINKER_VERSION ${CMAKE_${lang}_COMPILER_LINKER_VERSION} PARENT_SCOPE) + set(CMAKE_${lang}_COMPILER_LINKER_FRONTEND_VARIANT ${CMAKE_${lang}_COMPILER_LINKER_FRONTEND_VARIANT} PARENT_SCOPE) + set(CMAKE_${lang}_IMPLICIT_LINK_LIBRARIES "${implicit_libs}" PARENT_SCOPE) set(CMAKE_${lang}_IMPLICIT_LINK_DIRECTORIES "${implicit_dirs}" PARENT_SCOPE) set(CMAKE_${lang}_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "${implicit_fwks}" PARENT_SCOPE) diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index 85c555a..7d063ed 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -174,27 +174,30 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) endif() endif() - # FIXME(LLVMFlang): It does not provide predefines identifying the MSVC ABI or architecture. - # It should be taught to define _MSC_VER and its _M_* architecture flags. if("x${lang}" STREQUAL "xFortran" AND "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xLLVMFlang") - # Parse the target triple to detect information we should later be able - # to get during preprocessing above, once LLVMFlang provides it. + # Parse the target triple to detect information not always available from the preprocessor. if(COMPILER_${lang}_PRODUCED_OUTPUT MATCHES "-triple ([0-9a-z_]*)-.*windows-msvc([0-9]+)\\.([0-9]+)") - set(CMAKE_${lang}_SIMULATE_ID "MSVC") + # CMakeFortranCompilerId.F.in does not extract the _MSC_VER minor version. + # We can do better using the version parsed here. set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_MATCH_2}.${CMAKE_MATCH_3}") - set(arch ${CMAKE_MATCH_1}) - if(arch STREQUAL "x86_64") - set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "x64") - elseif(arch STREQUAL "aarch64") - set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "ARM64") - elseif(arch STREQUAL "arm64ec") - set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "ARM64EC") - elseif(arch MATCHES "^i[3-9]86$") - set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "X86") - else() - message(FATAL_ERROR "LLVMFlang target architecture unrecognized: ${arch}") + + if (CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 18.0) + # LLVMFlang < 18.0 does not provide predefines identifying the MSVC ABI or architecture. + set(CMAKE_${lang}_SIMULATE_ID "MSVC") + set(arch ${CMAKE_MATCH_1}) + if(arch STREQUAL "x86_64") + set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "x64") + elseif(arch STREQUAL "aarch64") + set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "ARM64") + elseif(arch STREQUAL "arm64ec") + set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "ARM64EC") + elseif(arch MATCHES "^i[3-9]86$") + set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "X86") + else() + message(FATAL_ERROR "LLVMFlang target architecture unrecognized: ${arch}") + endif() + set(MSVC_${lang}_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}") endif() - set(MSVC_${lang}_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}") elseif(COMPILER_${lang}_PRODUCED_OUTPUT MATCHES "-triple ([0-9a-z_]*)-.*windows-gnu") set(CMAKE_${lang}_SIMULATE_ID "GNU") endif() @@ -277,7 +280,8 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) endif() elseif("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xGNU" OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xAppleClang" - OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xFujitsuClang") + OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xFujitsuClang" + OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xTIClang") set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU") elseif("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xMSVC") set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC") @@ -426,7 +430,13 @@ Id flags: ${testflags} ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS} elseif(lang STREQUAL Fortran) set(v Intel) set(ext vfproj) - set(id_cl ifort.exe) + if(CMAKE_VS_PLATFORM_TOOLSET_FORTRAN) + set(id_cl "${CMAKE_VS_PLATFORM_TOOLSET_FORTRAN}.exe") + set(id_UseCompiler "UseCompiler=\"${CMAKE_VS_PLATFORM_TOOLSET_FORTRAN}Compiler\"") + else() + set(id_cl ifort.exe) + set(id_UseCompiler "") + endif() elseif(lang STREQUAL CSharp) set(v 10) set(ext csproj) diff --git a/Modules/CMakeDetermineFortranCompiler.cmake b/Modules/CMakeDetermineFortranCompiler.cmake index 392f0f1..613b0c4 100644 --- a/Modules/CMakeDetermineFortranCompiler.cmake +++ b/Modules/CMakeDetermineFortranCompiler.cmake @@ -22,7 +22,7 @@ elseif("${CMAKE_GENERATOR}" MATCHES "Xcode") _cmake_find_compiler_path(Fortran) else() if(NOT CMAKE_Fortran_COMPILER) - # prefer the environment variable CC + # prefer the environment variable FC if(NOT $ENV{FC} STREQUAL "") get_filename_component(CMAKE_Fortran_COMPILER_INIT $ENV{FC} PROGRAM PROGRAM_ARGS CMAKE_Fortran_FLAGS_ENV_INIT) if(CMAKE_Fortran_FLAGS_ENV_INIT) @@ -140,11 +140,11 @@ if(NOT CMAKE_Fortran_COMPILER_ID_RUN) set(CMAKE_Fortran_COMPILER_ID_TOOL_MATCH_INDEX 2) set(_version_info "") - foreach(m MAJOR MINOR PATCH TWEAK) + foreach(m IN ITEMS MAJOR MINOR PATCH TWEAK) set(_COMP "_${m}") string(APPEND _version_info " #if defined(COMPILER_VERSION${_COMP})") - foreach(d 1 2 3 4 5 6 7 8) + foreach(d RANGE 1 8) string(APPEND _version_info " # undef DEC # undef HEX @@ -265,8 +265,8 @@ if("${CMAKE_Fortran_COMPILER_ID};${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "LLVMFla "${log}\n" ) set(_CMAKE_Fortran_IMPLICIT_LINK_INFORMATION_DETERMINED_EARLY 1) - if("x${CMAKE_Fortran_COMPILER_ARCHITECTURE_ID}" STREQUAL "xARM64") - # FIXME(LLVMFlang): It does not add `-defaultlib:` fields to object + if("x${CMAKE_Fortran_COMPILER_ARCHITECTURE_ID}" STREQUAL "xARM64" AND CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 18.0) + # LLVMFlang < 18.0 does not add `-defaultlib:` fields to object # files to specify link dependencies on its runtime libraries. # For now, we add them ourselves. list(APPEND CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES "clang_rt.builtins-aarch64.lib") diff --git a/Modules/CMakeDetermineSystem.cmake b/Modules/CMakeDetermineSystem.cmake index fff4e9d..b330ed9 100644 --- a/Modules/CMakeDetermineSystem.cmake +++ b/Modules/CMakeDetermineSystem.cmake @@ -6,30 +6,6 @@ # CMAKE_SYSTEM_NAME - on unix this is uname -s, for windows it is Windows # CMAKE_SYSTEM_VERSION - on unix this is uname -r, for windows it is empty # CMAKE_SYSTEM - ${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION}, for windows: ${CMAKE_SYSTEM} -# -# Expected uname -s output: -# -# AIX AIX -# BSD/OS BSD/OS -# FreeBSD FreeBSD -# HP-UX HP-UX -# Linux Linux -# GNU/kFreeBSD GNU/kFreeBSD -# NetBSD NetBSD -# OpenBSD OpenBSD -# OFS/1 (Digital Unix) OSF1 -# SCO OpenServer 5 SCO_SV -# SCO UnixWare 7 UnixWare -# SCO UnixWare (pre release 7) UNIX_SV -# SCO XENIX Xenix -# Solaris SunOS -# SunOS SunOS -# Tru64 Tru64 -# Ultrix ULTRIX -# cygwin CYGWIN_NT-5.1 -# MSYS MSYS_NT-6.1 -# MacOSX Darwin - # find out on which system cmake runs if(CMAKE_HOST_UNIX) @@ -177,22 +153,19 @@ if(CMAKE_TOOLCHAIN_FILE) endif() endif() - -# if CMAKE_SYSTEM_NAME is here already set, either it comes from a toolchain file -# or it was set via -DCMAKE_SYSTEM_NAME=... -# if that's the case, assume we are crosscompiling if(CMAKE_SYSTEM_NAME) + # CMAKE_SYSTEM_NAME was set by a toolchain file or on the command line. + # Assume it set CMAKE_SYSTEM_VERSION and CMAKE_SYSTEM_PROCESSOR too. if(NOT DEFINED CMAKE_CROSSCOMPILING) set(CMAKE_CROSSCOMPILING TRUE) endif() - set(PRESET_CMAKE_SYSTEM_NAME TRUE) elseif(CMAKE_VS_WINCE_VERSION) set(CMAKE_SYSTEM_NAME "WindowsCE") set(CMAKE_SYSTEM_VERSION "${CMAKE_VS_WINCE_VERSION}") set(CMAKE_SYSTEM_PROCESSOR "${MSVC_C_ARCHITECTURE_ID}") set(CMAKE_CROSSCOMPILING TRUE) - set(PRESET_CMAKE_SYSTEM_NAME TRUE) else() + # Build for the host platform and architecture by default. set(CMAKE_SYSTEM_NAME "${CMAKE_HOST_SYSTEM_NAME}") if(NOT DEFINED CMAKE_SYSTEM_VERSION) set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}") @@ -206,7 +179,6 @@ else() ) endif() set(CMAKE_CROSSCOMPILING FALSE) - set(PRESET_CMAKE_SYSTEM_NAME FALSE) endif() include(Platform/${CMAKE_SYSTEM_NAME}-Determine OPTIONAL) @@ -224,7 +196,7 @@ endif() # in this case there is no CMAKE_BINARY_DIR if(CMAKE_BINARY_DIR) # write entry to the log file - if(PRESET_CMAKE_SYSTEM_NAME) + if(CMAKE_CROSSCOMPILING) message(CONFIGURE_LOG "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n" "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n" diff --git a/Modules/CMakeFindBinUtils.cmake b/Modules/CMakeFindBinUtils.cmake index e12b175..5e85440 100644 --- a/Modules/CMakeFindBinUtils.cmake +++ b/Modules/CMakeFindBinUtils.cmake @@ -60,6 +60,13 @@ endfunction() __resolve_tool_path(CMAKE_LINKER "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Linker") __resolve_tool_path(CMAKE_MT "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Manifest Tool") +macro(__resolve_linker_path __linker_type __name __search_path __doc) + if(NOT CMAKE_LINKER_${__linker_type}) + set( CMAKE_LINKER_${__linker_type} "${__name}") + endif() + __resolve_tool_path(CMAKE_LINKER_${__linker_type} "${__search_path}" "${__doc}") +endmacro() + set(_CMAKE_TOOL_VARS "") # if it's the MS C/CXX compiler, search for link @@ -93,6 +100,10 @@ if(("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC" AND list(APPEND _CMAKE_TOOL_VARS LINKER MT AR) + # look-up for possible usable linker + __resolve_linker_path(LINK "link" "${_CMAKE_TOOLCHAIN_LOCATION}" "link Linker") + __resolve_linker_path(LLD "lld-link" "${_CMAKE_TOOLCHAIN_LOCATION}" "lld-link Linker") + elseif("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" MATCHES "^x(Open)?Watcom$") set(_CMAKE_LINKER_NAMES "wlink") set(_CMAKE_AR_NAMES "wlib") @@ -193,10 +204,10 @@ else() endif() list(PREPEND _CMAKE_NM_NAMES "llvm-nm") if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_VERSION}" VERSION_GREATER_EQUAL 9) - # llvm-objdump versions prior to 9 did not support everything we need. + # llvm-objcopy and llvm-objdump on versions prior to 9 did not support everything we need. + list(PREPEND _CMAKE_OBJCOPY_NAMES "llvm-objcopy") list(PREPEND _CMAKE_OBJDUMP_NAMES "llvm-objdump") endif() - list(PREPEND _CMAKE_OBJCOPY_NAMES "llvm-objcopy") list(PREPEND _CMAKE_READELF_NAMES "llvm-readelf") list(PREPEND _CMAKE_DLLTOOL_NAMES "llvm-dlltool") list(PREPEND _CMAKE_ADDR2LINE_NAMES "llvm-addr2line") diff --git a/Modules/CMakeFindPackageMode.cmake b/Modules/CMakeFindPackageMode.cmake index 726e2a2..a6bbcc4 100644 --- a/Modules/CMakeFindPackageMode.cmake +++ b/Modules/CMakeFindPackageMode.cmake @@ -5,10 +5,9 @@ CMakeFindPackageMode -------------------- - - -This file is executed by cmake when invoked with --find-package. It -expects that the following variables are set using -D: +This file is executed by cmake when invoked with +:ref:`--find-package <Find-Package Tool Mode>`. +It expects that the following variables are set using ``-D``: ``NAME`` name of the package diff --git a/Modules/CMakeFortranCompiler.cmake.in b/Modules/CMakeFortranCompiler.cmake.in index 89a00ab..90c2ad0 100644 --- a/Modules/CMakeFortranCompiler.cmake.in +++ b/Modules/CMakeFortranCompiler.cmake.in @@ -15,6 +15,10 @@ set(CMAKE_AR "@CMAKE_AR@") set(CMAKE_Fortran_COMPILER_AR "@CMAKE_Fortran_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_Fortran_COMPILER_LINKER "@CMAKE_Fortran_COMPILER_LINKER@") +set(CMAKE_Fortran_COMPILER_LINKER_ID "@CMAKE_Fortran_COMPILER_LINKER_ID@") +set(CMAKE_Fortran_COMPILER_LINKER_VERSION @CMAKE_Fortran_COMPILER_LINKER_VERSION@) +set(CMAKE_Fortran_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_Fortran_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_Fortran_COMPILER_RANLIB "@CMAKE_Fortran_COMPILER_RANLIB@") set(CMAKE_TAPI "@CMAKE_TAPI@") set(CMAKE_COMPILER_IS_GNUG77 @CMAKE_COMPILER_IS_GNUG77@) diff --git a/Modules/CMakeFortranCompilerId.F.in b/Modules/CMakeFortranCompilerId.F.in index f5c2ab5..a040073 100644 --- a/Modules/CMakeFortranCompilerId.F.in +++ b/Modules/CMakeFortranCompilerId.F.in @@ -240,7 +240,7 @@ #else PRINT *, 'INFO:platform[]' #endif -#if defined(_WIN32) && (defined(__INTEL_COMPILER) || defined(__ICC)) +#if defined(_MSC_VER) # if defined(_M_IA64) PRINT *, 'INFO:arch[IA64]' # elif defined(_M_X64) || defined(_M_AMD64) diff --git a/Modules/CMakeFortranInformation.cmake b/Modules/CMakeFortranInformation.cmake index 0f71c6f..e364755 100644 --- a/Modules/CMakeFortranInformation.cmake +++ b/Modules/CMakeFortranInformation.cmake @@ -43,7 +43,7 @@ if (NOT _INCLUDED_FILE) endif () if(CMAKE_Fortran_SIZEOF_DATA_PTR) - foreach(f ${CMAKE_Fortran_ABI_FILES}) + foreach(f IN LISTS CMAKE_Fortran_ABI_FILES) include(${f}) endforeach() unset(CMAKE_Fortran_ABI_FILES) diff --git a/Modules/CMakeGenericSystem.cmake b/Modules/CMakeGenericSystem.cmake index 77c1780..ccfde60 100644 --- a/Modules/CMakeGenericSystem.cmake +++ b/Modules/CMakeGenericSystem.cmake @@ -177,20 +177,27 @@ endfunction() # was initialized by the block below. This is useful for user # projects to change the default prefix while still allowing the # command line to override it. -if(NOT DEFINED CMAKE_INSTALL_PREFIX) +if(NOT DEFINED CMAKE_INSTALL_PREFIX AND + NOT DEFINED ENV{CMAKE_INSTALL_PREFIX}) set(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT 1) endif() -# Choose a default install prefix for this platform. -if(CMAKE_HOST_UNIX) - set(CMAKE_INSTALL_PREFIX "/usr/local" +if(DEFINED ENV{CMAKE_INSTALL_PREFIX}) + set(CMAKE_INSTALL_PREFIX "$ENV{CMAKE_INSTALL_PREFIX}" CACHE PATH "Install path prefix, prepended onto install directories.") else() - GetDefaultWindowsPrefixBase(CMAKE_GENERIC_PROGRAM_FILES) - set(CMAKE_INSTALL_PREFIX - "${CMAKE_GENERIC_PROGRAM_FILES}/${PROJECT_NAME}" - CACHE PATH "Install path prefix, prepended onto install directories.") - set(CMAKE_GENERIC_PROGRAM_FILES) + # If CMAKE_INSTALL_PREFIX env variable is not set, + # choose a default install prefix for this platform. + if(CMAKE_HOST_UNIX) + set(CMAKE_INSTALL_PREFIX "/usr/local" + CACHE PATH "Install path prefix, prepended onto install directories.") + else() + GetDefaultWindowsPrefixBase(CMAKE_GENERIC_PROGRAM_FILES) + set(CMAKE_INSTALL_PREFIX + "${CMAKE_GENERIC_PROGRAM_FILES}/${PROJECT_NAME}" + CACHE PATH "Install path prefix, prepended onto install directories.") + set(CMAKE_GENERIC_PROGRAM_FILES) + endif() endif() # Set a variable which will be used as component name in install() commands diff --git a/Modules/CMakeHIPCompiler.cmake.in b/Modules/CMakeHIPCompiler.cmake.in index 6d5e62a..9d70e03 100644 --- a/Modules/CMakeHIPCompiler.cmake.in +++ b/Modules/CMakeHIPCompiler.cmake.in @@ -74,5 +74,11 @@ set(CMAKE_HIP_COMPILER_AR "@CMAKE_HIP_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_HIP_COMPILER_RANLIB "@CMAKE_HIP_COMPILER_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_HIP_COMPILER_LINKER "@CMAKE_HIP_COMPILER_LINKER@") +set(CMAKE_HIP_COMPILER_LINKER_ID "@CMAKE_HIP_COMPILER_LINKER_ID@") +set(CMAKE_HIP_COMPILER_LINKER_VERSION @CMAKE_HIP_COMPILER_LINKER_VERSION@) +set(CMAKE_HIP_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_HIP_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_MT "@CMAKE_MT@") set(CMAKE_TAPI "@CMAKE_TAPI@") diff --git a/Modules/CMakeOBJCCompiler.cmake.in b/Modules/CMakeOBJCCompiler.cmake.in index de73645..a8bb0d2 100644 --- a/Modules/CMakeOBJCCompiler.cmake.in +++ b/Modules/CMakeOBJCCompiler.cmake.in @@ -24,6 +24,12 @@ set(CMAKE_OBJC_COMPILER_AR "@CMAKE_OBJC_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_OBJC_COMPILER_RANLIB "@CMAKE_OBJC_COMPILER_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_OBJC_COMPILER_LINKER "@CMAKE_OBJC_COMPILER_LINKER@") +set(CMAKE_OBJC_COMPILER_LINKER_ID "@CMAKE_OBJC_COMPILER_LINKER_ID@") +set(CMAKE_OBJC_COMPILER_LINKER_VERSION @CMAKE_OBJC_COMPILER_LINKER_VERSION@) +set(CMAKE_OBJC_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_OBJC_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_MT "@CMAKE_MT@") set(CMAKE_TAPI "@CMAKE_TAPI@") set(CMAKE_COMPILER_IS_GNUOBJC @CMAKE_COMPILER_IS_GNUOBJC@) diff --git a/Modules/CMakeOBJCInformation.cmake b/Modules/CMakeOBJCInformation.cmake index 4c697da..8b8f10e 100644 --- a/Modules/CMakeOBJCInformation.cmake +++ b/Modules/CMakeOBJCInformation.cmake @@ -67,7 +67,7 @@ if (NOT _INCLUDED_FILE) endif () if(CMAKE_OBJC_SIZEOF_DATA_PTR) - foreach(f ${CMAKE_OBJC_ABI_FILES}) + foreach(f IN LISTS CMAKE_OBJC_ABI_FILES) include(${f}) endforeach() unset(CMAKE_OBJC_ABI_FILES) diff --git a/Modules/CMakeOBJCXXCompiler.cmake.in b/Modules/CMakeOBJCXXCompiler.cmake.in index 94d24ff..6a80d50 100644 --- a/Modules/CMakeOBJCXXCompiler.cmake.in +++ b/Modules/CMakeOBJCXXCompiler.cmake.in @@ -25,6 +25,12 @@ set(CMAKE_OBJCXX_COMPILER_AR "@CMAKE_OBJCXX_COMPILER_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") set(CMAKE_OBJCXX_COMPILER_RANLIB "@CMAKE_OBJCXX_COMPILER_RANLIB@") set(CMAKE_LINKER "@CMAKE_LINKER@") +set(CMAKE_LINKER_LINK "@CMAKE_LINKER_LINK@") +set(CMAKE_LINKER_LLD "@CMAKE_LINKER_LLD@") +set(CMAKE_OBJCXX_COMPILER_LINKER "@CMAKE_OBJCXX_COMPILER_LINKER@") +set(CMAKE_OBJCXX_COMPILER_LINKER_ID "@CMAKE_OBJCXX_COMPILER_LINKER_ID@") +set(CMAKE_OBJCXX_COMPILER_LINKER_VERSION @CMAKE_OBJCXX_COMPILER_LINKER_VERSION@) +set(CMAKE_OBJCXX_COMPILER_LINKER_FRONTEND_VARIANT @CMAKE_OBJCXX_COMPILER_LINKER_FRONTEND_VARIANT@) set(CMAKE_MT "@CMAKE_MT@") set(CMAKE_TAPI "@CMAKE_TAPI@") set(CMAKE_COMPILER_IS_GNUOBJCXX @CMAKE_COMPILER_IS_GNUOBJCXX@) @@ -44,7 +50,7 @@ if (CMAKE_OBJC_COMPILER_ID_RUN) endforeach() endif() -foreach (lang C CXX OBJC) +foreach (lang IN ITEMS C CXX OBJC) foreach(extension IN LISTS CMAKE_OBJCXX_SOURCE_FILE_EXTENSIONS) if (CMAKE_${lang}_COMPILER_ID_RUN) list(REMOVE_ITEM CMAKE_${lang}_SOURCE_FILE_EXTENSIONS ${extension}) diff --git a/Modules/CMakeOBJCXXInformation.cmake b/Modules/CMakeOBJCXXInformation.cmake index a6d824f..da1d6c6 100644 --- a/Modules/CMakeOBJCXXInformation.cmake +++ b/Modules/CMakeOBJCXXInformation.cmake @@ -62,7 +62,7 @@ if (NOT _INCLUDED_FILE) endif () if(CMAKE_OBJCXX_SIZEOF_DATA_PTR) - foreach(f ${CMAKE_OBJCXX_ABI_FILES}) + foreach(f IN LISTS CMAKE_OBJCXX_ABI_FILES) include(${f}) endforeach() unset(CMAKE_OBJCXX_ABI_FILES) @@ -178,7 +178,7 @@ if(NOT CMAKE_SHARED_MODULE_OBJCXX_FLAGS) endif() # Initialize OBJCXX link type selection flags from OBJC versions. -foreach(type SHARED_LIBRARY SHARED_MODULE EXE) +foreach(type IN ITEMS SHARED_LIBRARY SHARED_MODULE EXE) if(NOT CMAKE_${type}_LINK_STATIC_OBJCXX_FLAGS) set(CMAKE_${type}_LINK_STATIC_OBJCXX_FLAGS ${CMAKE_${type}_LINK_STATIC_OBJC_FLAGS}) diff --git a/Modules/CMakePackageConfigHelpers.cmake b/Modules/CMakePackageConfigHelpers.cmake index 581e65c..b5bcd02 100644 --- a/Modules/CMakePackageConfigHelpers.cmake +++ b/Modules/CMakePackageConfigHelpers.cmake @@ -8,9 +8,6 @@ CMakePackageConfigHelpers Helpers functions for creating config files that can be included by other projects to find and use a package. -Adds the :command:`configure_package_config_file()` and -:command:`write_basic_package_version_file()` commands. - Generating a Package Configuration File ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -190,6 +187,132 @@ Please note that these files are internal to CMake and you should not call :command:`configure_file()` on them yourself, but they can be used as starting point to create more sophisticated custom ``ConfigVersion.cmake`` files. +Generating an Apple Platform Selection File +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. command:: generate_apple_platform_selection_file + + .. versionadded:: 3.29 + + Create an Apple platform selection file: + + .. code-block:: cmake + + generate_apple_platform_selection_file(<filename> + INSTALL_DESTINATION <path> + [INSTALL_PREFIX <path>] + [MACOS_INCLUDE_FILE <file>] + [IOS_INCLUDE_FILE <file>] + [IOS_SIMULATOR_INCLUDE_FILE <file>] + [TVOS_INCLUDE_FILE <file>] + [TVOS_SIMULATOR_INCLUDE_FILE <file>] + [WATCHOS_INCLUDE_FILE <file>] + [WATCHOS_SIMULATOR_INCLUDE_FILE <file>] + [VISIONOS_INCLUDE_FILE <file>] + [VISIONOS_SIMULATOR_INCLUDE_FILE <file>] + ) + + Write a file that includes an Apple-platform-specific ``.cmake`` file, + e.g., for use as ``<PackageName>Config.cmake``. This can be used in + conjunction with the ``XCFRAMEWORK_LOCATION`` argument of + :command:`export(SETUP)` to export packages in a way that a project + built for any Apple platform can use them. + + ``INSTALL_DESTINATION <path>`` + Path to which the generated file will be installed by the caller, e.g., + via :command:`install(FILES)`. The path may be either relative to the + ``INSTALL_PREFIX`` or absolute. + + ``INSTALL_PREFIX <path>`` + Path prefix to which the package will be installed by the caller. + The ``<path>`` argument must be an absolute path. If this argument + is not passed, the :variable:`CMAKE_INSTALL_PREFIX` variable will be + used instead. + + ``MACOS_INCLUDE_FILE <file>`` + File to include if the platform is macOS. + + ``IOS_INCLUDE_FILE <file>`` + File to include if the platform is iOS. + + ``IOS_SIMULATOR_INCLUDE_FILE <file>`` + File to include if the platform is iOS Simulator. + + ``TVOS_INCLUDE_FILE <file>`` + File to include if the platform is tvOS. + + ``TVOS_SIMULATOR_INCLUDE_FILE <file>`` + File to include if the platform is tvOS Simulator. + + ``WATCHOS_INCLUDE_FILE <file>`` + File to include if the platform is watchOS. + + ``WATCHOS_SIMULATOR_INCLUDE_FILE <file>`` + File to include if the platform is watchOS Simulator. + + ``VISIONOS_INCLUDE_FILE <file>`` + File to include if the platform is visionOS. + + ``VISIONOS_SIMULATOR_INCLUDE_FILE <file>`` + File to include if the platform is visionOS Simulator. + + If any of the optional include files is not specified, and the consuming + project is built for its corresponding platform, an error will be thrown + when including the generated file. + +.. command:: generate_apple_architecture_selection_file + + .. versionadded:: 3.29 + + Create an Apple architecture selection file: + + .. code-block:: cmake + + generate_apple_architecture_selection_file(<filename> + INSTALL_DESTINATION <path> + [INSTALL_PREFIX <path>] + [SINGLE_ARCHITECTURES <archs> + SINGLE_ARCHITECTURE_INCLUDE_FILES <files>] + [UNIVERSAL_ARCHITECTURES <archs> + UNIVERSAL_INCLUDE_FILE <file>] + ) + + Write a file that includes an Apple-architecture-specific ``.cmake`` file + based on :variable:`CMAKE_OSX_ARCHITECTURES`, e.g., for inclusion from an + Apple-specific ``<PackageName>Config.cmake`` file. + + ``INSTALL_DESTINATION <path>`` + Path to which the generated file will be installed by the caller, e.g., + via :command:`install(FILES)`. The path may be either relative to the + ``INSTALL_PREFIX`` or absolute. + + ``INSTALL_PREFIX <path>`` + Path prefix to which the package will be installed by the caller. + The ``<path>`` argument must be an absolute path. If this argument + is not passed, the :variable:`CMAKE_INSTALL_PREFIX` variable will be + used instead. + + ``SINGLE_ARCHITECTURES <archs>`` + A :ref:`semicolon-separated list <CMake Language Lists>` of + architectures provided by entries of + ``SINGLE_ARCHITECTURE_INCLUDE_FILES``. + + ``SINGLE_ARCHITECTURE_INCLUDE_FILES <files>`` + A :ref:`semicolon-separated list <CMake Language Lists>` of + architecture-specific files. One of them will be loaded + when :variable:`CMAKE_OSX_ARCHITECTURES` contains a single + architecture matching the corresponding entry of + ``SINGLE_ARCHITECTURES``. + + ``UNIVERSAL_ARCHITECTURES <archs>`` + A :ref:`semicolon-separated list <CMake Language Lists>` of + architectures provided by the ``UNIVERSAL_INCLUDE_FILE``. + + ``UNIVERSAL_INCLUDE_FILE <file>`` + A file to load when :variable:`CMAKE_OSX_ARCHITECTURES` contains + a (non-strict) subset of the ``UNIVERSAL_ARCHITECTURES`` and + does not match any one of the ``SINGLE_ARCHITECTURES``. + Example Generating Package Files ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -344,3 +467,130 @@ endmacro() configure_file("${_inputFile}" "${_outputFile}" @ONLY) endfunction() + +function(generate_apple_platform_selection_file _output_file) + set(_config_file_options + MACOS_INCLUDE_FILE + IOS_INCLUDE_FILE + IOS_SIMULATOR_INCLUDE_FILE + TVOS_INCLUDE_FILE + TVOS_SIMULATOR_INCLUDE_FILE + WATCHOS_INCLUDE_FILE + WATCHOS_SIMULATOR_INCLUDE_FILE + VISIONOS_INCLUDE_FILE + VISIONOS_SIMULATOR_INCLUDE_FILE + ) + + set(_options) + set(_single + INSTALL_DESTINATION + INSTALL_PREFIX + ${_config_file_options} + ) + set(_multi) + cmake_parse_arguments(PARSE_ARGV 0 _gpsf "${_options}" "${_single}" "${_multi}") + + if(NOT _gpsf_INSTALL_DESTINATION) + message(FATAL_ERROR "No INSTALL_DESTINATION given to generate_apple_platform_selection_file()") + endif() + if(_gpsf_INSTALL_PREFIX) + set(maybe_INSTALL_PREFIX INSTALL_PREFIX ${_gpsf_INSTALL_PREFIX}) + else() + set(maybe_INSTALL_PREFIX "") + endif() + + set(_have_relative 0) + foreach(_opt IN LISTS _config_file_options) + if(_gpsf_${_opt}) + set(_config_file "${_gpsf_${_opt}}") + if(NOT IS_ABSOLUTE "${_config_file}") + string(PREPEND _config_file [[${PACKAGE_PREFIX_DIR}/]]) + set(_have_relative 1) + endif() + set(_branch_${_opt} "include(\"${_config_file}\")") + else() + set(_branch_${_opt} "message(FATAL_ERROR \"Platform not supported\")") + endif() + endforeach() + + configure_package_config_file("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/Internal/ApplePlatformSelection.cmake.in" "${_output_file}" + INSTALL_DESTINATION "${_gpsf_INSTALL_DESTINATION}" + ${maybe_INSTALL_PREFIX} + NO_SET_AND_CHECK_MACRO + NO_CHECK_REQUIRED_COMPONENTS_MACRO + ) +endfunction() + +function(generate_apple_architecture_selection_file _output_file) + set(_options) + set(_single + INSTALL_DESTINATION + INSTALL_PREFIX + SINGLE_ARCHITECTURES + SINGLE_ARCHITECTURE_INCLUDE_FILES + UNIVERSAL_ARCHITECTURES + UNIVERSAL_INCLUDE_FILE + ) + set(_multi) + cmake_parse_arguments(PARSE_ARGV 0 _gasf "${_options}" "${_single}" "${_multi}") + + if(NOT _gasf_INSTALL_DESTINATION) + message(FATAL_ERROR "No INSTALL_DESTINATION given to generate_apple_platform_selection_file()") + endif() + if(_gasf_INSTALL_PREFIX) + set(maybe_INSTALL_PREFIX INSTALL_PREFIX ${_gasf_INSTALL_PREFIX}) + else() + set(maybe_INSTALL_PREFIX "") + endif() + + list(LENGTH _gasf_SINGLE_ARCHITECTURES _gasf_SINGLE_ARCHITECTURES_len) + list(LENGTH _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES_len) + if(NOT _gasf_SINGLE_ARCHITECTURES_len EQUAL _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES_len) + message(FATAL_ERROR "SINGLE_ARCHITECTURES and SINGLE_ARCHITECTURE_INCLUDE_FILES do not have the same number of entries.") + endif() + + set(_branch_code "") + + foreach(pair IN ZIP_LISTS _gasf_SINGLE_ARCHITECTURES _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES) + set(arch "${pair_0}") + set(config_file "${pair_1}") + if(NOT IS_ABSOLUTE "${config_file}") + string(PREPEND config_file [[${PACKAGE_PREFIX_DIR}/]]) + endif() + string(APPEND _branch_code + "\n" + "if(CMAKE_OSX_ARCHITECTURES STREQUAL \"${arch}\")\n" + " include(\"${config_file}\")\n" + " return()\n" + "endif()\n" + ) + endforeach() + + if(_gasf_UNIVERSAL_ARCHITECTURES AND _gasf_UNIVERSAL_INCLUDE_FILE) + string(JOIN " " universal_archs "${_gasf_UNIVERSAL_ARCHITECTURES}") + set(config_file "${_gasf_UNIVERSAL_INCLUDE_FILE}") + if(NOT IS_ABSOLUTE "${config_file}") + string(PREPEND config_file [[${PACKAGE_PREFIX_DIR}/]]) + endif() + string(APPEND _branch_code + "\n" + "set(_cmake_apple_archs \"\${CMAKE_OSX_ARCHITECTURES}\")\n" + "list(REMOVE_ITEM _cmake_apple_archs ${universal_archs})\n" + "if(NOT _cmake_apple_archs)\n" + " include(\"${config_file}\")\n" + " return()\n" + "endif()\n" + ) + elseif(_gasf_UNIVERSAL_ARCHITECTURES) + message(FATAL_ERROR "UNIVERSAL_INCLUDE_FILE requires UNIVERSAL_ARCHITECTURES") + elseif(_gasf_UNIVERSAL_INCLUDE_FILE) + message(FATAL_ERROR "UNIVERSAL_ARCHITECTURES requires UNIVERSAL_INCLUDE_FILE") + endif() + + configure_package_config_file("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/Internal/AppleArchitectureSelection.cmake.in" "${_output_file}" + INSTALL_DESTINATION "${_gasf_INSTALL_DESTINATION}" + ${maybe_INSTALL_PREFIX} + NO_SET_AND_CHECK_MACRO + NO_CHECK_REQUIRED_COMPONENTS_MACRO + ) +endfunction() diff --git a/Modules/CMakeParseImplicitLinkInfo.cmake b/Modules/CMakeParseImplicitLinkInfo.cmake index cbdb915..896eac0 100644 --- a/Modules/CMakeParseImplicitLinkInfo.cmake +++ b/Modules/CMakeParseImplicitLinkInfo.cmake @@ -15,6 +15,26 @@ cmake_policy(SET CMP0054 NEW) # compatibility don't break. # function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj_regex) + set(keywordArgs) + set(oneValueArgs LANGUAGE COMPUTE_IMPLICIT_OBJECTS) + set(multiValueArgs ) + cmake_parse_arguments(EXTRA_PARSE "${keywordArgs}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + cmake_parse_implicit_link_info2("${text}" "${log_var}" "${obj_regex}" + COMPUTE_IMPLICIT_LIBS "${lib_var}" COMPUTE_IMPLICIT_DIRS "${dir_var}" + COMPUTE_IMPLICIT_FWKS "${fwk_var}" ${ARGN}) + + set(${lib_var} "${${lib_var}}" PARENT_SCOPE) + set(${dir_var} "${${dir_var}}" PARENT_SCOPE) + set(${fwk_var} "${${fwk_var}}" PARENT_SCOPE) + set(${log_var} "${${log_var}}" PARENT_SCOPE) + + if(EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS) + set(${EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS} "${${EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS}}" PARENT_SCOPE) + endif() +endfunction() + +function(cmake_parse_implicit_link_info2 text log_var obj_regex) set(implicit_libs_tmp "") set(implicit_objs_tmp "") set(implicit_dirs_tmp) @@ -22,25 +42,29 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj set(log "") set(keywordArgs) - set(oneValueArgs COMPUTE_IMPLICIT_OBJECTS LANGUAGE) + set(oneValueArgs LANGUAGE + COMPUTE_IMPLICIT_LIBS COMPUTE_IMPLICIT_DIRS COMPUTE_IMPLICIT_FWKS + COMPUTE_IMPLICIT_OBJECTS COMPUTE_LINKER) set(multiValueArgs ) cmake_parse_arguments(EXTRA_PARSE "${keywordArgs}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) set(is_msvc 0) if(EXTRA_PARSE_LANGUAGE AND - ("x${CMAKE_${EXTRA_PARSE_LANGUAGE}_ID}" STREQUAL "xMSVC" OR + ("x${CMAKE_${EXTRA_PARSE_LANGUAGE}_COMPILER_ID}" STREQUAL "xMSVC" OR "x${CMAKE_${EXTRA_PARSE_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC")) set(is_msvc 1) endif() - # Parse implicit linker arguments. - set(linker "CMAKE_LINKER-NOTFOUND") - if(CMAKE_LINKER) - get_filename_component(linker ${CMAKE_LINKER} NAME) - string(REGEX REPLACE "([][+.*?()^$])" "\\\\\\1" linker "${linker}") - endif() + set(linker "ld[0-9]*(\\.[a-z]+)?") if(is_msvc) - string(APPEND linker "|link\\.exe|lld-link") + string(APPEND linker "|link\\.exe|lld-link(\\.exe)?") + endif() + if(CMAKE_LINKER) + get_filename_component(default_linker ${CMAKE_LINKER} NAME) + if (NOT default_linker MATCHES "(${linker})") + string(REGEX REPLACE "([][+.*?()^$])" "\\\\\\1" default_linker "${default_linker}") + list(PREPEND linker "${default_linker}|") + endif() endif() set(startfile "CMAKE_LINK_STARTFILE-NOTFOUND") if(CMAKE_LINK_STARTFILE) @@ -50,9 +74,43 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj # whole line and just the command (argv[0]). set(linker_regex "^( *|.*[/\\])(${linker}|${startfile}|([^/\\]+-)?ld|collect2)[^/\\]*( |$)") set(linker_exclude_regex "collect2 version |^[A-Za-z0-9_]+=|/ldfe ") + set(linker_tool_regex "^[ \t]*(->|\")?[ \t]*(([^\"]*[/\\])?(${linker}))(\"|,| |$)") + set(linker_tool_exclude_regex "cuda-fake-ld|-fuse-ld=") + set(linker_tool "NOTFOUND") + set(linker_tool_fallback "") + set(link_line_parsed 0) string(APPEND log " link line regex: [${linker_regex}]\n") + if(EXTRA_PARSE_COMPUTE_LINKER) + string(APPEND log " linker tool regex: [${linker_tool_regex}]\n") + endif() string(REGEX REPLACE "\r?\n" ";" output_lines "${text}") foreach(line IN LISTS output_lines) + if(EXTRA_PARSE_COMPUTE_LINKER AND + NOT linker_tool AND NOT "${line}" MATCHES "${linker_tool_exclude_regex}") + if("${line}" MATCHES "exec: ([^()]*/(${linker}))") # IBM XL as nvcc host compiler + set(linker_tool "${CMAKE_MATCH_1}") + elseif("${line}" MATCHES "^export XL_LINKER=(.*/${linker})[ \t]*$") # IBM XL + set(linker_tool "${CMAKE_MATCH_1}") + elseif("${line}" MATCHES "--with-ld=") # GNU + # The GNU compiler reports how it was configured. + # This does not account for -fuse-ld= so use it only as a fallback. + if("${line}" MATCHES " --with-ld=([^ ]+/${linker})( |$)") + set(linker_tool_fallback "${CMAKE_MATCH_1}") + endif() + elseif("${line}" MATCHES "vs_link.*-- +([^\"]*[/\\](${linker})) ") # cmake -E vs_link_exe + set(linker_tool "${CMAKE_MATCH_1}") + elseif("${line}" MATCHES "${linker_tool_regex}") + set(linker_tool "${CMAKE_MATCH_2}") + endif() + endif() + if(NOT (EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS OR EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS + OR EXTRA_PARSE_COMPUTE_IMPLICIT_FWKS OR EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS)) + if(linker_tool) + break() + else() + continue() + endif() + endif() set(cmd) if("${line}" MATCHES "${linker_regex}" AND NOT "${line}" MATCHES "${linker_exclude_regex}") @@ -86,7 +144,8 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj endif() endif() set(search_static 0) - if("${cmd}" MATCHES "${linker_regex}") + if(NOT link_line_parsed AND "${cmd}" MATCHES "${linker_regex}") + set(link_line_parsed 1) string(APPEND log " link line: [${line}]\n") string(REGEX REPLACE ";-([LYz]);" ";-\\1" args "${args}") set(skip_value_of "") @@ -95,60 +154,78 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj string(APPEND log " arg [${arg}] ==> skip value of ${skip_value_of}\n") set(skip_value_of "") elseif("${arg}" MATCHES "^-L(.:)?[/\\]") - # Unix search path. - string(REGEX REPLACE "^-L" "" dir "${arg}") - list(APPEND implicit_dirs_tmp ${dir}) - string(APPEND log " arg [${arg}] ==> dir [${dir}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS) + # Unix search path. + string(REGEX REPLACE "^-L" "" dir "${arg}") + list(APPEND implicit_dirs_tmp ${dir}) + string(APPEND log " arg [${arg}] ==> dir [${dir}]\n") + endif() elseif("${arg}" MATCHES "^[-/](LIBPATH|libpath):(.+)") - # MSVC search path. - set(dir "${CMAKE_MATCH_2}") - list(APPEND implicit_dirs_tmp ${dir}) - string(APPEND log " arg [${arg}] ==> dir [${dir}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS) + # MSVC search path. + set(dir "${CMAKE_MATCH_2}") + list(APPEND implicit_dirs_tmp ${dir}) + string(APPEND log " arg [${arg}] ==> dir [${dir}]\n") + endif() elseif(is_msvc AND "${arg}" STREQUAL "-link") string(APPEND log " arg [${arg}] ==> ignore MSVC cl option\n") elseif(is_msvc AND "${arg}" MATCHES "^[-/][Ii][Mm][Pp][Ll][Ii][Bb]:") string(APPEND log " arg [${arg}] ==> ignore MSVC link option\n") + elseif(is_msvc AND "${arg}" MATCHES "^[-/][Ww][Hh][Oo][Ll][Ee][Aa][Rr][Cc][Hh][Ii][Vv][Ee]:Fortran_main") + string(APPEND log " arg [${arg}] ==> ignore LLVMFlang program entry point\n") elseif(is_msvc AND "${arg}" MATCHES "^(.*\\.[Ll][Ii][Bb])$") - set(lib "${CMAKE_MATCH_1}") - list(APPEND implicit_libs_tmp ${lib}) - string(APPEND log " arg [${arg}] ==> lib [${lib}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + set(lib "${CMAKE_MATCH_1}") + list(APPEND implicit_libs_tmp ${lib}) + string(APPEND log " arg [${arg}] ==> lib [${lib}]\n") + endif() elseif("${arg}" STREQUAL "-lto_library") # ld argument "-lto_library <path>" set(skip_value_of "${arg}") string(APPEND log " arg [${arg}] ==> ignore, skip following value\n") elseif("${arg}" MATCHES "^-l([^:].*)$") - # Unix library. - set(lib "${CMAKE_MATCH_1}") - if(search_static AND lib MATCHES "^(gfortran|stdc\\+\\+)$") - # Search for the static library later, once all link dirs are known. - set(lib "SEARCH_STATIC:${lib}") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + # Unix library. + set(lib "${CMAKE_MATCH_1}") + if(search_static AND lib MATCHES "^(gfortran|stdc\\+\\+)$") + # Search for the static library later, once all link dirs are known. + set(lib "SEARCH_STATIC:${lib}") + endif() + list(APPEND implicit_libs_tmp ${lib}) + string(APPEND log " arg [${arg}] ==> lib [${lib}]\n") endif() - list(APPEND implicit_libs_tmp ${lib}) - string(APPEND log " arg [${arg}] ==> lib [${lib}]\n") elseif("${arg}" MATCHES "^(.:)?[/\\].*\\.a$") - # Unix library full path. - list(APPEND implicit_libs_tmp ${arg}) - string(APPEND log " arg [${arg}] ==> lib [${arg}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + # Unix library full path. + list(APPEND implicit_libs_tmp ${arg}) + string(APPEND log " arg [${arg}] ==> lib [${arg}]\n") + endif() elseif("${arg}" MATCHES "^[-/](DEFAULTLIB|defaultlib):(.+)") - # Windows library. - set(lib "${CMAKE_MATCH_2}") - list(APPEND implicit_libs_tmp ${lib}) - string(APPEND log " arg [${arg}] ==> lib [${lib}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + # Windows library. + set(lib "${CMAKE_MATCH_2}") + list(APPEND implicit_libs_tmp ${lib}) + string(APPEND log " arg [${arg}] ==> lib [${lib}]\n") + endif() elseif("${arg}" MATCHES "^(.:)?[/\\].*\\.o$") if(EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS) list(APPEND implicit_objs_tmp ${arg}) string(APPEND log " arg [${arg}] ==> obj [${arg}]\n") endif() - if(obj_regex AND "${arg}" MATCHES "${obj_regex}") - # Object file full path. - list(APPEND implicit_libs_tmp ${arg}) + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + if(obj_regex AND "${arg}" MATCHES "${obj_regex}") + # Object file full path. + list(APPEND implicit_libs_tmp ${arg}) + endif() endif() elseif("${arg}" MATCHES "^-Y(P,)?[^0-9]") - # Sun search path ([^0-9] avoids conflict with Mac -Y<num>). - string(REGEX REPLACE "^-Y(P,)?" "" dirs "${arg}") - string(REPLACE ":" ";" dirs "${dirs}") - list(APPEND implicit_dirs_tmp ${dirs}) - string(APPEND log " arg [${arg}] ==> dirs [${dirs}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS) + # Sun search path ([^0-9] avoids conflict with Mac -Y<num>). + string(REGEX REPLACE "^-Y(P,)?" "" dirs "${arg}") + string(REPLACE ":" ";" dirs "${dirs}") + list(APPEND implicit_dirs_tmp ${dirs}) + string(APPEND log " arg [${arg}] ==> dirs [${dirs}]\n") + endif() elseif("${arg}" STREQUAL "-Bstatic") set(search_static 1) string(APPEND log " arg [${arg}] ==> search static\n" ) @@ -156,13 +233,17 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj set(search_static 0) string(APPEND log " arg [${arg}] ==> search dynamic\n" ) elseif("${arg}" MATCHES "^-l:") - # HP named library. - list(APPEND implicit_libs_tmp ${arg}) - string(APPEND log " arg [${arg}] ==> lib [${arg}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + # HP named library. + list(APPEND implicit_libs_tmp ${arg}) + string(APPEND log " arg [${arg}] ==> lib [${arg}]\n") + endif() elseif("${arg}" MATCHES "^-z(all|default|weak)extract") - # Link editor option. - list(APPEND implicit_libs_tmp ${arg}) - string(APPEND log " arg [${arg}] ==> opt [${arg}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + # Link editor option. + list(APPEND implicit_libs_tmp ${arg}) + string(APPEND log " arg [${arg}] ==> opt [${arg}]\n") + endif() elseif("${arg}" STREQUAL "cl.exe") string(APPEND log " arg [${arg}] ==> recognize MSVC cl\n") set(is_msvc 1) @@ -170,25 +251,39 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj string(APPEND log " arg [${arg}] ==> ignore\n") endif() endforeach() - break() elseif("${line}" MATCHES "LPATH(=| is:? *)(.*)$") - string(APPEND log " LPATH line: [${line}]\n") - # HP search path. - string(REPLACE ":" ";" paths "${CMAKE_MATCH_2}") - list(APPEND implicit_dirs_tmp ${paths}) - string(APPEND log " dirs [${paths}]\n") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS) + string(APPEND log " LPATH line: [${line}]\n") + # HP search path. + string(REPLACE ":" ";" paths "${CMAKE_MATCH_2}") + list(APPEND implicit_dirs_tmp ${paths}) + string(APPEND log " dirs [${paths}]\n") + endif() else() string(APPEND log " ignore line: [${line}]\n") endif() + if((NOT EXTRA_PARSE_COMPUTE_LINKER OR linker_tool) AND link_line_parsed) + break() + endif() endforeach() + if(NOT linker_tool AND linker_tool_fallback) + set(linker_tool "${linker_tool_fallback}") + endif() + if(linker_tool) + if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + cmake_path(NORMAL_PATH linker_tool) + endif() + string(APPEND log " linker tool for '${EXTRA_PARSE_LANGUAGE}': ${linker_tool}\n") + endif() + # Look for library search paths reported by linker. - if("${output_lines}" MATCHES ";Library search paths:((;\t[^;]+)+)") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS AND "${output_lines}" MATCHES ";Library search paths:((;\t[^;]+)+)") string(REPLACE ";\t" ";" implicit_dirs_match "${CMAKE_MATCH_1}") string(APPEND log " Library search paths: [${implicit_dirs_match}]\n") list(APPEND implicit_dirs_tmp ${implicit_dirs_match}) endif() - if("${output_lines}" MATCHES ";Framework search paths:((;\t[^;]+)+)") + if(EXTRA_PARSE_COMPUTE_IMPLICIT_FWKS AND "${output_lines}" MATCHES ";Framework search paths:((;\t[^;]+)+)") string(REPLACE ";\t" ";" implicit_fwks_match "${CMAKE_MATCH_1}") string(APPEND log " Framework search paths: [${implicit_fwks_match}]\n") list(APPEND implicit_fwks_tmp ${implicit_fwks_match}) @@ -273,11 +368,21 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj string(APPEND log " implicit fwks: [${implicit_fwks}]\n") # Return results. - set(${lib_var} "${implicit_libs}" PARENT_SCOPE) - set(${dir_var} "${implicit_dirs}" PARENT_SCOPE) - set(${fwk_var} "${implicit_fwks}" PARENT_SCOPE) + if(EXTRA_PARSE_COMPUTE_LINKER) + set(${EXTRA_PARSE_COMPUTE_LINKER} "${linker_tool}" PARENT_SCOPE) + endif() + set(${log_var} "${log}" PARENT_SCOPE) + if(EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS) + set(${EXTRA_PARSE_COMPUTE_IMPLICIT_LIBS} "${implicit_libs}" PARENT_SCOPE) + endif() + if(EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS) + set(${EXTRA_PARSE_COMPUTE_IMPLICIT_DIRS} "${implicit_dirs}" PARENT_SCOPE) + endif() + if(EXTRA_PARSE_COMPUTE_IMPLICIT_FWKS) + set(${EXTRA_PARSE_COMPUTE_IMPLICIT_FWKS} "${implicit_fwks}" PARENT_SCOPE) + endif() if(EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS) set(${EXTRA_PARSE_COMPUTE_IMPLICIT_OBJECTS} "${implicit_objs}" PARENT_SCOPE) endif() diff --git a/Modules/CMakePlatformId.h.in b/Modules/CMakePlatformId.h.in index 32b7166..fd0367e 100644 --- a/Modules/CMakePlatformId.h.in +++ b/Modules/CMakePlatformId.h.in @@ -219,6 +219,14 @@ # define ARCHITECTURE_ID "" # endif +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "Arm" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + #elif defined(__TI_COMPILER_VERSION__) # if defined(__TI_ARM__) # define ARCHITECTURE_ID "ARM" diff --git a/Modules/CMakeSwiftInformation.cmake b/Modules/CMakeSwiftInformation.cmake index 1c6f0df..f8b6748 100644 --- a/Modules/CMakeSwiftInformation.cmake +++ b/Modules/CMakeSwiftInformation.cmake @@ -56,6 +56,7 @@ set(CMAKE_Swift_LIBRARY_PATH_TERMINATOR "") set(CMAKE_Swift_LINK_LIBRARY_FLAG "-l") set(CMAKE_Swift_LINKER_WRAPPER_FLAG "-Xlinker" " ") set(CMAKE_Swift_RESPONSE_FILE_LINK_FLAG @) +set(CMAKE_Swift_RESPONSE_FILE_FLAG @) set(CMAKE_Swift_LINKER_PREFERENCE 50) set(CMAKE_Swift_LINKER_PREFERENCE_PROPAGATES 1) @@ -68,30 +69,42 @@ set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL -libc MD) set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug -libc MTd) set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL -libc MDd) +set(CMAKE_Swift_FLAGS_DEBUG_INIT "-Onone -g") +set(CMAKE_Swift_FLAGS_RELEASE_INIT "-O") +set(CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT "-O -g") +set(CMAKE_Swift_FLAGS_MINSIZEREL_INIT "-Osize") + if(CMAKE_GENERATOR STREQUAL "Xcode") + string(APPEND CMAKE_Swift_FLAGS_DEBUG_INIT " ${CMAKE_Swift_FLAGS_DEBUG_LINKER_FLAGS}") + string(APPEND CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT " ${CMAKE_Swift_FLAGS_RELWITHDEBINFO_LINKER_FLAGS}") +endif() + +# Warns if unset and uses old policy. +# Old policy flag-smashes the wmo and incremental flags onto the compiler flags. +# New policy respects the Swift_COMPILATION_MODE target property to add +# incremental and wholemodule optimization flags as appropriate. +cmake_policy(GET CMP0157 __SWIFT_COMP_MODE_CMP0157) +if(__SWIFT_COMP_MODE_CMP0157 STREQUAL "NEW") + set(CMAKE_Swift_COMPILATION_MODE_DEFAULT "incremental") +else() # Xcode has a separate Xcode project option (SWIFT_COMPILATION_MODE) used to set # whether compiling with whole-module optimizations or incrementally. Setting # these options here will have no effect when compiling with the built-in driver, # and will explode violently, leaving build products in the source directory, when - # using the old swift driver. - set(CMAKE_Swift_FLAGS_DEBUG_INIT "-Onone -g ${CMAKE_Swift_FLAGS_DEBUG_LINKER_FLAGS}") - set(CMAKE_Swift_FLAGS_RELEASE_INIT "-O") - set(CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT "-O -g ${CMAKE_Swift_FLAGS_RELWITHDEBINFO_LINKER_FLAGS}") - set(CMAKE_Swift_FLAGS_MINSIZEREL_INIT "-Osize") -else() - set(CMAKE_Swift_FLAGS_DEBUG_INIT "-Onone -g -incremental") - set(CMAKE_Swift_FLAGS_RELEASE_INIT "-O") - set(CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT "-O -g") - set(CMAKE_Swift_FLAGS_MINSIZEREL_INIT "-Osize") - - # Enable Whole Module Optimization by default unless the old - # C++ driver is being used, which behaves differently under WMO. - if(NOT CMAKE_Swift_COMPILER_USE_OLD_DRIVER) - string(APPEND CMAKE_Swift_FLAGS_RELEASE_INIT " -wmo") - string(APPEND CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT " -wmo") - string(APPEND CMAKE_Swift_FLAGS_MINSIZEREL_INIT " -wmo") + # using the old swift driver. Don't append `-incremental` or `-wmo` to the + # flags in the Xcode generator. + if(NOT CMAKE_GENERATOR STREQUAL "Xcode") + # Enable Whole Module Optimization by default unless the old + # C++ driver is being used, which behaves differently under WMO. + if(NOT CMAKE_Swift_COMPILER_USE_OLD_DRIVER) + string(APPEND CMAKE_Swift_FLAGS_RELEASE_INIT " -wmo") + string(APPEND CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT " -wmo") + string(APPEND CMAKE_Swift_FLAGS_MINSIZEREL_INIT " -wmo") + endif() + string(APPEND CMAKE_Swift_FLAGS_DEBUG_INIT " -incremental") endif() endif() +unset(__SWIFT_COMP_MODE_CMP0157) if(CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF") if(NOT DEFINED CMAKE_Swift_LINK_WHAT_YOU_USE_FLAG) @@ -104,36 +117,66 @@ endif() cmake_initialize_per_config_variable(CMAKE_Swift_FLAGS "Swift Compiler Flags") -# NOTE(compnerd) we do not have an object compile rule since we build the objects as part of the link step -if(NOT CMAKE_Swift_COMPILE_OBJECT) - set(CMAKE_Swift_COMPILE_OBJECT ":") -endif() - if(NOT CMAKE_Swift_NUM_THREADS MATCHES "^[0-9]+$") cmake_host_system_information(RESULT CMAKE_Swift_NUM_THREADS QUERY NUMBER_OF_LOGICAL_CORES) endif() -if(NOT CMAKE_Swift_CREATE_SHARED_LIBRARY) - set(CMAKE_Swift_CREATE_SHARED_LIBRARY "<CMAKE_Swift_COMPILER> -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-library -o <TARGET> -module-name <SWIFT_MODULE_NAME> -module-link-name <SWIFT_LIBRARY_NAME> -emit-module -emit-module-path <SWIFT_MODULE> -emit-dependencies <DEFINES> <FLAGS> <INCLUDES> <SWIFT_SOURCES> <LINK_FLAGS> <SONAME_FLAG> <TARGET_INSTALLNAME_DIR><TARGET_SONAME> ${CMAKE_Swift_IMPLIB_LINKER_FLAGS} <LINK_LIBRARIES>") -endif() +# Swift split-compilation requires CMP0157 NEW policy +if(CMAKE_Swift_COMPILATION_MODE_DEFAULT) + set(CMAKE_Swift_PARALLEL_FLAGS "-j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS}") + if(NOT CMAKE_Swift_COMPILE_OBJECT) + # Omit the object output. The output is controlled by the output-file-map + # for normal builds. For wholemodule builds, CMake appends the appropriate + # flags. + set(CMAKE_Swift_COMPILE_OBJECT "<CMAKE_Swift_COMPILER> ${CMAKE_Swift_PARALLEL_FLAGS} -c <DEFINES> <FLAGS> <INCLUDES> <SOURCE>") + endif() -if(NOT CMAKE_Swift_CREATE_SHARED_MODULE) - set(CMAKE_Swift_CREATE_SHARED_MODULE ${CMAKE_Swift_CREATE_SHARED_LIBRARY}) -endif() + if(NOT CMAKE_Swift_CREATE_SHARED_LIBRARY) + set(CMAKE_Swift_CREATE_SHARED_LIBRARY "<CMAKE_Swift_COMPILER> ${CMAKE_Swift_PARALLEL_FLAGS} -emit-library <CMAKE_SHARED_LIBRARY_Swift_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> ${CMAKE_Swift_IMPLIB_LINKER_FLAGS} <SONAME_FLAG> <TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>") + endif() -if(NOT CMAKE_Swift_LINK_EXECUTABLE) - set(CMAKE_Swift_LINK_EXECUTABLE "<CMAKE_Swift_COMPILER> -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-executable -o <TARGET> -emit-dependencies <DEFINES> <FLAGS> <INCLUDES> <SWIFT_SOURCES> <LINK_FLAGS> <LINK_LIBRARIES>") -endif() + if(NOT CMAKE_Swift_CREATE_SHARED_MODULE) + set(CMAKE_Swift_CREATE_SHARED_MODULE ${CMAKE_Swift_CREATE_SHARED_LIBRARY}) + endif() -if(NOT CMAKE_Swift_LINK_EXECUTABLE_WITH_EXPORTS) - set(CMAKE_Swift_LINK_EXECUTABLE_WITH_EXPORTS "${CMAKE_Swift_LINK_EXECUTABLE} -emit-module -emit-module-path <SWIFT_MODULE> ${CMAKE_Swift_IMPLIB_LINKER_FLAGS}") -endif() + if(NOT CMAKE_Swift_LINK_EXECUTABLE) + set(CMAKE_Swift_LINK_EXECUTABLE "<CMAKE_Swift_COMPILER> ${CMAKE_Swift_PARALLEL_FLAGS} -emit-executable -o <TARGET> <FLAGS> <OBJECTS> <LINK_FLAGS> <LINK_LIBRARIES>") + endif() + + if(NOT CMAKE_Swift_CREATE_STATIC_LIBRARY) + set(CMAKE_Swift_CREATE_STATIC_LIBRARY "<CMAKE_Swift_COMPILER> -emit-library -static -o <TARGET> <OBJECTS> <LINK_FLAGS>") + set(CMAKE_Swift_ARCHIVE_CREATE "<CMAKE_AR> crs <TARGET> <OBJECTS>") + set(CMAKE_Swift_ARCHIVE_FINISH "") + endif() + unset(CMAKE_Swift_PARALLEL_FLAGS) +else() + # NOTE(compnerd) we do not have an object compile rule since we build the objects as part of the link step + if(NOT CMAKE_Swift_COMPILE_OBJECT) + set(CMAKE_Swift_COMPILE_OBJECT ":") + endif() + + if(NOT CMAKE_Swift_CREATE_SHARED_LIBRARY) + set(CMAKE_Swift_CREATE_SHARED_LIBRARY "<CMAKE_Swift_COMPILER> -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-library -o <TARGET> -module-name <SWIFT_MODULE_NAME> -module-link-name <SWIFT_LIBRARY_NAME> -emit-module -emit-module-path <SWIFT_MODULE> -emit-dependencies <DEFINES> <FLAGS> <INCLUDES> <SWIFT_SOURCES> <LINK_FLAGS> <SONAME_FLAG> <TARGET_INSTALLNAME_DIR><TARGET_SONAME> ${CMAKE_Swift_IMPLIB_LINKER_FLAGS} <LINK_LIBRARIES>") + endif() -if(NOT CMAKE_Swift_CREATE_STATIC_LIBRARY) - set(CMAKE_Swift_CREATE_STATIC_LIBRARY "<CMAKE_Swift_COMPILER> -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-library -static -o <TARGET> -module-name <SWIFT_MODULE_NAME> -module-link-name <SWIFT_LIBRARY_NAME> -emit-module -emit-module-path <SWIFT_MODULE> -emit-dependencies <DEFINES> <FLAGS> <INCLUDES> <SWIFT_SOURCES> <LINK_FLAGS> <LINK_LIBRARIES>") + if(NOT CMAKE_Swift_CREATE_SHARED_MODULE) + set(CMAKE_Swift_CREATE_SHARED_MODULE ${CMAKE_Swift_CREATE_SHARED_LIBRARY}) + endif() + + if(NOT CMAKE_Swift_LINK_EXECUTABLE) + set(CMAKE_Swift_LINK_EXECUTABLE "<CMAKE_Swift_COMPILER> -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-executable -o <TARGET> -emit-dependencies <DEFINES> <FLAGS> <INCLUDES> <SWIFT_SOURCES> <LINK_FLAGS> <LINK_LIBRARIES>") + endif() - set(CMAKE_Swift_ARCHIVE_CREATE "<CMAKE_AR> crs <TARGET> <OBJECTS>") - set(CMAKE_Swift_ARCHIVE_FINISH "") + if(NOT CMAKE_Swift_LINK_EXECUTABLE_WITH_EXPORTS) + set(CMAKE_Swift_LINK_EXECUTABLE_WITH_EXPORTS "${CMAKE_Swift_LINK_EXECUTABLE} -emit-module -emit-module-path <SWIFT_MODULE> ${CMAKE_Swift_IMPLIB_LINKER_FLAGS}") + endif() + + if(NOT CMAKE_Swift_CREATE_STATIC_LIBRARY) + set(CMAKE_Swift_CREATE_STATIC_LIBRARY "<CMAKE_Swift_COMPILER> -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-library -static -o <TARGET> -module-name <SWIFT_MODULE_NAME> -module-link-name <SWIFT_LIBRARY_NAME> -emit-module -emit-module-path <SWIFT_MODULE> -emit-dependencies <DEFINES> <FLAGS> <INCLUDES> <SWIFT_SOURCES> <LINK_FLAGS> <LINK_LIBRARIES>") + + set(CMAKE_Swift_ARCHIVE_CREATE "<CMAKE_AR> crs <TARGET> <OBJECTS>") + set(CMAKE_Swift_ARCHIVE_FINISH "") + endif() endif() set(CMAKE_Swift_INFORMATION_LOADED 1) diff --git a/Modules/CPack.cmake b/Modules/CPack.cmake index ff1cb7e..813ac3c 100644 --- a/Modules/CPack.cmake +++ b/Modules/CPack.cmake @@ -866,6 +866,7 @@ if(NOT DEFINED CPACK_DMG_SLA_USE_RESOURCE_FILE_LICENSE "${_CMP0133_warning}\n" "For compatibility, CMake will enable the SLA in the CPack DragNDrop Generator." ) + unset(_CMP0133_warning) endif() _cpack_set_default(CPACK_DMG_SLA_USE_RESOURCE_FILE_LICENSE ON) endif() @@ -882,6 +883,24 @@ endif() # WiX specific variables _cpack_set_default(CPACK_WIX_SIZEOF_VOID_P "${CMAKE_SIZEOF_VOID_P}") +# productbuild specific variables +cmake_policy(GET CMP0161 _CPack_CMP0161) +if("x${_CPack_CMP0161}x" STREQUAL "xNEWx") + _cpack_set_default(CPACK_PRODUCTBUILD_DOMAINS ON) +elseif(APPLE AND CPACK_BINARY_PRODUCTBUILD AND + NOT DEFINED CPACK_PRODUCTBUILD_DOMAINS AND + NOT "x${_CPack_CMP0161}x" STREQUAL "xOLDx") + cmake_policy(GET_WARNING CMP0161 _CMP0161_warning) + message(AUTHOR_WARNING + "${_CMP0161_warning}\n" + "For compatibility, CPACK_PRODUCTBUILD_DOMAINS will remain unset. " + "Explicitly setting CPACK_PRODUCTBUILD_DOMAINS or setting policy CMP0161 " + "to NEW will prevent this warning." + ) + unset(_CMP0161_warning) +endif() +unset(_CPack_CMP0161) + # set sysroot so SDK tools can be used if(CMAKE_OSX_SYSROOT) _cpack_set_default(CPACK_OSX_SYSROOT "${_CMAKE_OSX_SYSROOT_PATH}") diff --git a/Modules/CSharpUtilities.cmake b/Modules/CSharpUtilities.cmake index dedb146..b5520ef 100644 --- a/Modules/CSharpUtilities.cmake +++ b/Modules/CSharpUtilities.cmake @@ -64,7 +64,7 @@ Main functions provided by the module Sets source file properties of ``.Designer.cs`` files depending on sibling filenames. Use this, if your CSharp target does **not** use Windows Forms (for Windows Forms use - :command:`csharp_set_designer_cs_properties` instead):: + :command:`csharp_set_windows_forms_properties` instead):: csharp_set_designer_cs_properties([<file1> [<file2> [...]]]) diff --git a/Modules/CheckIPOSupported/main.c b/Modules/CheckIPOSupported/main.c index 5be0864..8d2ab01 100644 --- a/Modules/CheckIPOSupported/main.c +++ b/Modules/CheckIPOSupported/main.c @@ -1,6 +1,6 @@ int foo(); -int main() +int main(void) { return foo(); } diff --git a/Modules/Compiler/ADSP-ASM.cmake b/Modules/Compiler/ADSP-ASM.cmake new file mode 100644 index 0000000..9ef5142 --- /dev/null +++ b/Modules/Compiler/ADSP-ASM.cmake @@ -0,0 +1,6 @@ +include(Compiler/ADSP) +__compiler_adsp(ASM) + +set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS asm) +set(CMAKE_ASM_OUTPUT_EXTENSION ".o" ) +set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> <SOURCE>") diff --git a/Modules/Compiler/ADSP.cmake b/Modules/Compiler/ADSP.cmake index 62566a0..39dcf39 100644 --- a/Modules/Compiler/ADSP.cmake +++ b/Modules/Compiler/ADSP.cmake @@ -10,6 +10,8 @@ macro(__compiler_adsp lang) set(_CMAKE_${lang}_ADSP_FLAGS "-proc=${CMAKE_ADSP_PROCESSOR}") + set(CMAKE_DEPFILE_FLAGS_${lang} "-MD -Mo <DEP_FILE>") + set(CMAKE_${lang}_COMPILE_OBJECT "<CMAKE_${lang}_COMPILER> ${_CMAKE_${lang}_ADSP_FLAGS} <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE>") diff --git a/Modules/Compiler/Clang.cmake b/Modules/Compiler/Clang.cmake index 4c033ca..2452d5e 100644 --- a/Modules/Compiler/Clang.cmake +++ b/Modules/Compiler/Clang.cmake @@ -17,6 +17,7 @@ set(__pch_header_OBJCXX "objective-c++-header") if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC" + OR "x${CMAKE_CUDA_SIMULATE_ID}" STREQUAL "xMSVC" OR "x${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "xMSVC") macro(__compiler_clang lang) endmacro() @@ -94,11 +95,11 @@ else() endif() set(CMAKE_${lang}_ARCHIVE_CREATE_IPO - "\"${__ar}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${__ar}\" qc <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_APPEND_IPO - "\"${__ar}\" r <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${__ar}\" q <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_FINISH_IPO diff --git a/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake b/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake deleted file mode 100644 index 2265e5e..0000000 --- a/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake +++ /dev/null @@ -1,7 +0,0 @@ - -set(_compiler_id_pp_test "defined(__COMO__)") - -set(_compiler_id_version_compute " - /* __COMO_VERSION__ = VRR */ -# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__COMO_VERSION__ / 100) -# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__COMO_VERSION__ % 100)") diff --git a/Modules/Compiler/GNU-Fortran.cmake b/Modules/Compiler/GNU-Fortran.cmake index 5dfb03e..452598b 100644 --- a/Modules/Compiler/GNU-Fortran.cmake +++ b/Modules/Compiler/GNU-Fortran.cmake @@ -17,10 +17,6 @@ endif() set(CMAKE_Fortran_POSTPROCESS_FLAG "-fpreprocessed") -# No -DNDEBUG for Fortran. -string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " -Os") -string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3") - # No -isystem for Fortran because it will not find .mod files. unset(CMAKE_INCLUDE_SYSTEM_FLAG_Fortran) diff --git a/Modules/Compiler/GNU.cmake b/Modules/Compiler/GNU.cmake index d01054b..138bb4b 100644 --- a/Modules/Compiler/GNU.cmake +++ b/Modules/Compiler/GNU.cmake @@ -74,36 +74,49 @@ macro(__compiler_gnu lang) if (NOT DEFINED CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED) ## check if this feature is supported by the linker - execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -Wl,--help - OUTPUT_VARIABLE _linker_capabilities - ERROR_VARIABLE _linker_capabilities) - if(_linker_capabilities MATCHES "--dependency-file") - set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED TRUE) + if (CMAKE_${lang}_COMPILER_LINKER AND CMAKE_${lang}_COMPILER_LINKER_ID MATCHES "GNU|LLD") + execute_process(COMMAND "${CMAKE_${lang}_COMPILER_LINKER}" --help + OUTPUT_VARIABLE _linker_capabilities + ERROR_VARIABLE _linker_capabilities) + if(_linker_capabilities MATCHES "--dependency-file") + set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED TRUE) + else() + set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED FALSE) + endif() + unset(_linker_capabilities) else() set(CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED FALSE) endif() - unset(_linker_capabilities) endif() endif() if (CMAKE_${lang}_LINKER_DEPFILE_SUPPORTED) set(CMAKE_${lang}_LINK_DEPENDS_USE_LINKER TRUE) else() - unset(CMAKE_${lang}_LINK_DEPENDS_USE_LINKER) + set(CMAKE_${lang}_LINK_DEPENDS_USE_LINKER FALSE) endif() - # For now, due to GNU binutils ld bug when LTO is enabled (see GNU bug - # `30568 <https://sourceware.org/bugzilla/show_bug.cgi?id=30568>`_), - # deactivate this feature. - if (NOT DEFINED CMAKE_LINK_DEPENDS_USE_LINKER) - set(CMAKE_LINK_DEPENDS_USE_LINKER FALSE) + # Due to GNU binutils ld bug when LTO is enabled (see GNU bug + # `30568 <https://sourceware.org/bugzilla/show_bug.cgi?id=30568>`_), + # deactivate this feature if the version is less than 2.41. + # For now, all known versions of gold linker have also this bug. + if (CMAKE_${lang}_COMPILER_LINKER_ID + AND (CMAKE_${lang}_COMPILER_LINKER_ID STREQUAL "GNUgold" + OR (CMAKE_${lang}_COMPILER_LINKER_ID STREQUAL "GNU" + AND CMAKE_${lang}_COMPILER_LINKER_VERSION VERSION_LESS "2.41"))) + set(CMAKE_${lang}_LINK_DEPENDS_USE_LINKER FALSE) endif() # Initial configuration flags. string(APPEND CMAKE_${lang}_FLAGS_INIT " ") string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g") - string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Os -DNDEBUG") - string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3 -DNDEBUG") - string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG") + string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Os") + string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3") + string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g") + if(NOT "x${lang}" STREQUAL "xFortran") + string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -DNDEBUG") + string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -DNDEBUG") + string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG") + endif() set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>") set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>") if(NOT APPLE OR NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4) # work around #4462 @@ -155,11 +168,11 @@ macro(__compiler_gnu lang) # # [1]: https://gcc.gnu.org/onlinedocs/gcc-4.9.4/gcc/Optimize-Options.html set(CMAKE_${lang}_ARCHIVE_CREATE_IPO - "\"${CMAKE_${lang}_COMPILER_AR}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${CMAKE_${lang}_COMPILER_AR}\" qc <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_APPEND_IPO - "\"${CMAKE_${lang}_COMPILER_AR}\" r <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${CMAKE_${lang}_COMPILER_AR}\" q <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_FINISH_IPO diff --git a/Modules/Compiler/IBMClang.cmake b/Modules/Compiler/IBMClang.cmake index 169a0f0..a43f788 100644 --- a/Modules/Compiler/IBMClang.cmake +++ b/Modules/Compiler/IBMClang.cmake @@ -58,11 +58,11 @@ macro(__compiler_ibmclang lang) set(__ranlib "${CMAKE_${lang}_COMPILER_RANLIB}") set(CMAKE_${lang}_ARCHIVE_CREATE_IPO - "\"${__ar}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${__ar}\" qc <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_APPEND_IPO - "\"${__ar}\" r <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${__ar}\" q <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_FINISH_IPO diff --git a/Modules/Compiler/IntelLLVM.cmake b/Modules/Compiler/IntelLLVM.cmake index f3c0bf4..5afb1ce 100644 --- a/Modules/Compiler/IntelLLVM.cmake +++ b/Modules/Compiler/IntelLLVM.cmake @@ -19,8 +19,8 @@ set(__pch_header_OBJCXX "objective-c++-header") macro(__compiler_intel_llvm_common lang) set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES) set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES) - set(CMAKE_${lang}_ARCHIVE_CREATE_IPO "\"${CMAKE_${lang}_COMPILER_AR}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>") - set(CMAKE_${lang}_ARCHIVE_APPEND_IPO "\"${CMAKE_${lang}_COMPILER_AR}\" r <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_CREATE_IPO "\"${CMAKE_${lang}_COMPILER_AR}\" qc <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_APPEND_IPO "\"${CMAKE_${lang}_COMPILER_AR}\" q <TARGET> <LINK_FLAGS> <OBJECTS>") set(CMAKE_${lang}_ARCHIVE_FINISH_IPO "\"${CMAKE_${lang}_COMPILER_RANLIB}\" <TARGET>") endmacro() @@ -36,6 +36,12 @@ if(CMAKE_HOST_WIN32) __compiler_intel_llvm_common(${lang}) set(CMAKE_${lang}_COMPILE_OPTIONS_IPO "-Qipo") set(CMAKE_${lang}_LINK_OPTIONS_IPO "-Qipo") + if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "2021.4") + set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-external:I") + if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "2022.2") + set(_CMAKE_INCLUDE_SYSTEM_FLAG_${lang}_WARNING "-external:W0 ") + endif () + endif () endmacro() else() # GNU-like diff --git a/Modules/Compiler/LCC-C.cmake b/Modules/Compiler/LCC-C.cmake index 3dd6e68..52c3bf3 100644 --- a/Modules/Compiler/LCC-C.cmake +++ b/Modules/Compiler/LCC-C.cmake @@ -12,18 +12,25 @@ endif() set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c) -set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90") -set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90") -set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON) +if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 1.23) + set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90") + set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90") + set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON) +endif() + set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99") set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99") set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON) -set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11") -set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11") -set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON) -set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17") -set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17") -set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x") -set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x") - -__compiler_check_default_language_standard(C 1.23 90 1.20 11 1.26 17) + +if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 1.20) + set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11") + set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11") + set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON) +endif() + +if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 1.26) + set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17") + set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17") +endif() + +__compiler_check_default_language_standard(C 1.17 89 1.23 99 1.26 17) diff --git a/Modules/Compiler/LCC-CXX.cmake b/Modules/Compiler/LCC-CXX.cmake index b3bdd3c..385947a 100644 --- a/Modules/Compiler/LCC-CXX.cmake +++ b/Modules/Compiler/LCC-CXX.cmake @@ -17,15 +17,27 @@ set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hi set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98") set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98") set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON) -set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11") -set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11") -set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON) -set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14") -set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14") -set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON) -set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17") -set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17") -set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a") -set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a") + +if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 1.20) + set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11") + set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11") + set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON) +endif() + +if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 1.21) + set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14") + set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14") + set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON) +endif() + +if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 1.24) + set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17") + set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17") +endif() + +if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 1.26) + set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a") + set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a") +endif() __compiler_check_default_language_standard(CXX 1.19 98 1.20 11 1.21 14 1.24 17 1.26 20) diff --git a/Modules/Compiler/LCC.cmake b/Modules/Compiler/LCC.cmake index f8c2084..2892ec6 100644 --- a/Modules/Compiler/LCC.cmake +++ b/Modules/Compiler/LCC.cmake @@ -65,11 +65,11 @@ macro(__compiler_lcc lang) set(CMAKE_${lang}_COMPILE_OPTIONS_IPO ${__lto_flags}) set(CMAKE_${lang}_ARCHIVE_CREATE_IPO - "\"${CMAKE_${lang}_COMPILER_AR}\" cr <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${CMAKE_${lang}_COMPILER_AR}\" qc <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_APPEND_IPO - "\"${CMAKE_${lang}_COMPILER_AR}\" r <TARGET> <LINK_FLAGS> <OBJECTS>" + "\"${CMAKE_${lang}_COMPILER_AR}\" q <TARGET> <LINK_FLAGS> <OBJECTS>" ) set(CMAKE_${lang}_ARCHIVE_FINISH_IPO diff --git a/Modules/Compiler/LLVMFlang-Fortran.cmake b/Modules/Compiler/LLVMFlang-Fortran.cmake index d27f094..0a432a9 100644 --- a/Modules/Compiler/LLVMFlang-Fortran.cmake +++ b/Modules/Compiler/LLVMFlang-Fortran.cmake @@ -15,6 +15,9 @@ set(CMAKE_Fortran_POSTPROCESS_FLAG "-ffixed-line-length-72") set(CMAKE_Fortran_COMPILE_OPTIONS_TARGET "--target=") +set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-Wl,") +set(CMAKE_Fortran_LINKER_WRAPPER_FLAG_SEP ",") + if(NOT "x${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "xMSVC") set(CMAKE_Fortran_VERBOSE_FLAG "-v") diff --git a/Modules/Compiler/TIClang-ASM.cmake b/Modules/Compiler/TIClang-ASM.cmake new file mode 100644 index 0000000..6bb07e3 --- /dev/null +++ b/Modules/Compiler/TIClang-ASM.cmake @@ -0,0 +1,9 @@ +include(Compiler/TIClang) + +set(CMAKE_ASM_OUTPUT_EXTENSION ".o") +set(CMAKE_ASM_OUTPUT_EXTENSION_REPLACE 1) + +set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -c -o <OBJECT> <SOURCE>") +set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS S;s;asm;msa) + +__compiler_ticlang(ASM) diff --git a/Modules/Compiler/TIClang-C-FeatureTests.cmake b/Modules/Compiler/TIClang-C-FeatureTests.cmake new file mode 100644 index 0000000..ef79229 --- /dev/null +++ b/Modules/Compiler/TIClang-C-FeatureTests.cmake @@ -0,0 +1 @@ +include(Compiler/Clang-C-FeatureTests) diff --git a/Modules/Compiler/TIClang-C.cmake b/Modules/Compiler/TIClang-C.cmake new file mode 100644 index 0000000..2721fef --- /dev/null +++ b/Modules/Compiler/TIClang-C.cmake @@ -0,0 +1,23 @@ +include(Compiler/Clang-C) +include(Compiler/TIClang) +__compiler_ticlang(C) + +if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_C) + # dependencies are computed by the compiler itself + set(CMAKE_C_DEPFILE_FORMAT gcc) + set(CMAKE_C_DEPENDS_USE_COMPILER TRUE) +endif() + +set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90") +set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90") +set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON) + +set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99") +set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99") +set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON) + +set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11") +set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11") +set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON) diff --git a/Modules/Compiler/TIClang-CXX-FeatureTests.cmake b/Modules/Compiler/TIClang-CXX-FeatureTests.cmake new file mode 100644 index 0000000..e038e80 --- /dev/null +++ b/Modules/Compiler/TIClang-CXX-FeatureTests.cmake @@ -0,0 +1 @@ +include(Compiler/Clang-CXX-FeatureTests) diff --git a/Modules/Compiler/TIClang-CXX.cmake b/Modules/Compiler/TIClang-CXX.cmake new file mode 100644 index 0000000..860bb42 --- /dev/null +++ b/Modules/Compiler/TIClang-CXX.cmake @@ -0,0 +1,25 @@ +include(Compiler/Clang-CXX) +include(Compiler/TIClang) +__compiler_ticlang(CXX) + +if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_CXX) + # dependencies are computed by the compiler itself + set(CMAKE_CXX_DEPFILE_FORMAT gcc) + set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE) +endif() + +set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98") +set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98") +set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON) + +set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11") +set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11") + +set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14") +set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14") +set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON) + +set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17") +set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17") diff --git a/Modules/Compiler/TIClang-DetermineCompiler.cmake b/Modules/Compiler/TIClang-DetermineCompiler.cmake new file mode 100644 index 0000000..2447fdf --- /dev/null +++ b/Modules/Compiler/TIClang-DetermineCompiler.cmake @@ -0,0 +1,10 @@ +# TI Clang-based Toolchains +set(_compiler_id_pp_test "defined(__clang__) && defined(__ti__)") + +set(_compiler_id_version_compute " + # define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__ti_major__) + # define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__ti_minor__) + # define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__ti_patchlevel__)") + +string(APPEND _compiler_id_version_compute " +# define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__ti_version__)") diff --git a/Modules/Compiler/TIClang.cmake b/Modules/Compiler/TIClang.cmake new file mode 100644 index 0000000..4965e62 --- /dev/null +++ b/Modules/Compiler/TIClang.cmake @@ -0,0 +1,30 @@ +if(__COMPILER_TICLANG) + return() +endif() +set(__COMPILER_TICLANG TRUE) + +include(Compiler/CMakeCommonCompilerMacros) + +# get linker supported cpu list +macro(__compiler_ticlang lang) + set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "-Xlinker ") + + set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>") + + set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>") + + set(CMAKE_${lang}_COMPILE_OBJECT "<CMAKE_${lang}_COMPILER> -c <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>") + + set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_${lang}_COMPILER> <FLAGS> -Xlinker --output_file=<TARGET> -Xlinker --map_file=<TARGET_NAME>.map -Xlinker --rom_model <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES>") + + set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> r <TARGET> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_FINISH "") + + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlinker" " ") + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP) +endmacro() + +set(CMAKE_EXECUTABLE_SUFFIX ".out") +set(CMAKE_LIBRARY_PATH_FLAG "-Wl,--search_path=") +set(CMAKE_LINK_LIBRARY_FLAG "-Wl,--library=") diff --git a/Modules/CompilerId/VS-Intel.vfproj.in b/Modules/CompilerId/VS-Intel.vfproj.in index 044dd20..fdd9d9d 100644 --- a/Modules/CompilerId/VS-Intel.vfproj.in +++ b/Modules/CompilerId/VS-Intel.vfproj.in @@ -13,7 +13,7 @@ Name="Debug|@id_platform@" OutputDirectory="." IntermediateDirectory="$(ConfigurationName)" - > + @id_UseCompiler@> <Tool Name="VFFortranCompilerTool" DebugInformationFormat="debugEnabled" diff --git a/Modules/ExternalProject.cmake b/Modules/ExternalProject.cmake index a5dceaa..8b10135 100644 --- a/Modules/ExternalProject.cmake +++ b/Modules/ExternalProject.cmake @@ -1518,6 +1518,21 @@ function(_ep_write_downloadfile_script netrc netrc_file ) + if("x${REMOTE}" STREQUAL "x") + message(FATAL_ERROR "REMOTE can't be empty") + endif() + if("x${LOCAL}" STREQUAL "x") + message(FATAL_ERROR "LOCAL can't be empty") + endif() + + # REMOTE could contain special characters that parse as separate arguments. + # Things like parentheses are legitimate characters in a URL, but would be + # seen as the start of a new unquoted argument by the cmake language parser. + # Avoid those special cases by preparing quoted strings for direct inclusion + # in the foreach() call that iterates over the set of URLs in REMOTE. + set(REMOTE "[====[${REMOTE}]====]") + string(REPLACE ";" "]====] [====[" REMOTE "${REMOTE}") + if(timeout) set(TIMEOUT_ARGS TIMEOUT ${timeout}) set(TIMEOUT_MSG "${timeout} seconds") @@ -1599,7 +1614,7 @@ function(_ep_write_downloadfile_script set(HTTP_HEADERS_ARGS "") if(NOT http_headers STREQUAL "") - foreach(header ${http_headers}) + foreach(header IN LISTS http_headers) string(PREPEND HTTP_HEADERS_ARGS "HTTPHEADER \"${header}\"\n " ) @@ -1724,7 +1739,7 @@ function(_ep_set_directories name) # Apply defaults and convert to absolute paths. set(places stamp download source binary install tmp) - foreach(var ${places}) + foreach(var IN LISTS places) string(TOUPPER "${var}" VAR) get_property(${var}_dir TARGET ${name} PROPERTY _EP_${VAR}_DIR) if(NOT ${var}_dir) @@ -1796,9 +1811,9 @@ endfunction() # macro(_ep_replace_location_tags target_name) set(vars ${ARGN}) - foreach(var ${vars}) - if(${var}) - foreach(dir + foreach(var IN LISTS vars) + if(var) + foreach(dir IN ITEMS SOURCE_DIR SOURCE_SUBDIR BINARY_DIR @@ -1828,7 +1843,7 @@ function(_ep_command_line_to_initial_cache if(force) set(forceArg "FORCE") endif() - foreach(line ${args}) + foreach(line IN LISTS args) if("${line}" MATCHES "^-D(.*)") set(line "${CMAKE_MATCH_1}") if(NOT "${setArg}" STREQUAL "") @@ -1884,7 +1899,7 @@ endfunction() function(ExternalProject_Get_Property name) - foreach(var ${ARGN}) + foreach(var IN LISTS ARGN) string(TOUPPER "${var}" VAR) get_property(is_set TARGET ${name} PROPERTY _EP_${VAR} SET) if(NOT is_set) @@ -1934,8 +1949,10 @@ function(_ep_get_build_command set(args) _ep_get_configure_command_id(${name} cfg_cmd_id) if(cfg_cmd_id STREQUAL "cmake") - # CMake project. Select build command based on generator. - get_target_property(cmake_generator ${name} _EP_CMAKE_GENERATOR) + # Adding a CMake project as an External Project. Select command based on generator + get_property(cmake_generator TARGET ${name} PROPERTY _EP_CMAKE_GENERATOR) + # cmake_generator is the CMake generator of the ExternalProject target being added + # CMAKE_GENERATOR is the CMake generator of the Current Project if("${CMAKE_GENERATOR}" MATCHES "Make" AND ("${cmake_generator}" MATCHES "Make" OR NOT cmake_generator)) # The project uses the same Makefile generator. Use recursive make. @@ -1948,6 +1965,11 @@ function(_ep_get_build_command endif() else() # Drive the project with "cmake --build". + if(NOT cmake_generator) + # If there is no CMake Generator defined on the ExternalProject, + # use the same Generator as the current project + set(cmake_generator "${CMAKE_GENERATOR}") + endif() get_target_property(cmake_command ${name} _EP_CMAKE_COMMAND) if(cmake_command) set(cmd "${cmake_command}") @@ -1977,7 +1999,11 @@ function(_ep_get_build_command list(APPEND args --config ${config}) endif() if(step STREQUAL "INSTALL") - list(APPEND args --target install) + if("${cmake_generator}" MATCHES "Green Hills MULTI") + list(APPEND args --target INSTALL) + else() + list(APPEND args --target install) + endif() endif() # But for "TEST" drive the project with corresponding "ctest". if("x${step}x" STREQUAL "xTESTx") @@ -2361,7 +2387,7 @@ function(ExternalProject_Add_StepTargets name) endif() message(AUTHOR_WARNING "${_cmp0114_warning}") endif() - foreach(step ${steps}) + foreach(step IN LISTS steps) _ep_step_add_target("${name}" "${step}" "${no_deps}") endforeach() endfunction() @@ -2542,7 +2568,7 @@ function(ExternalProject_Add_Step name step) get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) if(_isMultiConfig) _ep_get_configuration_subdir_genex(cfgdir) - foreach(cfg ${CMAKE_CONFIGURATION_TYPES}) + foreach(cfg IN LISTS CMAKE_CONFIGURATION_TYPES) string(REPLACE "${cfgdir}" "/${cfg}" stamp_file_config "${stamp_file}" ) @@ -2617,7 +2643,7 @@ function(ExternalProject_Add_Step name step) PROPERTY EP_STEP_TARGETS ) endif() - foreach(st ${step_targets}) + foreach(st IN LISTS step_targets) if("${st}" STREQUAL "${step}") _ep_step_add_target("${name}" "${step}" "FALSE") break() @@ -2664,7 +2690,7 @@ function(ExternalProject_Add_Step name step) message(AUTHOR_WARNING "${_cmp0114_warning}") endif() endif() - foreach(st ${independent_step_targets}) + foreach(st IN LISTS independent_step_targets) if("${st}" STREQUAL "${step}") _ep_step_add_target("${name}" "${step}" "TRUE") break() @@ -2730,17 +2756,15 @@ function(ExternalProject_Add_StepDependencies name step) # Always add file-level dependency, but add target-level dependency # only if the target exists for that step. _ep_get_step_stampfile(${name} ${step} stamp_file) - foreach(dep ${dependencies}) + foreach(dep IN LISTS dependencies) add_custom_command(APPEND OUTPUT ${stamp_file} DEPENDS ${dep} ) - if(TARGET ${name}-${step}) - foreach(dep ${dependencies}) - add_dependencies(${name}-${step} ${dep}) - endforeach() - endif() endforeach() + if(TARGET ${name}-${step}) + add_dependencies(${name}-${step} ${dependencies}) + endif() endfunction() @@ -3068,7 +3092,7 @@ hash=${hash} list(LENGTH url url_list_length) if(NOT "${url_list_length}" STREQUAL "1") - foreach(entry ${url}) + foreach(entry IN LISTS url) if(NOT "${entry}" MATCHES "^[a-z]+://") message(FATAL_ERROR "At least one entry of URL is a path (invalid in a list)" @@ -3763,6 +3787,9 @@ function(_ep_extract_configure_command var name) list(APPEND cmd "-G${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}") else() list(APPEND cmd "-G${CMAKE_GENERATOR}") + # GreenHills needs to know about the compiler and toolset. + # Be sure to update the similar section in + # FetchContent.cmake:__FetchContent_directPopulate() if("${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI") set(has_cmake_cache_default_args 1) list(APPEND cmake_cache_default_args diff --git a/Modules/ExternalProject/download.cmake.in b/Modules/ExternalProject/download.cmake.in index bf7f209..0ad0dd3 100644 --- a/Modules/ExternalProject/download.cmake.in +++ b/Modules/ExternalProject/download.cmake.in @@ -71,14 +71,6 @@ function(sleep_before_download attempt) execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep "${sleep_seconds}") endfunction() -if("@LOCAL@" STREQUAL "") - message(FATAL_ERROR "LOCAL can't be empty") -endif() - -if("@REMOTE@" STREQUAL "") - message(FATAL_ERROR "REMOTE can't be empty") -endif() - if(EXISTS "@LOCAL@") check_file_hash(has_hash hash_is_good) if(has_hash) @@ -115,7 +107,7 @@ foreach(i RANGE ${retry_number}) if(status_code IN_LIST download_retry_codes) sleep_before_download(${i}) endif() - foreach(url @REMOTE@) + foreach(url IN ITEMS @REMOTE@) if(NOT url IN_LIST skip_url_list) message(STATUS "Using src='${url}'") diff --git a/Modules/FetchContent.cmake b/Modules/FetchContent.cmake index 9bbeac0..48cdaf4 100644 --- a/Modules/FetchContent.cmake +++ b/Modules/FetchContent.cmake @@ -195,6 +195,12 @@ Commands still be called if :variable:`FETCHCONTENT_TRY_FIND_PACKAGE_MODE` is set to ``OPT_IN`` or is not set. + It would not normally be appropriate to specify ``REQUIRED`` as one of + the additional arguments after ``FIND_PACKAGE_ARGS``. Doing so would + mean the :command:`find_package` call must succeed, so none of the other + details specified in the ``FetchContent_Declare()`` call would get a + chance to be used as a fall-back. + Everything after the ``FIND_PACKAGE_ARGS`` keyword is appended to the :command:`find_package` call, so all other ``<contentOptions>`` must come before the ``FIND_PACKAGE_ARGS`` keyword. If the @@ -373,6 +379,10 @@ Commands :command:`FetchContent_Declare`, the ``EXCLUDE_FROM_ALL`` keyword will be added to the :command:`add_subdirectory` command as well. + .. versionadded:: 3.29 + :variable:`CMAKE_EXPORT_FIND_PACKAGE_NAME` is set to the dependency name + before calling :command:`add_subdirectory`. + Projects should aim to declare the details of all dependencies they might use before they call ``FetchContent_MakeAvailable()`` for any of them. This ensures that if any of the dependencies are also sub-dependencies of @@ -675,6 +685,17 @@ A number of cache variables can influence the behavior where details from a any content details, turning this option ``ON`` can significantly speed up the configure stage. It is ``OFF`` by default. + .. note:: + + The ``FETCHCONTENT_FULLY_DISCONNECTED`` variable is not an appropriate way + to prevent any network access on the first run in a build directory. + Doing so can break projects, lead to misleading error messages, and hide + subtle population failures. This variable is specifically intended to + only be turned on *after* the first time CMake has been run. + If you want to prevent network access even on the first run, use a + :ref:`dependency provider <dependency_providers>` and populate the + dependency from local content instead. + .. variable:: FETCHCONTENT_UPDATES_DISCONNECTED This is a less severe download/update control compared to @@ -1194,10 +1215,10 @@ function(__FetchContent_declareDetails contentName) set(propertyName "_FetchContent_${contentNameLower}_find_package_args") define_property(GLOBAL PROPERTY ${propertyName}) if(NOT __sawQuietKeyword) - list(INSERT __findPackageArgs 0 QUIET) + string(PREPEND __findPackageArgs "QUIET ") endif() if(CMAKE_FIND_PACKAGE_TARGETS_GLOBAL AND NOT __sawGlobalKeyword) - list(APPEND __findPackageArgs GLOBAL) + string(APPEND __findPackageArgs " GLOBAL") endif() cmake_language(EVAL CODE "set_property(GLOBAL PROPERTY ${propertyName} ${__findPackageArgs})" @@ -1596,6 +1617,20 @@ ExternalProject_Add_Step(${contentName}-populate copyfile list(APPEND subCMakeOpts "-DCMAKE_MAKE_PROGRAM:FILEPATH=${CMAKE_MAKE_PROGRAM}") endif() + # GreenHills needs to know about the compiler and toolset to run the + # subbuild commands. Be sure to update the similar section in + # ExternalProject.cmake:_ep_extract_configure_command() + if(CMAKE_GENERATOR MATCHES "Green Hills MULTI") + list(APPEND subCMakeOpts + "-DGHS_TARGET_PLATFORM:STRING=${GHS_TARGET_PLATFORM}" + "-DGHS_PRIMARY_TARGET:STRING=${GHS_PRIMARY_TARGET}" + "-DGHS_TOOLSET_ROOT:STRING=${GHS_TOOLSET_ROOT}" + "-DGHS_OS_ROOT:STRING=${GHS_OS_ROOT}" + "-DGHS_OS_DIR:STRING=${GHS_OS_DIR}" + "-DGHS_BSP_NAME:STRING=${GHS_BSP_NAME}" + ) + endif() + # Override the sub-build's configuration types for multi-config generators. # This ensures we are not affected by any custom setting from the project # and can always request a known configuration further below. @@ -1930,6 +1965,10 @@ macro(FetchContent_MakeAvailable) "Trying FETCHCONTENT_MAKEAVAILABLE_SERIAL dependency provider for " "${__cmake_contentName}" ) + + list(APPEND __cmake_fcCurrentVarsStack "__fcprefix__${CMAKE_EXPORT_FIND_PACKAGE_NAME}") + set(CMAKE_EXPORT_FIND_PACKAGE_NAME "${__cmake_contentName}") + # It's still valid if there are no saved details. The project may have # been written to assume a dependency provider is always set and will # provide dependencies without having any declared details for them. @@ -1947,12 +1986,12 @@ macro(FetchContent_MakeAvailable) # This property might be defined but empty. As long as it is defined, # find_package() can be called. get_property(__cmake_addfpargs GLOBAL PROPERTY - _FetchContent_${contentNameLower}_find_package_args + _FetchContent_${__cmake_contentNameLower}_find_package_args DEFINED ) if(__cmake_addfpargs) get_property(__cmake_fpargs GLOBAL PROPERTY - _FetchContent_${contentNameLower}_find_package_args + _FetchContent_${__cmake_contentNameLower}_find_package_args ) string(APPEND __cmake_providerArgs " FIND_PACKAGE_ARGS") foreach(__cmake_item IN LISTS __cmake_fpargs) @@ -1984,6 +2023,12 @@ macro(FetchContent_MakeAvailable) unset(__cmake_item) unset(__cmake_contentDetails) + list(POP_BACK __cmake_fcCurrentVarsStack __cmake_original_export_find_package_name) + string(SUBSTRING "${__cmake_original_export_find_package_name}" + 12 -1 __cmake_original_export_find_package_name + ) + set(CMAKE_EXPORT_FIND_PACKAGE_NAME ${__cmake_original_export_find_package_name}) + FetchContent_GetProperties(${__cmake_contentName}) if(${__cmake_contentNameLower}_POPULATED) continue() @@ -2053,6 +2098,9 @@ macro(FetchContent_MakeAvailable) endif() if(EXISTS ${__cmake_srcdir}/CMakeLists.txt) + list(APPEND __cmake_fcCurrentVarsStack "__fcprefix__${CMAKE_EXPORT_FIND_PACKAGE_NAME}") + set(CMAKE_EXPORT_FIND_PACKAGE_NAME "${__cmake_contentName}") + set(__cmake_add_subdirectory_args ${__cmake_srcdir} ${${__cmake_contentNameLower}_BINARY_DIR}) if(__cmake_arg_EXCLUDE_FROM_ALL) list(APPEND __cmake_add_subdirectory_args EXCLUDE_FROM_ALL) @@ -2061,6 +2109,12 @@ macro(FetchContent_MakeAvailable) list(APPEND __cmake_add_subdirectory_args SYSTEM) endif() add_subdirectory(${__cmake_add_subdirectory_args}) + + list(POP_BACK __cmake_fcCurrentVarsStack __cmake_original_export_find_package_name) + string(SUBSTRING "${__cmake_original_export_find_package_name}" + 12 -1 __cmake_original_export_find_package_name + ) + set(CMAKE_EXPORT_FIND_PACKAGE_NAME ${__cmake_original_export_find_package_name}) endif() unset(__cmake_srcdir) diff --git a/Modules/FindBLAS.cmake b/Modules/FindBLAS.cmake index 39a1163..e9b118f 100644 --- a/Modules/FindBLAS.cmake +++ b/Modules/FindBLAS.cmake @@ -746,7 +746,11 @@ if(BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All") set(_blas_openblas_lib "openblas") if(_blas_sizeof_integer EQUAL 8) - string(APPEND _blas_openblas_lib "64") + if(MINGW) + string(APPEND _blas_openblas_lib "_64") + else() + string(APPEND _blas_openblas_lib "64") + endif() endif() if(NOT BLAS_LIBRARIES) diff --git a/Modules/FindCUDAToolkit.cmake b/Modules/FindCUDAToolkit.cmake index 6b8b08e..2229de6 100644 --- a/Modules/FindCUDAToolkit.cmake +++ b/Modules/FindCUDAToolkit.cmake @@ -1100,7 +1100,10 @@ if(CUDAToolkit_FOUND) if(CUDA_${lib_name}_LIBRARY MATCHES "/stubs/" AND NOT WIN32) # Use a SHARED library with IMPORTED_IMPLIB, but not IMPORTED_LOCATION, # to indicate that the stub is for linkers but not dynamic loaders. - # It will not contribute any RPATH entry. + # It will not contribute any RPATH entry. When encountered as + # a private transitive dependency of another shared library, + # it will be passed explicitly to linkers so they can find it + # even when the runtime library file does not exist on disk. set(CUDA_IMPORT_PROPERTY IMPORTED_IMPLIB) set(CUDA_IMPORT_TYPE SHARED) endif() @@ -1134,9 +1137,6 @@ if(CUDAToolkit_FOUND) target_link_directories(CUDA::toolkit INTERFACE "${CUDAToolkit_LIBRARY_DIR}") endif() - _CUDAToolkit_find_and_add_import_lib(cuda_driver ALT cuda) - - # setup dependencies that are required for cudart/cudart_static when building # on linux. These are generally only required when using the CUDA toolkit # when CUDA language is disabled @@ -1159,6 +1159,7 @@ if(CUDAToolkit_FOUND) endif() endif() + _CUDAToolkit_find_and_add_import_lib(cuda_driver ALT cuda DEPS cudart_static_deps) _CUDAToolkit_find_and_add_import_lib(cudart DEPS cudart_static_deps) _CUDAToolkit_find_and_add_import_lib(cudart_static DEPS cudart_static_deps) diff --git a/Modules/FindCURL.cmake b/Modules/FindCURL.cmake index 2f33dac..5e5f1f8 100644 --- a/Modules/FindCURL.cmake +++ b/Modules/FindCURL.cmake @@ -94,8 +94,10 @@ find_package(PkgConfig QUIET) if(PKG_CONFIG_FOUND) pkg_check_modules(PC_CURL QUIET libcurl) if(PC_CURL_FOUND) - pkg_get_variable(CURL_SUPPORTED_PROTOCOLS libcurl supported_protocols) - pkg_get_variable(CURL_SUPPORTED_FEATURES libcurl supported_features) + pkg_get_variable(CURL_SUPPORTED_PROTOCOLS_STRING libcurl supported_protocols) + string(REPLACE " " ";" CURL_SUPPORTED_PROTOCOLS "${CURL_SUPPORTED_PROTOCOLS_STRING}") + pkg_get_variable(CURL_SUPPORTED_FEATURES_STRING libcurl supported_features) + string(REPLACE " " ";" CURL_SUPPORTED_FEATURES "${CURL_SUPPORTED_FEATURES_STRING}") endif() endif() diff --git a/Modules/FindCxxTest.cmake b/Modules/FindCxxTest.cmake index 714927f..a3283fa 100644 --- a/Modules/FindCxxTest.cmake +++ b/Modules/FindCxxTest.cmake @@ -10,7 +10,7 @@ Find CxxTest unit testing framework. Find the `CxxTest`_ suite and declare a helper macro for creating unit tests and integrating them with CTest. -.. _`CxxTest`: https://github.com/CxxTest/cxxtest#readme +.. _`CxxTest`: https://github.com/CxxTest/cxxtest Input Variables ^^^^^^^^^^^^^^^ diff --git a/Modules/FindICU.cmake b/Modules/FindICU.cmake index b4f4d71..9514d2d 100644 --- a/Modules/FindICU.cmake +++ b/Modules/FindICU.cmake @@ -136,6 +136,7 @@ function(_ICU_FIND) HINTS ${icu_roots} PATH_SUFFIXES ${icu_include_suffixes} DOC "ICU include directory") + mark_as_advanced(ICU_INCLUDE_DIR) set(ICU_INCLUDE_DIR "${ICU_INCLUDE_DIR}" PARENT_SCOPE) # Get version diff --git a/Modules/FindLAPACK.cmake b/Modules/FindLAPACK.cmake index 4d3ab5a..e142516 100644 --- a/Modules/FindLAPACK.cmake +++ b/Modules/FindLAPACK.cmake @@ -487,7 +487,11 @@ if(NOT LAPACK_NOT_FOUND_MESSAGE) set(_lapack_openblas_lib "openblas") if(_lapack_sizeof_integer EQUAL 8) - string(APPEND _lapack_openblas_lib "64") + if(MINGW) + string(APPEND _lapack_openblas_lib "_64") + else() + string(APPEND _lapack_openblas_lib "64") + endif() endif() check_lapack_libraries( diff --git a/Modules/FindMPI.cmake b/Modules/FindMPI.cmake index a25f113..834a3e1 100644 --- a/Modules/FindMPI.cmake +++ b/Modules/FindMPI.cmake @@ -301,9 +301,9 @@ if(WIN32) set(_MPI_Intel_Fortran_COMPILER_NAMES mpiifort.bat mpif77.bat mpif90.bat) # Intel MPI compiler names - set(_MPI_IntelLLVM_C_COMPILER_NAMES mpiicc.bat) - set(_MPI_IntelLLVM_CXX_COMPILER_NAMES mpiicpc.bat) - set(_MPI_IntelLLVM_Fortran_COMPILER_NAMES mpiifort.bat mpif77.bat mpif90.bat) + set(_MPI_IntelLLVM_C_COMPILER_NAMES mpiicx.bat mpiicc.bat) + set(_MPI_IntelLLVM_CXX_COMPILER_NAMES mpiicpx.bat mpiicpc.bat) + set(_MPI_IntelLLVM_Fortran_COMPILER_NAMES mpiifx.bat mpiifort.bat mpif77.bat mpif90.bat) # Intel MPI compiler names for MSMPI set(_MPI_MSVC_C_COMPILER_NAMES mpicl.bat) @@ -315,9 +315,9 @@ else() set(_MPI_Intel_Fortran_COMPILER_NAMES mpiifort mpiif95 mpiif90 mpiif77) # Intel compiler names - set(_MPI_IntelLLVM_C_COMPILER_NAMES mpiicc) - set(_MPI_IntelLLVM_CXX_COMPILER_NAMES mpiicpc mpiicxx mpiic++) - set(_MPI_IntelLLVM_Fortran_COMPILER_NAMES mpiifort mpiif95 mpiif90 mpiif77) + set(_MPI_IntelLLVM_C_COMPILER_NAMES mpiicx mpiicc) + set(_MPI_IntelLLVM_CXX_COMPILER_NAMES mpiicpx mpiicpc mpiicxx mpiic++) + set(_MPI_IntelLLVM_Fortran_COMPILER_NAMES mpiifx mpiifort mpiif95 mpiif90 mpiif77) endif() # PGI compiler names diff --git a/Modules/FindMatlab.cmake b/Modules/FindMatlab.cmake index 15c3f64..6c80506 100644 --- a/Modules/FindMatlab.cmake +++ b/Modules/FindMatlab.cmake @@ -658,23 +658,23 @@ function(matlab_get_mex_suffix matlab_root mex_suffix) set(devnull INPUT_FILE NUL) endif() + set(_arch) if(WIN32) # this environment variable is used to determine the arch on Windows if(CMAKE_SIZEOF_VOID_P EQUAL 8) - set(ENV{MATLAB_ARCH} "win64") + set(_arch "MATLAB_ARCH=win64") else() - set(ENV{MATLAB_ARCH} "win32") + set(_arch "MATLAB_ARCH=win32") endif() endif() # this is the preferred way. If this does not work properly (eg. MCR on Windows), then we use our own knowledge execute_process( - COMMAND ${Matlab_MEXEXTENSIONS_PROG} + COMMAND ${CMAKE_COMMAND} -E env ${_arch} ${Matlab_MEXEXTENSIONS_PROG} OUTPUT_VARIABLE _matlab_mex_extension ERROR_VARIABLE _matlab_mex_extension_error OUTPUT_STRIP_TRAILING_WHITESPACE ${devnull}) - unset(ENV{MATLAB_ARCH}) if(_matlab_mex_extension_error) if(WIN32) @@ -1330,7 +1330,7 @@ function(_Matlab_get_version_from_root matlab_root matlab_or_mcr matlab_known_ve find_program( _matlab_current_program - matlab + NAMES matlab ${_find_matlab_options} DOC "Matlab main program" ) @@ -1835,7 +1835,7 @@ set(_matlab_required_variables) # the MEX library/header are required find_path( Matlab_INCLUDE_DIRS - mex.h + NAMES mex.h PATHS ${MATLAB_INCLUDE_DIR_TO_LOOK} NO_DEFAULT_PATH ) @@ -1845,7 +1845,7 @@ if(Matlab_Or_MCR STREQUAL "MATLAB" OR Matlab_Or_MCR STREQUAL "UNKNOWN") _Matlab_find_library( ${_matlab_lib_prefix_for_search} Matlab_MEX_LIBRARY - mex + NAMES mex PATHS ${_matlab_lib_dir_for_search} NO_DEFAULT_PATH ) @@ -1861,7 +1861,7 @@ if(Matlab_Or_MCR STREQUAL "MATLAB" OR Matlab_Or_MCR STREQUAL "UNKNOWN") _Matlab_find_library( ${_matlab_lib_prefix_for_search} Matlab_MX_LIBRARY - mx + NAMES mx PATHS ${_matlab_lib_dir_for_search} NO_DEFAULT_PATH ) @@ -1877,7 +1877,7 @@ if(Matlab_HAS_CPP_API) _Matlab_find_library( ${_matlab_lib_prefix_for_search} Matlab_ENGINE_LIBRARY - MatlabEngine + NAMES MatlabEngine PATHS ${_matlab_lib_dir_for_search} DOC "MatlabEngine Library" NO_DEFAULT_PATH @@ -1890,7 +1890,7 @@ if(Matlab_HAS_CPP_API) _Matlab_find_library( ${_matlab_lib_prefix_for_search} Matlab_DATAARRAY_LIBRARY - MatlabDataArray + NAMES MatlabDataArray PATHS ${_matlab_lib_dir_for_search} DOC "MatlabDataArray Library" NO_DEFAULT_PATH @@ -1906,7 +1906,7 @@ if("ENG_LIBRARY" IN_LIST Matlab_FIND_COMPONENTS) _Matlab_find_library( ${_matlab_lib_prefix_for_search} Matlab_ENG_LIBRARY - eng + NAMES eng PATHS ${_matlab_lib_dir_for_search} NO_DEFAULT_PATH ) @@ -1920,7 +1920,7 @@ if("MAT_LIBRARY" IN_LIST Matlab_FIND_COMPONENTS) _Matlab_find_library( ${_matlab_lib_prefix_for_search} Matlab_MAT_LIBRARY - mat + NAMES mat PATHS ${_matlab_lib_dir_for_search} NO_DEFAULT_PATH ) @@ -1933,7 +1933,7 @@ endif() if("SIMULINK" IN_LIST Matlab_FIND_COMPONENTS) find_path( Matlab_SIMULINK_INCLUDE_DIR - simstruc.h + NAMES simstruc.h PATHS "${Matlab_ROOT_DIR}/simulink/include" NO_DEFAULT_PATH ) @@ -1947,7 +1947,7 @@ endif() if("MAIN_PROGRAM" IN_LIST Matlab_FIND_COMPONENTS) find_program( Matlab_MAIN_PROGRAM - matlab + NAMES matlab PATHS ${Matlab_ROOT_DIR} ${Matlab_ROOT_DIR}/bin DOC "Matlab main program" NO_DEFAULT_PATH @@ -1961,7 +1961,7 @@ endif() if("MEX_COMPILER" IN_LIST Matlab_FIND_COMPONENTS) find_program( Matlab_MEX_COMPILER - "mex" + NAMES "mex" PATHS ${Matlab_BINARIES_DIR} DOC "Matlab MEX compiler" NO_DEFAULT_PATH @@ -1975,7 +1975,7 @@ endif() if("MCC_COMPILER" IN_LIST Matlab_FIND_COMPONENTS) find_program( Matlab_MCC_COMPILER - "mcc" + NAMES "mcc" PATHS ${Matlab_BINARIES_DIR} DOC "Matlab MCC compiler" NO_DEFAULT_PATH diff --git a/Modules/FindOpenACC.cmake b/Modules/FindOpenACC.cmake index 436f5ea..e9ca683 100644 --- a/Modules/FindOpenACC.cmake +++ b/Modules/FindOpenACC.cmake @@ -147,6 +147,7 @@ function(_OPENACC_GET_FLAGS_CANDIDATE LANG FLAG_VAR) set(ACC_FLAG_PGI "-acc") set(ACC_FLAG_GNU "-fopenacc") set(ACC_FLAG_Cray "-h acc") + set(ACC_FLAG_Clang "-fopenacc") if(DEFINED ACC_FLAG_${CMAKE_${LANG}_COMPILER_ID}) set("${FLAG_VAR}" "${ACC_FLAG_${CMAKE_${LANG}_COMPILER_ID}}" PARENT_SCOPE) diff --git a/Modules/FindOpenGL.cmake b/Modules/FindOpenGL.cmake index 1527c31..0c77cfc 100644 --- a/Modules/FindOpenGL.cmake +++ b/Modules/FindOpenGL.cmake @@ -92,12 +92,17 @@ This module sets the following variables: Defined if the system has GLES3. ``OPENGL_INCLUDE_DIR`` Path to the OpenGL include directory. + The ``OPENGL_INCLUDE_DIRS`` variable is preferred. ``OPENGL_EGL_INCLUDE_DIRS`` Path to the EGL include directory. ``OPENGL_LIBRARIES`` Paths to the OpenGL library, windowing system libraries, and GLU libraries. On Linux, this assumes GLX and is never correct for EGL-based targets. Clients are encouraged to use the ``OpenGL::*`` import targets instead. +``OPENGL_INCLUDE_DIRS`` + .. versionadded:: 3.29 + + Paths to the OpenGL include directories. .. versionadded:: 3.10 Variables for GLVND-specific libraries ``OpenGL``, ``EGL`` and ``GLX``. @@ -127,6 +132,11 @@ The following cache variables may also be set: Path to the OpenGL GLES3 library. +``OPENGL_GLU_INCLUDE_DIR`` + .. versionadded:: 3.29 + + Path to the OpenGL GLU include directory. + .. versionadded:: 3.10 Variables for GLVND-specific libraries ``OpenGL``, ``EGL`` and ``GLX``. @@ -177,9 +187,24 @@ GLVND. For non-GLVND Linux and other systems these are left undefined. macOS-Specific ^^^^^^^^^^^^^^ -On OSX FindOpenGL defaults to using the framework version of OpenGL. People -will have to change the cache values of OPENGL_glu_LIBRARY and -OPENGL_gl_LIBRARY to use OpenGL with X11 on OSX. +On macOS this module defaults to using the macOS-native framework +version of OpenGL. To use the X11 version of OpenGL on macOS, one +can disable searching of frameworks. For example: + +.. code-block:: cmake + + find_package(X11) + if(APPLE AND X11_FOUND) + set(CMAKE_FIND_FRAMEWORK NEVER) + find_package(OpenGL) + unset(CMAKE_FIND_FRAMEWORK) + else() + find_package(OpenGL) + endif() + +An end user building this project may need to point CMake at their +X11 installation, e.g., with ``-DOpenGL_ROOT=/opt/X11``. + #]=======================================================================] set(_OpenGL_REQUIRED_VARS OPENGL_gl_LIBRARY) @@ -207,15 +232,21 @@ if (WIN32) OPENGL_glu_LIBRARY ) elseif (APPLE) - # The OpenGL.framework provides both gl and glu - find_library(OPENGL_gl_LIBRARY OpenGL DOC "OpenGL library for OS X") - find_library(OPENGL_glu_LIBRARY OpenGL DOC - "GLU library for OS X (usually same as OpenGL library)") - find_path(OPENGL_INCLUDE_DIR OpenGL/gl.h DOC "Include for OpenGL on OS X") + # The OpenGL.framework provides both gl and glu in OpenGL + # XQuartz provides libgl and libglu + find_library(OPENGL_gl_LIBRARY NAMES OpenGL GL DOC + "OpenGL GL library") + find_library(OPENGL_glu_LIBRARY NAMES OpenGL GLU DOC + "OpenGL GLU library") + find_path(OPENGL_INCLUDE_DIR NAMES OpenGL/gl.h GL/gl.h DOC + "Include for OpenGL") + find_path(OPENGL_GLU_INCLUDE_DIR NAMES OpenGL/glu.h GL/glu.h DOC + "Include for the OpenGL GLU library") list(APPEND _OpenGL_REQUIRED_VARS OPENGL_INCLUDE_DIR) list(APPEND _OpenGL_CACHE_VARS OPENGL_INCLUDE_DIR + OPENGL_GLU_INCLUDE_DIR OPENGL_gl_LIBRARY OPENGL_glu_LIBRARY ) @@ -271,6 +302,8 @@ else() /opt/graphics/OpenGL/include ) + find_path(OPENGL_GLU_INCLUDE_DIR GL/glu.h ${_OPENGL_INCLUDE_PATH}) + list(APPEND _OpenGL_CACHE_VARS OPENGL_INCLUDE_DIR OPENGL_GLX_INCLUDE_DIR @@ -278,6 +311,7 @@ else() OPENGL_GLES2_INCLUDE_DIR OPENGL_GLES3_INCLUDE_DIR OPENGL_xmesa_INCLUDE_DIR + OPENGL_GLU_INCLUDE_DIR ) # Search for the GLVND libraries. We do this regardless of COMPONENTS; we'll @@ -491,7 +525,7 @@ else() set( OPENGL_XMESA_FOUND "NO" ) endif() -if(OPENGL_glu_LIBRARY) +if(OPENGL_glu_LIBRARY AND (WIN32 OR OPENGL_GLU_INCLUDE_DIR)) set( OPENGL_GLU_FOUND "YES" ) else() set( OPENGL_GLU_FOUND "NO" ) @@ -549,6 +583,8 @@ unset(_OpenGL_REQUIRED_VARS) # OpenGL:: targets if(OPENGL_FOUND) + set(OPENGL_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR}) + # ::OpenGL is a GLVND library, and thus Linux-only: we don't bother checking # for a framework version of this library. if(OPENGL_opengl_LIBRARY AND NOT TARGET OpenGL::OpenGL) @@ -582,6 +618,7 @@ if(OPENGL_FOUND) OpenGL::OpenGL) set_target_properties(OpenGL::GLX PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${OPENGL_GLX_INCLUDE_DIR}") + list(APPEND OPENGL_INCLUDE_DIRS ${OPENGL_GLX_INCLUDE_DIR}) endif() # ::GLES2 is a GLVND library, and thus Linux-only: we don't bother checking @@ -611,6 +648,7 @@ if(OPENGL_FOUND) INTERFACE_INCLUDE_DIRECTORIES "${OPENGL_GLES2_INCLUDE_DIR}" ) + list(APPEND OPENGL_INCLUDE_DIRS ${OPENGL_GLES2_INCLUDE_DIR}) if (OPENGL_USE_GLES2) set(_OpenGL_EGL_IMPL OpenGL::GLES2) @@ -644,6 +682,7 @@ if(OPENGL_FOUND) INTERFACE_INCLUDE_DIRECTORIES "${OPENGL_GLES3_INCLUDE_DIR}" ) + list(APPEND OPENGL_INCLUDE_DIRS ${OPENGL_GLES3_INCLUDE_DIR}) if (OPENGL_USE_GLES3) set(_OpenGL_EGL_IMPL OpenGL::GLES3) @@ -695,6 +734,7 @@ if(OPENGL_FOUND) # Note that EGL's include directory is different from OpenGL/GLX's! set_target_properties(OpenGL::EGL PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${OPENGL_EGL_INCLUDE_DIR}") + list(APPEND OPENGL_INCLUDE_DIRS ${OPENGL_EGL_INCLUDE_DIR}) endif() if(OPENGL_GLU_FOUND AND NOT TARGET OpenGL::GLU) @@ -709,6 +749,10 @@ if(OPENGL_FOUND) endif() set_target_properties(OpenGL::GLU PROPERTIES INTERFACE_LINK_LIBRARIES OpenGL::GL) + # Note that GLU's include directory may be different from OpenGL's! + set_target_properties(OpenGL::GLU PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${OPENGL_GLU_INCLUDE_DIR}") + list(APPEND OPENGL_INCLUDE_DIRS ${OPENGL_GLU_INCLUDE_DIR}) endif() # OPENGL_LIBRARIES mirrors OpenGL::GL's logic ... @@ -725,6 +769,8 @@ if(OPENGL_FOUND) endif() endif() +list(REMOVE_DUPLICATES OPENGL_INCLUDE_DIRS) + # This deprecated setting is for backward compatibility with CMake1.4 set(OPENGL_LIBRARY ${OPENGL_LIBRARIES}) # This deprecated setting is for backward compatibility with CMake1.4 diff --git a/Modules/FindOpenMP.cmake b/Modules/FindOpenMP.cmake index 69099f7..1d36b9b 100644 --- a/Modules/FindOpenMP.cmake +++ b/Modules/FindOpenMP.cmake @@ -224,7 +224,8 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR) OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT ) - if(OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}) + if(OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG} AND + NOT "${CMAKE_${LANG}_COMPILER_ID};${CMAKE_${LANG}_SIMULATE_ID}" STREQUAL "Clang;MSVC") set("${OPENMP_FLAG_VAR}" "${OPENMP_FLAG}" PARENT_SCOPE) if(CMAKE_${LANG}_VERBOSE_FLAG) diff --git a/Modules/FindOpenSSL.cmake b/Modules/FindOpenSSL.cmake index 10282a0..3683f39 100644 --- a/Modules/FindOpenSSL.cmake +++ b/Modules/FindOpenSSL.cmake @@ -318,7 +318,14 @@ if(WIN32 AND NOT CYGWIN) set(_OPENSSL_STATIC_SUFFIX "_static" ) - set(_OPENSSL_PATH_SUFFIXES + set(_OPENSSL_PATH_SUFFIXES_DEBUG + "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d" + "lib/VC/static" + "VC/static" + "lib" + ) + set(_OPENSSL_PATH_SUFFIXES_RELEASE + "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}" "lib/VC/static" "VC/static" "lib" @@ -327,7 +334,14 @@ if(WIN32 AND NOT CYGWIN) set(_OPENSSL_STATIC_SUFFIX "" ) - set(_OPENSSL_PATH_SUFFIXES + set(_OPENSSL_PATH_SUFFIXES_DEBUG + "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d" + "lib/VC" + "VC" + "lib" + ) + set(_OPENSSL_PATH_SUFFIXES_RELEASE + "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}" "lib/VC" "VC" "lib" @@ -356,7 +370,7 @@ if(WIN32 AND NOT CYGWIN) NAMES_PER_DIR ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES - ${_OPENSSL_PATH_SUFFIXES} + ${_OPENSSL_PATH_SUFFIXES_DEBUG} ) find_library(LIB_EAY_RELEASE @@ -381,7 +395,7 @@ if(WIN32 AND NOT CYGWIN) NAMES_PER_DIR ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES - ${_OPENSSL_PATH_SUFFIXES} + ${_OPENSSL_PATH_SUFFIXES_RELEASE} ) find_library(SSL_EAY_DEBUG @@ -406,7 +420,7 @@ if(WIN32 AND NOT CYGWIN) NAMES_PER_DIR ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES - ${_OPENSSL_PATH_SUFFIXES} + ${_OPENSSL_PATH_SUFFIXES_DEBUG} ) find_library(SSL_EAY_RELEASE @@ -431,7 +445,7 @@ if(WIN32 AND NOT CYGWIN) NAMES_PER_DIR ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES - ${_OPENSSL_PATH_SUFFIXES} + ${_OPENSSL_PATH_SUFFIXES_RELEASE} ) set(LIB_EAY_LIBRARY_DEBUG "${LIB_EAY_DEBUG}") diff --git a/Modules/FindOpenThreads.cmake b/Modules/FindOpenThreads.cmake index bc45eea..6be3422 100644 --- a/Modules/FindOpenThreads.cmake +++ b/Modules/FindOpenThreads.cmake @@ -5,26 +5,32 @@ FindOpenThreads --------------- - - OpenThreads is a C++ based threading library. Its largest userbase seems to OpenSceneGraph so you might notice I accept OSGDIR as an -environment path. I consider this part of the Findosg* suite used to +environment path. I consider this part of the ``Findosg*`` suite used to find OpenSceneGraph components. Each component is separate and you must opt in to each module. -Locate OpenThreads This module defines OPENTHREADS_LIBRARY -OPENTHREADS_FOUND, if false, do not try to link to OpenThreads -OPENTHREADS_INCLUDE_DIR, where to find the headers +This module defines: + +``OPENTHREADS_LIBRARY`` + +``OPENTHREADS_FOUND`` + if false, do not try to link to OpenThreads +``OPENTHREADS_INCLUDE_DIR`` + where to find the headers + +``$OPENTHREADS_DIR`` is an environment variable that would correspond to the:: + + ./configure --prefix=$OPENTHREADS_DIR -$OPENTHREADS_DIR is an environment variable that would correspond to -the ./configure --prefix=$OPENTHREADS_DIR used in building osg. +used in building osg. -[CMake 2.8.10]: The CMake variables OPENTHREADS_DIR or OSG_DIR can now -be used as well to influence detection, instead of needing to specify -an environment variable. +.. versionadded:: 2.8.10 -Created by Eric Wing. + The CMake variables ``OPENTHREADS_DIR`` or ``OSG_DIR`` can now + be used as well to influence detection, instead of needing to specify + an environment variable. #]=======================================================================] # Header files are presumed to be included like diff --git a/Modules/FindPackageHandleStandardArgs.cmake b/Modules/FindPackageHandleStandardArgs.cmake index 56ba1e6..63b2bf2 100644 --- a/Modules/FindPackageHandleStandardArgs.cmake +++ b/Modules/FindPackageHandleStandardArgs.cmake @@ -342,7 +342,7 @@ function(FIND_PACKAGE_CHECK_VERSION version result) set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"") else () set(version_ok TRUE) - set(version_msg "(found suitable exact version \"${_FOUND_VERSION}\")") + set(version_msg "(found suitable exact version \"${version}\")") endif () else () if (NOT ${package}_FIND_VERSION VERSION_EQUAL version) diff --git a/Modules/FindPackageMessage.cmake b/Modules/FindPackageMessage.cmake index 0628b98..7efbe18 100644 --- a/Modules/FindPackageMessage.cmake +++ b/Modules/FindPackageMessage.cmake @@ -37,6 +37,7 @@ function(find_package_message pkg msg details) set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg}) if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}") # The message has not yet been printed. + string(STRIP "${msg}" msg) message(STATUS "${msg}") # Save the find details in the cache to avoid printing the same diff --git a/Modules/FindPerl.cmake b/Modules/FindPerl.cmake index 26962df..49bc54c 100644 --- a/Modules/FindPerl.cmake +++ b/Modules/FindPerl.cmake @@ -5,15 +5,20 @@ FindPerl -------- -Find perl +Find a Perl interpreter. -this module looks for Perl +This module defines the following variables: -:: +``PERL_EXECUTABLE`` + The full path to Perl. - PERL_EXECUTABLE - the full path to perl - PERL_FOUND - If false, don't attempt to use perl. - PERL_VERSION_STRING - version of perl found (since CMake 2.8.8) +``PERL_FOUND`` + True if the Perl executable was found. + +``PERL_VERSION_STRING`` + .. versionadded:: 2.8.8 + + The version of Perl found. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/FindCygwin.cmake) diff --git a/Modules/FindPkgConfig.cmake b/Modules/FindPkgConfig.cmake index 27d25fb..1b6a72a 100644 --- a/Modules/FindPkgConfig.cmake +++ b/Modules/FindPkgConfig.cmake @@ -656,6 +656,9 @@ macro(_pkg_check_modules_internal _is_required _is_silent _no_cmake_path _no_cma if (APPLE AND "-framework" IN_LIST ${_prefix}_LDFLAGS_OTHER) _pkgconfig_extract_frameworks("${_prefix}") + # Using _pkgconfig_set in this scope so that a future policy can switch to normal variables + _pkgconfig_set("${_pkg_check_prefix}_LIBRARIES" "${${_pkg_check_prefix}_LIBRARIES}") + _pkgconfig_set("${_pkg_check_prefix}_LDFLAGS_OTHER" "${${_pkg_check_prefix}_LDFLAGS_OTHER}") endif() _pkgconfig_invoke_dyn("${_pkg_check_modules_packages}" "${_prefix}" INCLUDE_DIRS "(^| )(-I|-isystem ?)" --cflags-only-I ) @@ -664,6 +667,9 @@ macro(_pkg_check_modules_internal _is_required _is_silent _no_cmake_path _no_cma if (${_prefix}_CFLAGS_OTHER MATCHES "-isystem") _pkgconfig_extract_isystem("${_prefix}") + # Using _pkgconfig_set in this scope so that a future policy can switch to normal variables + _pkgconfig_set("${_pkg_check_prefix}_CFLAGS_OTHER" "${${_pkg_check_prefix}_CFLAGS_OTHER}") + _pkgconfig_set("${_pkg_check_prefix}_INCLUDE_DIRS" "${${_pkg_check_prefix}_INCLUDE_DIRS}") endif () _pkg_recalculate("${_prefix}" ${_no_cmake_path} ${_no_cmake_environment_path} ${_imp_target} ${_imp_target_global}) diff --git a/Modules/FindVulkan.cmake b/Modules/FindVulkan.cmake index 581763d..0f45b63 100644 --- a/Modules/FindVulkan.cmake +++ b/Modules/FindVulkan.cmake @@ -537,13 +537,7 @@ _Vulkan_set_library_component_found(glslang-oglcompiler NO_WARNING) _Vulkan_set_library_component_found(glslang-osdependent NO_WARNING) _Vulkan_set_library_component_found(glslang-machineindependent NO_WARNING) _Vulkan_set_library_component_found(glslang-genericcodegen NO_WARNING) -_Vulkan_set_library_component_found(glslang - DEPENDENT_COMPONENTS - glslang-spirv - glslang-oglcompiler - glslang-osdependent - glslang-machineindependent - glslang-genericcodegen) +_Vulkan_set_library_component_found(glslang DEPENDENT_COMPONENTS glslang-spirv) _Vulkan_set_library_component_found(shaderc_combined) _Vulkan_set_library_component_found(SPIRV-Tools) _Vulkan_set_library_component_found(volk) @@ -747,10 +741,6 @@ if(Vulkan_FOUND) if((Vulkan_glslang_LIBRARY OR Vulkan_glslang_DEBUG_LIBRARY) AND TARGET Vulkan::glslang-spirv - AND TARGET Vulkan::glslang-oglcompiler - AND TARGET Vulkan::glslang-osdependent - AND TARGET Vulkan::glslang-machineindependent - AND TARGET Vulkan::glslang-genericcodegen AND NOT TARGET Vulkan::glslang) add_library(Vulkan::glslang STATIC IMPORTED) set_property(TARGET Vulkan::glslang @@ -775,10 +765,13 @@ if(Vulkan_FOUND) target_link_libraries(Vulkan::glslang INTERFACE Vulkan::glslang-spirv - Vulkan::glslang-oglcompiler - Vulkan::glslang-osdependent - Vulkan::glslang-machineindependent - Vulkan::glslang-genericcodegen + # OGLCompiler library has been fully removed since version 14.0.0 + # OSDependent, MachineIndependent, and GenericCodeGen may also be removed in the future. + # See https://github.com/KhronosGroup/glslang/issues/3462 + $<TARGET_NAME_IF_EXISTS:Vulkan::glslang-oglcompiler> + $<TARGET_NAME_IF_EXISTS:Vulkan::glslang-osdependent> + $<TARGET_NAME_IF_EXISTS:Vulkan::glslang-machineindependent> + $<TARGET_NAME_IF_EXISTS:Vulkan::glslang-genericcodegen> ) endif() diff --git a/Modules/FindX11.cmake b/Modules/FindX11.cmake index 1047e4f..491ea46 100644 --- a/Modules/FindX11.cmake +++ b/Modules/FindX11.cmake @@ -89,6 +89,7 @@ and also the following more fine grained variables and targets: X11_Xutil_INCLUDE_PATH, X11_Xutil_FOUND, X11::Xutil X11_Xv_INCLUDE_PATH, X11_Xv_LIB, X11_Xv_FOUND, X11::Xv X11_dpms_INCLUDE_PATH, (in X11_Xext_LIB), X11_dpms_FOUND + X11_Xdbe_INCLUDE_PATH, (in X11_Xext_LIB), X11_Xdbe_FOUND X11_XShm_INCLUDE_PATH, (in X11_Xext_LIB), X11_XShm_FOUND X11_Xshape_INCLUDE_PATH, (in X11_Xext_LIB), X11_Xshape_FOUND X11_XSync_INCLUDE_PATH, (in X11_Xext_LIB), X11_XSync_FOUND @@ -121,6 +122,10 @@ and also the following more fine grained variables and targets: ``xcb_shm``, ``xcb_sync``, ``xcb_xf86dri``, ``xcb_xinerama``, ``xcb_xinput``, ``xcb_xrm``, ``xcb_xvmc``, and ``xcb_xv`` libraries. +.. versionadded:: 3.29 + Added coverage of double buffer extension (variables + ``X11_Xdbe_INCLUDE_PATH`` and ``X11_Xdbe_FOUND``). + #]=======================================================================] if (UNIX) @@ -200,6 +205,7 @@ if (UNIX) find_path(X11_Xcomposite_INCLUDE_PATH X11/extensions/Xcomposite.h ${X11_INC_SEARCH_PATH}) find_path(X11_Xcursor_INCLUDE_PATH X11/Xcursor/Xcursor.h ${X11_INC_SEARCH_PATH}) find_path(X11_Xdamage_INCLUDE_PATH X11/extensions/Xdamage.h ${X11_INC_SEARCH_PATH}) + find_path(X11_Xdbe_INCLUDE_PATH X11/extensions/Xdbe.h ${X11_INC_SEARCH_PATH}) find_path(X11_Xdmcp_INCLUDE_PATH X11/Xdmcp.h ${X11_INC_SEARCH_PATH}) find_path(X11_Xext_INCLUDE_PATH X11/extensions/Xext.h ${X11_INC_SEARCH_PATH}) find_path(X11_dpms_INCLUDE_PATH X11/extensions/dpms.h ${X11_INC_SEARCH_PATH}) @@ -643,6 +649,11 @@ if (UNIX) set(X11_Xaw_FOUND TRUE) endif() + if (X11_Xdbe_INCLUDE_PATH) + set(X11_Xdbe_FOUND TRUE) + list(APPEND X11_INCLUDE_DIR ${X11_Xdbe_INCLUDE_PATH}) + endif () + # Most of the X11 headers will be in the same directories, avoid # creating a huge list of duplicates. if (X11_INCLUDE_DIR) @@ -1358,6 +1369,7 @@ if (UNIX) X11_XSync_INCLUDE_PATH X11_Xaw_LIB X11_Xaw_INCLUDE_PATH + X11_Xdbe_INCLUDE_PATH ) set(CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_SAVE}) set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE}) diff --git a/Modules/FindwxWidgets.cmake b/Modules/FindwxWidgets.cmake index 78fa481..b42a85e 100644 --- a/Modules/FindwxWidgets.cmake +++ b/Modules/FindwxWidgets.cmake @@ -37,7 +37,7 @@ select a configuration): wxWidgets_EXCLUDE_COMMON_LIBRARIES - Set to TRUE to exclude linking of commonly required libs (e.g., png tiff - jpeg zlib regex expat). + jpeg zlib regex expat scintilla lexilla). @@ -188,6 +188,9 @@ macro(DBG_MSG_V _MSG) # "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}): ${_MSG}") endmacro() +cmake_policy(PUSH) +cmake_policy(SET CMP0057 NEW) # if IN_LIST + # Clear return values in case the module is loaded more than once. set(wxWidgets_FOUND FALSE) set(wxWidgets_INCLUDE_DIRS "") @@ -244,8 +247,14 @@ macro(wx_extract_version) "\\2" wxWidgets_VERSION_MINOR "${_wx_version_h}" ) string(REGEX REPLACE "^(.*\n)?#define +wxRELEASE_NUMBER +([0-9]+).*" "\\2" wxWidgets_VERSION_PATCH "${_wx_version_h}" ) + string(REGEX REPLACE "^(.*\n)?#define +wxSUBRELEASE_NUMBER +([0-9]+).*" + "\\2" wxWidgets_VERSION_TWEAK "${_wx_version_h}" ) + set(wxWidgets_VERSION_STRING "${wxWidgets_VERSION_MAJOR}.${wxWidgets_VERSION_MINOR}.${wxWidgets_VERSION_PATCH}" ) + if(${wxWidgets_VERSION_TWEAK} GREATER 0) + string(APPEND wxWidgets_VERSION_STRING ".${wxWidgets_VERSION_TWEAK}") + endif() dbg_msg("wxWidgets_VERSION_STRING: ${wxWidgets_VERSION_STRING}") endmacro() @@ -265,6 +274,9 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # Useful common wx libs needed by almost all components. set(wxWidgets_COMMON_LIBRARIES png tiff jpeg zlib regex expat) + # Libraries needed by stc component + set(wxWidgets_STC_LIBRARIES scintilla lexilla) + # DEPRECATED: Use find_package(wxWidgets COMPONENTS mono) instead. if(NOT wxWidgets_FIND_COMPONENTS) if(wxWidgets_USE_MONOLITHIC) @@ -277,10 +289,15 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # Add the common (usually required libs) unless # wxWidgets_EXCLUDE_COMMON_LIBRARIES has been set. if(NOT wxWidgets_EXCLUDE_COMMON_LIBRARIES) - list(APPEND wxWidgets_FIND_COMPONENTS - ${wxWidgets_COMMON_LIBRARIES}) + if(stc IN_LIST wxWidgets_FIND_COMPONENTS) + list(APPEND wxWidgets_FIND_COMPONENTS ${wxWidgets_STC_LIBRARIES}) + endif() + list(APPEND wxWidgets_FIND_COMPONENTS ${wxWidgets_COMMON_LIBRARIES}) endif() + # Remove duplicates, for example when user has specified common libraries. + list(REMOVE_DUPLICATES wxWidgets_FIND_COMPONENTS) + #------------------------------------------------------------------- # WIN32: Helper MACROS #------------------------------------------------------------------- @@ -312,7 +329,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # FIXME: What if both regex libs are available. regex should be # found outside the loop and only wx${LIB}${_UCD}${_DBG}. # Find wxWidgets common libraries. - foreach(LIB ${wxWidgets_COMMON_LIBRARIES} scintilla) + foreach(LIB ${wxWidgets_COMMON_LIBRARIES} ${wxWidgets_STC_LIBRARIES}) find_library(WX_${LIB}${_DBG} NAMES wx${LIB}${_UCD}${_DBG} # for regex @@ -371,7 +388,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # Clear all debug or release library paths (arguments are "d" or ""). macro(WX_CLEAR_ALL_LIBS _DBG) # Clear wxWidgets common libraries. - foreach(LIB ${wxWidgets_COMMON_LIBRARIES} scintilla) + foreach(LIB ${wxWidgets_COMMON_LIBRARIES} ${wxWidgets_STC_LIBRARIES}) WX_CLEAR_LIB(WX_${LIB}${_DBG}) endforeach() @@ -441,12 +458,15 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") endif() DBG_MSG_V("OpenGL") - list(FIND ${_LIBS} gl WX_USE_GL) - if(NOT WX_USE_GL EQUAL -1) + if(gl IN_LIST ${_LIBS}) DBG_MSG_V("- is required.") list(APPEND wxWidgets_LIBRARIES opengl32 glu32) endif() + if(stc IN_LIST ${_LIBS}) + list(APPEND wxWidgets_LIBRARIES imm32) + endif() + list(APPEND wxWidgets_LIBRARIES winmm comctl32 uuid oleacc uxtheme rpcrt4 shlwapi version wsock32) endmacro() @@ -458,6 +478,9 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") foreach(version ${wx_versions}) foreach(patch RANGE 15 0 -1) list(APPEND wx_paths "wxWidgets-${version}.${patch}") + foreach(tweak RANGE 3 1 -1) + list(APPEND wx_paths "wxWidgets-${version}.${patch}.${tweak}") + endforeach() endforeach() endforeach() @@ -937,35 +960,38 @@ if(wxWidgets_FIND_STYLE STREQUAL "unix") endif() unset(_cygpath_exe CACHE) endif() -endif() -# Check that all libraries are present, as wx-config does not check it -set(_wx_lib_missing "") -foreach(_wx_lib_ ${wxWidgets_LIBRARIES}) - if("${_wx_lib_}" MATCHES "^-l(.*)") - set(_wx_lib_name "${CMAKE_MATCH_1}") - unset(_wx_lib_found CACHE) - find_library(_wx_lib_found NAMES ${_wx_lib_name} HINTS ${wxWidgets_LIBRARY_DIRS}) - if(_wx_lib_found STREQUAL _wx_lib_found-NOTFOUND) - list(APPEND _wx_lib_missing ${_wx_lib_name}) - endif() - unset(_wx_lib_found CACHE) - endif() -endforeach() + # Check that all libraries are present, as wx-config does not check it + set(_wx_lib_missing "") + foreach(_wx_lib_ ${wxWidgets_LIBRARIES}) + if("${_wx_lib_}" MATCHES "^-l(.*)") + set(_wx_lib_name "${CMAKE_MATCH_1}") + unset(_wx_lib_found CACHE) + find_library(_wx_lib_found NAMES ${_wx_lib_name} HINTS ${wxWidgets_LIBRARY_DIRS}) + if(_wx_lib_found STREQUAL _wx_lib_found-NOTFOUND) + list(APPEND _wx_lib_missing ${_wx_lib_name}) + endif() + unset(_wx_lib_found CACHE) + endif() + endforeach() -if (_wx_lib_missing) - string(REPLACE ";" " " _wx_lib_missing "${_wx_lib_missing}") - DBG_MSG_V("wxWidgets not found due to following missing libraries: ${_wx_lib_missing}") - set(wxWidgets_FOUND FALSE) - unset(wxWidgets_LIBRARIES) + if (_wx_lib_missing) + string(REPLACE ";" " " _wx_lib_missing "${_wx_lib_missing}") + DBG_MSG_V("wxWidgets not found due to following missing libraries: ${_wx_lib_missing}") + set(wxWidgets_FOUND FALSE) + unset(wxWidgets_LIBRARIES) + endif() + unset(_wx_lib_missing) endif() -unset(_wx_lib_missing) # Check if a specific version was requested by find_package(). if(wxWidgets_FOUND) wx_extract_version() endif() +file(TO_CMAKE_PATH "${wxWidgets_INCLUDE_DIRS}" wxWidgets_INCLUDE_DIRS) +file(TO_CMAKE_PATH "${wxWidgets_LIBRARY_DIRS}" wxWidgets_LIBRARY_DIRS) + # Debug output: DBG_MSG("wxWidgets_FOUND : ${wxWidgets_FOUND}") DBG_MSG("wxWidgets_INCLUDE_DIRS : ${wxWidgets_INCLUDE_DIRS}") @@ -1215,3 +1241,5 @@ function(WXWIDGETS_ADD_RESOURCES _outfiles) set(${_outfiles} ${${_outfiles}} PARENT_SCOPE) endfunction() + +cmake_policy(POP) diff --git a/Modules/FortranCInterface/Detect.cmake b/Modules/FortranCInterface/Detect.cmake index 010661e..d65c865 100644 --- a/Modules/FortranCInterface/Detect.cmake +++ b/Modules/FortranCInterface/Detect.cmake @@ -10,7 +10,7 @@ if(NOT EXISTS ${FortranCInterface_BINARY_DIR}/Output.cmake OR NOT EXISTS ${FortranCInterface_BINARY_DIR}/Input.cmake OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake IS_NEWER_THAN ${FortranCInterface_BINARY_DIR}/Input.cmake - OR NOT ${FortranCInterface_SOURCE_DIR}/Output.cmake + OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake IS_NEWER_THAN ${FortranCInterface_SOURCE_DIR}/Output.cmake.in OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake IS_NEWER_THAN ${FortranCInterface_SOURCE_DIR}/CMakeLists.txt @@ -177,7 +177,6 @@ endforeach() # Record the detection results. configure_file(${FortranCInterface_SOURCE_DIR}/Output.cmake.in ${FortranCInterface_BINARY_DIR}/Output.cmake @ONLY) -file(APPEND ${FortranCInterface_BINARY_DIR}/Output.cmake "\n") # Report the results. if(FortranCInterface_GLOBAL_FOUND) diff --git a/Modules/GNUInstallDirs.cmake b/Modules/GNUInstallDirs.cmake index 9796854..ed34c4a 100644 --- a/Modules/GNUInstallDirs.cmake +++ b/Modules/GNUInstallDirs.cmake @@ -20,11 +20,16 @@ Inclusion of this module defines the following variables: ``CMAKE_INSTALL_<dir>`` Destination for files of a given type. This value may be passed to - the ``DESTINATION`` options of :command:`install` commands for the - corresponding file type. It should typically be a path relative to - the installation prefix so that it can be converted to an absolute - path in a relocatable way (see ``CMAKE_INSTALL_FULL_<dir>``). - However, an absolute path is also allowed. + the ``DESTINATION`` options of :command:`install` commands for the + corresponding file type. It should be a path relative to the installation + prefix so that it can be converted to an absolute path in a relocatable way. + + While absolute paths are allowed, they are not recommended as they + do not work with the ``cmake --install`` command's + :option:`--prefix <cmake--install --prefix>` option, or with the + :manual:`cpack <cpack(1)>` installer generators. In particular, there is no + need to make paths absolute by prepending :variable:`CMAKE_INSTALL_PREFIX`; + this prefix is used by default if the DESTINATION is a relative path. ``CMAKE_INSTALL_FULL_<dir>`` @@ -34,6 +39,11 @@ Inclusion of this module defines the following variables: :variable:`CMAKE_INSTALL_PREFIX` variable. However, there are some `special cases`_ as documented below. + These variables shouldn't be used in :command:`install` commands + as they do not work with the ``cmake --install`` command's + :option:`--prefix <cmake--install --prefix>` option, or with the + :manual:`cpack <cpack(1)>` installer generators. + where ``<dir>`` is one of: ``BINDIR`` diff --git a/Modules/GetPrerequisites.cmake b/Modules/GetPrerequisites.cmake index 0ba35b6..d55c4ca 100644 --- a/Modules/GetPrerequisites.cmake +++ b/Modules/GetPrerequisites.cmake @@ -514,7 +514,7 @@ function(gp_resolved_file_type original_file file exepath dirs type_var) string(TOLOWER "${resolved_file}" lower) if(UNIX) - if(resolved_file MATCHES "^(/lib/|/lib32/|/libx32/|/lib64/|/usr/lib/|/usr/lib32/|/usr/libx32/|/usr/lib64/|/usr/X11R6/|/usr/bin/)") + if(resolved_file MATCHES "^/*(/lib/|/lib32/|/libx32/|/lib64/|/usr/lib/|/usr/lib32/|/usr/libx32/|/usr/lib64/|/usr/X11R6/|/usr/bin/)") set(is_system 1) endif() endif() diff --git a/Modules/GoogleTest.cmake b/Modules/GoogleTest.cmake index 57a7476..b62f839 100644 --- a/Modules/GoogleTest.cmake +++ b/Modules/GoogleTest.cmake @@ -475,10 +475,29 @@ function(gtest_discover_tests TARGET) set(ctest_file_base "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}[${counter}]") set(ctest_include_file "${ctest_file_base}_include.cmake") set(ctest_tests_file "${ctest_file_base}_tests.cmake") - get_property(crosscompiling_emulator + get_property(test_launcher TARGET ${TARGET} - PROPERTY CROSSCOMPILING_EMULATOR + PROPERTY TEST_LAUNCHER ) + cmake_policy(GET CMP0158 _CMP0158 + PARENT_SCOPE # undocumented, do not use outside of CMake + ) + if(NOT _CMP0158 OR _CMP0158 STREQUAL "OLD" OR _CMP0158 STREQUAL "NEW" AND CMAKE_CROSSCOMPILING) + get_property(crosscompiling_emulator + TARGET ${TARGET} + PROPERTY CROSSCOMPILING_EMULATOR + ) + endif() + + if(test_launcher AND crosscompiling_emulator) + set(test_executor "${test_launcher}" "${crosscompiling_emulator}") + elseif(test_launcher) + set(test_executor "${test_launcher}") + elseif(crosscompiling_emulator) + set(test_executor "${crosscompiling_emulator}") + else() + set(test_executor "") + endif() if(_DISCOVERY_MODE STREQUAL "POST_BUILD") add_custom_command( @@ -487,7 +506,7 @@ function(gtest_discover_tests TARGET) COMMAND "${CMAKE_COMMAND}" -D "TEST_TARGET=${TARGET}" -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>" - -D "TEST_EXECUTOR=${crosscompiling_emulator}" + -D "TEST_EXECUTOR=${test_executor}" -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}" -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}" -D "TEST_PROPERTIES=${_PROPERTIES}" @@ -500,7 +519,7 @@ function(gtest_discover_tests TARGET) -D "CTEST_FILE=${ctest_tests_file}" -D "TEST_DISCOVERY_TIMEOUT=${_DISCOVERY_TIMEOUT}" -D "TEST_XML_OUTPUT_DIR=${_XML_OUTPUT_DIR}" - -P "${_GOOGLETEST_DISCOVER_TESTS_SCRIPT}" + -P "${CMAKE_ROOT}/Modules/GoogleTestAddTests.cmake" VERBATIM ) @@ -526,10 +545,10 @@ function(gtest_discover_tests TARGET) " if(NOT EXISTS \"${ctest_tests_file}\" OR" "\n" " NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"$<TARGET_FILE:${TARGET}>\" OR\n" " NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"\${CMAKE_CURRENT_LIST_FILE}\")\n" - " include(\"${_GOOGLETEST_DISCOVER_TESTS_SCRIPT}\")" "\n" + " include(\"${CMAKE_ROOT}/Modules/GoogleTestAddTests.cmake\")" "\n" " gtest_discover_tests_impl(" "\n" " TEST_EXECUTABLE" " [==[" "$<TARGET_FILE:${TARGET}>" "]==]" "\n" - " TEST_EXECUTOR" " [==[" "${crosscompiling_emulator}" "]==]" "\n" + " TEST_EXECUTOR" " [==[" "${test_executor}" "]==]" "\n" " TEST_WORKING_DIR" " [==[" "${_WORKING_DIRECTORY}" "]==]" "\n" " TEST_EXTRA_ARGS" " [==[" "${_EXTRA_ARGS}" "]==]" "\n" " TEST_PROPERTIES" " [==[" "${_PROPERTIES}" "]==]" "\n" @@ -573,9 +592,5 @@ endfunction() ############################################################################### -set(_GOOGLETEST_DISCOVER_TESTS_SCRIPT - ${CMAKE_CURRENT_LIST_DIR}/GoogleTestAddTests.cmake -) - # Restore project's policies cmake_policy(POP) diff --git a/Modules/GoogleTestAddTests.cmake b/Modules/GoogleTestAddTests.cmake index de0f7d6..eea267d 100644 --- a/Modules/GoogleTestAddTests.cmake +++ b/Modules/GoogleTestAddTests.cmake @@ -112,6 +112,7 @@ function(gtest_discover_tests_impl) message(FATAL_ERROR "Error running test executable.\n" " Path: '${path}'\n" + " Working directory: '${_TEST_WORKING_DIR}'\n" " Result: ${result}\n" " Output:\n" " ${output}\n" diff --git a/Modules/Internal/AppleArchitectureSelection.cmake.in b/Modules/Internal/AppleArchitectureSelection.cmake.in new file mode 100644 index 0000000..fec0d41 --- /dev/null +++ b/Modules/Internal/AppleArchitectureSelection.cmake.in @@ -0,0 +1,8 @@ +@PACKAGE_INIT@ + +if(NOT CMAKE_OSX_ARCHITECTURES) + message(FATAL_ERROR "CMAKE_OSX_ARCHITECTURES must be explicitly set for this package") +endif() +@_branch_code@ + +message(FATAL_ERROR "Architecture not supported") diff --git a/Modules/Internal/ApplePlatformSelection.cmake.in b/Modules/Internal/ApplePlatformSelection.cmake.in new file mode 100644 index 0000000..5f5e01d --- /dev/null +++ b/Modules/Internal/ApplePlatformSelection.cmake.in @@ -0,0 +1,24 @@ +@PACKAGE_INIT@ + +string(TOLOWER "${CMAKE_OSX_SYSROOT}" _CMAKE_OSX_SYSROOT_LOWER) +if(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)iphonesimulator") + @_branch_IOS_SIMULATOR_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)iphoneos") + @_branch_IOS_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)appletvsimulator") + @_branch_TVOS_SIMULATOR_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)appletvos") + @_branch_TVOS_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)watchsimulator") + @_branch_WATCHOS_SIMULATOR_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)watchos") + @_branch_WATCHOS_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)xrsimulator") + @_branch_VISIONOS_SIMULATOR_INCLUDE_FILE@ +elseif(_CMAKE_OSX_SYSROOT_LOWER MATCHES "(^|/)xros") + @_branch_VISIONOS_INCLUDE_FILE@ +elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + @_branch_MACOS_INCLUDE_FILE@ +else() + message(FATAL_ERROR "Platform not supported") +endif() diff --git a/Modules/Internal/CMakeDetermineLinkerId.cmake b/Modules/Internal/CMakeDetermineLinkerId.cmake new file mode 100644 index 0000000..45499a5 --- /dev/null +++ b/Modules/Internal/CMakeDetermineLinkerId.cmake @@ -0,0 +1,107 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +# Function to identify the linker. This is used internally by CMake and should +# not be included by user code. +# If successful, sets CMAKE_<lang>_COMPILER_LINKER_ID and +# CMAKE_<lang>_COMPILER_LINKER_VERSION + +cmake_policy(PUSH) +cmake_policy(SET CMP0053 NEW) +cmake_policy(SET CMP0054 NEW) + +function(cmake_determine_linker_id lang linker) + if (NOT linker) + # linker was not identified + unset(CMAKE_${lang}_COMPILER_LINKER_ID PARENT_SCOPE) + unset(CMAKE_${lang}_COMPILER_LINKER_VERSION PARENT_SCOPE) + unset(CMAKE_${lang}_COMPILER_LINKER_FRONTEND_VARIANT PARENT_SCOPE) + return() + endif() + + set(linker_id) + set(linker_frontend) + set(linker_version) + + # Compute the linker ID and version. + foreach(flags IN ITEMS + "-v" # AppleClang, GNU, GNUgold, MOLD + "-V" # AIX, Solaris + "--version" # LLD + ) + execute_process(COMMAND "${linker}" ${flags} + OUTPUT_VARIABLE linker_desc + ERROR_VARIABLE linker_desc + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_STRIP_TRAILING_WHITESPACE) + + string(JOIN "\" \"" flags_string ${flags}) + string(REGEX REPLACE "\n\n.*" "" linker_desc_head "${linker_desc}") + message(CONFIGURE_LOG + "Running the ${lang} compiler's linker: \"${linker}\" \"${flags_string}\"\n" + "${linker_desc_head}\n" + ) + + if(CMAKE_EFFECTIVE_SYSTEM_NAME STREQUAL "Apple" AND linker_desc MATCHES "@\\(#\\)PROGRAM:ld.+PROJECT:[a-z0-9]+-([0-9.]+).+") + set(linker_id "AppleClang") + set(linker_frontend "GNU") + set(linker_version "${CMAKE_MATCH_1}") + break() + elseif(linker_desc MATCHES "mold \\(sold\\) ([0-9.]+)") + set(linker_id "MOLD") + set(linker_frontend "GNU") + set(linker_version "${CMAKE_MATCH_1}") + break() + elseif(linker_desc MATCHES "mold ([0-9.]+)") + set(linker_id "MOLD") + set(linker_frontend "GNU") + set(linker_version "${CMAKE_MATCH_1}") + break() + elseif(linker_desc MATCHES "LLD ([0-9.]+)") + set(linker_id "LLD") + set(linker_frontend "GNU") + set(linker_version "${CMAKE_MATCH_1}") + if(WIN32 AND NOT linker_desc MATCHES "compatible with GNU") + set(linker_frontend "MSVC") + endif() + break() + elseif(linker_desc MATCHES "GNU ld (\\([^)]+\\)|version) ([0-9.]+)") + set(linker_id "GNU") + set(linker_frontend "GNU") + set(linker_version "${CMAKE_MATCH_2}") + break() + elseif(linker_desc MATCHES "GNU gold \\([^)]+\\) ([0-9.]+)") + set(linker_id "GNUgold") + set(linker_frontend "GNU") + set(linker_version "${CMAKE_MATCH_1}") + break() + elseif(linker_desc MATCHES "Microsoft \\(R\\) Incremental Linker Version ([0-9.]+)") + set(linker_id "MSVC") + set(linker_frontend "MSVC") + set(linker_version "${CMAKE_MATCH_1}") + break() + elseif (CMAKE_SYSTEM_NAME STREQUAL "SunOS" AND linker_desc MATCHES "Solaris Link Editors: ([0-9.-]+)") + set(linker_id "Solaris") + set(linker_version "${CMAKE_MATCH_1}") + break() + elseif (CMAKE_SYSTEM_NAME STREQUAL "AIX" AND linker_desc MATCHES " LD ([0-9.]+)") + set(linker_id "AIX") + set(linker_version "${CMAKE_MATCH_1}") + break() + endif() + endforeach() + + set(CMAKE_${lang}_COMPILER_LINKER_ID "${linker_id}" PARENT_SCOPE) + if (linker_frontend) + set(CMAKE_${lang}_COMPILER_LINKER_FRONTEND_VARIANT "${linker_frontend}" PARENT_SCOPE) + else() + unset(CMAKE_${lang}_COMPILER_LINKER_FRONTEND_VARIANT PARENT_SCOPE) + endif() + if (linker_version) + set(CMAKE_${lang}_COMPILER_LINKER_VERSION "${linker_version}" PARENT_SCOPE) + else() + unset(CMAKE_${lang}_COMPILER_LINKER_VERSION PARENT_SCOPE) + endif() +endfunction() + +cmake_policy(POP) diff --git a/Modules/Internal/CPack/CPack.NuGet.nuspec.in b/Modules/Internal/CPack/CPack.NuGet.nuspec.in index d89d69f..4548a59 100644 --- a/Modules/Internal/CPack/CPack.NuGet.nuspec.in +++ b/Modules/Internal/CPack/CPack.NuGet.nuspec.in @@ -15,12 +15,14 @@ @_CPACK_NUGET_LICENSE_TAG@ @_CPACK_NUGET_ICONURL_TAG@ @_CPACK_NUGET_ICON_TAG@ + @_CPACK_NUGET_README_TAG@ @_CPACK_NUGET_REQUIRELICENSEACCEPTANCE_TAG@ @_CPACK_NUGET_SUMMARY_TAG@ @_CPACK_NUGET_RELEASENOTES_TAG@ @_CPACK_NUGET_COPYRIGHT_TAG@ @_CPACK_NUGET_LANGUAGE_TAG@ @_CPACK_NUGET_TAGS_TAG@ + @_CPACK_NUGET_REPOSITORY_TAG@ @_CPACK_NUGET_DEPENDENCIES_TAG@ </metadata> @_CPACK_NUGET_FILES_TAG@ diff --git a/Modules/Internal/CPack/CPackDeb.cmake b/Modules/Internal/CPack/CPackDeb.cmake index 38e32c2..55a621c 100644 --- a/Modules/Internal/CPack/CPackDeb.cmake +++ b/Modules/Internal/CPack/CPackDeb.cmake @@ -710,7 +710,7 @@ function(cpack_deb_prepare_package_vars) "${CPACK_DEBIAN_PACKAGE_NAME}-dbgsym_${CPACK_DEBIAN_PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.ddeb") else() if(NOT CPACK_DEBIAN_FILE_NAME MATCHES ".*\\.(deb|ipk)") - message(FATAL_ERROR "'${CPACK_DEBIAN_FILE_NAME}' is not a valid DEB package file name as it must end with '.deb' or '.ipk'!") + set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.deb") endif() set(CPACK_OUTPUT_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}") diff --git a/Modules/Internal/CPack/CPackNuGet.cmake b/Modules/Internal/CPack/CPackNuGet.cmake index 056d025..67f318a 100644 --- a/Modules/Internal/CPack/CPackNuGet.cmake +++ b/Modules/Internal/CPack/CPackNuGet.cmake @@ -294,6 +294,27 @@ function(_cpack_nuget_render_spec) # attributes: "type", "url", "branch", and "commit". While all fields are # considered optional, they are not independent. Currently unsupported. + # NuGet >= 5.10 + _cpack_nuget_variable_fallback_and_wrap_into_element(readme README) + + set(_CPACK_NUGET_REPOSITORY_TAG) + _cpack_nuget_variable_fallback(_repo_type REPOSITORY_TYPE) + _cpack_nuget_variable_fallback(_repo_url REPOSITORY_URL) + if(_repo_type AND _repo_url) + set(_CPACK_NUGET_REPOSITORY_TAG "<repository type=\"${_repo_type}\" url=\"${_repo_url}\"") + _cpack_nuget_variable_fallback(_repo_br REPOSITORY_BRANCH) + if(_repo_br) + string(APPEND _CPACK_NUGET_REPOSITORY_TAG " branch=\"${_repo_br}\"") + endif() + _cpack_nuget_variable_fallback(_repo_commit REPOSITORY_COMMIT) + if(_repo_commit) + string(APPEND _CPACK_NUGET_REPOSITORY_TAG " commit=\"${_repo_commit}\"") + endif() + string(APPEND _CPACK_NUGET_REPOSITORY_TAG " />") + else() + message(AUTHOR_WARNING "Skip adding the `<repository .../>` element due to missing URL or type") + endif() + # Handle dependencies _cpack_nuget_variable_fallback(_deps DEPENDENCIES) set(_collected_deps) diff --git a/Modules/Internal/CPack/CPackRPM.cmake b/Modules/Internal/CPack/CPackRPM.cmake index ace2c6b..5766045 100644 --- a/Modules/Internal/CPack/CPackRPM.cmake +++ b/Modules/Internal/CPack/CPackRPM.cmake @@ -1041,7 +1041,11 @@ function(cpack_rpm_generate_package) set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w9.lzdio") endif() if(CPACK_RPM_COMPRESSION_TYPE STREQUAL "xz") - set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w7.xzdio") + if(CPACK_THREADS GREATER "0") + set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w7T${CPACK_THREADS}.xzdio") + else() + set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w7T.xzdio") + endif() endif() if(CPACK_RPM_COMPRESSION_TYPE STREQUAL "bzip2") set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w9.bzdio") @@ -1577,7 +1581,7 @@ ${TMP_DEBUGINFO_ADDITIONAL_SOURCES} if(NOT CPACK_RPM_FILE_NAME STREQUAL "RPM-DEFAULT") if(CPACK_RPM_FILE_NAME) if(NOT CPACK_RPM_FILE_NAME MATCHES ".*\\.rpm") - message(FATAL_ERROR "'${CPACK_RPM_FILE_NAME}' is not a valid RPM package file name as it must end with '.rpm'!") + set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.rpm") endif() else() # old file name format for back compatibility diff --git a/Modules/Internal/CPack/CPackWIX.cmake b/Modules/Internal/CPack/CPackWIX.cmake index d1875f2..5fe772e 100644 --- a/Modules/Internal/CPack/CPackWIX.cmake +++ b/Modules/Internal/CPack/CPackWIX.cmake @@ -18,3 +18,7 @@ find_program(CPACK_WIX_LIGHT_EXECUTABLE light if(NOT CPACK_WIX_LIGHT_EXECUTABLE) message(FATAL_ERROR "Could not find the WiX light executable.") endif() + +if(NOT DEFINED CPACK_WIX_INSTALL_SCOPE) + set(CPACK_WIX_INSTALL_SCOPE "perMachine") +endif() diff --git a/Modules/Internal/CPack/WIX.template.in b/Modules/Internal/CPack/WIX.template.in index c0bf935..95ba7fa 100644 --- a/Modules/Internal/CPack/WIX.template.in +++ b/Modules/Internal/CPack/WIX.template.in @@ -12,7 +12,12 @@ Manufacturer="$(var.CPACK_PACKAGE_VENDOR)" UpgradeCode="$(var.CPACK_WIX_UPGRADE_GUID)"> + + <?if $(var.CPACK_WIX_INSTALL_SCOPE) = "NONE" ?> <Package InstallerVersion="301" Compressed="yes"/> + <?else?> + <Package InstallerVersion="301" Compressed="yes" InstallScope="$(var.CPACK_WIX_INSTALL_SCOPE)"/> + <?endif?> <Media Id="1" Cabinet="media1.cab" EmbedCab="yes"/> @@ -40,6 +45,7 @@ <FeatureRef Id="ProductFeature"/> <UIRef Id="$(var.CPACK_WIX_UI_REF)" /> + <UIRef Id="WixUI_ErrorProgressText" /> <?include "properties.wxi"?> <?include "product_fragment.wxi"?> diff --git a/Modules/Platform/ADSP-Common.cmake b/Modules/Platform/ADSP-Common.cmake index 2ba90b2..7ec8a6f 100644 --- a/Modules/Platform/ADSP-Common.cmake +++ b/Modules/Platform/ADSP-Common.cmake @@ -9,9 +9,9 @@ macro(__platform_adsp_init) set(CMAKE_ADSP_PROCESSOR "ADSP-${CMAKE_SYSTEM_PROCESSOR}") string(TOUPPER "${CMAKE_ADSP_PROCESSOR}" CMAKE_ADSP_PROCESSOR) - set(CMAKE_ADSP_COMPILER_NAME cc21k.exe) + set(CMAKE_ADSP_COMPILER_NAME "cc21k${CMAKE_EXECUTABLE_SUFFIX}") if(CMAKE_ADSP_PROCESSOR MATCHES "^ADSP-BF") - set(CMAKE_ADSP_COMPILER_NAME ccblkfn.exe) + set(CMAKE_ADSP_COMPILER_NAME "ccblkfn${CMAKE_EXECUTABLE_SUFFIX}") endif() set(CMAKE_ADSP_PLATFORM_INITIALIZED TRUE) @@ -20,7 +20,12 @@ endmacro() macro(__platform_adsp lang) __platform_adsp_init() - set(CMAKE_${lang}_COMPILER "${CMAKE_ADSP_ROOT}/${CMAKE_ADSP_COMPILER_NAME}") + find_program( + CMAKE_${lang}_COMPILER + "${CMAKE_ADSP_COMPILER_NAME}" + PATHS "${CMAKE_ADSP_ROOT}" + REQUIRED + ) execute_process( COMMAND "${CMAKE_${lang}_COMPILER}" "-proc=${CMAKE_ADSP_PROCESSOR}" "-version" diff --git a/Modules/Platform/ADSP-Determine.cmake b/Modules/Platform/ADSP-Determine.cmake index 6ccf1ea..1588c92 100644 --- a/Modules/Platform/ADSP-Determine.cmake +++ b/Modules/Platform/ADSP-Determine.cmake @@ -21,6 +21,6 @@ endif() if(NOT CMAKE_ADSP_ROOT) _find_adsp_root("C:/Program Files (x86)/Analog Devices/VisualDSP *") endif() -if(NOT IS_DIRECTORY "${CMAKE_ADSP_ROOT}") - message(FATAL_ERROR "ADSP: could not find CCES/VDSP++ install directory ${CMAKE_ADSP_ROOT}") +if(NOT CMAKE_ADSP_ROOT) + _find_adsp_root("/opt/analog/cces *") endif() diff --git a/Modules/Platform/AIX-GNU.cmake b/Modules/Platform/AIX-GNU.cmake index a9aa8e0..55a6680 100644 --- a/Modules/Platform/AIX-GNU.cmake +++ b/Modules/Platform/AIX-GNU.cmake @@ -14,8 +14,11 @@ macro(__aix_compiler_gnu lang) string(APPEND CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS " -Wl,-bnoipath") set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-Wl,-bexpall") # CMP0065 old behavior set(CMAKE_${lang}_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH 1) + set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-Wl,-v") set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath") + set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=ALL) + if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 7 OR CMAKE_SYSTEM_VERSION VERSION_LESS 7.1) unset(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY) endif() diff --git a/Modules/Platform/AIX-XL.cmake b/Modules/Platform/AIX-XL.cmake index 902cbb3..c225de9 100644 --- a/Modules/Platform/AIX-XL.cmake +++ b/Modules/Platform/AIX-XL.cmake @@ -17,6 +17,7 @@ macro(__aix_compiler_xl lang) set(CMAKE_SHARED_MODULE_${lang}_FLAGS " ") set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath") + set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=ALL) set(_OBJECTS " <OBJECTS>") if(DEFINED CMAKE_XL_CreateExportList AND CMAKE_XL_CreateExportList STREQUAL "") diff --git a/Modules/Platform/Apple-Clang.cmake b/Modules/Platform/Apple-Clang.cmake index 61a6cd2..bd5ba9a 100644 --- a/Modules/Platform/Apple-Clang.cmake +++ b/Modules/Platform/Apple-Clang.cmake @@ -15,9 +15,18 @@ macro(__apple_compiler_clang lang) set(CMAKE_${lang}_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ") endif() + set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=ALL) + set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK "-framework <LIBRARY>") set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE) + # linker selection + set(CMAKE_${lang}_USING_LINKER_SYSTEM "-fuse-ld=ld") + set(CMAKE_${lang}_USING_LINKER_APPLE_CLASSIC "-fuse-ld=ld" "LINKER:-ld_classic") + set(CMAKE_${lang}_USING_LINKER_LLD "-fuse-ld=lld") + set(CMAKE_${lang}_USING_LINKER_MOLD "-fuse-ld=mold") + set(CMAKE_${lang}_USING_LINKER_SOLD "-fuse-ld=sold") + if(_CMAKE_OSX_SYSROOT_PATH MATCHES "/iPhoneOS") set(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG "-miphoneos-version-min=") elseif(_CMAKE_OSX_SYSROOT_PATH MATCHES "/iPhoneSimulator") diff --git a/Modules/Platform/Apple-GNU.cmake b/Modules/Platform/Apple-GNU.cmake index 823c790..15f6a71 100644 --- a/Modules/Platform/Apple-GNU.cmake +++ b/Modules/Platform/Apple-GNU.cmake @@ -17,6 +17,9 @@ macro(__apple_compiler_gnu lang) set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK "-framework <LIBRARY>") set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE) + + set(CMAKE_${lang}_USING_LINKER_SYSTEM "") + set(CMAKE_${lang}_USING_LINKER_APPLE_CLASSIC "LINKER:-ld_classic") endmacro() macro(cmake_gnu_set_sysroot_flag lang) diff --git a/Modules/Platform/CYGWIN-GNU.cmake b/Modules/Platform/CYGWIN-GNU.cmake index ef64012..070b24d 100644 --- a/Modules/Platform/CYGWIN-GNU.cmake +++ b/Modules/Platform/CYGWIN-GNU.cmake @@ -52,6 +52,8 @@ macro(__cygwin_compiler_gnu lang) "<CMAKE_${lang}_COMPILER> <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> -Wl,--out-implib,<TARGET_IMPLIB> ${CMAKE_GNULD_IMAGE_VERSION} <LINK_LIBRARIES>") set(CMAKE_${lang}_CREATE_WIN32_EXE "-mwindows") + set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-Wl,-v") + # No -fPIC on cygwin set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "") set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "") diff --git a/Modules/Platform/Darwin.cmake b/Modules/Platform/Darwin.cmake index d614182..533b9ce 100644 --- a/Modules/Platform/Darwin.cmake +++ b/Modules/Platform/Darwin.cmake @@ -125,17 +125,17 @@ set(CMAKE_LINK_LIBRARY_USING_WEAK_FRAMEWORK "LINKER:-weak_framework,<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_WEAK_FRAMEWORK_SUPPORTED TRUE) # Defines LINK_LIBRARY features for libraries -set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY "PATH{LINKER:-needed_library <LIBRARY>}NAME{LINKER:-needed-l<LIBRARY>}") +set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY "PATH{LINKER:-needed_library,<LIBRARY>}NAME{LINKER:-needed-l<LIBRARY>}") set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY_SUPPORTED TRUE) -set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY "PATH{LINKER:-reexport_library <LIBRARY>}NAME{LINKER:-reexport-l<LIBRARY>}") +set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY "PATH{LINKER:-reexport_library,<LIBRARY>}NAME{LINKER:-reexport-l<LIBRARY>}") set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY_SUPPORTED TRUE) -set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY "PATH{LINKER:-weak_library <LIBRARY>}NAME{LINKER:-weak-l<LIBRARY>}") +set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY "PATH{LINKER:-weak_library,<LIBRARY>}NAME{LINKER:-weak-l<LIBRARY>}") set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY_SUPPORTED TRUE) # Defines LINK_LIBRARY feature to Force loading of all members of an archive -set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:-force_load <LIB_ITEM>") +set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:-force_load,<LIB_ITEM>") set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) # default to searching for frameworks first diff --git a/Modules/Platform/Linux-Clang-CUDA.cmake b/Modules/Platform/Linux-Clang-CUDA.cmake new file mode 100644 index 0000000..4a9337e --- /dev/null +++ b/Modules/Platform/Linux-Clang-CUDA.cmake @@ -0,0 +1,2 @@ +include(Platform/Linux-GNU) +__linux_compiler_gnu(CUDA) diff --git a/Modules/Platform/Linux-GNU.cmake b/Modules/Platform/Linux-GNU.cmake index 6878254..c3878eb 100644 --- a/Modules/Platform/Linux-GNU.cmake +++ b/Modules/Platform/Linux-GNU.cmake @@ -12,4 +12,13 @@ macro(__linux_compiler_gnu lang) # We pass this for historical reasons. Projects may have # executables that use dlopen but do not set ENABLE_EXPORTS. set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-rdynamic") + + set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-Wl,-v") + + # linker selection + set(CMAKE_${lang}_USING_LINKER_SYSTEM "") + set(CMAKE_${lang}_USING_LINKER_LLD "-fuse-ld=lld") + set(CMAKE_${lang}_USING_LINKER_BFD "-fuse-ld=bfd") + set(CMAKE_${lang}_USING_LINKER_GOLD "-fuse-ld=gold") + set(CMAKE_${lang}_USING_LINKER_MOLD "-fuse-ld=mold") endmacro() diff --git a/Modules/Platform/Linux-LLVMFlang-Fortran.cmake b/Modules/Platform/Linux-LLVMFlang-Fortran.cmake new file mode 100644 index 0000000..ceecc2f --- /dev/null +++ b/Modules/Platform/Linux-LLVMFlang-Fortran.cmake @@ -0,0 +1 @@ +include(Platform/Linux-GNU-Fortran) diff --git a/Modules/Platform/Linux-NVIDIA-CUDA.cmake b/Modules/Platform/Linux-NVIDIA-CUDA.cmake new file mode 100644 index 0000000..f383720 --- /dev/null +++ b/Modules/Platform/Linux-NVIDIA-CUDA.cmake @@ -0,0 +1,9 @@ + +set(CMAKE_CUDA_VERBOSE_LINK_FLAG "-Wl,-v") + +# linker selection +set(CMAKE_CUDA_USING_LINKER_SYSTEM "") +set(CMAKE_CUDA_USING_LINKER_LLD "-fuse-ld=lld") +set(CMAKE_CUDA_USING_LINKER_BFD "-fuse-ld=bfd") +set(CMAKE_CUDA_USING_LINKER_GOLD "-fuse-ld=gold") +set(CMAKE_CUDA_USING_LINKER_MOLD "-fuse-ld=mold") diff --git a/Modules/Platform/Windows-Clang-C.cmake b/Modules/Platform/Windows-Clang-C.cmake index 322e3fb..a90e4b7 100644 --- a/Modules/Platform/Windows-Clang-C.cmake +++ b/Modules/Platform/Windows-Clang-C.cmake @@ -1,7 +1,7 @@ include(Platform/Windows-Clang) __windows_compiler_clang(C) -if("x${MAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") +if("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" AND CMAKE_DEPFILE_FLAGS_C) diff --git a/Modules/Platform/Windows-Clang-CUDA.cmake b/Modules/Platform/Windows-Clang-CUDA.cmake new file mode 100644 index 0000000..c37df3b --- /dev/null +++ b/Modules/Platform/Windows-Clang-CUDA.cmake @@ -0,0 +1,16 @@ +include(Platform/Windows-Clang) +__windows_compiler_clang(CUDA) + +# Tell Clang where to find the CUDA libraries. +set(__IMPLICIT_LINKS) +foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES}) + string(APPEND __IMPLICIT_LINKS " -L\"${dir}\"") +endforeach() +string(APPEND CMAKE_CUDA_LINK_EXECUTABLE "${__IMPLICIT_LINKS}") +string(APPEND CMAKE_CUDA_CREATE_SHARED_LIBRARY "${__IMPLICIT_LINKS}") +string(APPEND CMAKE_CUDA_CREATE_SHARED_MODULE "${__IMPLICIT_LINKS}") +unset(__IMPLICIT_LINKS) + +# Device linking is just regular linking so these are the same. +set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG ${CMAKE_CUDA_LINKER_WRAPPER_FLAG}) +set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG_SEP ${CMAKE_CUDA_LINKER_WRAPPER_FLAG_SEP}) diff --git a/Modules/Platform/Windows-Clang-CXX.cmake b/Modules/Platform/Windows-Clang-CXX.cmake index b4aaf1e..af2a48f 100644 --- a/Modules/Platform/Windows-Clang-CXX.cmake +++ b/Modules/Platform/Windows-Clang-CXX.cmake @@ -2,7 +2,7 @@ include(Platform/Windows-Clang) set(_COMPILE_CXX_MSVC " -TP") __windows_compiler_clang(CXX) -if("x${MAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") +if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" AND CMAKE_DEPFILE_FLAGS_CXX) diff --git a/Modules/Platform/Windows-Clang-OBJC.cmake b/Modules/Platform/Windows-Clang-OBJC.cmake new file mode 100644 index 0000000..7babb98 --- /dev/null +++ b/Modules/Platform/Windows-Clang-OBJC.cmake @@ -0,0 +1,18 @@ +include(Platform/Windows-Clang) +__windows_compiler_clang(OBJC) + +if("x${CMAKE_OBJC_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_OBJC) + set(CMAKE_OBJC_DEPENDS_USE_COMPILER TRUE) + endif() +elseif("x${CMAKE_OBJC_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_OBJC) + # dependencies are computed by the compiler itself + set(CMAKE_OBJC_DEPFILE_FORMAT gcc) + set(CMAKE_OBJC_DEPENDS_USE_COMPILER TRUE) + endif() +endif() diff --git a/Modules/Platform/Windows-Clang-OBJCXX.cmake b/Modules/Platform/Windows-Clang-OBJCXX.cmake new file mode 100644 index 0000000..3bc1673 --- /dev/null +++ b/Modules/Platform/Windows-Clang-OBJCXX.cmake @@ -0,0 +1,18 @@ +include(Platform/Windows-Clang) +__windows_compiler_clang(OBJCXX) + +if("x${CMAKE_OBJCXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_OBJCXX) + set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE) + endif() +elseif("x${CMAKE_OBJCXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_OBJCXX) + # dependencies are computed by the compiler itself + set(CMAKE_OBJCXX_DEPFILE_FORMAT gcc) + set(CMAKE_OBJCXX_DEPENDS_USE_COMPILER TRUE) + endif() +endif() diff --git a/Modules/Platform/Windows-Clang.cmake b/Modules/Platform/Windows-Clang.cmake index 33d271d..b9e6394 100644 --- a/Modules/Platform/Windows-Clang.cmake +++ b/Modules/Platform/Windows-Clang.cmake @@ -45,6 +45,7 @@ macro(__windows_compiler_clang_gnu lang) math(EXPR MSVC_VERSION "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}") endif() + set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-v") # No -fPIC on Windows set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "") set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "") @@ -52,6 +53,15 @@ macro(__windows_compiler_clang_gnu lang) set(CMAKE_${lang}_LINK_OPTIONS_PIE "") set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE "") set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "") + set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared") + + set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=FORWARD UNICITY=ALL) + + # linker selection + set(CMAKE_${lang}_USING_LINKER_DEFAULT "-fuse-ld=lld-link") + set(CMAKE_${lang}_USING_LINKER_SYSTEM "-fuse-ld=link") + set(CMAKE_${lang}_USING_LINKER_LLD "-fuse-ld=lld-link") + set(CMAKE_${lang}_USING_LINKER_MSVC "-fuse-ld=link") set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1) set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES 1) @@ -74,10 +84,10 @@ macro(__windows_compiler_clang_gnu lang) set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>") set(CMAKE_${lang}_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>") set(CMAKE_${lang}_CREATE_SHARED_LIBRARY - "<CMAKE_${lang}_COMPILER> -fuse-ld=lld-link -nostartfiles -nostdlib <CMAKE_SHARED_LIBRARY_${lang}_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> -o <TARGET> ${CMAKE_GNULD_IMAGE_VERSION} -Xlinker /MANIFEST:EMBED -Xlinker /implib:<TARGET_IMPLIB> -Xlinker /pdb:<TARGET_PDB> -Xlinker /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <OBJECTS> <LINK_LIBRARIES> <MANIFESTS>") + "<CMAKE_${lang}_COMPILER> -nostartfiles -nostdlib <CMAKE_SHARED_LIBRARY_${lang}_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> -o <TARGET> ${CMAKE_GNULD_IMAGE_VERSION} -Xlinker /MANIFEST:EMBED -Xlinker /implib:<TARGET_IMPLIB> -Xlinker /pdb:<TARGET_PDB> -Xlinker /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <OBJECTS> <LINK_LIBRARIES> <MANIFESTS>") set(CMAKE_${lang}_CREATE_SHARED_MODULE ${CMAKE_${lang}_CREATE_SHARED_LIBRARY}) set(CMAKE_${lang}_LINK_EXECUTABLE - "<CMAKE_${lang}_COMPILER> -fuse-ld=lld-link -nostartfiles -nostdlib <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> -Xlinker /MANIFEST:EMBED -Xlinker /implib:<TARGET_IMPLIB> -Xlinker /pdb:<TARGET_PDB> -Xlinker /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> ${CMAKE_GNULD_IMAGE_VERSION} <LINK_LIBRARIES> <MANIFESTS>") + "<CMAKE_${lang}_COMPILER> -nostartfiles -nostdlib <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> -Xlinker /MANIFEST:EMBED -Xlinker /implib:<TARGET_IMPLIB> -Xlinker /pdb:<TARGET_PDB> -Xlinker /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> ${CMAKE_GNULD_IMAGE_VERSION} <LINK_LIBRARIES> <MANIFESTS>") set(CMAKE_${lang}_CREATE_WIN32_EXE "-Xlinker /subsystem:windows") set(CMAKE_${lang}_CREATE_CONSOLE_EXE "-Xlinker /subsystem:console") @@ -157,36 +167,32 @@ macro(__enable_llvm_rc_preprocessing clang_option_prefix extra_pp_flags) endif() endmacro() -macro(__verify_same_language_values variable) - foreach(lang "C" "CXX" "HIP") - if(DEFINED CMAKE_${lang}_${variable}) - list(APPEND __LANGUAGE_VALUES_${variable} "${CMAKE_${lang}_${variable}}") - endif() +function(__verify_same_language_values variable langs) + foreach(lang IN LISTS langs) + list(APPEND __LANGUAGE_VALUES_${variable} ${CMAKE_${lang}_${variable}}) endforeach() list(REMOVE_DUPLICATES __LANGUAGE_VALUES_${variable}) list(LENGTH __LANGUAGE_VALUES_${variable} __NUM_VALUES) - if(__NUM_VALUES GREATER 1) message(FATAL_ERROR ${ARGN}) endif() - unset(__NUM_VALUES) - unset(__LANGUAGE_VALUES_${variable}) -endmacro() +endfunction() if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC" + OR "x${CMAKE_CUDA_SIMULATE_ID}" STREQUAL "xMSVC" OR "x${CMAKE_HIP_SIMULATE_ID}" STREQUAL "xMSVC") - __verify_same_language_values(COMPILER_ID + __verify_same_language_values(COMPILER_ID "C;CXX;HIP" "The current configuration mixes Clang and MSVC or " "some other CL compatible compiler tool. This is not supported. " - "Use either clang or MSVC as both C, C++ and/or HIP compilers.") + "Use either Clang or MSVC as the compiler for all of C, C++, and/or HIP.") - __verify_same_language_values(COMPILER_FRONTEND_VARIANT + __verify_same_language_values(COMPILER_FRONTEND_VARIANT "C;CXX;CUDA;HIP" "The current configuration uses the Clang compiler " "tool with mixed frontend variants, both the GNU and in MSVC CL " "like variants. This is not supported. Use either clang/clang++ " - "or clang-cl as both C, C++ and/or HIP compilers.") + "or clang-cl as all C, C++, CUDA, and/or HIP compilers.") if(NOT CMAKE_RC_COMPILER_INIT) # Check if rc is already in the path @@ -208,6 +214,7 @@ if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" if ( "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" OR "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" + OR "x${CMAKE_CUDA_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" OR "x${CMAKE_HIP_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") include(Platform/Windows-MSVC) diff --git a/Modules/Platform/Windows-GNU-OBJC-ABI.cmake b/Modules/Platform/Windows-GNU-OBJC-ABI.cmake new file mode 100644 index 0000000..c8b2ea6 --- /dev/null +++ b/Modules/Platform/Windows-GNU-OBJC-ABI.cmake @@ -0,0 +1 @@ +__windows_compiler_gnu_abi(OBJC) diff --git a/Modules/Platform/Windows-GNU-OBJC.cmake b/Modules/Platform/Windows-GNU-OBJC.cmake new file mode 100644 index 0000000..42cf3f8 --- /dev/null +++ b/Modules/Platform/Windows-GNU-OBJC.cmake @@ -0,0 +1,2 @@ +include(Platform/Windows-GNU) +__windows_compiler_gnu(OBJC) diff --git a/Modules/Platform/Windows-GNU-OBJCXX-ABI.cmake b/Modules/Platform/Windows-GNU-OBJCXX-ABI.cmake new file mode 100644 index 0000000..9a11514 --- /dev/null +++ b/Modules/Platform/Windows-GNU-OBJCXX-ABI.cmake @@ -0,0 +1 @@ +__windows_compiler_gnu_abi(OBJCXX) diff --git a/Modules/Platform/Windows-GNU-OBJCXX.cmake b/Modules/Platform/Windows-GNU-OBJCXX.cmake new file mode 100644 index 0000000..072cf28 --- /dev/null +++ b/Modules/Platform/Windows-GNU-OBJCXX.cmake @@ -0,0 +1,2 @@ +include(Platform/Windows-GNU) +__windows_compiler_gnu(OBJCXX) diff --git a/Modules/Platform/Windows-GNU.cmake b/Modules/Platform/Windows-GNU.cmake index 412af6b..9f81882 100644 --- a/Modules/Platform/Windows-GNU.cmake +++ b/Modules/Platform/Windows-GNU.cmake @@ -112,6 +112,13 @@ macro(__windows_compiler_gnu lang) set(CMAKE_${type}_LINK_DYNAMIC_${lang}_FLAGS "-Wl,-Bdynamic") endforeach() + set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-Wl,-v") + + # linker selection + set(CMAKE_${lang}_USING_LINKER_SYSTEM "") + set(CMAKE_${lang}_USING_LINKER_BFD "-fuse-ld=bfd") + set(CMAKE_${lang}_USING_LINKER_LLD "-fuse-ld=lld") + # No -fPIC on Windows set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "") set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "") diff --git a/Modules/Platform/Windows-LLVMFlang-Fortran.cmake b/Modules/Platform/Windows-LLVMFlang-Fortran.cmake index 57e36c6..10e3b2c 100644 --- a/Modules/Platform/Windows-LLVMFlang-Fortran.cmake +++ b/Modules/Platform/Windows-LLVMFlang-Fortran.cmake @@ -5,17 +5,22 @@ elseif("x${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "xMSVC") include(Platform/Windows-MSVC) __windows_compiler_msvc(Fortran) - # FIXME(LLVMFlang): It does not provides MSVC runtime library selection flags. - # It should be given a flag like classic Flang's `-Xclang --dependent-lib=`, or a - # dedicated flag to select among multiple `Fortran*.lib` runtime library variants - # that each depend on a different MSVC runtime library. For now, LLVMFlang's - # `Fortran*.lib` runtime libraries hard-code use of msvcrt (MultiThreadedDLL), - # so we link to it ourselves. - set(_LLVMFlang_LINK_RUNTIME "-defaultlib:msvcrt") - set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded "") - set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "") - set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug "") - set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "") + if(CMAKE_Fortran_COMPILER_VERSION VERSION_GREATER_EQUAL 18.0) + set(_LLVMFlang_LINK_RUNTIME "") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded "-fms-runtime-lib=static") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "-fms-runtime-lib=dll") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug "-fms-runtime-lib=static_dbg") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "-fms-runtime-lib=dll_dbg") + else() + # LLVMFlang < 18.0 does not have MSVC runtime library selection flags. + # The official distrubtion's `Fortran*.lib` runtime libraries hard-code + # use of msvcrt (MultiThreadedDLL), so we link to it ourselves. + set(_LLVMFlang_LINK_RUNTIME "-defaultlib:msvcrt") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded "") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug "") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "") + endif() # LLVMFlang, like Clang, does not provide all debug information format flags. # In order to provide easy integration with C and C++ projects that use the diff --git a/Modules/Platform/Windows-MSVC.cmake b/Modules/Platform/Windows-MSVC.cmake index 829ab9b..48e7c4e 100644 --- a/Modules/Platform/Windows-MSVC.cmake +++ b/Modules/Platform/Windows-MSVC.cmake @@ -512,6 +512,14 @@ macro(__windows_compiler_msvc lang) set(CMAKE_DEPFILE_FLAGS_${lang} "/showIncludes") set(CMAKE_${lang}_DEPFILE_FORMAT msvc) endif() + + set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=FORWARD UNICITY=ALL) + + # linker selection + set(CMAKE_${lang}_USING_LINKER_SYSTEM "${CMAKE_LINKER_LINK}") + set(CMAKE_${lang}_USING_LINKER_LLD "${CMAKE_LINKER_LLD}") + set(CMAKE_${lang}_USING_LINKER_MSVC "${CMAKE_LINKER_LINK}") + set(CMAKE_${lang}_USING_LINKER_MODE TOOL) endmacro() macro(__windows_compiler_msvc_enable_rc flags) diff --git a/Modules/Platform/Windows-NVIDIA-CUDA.cmake b/Modules/Platform/Windows-NVIDIA-CUDA.cmake index 326e715..6489841 100644 --- a/Modules/Platform/Windows-NVIDIA-CUDA.cmake +++ b/Modules/Platform/Windows-NVIDIA-CUDA.cmake @@ -47,6 +47,12 @@ set(CMAKE_CUDA_DEVICE_LINK_EXECUTABLE "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -Xcompiler=-Fd<TARGET_COMPILE_PDB>,-FS${__IMPLICIT_DLINK_FLAGS}") unset(__IMPLICIT_DLINK_FLAGS) +# linker selection +set(CMAKE_CUDA_USING_LINKER_SYSTEM "${CMAKE_LINKER_LINK}") +set(CMAKE_CUDA_USING_LINKER_LLD "${CMAKE_LINKER_LLD}") +set(CMAKE_CUDA_USING_LINKER_MSVC "${CMAKE_LINKER_LINK}") +set(CMAKE_CUDA_USING_LINKER_MODE TOOL) + string(REPLACE "/D" "-D" _PLATFORM_DEFINES_CUDA "${_PLATFORM_DEFINES}${_PLATFORM_DEFINES_CXX}") if(CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT) diff --git a/Modules/Platform/Windows.cmake b/Modules/Platform/Windows.cmake index 1bf39cf..af7335b 100644 --- a/Modules/Platform/Windows.cmake +++ b/Modules/Platform/Windows.cmake @@ -13,8 +13,15 @@ set(CMAKE_LINK_LIBRARY_SUFFIX ".lib") set(CMAKE_DL_LIBS "") set(CMAKE_EXTRA_LINK_EXTENSIONS ".targets") -set(CMAKE_FIND_LIBRARY_PREFIXES "") -set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib") +set(CMAKE_FIND_LIBRARY_PREFIXES + "" # static or import library from MSVC tooling + "lib" # static library from Meson with MSVC tooling + ) +set(CMAKE_FIND_LIBRARY_SUFFIXES + ".dll.lib" # import library from Rust toolchain for MSVC ABI + ".lib" # static or import library from MSVC tooling + ".a" # static library from Meson with MSVC tooling + ) # for borland make long command lines are redirected to a file # with the following syntax, see Windows-bcc32.cmake for use diff --git a/Modules/UseEcos.cmake b/Modules/UseEcos.cmake index 83c9b20..5e6f606 100644 --- a/Modules/UseEcos.cmake +++ b/Modules/UseEcos.cmake @@ -8,21 +8,31 @@ UseEcos This module defines variables and macros required to build eCos application. This file contains the following macros: -ECOS_ADD_INCLUDE_DIRECTORIES() - add the eCos include dirs -ECOS_ADD_EXECUTABLE(name source1 ... sourceN ) - create an eCos -executable ECOS_ADJUST_DIRECTORY(VAR source1 ... sourceN ) - adjusts -the path of the source files and puts the result into VAR - -Macros for selecting the toolchain: ECOS_USE_ARM_ELF_TOOLS() - enable -the ARM ELF toolchain for the directory where it is called -ECOS_USE_I386_ELF_TOOLS() - enable the i386 ELF toolchain for the -directory where it is called ECOS_USE_PPC_EABI_TOOLS() - enable the -PowerPC toolchain for the directory where it is called - -It contains the following variables: ECOS_DEFINITIONS -ECOSCONFIG_EXECUTABLE ECOS_CONFIG_FILE - defaults to ecos.ecc, if your -eCos configuration file has a different name, adjust this variable for -internal use only: + +``ECOS_ADD_INCLUDE_DIRECTORIES()`` + add the eCos include dirs +``ECOS_ADD_EXECUTABLE(name source1 ... sourceN )`` + create an eCos executable +``ECOS_ADJUST_DIRECTORY(VAR source1 ... sourceN )`` + adjusts the path of the source files and puts the result into ``VAR`` + +Macros for selecting the toolchain: + +``ECOS_USE_ARM_ELF_TOOLS()`` + enable the ARM ELF toolchain for the directory where it is called +``ECOS_USE_I386_ELF_TOOLS()`` + enable the i386 ELF toolchain for the directory where it is called +``ECOS_USE_PPC_EABI_TOOLS()`` + enable the PowerPC toolchain for the directory where it is called + +It contains the following variables: + +``ECOS_DEFINITIONS`` + +``ECOSCONFIG_EXECUTABLE`` + +``ECOS_CONFIG_FILE`` + defaults to ecos.ecc, if your eCos configuration file has a different name, adjust this variable for internal use only: :: diff --git a/Modules/UseJava/javaTargets.cmake.in b/Modules/UseJava/javaTargets.cmake.in index 6e14256..f3670c2 100644 --- a/Modules/UseJava/javaTargets.cmake.in +++ b/Modules/UseJava/javaTargets.cmake.in @@ -1,6 +1,5 @@ -cmake_minimum_required(VERSION 2.8.12) cmake_policy(PUSH) -cmake_policy(VERSION 2.8) +cmake_policy(VERSION 2.8.12...3.27) #---------------------------------------------------------------- # Generated CMake Java target import file. diff --git a/Modules/UseSWIG.cmake b/Modules/UseSWIG.cmake index cece973..f264fb6 100644 --- a/Modules/UseSWIG.cmake +++ b/Modules/UseSWIG.cmake @@ -657,7 +657,7 @@ function(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile) if(NOT ("-dllimport" IN_LIST swig_source_file_flags OR "-dllimport" IN_LIST SWIG_MODULE_${name}_EXTRA_FLAGS)) # This makes sure that the name used in the generated DllImport # matches the library name created by CMake - list (APPEND SWIG_MODULE_${name}_EXTRA_FLAGS "-dllimport" "$<TARGET_FILE_PREFIX:${target_name}>$<TARGET_FILE_BASE_NAME:${target_name}>") + list (APPEND SWIG_MODULE_${name}_EXTRA_FLAGS "-dllimport" "$<TARGET_FILE_BASE_NAME:${target_name}>") endif() endif() if (SWIG_MODULE_${name}_LANGUAGE STREQUAL "PYTHON" AND NOT SWIG_MODULE_${name}_NOPROXY) |