m4/host-cpu-c-abi.m4

   1 # host-cpu-c-abi.m4 serial 13
   2 dnl Copyright (C) 2002-2020 Free Software Foundation, Inc.
   3 dnl This file is free software; the Free Software Foundation
   4 dnl gives unlimited permission to copy and/or distribute it,
   5 dnl with or without modifications, as long as this notice is preserved.
   6
   7 dnl From Bruno Haible and Sam Steingold.
   8
   9 dnl Sets the HOST_CPU variable to the canonical name of the CPU.
  10 dnl Sets the HOST_CPU_C_ABI variable to the canonical name of the CPU with its
  11 dnl C language ABI (application binary interface).
  12 dnl Also defines __${HOST_CPU}__ and __${HOST_CPU_C_ABI}__ as C macros in
  13 dnl config.h.
  14 dnl
  15 dnl This canonical name can be used to select a particular assembly language
  16 dnl source file that will interoperate with C code on the given host.
  17 dnl
  18 dnl For example:
  19 dnl * 'i386' and 'sparc' are different canonical names, because code for i386
  20 dnl   will not run on SPARC CPUs and vice versa. They have different
  21 dnl   instruction sets.
  22 dnl * 'sparc' and 'sparc64' are different canonical names, because code for
  23 dnl   'sparc' and code for 'sparc64' cannot be linked together: 'sparc' code
  24 dnl   contains 32-bit instructions, whereas 'sparc64' code contains 64-bit
  25 dnl   instructions. A process on a SPARC CPU can be in 32-bit mode or in 64-bit
  26 dnl   mode, but not both.
  27 dnl * 'mips' and 'mipsn32' are different canonical names, because they use
  28 dnl   different argument passing and return conventions for C functions, and
  29 dnl   although the instruction set of 'mips' is a large subset of the
  30 dnl   instruction set of 'mipsn32'.
  31 dnl * 'mipsn32' and 'mips64' are different canonical names, because they use
  32 dnl   different sizes for the C types like 'int' and 'void *', and although
  33 dnl   the instruction sets of 'mipsn32' and 'mips64' are the same.
  34 dnl * The same canonical name is used for different endiannesses. You can
  35 dnl   determine the endianness through preprocessor symbols:
  36 dnl   - 'arm': test __ARMEL__.
  37 dnl   - 'mips', 'mipsn32', 'mips64': test _MIPSEB vs. _MIPSEL.
  38 dnl   - 'powerpc64': test _BIG_ENDIAN vs. _LITTLE_ENDIAN.
  39 dnl * The same name 'i386' is used for CPUs of type i386, i486, i586
  40 dnl   (Pentium), AMD K7, Pentium II, Pentium IV, etc., because
  41 dnl   - Instructions that do not exist on all of these CPUs (cmpxchg,
  42 dnl     MMX, SSE, SSE2, 3DNow! etc.) are not frequently used. If your
  43 dnl     assembly language source files use such instructions, you will
  44 dnl     need to make the distinction.
  45 dnl   - Speed of execution of the common instruction set is reasonable across
  46 dnl     the entire family of CPUs. If you have assembly language source files
  47 dnl     that are optimized for particular CPU types (like GNU gmp has), you
  48 dnl     will need to make the distinction.
  49 dnl   See <https://en.wikipedia.org/wiki/X86_instruction_listings>.
  50 AC_DEFUN([gl_HOST_CPU_C_ABI],
  51 [
  52   AC_REQUIRE([AC_CANONICAL_HOST])
  53   AC_REQUIRE([gl_C_ASM])
  54   AC_CACHE_CHECK([host CPU and C ABI], [gl_cv_host_cpu_c_abi],
  55     [case "$host_cpu" in
  56
  57 changequote(,)dnl
  58        i[34567]86 )
  59 changequote([,])dnl
  60          gl_cv_host_cpu_c_abi=i386
  61          ;;
  62
  63        x86_64 )
  64          # On x86_64 systems, the C compiler may be generating code in one of
  65          # these ABIs:
  66          # - 64-bit instruction set, 64-bit pointers, 64-bit 'long': x86_64.
  67          # - 64-bit instruction set, 64-bit pointers, 32-bit 'long': x86_64
  68          #   with native Windows (mingw, MSVC).
  69          # - 64-bit instruction set, 32-bit pointers, 32-bit 'long': x86_64-x32.
  70          # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': i386.
  71          AC_COMPILE_IFELSE(
  72            [AC_LANG_SOURCE(
  73               [[#if (defined __x86_64__ || defined __amd64__ \
  74                      || defined _M_X64 || defined _M_AMD64)
  75                  int ok;
  76                 #else
  77                  error fail
  78                 #endif
  79               ]])],
  80            [AC_COMPILE_IFELSE(
  81               [AC_LANG_SOURCE(
  82                  [[#if defined __ILP32__ || defined _ILP32
  83                     int ok;
  84                    #else
  85                     error fail
  86                    #endif
  87                  ]])],
  88               [gl_cv_host_cpu_c_abi=x86_64-x32],
  89               [gl_cv_host_cpu_c_abi=x86_64])],
  90            [gl_cv_host_cpu_c_abi=i386])
  91          ;;
  92
  93 changequote(,)dnl
  94        alphaev[4-8] | alphaev56 | alphapca5[67] | alphaev6[78] )
  95 changequote([,])dnl
  96          gl_cv_host_cpu_c_abi=alpha
  97          ;;
  98
  99        arm* | aarch64 )
 100          # Assume arm with EABI.
 101          # On arm64 systems, the C compiler may be generating code in one of
 102          # these ABIs:
 103          # - aarch64 instruction set, 64-bit pointers, 64-bit 'long': arm64.
 104          # - aarch64 instruction set, 32-bit pointers, 32-bit 'long': arm64-ilp32.
 105          # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': arm or armhf.
 106          AC_COMPILE_IFELSE(
 107            [AC_LANG_SOURCE(
 108               [[#ifdef __aarch64__
 109                  int ok;
 110                 #else
 111                  error fail
 112                 #endif
 113               ]])],
 114            [AC_COMPILE_IFELSE(
 115               [AC_LANG_SOURCE(
 116                 [[#if defined __ILP32__ || defined _ILP32
 117                    int ok;
 118                   #else
 119                    error fail
 120                   #endif
 121                 ]])],
 122               [gl_cv_host_cpu_c_abi=arm64-ilp32],
 123               [gl_cv_host_cpu_c_abi=arm64])],
 124            [# Don't distinguish little-endian and big-endian arm, since they
 125             # don't require different machine code for simple operations and
 126             # since the user can distinguish them through the preprocessor
 127             # defines __ARMEL__ vs. __ARMEB__.
 128             # But distinguish arm which passes floating-point arguments and
 129             # return values in integer registers (r0, r1, ...) - this is
 130             # gcc -mfloat-abi=soft or gcc -mfloat-abi=softfp - from arm which
 131             # passes them in float registers (s0, s1, ...) and double registers
 132             # (d0, d1, ...) - this is gcc -mfloat-abi=hard. GCC 4.6 or newer
 133             # sets the preprocessor defines __ARM_PCS (for the first case) and
 134             # __ARM_PCS_VFP (for the second case), but older GCC does not.
 135             echo 'double ddd; void func (double dd) { ddd = dd; }' > conftest.c
 136             # Look for a reference to the register d0 in the .s file.
 137             AC_TRY_COMMAND(${CC-cc} $CFLAGS $CPPFLAGS $gl_c_asm_opt conftest.c) >/dev/null 2>&1
 138             if LC_ALL=C grep 'd0,' conftest.$gl_asmext >/dev/null; then
 139               gl_cv_host_cpu_c_abi=armhf
 140             else
 141               gl_cv_host_cpu_c_abi=arm
 142             fi
 143             rm -f conftest*
 144            ])
 145          ;;
 146
 147        hppa1.0 | hppa1.1 | hppa2.0* | hppa64 )
 148          # On hppa, the C compiler may be generating 32-bit code or 64-bit
 149          # code. In the latter case, it defines _LP64 and __LP64__.
 150          AC_COMPILE_IFELSE(
 151            [AC_LANG_SOURCE(
 152               [[#ifdef __LP64__
 153                  int ok;
 154                 #else
 155                  error fail
 156                 #endif
 157               ]])],
 158            [gl_cv_host_cpu_c_abi=hppa64],
 159            [gl_cv_host_cpu_c_abi=hppa])
 160          ;;
 161
 162        ia64* )
 163          # On ia64 on HP-UX, the C compiler may be generating 64-bit code or
 164          # 32-bit code. In the latter case, it defines _ILP32.
 165          AC_COMPILE_IFELSE(
 166            [AC_LANG_SOURCE(
 167               [[#ifdef _ILP32
 168                  int ok;
 169                 #else
 170                  error fail
 171                 #endif
 172               ]])],
 173            [gl_cv_host_cpu_c_abi=ia64-ilp32],
 174            [gl_cv_host_cpu_c_abi=ia64])
 175          ;;
 176
 177        mips* )
 178          # We should also check for (_MIPS_SZPTR == 64), but gcc keeps this
 179          # at 32.
 180          AC_COMPILE_IFELSE(
 181            [AC_LANG_SOURCE(
 182               [[#if defined _MIPS_SZLONG && (_MIPS_SZLONG == 64)
 183                  int ok;
 184                 #else
 185                  error fail
 186                 #endif
 187               ]])],
 188            [gl_cv_host_cpu_c_abi=mips64],
 189            [# In the n32 ABI, _ABIN32 is defined, _ABIO32 is not defined (but
 190             # may later get defined by <sgidefs.h>), and _MIPS_SIM == _ABIN32.
 191             # In the 32 ABI, _ABIO32 is defined, _ABIN32 is not defined (but
 192             # may later get defined by <sgidefs.h>), and _MIPS_SIM == _ABIO32.
 193             AC_COMPILE_IFELSE(
 194               [AC_LANG_SOURCE(
 195                  [[#if (_MIPS_SIM == _ABIN32)
 196                     int ok;
 197                    #else
 198                     error fail
 199                    #endif
 200                  ]])],
 201               [gl_cv_host_cpu_c_abi=mipsn32],
 202               [gl_cv_host_cpu_c_abi=mips])])
 203          ;;
 204
 205        powerpc* )
 206          # Different ABIs are in use on AIX vs. Mac OS X vs. Linux,*BSD.
 207          # No need to distinguish them here; the caller may distinguish
 208          # them based on the OS.
 209          # On powerpc64 systems, the C compiler may still be generating
 210          # 32-bit code. And on powerpc-ibm-aix systems, the C compiler may
 211          # be generating 64-bit code.
 212          AC_COMPILE_IFELSE(
 213            [AC_LANG_SOURCE(
 214               [[#if defined __powerpc64__ || defined _ARCH_PPC64
 215                  int ok;
 216                 #else
 217                  error fail
 218                 #endif
 219               ]])],
 220            [# On powerpc64, there are two ABIs on Linux: The AIX compatible
 221             # one and the ELFv2 one. The latter defines _CALL_ELF=2.
 222             AC_COMPILE_IFELSE(
 223               [AC_LANG_SOURCE(
 224                  [[#if defined _CALL_ELF && _CALL_ELF == 2
 225                     int ok;
 226                    #else
 227                     error fail
 228                    #endif
 229                  ]])],
 230               [gl_cv_host_cpu_c_abi=powerpc64-elfv2],
 231               [gl_cv_host_cpu_c_abi=powerpc64])
 232            ],
 233            [gl_cv_host_cpu_c_abi=powerpc])
 234          ;;
 235
 236        rs6000 )
 237          gl_cv_host_cpu_c_abi=powerpc
 238          ;;
 239
 240        riscv32 | riscv64 )
 241          # There are 2 architectures (with variants): rv32* and rv64*.
 242          AC_COMPILE_IFELSE(
 243            [AC_LANG_SOURCE(
 244               [[#if __riscv_xlen == 64
 245                   int ok;
 246                 #else
 247                   error fail
 248                 #endif
 249               ]])],
 250            [cpu=riscv64],
 251            [cpu=riscv32])
 252          # There are 6 ABIs: ilp32, ilp32f, ilp32d, lp64, lp64f, lp64d.
 253          # Size of 'long' and 'void *':
 254          AC_COMPILE_IFELSE(
 255            [AC_LANG_SOURCE(
 256               [[#if defined __LP64__
 257                   int ok;
 258                 #else
 259                   error fail
 260                 #endif
 261               ]])],
 262            [main_abi=lp64],
 263            [main_abi=ilp32])
 264          # Float ABIs:
 265          # __riscv_float_abi_double:
 266          #   'float' and 'double' are passed in floating-point registers.
 267          # __riscv_float_abi_single:
 268          #   'float' are passed in floating-point registers.
 269          # __riscv_float_abi_soft:
 270          #   No values are passed in floating-point registers.
 271          AC_COMPILE_IFELSE(
 272            [AC_LANG_SOURCE(
 273               [[#if defined __riscv_float_abi_double
 274                   int ok;
 275                 #else
 276                   error fail
 277                 #endif
 278               ]])],
 279            [float_abi=d],
 280            [AC_COMPILE_IFELSE(
 281               [AC_LANG_SOURCE(
 282                  [[#if defined __riscv_float_abi_single
 283                      int ok;
 284                    #else
 285                      error fail
 286                    #endif
 287                  ]])],
 288               [float_abi=f],
 289               [float_abi=''])
 290            ])
 291          gl_cv_host_cpu_c_abi="${cpu}-${main_abi}${float_abi}"
 292          ;;
 293
 294        s390* )
 295          # On s390x, the C compiler may be generating 64-bit (= s390x) code
 296          # or 31-bit (= s390) code.
 297          AC_COMPILE_IFELSE(
 298            [AC_LANG_SOURCE(
 299               [[#if defined __LP64__ || defined __s390x__
 300                   int ok;
 301                 #else
 302                   error fail
 303                 #endif
 304               ]])],
 305            [gl_cv_host_cpu_c_abi=s390x],
 306            [gl_cv_host_cpu_c_abi=s390])
 307          ;;
 308
 309        sparc | sparc64 )
 310          # UltraSPARCs running Linux have `uname -m` = "sparc64", but the
 311          # C compiler still generates 32-bit code.
 312          AC_COMPILE_IFELSE(
 313            [AC_LANG_SOURCE(
 314               [[#if defined __sparcv9 || defined __arch64__
 315                  int ok;
 316                 #else
 317                  error fail
 318                 #endif
 319               ]])],
 320            [gl_cv_host_cpu_c_abi=sparc64],
 321            [gl_cv_host_cpu_c_abi=sparc])
 322          ;;
 323
 324        *)
 325          gl_cv_host_cpu_c_abi="$host_cpu"
 326          ;;
 327      esac
 328     ])
 329
 330   dnl In most cases, $HOST_CPU and $HOST_CPU_C_ABI are the same.
 331   HOST_CPU=`echo "$gl_cv_host_cpu_c_abi" | sed -e 's/-.*//'`
 332   HOST_CPU_C_ABI="$gl_cv_host_cpu_c_abi"
 333   AC_SUBST([HOST_CPU])
 334   AC_SUBST([HOST_CPU_C_ABI])
 335
 336   # This was
 337   #   AC_DEFINE_UNQUOTED([__${HOST_CPU}__])
 338   #   AC_DEFINE_UNQUOTED([__${HOST_CPU_C_ABI}__])
 339   # earlier, but KAI C++ 3.2d doesn't like this.
 340   sed -e 's/-/_/g' >> confdefs.h <<EOF
 341 #ifndef __${HOST_CPU}__
 342 #define __${HOST_CPU}__ 1
 343 #endif
 344 #ifndef __${HOST_CPU_C_ABI}__
 345 #define __${HOST_CPU_C_ABI}__ 1
 346 #endif
 347 EOF
 348   AH_TOP([/* CPU and C ABI indicator */
 349 #ifndef __i386__
 350 #undef __i386__
 351 #endif
 352 #ifndef __x86_64_x32__
 353 #undef __x86_64_x32__
 354 #endif
 355 #ifndef __x86_64__
 356 #undef __x86_64__
 357 #endif
 358 #ifndef __alpha__
 359 #undef __alpha__
 360 #endif
 361 #ifndef __arm__
 362 #undef __arm__
 363 #endif
 364 #ifndef __armhf__
 365 #undef __armhf__
 366 #endif
 367 #ifndef __arm64_ilp32__
 368 #undef __arm64_ilp32__
 369 #endif
 370 #ifndef __arm64__
 371 #undef __arm64__
 372 #endif
 373 #ifndef __hppa__
 374 #undef __hppa__
 375 #endif
 376 #ifndef __hppa64__
 377 #undef __hppa64__
 378 #endif
 379 #ifndef __ia64_ilp32__
 380 #undef __ia64_ilp32__
 381 #endif
 382 #ifndef __ia64__
 383 #undef __ia64__
 384 #endif
 385 #ifndef __m68k__
 386 #undef __m68k__
 387 #endif
 388 #ifndef __mips__
 389 #undef __mips__
 390 #endif
 391 #ifndef __mipsn32__
 392 #undef __mipsn32__
 393 #endif
 394 #ifndef __mips64__
 395 #undef __mips64__
 396 #endif
 397 #ifndef __powerpc__
 398 #undef __powerpc__
 399 #endif
 400 #ifndef __powerpc64__
 401 #undef __powerpc64__
 402 #endif
 403 #ifndef __powerpc64_elfv2__
 404 #undef __powerpc64_elfv2__
 405 #endif
 406 #ifndef __riscv32__
 407 #undef __riscv32__
 408 #endif
 409 #ifndef __riscv64__
 410 #undef __riscv64__
 411 #endif
 412 #ifndef __riscv32_ilp32__
 413 #undef __riscv32_ilp32__
 414 #endif
 415 #ifndef __riscv32_ilp32f__
 416 #undef __riscv32_ilp32f__
 417 #endif
 418 #ifndef __riscv32_ilp32d__
 419 #undef __riscv32_ilp32d__
 420 #endif
 421 #ifndef __riscv64_ilp32__
 422 #undef __riscv64_ilp32__
 423 #endif
 424 #ifndef __riscv64_ilp32f__
 425 #undef __riscv64_ilp32f__
 426 #endif
 427 #ifndef __riscv64_ilp32d__
 428 #undef __riscv64_ilp32d__
 429 #endif
 430 #ifndef __riscv64_lp64__
 431 #undef __riscv64_lp64__
 432 #endif
 433 #ifndef __riscv64_lp64f__
 434 #undef __riscv64_lp64f__
 435 #endif
 436 #ifndef __riscv64_lp64d__
 437 #undef __riscv64_lp64d__
 438 #endif
 439 #ifndef __s390__
 440 #undef __s390__
 441 #endif
 442 #ifndef __s390x__
 443 #undef __s390x__
 444 #endif
 445 #ifndef __sh__
 446 #undef __sh__
 447 #endif
 448 #ifndef __sparc__
 449 #undef __sparc__
 450 #endif
 451 #ifndef __sparc64__
 452 #undef __sparc64__
 453 #endif
 454 ])
 455
 456 ])
 457
 458
 459 dnl Sets the HOST_CPU_C_ABI_32BIT variable to 'yes' if the C language ABI
 460 dnl (application binary interface) is a 32-bit one, to 'no' if it is a 64-bit
 461 dnl one, or to 'unknown' if unknown.
 462 dnl This is a simplified variant of gl_HOST_CPU_C_ABI.
 463 AC_DEFUN([gl_HOST_CPU_C_ABI_32BIT],
 464 [
 465   AC_REQUIRE([AC_CANONICAL_HOST])
 466   AC_CACHE_CHECK([32-bit host C ABI], [gl_cv_host_cpu_c_abi_32bit],
 467     [if test -n "$gl_cv_host_cpu_c_abi"; then
 468        case "$gl_cv_host_cpu_c_abi" in
 469          i386 | x86_64-x32 | arm | armhf | arm64-ilp32 | hppa | ia64-ilp32 | mips | mipsn32 | powerpc | riscv*-ilp32* | s390 | sparc)
 470            gl_cv_host_cpu_c_abi_32bit=yes ;;
 471          x86_64 | alpha | arm64 | hppa64 | ia64 | mips64 | powerpc64 | powerpc64-elfv2 | riscv*-lp64* | s390x | sparc64 )
 472            gl_cv_host_cpu_c_abi_32bit=no ;;
 473          *)
 474            gl_cv_host_cpu_c_abi_32bit=unknown ;;
 475        esac
 476      else
 477        case "$host_cpu" in
 478
 479          # CPUs that only support a 32-bit ABI.
 480          arc \
 481          | bfin \
 482          | cris* \
 483          | csky \
 484          | epiphany \
 485          | ft32 \
 486          | h8300 \
 487          | m68k \
 488          | microblaze | microblazeel \
 489          | nds32 | nds32le | nds32be \
 490          | nios2 | nios2eb | nios2el \
 491          | or1k* \
 492          | or32 \
 493          | sh | sh[1234] | sh[1234]e[lb] \
 494          | tic6x \
 495          | xtensa* )
 496            gl_cv_host_cpu_c_abi_32bit=yes
 497            ;;
 498
 499          # CPUs that only support a 64-bit ABI.
 500 changequote(,)dnl
 501          alpha | alphaev[4-8] | alphaev56 | alphapca5[67] | alphaev6[78] \
 502          | mmix )
 503 changequote([,])dnl
 504            gl_cv_host_cpu_c_abi_32bit=no
 505            ;;
 506
 507 changequote(,)dnl
 508          i[34567]86 )
 509 changequote([,])dnl
 510            gl_cv_host_cpu_c_abi_32bit=yes
 511            ;;
 512
 513          x86_64 )
 514            # On x86_64 systems, the C compiler may be generating code in one of
 515            # these ABIs:
 516            # - 64-bit instruction set, 64-bit pointers, 64-bit 'long': x86_64.
 517            # - 64-bit instruction set, 64-bit pointers, 32-bit 'long': x86_64
 518            #   with native Windows (mingw, MSVC).
 519            # - 64-bit instruction set, 32-bit pointers, 32-bit 'long': x86_64-x32.
 520            # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': i386.
 521            AC_COMPILE_IFELSE(
 522              [AC_LANG_SOURCE(
 523                 [[#if (defined __x86_64__ || defined __amd64__ \
 524                        || defined _M_X64 || defined _M_AMD64) \
 525                       && !(defined __ILP32__ || defined _ILP32)
 526                    int ok;
 527                   #else
 528                    error fail
 529                   #endif
 530                 ]])],
 531              [gl_cv_host_cpu_c_abi_32bit=no],
 532              [gl_cv_host_cpu_c_abi_32bit=yes])
 533            ;;
 534
 535          arm* | aarch64 )
 536            # Assume arm with EABI.
 537            # On arm64 systems, the C compiler may be generating code in one of
 538            # these ABIs:
 539            # - aarch64 instruction set, 64-bit pointers, 64-bit 'long': arm64.
 540            # - aarch64 instruction set, 32-bit pointers, 32-bit 'long': arm64-ilp32.
 541            # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': arm or armhf.
 542            AC_COMPILE_IFELSE(
 543              [AC_LANG_SOURCE(
 544                 [[#if defined __aarch64__ && !(defined __ILP32__ || defined _ILP32)
 545                    int ok;
 546                   #else
 547                    error fail
 548                   #endif
 549                 ]])],
 550              [gl_cv_host_cpu_c_abi_32bit=no],
 551              [gl_cv_host_cpu_c_abi_32bit=yes])
 552            ;;
 553
 554          hppa1.0 | hppa1.1 | hppa2.0* | hppa64 )
 555            # On hppa, the C compiler may be generating 32-bit code or 64-bit
 556            # code. In the latter case, it defines _LP64 and __LP64__.
 557            AC_COMPILE_IFELSE(
 558              [AC_LANG_SOURCE(
 559                 [[#ifdef __LP64__
 560                    int ok;
 561                   #else
 562                    error fail
 563                   #endif
 564                 ]])],
 565              [gl_cv_host_cpu_c_abi_32bit=no],
 566              [gl_cv_host_cpu_c_abi_32bit=yes])
 567            ;;
 568
 569          ia64* )
 570            # On ia64 on HP-UX, the C compiler may be generating 64-bit code or
 571            # 32-bit code. In the latter case, it defines _ILP32.
 572            AC_COMPILE_IFELSE(
 573              [AC_LANG_SOURCE(
 574                 [[#ifdef _ILP32
 575                    int ok;
 576                   #else
 577                    error fail
 578                   #endif
 579                 ]])],
 580              [gl_cv_host_cpu_c_abi_32bit=yes],
 581              [gl_cv_host_cpu_c_abi_32bit=no])
 582            ;;
 583
 584          mips* )
 585            # We should also check for (_MIPS_SZPTR == 64), but gcc keeps this
 586            # at 32.
 587            AC_COMPILE_IFELSE(
 588              [AC_LANG_SOURCE(
 589                 [[#if defined _MIPS_SZLONG && (_MIPS_SZLONG == 64)
 590                    int ok;
 591                   #else
 592                    error fail
 593                   #endif
 594                 ]])],
 595              [gl_cv_host_cpu_c_abi_32bit=no],
 596              [gl_cv_host_cpu_c_abi_32bit=yes])
 597            ;;
 598
 599          powerpc* )
 600            # Different ABIs are in use on AIX vs. Mac OS X vs. Linux,*BSD.
 601            # No need to distinguish them here; the caller may distinguish
 602            # them based on the OS.
 603            # On powerpc64 systems, the C compiler may still be generating
 604            # 32-bit code. And on powerpc-ibm-aix systems, the C compiler may
 605            # be generating 64-bit code.
 606            AC_COMPILE_IFELSE(
 607              [AC_LANG_SOURCE(
 608                 [[#if defined __powerpc64__ || defined _ARCH_PPC64
 609                    int ok;
 610                   #else
 611                    error fail
 612                   #endif
 613                 ]])],
 614              [gl_cv_host_cpu_c_abi_32bit=no],
 615              [gl_cv_host_cpu_c_abi_32bit=yes])
 616            ;;
 617
 618          rs6000 )
 619            gl_cv_host_cpu_c_abi_32bit=yes
 620            ;;
 621
 622          riscv32 | riscv64 )
 623            # There are 6 ABIs: ilp32, ilp32f, ilp32d, lp64, lp64f, lp64d.
 624            # Size of 'long' and 'void *':
 625            AC_COMPILE_IFELSE(
 626              [AC_LANG_SOURCE(
 627                 [[#if defined __LP64__
 628                     int ok;
 629                   #else
 630                     error fail
 631                   #endif
 632                 ]])],
 633              [gl_cv_host_cpu_c_abi_32bit=no],
 634              [gl_cv_host_cpu_c_abi_32bit=yes])
 635            ;;
 636
 637          s390* )
 638            # On s390x, the C compiler may be generating 64-bit (= s390x) code
 639            # or 31-bit (= s390) code.
 640            AC_COMPILE_IFELSE(
 641              [AC_LANG_SOURCE(
 642                 [[#if defined __LP64__ || defined __s390x__
 643                     int ok;
 644                   #else
 645                     error fail
 646                   #endif
 647                 ]])],
 648              [gl_cv_host_cpu_c_abi_32bit=no],
 649              [gl_cv_host_cpu_c_abi_32bit=yes])
 650            ;;
 651
 652          sparc | sparc64 )
 653            # UltraSPARCs running Linux have `uname -m` = "sparc64", but the
 654            # C compiler still generates 32-bit code.
 655            AC_COMPILE_IFELSE(
 656              [AC_LANG_SOURCE(
 657                 [[#if defined __sparcv9 || defined __arch64__
 658                    int ok;
 659                   #else
 660                    error fail
 661                   #endif
 662                 ]])],
 663              [gl_cv_host_cpu_c_abi_32bit=no],
 664              [gl_cv_host_cpu_c_abi_32bit=yes])
 665            ;;
 666
 667          *)
 668            gl_cv_host_cpu_c_abi_32bit=unknown
 669            ;;
 670        esac
 671      fi
 672     ])
 673
 674   HOST_CPU_C_ABI_32BIT="$gl_cv_host_cpu_c_abi_32bit"
 675 ])