Merge topic 'cuda-host-compiler-id'

3b4d0df670 NVCC: Detect host compiler id and version
38cacd83a5 Tests: Migrate compiler id tests to RunCMake infrastructure
37173f1ccc Tests/RunCMake: Generalize construction of arguments for languages to test

Acked-by: Kitware Robot <[email protected]>
Tested-by: buildbot <[email protected]>
Merge-request: !9841

Help/manual/cmake-variables.7.rst

@@ -637,6 +637,8 @@ Variables for Languages
    /variable/CMAKE_LANG_FLAGS_RELWITHDEBINFO
    /variable/CMAKE_LANG_FLAGS_RELWITHDEBINFO_INIT
    /variable/CMAKE_LANG_HOST_COMPILER
+   /variable/CMAKE_LANG_HOST_COMPILER_ID
+   /variable/CMAKE_LANG_HOST_COMPILER_VERSION
    /variable/CMAKE_LANG_IGNORE_EXTENSIONS
    /variable/CMAKE_LANG_IMPLICIT_INCLUDE_DIRECTORIES
    /variable/CMAKE_LANG_IMPLICIT_LINK_DIRECTORIES

Help/release/dev/cuda-host-compiler-id.rst

@@ -0,0 +1,8 @@
+cuda-host-compiler-id
+---------------------
+
+* The :variable:`CMAKE_<LANG>_HOST_COMPILER_ID` and
+  :variable:`CMAKE_<LANG>_HOST_COMPILER_VERSION` variables were added,
+  where ``<LANG>`` is either ``CUDA`` or ``HIP``.  They are populated
+  when :variable:`CMAKE_<LANG>_COMPILER_ID` is ``NVIDIA`` to identify
+  NVCC's host compiler.

Help/variable/CMAKE_LANG_HOST_COMPILER.rst

@@ -42,3 +42,8 @@ variable is read-only and changes to it are undefined behavior.
 .. note::
 
   Ignored when using :ref:`Visual Studio Generators`.
+
+See the :variable:`CMAKE_<LANG>_HOST_COMPILER_ID` and
+:variable:`CMAKE_<LANG>_HOST_COMPILER_VERSION` variables for
+information about the host compiler used by ``nvcc``, whether
+by default or specified by ``CMAKE_<LANG>_HOST_COMPILER``.

Help/variable/CMAKE_LANG_HOST_COMPILER_ID.rst

@@ -0,0 +1,10 @@
+CMAKE_<LANG>_HOST_COMPILER_ID
+-----------------------------
+
+.. versionadded:: 3.31
+
+This variable is available when ``<LANG>`` is ``CUDA`` or ``HIP``
+and :variable:`CMAKE_<LANG>_COMPILER_ID` is ``NVIDIA``.
+It contains the identity of the host compiler invoked by ``nvcc``,
+either by default or as specified by :variable:`CMAKE_<LANG>_HOST_COMPILER`,
+among possibilities documented by :variable:`CMAKE_<LANG>_COMPILER_ID`.

Help/variable/CMAKE_LANG_HOST_COMPILER_VERSION.rst

@@ -0,0 +1,10 @@
+CMAKE_<LANG>_HOST_COMPILER_VERSION
+----------------------------------
+
+.. versionadded:: 3.31
+
+This variable is available when ``<LANG>`` is ``CUDA`` or ``HIP``
+and :variable:`CMAKE_<LANG>_COMPILER_ID` is ``NVIDIA``.
+It contains the version of the host compiler invoked by ``nvcc``,
+either by default or as specified by :variable:`CMAKE_<LANG>_HOST_COMPILER`,
+in the same format as :variable:`CMAKE_<LANG>_COMPILER_VERSION`.

Modules/CMakeCUDACompiler.cmake.in

