Merge topic 'clang_cuda_prep'

d86fcc6359 CUDAToolkit: Deduce toolkit binary directory from compiler path only for NVCC
87e98bf8be CUDA: Forward CMAKE_CUDA_COMPILER_TARGET in try_compile()
60e60b9201 GNU: Disable depfiles in try-compile mode only for GCC
5f02add366 CUDA: Refactor PTX compilation flag into compiler modules
25439c7d62 Clang: Refactor CXX standard flags into __compiler_clang_cxx_standards()

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !4567

7 files changed, 128 insertions, 190 deletions

diff --git a/Modules/CMakeCUDAInformation.cmake b/Modules/CMakeCUDAInformation.cmake
index f7eb4a7..ab562c6 100644
--- a/Modules/CMakeCUDAInformation.cmake
+++ b/Modules/CMakeCUDAInformation.cmake
@@ -138,7 +138,7 @@ endif()
 #Specify how to compile when ptx has been requested
 if(NOT CMAKE_CUDA_COMPILE_PTX_COMPILATION)
   set(CMAKE_CUDA_COMPILE_PTX_COMPILATION
-    "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} -ptx <SOURCE> -o <OBJECT>")
+    "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} ${_CMAKE_CUDA_PTX_FLAG} <SOURCE> -o <OBJECT>")
 endif()
 
 #Specify how to compile when separable compilation has been requested
diff --git a/Modules/Compiler/Clang-CXX.cmake b/Modules/Compiler/Clang-CXX.cmake
index cb240f9..789e991 100644
--- a/Modules/Compiler/Clang-CXX.cmake
+++ b/Modules/Compiler/Clang-CXX.cmake
@@ -1,5 +1,6 @@
 include(Compiler/Clang)
 __compiler_clang(CXX)
+__compiler_clang_cxx_standards(CXX)
 
 if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
   set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
@@ -13,121 +14,3 @@ endif()
 if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")
   set(CMAKE_CXX_CLANG_TIDY_DRIVER_MODE "cl")
 endif()
-
-if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
-  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 2.1)
-    set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
-    set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
-  endif()
-
-  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.1)
-    set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
-    set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
-    set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
-    set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
-  elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 2.1)
-    set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++0x")
-    set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
-  endif()
-
-  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)
-    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
-    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
-    set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
-  elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
-    set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
-    set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
-    set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
-  endif()
-
-  set(_clang_version_std17 5.0)
-  if(CMAKE_SYSTEM_NAME STREQUAL "Android")
-    set(_clang_version_std17 6.0)
-  endif()
-
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
-    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
-    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
-  elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)
-    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
-    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
-  endif()
-
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
-    set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
-    set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
-  endif()
-
-  unset(_clang_version_std17)
-
-  if("x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
-    # The MSVC standard library requires C++14, and MSVC itself has no
-    # notion of operating in a mode not aware of at least that standard.
-    set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++14")
-    set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++14")
-    set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++14")
-    set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++14")
-
-    # This clang++ is missing some features because of MSVC compatibility.
-    unset(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT)
-    unset(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT)
-    unset(CMAKE_CXX17_STANDARD__HAS_FULL_SUPPORT)
-    unset(CMAKE_CXX20_STANDARD__HAS_FULL_SUPPORT)
-  endif()
-
-  __compiler_check_default_language_standard(CXX 2.1 98)
-elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 3.9
-    AND CMAKE_CXX_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.0)
-  # This version of clang-cl and the MSVC version it simulates have
-  # support for -std: flags.
-  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
-  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std:c++14")
-  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std:c++14")
-  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
-    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std:c++17")
-    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std:c++17")
-    set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std:c++latest")
-    set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std:c++latest")
-  else()
-    set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std:c++latest")
-    set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std:c++latest")
-  endif()
-
-  __compiler_check_default_language_standard(CXX 3.9 14)
-else()
-  # This version of clang-cl, or the MSVC version it simulates, does not have
-  # language standards.  Set these options as empty strings so the feature
-  # test infrastructure can at least check to see if they are defined.
-  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "")
-
-  # There is no meaningful default for this
-  set(CMAKE_CXX_STANDARD_DEFAULT "")
-
-  # There are no compiler modes so we only need to test features once.
-  # Override the default macro for this special case.  Pretend that
-  # all language standards are available so that at least compilation
-  # can be attempted.
-  macro(cmake_record_cxx_compile_features)
-    list(APPEND CMAKE_CXX_COMPILE_FEATURES
-      cxx_std_98
-      cxx_std_11
-      cxx_std_14
-      cxx_std_17
-      cxx_std_20
-      )
-    _record_compiler_features(CXX "" CMAKE_CXX_COMPILE_FEATURES)
-  endmacro()
-endif()
diff --git a/Modules/Compiler/Clang-OBJCXX.cmake b/Modules/Compiler/Clang-OBJCXX.cmake
index b01ce64..453b5fd 100644
--- a/Modules/Compiler/Clang-OBJCXX.cmake
+++ b/Modules/Compiler/Clang-OBJCXX.cmake
@@ -1,70 +1,3 @@
 include(Compiler/Clang)
 __compiler_clang(OBJCXX)
