Provide CMAKE_<LANG>_COMPILER_ARCHITECTURE_ID on more compilers

Provide it whenever we can detect a target architecture from the
compiler during compiler inspection.  In order to avoid changing
existing IDs, do this only for compilers where we don't already
detect a target architecture during compiler identification.

Fixes: #17702

Help/release/dev/compiler-architecture-id.rst

@@ -0,0 +1,5 @@
+compiler-architecture-id
+------------------------
+
+* The :variable:`CMAKE_<LANG>_COMPILER_ARCHITECTURE_ID` variable is now
+  populated for most compilers, and documented for public use.

Help/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.rst

@@ -3,11 +3,149 @@ CMAKE_<LANG>_COMPILER_ARCHITECTURE_ID
 
 .. versionadded:: 3.10
 
-Identifier indicating the
-target architecture of the compiler for language ``<LANG>``.
+:ref:`List <CMake Language Lists>` of identifiers indicating the
+target architecture(s) of the compiler for language ``<LANG>``.
+
+Typically the list has one entry unless :variable:`CMAKE_OSX_ARCHITECTURES`
+lists multiple architectures.
 
 Possible values for each platform are documented in the following sections.
 
+.. Sync with:
+     Modules/CMakeCompilerABI.h
+     Modules/CMakeFortranCompilerABI.F
+     Modules/CMakeFortranCompilerABI.F90
+     Modules/Internal/CMakeParseCompilerArchitectureId.cmake
+
+Apple Platforms
+^^^^^^^^^^^^^^^
+
+.. versionadded:: 4.1
+
+These identifiers are used when the :variable:`CMAKE_<LANG>_COMPILER`
+targets an Apple platform (``__APPLE__`` is defined).
+
+``arm64``
+  ARM 64-bit
+
+``arm64e``
+  ARM 64-bit with Pointer Authentication (PACs)
+
+``arm64_32``
+  ARM 64-bit with 32-bit pointers (watchOS)
+
+``armv5``, ``armv6``, ``armv7``, ``armv7k``, ``armv7s``
+  ARM 32-bit
+
+``i386``, ``i486``, ``i586``, ``i686``
+  Intel 32-bit
+
+``ppc``
+  PowerPC 32-bit
+
+``x86_64``
+  Intel 64-bit
+
+UNIX Platforms
+^^^^^^^^^^^^^^
+
+.. versionadded:: 4.1
+
+These identifiers are used when the :variable:`CMAKE_<LANG>_COMPILER`
+targets a UNIX platform.
+
+``aarch64``
+  ARM 64-bit
+
+``alpha``
+  DEC Alpha
+
+``armv5``, ``armv6``, ``armv7``
+  ARM 32-bit
+
+``i386``, ``i486``, ``i586``, ``i686``
+  Intel 32-bit
+
+``ia64``
+  Itanium 64-bit
+
+``loongarch32``
+  LoongArch 32-bit
+
+``loongarch64``
+  LoongArch 64-bit
+
+``m68k``
+  Motorola 68000
+
+``mips``
+  MIPS 32-bit big-endian
+
+``mipsel``
+  MIPS 32-bit little-endian
+
+``mips64``
+  MIPS 64-bit big-endian
+
+``mips64el``
+  MIPS 64-bit little-endian
+
+``parisc``
+  PA-RISC 32-bit
+
+``parisc64``
+  PA-RISC 64-bit
+
+``ppc``
+  PowerPC 32-bit big-endian
+
+``ppcle``
+  PowerPC 32-bit little-endian
+
+``ppc64``
+  PowerPC 64-bit big-endian
+
+``ppc64le``
+  PowerPC 64-bit little-endian
+
+``riscv32``
+  RISC-V 32-bit
+
+``riscv64``
+  RISC-V 64-bit
+
+``s390``, ``s390x``
+  IBM Z
+
+``sparc``
+  SPARC 32-bit
+
+``sparcv9``
+  SPARC 64-bit
+
+``x86_64``
+  Intel 64-bit
+
+Windows Platforms with GNU ABI (MinGW)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. versionadded:: 4.1
+
+These identifiers are used when the :variable:`CMAKE_<LANG>_COMPILER`
+targets Windows with a GNU ABI (``_WIN32`` and ``__MINGW32__`` are defined).
+
+``aarch64``
+  ARM 64-bit
+
+``armv7``
+  ARM 32-bit
+
+``i386``, ``i486``, ``i586``, ``i686``
+  Intel 32-bit
+
+``x86_64``
+  Intel 64-bit
+
 Windows Platforms with MSVC ABI
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

Modules/CMakeCCompilerABI.c

@@ -22,6 +22,9 @@ int main(int argc, char* argv[])
   require += info_byte_order_little_endian[argc];
 #if defined(ABI_ID)
   require += info_abi[argc];