@@ -3,6 +3,8 @@ set(CMAKE_CUDA_HOST_COMPILER "@CMAKE_CUDA_HOST_COMPILER@")
 set(CMAKE_CUDA_HOST_LINK_LAUNCHER "@CMAKE_CUDA_HOST_LINK_LAUNCHER@")
 set(CMAKE_CUDA_COMPILER_ID "@CMAKE_CUDA_COMPILER_ID@")
 set(CMAKE_CUDA_COMPILER_VERSION "@CMAKE_CUDA_COMPILER_VERSION@")
+set(CMAKE_CUDA_HOST_COMPILER_ID "@CMAKE_CUDA_HOST_COMPILER_ID@")
+set(CMAKE_CUDA_HOST_COMPILER_VERSION "@CMAKE_CUDA_HOST_COMPILER_VERSION@")
 set(CMAKE_CUDA_DEVICE_LINKER "@CMAKE_CUDA_DEVICE_LINKER@")
 set(CMAKE_CUDA_FATBINARY "@CMAKE_CUDA_FATBINARY@")
 set(CMAKE_CUDA_STANDARD_COMPUTED_DEFAULT "@CMAKE_CUDA_STANDARD_COMPUTED_DEFAULT@")

Modules/CMakeCUDACompilerId.cu.in

@@ -16,6 +16,28 @@ char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
 @CMAKE_CUDA_COMPILER_ID_PLATFORM_CONTENT@
 @CMAKE_CUDA_COMPILER_ID_ERROR_FOR_TEST@
 
+#ifdef HOST_COMPILER_ID
+char const* info_host_compiler = "INFO" ":" "host_compiler[" HOST_COMPILER_ID "]";
+#endif
+#ifdef HOST_COMPILER_VERSION
+char const* info_host_compiler_version = "INFO" ":" "host_compiler_version[" HOST_COMPILER_VERSION "]";
+#elif defined(HOST_COMPILER_VERSION_MAJOR)
+char const info_host_compiler_version[] = {
+  'I', 'N', 'F', 'O', ':','h','o','s','t','_',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  HOST_COMPILER_VERSION_MAJOR,
+# ifdef HOST_COMPILER_VERSION_MINOR
+  '.', HOST_COMPILER_VERSION_MINOR,
+#  ifdef HOST_COMPILER_VERSION_PATCH
+   '.', HOST_COMPILER_VERSION_PATCH,
+#   ifdef HOST_COMPILER_VERSION_TWEAK
+    '.', HOST_COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
 #define CXX_STD_11 201103L
 #define CXX_STD_14 201402L
 #define CXX_STD_17 201703L
@@ -74,6 +96,12 @@ int main(int argc, char* argv[])
 #endif
 #ifdef SIMULATE_VERSION_MAJOR
   require += info_simulate_version[argc];
+#endif
+#ifdef HOST_COMPILER_ID
+  require += info_host_compiler[argc];
+#endif
+#ifdef HOST_COMPILER_VERSION_MAJOR
+  require += info_host_compiler_version[argc];
 #endif
   require += info_language_standard_default[argc];
   require += info_language_extensions_default[argc];

Modules/CMakeDetermineCompilerId.cmake

@@ -347,8 +347,17 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
     else()
       set(_archid "")
     endif()
+    if(CMAKE_${lang}_HOST_COMPILER_ID)
+      set(_hostcc " with host compiler ${CMAKE_${lang}_HOST_COMPILER_ID}")
+      if(CMAKE_${lang}_HOST_COMPILER_VERSION)
+        string(APPEND _hostcc " ${CMAKE_${lang}_HOST_COMPILER_VERSION}")
+      endif()
+    else()
+      set(_hostcc "")
+    endif()
     message(STATUS "The ${lang} compiler identification is "
-      "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}${_variant}")
+      "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}${_variant}${_hostcc}")
+    unset(_hostcc)
     unset(_archid)
     unset(_version)
     unset(_variant)
@@ -373,6 +382,8 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
   set(CMAKE_${lang}_COMPILER_WRAPPER "${CMAKE_${lang}_COMPILER_WRAPPER}" PARENT_SCOPE)
   set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE)
   set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE)