-
-if("x${CMAKE_OBJCXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
-  if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 2.1)
-    set(CMAKE_OBJCXX98_STANDARD_COMPILE_OPTION "-std=c++98")
-    set(CMAKE_OBJCXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
-  endif()
-
-  if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 3.1)
-    set(CMAKE_OBJCXX98_STANDARD__HAS_FULL_SUPPORT ON)
-    set(CMAKE_OBJCXX11_STANDARD_COMPILE_OPTION "-std=c++11")
-    set(CMAKE_OBJCXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
-    set(CMAKE_OBJCXX11_STANDARD__HAS_FULL_SUPPORT ON)
-  elseif(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 2.1)
-    set(CMAKE_OBJCXX11_STANDARD_COMPILE_OPTION "-std=c++0x")
-    set(CMAKE_OBJCXX11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
-  endif()
-
-  if(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 3.5)
-    set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std=c++14")
-    set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
-    set(CMAKE_OBJCXX14_STANDARD__HAS_FULL_SUPPORT ON)
-  elseif(NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 3.4)
-    set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
-    set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
-    set(CMAKE_OBJCXX14_STANDARD__HAS_FULL_SUPPORT ON)
-  endif()
-
-  set(_clang_version_std17 5.0)
-
-  if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
-    set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std=c++17")
-    set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
-  elseif (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS 3.5)
-    set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
-    set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
-  endif()
-
-  if (NOT CMAKE_OBJCXX_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
-    set(CMAKE_OBJCXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
-    set(CMAKE_OBJCXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
-  endif()
-
-  unset(_clang_version_std17)
-
-  __compiler_check_default_language_standard(OBJCXX 2.1 98)
-elseif(CMAKE_OBJCXX_COMPILER_VERSION VERSION_GREATER_EQUAL 3.9
-    AND CMAKE_OBJCXX_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.0)
-  # This version of clang-cl and the MSVC version it simulates have
-  # support for -std: flags.
-  set(CMAKE_OBJCXX98_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_OBJCXX98_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_OBJCXX98_STANDARD__HAS_FULL_SUPPORT ON)
-  set(CMAKE_OBJCXX11_STANDARD_COMPILE_OPTION "")
-  set(CMAKE_OBJCXX11_EXTENSION_COMPILE_OPTION "")
-  set(CMAKE_OBJCXX14_STANDARD_COMPILE_OPTION "-std:c++14")
-  set(CMAKE_OBJCXX14_EXTENSION_COMPILE_OPTION "-std:c++14")
-  if (CMAKE_OBJCXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
-    set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std:c++17")
-    set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std:c++17")
-    set(CMAKE_OBJCXX20_STANDARD_COMPILE_OPTION "-std:c++latest")
-    set(CMAKE_OBJCXX20_EXTENSION_COMPILE_OPTION "-std:c++latest")
-  else()
-    set(CMAKE_OBJCXX17_STANDARD_COMPILE_OPTION "-std:c++latest")
-    set(CMAKE_OBJCXX17_EXTENSION_COMPILE_OPTION "-std:c++latest")
-  endif()
-
-  __compiler_check_default_language_standard(OBJCXX 3.9 14)
-endif()
+__compiler_clang_cxx_standards(OBJCXX)
diff --git a/Modules/Compiler/Clang.cmake b/Modules/Compiler/Clang.cmake
index f65916f..cd47aa6 100644
--- a/Modules/Compiler/Clang.cmake
+++ b/Modules/Compiler/Clang.cmake
@@ -105,3 +105,123 @@ else()
     set(CMAKE_${lang}_COMPILE_OPTIONS_CREATE_PCH -Xclang -emit-pch -Xclang -include -Xclang <PCH_HEADER>)
   endmacro()
 endif()
+
+macro(__compiler_clang_cxx_standards lang)
+  if("x${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 2.1)
+      set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "-std=c++98")
+      set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.1)
+      set(CMAKE_${lang}98_STANDARD__HAS_FULL_SUPPORT ON)
+      set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++11")
+      set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+      set(CMAKE_${lang}11_STANDARD__HAS_FULL_SUPPORT ON)
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 2.1)
+      set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++0x")
+      set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
+    endif()
+
+    if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.5)
+      set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+      set(CMAKE_${lang}14_STANDARD__HAS_FULL_SUPPORT ON)
+    elseif(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.4)
+      set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std=c++1y")
+      set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
+      set(CMAKE_${lang}14_STANDARD__HAS_FULL_SUPPORT ON)
+    endif()
+
+    set(_clang_version_std17 5.0)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Android")
+      set(_clang_version_std17 6.0)
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std=c++17")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
+    elseif (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 3.5)
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std=c++1z")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
+    endif()
+
+    if (NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS "${_clang_version_std17}")
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std=c++2a")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
+    endif()
+
+    unset(_clang_version_std17)
+
+    if("x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
+      # The MSVC standard library requires C++14, and MSVC itself has no
+      # notion of operating in a mode not aware of at least that standard.
+      set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+      set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "-std=c++14")
+      set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+
+      # This clang++ is missing some features because of MSVC compatibility.
+      unset(CMAKE_${lang}11_STANDARD__HAS_FULL_SUPPORT)
+      unset(CMAKE_${lang}14_STANDARD__HAS_FULL_SUPPORT)
+      unset(CMAKE_${lang}17_STANDARD__HAS_FULL_SUPPORT)
+      unset(CMAKE_${lang}20_STANDARD__HAS_FULL_SUPPORT)
+    endif()
+
+    __compiler_check_default_language_standard(${lang} 2.1 98)
+  elseif(CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 3.9
+      AND CMAKE_${lang}_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.0)
+    # This version of clang-cl and the MSVC version it simulates have
+    # support for -std: flags.
+    set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}98_STANDARD__HAS_FULL_SUPPORT ON)
+    set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "-std:c++14")
+    set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "-std:c++14")
+    if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std:c++17")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std:c++17")
+      set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "-std:c++latest")
+      set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "-std:c++latest")
+    else()
+      set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "-std:c++latest")
+      set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "-std:c++latest")
+    endif()
+
+    __compiler_check_default_language_standard(${lang} 3.9 14)
+  else()
+    # This version of clang-cl, or the MSVC version it simulates, does not have
+    # language standards.  Set these options as empty strings so the feature
+    # test infrastructure can at least check to see if they are defined.
+    set(CMAKE_${lang}98_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}98_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}11_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}14_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}14_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}17_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}17_EXTENSION_COMPILE_OPTION "")
+    set(CMAKE_${lang}20_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_${lang}20_EXTENSION_COMPILE_OPTION "")
+
+    # There is no meaningful default for this
+    set(CMAKE_${lang}_STANDARD_DEFAULT "")
+
+    # There are no compiler modes so we only need to test features once.
+    # Override the default macro for this special case.  Pretend that
+    # all language standards are available so that at least compilation
+    # can be attempted.
+    macro(cmake_record_${lang}_compile_features)
+      list(APPEND CMAKE_${lang}_COMPILE_FEATURES
+        ${lang}_std_98
+        ${lang}_std_11
+        ${lang}_std_14
+        ${lang}_std_17
+        ${lang}_std_20
+        )
+      _record_compiler_features(${lang} "" CMAKE_${lang}_COMPILE_FEATURES)
+    endmacro()
+  endif()
+endmacro()
diff --git a/Modules/Compiler/GNU.cmake b/Modules/Compiler/GNU.cmake
index 3357a86..df6d6b8 100644
--- a/Modules/Compiler/GNU.cmake
+++ b/Modules/Compiler/GNU.cmake
@@ -44,7 +44,8 @@ macro(__compiler_gnu lang)
   # tests to always succeed.  Work around this by disabling dependency tracking
   # in try_compile mode.
   get_property(_IN_TC GLOBAL PROPERTY IN_TRY_COMPILE)
