18 files changed, 290 insertions, 63 deletions
diff --git a/Modules/Compiler/ARMClang.cmake b/Modules/Compiler/ARMClang.cmake
index da7a43c..354c11d 100644
--- a/Modules/Compiler/ARMClang.cmake
+++ b/Modules/Compiler/ARMClang.cmake
@@ -3,6 +3,9 @@ if(_ARMClang_CMAKE_LOADED)
 endif()
 set(_ARMClang_CMAKE_LOADED TRUE)
 
+# Save the CMP0123 setting in a variable used both below and by try_compile.
+cmake_policy(GET CMP0123 CMAKE_ARMClang_CMP0123)
+
 cmake_policy(PUSH)
 cmake_policy(SET CMP0057 NEW) # if IN_LIST
 
@@ -82,36 +85,53 @@ macro(__compiler_armclang lang)
   if(NOT CMAKE_${lang}_COMPILER_ARCH_LIST)
     __armclang_set_arch_list(${lang} CMAKE_${lang}_COMPILER_ARCH_LIST)
   endif()
-  if(NOT CMAKE_SYSTEM_PROCESSOR AND NOT CMAKE_SYSTEM_ARCH)
-    message(FATAL_ERROR "  CMAKE_SYSTEM_PROCESSOR or CMAKE_SYSTEM_ARCH must be set for ARMClang\n"
-      "  Supported processor: ${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}\n"
-      "  Supported Architecture: ${CMAKE_${lang}_COMPILER_ARCH_LIST}")
-  else()
-    __armclang_check_processor("${CMAKE_SYSTEM_ARCH}" "${CMAKE_${lang}_COMPILER_ARCH_LIST}" _CMAKE_${lang}_CHECK_ARCH_RESULT)
-    if( _CMAKE_${lang}_CHECK_ARCH_RESULT)
-      string(APPEND CMAKE_${lang}_FLAGS_INIT "-march=${CMAKE_SYSTEM_ARCH}")
-      set(__march_flag_set TRUE)
+
+  # CMAKE_SYSTEM_PROCESSOR and CMAKE_SYSTEM_ARCH are not sufficient because they provide no
+  # information of additional CPU features needed in `-mcpu=<name>[+[no]<feature>+...]`.
+  # The automatic setting of compile and link options is deprecated and projects should specify their own.
+  cmake_policy(GET CMP0123 policy_CMP0123)
+  if(NOT "x${CMAKE_ARMClang_CMP0123}x" STREQUAL "xNEWx")
+    if(NOT "x${CMAKE_ARMClang_CMP0123}x" STREQUAL "xOLDx")
+      cmake_policy(GET_WARNING CMP0123 _cmp0123_warning)
+      message(AUTHOR_WARNING
+        "${_cmp0123_warning}\n"
+        "For compatibility, CMake will automatically add cpu/arch flags based "
+        "on the CMAKE_SYSTEM_PROCESSOR and/or CMAKE_SYSTEM_ARCH variables."
+        )
     endif()