+  set(CMAKE_${lang}_HOST_COMPILER_ID "${CMAKE_${lang}_HOST_COMPILER_ID}" PARENT_SCOPE)
+  set(CMAKE_${lang}_HOST_COMPILER_VERSION "${CMAKE_${lang}_HOST_COMPILER_VERSION}" PARENT_SCOPE)
   set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE)
   set(CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT "${CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT}" PARENT_SCOPE)
   set(CMAKE_${lang}_COMPILER_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE)
@@ -395,6 +406,22 @@ function(CMAKE_DETERMINE_COMPILER_ID_WRITE lang src)
     PLATFORM_DEFAULT_COMPILER
   )
 
+  if(lang MATCHES "^(CUDA|HIP)$")
+    compiler_id_detection(CMAKE_${lang}_HOST_COMPILER_ID_CONTENT CXX
+      PREFIX HOST_
+      ID_STRING
+      VERSION_STRINGS
+    )
+    string(APPEND CMAKE_${lang}_COMPILER_ID_CONTENT
+      "\n"
+      "\n"
+      "/* Detect host compiler used by NVCC. */\n"
+      "#ifdef __NVCC__\n"
+      "${CMAKE_${lang}_HOST_COMPILER_ID_CONTENT}\n"
+      "#endif /* __NVCC__ */\n"
+    )
+  endif()
+
   unset(src_in CACHE)
   string(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY)
   file(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}")
@@ -941,6 +968,8 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
     set(ARCHITECTURE_ID)
     set(SIMULATE_ID)
     set(SIMULATE_VERSION)
+    set(HOST_COMPILER_ID)
+    set(HOST_COMPILER_VERSION)
     set(CMAKE_${lang}_COMPILER_ID_STRING_REGEX ".?I.?N.?F.?O.?:.?[A-Za-z0-9_]+\\[[^]]*\\]")
     foreach(encoding "" "ENCODING;UTF-16LE" "ENCODING;UTF-16BE")
       cmake_policy(PUSH)
@@ -1027,6 +1056,13 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
       if("${info}" MATCHES "INFO:qnxnto\\[\\]")
         set(COMPILER_QNXNTO 1)
       endif()
+      if("${info}" MATCHES "INFO:host_compiler\\[([^]\"]*)\\]")
+        set(HOST_COMPILER_ID "${CMAKE_MATCH_1}")
+      endif()
+      if("${info}" MATCHES "INFO:host_compiler_version\\[([^]\"]*)\\]")
+        string(REGEX REPLACE "^0+([0-9]+)" "\\1" HOST_COMPILER_VERSION "${CMAKE_MATCH_1}")
+        string(REGEX REPLACE "\\.0+([0-9])" ".\\1" HOST_COMPILER_VERSION "${HOST_COMPILER_VERSION}")
+      endif()
       if("${info}" MATCHES "INFO:standard_default\\[([^]\"]*)\\]")
         set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_MATCH_1}")
       endif()
@@ -1088,6 +1124,8 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
       set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}")
       set(CMAKE_${lang}_SIMULATE_ID "${SIMULATE_ID}")
       set(CMAKE_${lang}_SIMULATE_VERSION "${SIMULATE_VERSION}")
+      set(CMAKE_${lang}_HOST_COMPILER_ID "${HOST_COMPILER_ID}")
+      set(CMAKE_${lang}_HOST_COMPILER_VERSION "${HOST_COMPILER_VERSION}")
     endif()
 
     # Check the compiler identification string.
@@ -1095,7 +1133,12 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
       # The compiler identification was found.
       string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
         "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in:\n"
-        "  ${file}\n\n")
+        "  ${file}\n")
+      if(CMAKE_${lang}_HOST_COMPILER_ID)
+        string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
+          "The host compiler identification is ${CMAKE_${lang}_HOST_COMPILER_ID}\n")
+      endif()
+      string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG "\n")
     else()
       # The compiler identification could not be found.
       string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
