| 1 | # host-cpu-c-abi.m4 serial 13 |
| 2 | dnl Copyright (C) 2002-2019 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 | ]) |