-    __armclang_check_processor("${CMAKE_SYSTEM_PROCESSOR}" "${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}" _CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
-    if(_CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
-      string(APPEND CMAKE_${lang}_FLAGS_INIT "-mcpu=${CMAKE_SYSTEM_PROCESSOR}")
-      set(__mcpu_flag_set TRUE)
+
+    if(NOT CMAKE_SYSTEM_PROCESSOR AND NOT CMAKE_SYSTEM_ARCH)
+      message(FATAL_ERROR "  CMAKE_SYSTEM_PROCESSOR or CMAKE_SYSTEM_ARCH must be set for ARMClang\n"
+        "  Supported processor: ${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}\n"
+        "  Supported Architecture: ${CMAKE_${lang}_COMPILER_ARCH_LIST}")
+    else()
+      __armclang_check_processor("${CMAKE_SYSTEM_ARCH}" "${CMAKE_${lang}_COMPILER_ARCH_LIST}" _CMAKE_${lang}_CHECK_ARCH_RESULT)
+      if( _CMAKE_${lang}_CHECK_ARCH_RESULT)
+        string(APPEND CMAKE_${lang}_FLAGS_INIT " -march=${CMAKE_SYSTEM_ARCH}")
+        set(__march_flag_set TRUE)
+      endif()
+      __armclang_check_processor("${CMAKE_SYSTEM_PROCESSOR}" "${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}" _CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
+      if(_CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
+        string(APPEND CMAKE_${lang}_FLAGS_INIT " -mcpu=${CMAKE_SYSTEM_PROCESSOR}")
+        set(__mcpu_flag_set TRUE)
+      endif()
+      if(NOT __march_flag_set AND NOT __mcpu_flag_set)
+        message(FATAL_ERROR "At least one of the variables CMAKE_SYSTEM_PROCESSOR or CMAKE_SYSTEM_ARCH must be set for ARMClang\n"
+                            "Supported processor: ${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}\n"
+                            "  Supported Architecture: ${CMAKE_${lang}_COMPILER_ARCH_LIST}")
+      endif()
+      unset(_CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
+      unset(_CMAKE_${lang}_CHECK_ARCH_RESULT)
     endif()
-    if(NOT __march_flag_set AND NOT __mcpu_flag_set)
-      message(FATAL_ERROR "At least one of the variables CMAKE_SYSTEM_PROCESSOR or CMAKE_SYSTEM_ARCH must be set for ARMClang\n"
-                          "Supported processor: ${CMAKE_${lang}_COMPILER_PROCESSOR_LIST}\n"
-                          "  Supported Architecture: ${CMAKE_${lang}_COMPILER_ARCH_LIST}")
+
+    #check if CMAKE_SYSTEM_PROCESSOR belongs to supported cpu list for armlink
+    __armlink_set_cpu_list( ${lang} CMAKE_LINKER_CPU_LIST)
+    list(TRANSFORM CMAKE_LINKER_CPU_LIST TOLOWER)
+    __armclang_check_processor("${CMAKE_SYSTEM_PROCESSOR}" "${CMAKE_LINKER_CPU_LIST}" _CMAKE_CHECK_LINK_CPU_RESULT)
+    if(_CMAKE_CHECK_LINK_CPU_RESULT)
+      string(APPEND CMAKE_${lang}_LINK_FLAGS " --cpu=${CMAKE_SYSTEM_PROCESSOR}")
     endif()
-    unset(_CMAKE_${lang}_CHECK_PROCESSOR_RESULT)
-    unset(_CMAKE_${lang}_CHECK_ARCH_RESULT)
-  endif()
 
-  #check if CMAKE_SYSTEM_PROCESSOR belongs to supported cpu list for armlink
-  __armlink_set_cpu_list( ${lang} CMAKE_LINKER_CPU_LIST)
-  list(TRANSFORM CMAKE_LINKER_CPU_LIST TOLOWER)
-  __armclang_check_processor("${CMAKE_SYSTEM_PROCESSOR}" "${CMAKE_LINKER_CPU_LIST}" _CMAKE_CHECK_LINK_CPU_RESULT)
-  if(_CMAKE_CHECK_LINK_CPU_RESULT)
-    string(APPEND CMAKE_${lang}_LINK_FLAGS "--cpu=${CMAKE_SYSTEM_PROCESSOR}")
   endif()
 
   if(__CMAKE_ARMClang_USING_armlink)
diff --git a/Modules/Compiler/CMakeCommonCompilerMacros.cmake b/Modules/Compiler/CMakeCommonCompilerMacros.cmake
index cd897c5..29e6730 100644
--- a/Modules/Compiler/CMakeCommonCompilerMacros.cmake
+++ b/Modules/Compiler/CMakeCommonCompilerMacros.cmake
@@ -64,6 +64,12 @@ endmacro()
 # Define to allow compile features to be automatically determined
 macro(cmake_record_c_compile_features)
   set(_result 0)
+  if(_result EQUAL 0 AND DEFINED CMAKE_C23_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_c(23)
+  endif()
+  if(_result EQUAL 0 AND DEFINED CMAKE_C17_STANDARD_COMPILE_OPTION)
+    _has_compiler_features_c(17)
+  endif()
   if(_result EQUAL 0 AND DEFINED CMAKE_C11_STANDARD_COMPILE_OPTION)
     if(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT)
       _has_compiler_features_c(11)
diff --git a/Modules/Compiler/Clang-C.cmake b/Modules/Compiler/Clang-C.cmake
index 5609abf..cf493d7 100644
--- a/Modules/Compiler/Clang-C.cmake
+++ b/Modules/Compiler/Clang-C.cmake
@@ -25,37 +25,60 @@ elseif("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
   endif()
 endif()
 
-if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4)
-  if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
+if("x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 2.1)
     set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
     set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
-    set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
 
     set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
     set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
-    set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+  endif()
 
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.1)
     set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
     set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
-    set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
-  else()
-    # clang-cl doesn't have any of these
-    set(CMAKE_C90_STANDARD_COMPILE_OPTION "")
-    set(CMAKE_C90_EXTENSION_COMPILE_OPTION "")
-    set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+  elseif(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.0)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c1x")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x")
+  endif()
+
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
+    set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
+    set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+  endif()
+
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
+    set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
+    set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
+  endif()
+else()
+  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_C99_STANDARD_COMPILE_OPTION "")
-    set(CMAKE_C99_EXTENSION_COMPILE_OPTION "")
-    set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+  if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 13.0)
+    set(CMAKE_C11_STANDARD_COMPILE_OPTION "/std:c11")
+    set(CMAKE_C11_EXTENSION_COMPILE_OPTION "/std:c11")
 
+    set(CMAKE_C17_STANDARD_COMPILE_OPTION "/std:c17")
+    set(CMAKE_C17_EXTENSION_COMPILE_OPTION "/std:c17")
+  else()
     set(CMAKE_C11_STANDARD_COMPILE_OPTION "")
     set(CMAKE_C11_EXTENSION_COMPILE_OPTION "")
-    set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+
+    set(CMAKE_C17_STANDARD_COMPILE_OPTION "")
+    set(CMAKE_C17_EXTENSION_COMPILE_OPTION "")
   endif()
 endif()
 
-if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
-  __compiler_check_default_language_standard(C 3.4 99 3.6 11)
-else()
-  set(CMAKE_C_STANDARD_DEFAULT "")
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 2.1)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
 endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.0)
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+__compiler_check_default_language_standard(C 2.1 99 3.5.2 11 11.0 17)
diff --git a/Modules/Compiler/Clang-CUDA.cmake b/Modules/Compiler/Clang-CUDA.cmake
index cafc7dd..0223081 100644
--- a/Modules/Compiler/Clang-CUDA.cmake
+++ b/Modules/Compiler/Clang-CUDA.cmake
@@ -22,8 +22,8 @@ set(_CMAKE_CUDA_PTX_FLAG "--cuda-device-only -S")
 set(_CMAKE_CUDA_DEVICE_CODE "-fgpu-rdc -c")
 
 # RulePlaceholderExpander expands crosscompile variables like sysroot and target only for CMAKE_<LANG>_COMPILER. Override the default.
-set(CMAKE_CUDA_LINK_EXECUTABLE "<CMAKE_CUDA_COMPILER> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICT_LINKS}")
-set(CMAKE_CUDA_CREATE_SHARED_LIBRARY "<CMAKE_CUDA_COMPILER> <CMAKE_SHARED_LIBRARY_CUDA_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>${__IMPLICT_LINKS}")
+set(CMAKE_CUDA_LINK_EXECUTABLE "<CMAKE_CUDA_COMPILER> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
+set(CMAKE_CUDA_CREATE_SHARED_LIBRARY "<CMAKE_CUDA_COMPILER> <CMAKE_SHARED_LIBRARY_CUDA_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
 
 set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "STATIC")
 set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "cudadevrt;cudart_static")
diff --git a/Modules/Compiler/Fujitsu-C.cmake b/Modules/Compiler/Fujitsu-C.cmake
new file mode 100644
index 0000000..dd31e43
--- /dev/null
+++ b/Modules/Compiler/Fujitsu-C.cmake
@@ -0,0 +1,20 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+include(Compiler/Fujitsu)
+__compiler_fujitsu(C)
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 4)
+  set(CMAKE_C90_STANDARD_COMPILE_OPTION  -std=c89)
+  set(CMAKE_C90_EXTENSION_COMPILE_OPTION -std=gnu89)
+  set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C99_STANDARD_COMPILE_OPTION  -std=c99)
+  set(CMAKE_C99_EXTENSION_COMPILE_OPTION -std=gnu99)
+  set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_C11_STANDARD_COMPILE_OPTION  -std=c11)
+  set(CMAKE_C11_EXTENSION_COMPILE_OPTION -std=gnu11)
+  set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
+endif()
+
+__compiler_check_default_language_standard(C 4 11)
diff --git a/Modules/Compiler/Fujitsu-CXX.cmake b/Modules/Compiler/Fujitsu-CXX.cmake
new file mode 100644
index 0000000..0f42196
--- /dev/null
+++ b/Modules/Compiler/Fujitsu-CXX.cmake
@@ -0,0 +1,47 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+include(Compiler/Fujitsu)
+__compiler_fujitsu(CXX)
+
+#set(CMAKE_PCH_EXTENSION .pch)
+#set(CMAKE_PCH_EPILOGUE "#pragma hdrstop")
+#set(CMAKE_CXX_COMPILE_OPTIONS_USE_PCH --no_pch_messages -include <PCH_HEADER> --use_pch <PCH_FILE>)
+#set(CMAKE_CXX_COMPILE_OPTIONS_CREATE_PCH --no_pch_messages -include <PCH_HEADER> --create_pch <PCH_FILE>)
+
+# The Fujitsu compiler offers both a 98 and 03 mode.  These two are
+# essentially interchangeable as 03 simply provides clarity to some 98
+# ambiguyity.
+#
+# Re: Stroustrup's C++ FAQ:
+#   What is the difference between C++98 and C++03?
+#     From a programmer's view there is none. The C++03 revision of the
+#     standard was a bug fix release for implementers to ensure greater
+#     consistency and portability. In particular, tutorial and reference
+#     material describing C++98 and C++03 can be used interchangeably by all
+#     except compiler writers and standards gurus.
+#
+# Since CMake doesn't actually have an 03 mode and they're effectively
+# interchangeable then we're just going to explicitly use 03 mode in the
+# compiler when 98 is requested.
+
+# The version matching is messy here.  The std support seems to be related to
+# the compiler tweak version derived from the patch id in the version string.
+
+if(CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 4)
+  set(CMAKE_CXX98_STANDARD_COMPILE_OPTION  -std=c++03)
+  set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -std=gnu++03)
+  set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX11_STANDARD_COMPILE_OPTION  -std=c++11)
+  set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -std=gnu++11)
+  set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX14_STANDARD_COMPILE_OPTION  -std=c++14)
+  set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -std=gnu++14)
+  set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+
+  set(CMAKE_CXX17_STANDARD_COMPILE_OPTION  -std=c++17)
+  set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION -std=gnu++17)
+endif()
+
+__compiler_check_default_language_standard(CXX 4 14)
diff --git a/Modules/Compiler/Fujitsu-DetermineCompiler.cmake b/Modules/Compiler/Fujitsu-DetermineCompiler.cmake
index 73ee38c..8534916 100644
--- a/Modules/Compiler/Fujitsu-DetermineCompiler.cmake
+++ b/Modules/Compiler/Fujitsu-DetermineCompiler.cmake
@@ -1,2 +1,17 @@
 