@@ -1144,6 +1187,8 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
   set(COMPILER_QNXNTO "${COMPILER_QNXNTO}" PARENT_SCOPE)
   set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE)
   set(CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT "${CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT}" PARENT_SCOPE)
+  set(CMAKE_${lang}_HOST_COMPILER_ID "${CMAKE_${lang}_HOST_COMPILER_ID}" PARENT_SCOPE)
+  set(CMAKE_${lang}_HOST_COMPILER_VERSION "${CMAKE_${lang}_HOST_COMPILER_VERSION}" PARENT_SCOPE)
 endfunction()
 
 #-----------------------------------------------------------------------------

Modules/CMakeHIPCompiler.cmake.in

@@ -3,6 +3,8 @@ set(CMAKE_HIP_HOST_COMPILER "@CMAKE_HIP_HOST_COMPILER@")
 set(CMAKE_HIP_HOST_LINK_LAUNCHER "@CMAKE_HIP_HOST_LINK_LAUNCHER@")
 set(CMAKE_HIP_COMPILER_ID "@CMAKE_HIP_COMPILER_ID@")
 set(CMAKE_HIP_COMPILER_VERSION "@CMAKE_HIP_COMPILER_VERSION@")
+set(CMAKE_HIP_HOST_COMPILER_ID "@CMAKE_HIP_HOST_COMPILER_ID@")
+set(CMAKE_HIP_HOST_COMPILER_VERSION "@CMAKE_HIP_HOST_COMPILER_VERSION@")
 set(CMAKE_HIP_STANDARD_COMPUTED_DEFAULT "@CMAKE_HIP_STANDARD_COMPUTED_DEFAULT@")
 set(CMAKE_HIP_EXTENSIONS_COMPUTED_DEFAULT "@CMAKE_HIP_EXTENSIONS_COMPUTED_DEFAULT@")
 set(CMAKE_HIP_STANDARD_LATEST "@CMAKE_HIP_STANDARD_LATEST@")

Modules/CMakeHIPCompilerId.hip.in

@@ -16,6 +16,28 @@ char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
 @CMAKE_HIP_COMPILER_ID_PLATFORM_CONTENT@
 @CMAKE_HIP_COMPILER_ID_ERROR_FOR_TEST@
 
