From 549eedfe859db7cd7f57a446332b489a511d26ce Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 14:50:41 -0500 Subject: Tests: Fix CMP0115 warnings in CompileFeatures test Pass source file extensions explicitly. --- Tests/CompileFeatures/CMakeLists.txt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Tests/CompileFeatures/CMakeLists.txt b/Tests/CompileFeatures/CMakeLists.txt index 922e07f..a608b6a 100644 --- a/Tests/CompileFeatures/CMakeLists.txt +++ b/Tests/CompileFeatures/CMakeLists.txt @@ -4,9 +4,12 @@ cmake_policy(SET CMP0057 NEW) project(CompileFeatures) +set(ext_C c) +set(ext_CXX cpp) + macro(run_test feature lang) if (${feature} IN_LIST CMAKE_${lang}_COMPILE_FEATURES) - add_library(test_${feature} OBJECT ${feature}) + add_library(test_${feature} OBJECT ${feature}.${ext_${lang}}) set_property(TARGET test_${feature} PROPERTY COMPILE_FEATURES "${feature}" ) -- cgit v0.12 From 4c7e2615b8ddf162f18521c4685fddbb8010eb68 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Thu, 21 Jan 2021 19:15:22 -0500 Subject: Tests: Use the CVS :local: access method for local directories Windows absolute paths start with a drive letter, followed by the path. Without an explicit access method specification, CVS treats the drive letter as a host name. This changes explicitly adds `:local:` to local directory repository paths used in tests to avoid this confusion. See the CVS Manual [1] for more information. [1] https://www.gnu.org/software/trans-coord/manual/cvs/cvs.html#Repository Signed-off-by: William R. Dieter --- Tests/CTestUpdateCVS.cmake.in | 18 ++++-------------- Tests/ExternalProject/CMakeLists.txt | 6 +++--- 2 files changed, 7 insertions(+), 17 deletions(-) diff --git a/Tests/CTestUpdateCVS.cmake.in b/Tests/CTestUpdateCVS.cmake.in index 5389bdf..8e0b611 100644 --- a/Tests/CTestUpdateCVS.cmake.in +++ b/Tests/CTestUpdateCVS.cmake.in @@ -17,21 +17,11 @@ message("Using CVS tools:") set(CVS "@CVS_EXECUTABLE@") message(" cvs = ${CVS}") -set(REPO ${TOP}/repo) - -# The MSYS cvs tool interprets "c:/" as a "machine:" name for SSH. -# Detect the MSYS cvs and convert the repo path to an MSYS path. -if(WIN32) - if(EXISTS "${CVS}") - file(STRINGS "${CVS}" cvs_is_msys LIMIT_COUNT 1 REGEX "[Mm][Ss][Yy][Ss]") - if(cvs_is_msys) - message(" '${CVS}' is from MSYS (contains '${cvs_is_msys}')") - string(REGEX REPLACE "^([A-Za-z]):" "/\\1" REPO "${REPO}") - endif() - endif() -endif() +# Pre-pending :local: prevents cvs from trying to interpret Windows drive +# letters, like "C:", as host names. +set(REPO ":local:${TOP}/repo") -set(CVSCMD ${CVS} -d${REPO}) +set(CVSCMD ${CVS} -d "${REPO}") # CVSNT requires an extra option to 'cvs init'. set(CVS_INIT_OPT) diff --git a/Tests/ExternalProject/CMakeLists.txt b/Tests/ExternalProject/CMakeLists.txt index 132abf4..59e3bcc 100644 --- a/Tests/ExternalProject/CMakeLists.txt +++ b/Tests/ExternalProject/CMakeLists.txt @@ -161,7 +161,7 @@ if(do_cvs_tests) # set(proj TutorialStep1-CVS-20090626) ExternalProject_Add(${proj} - CVS_REPOSITORY "${local_cvs_repo}" + CVS_REPOSITORY ":local:${local_cvs_repo}" CVS_MODULE "TutorialStep1" CVS_TAG "-D2009-06-26 16:50:00 UTC" UPDATE_COMMAND "" @@ -176,7 +176,7 @@ if(do_cvs_tests) # set(proj TutorialStep1-CVS-testtag1) ExternalProject_Add(${proj} - CVS_REPOSITORY "${local_cvs_repo}" + CVS_REPOSITORY ":local:${local_cvs_repo}" CVS_MODULE "TutorialStep1" CVS_TAG -rtesttag1 UPDATE_COMMAND "" @@ -191,7 +191,7 @@ if(do_cvs_tests) # set(proj TutorialStep1-CVS-HEAD) ExternalProject_Add(${proj} - CVS_REPOSITORY "${local_cvs_repo}" + CVS_REPOSITORY ":local:${local_cvs_repo}" CVS_MODULE "TutorialStep1" CMAKE_GENERATOR "${CMAKE_GENERATOR}" CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH= -- cgit v0.12 From f905cfdc773f8fc1221b01b74292b8d9e8140242 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Thu, 3 Dec 2020 19:20:43 -0500 Subject: Tests: Fix Fortran test C function prototypes Several extern functions were declared without return type, which results in warnings. The functions are for calling Fortran subroutines, so there should not be a return value. Signed-off-by: William R. Dieter --- Tests/Fortran/myc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Tests/Fortran/myc.c b/Tests/Fortran/myc.c index efd9b68..1a4d5a4 100644 --- a/Tests/Fortran/myc.c +++ b/Tests/Fortran/myc.c @@ -1,6 +1,6 @@ #include "foo.h" -extern F_test_mod_sub(void); -extern F_mysub(void); +extern void F_test_mod_sub(void); +extern void F_mysub(void); int myc(void) { F_mysub(); -- cgit v0.12 From 49d7e0c91dffe3cae50d174474f69716632eb866 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Thu, 3 Dec 2020 18:49:57 -0500 Subject: Tests: Make GCOV test more robust to symbolic links in paths Symbolic links in the path to the cmake build directory caused some paths to have '..' directories in the path, which are equivalent, but not a string match for the expected path. As a result, some tests fail. Signed-off-by: William R. Dieter --- Tests/CTestCoverageCollectGCOV/test.cmake.in | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/Tests/CTestCoverageCollectGCOV/test.cmake.in b/Tests/CTestCoverageCollectGCOV/test.cmake.in index 1818888..a36f374 100644 --- a/Tests/CTestCoverageCollectGCOV/test.cmake.in +++ b/Tests/CTestCoverageCollectGCOV/test.cmake.in @@ -29,6 +29,20 @@ set(expected_out uncovered/uncovered2.cpp ) +# A symbolic link in the path can cause tar to put an equivalent, but not +# minimal file name to some files in the tar file. Convert paths to absolute +# then back to relative to get them in canonical form (or maybe this is a bug +# in how the tarball is generated?) +function(to_relative_paths real_paths paths) + foreach(file ${paths}) + file(REAL_PATH "${file}" real_path BASE_DIRECTORY "${CTEST_BINARY_DIRECTORY}") + file(RELATIVE_PATH relative_path "${CTEST_BINARY_DIRECTORY}" "${real_path}") + list(APPEND local_real_paths "${relative_path}") + message(DEBUG "${file} -> ${real_path} -> ${relative_path}") + endforeach() + set("${real_paths}" "${local_real_paths}" PARENT_SCOPE) +endfunction() + #------------------------------------------------------------------------------# # Test 1: with standard arguments #------------------------------------------------------------------------------# @@ -50,6 +64,7 @@ execute_process(COMMAND ) string(REPLACE "\n" ";" out "${out}") +to_relative_paths(out "${out}") list(SORT out) if("${out}" STREQUAL "${expected_out}") @@ -80,6 +95,7 @@ execute_process(COMMAND ) string(REPLACE "\n" ";" out "${out}") +to_relative_paths(out "${out}") list(SORT out) if("${out}" STREQUAL "${expected_out}") @@ -110,6 +126,7 @@ execute_process(COMMAND ) string(REPLACE "\n" ";" out "${out}") +to_relative_paths(out "${out}") list(SORT out) if("${out}" STREQUAL "${expected_out}") @@ -140,6 +157,7 @@ execute_process(COMMAND ) string(REPLACE "\n" ";" out "${out}") +to_relative_paths(out "${out}") list(SORT out) if("${out}" STREQUAL "${expected_out}") @@ -170,6 +188,7 @@ execute_process(COMMAND ) string(REPLACE "\n" ";" out "${out}") +to_relative_paths(out "${out}") list(SORT out) if("${out}" STREQUAL "${expected_out}") -- cgit v0.12 From f6f048898d4bfd7223c454de75167af2c2425b63 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Tue, 10 Nov 2020 19:37:37 -0500 Subject: Tests: Update RunCMake.DependencyGraph to canonicalize paths when comparing A symbolic link in the path was causing false path mismatches. Resolving the symlinks makes both paths identical. Signed-off-by: William R. Dieter --- Tests/RunCMake/DependencyGraph/RunCMakeTest.cmake | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Tests/RunCMake/DependencyGraph/RunCMakeTest.cmake b/Tests/RunCMake/DependencyGraph/RunCMakeTest.cmake index cb0d541..891e138 100644 --- a/Tests/RunCMake/DependencyGraph/RunCMakeTest.cmake +++ b/Tests/RunCMake/DependencyGraph/RunCMakeTest.cmake @@ -10,7 +10,8 @@ function(check_files dir) set(actual) foreach(i IN LISTS glob) if(NOT i MATCHES "(\\.manifest$)|(\\.exp$)|(\\.tds$)") - list(APPEND actual ${i}) + get_filename_component(real_path ${i} REALPATH) + list(APPEND actual ${real_path}) endif() endforeach() list(REMOVE_DUPLICATES actual) -- cgit v0.12 From f5d79dec5345473cd09a0f56e4603073baf84065 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Fri, 15 Jan 2021 02:03:34 -0500 Subject: Tests: Cleanup CPack message when files are expected and none are found Previously, when looking for exactly one file and the number of files was not one, the test printed out an error message saying that too many files were found, then printing the list of files. However, 0 is not 1 and also not too many files. To reduce confusion, this commit adds a different message when 0 files are found and 1 is expected. Signed-off-by: William R. Dieter --- Tests/RunCMake/CPack/VerifyResult.cmake | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Tests/RunCMake/CPack/VerifyResult.cmake b/Tests/RunCMake/CPack/VerifyResult.cmake index 345b37f..0ab545a 100644 --- a/Tests/RunCMake/CPack/VerifyResult.cmake +++ b/Tests/RunCMake/CPack/VerifyResult.cmake @@ -79,6 +79,11 @@ if(NOT EXPECTED_FILES_COUNT EQUAL 0) "which does not match:${msg_expected}\n" "${output_error_message}") endif() + elseif(foundFilescount_ EQUAL 0) + message(FATAL_ERROR + "Found no files for file No. '${file_no_}'!" + " Globbing expression: '${EXPECTED_FILE_${file_no_}}'" + "${output_error_message}") else() message(FATAL_ERROR "Found more than one file for file No. '${file_no_}'!" -- cgit v0.12 From 9bef4bef0fbe69825f9103365a89be4696b6e1d0 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: GenerateExportHeader: Recognize Intel < 12 more strictly Match exactly the `Intel` compiler id. Signed-off-by: William R. Dieter --- Modules/GenerateExportHeader.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Modules/GenerateExportHeader.cmake b/Modules/GenerateExportHeader.cmake index 2c4572f..a9a9c59 100644 --- a/Modules/GenerateExportHeader.cmake +++ b/Modules/GenerateExportHeader.cmake @@ -221,7 +221,7 @@ macro(_test_compiler_hidden_visibility) set(GCC_TOO_OLD TRUE) elseif(CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER_VERSION VERSION_LESS "4.2") set(GCC_TOO_OLD TRUE) - elseif(CMAKE_CXX_COMPILER_ID MATCHES Intel AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.0") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.0") set(_INTEL_TOO_OLD TRUE) endif() -- cgit v0.12 From a90d2a9eed202b58b72776f9beb0569e92c90d21 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: IntelLLVM: Add support for Intel LLVM-based compilers Using a single ID 'IntelLLVM' for the suite of Intel compilers based on the LLVM backend. The 'IntelLLVM' ID are used for C, C++, and Fortran. Data Parallel C++ will be handled in a separate commit. The C and C++ definitions are based on the Clang definitions. The Intel LLVM-based C and C++ compilers are based on the Clang front end, so existing Clang options are more likely to be a good match than options for the older Intel compilers. Fortran is based on the older Fortran front end with the LLVM backend. It has a similar interface to the older versions, though many options are shared with the C and C++ compilers. Fixes: #21561 Signed-off-by: William R. Dieter --- Help/variable/CMAKE_LANG_COMPILER_ID.rst | 1 + Modules/CMakeCompilerIdDetection.cmake | 1 + Modules/CMakeDetermineASMCompiler.cmake | 4 + Modules/CMakeDetermineCCompiler.cmake | 5 +- Modules/CMakeDetermineCXXCompiler.cmake | 5 +- Modules/CMakeDetermineCompilerId.cmake | 3 +- Modules/CMakeDetermineFortranCompiler.cmake | 8 +- ...atorDetermineCompilerMacrosAndIncludeDirs.cmake | 4 +- Modules/CMakeFortranCompilerId.F.in | 16 +++- Modules/CMakeTestGNU.c | 3 +- Modules/Compiler/IntelLLVM-ASM.cmake | 12 +++ Modules/Compiler/IntelLLVM-C.cmake | 63 +++++++++++++++ Modules/Compiler/IntelLLVM-CXX.cmake | 69 ++++++++++++++++ Modules/Compiler/IntelLLVM-DetermineCompiler.cmake | 41 ++++++++++ Modules/Compiler/IntelLLVM-Fortran.cmake | 19 +++++ Modules/Compiler/IntelLLVM.cmake | 93 ++++++++++++++++++++++ Modules/Platform/Apple-IntelLLVM-C.cmake | 2 + Modules/Platform/Apple-IntelLLVM-CXX.cmake | 2 + Modules/Platform/Apple-IntelLLVM-Fortran.cmake | 8 ++ Modules/Platform/Apple-IntelLLVM.cmake | 17 ++++ Modules/Platform/Linux-IntelLLVM-C.cmake | 3 + Modules/Platform/Linux-IntelLLVM-CXX.cmake | 3 + Modules/Platform/Linux-IntelLLVM-Fortran.cmake | 4 + Modules/Platform/Linux-IntelLLVM.cmake | 55 +++++++++++++ Modules/Platform/Windows-IntelLLVM-ASM.cmake | 2 + Modules/Platform/Windows-IntelLLVM-C.cmake | 2 + Modules/Platform/Windows-IntelLLVM-CXX.cmake | 3 + Modules/Platform/Windows-IntelLLVM-Fortran.cmake | 44 ++++++++++ Modules/Platform/Windows-IntelLLVM.cmake | 17 ++++ 29 files changed, 497 insertions(+), 12 deletions(-) create mode 100644 Modules/Compiler/IntelLLVM-ASM.cmake create mode 100644 Modules/Compiler/IntelLLVM-C.cmake create mode 100644 Modules/Compiler/IntelLLVM-CXX.cmake create mode 100644 Modules/Compiler/IntelLLVM-DetermineCompiler.cmake create mode 100644 Modules/Compiler/IntelLLVM-Fortran.cmake create mode 100644 Modules/Compiler/IntelLLVM.cmake create mode 100644 Modules/Platform/Apple-IntelLLVM-C.cmake create mode 100644 Modules/Platform/Apple-IntelLLVM-CXX.cmake create mode 100644 Modules/Platform/Apple-IntelLLVM-Fortran.cmake create mode 100644 Modules/Platform/Apple-IntelLLVM.cmake create mode 100644 Modules/Platform/Linux-IntelLLVM-C.cmake create mode 100644 Modules/Platform/Linux-IntelLLVM-CXX.cmake create mode 100644 Modules/Platform/Linux-IntelLLVM-Fortran.cmake create mode 100644 Modules/Platform/Linux-IntelLLVM.cmake create mode 100644 Modules/Platform/Windows-IntelLLVM-ASM.cmake create mode 100644 Modules/Platform/Windows-IntelLLVM-C.cmake create mode 100644 Modules/Platform/Windows-IntelLLVM-CXX.cmake create mode 100644 Modules/Platform/Windows-IntelLLVM-Fortran.cmake create mode 100644 Modules/Platform/Windows-IntelLLVM.cmake diff --git a/Help/variable/CMAKE_LANG_COMPILER_ID.rst b/Help/variable/CMAKE_LANG_COMPILER_ID.rst index 1270610..89d9e27 100644 --- a/Help/variable/CMAKE_LANG_COMPILER_ID.rst +++ b/Help/variable/CMAKE_LANG_COMPILER_ID.rst @@ -25,6 +25,7 @@ include: HP = Hewlett-Packard Compiler (hp.com) IAR = IAR Systems (iar.com) Intel = Intel Compiler (intel.com) + IntelLLVM = Intel LLVM-Based Compiler (intel.com) MSVC = Microsoft Visual Studio (microsoft.com) NVHPC = NVIDIA HPC SDK Compiler (nvidia.com) NVIDIA = NVIDIA CUDA Compiler (nvidia.com) diff --git a/Modules/CMakeCompilerIdDetection.cmake b/Modules/CMakeCompilerIdDetection.cmake index d64804e..214d58a 100644 --- a/Modules/CMakeCompilerIdDetection.cmake +++ b/Modules/CMakeCompilerIdDetection.cmake @@ -49,6 +49,7 @@ function(compiler_id_detection outvar lang) endif() list(APPEND ordered_compilers Intel + IntelLLVM PathScale Embarcadero Borland diff --git a/Modules/CMakeDetermineASMCompiler.cmake b/Modules/CMakeDetermineASMCompiler.cmake index a3e5a12..e8b9db7 100644 --- a/Modules/CMakeDetermineASMCompiler.cmake +++ b/Modules/CMakeDetermineASMCompiler.cmake @@ -78,6 +78,10 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Intel "--version") set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Intel "(ICC)") + list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS IntelLLVM ) + set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_IntelLLVM "--version") + set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_IntelLLVM "(Intel[^\n]+oneAPI)") + list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS SunPro ) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_SunPro "-V") set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_SunPro "Sun C") diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake index ab33b40..59c0574 100644 --- a/Modules/CMakeDetermineCCompiler.cmake +++ b/Modules/CMakeDetermineCCompiler.cmake @@ -59,7 +59,7 @@ else() # finally list compilers to try if(NOT CMAKE_C_COMPILER_INIT) - set(CMAKE_C_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}cc ${_CMAKE_TOOLCHAIN_PREFIX}gcc cl bcc xlc clang) + set(CMAKE_C_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}cc ${_CMAKE_TOOLCHAIN_PREFIX}gcc cl bcc xlc icx clang) endif() _cmake_find_compiler(C) @@ -134,7 +134,8 @@ else() # variable but are not aware of CMAKE_C_COMPILER_FRONTEND_VARIANT. # They pre-date our support for the GNU-like variant targeting the # MSVC ABI so we do not consider that here. - if(CMAKE_C_COMPILER_ID STREQUAL "Clang") + if(CMAKE_C_COMPILER_ID STREQUAL "Clang" + OR "x${CMAKE_${lang}_COMPILER_ID" STREQUAL "xIntelLLVM") if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") set(CMAKE_C_COMPILER_FRONTEND_VARIANT "MSVC") else() diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake index 7283bc2..fd07a5c 100644 --- a/Modules/CMakeDetermineCXXCompiler.cmake +++ b/Modules/CMakeDetermineCXXCompiler.cmake @@ -58,7 +58,7 @@ else() # finally list compilers to try if(NOT CMAKE_CXX_COMPILER_INIT) - set(CMAKE_CXX_COMPILER_LIST CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC clang++) + set(CMAKE_CXX_COMPILER_LIST CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC icpx icx clang++) endif() _cmake_find_compiler(CXX) @@ -131,7 +131,8 @@ else() # variable but are not aware of CMAKE_CXX_COMPILER_FRONTEND_VARIANT. # They pre-date our support for the GNU-like variant targeting the # MSVC ABI so we do not consider that here. - if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" + OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM") if("x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "MSVC") else() diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index d07db70..90697f0 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -164,7 +164,8 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) endif() set(_variant "") - if("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xClang") + if("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xClang" + OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xIntelLLVM") if("x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC") if(CMAKE_GENERATOR MATCHES "Visual Studio") set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC") diff --git a/Modules/CMakeDetermineFortranCompiler.cmake b/Modules/CMakeDetermineFortranCompiler.cmake index 8a57408..d7d032c 100644 --- a/Modules/CMakeDetermineFortranCompiler.cmake +++ b/Modules/CMakeDetermineFortranCompiler.cmake @@ -59,6 +59,8 @@ else() # af77: Apogee F77 compiler for Intergraph hardware running CLIX # epcf90: "Edinburgh Portable Compiler" F90 # fort: Compaq (now HP) Fortran 90/95 compiler for Tru64 and Linux/Alpha + # ifx: Intel Fortran LLVM-based compiler + # ifort: Intel Classic Fortran compiler # ifc: Intel Fortran 95 compiler for Linux/x86 # efc: Intel Fortran 95 compiler for IA64 # nagfor: NAG Fortran compiler @@ -68,14 +70,14 @@ else() # so if you paid for a compiler it is picked by default. if(CMAKE_HOST_WIN32) set(CMAKE_Fortran_COMPILER_LIST - ifort pgf95 pgfortran lf95 fort + ifort ifx pgf95 pgfortran lf95 fort flang gfortran gfortran-4 g95 f90 pgf90 pgf77 g77 f77 nag ) else() set(CMAKE_Fortran_COMPILER_LIST ftn - ifort ifc efc pgf95 pgfortran lf95 xlf95 fort + ifort ifc ifx efc pgf95 pgfortran lf95 xlf95 fort flang gfortran gfortran-4 g95 f90 pgf90 frt pgf77 xlf g77 f77 nag ) @@ -83,7 +85,7 @@ else() # Vendor-specific compiler names. set(_Fortran_COMPILER_NAMES_GNU gfortran gfortran-4 g95 g77) - set(_Fortran_COMPILER_NAMES_Intel ifort ifc efc) + set(_Fortran_COMPILER_NAMES_Intel ifort ifc efc ifx) set(_Fortran_COMPILER_NAMES_Absoft af95 af90 af77) set(_Fortran_COMPILER_NAMES_PGI pgf95 pgfortran pgf90 pgf77) set(_Fortran_COMPILER_NAMES_Flang flang) diff --git a/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake b/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake index 11f4a29..f90301b 100644 --- a/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake +++ b/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake @@ -88,7 +88,7 @@ set(ENV{LANG} C) # Now check for C, works for gcc and Intel compiler at least if (NOT CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS) - if (CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES Intel OR CMAKE_C_COMPILER_ID MATCHES Clang) + if (CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES "Intel" OR CMAKE_C_COMPILER_ID MATCHES Clang) _DETERMINE_GCC_SYSTEM_INCLUDE_DIRS(c _dirs _defines) set(CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS "${_dirs}" CACHE INTERNAL "C compiler system include directories") set(CMAKE_EXTRA_GENERATOR_C_SYSTEM_DEFINED_MACROS "${_defines}" CACHE INTERNAL "C compiler system defined macros") @@ -99,7 +99,7 @@ endif () # And now the same for C++ if (NOT CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS) - if ("${CMAKE_CXX_COMPILER_ID}" MATCHES GNU OR "${CMAKE_CXX_COMPILER_ID}" MATCHES Intel OR "${CMAKE_CXX_COMPILER_ID}" MATCHES Clang) + if ("${CMAKE_CXX_COMPILER_ID}" MATCHES GNU OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES Clang) _DETERMINE_GCC_SYSTEM_INCLUDE_DIRS(c++ _dirs _defines) set(CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS "${_dirs}" CACHE INTERNAL "CXX compiler system include directories") set(CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS "${_defines}" CACHE INTERNAL "CXX compiler system defined macros") diff --git a/Modules/CMakeFortranCompilerId.F.in b/Modules/CMakeFortranCompilerId.F.in index 6ef798f..1cc08df 100644 --- a/Modules/CMakeFortranCompilerId.F.in +++ b/Modules/CMakeFortranCompilerId.F.in @@ -22,7 +22,21 @@ PRINT *, 'INFO:simulate_version[013.00]' # endif #endif -#if defined(__INTEL_COMPILER) || defined(__ICC) +#if defined(__INTEL_LLVM_COMPILER) + PRINT *, 'INFO:compiler[IntelLLVM]' +! __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and +! later. Look for 6 digit vs. 8 digit version number to decide encoding. +! VVVV is no smaller than the current year when a versio is released. +# if __INTEL_LLVM_COMPILER < 1000000 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +# endif +#elif defined(__INTEL_COMPILER) || defined(__ICC) PRINT *, 'INFO:compiler[Intel]' # define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) # define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) diff --git a/Modules/CMakeTestGNU.c b/Modules/CMakeTestGNU.c index 933e5a2..7dcafde 100644 --- a/Modules/CMakeTestGNU.c +++ b/Modules/CMakeTestGNU.c @@ -1,4 +1,5 @@ -#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +#if defined(__GNUC__) && \ + !(defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)) void THIS_IS_GNU(); #endif #ifdef __MINGW32__ diff --git a/Modules/Compiler/IntelLLVM-ASM.cmake b/Modules/Compiler/IntelLLVM-ASM.cmake new file mode 100644 index 0000000..c258a0a --- /dev/null +++ b/Modules/Compiler/IntelLLVM-ASM.cmake @@ -0,0 +1,12 @@ +include(Compiler/IntelLLVM) +__compiler_intel_llvm(ASM) + +string(APPEND CMAKE_ASM_FLAGS_MINSIZEREL_INIT " -DNDEBUG") +string(APPEND CMAKE_ASM_FLAGS_RELEASE_INIT " -DNDEBUG") +string(APPEND CMAKE_ASM_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG") + +if(UNIX) + set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S) +else() + set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS asm) +endif() diff --git a/Modules/Compiler/IntelLLVM-C.cmake b/Modules/Compiler/IntelLLVM-C.cmake new file mode 100644 index 0000000..0ad2f0d --- /dev/null +++ b/Modules/Compiler/IntelLLVM-C.cmake @@ -0,0 +1,63 @@ +include(Compiler/IntelLLVM) +__compiler_intel_llvm(C) + +if("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") + set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -TC) + set(CMAKE_C_CLANG_TIDY_DRIVER_MODE "cl") + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_C) + set(CMAKE_C_DEPENDS_USE_COMPILER TRUE) + endif() +else() + set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x 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() + + string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG") + string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG") + string(APPEND CMAKE_C_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG") +endif() + +set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON) +set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON) +set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON) +set(CMAKE_C17_STANDARD__HAS_FULL_SUPPORT ON) + +if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") + set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90") + set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90") + + set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99") + set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99") + + set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11") + set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11") + + set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17") + set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17") +else() + # clang-cl doesn't have any of these + set(CMAKE_C90_STANDARD_COMPILE_OPTION "") + set(CMAKE_C90_EXTENSION_COMPILE_OPTION "") + + set(CMAKE_C99_STANDARD_COMPILE_OPTION "") + set(CMAKE_C99_EXTENSION_COMPILE_OPTION "") + + set(CMAKE_C11_STANDARD_COMPILE_OPTION "") + set(CMAKE_C11_EXTENSION_COMPILE_OPTION "") + + set(CMAKE_C17_STANDARD_COMPILE_OPTION "") + set(CMAKE_C17_EXTENSION_COMPILE_OPTION "") +endif() + +if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") + __compiler_check_default_language_standard(C 2020 17) +else() + set(CMAKE_C_STANDARD_DEFAULT "") +endif() diff --git a/Modules/Compiler/IntelLLVM-CXX.cmake b/Modules/Compiler/IntelLLVM-CXX.cmake new file mode 100644 index 0000000..4c0c26e --- /dev/null +++ b/Modules/Compiler/IntelLLVM-CXX.cmake @@ -0,0 +1,69 @@ +include(Compiler/IntelLLVM) +__compiler_intel_llvm(CXX) + +if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") + set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -TP) + set(CMAKE_CXX_CLANG_TIDY_DRIVER_MODE "cl") + if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) + AND CMAKE_GENERATOR MATCHES "Makefiles|WMake" + AND CMAKE_DEPFILE_FLAGS_CXX) + set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE) + endif() +else() + set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++) + 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_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") + + string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG") + string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG") + string(APPEND CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT " -DNDEBUG") +endif() + +set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON) +set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON) +set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON) + +if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98") + set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98") + + 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_CXX17_STANDARD_COMPILE_OPTION "-std=c++17") + set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17") + + set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20") + set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20") +else() + set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "") + set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "") + + set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-Qstd=c++11") + set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-Qstd=c++11") + + set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-Qstd=c++14") + set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-Qstd=c++14") + + set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-Qstd=c++17") + set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-Qstd=c++17") + + set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-Qstd=c++20") + set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-Qstd=c++20") +endif() + +if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + __compiler_check_default_language_standard(CXX 2020 14) +else() + set(CMAKE_CXX_STANDARD_DEFAULT "") +endif() diff --git a/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake b/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake new file mode 100644 index 0000000..124dafe --- /dev/null +++ b/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake @@ -0,0 +1,41 @@ + +set(_compiler_id_pp_test "(defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)") + +set(_compiler_id_version_compute " +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a versio is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__INTEL_LLVM_COMPILER/100) +# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__INTEL_LLVM_COMPILER/10 % 10) +# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__INTEL_LLVM_COMPILER % 10) +#else +# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__INTEL_LLVM_COMPILER/10000) +# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__INTEL_LLVM_COMPILER/100 % 100) +# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(_MSC_VER / 100) +# define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(__GNUC__) +#elif defined(__GNUG__) +# define @PREFIX@SIMULATE_VERSION_MAJOR @MACRO_DEC@(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define @PREFIX@SIMULATE_VERSION_MINOR @MACRO_DEC@(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define @PREFIX@SIMULATE_VERSION_PATCH @MACRO_DEC@(__GNUC_PATCHLEVEL__) +#endif") + +set(_compiler_id_simulate " +#if defined(_MSC_VER) +# define @PREFIX@SIMULATE_ID \"MSVC\" +#endif +#if defined(__GNUC__) +# define @PREFIX@SIMULATE_ID \"GNU\" +#endif") diff --git a/Modules/Compiler/IntelLLVM-Fortran.cmake b/Modules/Compiler/IntelLLVM-Fortran.cmake new file mode 100644 index 0000000..3dfa099 --- /dev/null +++ b/Modules/Compiler/IntelLLVM-Fortran.cmake @@ -0,0 +1,19 @@ +include(Compiler/IntelLLVM) +__compiler_intel_llvm(Fortran) + +set(CMAKE_Fortran_SUBMODULE_SEP "@") +set(CMAKE_Fortran_SUBMODULE_EXT ".smod") + +set(CMAKE_Fortran_MODDIR_FLAG "-module ") +set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-fixed") +set(CMAKE_Fortran_FORMAT_FREE_FLAG "-free") + +set(CMAKE_Fortran_COMPILE_WITH_DEFINES 1) + +set(CMAKE_Fortran_CREATE_PREPROCESSED_SOURCE " -E > ") +set(CMAKE_Fortran_CREATE_ASSEMBLY_SOURCE " -S -o ") + +set(CMAKE_Fortran_PREPROCESS_SOURCE + " -fpp -E > ") +set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-fpp") +set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-nofpp") diff --git a/Modules/Compiler/IntelLLVM.cmake b/Modules/Compiler/IntelLLVM.cmake new file mode 100644 index 0000000..43eb13a --- /dev/null +++ b/Modules/Compiler/IntelLLVM.cmake @@ -0,0 +1,93 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This module is shared by multiple languages; use include blocker. +if(__COMPILER_LLVM_INTEL) + return() +endif() +set(__COMPILER_LLVM_INTEL 1) + +include(Compiler/CMakeCommonCompilerMacros) + +set(__pch_header_C "c-header") +set(__pch_header_CXX "c++-header") +set(__pch_header_OBJC "objective-c-header") +set(__pch_header_OBJCXX "objective-c++-header") + +if(CMAKE_HOST_WIN32) + # MSVC-like + macro(__compiler_intel_llvm lang) + set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-imsvc ") + if(NOT "x${lang}" STREQUAL "xFortran") + set(CMAKE_${lang}_COMPILE_OPTIONS_INVALID_PCH -Winvalid-pch) + endif() + endmacro() +else() + # GNU-like + macro(__compiler_intel_llvm lang) + set(CMAKE_${lang}_VERBOSE_FLAG "-v") + + string(APPEND CMAKE_${lang}_FLAGS_INIT " ") + string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g") + 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") + + set(_CMAKE_${lang}_PIE_MAY_BE_SUPPORTED_BY_LINKER YES) + set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC") + set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE") + set(CMAKE_${lang}_LINK_OPTIONS_PIE ${CMAKE_${lang}_COMPILE_OPTIONS_PIE} "-pie") + set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE "-no-pie") + + set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "-fPIC") + set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared") + + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Wl,") + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",") + + # distcc does not transform -o to -MT when invoking the preprocessor + # internally, as it ought to. Work around this bug by setting -MT here + # even though it isn't strictly necessary. + set(CMAKE_DEPFILE_FLAGS_${lang} "-MD -MT -MF ") + + set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ") + set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") + set(CMAKE_${lang}_COMPILE_OPTIONS_TARGET "--target=") + set(CMAKE_${lang}_COMPILE_OPTIONS_SYSROOT "--sysroot=") + set(CMAKE_${lang}_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN "--gcc-toolchain=") + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlinker" " ") + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP) + + set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES) + set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES) + set(CMAKE_${lang}_COMPILE_OPTIONS_IPO "-flto=thin") + set(CMAKE_${lang}_ARCHIVE_CREATE_IPO "\"${CMAKE_${lang}_COMPILER_AR}\" cr ") + set(CMAKE_${lang}_ARCHIVE_APPEND_IPO "\"${CMAKE_${lang}_COMPILER_AR}\" r ") + set(CMAKE_${lang}_ARCHIVE_FINISH_IPO "\"${CMAKE_${lang}_COMPILER_RANLIB}\" ") + + set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE " -E > ") + set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE " -S -o ") + + set(CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "${CMAKE_${lang}_COMPILER}") + if(CMAKE_${lang}_COMPILER_ARG1) + separate_arguments(_COMPILER_ARGS NATIVE_COMMAND "${CMAKE_${lang}_COMPILER_ARG1}") + list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND ${_COMPILER_ARGS}) + unset(_COMPILER_ARGS) + endif() + list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "-dM" "-E" "-c" "${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp") + if(CMAKE_${lang}_COMPILER_TARGET) + list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "--target=${CMAKE_${lang}_COMPILER_TARGET}") + endif() + + if(NOT "x${lang}" STREQUAL "xFortran") + # Precompile Headers + set(CMAKE_PCH_EXTENSION .pch) + set(CMAKE_PCH_PROLOGUE "#pragma clang system_header") + set(CMAKE_${lang}_COMPILE_OPTIONS_INSTANTIATE_TEMPLATES_PCH -fpch-instantiate-templates) + set(CMAKE_${lang}_COMPILE_OPTIONS_INVALID_PCH -Winvalid-pch) + set(CMAKE_${lang}_COMPILE_OPTIONS_USE_PCH -Xclang -include-pch -Xclang -Xclang -include -Xclang ) + set(CMAKE_${lang}_COMPILE_OPTIONS_CREATE_PCH -Xclang -emit-pch -Xclang -include -Xclang -x ${__pch_header_${lang}}) + endif() + endmacro() +endif() diff --git a/Modules/Platform/Apple-IntelLLVM-C.cmake b/Modules/Platform/Apple-IntelLLVM-C.cmake new file mode 100644 index 0000000..8e74729 --- /dev/null +++ b/Modules/Platform/Apple-IntelLLVM-C.cmake @@ -0,0 +1,2 @@ +include(Platform/Apple-IntelLLVM) +__apple_compiler_intel_llvm(C) diff --git a/Modules/Platform/Apple-IntelLLVM-CXX.cmake b/Modules/Platform/Apple-IntelLLVM-CXX.cmake new file mode 100644 index 0000000..38640e1 --- /dev/null +++ b/Modules/Platform/Apple-IntelLLVM-CXX.cmake @@ -0,0 +1,2 @@ +include(Platform/Apple-IntelLLVM) +__apple_compiler_intel_llvm(CXX) diff --git a/Modules/Platform/Apple-IntelLLVM-Fortran.cmake b/Modules/Platform/Apple-IntelLLVM-Fortran.cmake new file mode 100644 index 0000000..d0486ed --- /dev/null +++ b/Modules/Platform/Apple-IntelLLVM-Fortran.cmake @@ -0,0 +1,8 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +include(Platform/Apple-IntelLLVM) +__apple_compiler_intel_llvm(Fortran) + +set(CMAKE_Fortran_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ") +set(CMAKE_Fortran_OSX_CURRENT_VERSION_FLAG "-current_version ") diff --git a/Modules/Platform/Apple-IntelLLVM.cmake b/Modules/Platform/Apple-IntelLLVM.cmake new file mode 100644 index 0000000..2f9f0ca --- /dev/null +++ b/Modules/Platform/Apple-IntelLLVM.cmake @@ -0,0 +1,17 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This module is shared by multiple languages; use include blocker. +include_guard() + +macro(__apple_compiler_intel_llvm lang) + set(CMAKE_${lang}_VERBOSE_FLAG "-v -Wl,-v") # also tell linker to print verbose output + set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names") + set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS "-bundle -Wl,-headerpad_max_install_names") + + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Wl,") + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",") + + set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") +endmacro() diff --git a/Modules/Platform/Linux-IntelLLVM-C.cmake b/Modules/Platform/Linux-IntelLLVM-C.cmake new file mode 100644 index 0000000..5356c4f --- /dev/null +++ b/Modules/Platform/Linux-IntelLLVM-C.cmake @@ -0,0 +1,3 @@ +include(Platform/Linux-IntelLLVM) +__linux_compiler_intel_llvm(C) +set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-isystem ") diff --git a/Modules/Platform/Linux-IntelLLVM-CXX.cmake b/Modules/Platform/Linux-IntelLLVM-CXX.cmake new file mode 100644 index 0000000..44ce0e8 --- /dev/null +++ b/Modules/Platform/Linux-IntelLLVM-CXX.cmake @@ -0,0 +1,3 @@ +include(Platform/Linux-IntelLLVM) +__linux_compiler_intel_llvm(CXX) +set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ") diff --git a/Modules/Platform/Linux-IntelLLVM-Fortran.cmake b/Modules/Platform/Linux-IntelLLVM-Fortran.cmake new file mode 100644 index 0000000..1cd9b1f --- /dev/null +++ b/Modules/Platform/Linux-IntelLLVM-Fortran.cmake @@ -0,0 +1,4 @@ +include(Platform/Linux-IntelLLVM) +__linux_compiler_intel_llvm(Fortran) +string(APPEND CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS " -nofor-main") +set(CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS "") diff --git a/Modules/Platform/Linux-IntelLLVM.cmake b/Modules/Platform/Linux-IntelLLVM.cmake new file mode 100644 index 0000000..1363b44 --- /dev/null +++ b/Modules/Platform/Linux-IntelLLVM.cmake @@ -0,0 +1,55 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This module is shared by multiple languages; use include blocker. +if(__LINUX_COMPILER_INTEL_LLVM) + return() +endif() +set(__LINUX_COMPILER_INTEL_LLVM 1) + +if(NOT XIAR) + set(_intel_xiar_hints) + foreach(lang C CXX Fortran) + if(IS_ABSOLUTE "${CMAKE_${lang}_COMPILER}") + get_filename_component(_hint "${CMAKE_${lang}_COMPILER}" PATH) + list(APPEND _intel_xiar_hints ${_hint}) + endif() + endforeach() + find_program(XIAR NAMES xiar HINTS ${_intel_xiar_hints}) + mark_as_advanced(XIAR) +endif() + +macro(__linux_compiler_intel_llvm lang) + set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC") + set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE") + set(_CMAKE_${lang}_PIE_MAY_BE_SUPPORTED_BY_LINKER NO) + set(_CMAKE_${lang}_PIE_MAY_BE_SUPPORTED_BY_LINKER YES) + set(CMAKE_${lang}_LINK_OPTIONS_PIE ${CMAKE_${lang}_COMPILE_OPTIONS_PIE} "-pie") + set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE "-no-pie") + set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "-fPIC") + set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared") + + # 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}_LINKER_WRAPPER_FLAG "-Wl,") + set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",") + + set(_CMAKE_${lang}_IPO_SUPPORTED_BY_CMAKE YES) + + if(XIAR) + # INTERPROCEDURAL_OPTIMIZATION + set(CMAKE_${lang}_COMPILE_OPTIONS_IPO -ipo) + set(CMAKE_${lang}_CREATE_STATIC_LIBRARY_IPO + "${XIAR} cr " + "${XIAR} -s ") + set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES) + set(_CMAKE_${lang}_IPO_LEGACY_BEHAVIOR YES) + else() + set(_CMAKE_${lang}_IPO_MAY_BE_SUPPORTED_BY_COMPILER NO) + endif() + + set(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") +endmacro() diff --git a/Modules/Platform/Windows-IntelLLVM-ASM.cmake b/Modules/Platform/Windows-IntelLLVM-ASM.cmake new file mode 100644 index 0000000..f355e49 --- /dev/null +++ b/Modules/Platform/Windows-IntelLLVM-ASM.cmake @@ -0,0 +1,2 @@ +include(Platform/Windows-IntelLLVM) +__windows_compiler_intel(ASM) diff --git a/Modules/Platform/Windows-IntelLLVM-C.cmake b/Modules/Platform/Windows-IntelLLVM-C.cmake new file mode 100644 index 0000000..93c3364 --- /dev/null +++ b/Modules/Platform/Windows-IntelLLVM-C.cmake @@ -0,0 +1,2 @@ +include(Platform/Windows-IntelLLVM) +__windows_compiler_intel(C) diff --git a/Modules/Platform/Windows-IntelLLVM-CXX.cmake b/Modules/Platform/Windows-IntelLLVM-CXX.cmake new file mode 100644 index 0000000..4667895 --- /dev/null +++ b/Modules/Platform/Windows-IntelLLVM-CXX.cmake @@ -0,0 +1,3 @@ +include(Platform/Windows-IntelLLVM) +set(_COMPILE_CXX " /TP") +__windows_compiler_intel(CXX) diff --git a/Modules/Platform/Windows-IntelLLVM-Fortran.cmake b/Modules/Platform/Windows-IntelLLVM-Fortran.cmake new file mode 100644 index 0000000..06d0a00 --- /dev/null +++ b/Modules/Platform/Windows-IntelLLVM-Fortran.cmake @@ -0,0 +1,44 @@ +include(Platform/Windows-IntelLLVM) +set(CMAKE_BUILD_TYPE_INIT Debug) +set(_COMPILE_Fortran " /fpp") +set(CMAKE_Fortran_MODDIR_FLAG "-module:") +set(CMAKE_Fortran_STANDARD_LIBRARIES_INIT "user32.lib") +__windows_compiler_intel(Fortran) +if(CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT) + set(_LIBSDLL "") + set(_DBGLIBS "") + set(_THREADS "") +else() + set(_LIBSDLL " /libs:dll") + set(_DBGLIBS " /dbglibs") + set(_THREADS " /threads") +endif() + +cmake_policy(GET CMP0092 _cmp0092) +if(NOT _cmp0092 STREQUAL "NEW") + string(APPEND CMAKE_Fortran_FLAGS_INIT " /W1") +endif() +unset(_cmp0092) + +string(APPEND CMAKE_Fortran_FLAGS_INIT " /nologo /fpp${_LIBSDLL}${_THREADS}") +string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " /Od /debug:full${_DBGLIBS}") +string(APPEND CMAKE_Fortran_FLAGS_MINSIZEREL_INIT " /O1 /DNDEBUG") +string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " /O2 /DNDEBUG") +string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " /O2 /debug:full /DNDEBUG") +unset(_LIBSDLL) +unset(_DBGLIBS) +unset(_THREADS) + +set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded -threads -libs:static) +set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL -threads -libs:dll) +set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug -threads -libs:static -dbglibs) +set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL -threads -libs:dll -dbglibs) + +# Intel Fortran for Windows supports single-threaded RTL but it is +# not implemented by the Visual Studio integration. +if(NOT CMAKE_GENERATOR MATCHES "Visual Studio") + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_SingleThreaded -libs:static) + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_SingleThreadedDLL -libs:dll) + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_SingleThreadedDebug -libs:static -dbglibs) + set(CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_SingleThreadedDebugDLL -libs:dll -dbglibs) +endif() diff --git a/Modules/Platform/Windows-IntelLLVM.cmake b/Modules/Platform/Windows-IntelLLVM.cmake new file mode 100644 index 0000000..b9ea037 --- /dev/null +++ b/Modules/Platform/Windows-IntelLLVM.cmake @@ -0,0 +1,17 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +# This module is shared by multiple languages; use include blocker. +if(__WINDOWS_INTEL) + return() +endif() +set(__WINDOWS_INTEL 1) + +include(Platform/Windows-MSVC) +macro(__windows_compiler_intel lang) + __windows_compiler_msvc(${lang}) + + set(CMAKE_DEPFILE_FLAGS_${lang} "-QMMD -QMT -QMF ") + set(CMAKE_${lang}_DEPFILE_FORMAT gcc) +endmacro() -- cgit v0.12 From 87909f0600f635a86ae4152868e7fed51d502d3d Mon Sep 17 00:00:00 2001 From: Brad King Date: Wed, 27 Jan 2021 14:57:30 -0500 Subject: Utilities: Suppress warnings in third-party code when using IntelLLVM --- Source/CursesDialog/form/CMakeLists.txt | 2 +- Utilities/cmbzip2/CMakeLists.txt | 2 +- Utilities/cmcurl/CMakeLists.txt | 2 +- Utilities/cmexpat/CMakeLists.txt | 2 +- Utilities/cmjsoncpp/CMakeLists.txt | 2 +- Utilities/cmlibarchive/CMakeLists.txt | 2 +- Utilities/cmliblzma/CMakeLists.txt | 2 +- Utilities/cmlibrhash/CMakeLists.txt | 2 +- Utilities/cmlibuv/CMakeLists.txt | 2 +- Utilities/cmnghttp2/CMakeLists.txt | 2 +- Utilities/cmzlib/CMakeLists.txt | 2 +- Utilities/cmzstd/CMakeLists.txt | 2 +- 12 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Source/CursesDialog/form/CMakeLists.txt b/Source/CursesDialog/form/CMakeLists.txt index 21c499e..8f26b9a 100644 --- a/Source/CursesDialog/form/CMakeLists.txt +++ b/Source/CursesDialog/form/CMakeLists.txt @@ -5,7 +5,7 @@ project(CMAKE_FORM) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmbzip2/CMakeLists.txt b/Utilities/cmbzip2/CMakeLists.txt index cb4a038..9b53b0f 100644 --- a/Utilities/cmbzip2/CMakeLists.txt +++ b/Utilities/cmbzip2/CMakeLists.txt @@ -2,7 +2,7 @@ project(bzip2) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmcurl/CMakeLists.txt b/Utilities/cmcurl/CMakeLists.txt index ecdf3af..327c829 100644 --- a/Utilities/cmcurl/CMakeLists.txt +++ b/Utilities/cmcurl/CMakeLists.txt @@ -95,7 +95,7 @@ endif(APPLE) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmexpat/CMakeLists.txt b/Utilities/cmexpat/CMakeLists.txt index cf31556..b8dc4e8 100644 --- a/Utilities/cmexpat/CMakeLists.txt +++ b/Utilities/cmexpat/CMakeLists.txt @@ -1,6 +1,6 @@ # Disable warnings to avoid changing 3rd party code. IF(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "PathScale") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmjsoncpp/CMakeLists.txt b/Utilities/cmjsoncpp/CMakeLists.txt index 764be8d..74e9988 100644 --- a/Utilities/cmjsoncpp/CMakeLists.txt +++ b/Utilities/cmjsoncpp/CMakeLists.txt @@ -2,7 +2,7 @@ project(JsonCpp CXX) # Disable warnings to avoid changing 3rd party code. if(CMAKE_CXX_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w") elseif(CMAKE_CXX_COMPILER_ID STREQUAL "PathScale") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -woffall") diff --git a/Utilities/cmlibarchive/CMakeLists.txt b/Utilities/cmlibarchive/CMakeLists.txt index 6d6c1fb..689d98a 100644 --- a/Utilities/cmlibarchive/CMakeLists.txt +++ b/Utilities/cmlibarchive/CMakeLists.txt @@ -94,7 +94,7 @@ SET(CMAKE_REQUIRED_FLAGS) # Disable warnings to avoid changing 3rd party code. IF(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "PathScale") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmliblzma/CMakeLists.txt b/Utilities/cmliblzma/CMakeLists.txt index 6b6fae6..32a14dc 100644 --- a/Utilities/cmliblzma/CMakeLists.txt +++ b/Utilities/cmliblzma/CMakeLists.txt @@ -148,7 +148,7 @@ INCLUDE_DIRECTORIES( # Disable warnings to avoid changing 3rd party code. IF(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "PathScale") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmlibrhash/CMakeLists.txt b/Utilities/cmlibrhash/CMakeLists.txt index 1b025fc..37e2399 100644 --- a/Utilities/cmlibrhash/CMakeLists.txt +++ b/Utilities/cmlibrhash/CMakeLists.txt @@ -2,7 +2,7 @@ project(librhash C) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmlibuv/CMakeLists.txt b/Utilities/cmlibuv/CMakeLists.txt index 92d2411..f8b47af 100644 --- a/Utilities/cmlibuv/CMakeLists.txt +++ b/Utilities/cmlibuv/CMakeLists.txt @@ -2,7 +2,7 @@ project(libuv C) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmnghttp2/CMakeLists.txt b/Utilities/cmnghttp2/CMakeLists.txt index 3a11ace..17cc6dd 100644 --- a/Utilities/cmnghttp2/CMakeLists.txt +++ b/Utilities/cmnghttp2/CMakeLists.txt @@ -1,6 +1,6 @@ # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmzlib/CMakeLists.txt b/Utilities/cmzlib/CMakeLists.txt index 0584c55..d266af9 100644 --- a/Utilities/cmzlib/CMakeLists.txt +++ b/Utilities/cmzlib/CMakeLists.txt @@ -2,7 +2,7 @@ PROJECT(CMZLIB) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") diff --git a/Utilities/cmzstd/CMakeLists.txt b/Utilities/cmzstd/CMakeLists.txt index 4f4f91f..323151c 100644 --- a/Utilities/cmzstd/CMakeLists.txt +++ b/Utilities/cmzstd/CMakeLists.txt @@ -2,7 +2,7 @@ project(zstd C) # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES - "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel)$") + "^(GNU|Clang|AppleClang|XLClang|XL|VisualAge|SunPro|HP|Intel|IntelLLVM)$") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w") elseif(CMAKE_C_COMPILER_ID STREQUAL "PathScale") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") -- cgit v0.12 From 32498d0665dfb49ecb9d88790f83c6ca3e75e2b4 Mon Sep 17 00:00:00 2001 From: Brad King Date: Tue, 26 Jan 2021 11:54:41 -0500 Subject: cmake: Reduce default recursion depth when compiling with IntelLLVM This compiler makes stack frames large enough (at least in Debug builds) that CMake language recursion to depth 1000 overflows the stack. Reduce the limit for this compiler. --- Source/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index dca94ee..b3d8369 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -46,6 +46,8 @@ if(NOT CMake_DEFAULT_RECURSION_LIMIT) set(CMake_DEFAULT_RECURSION_LIMIT 100) elseif(MINGW) set(CMake_DEFAULT_RECURSION_LIMIT 400) + elseif(WIN32 AND CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM") + set(CMake_DEFAULT_RECURSION_LIMIT 600) else() set(CMake_DEFAULT_RECURSION_LIMIT 1000) endif() -- cgit v0.12 From 67dfc6556cc8ef06a114c79f17e50dafadae7bce Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: IRSL: Add support for IntelLLVM Use the same code paths as the `Intel` compiler id. Signed-off-by: William R. Dieter --- Modules/InstallRequiredSystemLibraries.cmake | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Modules/InstallRequiredSystemLibraries.cmake b/Modules/InstallRequiredSystemLibraries.cmake index a39393dc..2d08e08 100644 --- a/Modules/InstallRequiredSystemLibraries.cmake +++ b/Modules/InstallRequiredSystemLibraries.cmake @@ -71,7 +71,7 @@ cmake_policy(SET CMP0054 NEW) # if() quoted variables not dereferenced set(_IRSL_HAVE_Intel FALSE) set(_IRSL_HAVE_MSVC FALSE) foreach(LANG IN ITEMS C CXX Fortran) - if("${CMAKE_${LANG}_COMPILER_ID}" STREQUAL "Intel") + if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "Intel") if(NOT _IRSL_HAVE_Intel) get_filename_component(_Intel_basedir "${CMAKE_${LANG}_COMPILER}" PATH) if(CMAKE_SIZEOF_VOID_P EQUAL 8) @@ -637,10 +637,10 @@ if(_IRSL_HAVE_Intel) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") endforeach() - if(CMAKE_C_COMPILER_ID STREQUAL Intel OR CMAKE_CXX_COMPILER_ID STREQUAL Intel) + if(CMAKE_C_COMPILER_ID MATCHES Intel OR CMAKE_CXX_COMPILER_ID MATCHES Intel) list(APPEND __install_libs "${_Intel_redistdir}/libgfxoffload.dll") endif() - if(CMAKE_Fortran_COMPILER_ID STREQUAL Intel) + if(CMAKE_Fortran_COMPILER_ID MATCHES Intel) foreach(__Intel_lib IN ITEMS ifdlg100.dll libicaf.dll libifcoremd.dll libifcoremdd.dll libifcorert.dll libifcorertd.dll libifportmd.dll) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") @@ -650,12 +650,12 @@ if(_IRSL_HAVE_Intel) foreach(__Intel_lib IN ITEMS libchkp.dylib libcilkrts.5.dylib libcilkrts.dylib libimf.dylib libintlc.dylib libirc.dylib libirng.dylib libsvml.dylib) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") endforeach() - if(CMAKE_C_COMPILER_ID STREQUAL Intel OR CMAKE_CXX_COMPILER_ID STREQUAL Intel) + if(CMAKE_C_COMPILER_ID MATCHES Intel OR CMAKE_CXX_COMPILER_ID MATCHES Intel) if(_Intel_compiler_ver VERSION_LESS 17) list(APPEND __install_libs "${_Intel_redistdir}/libistrconv.dylib") endif() endif() - if(CMAKE_Fortran_COMPILER_ID STREQUAL Intel) + if(CMAKE_Fortran_COMPILER_ID MATCHES Intel) foreach(__Intel_lib IN ITEMS libifcore.dylib libifcoremt.dylib libifport.dylib libifportmt.dylib) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") @@ -672,7 +672,7 @@ if(_IRSL_HAVE_Intel) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") endforeach() endif() - if(CMAKE_C_COMPILER_ID STREQUAL Intel OR CMAKE_CXX_COMPILER_ID STREQUAL Intel) + if(CMAKE_C_COMPILER_ID MATCHES Intel OR CMAKE_CXX_COMPILER_ID MATCHES Intel) set(__install_dirs "${_Intel_redistdir}/irml") list(APPEND __install_libs "${_Intel_redistdir}/cilk_db.so") if(_Intel_compiler_ver VERSION_GREATER_EQUAL 15) @@ -691,7 +691,7 @@ if(_IRSL_HAVE_Intel) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") endforeach() endif() - if(CMAKE_Fortran_COMPILER_ID STREQUAL Intel) + if(CMAKE_Fortran_COMPILER_ID MATCHES Intel) foreach(__Intel_lib IN ITEMS libicaf.so libifcore.so libifcore.so.5 libifcoremt.so libifcoremt.so.5 libifport.so libifport.so.5) list(APPEND __install_libs "${_Intel_redistdir}/${__Intel_lib}") -- cgit v0.12 From 90941a18964e042c269faf2ae57a813c1361b941 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: FindMPI: Add support for IntelLLVM Signed-off-by: William R. Dieter --- Modules/FindMPI.cmake | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/Modules/FindMPI.cmake b/Modules/FindMPI.cmake index 8476823..8cc39ac 100644 --- a/Modules/FindMPI.cmake +++ b/Modules/FindMPI.cmake @@ -294,6 +294,11 @@ if(WIN32) set(_MPI_Intel_CXX_COMPILER_NAMES mpiicpc.bat) 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) + # Intel MPI compiler names for MSMPI set(_MPI_MSVC_C_COMPILER_NAMES mpicl.bat) set(_MPI_MSVC_CXX_COMPILER_NAMES mpicl.bat) @@ -302,6 +307,11 @@ else() set(_MPI_Intel_C_COMPILER_NAMES mpiicc) set(_MPI_Intel_CXX_COMPILER_NAMES mpiicpc mpiicxx mpiic++) 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) endif() # PGI compiler names @@ -327,7 +337,7 @@ set(_MPI_XL_Fortran_COMPILER_NAMES mpixlf95 mpixlf95_r mpxlf95 mpxlf95 # pick up the right settings for it. foreach (LANG IN ITEMS C CXX Fortran) set(_MPI_${LANG}_COMPILER_NAMES "") - foreach (id IN ITEMS GNU Intel MSVC PGI XL) + foreach (id IN ITEMS GNU Intel IntelLLVM MSVC PGI XL) if (NOT CMAKE_${LANG}_COMPILER_ID OR CMAKE_${LANG}_COMPILER_ID STREQUAL id) foreach(_COMPILER_NAME IN LISTS _MPI_${id}_${LANG}_COMPILER_NAMES) list(APPEND _MPI_${LANG}_COMPILER_NAMES ${_COMPILER_NAME}${MPI_EXECUTABLE_SUFFIX}) -- cgit v0.12 From 042aba3db4e2f062a91b62579b6b1957a53b1ec2 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: FindOpenMP: Add support for IntelLLVM Signed-off-by: William R. Dieter --- Modules/FindOpenMP.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/Modules/FindOpenMP.cmake b/Modules/FindOpenMP.cmake index 11c6050..a1ffc25 100644 --- a/Modules/FindOpenMP.cmake +++ b/Modules/FindOpenMP.cmake @@ -113,6 +113,7 @@ function(_OPENMP_FLAG_CANDIDATES LANG) else() set(OMP_FLAG_Intel "-qopenmp") endif() + set(OMP_FLAG_IntelLLVM "-fiopenmp") set(OMP_FLAG_MSVC "-openmp") set(OMP_FLAG_PathScale "-openmp") set(OMP_FLAG_NAG "-openmp") -- cgit v0.12 From 37ac9df3424663c49b1c1992fcbd3e64833c6936 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: FindBoost: Add support for IntelLLVM Use the same code paths as the `Intel` compiler. Signed-off-by: William R. Dieter --- Modules/FindBoost.cmake | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Modules/FindBoost.cmake b/Modules/FindBoost.cmake index e41e864..6ee425b 100644 --- a/Modules/FindBoost.cmake +++ b/Modules/FindBoost.cmake @@ -853,7 +853,8 @@ endfunction() # Guesses Boost's compiler prefix used in built library names # Returns the guess by setting the variable pointed to by _ret function(_Boost_GUESS_COMPILER_PREFIX _ret) - if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel") + if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel" + OR "x${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "xIntelLLVM") if(WIN32) set (_boost_COMPILER "-iw") else() @@ -1891,7 +1892,8 @@ endif() if(WIN32 AND Boost_USE_DEBUG_RUNTIME) if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang" - OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel") + OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel" + OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM") string(APPEND _boost_DEBUG_ABI_TAG "g") endif() endif() -- cgit v0.12 From aedb9add56f09a43755948bf973d7f9893a0a0ea Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 2 Nov 2020 20:11:25 -0500 Subject: FindBLAS: Add support for IntelLLVM Signed-off-by: William R. Dieter --- Modules/FindBLAS.cmake | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Modules/FindBLAS.cmake b/Modules/FindBLAS.cmake index 01d0236..4cf812b 100644 --- a/Modules/FindBLAS.cmake +++ b/Modules/FindBLAS.cmake @@ -842,6 +842,9 @@ if(BLA_VENDOR MATCHES "ACML" OR BLA_VENDOR STREQUAL "All") if(CMAKE_Fortran_COMPILER_ID STREQUAL "Intel") set(_ACML_COMPILER32 "ifort32") set(_ACML_COMPILER64 "ifort64") + elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "IntelLLVM") + # 32-bit not supported + set(_ACML_COMPILER64 "ifx") elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "SunPro") set(_ACML_COMPILER32 "sun32") set(_ACML_COMPILER64 "sun64") -- cgit v0.12 From 882baca37b07dde28443c11faf052f35834d0da3 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Fri, 15 Jan 2021 02:03:34 -0500 Subject: Tests: Update Fortran tests for IntelLLVM Update checks for the `Intel` compiler id to match `IntelLLVM` too. Signed-off-by: William R. Dieter --- Tests/Fortran/CMakeLists.txt | 2 +- Tests/FortranOnly/CMakeLists.txt | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Tests/Fortran/CMakeLists.txt b/Tests/Fortran/CMakeLists.txt index 929fa4d..1868892 100644 --- a/Tests/Fortran/CMakeLists.txt +++ b/Tests/Fortran/CMakeLists.txt @@ -120,7 +120,7 @@ endfunction() # if the id's match or the compilers are compatible, then # call the test_fortran_c_interface_module function if("${CMAKE_Fortran_COMPILER_ID}:${CMAKE_C_COMPILER_ID}" MATCHES - "(Intel:MSVC|Absoft:GNU)" + "(Intel(LLVM)?:MSVC|Absoft:GNU)" OR ("${CMAKE_Fortran_COMPILER_ID}" STREQUAL "${CMAKE_C_COMPILER_ID}" )) test_fortran_c_interface_module() else() diff --git a/Tests/FortranOnly/CMakeLists.txt b/Tests/FortranOnly/CMakeLists.txt index b40f05e..b5b5e56 100644 --- a/Tests/FortranOnly/CMakeLists.txt +++ b/Tests/FortranOnly/CMakeLists.txt @@ -111,7 +111,7 @@ endif() # Test that with Intel Fortran we always compile with preprocessor # defines even if splitting the preprocessing and compilation steps. -if(CMAKE_Fortran_COMPILER_ID STREQUAL "Intel") +if(CMAKE_Fortran_COMPILER_ID MATCHES "Intel") add_executable(IntelIfDef IntelIfDef.f) set_property(TARGET IntelIfDef PROPERTY Fortran_FORMAT FIXED) target_compile_definitions(IntelIfDef PRIVATE SOME_DEF) @@ -152,7 +152,7 @@ if(test_pp_flags AND NOT CMAKE_Fortran_COMPILER_ID MATCHES "(Flang|NAG|PGI|NVHPC add_library(no_preprocess_source STATIC no_preprocess_source_upper.F) target_compile_options(no_preprocess_source PRIVATE -DINTEGER=nonsense) if(NOT CMAKE_Fortran_COMPILER_ID STREQUAL "Cray" - AND NOT "${CMAKE_Fortran_COMPILER_ID};${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "Intel;MSVC") + AND NOT "${CMAKE_Fortran_COMPILER_ID};${CMAKE_Fortran_SIMULATE_ID}" MATCHES "Intel(LLVM)?;MSVC") target_sources(no_preprocess_target PRIVATE no_preprocess_target_fpp.fpp) target_sources(no_preprocess_source PRIVATE no_preprocess_source_fpp.fpp) endif() -- cgit v0.12 From ae9f986da1d493f243c0c4bca7dab8dcee6a2861 Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 12:59:21 -0500 Subject: Tests: Update Assembler test for IntelLLVM Enable parts of the test the same way we do for `Intel`. --- Tests/Assembler/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/Assembler/CMakeLists.txt b/Tests/Assembler/CMakeLists.txt index a574c4e..0a2c819 100644 --- a/Tests/Assembler/CMakeLists.txt +++ b/Tests/Assembler/CMakeLists.txt @@ -9,7 +9,7 @@ set(SRCS) # and also generate assembler files from C: if("${CMAKE_GENERATOR}" MATCHES "Makefile|Xcode|Ninja" AND NOT CMAKE_OSX_ARCHITECTURES MATCHES ";") - if((CMAKE_C_COMPILER_ID MATCHES "^(GNU|Clang|AppleClang|HP|SunPro|XL)$") OR (CMAKE_C_COMPILER_ID STREQUAL "Intel" AND UNIX) + if((CMAKE_C_COMPILER_ID MATCHES "^(GNU|Clang|AppleClang|HP|SunPro|XL)$") OR (CMAKE_C_COMPILER_ID MATCHES "Intel" AND UNIX) AND NOT (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")) set(C_FLAGS "${CMAKE_C_FLAGS}") separate_arguments(C_FLAGS) -- cgit v0.12 From 7de61526a01305b058dad99a11b81e2d3fe18ed6 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Fri, 15 Jan 2021 17:02:16 -0500 Subject: Tests: Update CPack DEBUGINFO tests for IntelLLVM By default icx and icpx do not add build IDs when linking, so enable the build ID to make the test pass. Signed-off-by: William R. Dieter --- Tests/RunCMake/CPack/tests/DEBUGINFO/test.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/RunCMake/CPack/tests/DEBUGINFO/test.cmake b/Tests/RunCMake/CPack/tests/DEBUGINFO/test.cmake index 04b44f6..9ff1f8a 100644 --- a/Tests/RunCMake/CPack/tests/DEBUGINFO/test.cmake +++ b/Tests/RunCMake/CPack/tests/DEBUGINFO/test.cmake @@ -1,7 +1,7 @@ set(CMAKE_BUILD_WITH_INSTALL_RPATH 1) # Some compilers do not add build id to binaries by default. -if(CMAKE_CXX_COMPILER_ID MATCHES "^(PGI|NVHPC)$") +if(CMAKE_CXX_COMPILER_ID MATCHES "^(IntelLLVM|PGI|NVHPC)$") string(APPEND CMAKE_EXE_LINKER_FLAGS "-Wl,--build-id") string(APPEND CMAKE_SHARED_LINKER_FLAGS "-Wl,--build-id") endif() -- cgit v0.12 From d83df2af57d79ec2a38ce03b5ca08f21e137b717 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Fri, 15 Jan 2021 19:20:27 -0500 Subject: Tests: Update Preprocess test for IntelLLVM Work around an icx bug in command line handling of preprocessor macros. A `\\\"` string in a macro passed to icx on the command line is not properly parsed in compiler versions 2021.1.0 and earlier. This problem is expected to be fixed, though a target release has no been set yet. Signed-off-by: William R. Dieter --- Tests/Preprocess/CMakeLists.txt | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Tests/Preprocess/CMakeLists.txt b/Tests/Preprocess/CMakeLists.txt index bce1b3f..bf2af64 100644 --- a/Tests/Preprocess/CMakeLists.txt +++ b/Tests/Preprocess/CMakeLists.txt @@ -147,8 +147,13 @@ endif() # - NMake is okay with just \\\" # - The XL compiler does not re-escape \\\" when launching an # internal tool to do preprocessing . +# - The IntelLLVM C and C++ compiler drivers do not re-escape the \\\" when +# launching the underlying compiler. FIXME: this bug is expected to be fixed +# in a future release. if((PP_NMAKE OR PP_UMAKE) AND - NOT CMAKE_C_COMPILER_ID STREQUAL "XL") + NOT CMAKE_C_COMPILER_ID STREQUAL "XL" AND + NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM" AND + NOT CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM") string(APPEND STRING_EXTRA "\\\"") endif() -- cgit v0.12 From 12720a5b71ebc6e9a800c126ad62857099588cc6 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Thu, 21 Jan 2021 19:50:50 -0500 Subject: Tests: Update MSVCRuntimeLibrary.Fortran test for IntelLLVM `ifx` needs the same command line arguments as `ifort`. Signed-off-by: William R. Dieter --- Tests/MSVCRuntimeLibrary/Fortran/CMakeLists.txt | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Tests/MSVCRuntimeLibrary/Fortran/CMakeLists.txt b/Tests/MSVCRuntimeLibrary/Fortran/CMakeLists.txt index 27838a4..41bd6f5 100644 --- a/Tests/MSVCRuntimeLibrary/Fortran/CMakeLists.txt +++ b/Tests/MSVCRuntimeLibrary/Fortran/CMakeLists.txt @@ -6,8 +6,9 @@ foreach(t MultiThreaded SingleThreaded) foreach(dbg "" Debug) foreach(dll "" DLL) set(var "CMAKE_Fortran_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_${t}${dbg}${dll}") - if(CMAKE_Fortran_COMPILER_ID STREQUAL "Intel") - # ifort does not actually define these, so inject them + if(CMAKE_Fortran_COMPILER_ID STREQUAL "Intel" + OR CMAKE_Fortran_COMPILER_ID STREQUAL "IntelLLVM") + # ifort and ifx do not actually define these, so inject them string(REPLACE "-threads" "-threads;-D_MT" "${var}" "${${var}}") string(REPLACE "-dbglibs" "-dbglibs;-D_DEBUG" "${var}" "${${var}}") elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "Flang") -- cgit v0.12 From 3ceb364b1c0bed59a2f0148a004882d374e23a5d Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 10:24:43 -0500 Subject: Tests: Update RunCMake.FileAPI for IntelLLVM --- Tests/RunCMake/FileAPI/codemodel-v2-check.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/RunCMake/FileAPI/codemodel-v2-check.py b/Tests/RunCMake/FileAPI/codemodel-v2-check.py index c66757f..df2410a 100644 --- a/Tests/RunCMake/FileAPI/codemodel-v2-check.py +++ b/Tests/RunCMake/FileAPI/codemodel-v2-check.py @@ -608,7 +608,7 @@ def gen_check_targets(c, g, inSource): read_codemodel_json_data("targets/generated_exe.json"), ] - if cxx_compiler_id in ['Clang', 'AppleClang', 'GNU', 'Intel', 'MSVC', 'Embarcadero'] and g["name"] != "Xcode": + if cxx_compiler_id in ['Clang', 'AppleClang', 'GNU', 'Intel', 'IntelLLVM', 'MSVC', 'Embarcadero'] and g["name"] != "Xcode": for e in expected: if e["name"] == "cxx_exe": if matches(g["name"], "^(Visual Studio |Ninja Multi-Config)"): -- cgit v0.12 From f26f10184fda39fd029ebc5fd4e72a55af5d3509 Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 10:29:08 -0500 Subject: Tests: Update Module.WriteCompilerDetectionHeader for IntelLLVM --- Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt index 7339222..0cf74bf 100644 --- a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt +++ b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt @@ -52,7 +52,7 @@ endmacro() # detailed features tables, not just meta-features if (CMAKE_C_COMPILE_FEATURES) - if(NOT CMAKE_C_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang)$") + if(NOT CMAKE_C_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|IntelLLVM)$") set(C_expected_features ${CMAKE_C_COMPILE_FEATURES}) list(FILTER C_expected_features EXCLUDE REGEX "^c_std_[0-9][0-9]") endif() @@ -95,7 +95,7 @@ if (C_expected_features) endif() if (CMAKE_CXX_COMPILE_FEATURES) - if(NOT CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang)$") + if(NOT CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|IntelLLVM)$") set(CXX_expected_features ${CMAKE_CXX_COMPILE_FEATURES}) list(FILTER CXX_expected_features EXCLUDE REGEX "^cxx_std_[0-9][0-9]") endif() -- cgit v0.12 From 01b1e9c40df7bc31265c61196a32a9229dd3c26d Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 14:52:19 -0500 Subject: Tests: Update CompileFeatures test for IntelLLVM We do not have granular features for this compiler. --- Tests/CompileFeatures/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Tests/CompileFeatures/CMakeLists.txt b/Tests/CompileFeatures/CMakeLists.txt index a608b6a..cff98e3 100644 --- a/Tests/CompileFeatures/CMakeLists.txt +++ b/Tests/CompileFeatures/CMakeLists.txt @@ -18,7 +18,7 @@ macro(run_test feature lang) endif() endmacro() -if(NOT CMAKE_C_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang)$") +if(NOT CMAKE_C_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|IntelLLVM)$") get_property(c_features GLOBAL PROPERTY CMAKE_C_KNOWN_FEATURES) list(FILTER c_features EXCLUDE REGEX "^c_std_[0-9][0-9]") foreach(feature ${c_features}) @@ -26,7 +26,7 @@ if(NOT CMAKE_C_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang)$") endforeach() endif() -if(NOT CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang)$") +if(NOT CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|IntelLLVM)$") get_property(cxx_features GLOBAL PROPERTY CMAKE_CXX_KNOWN_FEATURES) list(FILTER cxx_features EXCLUDE REGEX "^cxx_std_[0-9][0-9]") foreach(feature ${cxx_features}) -- cgit v0.12 From 661b04d6a66f0189c57c306cb57c8ba1863feff4 Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 15:36:56 -0500 Subject: Tests: Skip old PrecompiledHeader test on IntelLLVM This test uses hard-coded flags for a fixed set of compilers. We have first-class PCH support implemented for IntelLLVM. --- Tests/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index d28d89f..c24bb9f 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -1948,7 +1948,7 @@ if(BUILD_TESTING) if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR NOT "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") ADD_TEST_MACRO(ForceInclude foo) endif() - if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang") + if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM") ADD_TEST_MACRO(PrecompiledHeader foo) endif() set(MSVCRuntimeLibrary_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA}) -- cgit v0.12 From a619b327686718e10bdecdf2a5d677bfcd4789b5 Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 22 Jan 2021 15:57:43 -0500 Subject: Tests: Update RunCMake.GenerateExportHeader for IntelLLVM On Windows, the expected results are like Clang's. --- Tests/RunCMake/GenerateExportHeader/GEH.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/RunCMake/GenerateExportHeader/GEH.cmake b/Tests/RunCMake/GenerateExportHeader/GEH.cmake index ae9a84c..431d1ce 100644 --- a/Tests/RunCMake/GenerateExportHeader/GEH.cmake +++ b/Tests/RunCMake/GenerateExportHeader/GEH.cmake @@ -103,7 +103,7 @@ add_executable(GenerateExportHeader exportheader_test.cpp) target_link_libraries(GenerateExportHeader ${link_libraries}) if (WIN32 OR CYGWIN) - if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + if((CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM") AND CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") set(_platform Win32-Clang) elseif(MSVC AND COMPILER_HAS_DEPRECATED) -- cgit v0.12 From ddaf412dd035dbc85d33634d2cfb0b3a8bcdf804 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Fri, 22 Jan 2021 17:19:16 -0500 Subject: Tests: Skip per file PDBs in PDBDirectoryAndName for IntelLLVM The IntelLLVM C compiler do not yet support PDBs per file with the /Fd option. Disable the parts of PDBDirectoryAndName that tries to generate them so that the test will pass. --- Tests/PDBDirectoryAndName/CMakeLists.txt | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Tests/PDBDirectoryAndName/CMakeLists.txt b/Tests/PDBDirectoryAndName/CMakeLists.txt index 95aa351..5aa2459 100644 --- a/Tests/PDBDirectoryAndName/CMakeLists.txt +++ b/Tests/PDBDirectoryAndName/CMakeLists.txt @@ -9,8 +9,9 @@ endif() # Intel 11.1 does not support /Fd but Intel 14.0 does. # TODO: Did a version in between these add it? -if(CMAKE_C_COMPILER_ID STREQUAL Intel AND - CMAKE_C_COMPILER_VERSION VERSION_LESS 14.0) +if((CMAKE_C_COMPILER_ID STREQUAL Intel AND + CMAKE_C_COMPILER_VERSION VERSION_LESS 14.0) OR + CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM") set(NO_COMPILE_PDB 1) endif() -- cgit v0.12 From ccdf7c000529782029a9956021a147e214521864 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Mon, 25 Jan 2021 20:26:13 -0500 Subject: Tests: Skip VSGNUFortran test for ifx. DLLEXPORT is not implemented in ifx yet, and required by this test. --- Tests/CMakeLists.txt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index c24bb9f..a633bd2 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -429,6 +429,10 @@ if(BUILD_TESTING) set(CMAKE_SKIP_VSGNUFortran TRUE) endif() endif() + if(CMAKE_Fortran_COMPILER_ID STREQUAL IntelLLVM) + message(STATUS "Skip VSGNUFortran for ifx until DLLEXPORT support is implemented") + set(CMAKE_SKIP_VSGNUFortran TRUE) + endif() if((CMAKE_C_COMPILER MATCHES lsb) AND (CMAKE_Fortran_COMPILER MATCHES ifort)) message(STATUS "Skip VSGNUFortran for ifort and lsb compilers") -- cgit v0.12 From 9b5fd04905811ef5fcae740c9edbf5dca7db0511 Mon Sep 17 00:00:00 2001 From: "William R. Dieter" Date: Tue, 26 Jan 2021 03:06:52 -0500 Subject: Tests: Disable MFC test for IntelLLVM due to #18311 clang-cl cannot deal with implicit dependencies in UTF16 files (see #18311). IntelLLVM inherits this behavior from Clang. The MFC test uses `rc` in the way described in #18311 and gets the same error described in #18311. Disable the test until #18311 is fixed. Signed-off-by: William R. Dieter --- Tests/CMakeLists.txt | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index a633bd2..4ed902c 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -2018,12 +2018,19 @@ if(BUILD_TESTING) endif() endif() - # For the Watcom WMake generator, avoid the MFC test by default. if(CTEST_RUN_MFC) + # For the Watcom WMake generator, avoid the MFC test by default. if("${CMAKE_GENERATOR}" MATCHES "WMake") message(STATUS "using the Watcom WMake generator, avoiding MFC test") set(CTEST_RUN_MFC OFF) + elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "IntelLLVM") + # clang-cl cannot deal with implicit dependencies in UTF16 files + # (see #18311). IntelLLVM inherits this behavior from Clang. + # TODO: maybe clang should also skip the MFC test + message(STATUS + "using generator other than Visual Studio with clang-cl, avoiding MFC test") + set(CTEST_RUN_MFC OFF) endif() endif() -- cgit v0.12