-set(_compiler_id_pp_test "defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)")
+set(_compiler_id_pp_test "defined(__FUJITSU)")
+
+set(_compiler_id_version_compute "
+# if defined(__FCC_version__)
+#   define @PREFIX@COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__FCC_major__)
+#   define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__FCC_minor__)
+#   define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__FCC_VERSION)
+# endif
+")
diff --git a/Modules/Compiler/Fujitsu-Fortran.cmake b/Modules/Compiler/Fujitsu-Fortran.cmake
new file mode 100644
index 0000000..face2d6
--- /dev/null
+++ b/Modules/Compiler/Fujitsu-Fortran.cmake
@@ -0,0 +1,16 @@
+include(Compiler/Fujitsu)
+__compiler_fujitsu(Fortran)
+
+set(CMAKE_Fortran_SUBMODULE_SEP ".")
+set(CMAKE_Fortran_SUBMODULE_EXT ".smod")
+
+set(CMAKE_Fortran_PREPROCESS_SOURCE
+  "<CMAKE_Fortran_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -Cpp -P <SOURCE> -o <PREPROCESSED_SOURCE>")
+set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-Cpp")
+
+set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-Fixed")
+set(CMAKE_Fortran_FORMAT_FREE_FLAG "-Free")
+
+string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT "")
+
+set(CMAKE_Fortran_MODDIR_FLAG "-M ")
diff --git a/Modules/Compiler/Fujitsu.cmake b/Modules/Compiler/Fujitsu.cmake
new file mode 100644
index 0000000..13bc57c
--- /dev/null
+++ b/Modules/Compiler/Fujitsu.cmake
@@ -0,0 +1,33 @@
+# 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_FUJITSU)
+  return()
+endif()
+set(__COMPILER_FUJITSU 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+macro(__compiler_fujitsu lang)
+  set(CMAKE_${lang}_VERBOSE_FLAG "-###")
+
+  # Initial configuration flags
+  string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+  string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g -O0")
+  string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3 -DNDEBUG")
+  string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
+
+  # PIC flags
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC")
+  set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE")
+
+  # Passing link options to the compiler
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Wl,")
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP ",")
+
+  # How to actually call the compiler
+  set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
+  "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E $<$<COMPILE_LANGUAGE:Fortran>:-Cpp> <SOURCE> > <PREPROCESSED_SOURCE>")
+  set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+endmacro()
diff --git a/Modules/Compiler/FujitsuClang-C.cmake b/Modules/Compiler/FujitsuClang-C.cmake
new file mode 100644
index 0000000..f700d2d
--- /dev/null
+++ b/Modules/Compiler/FujitsuClang-C.cmake
@@ -0,0 +1,6 @@
+include(Compiler/FujitsuClang)
+
+set(_fjclang_ver "${CMAKE_C_COMPILER_VERSION_INTERNAL}")
+set(CMAKE_C_COMPILER_VERSION "${CMAKE_C_COMPILER_VERSION_INTERNAL}")
+include(Compiler/Clang-C)
+set(CMAKE_C_COMPILER_VERSION "${_fjclang_ver}")
diff --git a/Modules/Compiler/FujitsuClang-CXX.cmake b/Modules/Compiler/FujitsuClang-CXX.cmake
new file mode 100644
index 0000000..c8790cd
--- /dev/null
+++ b/Modules/Compiler/FujitsuClang-CXX.cmake
@@ -0,0 +1,6 @@
+include(Compiler/FujitsuClang)
+
+set(_fjclang_ver "${CMAKE_CXX_COMPILER_VERSION_INTERNAL}")
+set(CMAKE_CXX_COMPILER_VERSION "${CMAKE_CXX_COMPILER_VERSION_INTERNAL}")
+include(Compiler/Clang-CXX)
+set(CMAKE_CXX_COMPILER_VERSION "${_fjclang_ver}")
diff --git a/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake b/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake
new file mode 100644
index 0000000..f6719b1
--- /dev/null
+++ b/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake
@@ -0,0 +1,9 @@
+
+set(_compiler_id_pp_test "defined(__CLANG_FUJITSU)")
+
+set(_compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__FCC_major__)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__FCC_minor__)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__FCC_patchlevel__)
+# define @PREFIX@COMPILER_VERSION_INTERNAL_STR __clang_version__
+")
diff --git a/Modules/Compiler/FujitsuClang.cmake b/Modules/Compiler/FujitsuClang.cmake
new file mode 100644
index 0000000..a848248
--- /dev/null
+++ b/Modules/Compiler/FujitsuClang.cmake
@@ -0,0 +1,11 @@
+# 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_FUJITSUCLANG)
+  return()
+endif()
+set(__COMPILER_FUJITSUCLANG 1)
+
+include(Compiler/Clang)
diff --git a/Modules/Compiler/GNU-C.cmake b/Modules/Compiler/GNU-C.cmake
index 86b4d83..39e9c72 100644
--- a/Modules/Compiler/GNU-C.cmake
+++ b/Modules/Compiler/GNU-C.cmake
@@ -36,4 +36,14 @@ elseif (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.6)
   set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x")
 endif()
 
