1dnl Copyright (C) 2005-2022 Free Software Foundation, Inc.
2dnl
3dnl This file is part of GCC.
4dnl
5dnl GCC is free software; you can redistribute it and/or modify
6dnl it under the terms of the GNU General Public License as published by
7dnl the Free Software Foundation; either version 3, or (at your option)
8dnl any later version.
9dnl
10dnl GCC is distributed in the hope that it will be useful,
11dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
12dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13dnl GNU General Public License for more details.
14dnl
15dnl You should have received a copy of the GNU General Public License
16dnl along with GCC; see the file COPYING3.  If not see
17dnl <http://www.gnu.org/licenses/>.
18
19dnl See whether we need a declaration for a function.
20dnl The result is highly dependent on the INCLUDES passed in, so make sure
21dnl to use a different cache variable name in this macro if it is invoked
22dnl in a different context somewhere else.
23dnl gcc_AC_CHECK_DECL(SYMBOL,
24dnl       [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
25AC_DEFUN([gcc_AC_CHECK_DECL],
26[AC_MSG_CHECKING([whether $1 is declared])
27AC_CACHE_VAL(gcc_cv_have_decl_$1,
28[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$4],
29[#ifndef $1
30char *(*pfn) = (char *(*)) $1 ;
31#endif])], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
32if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
33  AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
34else
35  AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
36fi
37])dnl
38
39dnl Check multiple functions to see whether each needs a declaration.
40dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
41dnl gcc_AC_CHECK_DECLS(SYMBOLS,
42dnl       [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
43AC_DEFUN([gcc_AC_CHECK_DECLS],
44[AC_FOREACH([gcc_AC_Func], [$1],
45  [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
46  [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
47   define to 0.])])dnl
48for ac_func in $1
49do
50  ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
51gcc_AC_CHECK_DECL($ac_func,
52  [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
53  [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
54dnl It is possible that the include files passed in here are local headers
55dnl which supply a backup declaration for the relevant prototype based on
56dnl the definition of (or lack of) the HAVE_DECL_ macro.  If so, this test
57dnl will always return success.  E.g. see libiberty.h's handling of
58dnl `basename'.  To avoid this, we define the relevant HAVE_DECL_ macro to
59dnl 1 so that any local headers used do not provide their own prototype
60dnl during this test.
61#undef $ac_tr_decl
62#define $ac_tr_decl 1
63  $4
64)
65done
66])
67
68dnl 'make compare' can be significantly faster, if cmp itself can
69dnl skip bytes instead of using tail.  The test being performed is
70dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
71dnl but we need to sink errors and handle broken shells.  We also test
72dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
73dnl accepted by cmp on some systems.
74AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
75[AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
76[ echo abfoo >t1
77  echo cdfoo >t2
78  gcc_cv_prog_cmp_skip=slowcompare
79  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
80    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
81      :
82    else
83      gcc_cv_prog_cmp_skip=gnucompare
84    fi
85  fi
86  if test $gcc_cv_prog_cmp_skip = slowcompare ; then
87    if cmp t1 t2 2 2 > /dev/null 2>&1; then
88      if cmp t1 t2 1 1 > /dev/null 2>&1; then
89        :
90      else
91        gcc_cv_prog_cmp_skip=fastcompare
92      fi
93    fi
94  fi
95  rm t1 t2
96])
97make_compare_target=$gcc_cv_prog_cmp_skip
98AC_SUBST(make_compare_target)
99])
100
101dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
102AC_DEFUN([gcc_AC_PROG_LN_S],
103[AC_MSG_CHECKING(whether ln -s works)
104AC_CACHE_VAL(gcc_cv_prog_LN_S,
105[rm -f conftestdata_t
106echo >conftestdata_f
107if ln -s conftestdata_f conftestdata_t 2>/dev/null
108then
109  gcc_cv_prog_LN_S="ln -s"
110else
111  if ln conftestdata_f conftestdata_t 2>/dev/null
112  then
113    gcc_cv_prog_LN_S=ln
114  else
115    if cp -p conftestdata_f conftestdata_t 2>/dev/null
116    then
117      gcc_cv_prog_LN_S="cp -p"
118    else
119      gcc_cv_prog_LN_S=cp
120    fi
121  fi
122fi
123rm -f conftestdata_f conftestdata_t
124])dnl
125LN_S="$gcc_cv_prog_LN_S"
126if test "$gcc_cv_prog_LN_S" = "ln -s"; then
127  AC_MSG_RESULT(yes)
128else
129  if test "$gcc_cv_prog_LN_S" = "ln"; then
130    AC_MSG_RESULT([no, using ln])
131  else
132    AC_MSG_RESULT([no, and neither does ln, so using $gcc_cv_prog_LN_S])
133  fi
134fi
135AC_SUBST(LN_S)dnl
136])
137
138dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
139dnl of the usual 2.
140AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
141[AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
142[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
143#include <sys/types.h>
144#ifdef HAVE_SYS_STAT_H
145# include <sys/stat.h>
146#endif
147#ifdef HAVE_UNISTD_H
148# include <unistd.h>
149#endif
150#ifdef HAVE_DIRECT_H
151# include <direct.h>
152#endif], [mkdir ("foo", 0);])],
153        gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
154if test $gcc_cv_mkdir_takes_one_arg = yes ; then
155  AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
156fi
157])
158
159AC_DEFUN([gcc_AC_PROG_INSTALL],
160[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
161# Find a good install program.  We prefer a C program (faster),
162# so one script is as good as another.  But avoid the broken or
163# incompatible versions:
164# SysV /etc/install, /usr/sbin/install
165# SunOS /usr/etc/install
166# IRIX /sbin/install
167# AIX /bin/install
168# AFS /usr/afsws/bin/install, which mishandles nonexistent args
169# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
170# ./install, which can be erroneously created by make from ./install.sh.
171AC_MSG_CHECKING(for a BSD compatible install)
172if test -z "$INSTALL"; then
173AC_CACHE_VAL(ac_cv_path_install,
174[  IFS="${IFS=      }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
175  for ac_dir in $PATH; do
176    # Account for people who put trailing slashes in PATH elements.
177    case "$ac_dir/" in
178    /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
179    *)
180      # OSF1 and SCO ODT 3.0 have their own names for install.
181      for ac_prog in ginstall scoinst install; do
182        if test -f $ac_dir/$ac_prog; then
183            if test $ac_prog = install &&
184            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
185              # AIX install.  It has an incompatible calling convention.
186              # OSF/1 installbsd also uses dspmsg, but is usable.
187              :
188            else
189              ac_cv_path_install="$ac_dir/$ac_prog -c"
190              break 2
191            fi
192          fi
193      done
194      ;;
195    esac
196  done
197  IFS="$ac_save_IFS"
198])dnl
199  if test "${ac_cv_path_install+set}" = set; then
200    INSTALL="$ac_cv_path_install"
201  else
202    # As a last resort, use the slow shell script.  We don't cache a
203    # path for INSTALL within a source directory, because that will
204    # break other packages using the cache if that directory is
205    # removed, or if the path is relative.
206    INSTALL="$ac_install_sh"
207  fi
208fi
209dnl We do special magic for INSTALL instead of AC_SUBST, to get
210dnl relative paths right.
211AC_MSG_RESULT($INSTALL)
212AC_SUBST(INSTALL)dnl
213
214# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
215# It thinks the first close brace ends the variable substitution.
216test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
217AC_SUBST(INSTALL_PROGRAM)dnl
218
219test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
220AC_SUBST(INSTALL_DATA)dnl
221])
222
223dnl Determine if enumerated bitfields are unsigned.   ISO C says they can
224dnl be either signed or unsigned.
225dnl
226AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
227[AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
228[AC_RUN_IFELSE([AC_LANG_SOURCE([#include <stdlib.h>
229enum t { BLAH = 128 } ;
230struct s_t { enum t member : 8; } s ;
231int main(void)
232{
233        s.member = BLAH;
234        if (s.member < 0) exit(1);
235        exit(0);
236
237}])], gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
238if test $gcc_cv_enum_bf_unsigned = yes; then
239  AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
240    [Define if enumerated bitfields are treated as unsigned values.])
241fi])
242
243dnl Probe number of bits in a byte.
244dnl Note C89 requires CHAR_BIT >= 8.
245dnl
246AC_DEFUN([gcc_AC_C_CHAR_BIT],
247[AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
248[AC_EGREP_CPP(found,
249[#ifdef HAVE_LIMITS_H
250#include <limits.h>
251#endif
252#ifdef CHAR_BIT
253found
254#endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
255])
256if test $gcc_cv_decl_char_bit = no; then
257  AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
258[i=8
259 gcc_cv_c_nbby=
260 while test $i -lt 65; do
261   AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,
262     [switch(0) {
263  case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
264  case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
265  ; }])],
266     [gcc_cv_c_nbby=$i; break])
267   i=`expr $i + 1`
268 done
269 test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
270])
271if test $gcc_cv_c_nbby = failed; then
272  AC_MSG_ERROR(cannot determine number of bits in a byte)
273else
274  AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
275  [Define as the number of bits in a byte, if `limits.h' doesn't.])
276fi
277fi])
278
279AC_DEFUN([gcc_AC_INITFINI_ARRAY],
280[AC_ARG_ENABLE(initfini-array,
281          [  --enable-initfini-array    use .init_array/.fini_array sections],
282          [], [
283AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
284                     gcc_cv_initfini_array, [dnl
285  if test "x${build}" = "x${target}" && test "x${build}" = "x${host}"; then
286    case "${target}" in
287      ia64-*)
288          AC_RUN_IFELSE([AC_LANG_SOURCE([
289#ifndef __ELF__
290#error Not an ELF OS
291#endif
292/* We turn on .preinit_array/.init_array/.fini_array support for ia64
293   if it can be used.  */
294static int x = -1;
295int main (void) { return x; }
296int foo (void) { x = 0; }
297int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;
298])],
299               [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
300               [gcc_cv_initfini_array=no]);;
301      *)
302          gcc_cv_initfini_array=no
303          if test $in_tree_ld = yes ; then
304            if test "$gcc_cv_gld_major_version" -eq 2 \
305               -a "$gcc_cv_gld_minor_version" -ge 22 \
306               -o "$gcc_cv_gld_major_version" -gt 2 \
307               && test $in_tree_ld_is_elf = yes; then
308              gcc_cv_initfini_array=yes
309            fi
310          elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
311            case $target:$gas in
312              *:yes)
313                sh_flags='"a"'
314                sh_type='%progbits'
315                ;;
316              i?86-*-solaris2*:no | x86_64-*-solaris2*:no)
317                sh_flags='"a"'
318                sh_type='@progbits'
319                ;;
320              sparc*-*-solaris2*:no)
321                sh_flags='#alloc'
322                sh_type='#progbits'
323                sh_quote='"'
324                ;;
325            esac
326            case "$target:$gnu_ld" in
327              *:yes)
328                cat > conftest.s <<EOF
329.section .dtors,$sh_flags,$sh_type
330.balign 4
331.byte 'A', 'A', 'A', 'A'
332.section .ctors,$sh_flags,$sh_type
333.balign 4
334.byte 'B', 'B', 'B', 'B'
335.section .fini_array.65530,$sh_flags,$sh_type
336.balign 4
337.byte 'C', 'C', 'C', 'C'
338.section .init_array.65530,$sh_flags,$sh_type
339.balign 4
340.byte 'D', 'D', 'D', 'D'
341.section .dtors.64528,$sh_flags,$sh_type
342.balign 4
343.byte 'E', 'E', 'E', 'E'
344.section .ctors.64528,$sh_flags,$sh_type
345.balign 4
346.byte 'F', 'F', 'F', 'F'
347.section .fini_array.01005,$sh_flags,$sh_type
348.balign 4
349.byte 'G', 'G', 'G', 'G'
350.section .init_array.01005,$sh_flags,$sh_type
351.balign 4
352.byte 'H', 'H', 'H', 'H'
353.text
354.globl _start
355_start:
356EOF
357                if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
358                   && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
359                   && $gcc_cv_objdump -s -j .init_array conftest \
360                        | grep HHHHFFFFDDDDBBBB > /dev/null 2>&1 \
361                   && $gcc_cv_objdump -s -j .fini_array conftest \
362                        | grep GGGGEEEECCCCAAAA > /dev/null 2>&1; then
363                  gcc_cv_initfini_array=yes
364                fi
365                ;;
366              *-*-solaris2*:no)
367                # When Solaris ld added constructor priority support, it was
368                # decided to only handle .init_array.N/.fini_array.N since
369                # there was no need for backwards compatibility with
370                # .ctors.N/.dtors.N.  .ctors/.dtors remain as separate
371                # sections with correct execution order resp. to
372                # .init_array/.fini_array, while gld merges them into
373                # .init_array/.fini_array.
374                cat > conftest.s <<EOF
375.section $sh_quote.fini_array.65530$sh_quote,$sh_flags,$sh_type
376.align 4
377.byte 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C'
378.section $sh_quote.init_array.65530$sh_quote,$sh_flags,$sh_type
379.align 4
380.byte 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D'
381.section $sh_quote.fini_array.01005$sh_quote,$sh_flags,$sh_type
382.align 4
383.byte 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G'
384.section $sh_quote.init_array.01005$sh_quote,$sh_flags,$sh_type
385.align 4
386.byte 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'
387.text
388.globl _start
389_start:
390EOF
391                if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
392                   && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
393                   && $gcc_cv_objdump -s -j .init_array conftest \
394                        | grep HHHHHHHHDDDDDDDD > /dev/null 2>&1 \
395                   && $gcc_cv_objdump -s -j .fini_array conftest \
396                        | grep GGGGGGGGCCCCCCCC > /dev/null 2>&1; then
397                  gcc_cv_initfini_array=yes
398                fi
399                ;;
400              esac
401changequote(,)dnl
402            rm -f conftest conftest.*
403changequote([,])dnl
404          fi
405          AC_PREPROC_IFELSE([AC_LANG_SOURCE([
406#ifndef __ELF__
407# error Not an ELF OS
408#endif
409#include <stdlib.h>
410#if defined __GLIBC_PREREQ
411# if __GLIBC_PREREQ (2, 4)
412# else
413#  error GLIBC 2.4 required
414# endif
415#else
416# if defined __sun__ && defined __svr4__
417   /* Solaris ld.so.1 supports .init_array/.fini_array since Solaris 8.  */
418# else
419#  error The C library not known to support .init_array/.fini_array
420# endif
421#endif
422])],, [gcc_cv_initfini_array=no]);;
423    esac
424  else
425    case "${target}" in
426      aarch64*-linux-gnu*)
427          # AArch64 postdates glibc support for .init_array/.fini_array,
428          # so we don't need the preprocessor test above.
429          gcc_cv_initfini_array=yes
430          ;;
431
432      *)
433          AC_MSG_CHECKING(cross compile... guessing)
434          gcc_cv_initfini_array=no
435          ;;
436    esac
437  fi])
438  enable_initfini_array=$gcc_cv_initfini_array
439])
440AC_DEFINE_UNQUOTED(HAVE_INITFINI_ARRAY_SUPPORT,
441  [`if test $enable_initfini_array = yes; then echo 1; else echo 0; fi`],
442  [Define 0/1 if .init_array/.fini_array sections are available and working.])
443])
444
445dnl # gcc_GAS_FLAGS
446dnl # Used by gcc_GAS_CHECK_FEATURE
447dnl #
448AC_DEFUN([gcc_GAS_FLAGS],
449[AC_CACHE_CHECK([assembler flags], gcc_cv_as_flags,
450[ case "$target" in
451  i[[34567]]86-*-linux*)
452    dnl Override the default, which may be incompatible.
453    gcc_cv_as_flags=--32
454    ;;
455  x86_64-*-linux-gnux32)
456    dnl Override the default, which may be incompatible.
457    gcc_cv_as_flags=--x32
458    ;;
459  x86_64-*-linux*)
460    dnl Override the default, which may be incompatible.
461    gcc_cv_as_flags=--64
462    ;;
463  powerpc*-*-darwin*)
464    dnl Always pass -arch ppc to assembler.
465    gcc_cv_as_flags="-arch ppc"
466    ;;
467  *)
468    gcc_cv_as_flags=" "
469    ;;
470  esac])
471])
472
473dnl gcc_GAS_CHECK_FEATURE(description, cv,
474dnl [extra switches to as], [assembler input],
475dnl [extra testing logic], [command if feature available])
476dnl
477dnl Checks for an assembler feature.
478dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
479dnl if assembly succeeds.  If EXTRA TESTING LOGIC is not the empty string,
480dnl then it is run instead of simply setting CV to "yes" - it is responsible
481dnl for doing so, if appropriate.
482AC_DEFUN([gcc_GAS_CHECK_FEATURE],
483[AC_REQUIRE([gcc_GAS_FLAGS])dnl
484AC_CACHE_CHECK([assembler for $1], [$2],
485 [[$2]=no
486  if test x$gcc_cv_as != x; then
487    AS_ECHO([ifelse(m4_substr([$4],0,1),[$], "[$4]", '[$4]')]) > conftest.s
488    if AC_TRY_COMMAND([$gcc_cv_as $gcc_cv_as_flags $3 -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD])
489    then
490          ifelse([$5],, [$2]=yes, [$5])
491    else
492      echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
493      cat conftest.s >&AS_MESSAGE_LOG_FD
494    fi
495    rm -f conftest.o conftest.s
496  fi])
497ifelse([$6],,,[dnl
498if test $[$2] = yes; then
499  $6
500fi])
501ifelse([$7],,,[dnl
502if test $[$2] != yes; then
503  $7
504fi])])
505
506dnl GCC_TARGET_TEMPLATE(KEY)
507dnl ------------------------
508dnl Define KEY as a valid configure key on the target machine.
509
510m4_define([GCC_TARGET_TEMPLATE],
511[m4_define([GCC_TARGET_TEMPLATE($1)],[])])
512
513dnl AH_TEMPLATE(KEY, DESCRIPTION)
514dnl -----------------------------
515dnl Issue an autoheader template for KEY, i.e., a comment composed of
516dnl DESCRIPTION (properly wrapped), and then #undef KEY.  Redefinition
517dnl of the macro in autoheader.m4, to support definition of only a few
518dnl keys while compiling target libraries.
519
520m4_define([AH_TEMPLATE],
521[AH_VERBATIM([$1],m4_text_wrap([$2 */], [   ], [/* ])
522m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[#ifndef USED_FOR_TARGET
523])[#undef $1]m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[
524#endif
525]))])
526
527dnl Make sure that build_exeext is looked for
528AC_DEFUN([gcc_AC_BUILD_EXEEXT], [
529ac_executable_extensions="$build_exeext"])
530
531dnl GCC_GLIBC_VERSION_GTE_IFELSE(MAJOR, MINOR, IF-TRUE, IF-FALSE)
532dnl -------------------------------------------------------------
533dnl If the target glibc version ($glibc_version_major.$glibc_version_minor)
534dnl is at least MAJOR.MINOR, call IF-TRUE, otherwise call IF-FALSE.
535AC_DEFUN([GCC_GLIBC_VERSION_GTE_IFELSE],
536[
537AS_IF([test $glibc_version_major -gt $1 \
538  || ( test $glibc_version_major -eq $1 && test $glibc_version_minor -ge $2 )],
539[$3], [$4])])
540