+#endif
+#if defined(ARCHITECTURE_ID)
+  require += info_arch[argc];
 #endif
   (void)argv;
   return require;

Modules/CMakeCUDACompilerABI.cu

@@ -13,6 +13,9 @@ int main(int argc, char* argv[])
   require += info_byte_order_little_endian[argc];
 #if defined(ABI_ID)
   require += info_abi[argc];
+#endif
+#if defined(ARCHITECTURE_ID)
+  require += info_arch[argc];
 #endif
   static_cast<void>(argv);
 

Modules/CMakeCXXCompilerABI.cpp

@@ -12,6 +12,9 @@ int main(int argc, char* argv[])
   require += info_byte_order_little_endian[argc];
 #if defined(ABI_ID)
   require += info_abi[argc];
+#endif
+#if defined(ARCHITECTURE_ID)
+  require += info_arch[argc];
 #endif
   (void)argv;
   return require;

Modules/CMakeCompilerABI.h

@@ -40,6 +40,110 @@ static unsigned short const info_byte_order_little_endian[] = {
 #  define ABI_ID "ELF"
 #endif
 
+/* Sync with:
+ *   Help/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.rst
+ *   Modules/CMakeFortranCompilerABI.F
+ *   Modules/CMakeFortranCompilerABI.F90
+ *   Modules/Internal/CMakeParseCompilerArchitectureId.cmake
+ */
+#if defined(__APPLE__) && defined(__arm64__)
+#  if defined(__ARM64_ARCH_8_32__)
+#    define ARCHITECTURE_ID "arm64_32"
+#  elif defined(__arm64e__)
+#    define ARCHITECTURE_ID "arm64e"
+#  else
+#    define ARCHITECTURE_ID "arm64"
+#  endif
+#elif defined(_MSC_VER) && defined(_M_ARM64EC)
+#  define ARCHITECTURE_ID "arm64ec"
+#elif defined(_MSC_VER) && defined(_M_ARM64)
+#  define ARCHITECTURE_ID "arm64"
+#elif defined(__arm64ec__)
+#  define ARCHITECTURE_ID "arm64ec"
+#elif defined(__aarch64__)
+#  define ARCHITECTURE_ID "aarch64"
+#elif __ARM_ARCH == 7 || _M_ARM == 7 || defined(__ARM_ARCH_7__) ||            \
+  defined(__TI_ARM_V7__)
+#  if defined(__APPLE__) && defined(__ARM_ARCH_7K__)
+#    define ARCHITECTURE_ID "armv7k"
+#  elif defined(__APPLE__) && defined(__ARM_ARCH_7S__)
+#    define ARCHITECTURE_ID "armv7s"
+#  else
+#    define ARCHITECTURE_ID "armv7"
+#  endif
+#elif __ARM_ARCH == 6 || _M_ARM == 6 || defined(__ARM_ARCH_6__) ||            \
+  defined(__TI_ARM_V6__)
+#  define ARCHITECTURE_ID "armv6"
+#elif __ARM_ARCH == 5 || _M_ARM == 5 || defined(__ARM_ARCH_5__) ||            \
+  defined(__TI_ARM_V5__)
+#  define ARCHITECTURE_ID "armv5"
+#elif defined(__alpha) || defined(__alpha) || defined(_M_ALPHA)
+#  define ARCHITECTURE_ID "alpha"
+#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) ||         \
+  defined(__amd64__) || defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x86_64"
+#elif defined(__i686) || defined(__i686__) || _M_IX86 == 600
+#  define ARCHITECTURE_ID "i686"
+#elif defined(__i586) || defined(__i586__) || _M_IX86 == 500
+#  define ARCHITECTURE_ID "i586"
+#elif defined(__i486) || defined(__i486__) || _M_IX86 == 400
+#  define ARCHITECTURE_ID "i486"
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+#  define ARCHITECTURE_ID "i386"
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+#  define ARCHITECTURE_ID "ia64"
+#elif defined(__loongarch64)
+#  define ARCHITECTURE_ID "loongarch64"
+#elif defined(__loongarch__)
+#  define ARCHITECTURE_ID "loongarch32"
+#elif defined(__m68k__)
+#  define ARCHITECTURE_ID "m68k"
+#elif defined(__mips64) || defined(__mips64__)
+#  if defined(_MIPSEL)
+#    define ARCHITECTURE_ID "mips64el"
+#  else
+#    define ARCHITECTURE_ID "mips64"
+#  endif
+#elif defined(__mips) || defined(__mips__)
+#  if defined(_MIPSEL)
+#    define ARCHITECTURE_ID "mipsel"
+#  else
+#    define ARCHITECTURE_ID "mips"
+#  endif
+#elif defined(__riscv) && __riscv_xlen == 64
+#  define ARCHITECTURE_ID "riscv64"
+#elif defined(__riscv) && __riscv_xlen == 32
+#  define ARCHITECTURE_ID "riscv32"
+#elif defined(__s390x__)
+#  define ARCHITECTURE_ID "s390x"
+#elif defined(__s390__)
+#  define ARCHITECTURE_ID "s390"
+#elif defined(__sparcv9) || defined(__sparcv9__) || defined(__sparc64__)
+#  define ARCHITECTURE_ID "sparcv9"
+#elif defined(__sparc) || defined(__sparc__)
+#  define ARCHITECTURE_ID "sparc"
+#elif defined(__hppa) || defined(__hppa__)
+#  if defined(__LP64__)
+#    define ARCHITECTURE_ID "parisc64"
+#  else
+#    define ARCHITECTURE_ID "parisc"
+#  endif
+#elif defined(__ppc64__) || defined(__powerpc64__) || defined(__PPC64__) ||   \
+  defined(_ARCH_PPC64)
+#  if defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__)
+#    define ARCHITECTURE_ID "ppc64le"
+#  else
+#    define ARCHITECTURE_ID "ppc64"
+#  endif
+#elif defined(__ppc__) || defined(__powerpc__) || defined(__PPC__) ||         \
+  defined(_ARCH_PPC)
+#  if defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__)
+#    define ARCHITECTURE_ID "ppcle"
+#  else
+#    define ARCHITECTURE_ID "ppc"
+#  endif
+#endif
+
 /* Construct the string literal in pieces to prevent the source from
    getting matched.  Store it in a pointer rather than an array
    because some compilers will just produce instructions to fill the
@@ -49,3 +153,8 @@ static char const* info_abi = "INFO"
                               ":"
                               "abi[" ABI_ID "]";
 #endif
+#if defined(ARCHITECTURE_ID)
+static char const* info_arch = "INFO"
+                               ":"
+                               "arch[" ARCHITECTURE_ID "]";
+#endif

Modules/CMakeDetermineCompilerABI.cmake

@@ -150,6 +150,7 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
       set(ABI_SIZEOF_DPTR "NOTFOUND")
       set(ABI_BYTE_ORDER "NOTFOUND")
       set(ABI_NAME "NOTFOUND")
+      set(ARCHITECTURE_ID "")
       foreach(info ${ABI_STRINGS})
         if("${info}" MATCHES "INFO:sizeof_dptr\\[0*([^]]*)\\]" AND NOT ABI_SIZEOF_DPTR)
           set(ABI_SIZEOF_DPTR "${CMAKE_MATCH_1}")
@@ -167,6 +168,9 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
         if("${info}" MATCHES "INFO:abi\\[([^]]*)\\]" AND NOT ABI_NAME)
           set(ABI_NAME "${CMAKE_MATCH_1}")
         endif()
+        if("${info}" MATCHES "INFO:arch\\[([^]\"]*)\\]")
+          list(APPEND ARCHITECTURE_ID "${CMAKE_MATCH_1}")
+        endif()
       endforeach()
 
       if(ABI_SIZEOF_DPTR)
@@ -183,6 +187,28 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
         set(CMAKE_${lang}_COMPILER_ABI "${ABI_NAME}" PARENT_SCOPE)
       endif()
 
+      # The GNU Fortran compiler does not predefine architecture macros.
+      if(NOT CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND NOT ARCHITECTURE_ID
+         AND lang STREQUAL "Fortran" AND CMAKE_${lang}_COMPILER_ID STREQUAL "GNU")
+        execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -dumpmachine
+          OUTPUT_VARIABLE _dumpmachine_triple OUTPUT_STRIP_TRAILING_WHITESPACE
+          ERROR_VARIABLE  _dumpmachine_stderr
+          RESULT_VARIABLE _dumpmachine_result
+          )
+        if(_dumpmachine_result EQUAL 0)
+          include(Internal/CMakeParseCompilerArchitectureId)
+          cmake_parse_compiler_architecture_id("${_dumpmachine_triple}" ARCHITECTURE_ID)
+        endif()
+      endif()
+
+      # For some compilers we detect the architecture id during compiler identification.
+      # If this was not one of those, use what was detected during compiler ABI detection,
+      # which might be a list, e.g., when CMAKE_OSX_ARCHITECTURES has multiple values.
+      if(NOT CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND ARCHITECTURE_ID)
+        list(SORT ARCHITECTURE_ID)
+        set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${ARCHITECTURE_ID}" PARENT_SCOPE)
+      endif()
+
       # Parse implicit include directory for this language, if available.
       if(CMAKE_${lang}_VERBOSE_FLAG)
         set (implicit_incdirs "")

Modules/CMakeFortranCompilerABI.F

@@ -40,5 +40,108 @@
 #if defined(__ELF__)
         PRINT *, 'INFO:abi[ELF]'
 #endif
+
+#if 0
+! Sync with
+!   Help/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.rst
+!   Modules/CMakeCompilerABI.h
+!   Modules/CMakeFortranCompilerABI.F90
+!   Modules/Internal/CMakeParseCompilerArchitectureId.cmake
+#endif
+#if defined(__APPLE__) && defined(__arm64__)
+#  if defined(__ARM64_ARCH_8_32__)
+        PRINT *, 'INFO:arch[arm64_32]'
+#  elif defined(__arm64e__)
+        PRINT *, 'INFO:arch[arm64e]'
+#  else
+        PRINT *, 'INFO:arch[arm64]'
+#  endif
+#elif defined(_MSC_VER) && defined(_M_ARM64EC)
+        PRINT *, 'INFO:arch[arm64ec]'
+#elif defined(_MSC_VER) && defined(_M_ARM64)
+        PRINT *, 'INFO:arch[arm64]'
+#elif defined(__arm64ec__)
+        PRINT *, 'INFO:arch[arm64ec]'
+#elif defined(__aarch64__)
+        PRINT *, 'INFO:arch[aarch64]'
+#elif __ARM_ARCH == 7 || _M_ARM == 7 || defined(__ARM_ARCH_7__)
+#  if defined(__APPLE__) && defined(__ARM_ARCH_7K__)
+        PRINT *, 'INFO:arch[armv7k]'
+#  elif defined(__APPLE__) && defined(__ARM_ARCH_7S__)
+        PRINT *, 'INFO:arch[armv7s]'
+#  else
+        PRINT *, 'INFO:arch[armv7]'
+#  endif
+#elif __ARM_ARCH == 6 || _M_ARM == 6 || defined(__ARM_ARCH_6__)
+        PRINT *, 'INFO:arch[armv6]'
+#elif __ARM_ARCH == 5 || _M_ARM == 5 || defined(__ARM_ARCH_5__)
+        PRINT *, 'INFO:arch[armv5]'
+#elif defined(__alpha) || defined(__alpha) || defined(_M_ALPHA)
+        PRINT *, 'INFO:arch[alpha]'
+#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) ||         \
+  defined(__amd64__) || defined(_M_X64) || defined(_M_AMD64)
+        PRINT *, 'INFO:arch[x86_64]'
+#elif defined(__i686) || defined(__i686__) || _M_IX86 == 600
+        PRINT *, 'INFO:arch[i686]'
+#elif defined(__i586) || defined(__i586__) || _M_IX86 == 500
+        PRINT *, 'INFO:arch[i586]'
+#elif defined(__i486) || defined(__i486__) || _M_IX86 == 400
+        PRINT *, 'INFO:arch[i486]'
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+        PRINT *, 'INFO:arch[i386]'
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+        PRINT *, 'INFO:arch[ia64]'
+#elif defined(__loongarch64)
+        PRINT *, 'INFO:arch[loongarch64]'
+#elif defined(__loongarch__)
+        PRINT *, 'INFO:arch[loongarch32]'
+#elif defined(__m68k__)
+        PRINT *, 'INFO:arch[m68k]'
+#elif defined(__mips64) || defined(__mips64__)
+#  if defined(_MIPSEL)
+        PRINT *, 'INFO:arch[mips64el]'
+#  else
+        PRINT *, 'INFO:arch[mips64]'
+#  endif
+#elif defined(__mips) || defined(__mips__)
+#  if defined(_MIPSEL)
+        PRINT *, 'INFO:arch[mipsel]'
+#  else
+        PRINT *, 'INFO:arch[mips]'
+#  endif
+#elif defined(__riscv) && __riscv_xlen == 64
+        PRINT *, 'INFO:arch[riscv64]'
+#elif defined(__riscv) && __riscv_xlen == 32
+        PRINT *, 'INFO:arch[riscv32]'
+#elif defined(__s390x__)
+        PRINT *, 'INFO:arch[s390x]'
+#elif defined(__s390__)
+        PRINT *, 'INFO:arch[s390]'
+#elif defined(__sparcv9) || defined(__sparcv9__) || defined(__sparc64__)
+        PRINT *, 'INFO:arch[sparcv9]'
+#elif defined(__sparc) || defined(__sparc__)
+        PRINT *, 'INFO:arch[sparc]'
+#elif defined(__hppa) || defined(__hppa__)
+#  if defined(__LP64__)
+        PRINT *, 'INFO:arch[parisc64]'
+#  else
+        PRINT *, 'INFO:arch[parisc]'
+#  endif
+#elif defined(__ppc64__) || defined(__powerpc64__) || defined(__PPC64__) ||   \
+  defined(_ARCH_PPC64)
+#  if defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__)
+        PRINT *, 'INFO:arch[ppc64le]'
+#  else
+        PRINT *, 'INFO:arch[ppc64]'
+#  endif
+#elif defined(__ppc__) || defined(__powerpc__) || defined(__PPC__) ||         \
+  defined(_ARCH_PPC)
+#  if defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__)
+        PRINT *, 'INFO:arch[ppcle]'
+#  else
+        PRINT *, 'INFO:arch[ppc]'
+#  endif
+#endif
+
         PRINT *, 'ABI Detection'
       END

Modules/CMakeFortranCompilerABI.F90

@@ -48,5 +48,108 @@ PRINT *, 'INFO:sizeof_dptr[4]'
 #if defined(__ELF__)
 PRINT *, 'INFO:abi[ELF]'
 #endif
+
+#if 0
+! Sync with
+!   Help/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.rst
+!   Modules/CMakeCompilerABI.h
+!   Modules/CMakeFortranCompilerABI.F
+!   Modules/Internal/CMakeParseCompilerArchitectureId.cmake
+#endif
+#if defined(__APPLE__) && defined(__arm64__)
+#  if defined(__ARM64_ARCH_8_32__)
+PRINT *, 'INFO:arch[arm64_32]'
+#  elif defined(__arm64e__)
+PRINT *, 'INFO:arch[arm64e]'
+#  else
+PRINT *, 'INFO:arch[arm64]'
+#  endif
+#elif defined(_MSC_VER) && defined(_M_ARM64EC)
+PRINT *, 'INFO:arch[arm64ec]'
+#elif defined(_MSC_VER) && defined(_M_ARM64)
+PRINT *, 'INFO:arch[arm64]'
+#elif defined(__arm64ec__)
+PRINT *, 'INFO:arch[arm64ec]'
+#elif defined(__aarch64__)
+PRINT *, 'INFO:arch[aarch64]'
+#elif __ARM_ARCH == 7 || _M_ARM == 7 || defined(__ARM_ARCH_7__)
+#  if defined(__APPLE__) && defined(__ARM_ARCH_7K__)
+PRINT *, 'INFO:arch[armv7k]'
+#  elif defined(__APPLE__) && defined(__ARM_ARCH_7S__)
+PRINT *, 'INFO:arch[armv7s]'
+#  else
+PRINT *, 'INFO:arch[armv7]'
+#  endif
+#elif __ARM_ARCH == 6 || _M_ARM == 6 || defined(__ARM_ARCH_6__)
+PRINT *, 'INFO:arch[armv6]'
+#elif __ARM_ARCH == 5 || _M_ARM == 5 || defined(__ARM_ARCH_5__)
+PRINT *, 'INFO:arch[armv5]'
+#elif defined(__alpha) || defined(__alpha) || defined(_M_ALPHA)
+PRINT *, 'INFO:arch[alpha]'
+#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) ||         \
+  defined(__amd64__) || defined(_M_X64) || defined(_M_AMD64)
+PRINT *, 'INFO:arch[x86_64]'
+#elif defined(__i686) || defined(__i686__) || _M_IX86 == 600
+PRINT *, 'INFO:arch[i686]'
+#elif defined(__i586) || defined(__i586__) || _M_IX86 == 500
+PRINT *, 'INFO:arch[i586]'
+#elif defined(__i486) || defined(__i486__) || _M_IX86 == 400
+PRINT *, 'INFO:arch[i486]'
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+PRINT *, 'INFO:arch[i386]'
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+PRINT *, 'INFO:arch[ia64]'
+#elif defined(__loongarch64)
+PRINT *, 'INFO:arch[loongarch64]'
+#elif defined(__loongarch__)
+PRINT *, 'INFO:arch[loongarch32]'
+#elif defined(__m68k__)
+PRINT *, 'INFO:arch[m68k]'
+#elif defined(__mips64) || defined(__mips64__)
+#  if defined(_MIPSEL)
+PRINT *, 'INFO:arch[mips64el]'
+#  else
+PRINT *, 'INFO:arch[mips64]'
+#  endif
+#elif defined(__mips) || defined(__mips__)
+#  if defined(_MIPSEL)
+PRINT *, 'INFO:arch[mipsel]'
+#  else
+PRINT *, 'INFO:arch[mips]'
+#  endif
+#elif defined(__riscv) && __riscv_xlen == 64
+PRINT *, 'INFO:arch[riscv64]'
+#elif defined(__riscv) && __riscv_xlen == 32
+PRINT *, 'INFO:arch[riscv32]'
+#elif defined(__s390x__)
+PRINT *, 'INFO:arch[s390x]'
+#elif defined(__s390__)
+PRINT *, 'INFO:arch[s390]'
+#elif defined(__sparcv9) || defined(__sparcv9__) || defined(__sparc64__)
+PRINT *, 'INFO:arch[sparcv9]'
+#elif defined(__sparc) || defined(__sparc__)
+PRINT *, 'INFO:arch[sparc]'
+#elif defined(__hppa) || defined(__hppa__)
+#  if defined(__LP64__)
+PRINT *, 'INFO:arch[parisc64]'
+#  else
+PRINT *, 'INFO:arch[parisc]'
+#  endif
+#elif defined(__ppc64__) || defined(__powerpc64__) || defined(__PPC64__) ||   \
+  defined(_ARCH_PPC64)
+#  if defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__)
+PRINT *, 'INFO:arch[ppc64le]'
+#  else
+PRINT *, 'INFO:arch[ppc64]'
+#  endif
+#elif defined(__ppc__) || defined(__powerpc__) || defined(__PPC__) ||         \
+  defined(_ARCH_PPC)
+#  if defined(_LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__)
+PRINT *, 'INFO:arch[ppcle]'
+#  else
+PRINT *, 'INFO:arch[ppc]'
+#  endif
+#endif
+
 PRINT *, 'ABI Detection'
 end program

Modules/CMakeHIPCompilerABI.hip

@@ -14,6 +14,9 @@ int main(int argc, char* argv[])
   require += info_sizeof_dptr[argc];
 #if defined(ABI_ID)
   require += info_abi[argc];
+#endif
+#if defined(ARCHITECTURE_ID)
+  require += info_arch[argc];
 #endif
   static_cast<void>(argv);
 

Modules/CMakeOBJCCompilerABI.m

@@ -16,6 +16,9 @@ int main(int argc, char *argv[])
   require += info_byte_order_little_endian[argc];
 #if defined(ABI_ID)
   require += info_abi[argc];
+#endif
+#if defined(ARCHITECTURE_ID)
+  require += info_arch[argc];
 #endif
   (void)argv;
   return require;

Modules/CMakeOBJCXXCompilerABI.mm

@@ -16,6 +16,9 @@ int main(int argc, char *argv[])
   require += info_byte_order_little_endian[argc];
 #if defined(ABI_ID)
   require += info_abi[argc];
+#endif
+#if defined(ARCHITECTURE_ID)
+  require += info_arch[argc];
 #endif
   (void)argv;
   return require;

Modules/Internal/CMakeParseCompilerArchitectureId.cmake

@@ -0,0 +1,74 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+function(cmake_parse_compiler_architecture_id triple arch_id_var)
+  # Sync with:
+  #   Help/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.rst
+  #   Modules/CMakeCompilerABI.h
+  #   Modules/CMakeFortranCompilerABI.F
+  #   Modules/CMakeFortranCompilerABI.F90
+  if(_dumpmachine_triple MATCHES "^(aarch64|arm64)-apple-")
+    set(ARCHITECTURE_ID "arm64")
+  elseif(_dumpmachine_triple MATCHES "^(aarch64|arm64)_32-apple-")
+    set(ARCHITECTURE_ID "arm64_32")
+  elseif(_dumpmachine_triple MATCHES "^(aarch64|arm64)e-apple-")
+    set(ARCHITECTURE_ID "arm64e")
+  elseif(_dumpmachine_triple MATCHES "^(armv7k|armv7s)-apple-")
+    set(ARCHITECTURE_ID "${CMAKE_MATCH_1}")
+  elseif(_dumpmachine_triple MATCHES "^(aarch64|arm64)-")
+    set(ARCHITECTURE_ID "aarch64")
+  elseif(_dumpmachine_triple MATCHES "^(armv[5-7])[^-]*-")
+    set(ARCHITECTURE_ID "${CMAKE_MATCH_1}")
+  elseif(_dumpmachine_triple MATCHES "^alpha[^-]*-")
+    set(ARCHITECTURE_ID "alpha")
+  elseif(_dumpmachine_triple MATCHES "^(x86_64|amd64)-")
+    set(ARCHITECTURE_ID "x86_64")
+  elseif(_dumpmachine_triple MATCHES "^(i[3-6]86)-")
+    set(ARCHITECTURE_ID "${CMAKE_MATCH_1}")
+  elseif(_dumpmachine_triple MATCHES "^ia64-")
+    set(ARCHITECTURE_ID "ia64")
+  elseif(_dumpmachine_triple MATCHES "^loongarch64-")
+    set(ARCHITECTURE_ID "loongarch64")
+  elseif(_dumpmachine_triple MATCHES "^loongarch(32)?-")
+    set(ARCHITECTURE_ID "loongarch32")
+  elseif(_dumpmachine_triple MATCHES "^m68k-")
+    set(ARCHITECTURE_ID "m68k")
+  elseif(_dumpmachine_triple MATCHES "^mingw32$") # MinGW/MSYS 1.0: http://mingw.osdn.io/
+    set(ARCHITECTURE_ID "i386")
+  elseif(_dumpmachine_triple MATCHES "^mips[^-]*64[^-]*el-")
+    set(ARCHITECTURE_ID "mips64el")
+  elseif(_dumpmachine_triple MATCHES "^mips[^-]*64[^-]*-")
+    set(ARCHITECTURE_ID "mips64")
+  elseif(_dumpmachine_triple MATCHES "^mips[^-]*el[^-]*-")
+    set(ARCHITECTURE_ID "mipsel")
+  elseif(_dumpmachine_triple MATCHES "^mips[^-]*-")
+    set(ARCHITECTURE_ID "mips")
+  elseif(_dumpmachine_triple MATCHES "^riscv64-")
+    set(ARCHITECTURE_ID "riscv64")
+  elseif(_dumpmachine_triple MATCHES "^riscv32-")
+    set(ARCHITECTURE_ID "riscv32")
+  elseif(_dumpmachine_triple MATCHES "^s390x-")
+    set(ARCHITECTURE_ID "s390x")
+  elseif(_dumpmachine_triple MATCHES "^s390-")
+    set(ARCHITECTURE_ID "s390")
+  elseif(_dumpmachine_triple MATCHES "^(sparcv9|sparc64)-")
+    set(ARCHITECTURE_ID "sparcv9")
+  elseif(_dumpmachine_triple MATCHES "^sparc-")
+    set(ARCHITECTURE_ID "sparc")
+  elseif(_dumpmachine_triple MATCHES "^(hppa64|parisc64)-")
+    set(ARCHITECTURE_ID "parisc64")
+  elseif(_dumpmachine_triple MATCHES "^(hppa[0-9.]*|parisc)-")
+    set(ARCHITECTURE_ID "parisc")
+  elseif(_dumpmachine_triple MATCHES "^(powerpc64le|ppc64le)-")
+    set(ARCHITECTURE_ID "ppc64le")
+  elseif(_dumpmachine_triple MATCHES "^(powerpc64|ppc64)-")
+    set(ARCHITECTURE_ID "ppc64")
+  elseif(_dumpmachine_triple MATCHES "^(powerpcle|ppcle)-")
+    set(ARCHITECTURE_ID "ppcle")
+  elseif(_dumpmachine_triple MATCHES "^(powerpc|ppc)-")
+    set(ARCHITECTURE_ID "ppc")
+  else()
+    set(ARCHITECTURE_ID "")
+  endif()
+  set("${arch_id_var}" "${ARCHITECTURE_ID}" PARENT_SCOPE)
+endfunction()

Modules/SystemInformation.in

@@ -18,8 +18,14 @@ CMAKE_SKIP_RPATH == "${CMAKE_SKIP_RPATH}"
 CMAKE_SYSTEM_INFO_FILE == "${CMAKE_SYSTEM_INFO_FILE}"
 CMAKE_SYSTEM_NAME == "${CMAKE_SYSTEM_NAME}"
 CMAKE_SYSTEM == "${CMAKE_SYSTEM}"
-CMAKE_CXX_COMPILER == "${CMAKE_CXX_COMPILER}"
 CMAKE_C_COMPILER == "${CMAKE_C_COMPILER}"
+CMAKE_C_COMPILER_ID == "${CMAKE_C_COMPILER_ID}"
+CMAKE_C_COMPILER_VERSION == "${CMAKE_C_COMPILER_VERSION}"
+CMAKE_C_COMPILER_ARCHITECTURE_ID == "${CMAKE_C_COMPILER_ARCHITECTURE_ID}"
+CMAKE_CXX_COMPILER == "${CMAKE_CXX_COMPILER}"
+CMAKE_CXX_COMPILER_ID == "${CMAKE_CXX_COMPILER_ID}"
+CMAKE_CXX_COMPILER_VERSION == "${CMAKE_CXX_COMPILER_VERSION}"
+CMAKE_CXX_COMPILER_ARCHITECTURE_ID == "${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}"
 CMAKE_COMPILER_IS_GNUCC == "${CMAKE_COMPILER_IS_GNUCC}"
 CMAKE_COMPILER_IS_GNUCXX == "${CMAKE_COMPILER_IS_GNUCXX}"
 

Tests/RunCMake/CompilerId/C-stdout.txt

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

Tests/RunCMake/CompilerId/C.cmake

@@ -2,3 +2,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}'")
+message(STATUS "CMAKE_C_COMPILER_ARCHITECTURE_ID='${CMAKE_C_COMPILER_ARCHITECTURE_ID}'")

Tests/RunCMake/CompilerId/CUDA-stdout.txt

@@ -1,11 +1,13 @@
 (-- CMAKE_CUDA_COMPILER='[^']+'
 -- CMAKE_CUDA_COMPILER_ID='NVIDIA'
 -- CMAKE_CUDA_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+-- CMAKE_CUDA_COMPILER_ARCHITECTURE_ID='[A-Za-z0-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_COMPILER_ARCHITECTURE_ID='[A-Za-z0-9_;]+'
 -- CMAKE_CUDA_HOST_COMPILER_ID=''
 -- CMAKE_CUDA_HOST_COMPILER_VERSION=''
 )

Tests/RunCMake/CompilerId/CUDA.cmake

@@ -2,5 +2,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_COMPILER_ARCHITECTURE_ID='${CMAKE_CUDA_COMPILER_ARCHITECTURE_ID}'")
 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

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

Tests/RunCMake/CompilerId/CXX.cmake

@@ -2,3 +2,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}'")
+message(STATUS "CMAKE_CXX_COMPILER_ARCHITECTURE_ID='${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}'")

Tests/RunCMake/CompilerId/Fortran-stdout.txt

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

Tests/RunCMake/CompilerId/Fortran.cmake

@@ -2,3 +2,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}'")
+message(STATUS "CMAKE_Fortran_COMPILER_ARCHITECTURE_ID='${CMAKE_Fortran_COMPILER_ARCHITECTURE_ID}'")

Tests/RunCMake/CompilerId/HIP-stdout.txt

@@ -1,11 +1,13 @@
 (-- CMAKE_HIP_COMPILER='[^']+'
 -- CMAKE_HIP_COMPILER_ID='NVIDIA'
 -- CMAKE_HIP_COMPILER_VERSION='([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?'
+-- CMAKE_HIP_COMPILER_ARCHITECTURE_ID='[A-Za-z0-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_COMPILER_ARCHITECTURE_ID='[A-Za-z0-9_;]+'
 -- CMAKE_HIP_HOST_COMPILER_ID=''
 -- CMAKE_HIP_HOST_COMPILER_VERSION=''
 )

Tests/RunCMake/CompilerId/HIP.cmake

@@ -2,5 +2,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_COMPILER_ARCHITECTURE_ID='${CMAKE_HIP_COMPILER_ARCHITECTURE_ID}'")
 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/OBJC-stdout.txt

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

Tests/RunCMake/CompilerId/OBJC.cmake

@@ -2,3 +2,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}'")
+message(STATUS "CMAKE_OBJC_COMPILER_ARCHITECTURE_ID='${CMAKE_OBJC_COMPILER_ARCHITECTURE_ID}'")

Tests/RunCMake/CompilerId/OBJCXX-stdout.txt

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

Tests/RunCMake/CompilerId/OBJCXX.cmake

@@ -2,3 +2,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}'")
+message(STATUS "CMAKE_OBJCXX_COMPILER_ARCHITECTURE_ID='${CMAKE_OBJCXX_COMPILER_ARCHITECTURE_ID}'")

Tests/SystemInformation/SystemInformation.in

@@ -19,6 +19,7 @@ CMAKE_COMPILER_IS_GNUCC == "${CMAKE_COMPILER_IS_GNUCC}"
 CMAKE_COMPILER_IS_GNUCXX == "${CMAKE_COMPILER_IS_GNUCXX}"
 CMAKE_C_COMPILER_ID == "${CMAKE_C_COMPILER_ID}"
 CMAKE_C_COMPILER_VERSION == "${CMAKE_C_COMPILER_VERSION}"
+CMAKE_C_COMPILER_ARCHITECTURE_ID == "${CMAKE_C_COMPILER_ARCHITECTURE_ID}"
 CMAKE_C90_STANDARD_COMPILE_OPTION == "${CMAKE_C90_STANDARD_COMPILE_OPTION}"
 CMAKE_C99_STANDARD_COMPILE_OPTION == "${CMAKE_C99_STANDARD_COMPILE_OPTION}"
 CMAKE_C11_STANDARD_COMPILE_OPTION == "${CMAKE_C11_STANDARD_COMPILE_OPTION}"
@@ -31,6 +32,7 @@ CMAKE_C99_COMPILE_FEATURES == "${CMAKE_C99_COMPILE_FEATURES}"
 CMAKE_C11_COMPILE_FEATURES == "${CMAKE_C11_COMPILE_FEATURES}"
 CMAKE_CXX_COMPILER_ID == "${CMAKE_CXX_COMPILER_ID}"
 CMAKE_CXX_COMPILER_VERSION == "${CMAKE_CXX_COMPILER_VERSION}"
+CMAKE_CXX_COMPILER_ARCHITECTURE_ID == "${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}"
 CMAKE_CXX98_STANDARD_COMPILE_OPTION == "${CMAKE_CXX98_STANDARD_COMPILE_OPTION}"
 CMAKE_CXX11_STANDARD_COMPILE_OPTION == "${CMAKE_CXX11_STANDARD_COMPILE_OPTION}"
 CMAKE_CXX98_EXTENSION_COMPILE_OPTION == "${CMAKE_CXX98_EXTENSION_COMPILE_OPTION}"