-  if(NOT _IN_TC OR CMAKE_FORCE_DEPFILES)
+  if(CMAKE_${lang}_COMPILER_ID STREQUAL "GNU" AND _IN_TC AND NOT CMAKE_FORCE_DEPFILES)
+  else()
     # 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.
diff --git a/Modules/Compiler/NVIDIA-CUDA.cmake b/Modules/Compiler/NVIDIA-CUDA.cmake
index 2a2564e..e24738d 100644
--- a/Modules/Compiler/NVIDIA-CUDA.cmake
+++ b/Modules/Compiler/NVIDIA-CUDA.cmake
@@ -5,6 +5,7 @@ set(CMAKE_CUDA_VERBOSE_FLAG "-v")
 set(CMAKE_CUDA_VERBOSE_COMPILE_FLAG "-Xcompiler=-v")
 
 set(_CMAKE_COMPILE_AS_CUDA_FLAG "-x cu")
+set(_CMAKE_CUDA_PTX_FLAG "-ptx")
 
 if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
   # The -forward-unknown-to-host-compiler flag was only
diff --git a/Modules/FindCUDAToolkit.cmake b/Modules/FindCUDAToolkit.cmake
index 4b14ddc..eed1d81 100644
--- a/Modules/FindCUDAToolkit.cmake
+++ b/Modules/FindCUDAToolkit.cmake
@@ -473,9 +473,9 @@ Result variables
 #
 ###############################################################################
 
-if(CMAKE_CUDA_COMPILER_LOADED AND NOT CUDAToolkit_BIN_DIR)
+# For NVCC we can easily deduce the SDK binary directory from the compiler path.
+if(CMAKE_CUDA_COMPILER_LOADED AND NOT CUDAToolkit_BIN_DIR AND CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
   get_filename_component(cuda_dir "${CMAKE_CUDA_COMPILER}" DIRECTORY)
-  # use the already detected cuda compiler
   set(CUDAToolkit_BIN_DIR "${cuda_dir}" CACHE PATH "")
   mark_as_advanced(CUDAToolkit_BIN_DIR)
   unset(cuda_dir)