+#ifdef HOST_COMPILER_ID
+char const* info_host_compiler = "INFO" ":" "host_compiler[" HOST_COMPILER_ID "]";
+#endif
+#ifdef HOST_COMPILER_VERSION
+char const* info_host_compiler_version = "INFO" ":" "host_compiler_version[" HOST_COMPILER_VERSION "]";
+#elif defined(HOST_COMPILER_VERSION_MAJOR)
+char const info_host_compiler_version[] = {
+  'I', 'N', 'F', 'O', ':','h','o','s','t','_',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  HOST_COMPILER_VERSION_MAJOR,
+# ifdef HOST_COMPILER_VERSION_MINOR
+  '.', HOST_COMPILER_VERSION_MINOR,
+#  ifdef HOST_COMPILER_VERSION_PATCH
+   '.', HOST_COMPILER_VERSION_PATCH,
+#   ifdef HOST_COMPILER_VERSION_TWEAK
+    '.', HOST_COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+#
 #define CXX_STD_98 199711L
 #define CXX_STD_11 201103L
 #define CXX_STD_14 201402L
@@ -66,6 +88,12 @@ int main(int argc, char* argv[])
 #endif
 #ifdef SIMULATE_VERSION_MAJOR
   require += info_simulate_version[argc];
+#endif
+#ifdef HOST_COMPILER_ID
+  require += info_host_compiler[argc];
+#endif
+#ifdef HOST_COMPILER_VERSION_MAJOR
+  require += info_host_compiler_version[argc];
 #endif
   require += info_language_standard_default[argc];
   require += info_language_extensions_default[argc];

Tests/CMakeOnly/CMakeLists.txt

@@ -35,29 +35,11 @@ endif()
 
 add_CMakeOnly_test(CheckStructHasMember)
 
-add_CMakeOnly_test(CompilerIdC)
-add_CMakeOnly_test(CompilerIdCXX)
-
 if (APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
-  add_CMakeOnly_test(CompilerIdOBJC)
   add_CMakeOnly_test(CheckOBJCCompilerFlag)
-  add_CMakeOnly_test(CompilerIdOBJCXX)
   add_CMakeOnly_test(CheckOBJCXXCompilerFlag)
 endif()
 
-if(CMake_TEST_CUDA)
-  add_CMakeOnly_test(CompilerIdCUDA)
-endif()
-
-
-if(CMAKE_Fortran_COMPILER)
-  add_CMakeOnly_test(CompilerIdFortran)
-  set_property(TEST CMakeOnly.CompilerIdFortran APPEND PROPERTY LABELS "Fortran")
-endif()
-if(CMAKE_GENERATOR MATCHES "Visual Studio")
-  add_CMakeOnly_test(CompilerIdCSharp)
-endif()
-
 add_test(CMakeOnly.AllFindModules ${CMAKE_CMAKE_COMMAND}
   -DTEST=AllFindModules
   -DCMAKE_ARGS=-DCMake_TEST_CMakeOnly.AllFindModules_NO_VERSION=${CMake_TEST_CMakeOnly.AllFindModules_NO_VERSION}

Tests/CMakeOnly/CompilerIdC/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CompilerIdC C)
-
-foreach(v
-    CMAKE_C_COMPILER
-    CMAKE_C_COMPILER_ID
-    CMAKE_C_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()
-
-# Version numbers may only contain numbers and periods.
-if(NOT CMAKE_C_COMPILER_VERSION MATCHES
-    "^([0-9]+)(\\.([0-9]+))?(\\.([0-9]+))?(\\.([0-9]+))?$"
-    )
-  message(SEND_ERROR "Compiler version is not numeric!")
-endif()

Tests/CMakeOnly/CompilerIdCSharp/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 3.7.0)
-project(CompilerIdCSharp CSharp)
-
-foreach(v
-    CMAKE_CSharp_COMPILER
-    CMAKE_CSharp_COMPILER_ID
-    CMAKE_CSharp_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()
-
-# Version numbers may only contain numbers and periods.
-if(NOT CMAKE_CSharp_COMPILER_VERSION MATCHES
-    "^([0-9]+)(\\.([0-9]+))?(\\.([0-9]+))?(\\.([0-9]+))?$"
-    )
-  message(SEND_ERROR "Compiler version is not numeric!")
-endif()

Tests/CMakeOnly/CompilerIdCUDA/CMakeLists.txt

@@ -1,14 +0,0 @@
-cmake_minimum_required(VERSION 3.18)
-project(CompilerIdCUDA CUDA)
-
-foreach(v
-    CMAKE_CUDA_COMPILER
-    CMAKE_CUDA_COMPILER_ID
-    CMAKE_CUDA_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()

Tests/CMakeOnly/CompilerIdCXX/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CompilerIdCXX CXX)
-
-foreach(v
-    CMAKE_CXX_COMPILER
-    CMAKE_CXX_COMPILER_ID
-    CMAKE_CXX_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()
-
-# Version numbers may only contain numbers and periods.
-if(NOT CMAKE_CXX_COMPILER_VERSION MATCHES
-    "^([0-9]+)(\\.([0-9]+))?(\\.([0-9]+))?(\\.([0-9]+))?$"
-    )
-  message(SEND_ERROR "Compiler version is not numeric!")
-endif()

Tests/CMakeOnly/CompilerIdFortran/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CompilerIdFortran Fortran)
-
-foreach(v
-    CMAKE_Fortran_COMPILER
-    CMAKE_Fortran_COMPILER_ID
-    CMAKE_Fortran_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()
-
-# Version numbers may only contain numbers and periods.
-if(NOT CMAKE_Fortran_COMPILER_VERSION MATCHES
-    "^([0-9]+)(\\.([0-9]+))?(\\.([0-9]+))?(\\.([0-9]+))?$"
-    )
-  message(SEND_ERROR "Compiler version is not numeric!")
-endif()

Tests/CMakeOnly/CompilerIdOBJC/CMakeLists.txt

@@ -1,14 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-project(CompilerIdOBJC OBJC)
-
-foreach(v
-    CMAKE_OBJC_COMPILER
-    CMAKE_OBJC_COMPILER_ID
-    CMAKE_OBJC_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()

Tests/CMakeOnly/CompilerIdOBJCXX/CMakeLists.txt

@@ -1,14 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-project(CompilerIdOBJCXX OBJCXX)
-
-foreach(v
-    CMAKE_OBJCXX_COMPILER
-    CMAKE_OBJCXX_COMPILER_ID
-    CMAKE_OBJCXX_COMPILER_VERSION
-    )
-  if(${v})
-    message(STATUS "${v}=[${${v}}]")
-  else()
-    message(SEND_ERROR "${v} not set!")
-  endif()
-endforeach()

Tests/RunCMake/CMakeLists.txt

@@ -369,7 +369,7 @@ if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 endif()
 add_RunCMake_test(CompilerNotFound)
 if(DEFINED CMake_TEST_OBJC)
-  list(APPEND CompilerTest_ARGS -DCMake_TEST_OBJC=${CMake_TEST_OBJC})
+  list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_OBJC=${CMake_TEST_OBJC})
 endif()
 if(CMAKE_Fortran_COMPILER)
   # lfortran < 1.24 cannot handle long file names.  Fortran is not
@@ -377,19 +377,21 @@ if(CMAKE_Fortran_COMPILER)
   if(CMAKE_C_COMPILER_ID STREQUAL "LCC" AND CMAKE_C_COMPILER_VERSION VERSION_LESS "1.24")
     string(LENGTH "${CMAKE_CURRENT_BINARY_DIR}" _CCBD_LEN)
     if(_CCBD_LEN LESS 35)
-      list(APPEND CompilerTest_ARGS -DCMake_TEST_Fortran=1)
+      list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_Fortran=1)
     endif()
     unset(_CCBD_LEN)
   else()
-    list(APPEND CompilerTest_ARGS -DCMake_TEST_Fortran=1)
+    list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_Fortran=1)
   endif()
 endif()
 foreach(lang IN ITEMS CUDA HIP ISPC)
   if(CMake_TEST_${lang})
-    list(APPEND CompilerTest_ARGS -DCMake_TEST_${lang}=1)
+    list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_${lang}=1)
   endif()
 endforeach()
-add_RunCMake_test(CompilerTest)
+add_RunCMake_test(CompilerId ${CMake_TEST_LANG_VARS})
+set_property(TEST RunCMake.CompilerId APPEND PROPERTY LABELS "CUDA" "HIP" "ISPC" "Fortran")
+add_RunCMake_test(CompilerTest ${CMake_TEST_LANG_VARS})
 set_property(TEST RunCMake.CompilerTest APPEND PROPERTY LABELS "CUDA" "HIP" "ISPC" "Fortran")
 add_RunCMake_test(Configure -DMSVC_IDE=${MSVC_IDE})
 add_RunCMake_test(DisallowedCommands)

Tests/RunCMake/CompilerId/C-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_C_COMPILER='[^']+'
+-- CMAKE_C_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_C_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/C.cmake

