Add m4/host-cpu-c-abi.m4.
[ginac.git] / m4 / host-cpu-c-abi.m4
1 # host-cpu-c-abi.m4 serial 12
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, or to 'no' otherwise.
461 dnl This is a simplified variant of gl_HOST_CPU_C_ABI.
462 AC_DEFUN([gl_HOST_CPU_C_ABI_32BIT],
463 [
464   AC_REQUIRE([AC_CANONICAL_HOST])
465   AC_CACHE_CHECK([32-bit host C ABI], [gl_cv_host_cpu_c_abi_32bit],
466     [if test -n "$gl_cv_host_cpu_c_abi"; then
467        case "$gl_cv_host_cpu_c_abi" in
468          i386 | x86_64-x32 | arm | armhf | arm64-ilp32 | hppa | ia64-ilp32 | mips | mipsn32 | powerpc | riscv*-ilp32* | s390 | sparc)
469            gl_cv_host_cpu_c_abi_32bit=yes ;;
470          *)
471            gl_cv_host_cpu_c_abi_32bit=no ;;
472        esac
473      else
474        case "$host_cpu" in
475
476          # CPUs that only support a 32-bit ABI.
477          arc \
478          | bfin \
479          | cris* \
480          | csky \
481          | epiphany \
482          | ft32 \
483          | h8300 \
484          | m68k \
485          | microblaze | microblazeel \
486          | nds32 | nds32le | nds32be \
487          | nios2 | nios2eb | nios2el \
488          | or1k* \
489          | or32 \
490          | sh | sh[1234] | sh[1234]e[lb] \
491          | tic6x \
492          | xtensa* )
493            gl_cv_host_cpu_c_abi_32bit=yes
494            ;;
495
496 changequote(,)dnl
497          i[34567]86 )
498 changequote([,])dnl
499            gl_cv_host_cpu_c_abi_32bit=yes
500            ;;
501
502          x86_64 )
503            # On x86_64 systems, the C compiler may be generating code in one of
504            # these ABIs:
505            # - 64-bit instruction set, 64-bit pointers, 64-bit 'long': x86_64.
506            # - 64-bit instruction set, 64-bit pointers, 32-bit 'long': x86_64
507            #   with native Windows (mingw, MSVC).
508            # - 64-bit instruction set, 32-bit pointers, 32-bit 'long': x86_64-x32.
509            # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': i386.
510            AC_COMPILE_IFELSE(
511              [AC_LANG_SOURCE(
512                 [[#if (defined __x86_64__ || defined __amd64__ \
513                        || defined _M_X64 || defined _M_AMD64) \
514                       && !(defined __ILP32__ || defined _ILP32)
515                    int ok;
516                   #else
517                    error fail
518                   #endif
519                 ]])],
520              [gl_cv_host_cpu_c_abi_32bit=no],
521              [gl_cv_host_cpu_c_abi_32bit=yes])
522            ;;
523
524          arm* | aarch64 )
525            # Assume arm with EABI.
526            # On arm64 systems, the C compiler may be generating code in one of
527            # these ABIs:
528            # - aarch64 instruction set, 64-bit pointers, 64-bit 'long': arm64.
529            # - aarch64 instruction set, 32-bit pointers, 32-bit 'long': arm64-ilp32.
530            # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': arm or armhf.
531            AC_COMPILE_IFELSE(
532              [AC_LANG_SOURCE(
533                 [[#if defined __aarch64__ && !(defined __ILP32__ || defined _ILP32)
534                    int ok;
535                   #else
536                    error fail
537                   #endif
538                 ]])],
539              [gl_cv_host_cpu_c_abi_32bit=no],
540              [gl_cv_host_cpu_c_abi_32bit=yes])
541            ;;
542
543          hppa1.0 | hppa1.1 | hppa2.0* | hppa64 )
544            # On hppa, the C compiler may be generating 32-bit code or 64-bit
545            # code. In the latter case, it defines _LP64 and __LP64__.
546            AC_COMPILE_IFELSE(
547              [AC_LANG_SOURCE(
548                 [[#ifdef __LP64__
549                    int ok;
550                   #else
551                    error fail
552                   #endif
553                 ]])],
554              [gl_cv_host_cpu_c_abi_32bit=no],
555              [gl_cv_host_cpu_c_abi_32bit=yes])
556            ;;
557
558          ia64* )
559            # On ia64 on HP-UX, the C compiler may be generating 64-bit code or
560            # 32-bit code. In the latter case, it defines _ILP32.
561            AC_COMPILE_IFELSE(
562              [AC_LANG_SOURCE(
563                 [[#ifdef _ILP32
564                    int ok;
565                   #else
566                    error fail
567                   #endif
568                 ]])],
569              [gl_cv_host_cpu_c_abi_32bit=yes],
570              [gl_cv_host_cpu_c_abi_32bit=no])
571            ;;
572
573          mips* )
574            # We should also check for (_MIPS_SZPTR == 64), but gcc keeps this
575            # at 32.
576            AC_COMPILE_IFELSE(
577              [AC_LANG_SOURCE(
578                 [[#if defined _MIPS_SZLONG && (_MIPS_SZLONG == 64)
579                    int ok;
580                   #else
581                    error fail
582                   #endif
583                 ]])],
584              [gl_cv_host_cpu_c_abi_32bit=no],
585              [gl_cv_host_cpu_c_abi_32bit=yes])
586            ;;
587
588          powerpc* )
589            # Different ABIs are in use on AIX vs. Mac OS X vs. Linux,*BSD.
590            # No need to distinguish them here; the caller may distinguish
591            # them based on the OS.
592            # On powerpc64 systems, the C compiler may still be generating
593            # 32-bit code. And on powerpc-ibm-aix systems, the C compiler may
594            # be generating 64-bit code.
595            AC_COMPILE_IFELSE(
596              [AC_LANG_SOURCE(
597                 [[#if defined __powerpc64__ || defined _ARCH_PPC64
598                    int ok;
599                   #else
600                    error fail
601                   #endif
602                 ]])],
603              [gl_cv_host_cpu_c_abi_32bit=no],
604              [gl_cv_host_cpu_c_abi_32bit=yes])
605            ;;
606
607          rs6000 )
608            gl_cv_host_cpu_c_abi_32bit=yes
609            ;;
610
611          riscv32 | riscv64 )
612            # There are 6 ABIs: ilp32, ilp32f, ilp32d, lp64, lp64f, lp64d.
613            # Size of 'long' and 'void *':
614            AC_COMPILE_IFELSE(
615              [AC_LANG_SOURCE(
616                 [[#if defined __LP64__
617                     int ok;
618                   #else
619                     error fail
620                   #endif
621                 ]])],
622              [gl_cv_host_cpu_c_abi_32bit=no],
623              [gl_cv_host_cpu_c_abi_32bit=yes])
624            ;;
625
626          s390* )
627            # On s390x, the C compiler may be generating 64-bit (= s390x) code
628            # or 31-bit (= s390) code.
629            AC_COMPILE_IFELSE(
630              [AC_LANG_SOURCE(
631                 [[#if defined __LP64__ || defined __s390x__
632                     int ok;
633                   #else
634                     error fail
635                   #endif
636                 ]])],
637              [gl_cv_host_cpu_c_abi_32bit=no],
638              [gl_cv_host_cpu_c_abi_32bit=yes])
639            ;;
640
641          sparc | sparc64 )
642            # UltraSPARCs running Linux have `uname -m` = "sparc64", but the
643            # C compiler still generates 32-bit code.
644            AC_COMPILE_IFELSE(
645              [AC_LANG_SOURCE(
646                 [[#if defined __sparcv9 || defined __arch64__
647                    int ok;
648                   #else
649                    error fail
650                   #endif
651                 ]])],
652              [gl_cv_host_cpu_c_abi_32bit=no],
653              [gl_cv_host_cpu_c_abi_32bit=yes])
654            ;;
655
656          *)
657            gl_cv_host_cpu_c_abi_32bit=no
658            ;;
659        esac
660      fi
661     ])
662
663   HOST_CPU_C_ABI_32BIT="$gl_cv_host_cpu_c_abi_32bit"
664 ])