-__compiler_check_default_language_standard(C 3.4 90 5.0 11)
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+  set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
+  set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
+endif()
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 9.1)
+  set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c23")
+  set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu23")
+endif()
+
+__compiler_check_default_language_standard(C 3.4 90 5.0 11 8.1 17)
diff --git a/Modules/Compiler/GNU-CXX.cmake b/Modules/Compiler/GNU-CXX.cmake
index 758d3c7..b35f254 100644
--- a/Modules/Compiler/GNU-CXX.cmake
+++ b/Modules/Compiler/GNU-CXX.cmake
@@ -61,9 +61,14 @@ elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
   set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
 endif()
 
-if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11.1)
+  set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
+  set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
+  set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++23")
+  set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++23")
+elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0)
   set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
   set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
 endif()
 
-__compiler_check_default_language_standard(CXX 3.4 98 6.0 14)
+__compiler_check_default_language_standard(CXX 3.4 98 6.0 14 11.1 17)
diff --git a/Modules/Compiler/IntelLLVM-C.cmake b/Modules/Compiler/IntelLLVM-C.cmake
index fce2971..beb7132 100644
--- a/Modules/Compiler/IntelLLVM-C.cmake
+++ b/Modules/Compiler/IntelLLVM-C.cmake
@@ -37,6 +37,9 @@ if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
 
   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 "")