@@ -0,0 +1,4 @@
+enable_language(C)
+message(STATUS "CMAKE_C_COMPILER='${CMAKE_C_COMPILER}'")
+message(STATUS "CMAKE_C_COMPILER_ID='${CMAKE_C_COMPILER_ID}'")
+message(STATUS "CMAKE_C_COMPILER_VERSION='${CMAKE_C_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.30)
+project(${RunCMake_TEST} NONE)
+include(${RunCMake_TEST}.cmake)

Tests/RunCMake/CompilerId/CSharp-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_CSharp_COMPILER='[^']+'
+-- CMAKE_CSharp_COMPILER_ID='[A-Za-z ]+'
+-- CMAKE_CSharp_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/CSharp.cmake

@@ -0,0 +1,4 @@
+enable_language(CSharp)
+message(STATUS "CMAKE_CSharp_COMPILER='${CMAKE_CSharp_COMPILER}'")
+message(STATUS "CMAKE_CSharp_COMPILER_ID='${CMAKE_CSharp_COMPILER_ID}'")
+message(STATUS "CMAKE_CSharp_COMPILER_VERSION='${CMAKE_CSharp_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/CUDA-stdout.txt

@@ -0,0 +1,11 @@
+(-- CMAKE_CUDA_COMPILER='[^']+'
+-- CMAKE_CUDA_COMPILER_ID='NVIDIA'
+-- CMAKE_CUDA_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+-- CMAKE_CUDA_HOST_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_CUDA_HOST_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+|-- CMAKE_CUDA_COMPILER='[^']+'
+-- CMAKE_CUDA_COMPILER_ID='([^N]|N[^V]|NV[^I]|NVI[^D]|NVID[^I]|NVIDI[^A])[A-Za-z]*'
+-- CMAKE_CUDA_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+-- CMAKE_CUDA_HOST_COMPILER_ID=''
+-- CMAKE_CUDA_HOST_COMPILER_VERSION=''
+)

