host-cpu-c-abi.m4 (22432B)
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 ])