@@ -47,12 +50,13 @@ else()
 
   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")
-  # FIXME: The compiler actually defaults to C17, but
-  # CMake does not yet model or detect that standard.
-  __compiler_check_default_language_standard(C 2020 11)
+  __compiler_check_default_language_standard(C 2020 17)
 else()
   set(CMAKE_C_STANDARD_DEFAULT "")
 endif()
diff --git a/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake b/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake
index 124dafe..917a364 100644
--- a/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake
+++ b/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake
@@ -4,7 +4,7 @@ set(_compiler_id_pp_test "(defined(__clang__) && defined(__INTEL_CLANG_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.
+ * VVVV is no smaller than the current year when a version is released.
  */
 #if __INTEL_LLVM_COMPILER < 1000000L
 # define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__INTEL_LLVM_COMPILER/100)
diff --git a/Modules/Compiler/NVIDIA-CUDA.cmake b/Modules/Compiler/NVIDIA-CUDA.cmake
index a0f7c05..c2fe42d 100644
--- a/Modules/Compiler/NVIDIA-CUDA.cmake
+++ b/Modules/Compiler/NVIDIA-CUDA.cmake
@@ -24,21 +24,17 @@ else()
   set(_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS "")
 endif()
 
+if(CMAKE_CUDA_HOST_COMPILER AND NOT CMAKE_GENERATOR MATCHES "Visual Studio")
+  string(APPEND _CMAKE_CUDA_EXTRA_FLAGS " -ccbin=<CMAKE_CUDA_HOST_COMPILER>")
+endif()
+
 if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
   # The -MD flag was only added to nvcc in 10.2 so
   # before that we had to invoke the compiler twice
   # to get header dependency information
   set(CMAKE_DEPFILE_FLAGS_CUDA "-MD -MT <DEP_TARGET> -MF <DEP_FILE>")
 else()
-  if(CMAKE_CUDA_HOST_COMPILER AND NOT CMAKE_SYSTEM_NAME STREQUAL "Windows")
-    # FIXME: Move the main -ccbin= flag from CMakeCUDAInformation to
-    # a block above, remove this copy, and update the VS generator too.
-    set(_CMAKE_CUDA_EXTRA_FLAGS_LOCAL " -ccbin=<CMAKE_CUDA_HOST_COMPILER>")
-  else()
-    set(_CMAKE_CUDA_EXTRA_FLAGS_LOCAL "")
-  endif()
-  set(CMAKE_CUDA_DEPENDS_EXTRA_COMMANDS "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS}${_CMAKE_CUDA_EXTRA_FLAGS_LOCAL} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} -M <SOURCE> -MT <OBJECT> -o <DEP_FILE>")
-  unset(_CMAKE_CUDA_EXTRA_FLAGS_LOCAL)
+  set(CMAKE_CUDA_DEPENDS_EXTRA_COMMANDS "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} -M <SOURCE> -MT <OBJECT> -o <DEP_FILE>")
 endif()
 set(CMAKE_CUDA_DEPFILE_FORMAT gcc)
 if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)