Tests/RunCMake/CompilerId/CUDA.cmake

@@ -0,0 +1,6 @@
+enable_language(CUDA)
+message(STATUS "CMAKE_CUDA_COMPILER='${CMAKE_CUDA_COMPILER}'")
+message(STATUS "CMAKE_CUDA_COMPILER_ID='${CMAKE_CUDA_COMPILER_ID}'")
+message(STATUS "CMAKE_CUDA_COMPILER_VERSION='${CMAKE_CUDA_COMPILER_VERSION}'")
+message(STATUS "CMAKE_CUDA_HOST_COMPILER_ID='${CMAKE_CUDA_HOST_COMPILER_ID}'")
+message(STATUS "CMAKE_CUDA_HOST_COMPILER_VERSION='${CMAKE_CUDA_HOST_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/CXX-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_CXX_COMPILER='[^']+'
+-- CMAKE_CXX_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_CXX_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/CXX.cmake

@@ -0,0 +1,4 @@
+enable_language(CXX)
+message(STATUS "CMAKE_CXX_COMPILER='${CMAKE_CXX_COMPILER}'")
+message(STATUS "CMAKE_CXX_COMPILER_ID='${CMAKE_CXX_COMPILER_ID}'")
+message(STATUS "CMAKE_CXX_COMPILER_VERSION='${CMAKE_CXX_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/Fortran-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_Fortran_COMPILER='[^']+'
+-- CMAKE_Fortran_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_Fortran_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/Fortran.cmake

@@ -0,0 +1,4 @@
+enable_language(Fortran)
+message(STATUS "CMAKE_Fortran_COMPILER='${CMAKE_Fortran_COMPILER}'")
+message(STATUS "CMAKE_Fortran_COMPILER_ID='${CMAKE_Fortran_COMPILER_ID}'")
+message(STATUS "CMAKE_Fortran_COMPILER_VERSION='${CMAKE_Fortran_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/HIP-stdout.txt

@@ -0,0 +1,11 @@
+(-- CMAKE_HIP_COMPILER='[^']+'
+-- CMAKE_HIP_COMPILER_ID='NVIDIA'
+-- CMAKE_HIP_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+-- CMAKE_HIP_HOST_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_HIP_HOST_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+|-- CMAKE_HIP_COMPILER='[^']+'
+-- CMAKE_HIP_COMPILER_ID='([^N]|N[^V]|NV[^I]|NVI[^D]|NVID[^I]|NVIDI[^A])[A-Za-z]*'
+-- CMAKE_HIP_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+-- CMAKE_HIP_HOST_COMPILER_ID=''
+-- CMAKE_HIP_HOST_COMPILER_VERSION=''
+)

Tests/RunCMake/CompilerId/HIP.cmake

@@ -0,0 +1,6 @@
+enable_language(HIP)
+message(STATUS "CMAKE_HIP_COMPILER='${CMAKE_HIP_COMPILER}'")
+message(STATUS "CMAKE_HIP_COMPILER_ID='${CMAKE_HIP_COMPILER_ID}'")
+message(STATUS "CMAKE_HIP_COMPILER_VERSION='${CMAKE_HIP_COMPILER_VERSION}'")
+message(STATUS "CMAKE_HIP_HOST_COMPILER_ID='${CMAKE_HIP_HOST_COMPILER_ID}'")
+message(STATUS "CMAKE_HIP_HOST_COMPILER_VERSION='${CMAKE_HIP_HOST_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/ISPC-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_ISPC_COMPILER='[^']+'
+-- CMAKE_ISPC_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_ISPC_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/ISPC.cmake

@@ -0,0 +1,4 @@
+enable_language(ISPC)
+message(STATUS "CMAKE_ISPC_COMPILER='${CMAKE_ISPC_COMPILER}'")
+message(STATUS "CMAKE_ISPC_COMPILER_ID='${CMAKE_ISPC_COMPILER_ID}'")
+message(STATUS "CMAKE_ISPC_COMPILER_VERSION='${CMAKE_ISPC_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/OBJC-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_OBJC_COMPILER='[^']+'
+-- CMAKE_OBJC_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_OBJC_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/OBJC.cmake

@@ -0,0 +1,4 @@
+enable_language(OBJC)
+message(STATUS "CMAKE_OBJC_COMPILER='${CMAKE_OBJC_COMPILER}'")
+message(STATUS "CMAKE_OBJC_COMPILER_ID='${CMAKE_OBJC_COMPILER_ID}'")
+message(STATUS "CMAKE_OBJC_COMPILER_VERSION='${CMAKE_OBJC_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/OBJCXX-stdout.txt

@@ -0,0 +1,3 @@
+-- CMAKE_OBJCXX_COMPILER='[^']+'
+-- CMAKE_OBJCXX_COMPILER_ID='[A-Za-z]+'
+-- CMAKE_OBJCXX_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'

Tests/RunCMake/CompilerId/OBJCXX.cmake

@@ -0,0 +1,4 @@
+enable_language(OBJCXX)
+message(STATUS "CMAKE_OBJCXX_COMPILER='${CMAKE_OBJCXX_COMPILER}'")
+message(STATUS "CMAKE_OBJCXX_COMPILER_ID='${CMAKE_OBJCXX_COMPILER_ID}'")
+message(STATUS "CMAKE_OBJCXX_COMPILER_VERSION='${CMAKE_OBJCXX_COMPILER_VERSION}'")

Tests/RunCMake/CompilerId/RunCMakeTest.cmake

@@ -0,0 +1,29 @@
+include(RunCMake)
+
+run_cmake(C)
+run_cmake(CXX)
+
+if(CMake_TEST_CUDA)
+  run_cmake(CUDA)
+endif()
+
+if(CMake_TEST_Fortran)
+  run_cmake(Fortran)
+endif()
+
+if(CMake_TEST_HIP)
+  run_cmake(HIP)
+endif()
+
+if(CMake_TEST_ISPC)
+  run_cmake(ISPC)
+endif()
+
+if(CMake_TEST_OBJC)
+  run_cmake(OBJC)
+  run_cmake(OBJCXX)
+endif()
+
+if(RunCMake_GENERATOR MATCHES "Visual Studio")
+  run_cmake(CSharp)
+endif()