OpenMP: Update documentation of metadirective implementation status.
[gcc.git] / gcc / configure.ac
blob8fab93c9365496062583c5bd8ace402c8a797817
1 # configure.ac for GCC
2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2025 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
11 #version.
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 #for more details.
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3.  If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
26 AC_INIT
27 AC_CONFIG_SRCDIR(tree.cc)
28 AC_CONFIG_MACRO_DIRS([../config] [..])
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
34 AC_CANONICAL_BUILD
35 AC_CANONICAL_HOST
36 AC_CANONICAL_TARGET
38 # Determine the noncanonical host name, for Ada.
39 ACX_NONCANONICAL_HOST
41 # Determine the noncanonical target name, for directory use.
42 ACX_NONCANONICAL_TARGET
44 # Used for constructing correct paths for offload compilers.
45 real_target_noncanonical=${target_noncanonical}
46 accel_dir_suffix=
48 # Determine the target- and build-specific subdirectories
49 GCC_TOPLEV_SUBDIRS
51 # Set program_transform_name
52 AC_ARG_PROGRAM
54 # Check for bogus environment variables.
55 # Test if LIBRARY_PATH contains the notation for the current directory
56 # since this would lead to problems installing/building glibc.
57 # LIBRARY_PATH contains the current directory if one of the following
58 # is true:
59 # - one of the terminals (":" and ";") is the first or last sign
60 # - two terminals occur directly after each other
61 # - the path contains an element with a dot in it
62 AC_MSG_CHECKING(LIBRARY_PATH variable)
63 changequote(,)dnl
64 case ${LIBRARY_PATH} in
65   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
66     library_path_setting="contains current directory"
67     ;;
68   *)
69     library_path_setting="ok"
70     ;;
71 esac
72 changequote([,])dnl
73 AC_MSG_RESULT($library_path_setting)
74 if test "$library_path_setting" != "ok"; then
75 AC_MSG_ERROR([
76 *** LIBRARY_PATH shouldn't contain the current directory when
77 *** building gcc. Please change the environment variable
78 *** and run configure again.])
81 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
82 # since this would lead to problems installing/building glibc.
83 # GCC_EXEC_PREFIX contains the current directory if one of the following
84 # is true:
85 # - one of the terminals (":" and ";") is the first or last sign
86 # - two terminals occur directly after each other
87 # - the path contains an element with a dot in it
88 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
89 changequote(,)dnl
90 case ${GCC_EXEC_PREFIX} in
91   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
92     gcc_exec_prefix_setting="contains current directory"
93     ;;
94   *)
95     gcc_exec_prefix_setting="ok"
96     ;;
97 esac
98 changequote([,])dnl
99 AC_MSG_RESULT($gcc_exec_prefix_setting)
100 if test "$gcc_exec_prefix_setting" != "ok"; then
101 AC_MSG_ERROR([
102 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
103 *** building gcc. Please change the environment variable
104 *** and run configure again.])
107 # -----------
108 # Directories
109 # -----------
111 # Specify the local prefix
112 local_prefix=
113 AC_ARG_WITH(local-prefix,
114 [AS_HELP_STRING([--with-local-prefix=DIR],
115                 [specifies directory to put local include])],
116 [case "${withval}" in
117 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
118 no)     ;;
119 *)      local_prefix=$with_local_prefix ;;
120 esac])
122 # Default local prefix if it is empty
123 if test x$local_prefix = x; then
124         local_prefix=/usr/local
127 AC_ARG_WITH([native-system-header-dir],
128   [  --with-native-system-header-dir=dir
129                           use dir as the directory to look for standard
130                           system header files in.  Defaults to /usr/include.],
132  case ${with_native_system_header_dir} in
133  yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
134  /* | [[A-Za-z]]:[[\\/]]*) ;;
135  *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
136  esac
137  configured_native_system_header_dir="${withval}"
138 ], [configured_native_system_header_dir=])
140 AC_ARG_WITH(build-sysroot, 
141   [AS_HELP_STRING([--with-build-sysroot=sysroot],
142                   [use sysroot as the system root during the build])],
143   [if test x"$withval" != x ; then
144      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
145    fi],
146   [SYSROOT_CFLAGS_FOR_TARGET=])
147 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
149 if test "x$prefix" = xNONE; then
150  test_prefix=/usr/local
151 else
152  test_prefix=$prefix
154 if test "x$exec_prefix" = xNONE; then
155  test_exec_prefix=$test_prefix
156 else
157  test_exec_prefix=$exec_prefix
160 AC_ARG_WITH(sysroot,
161 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
162                 [search for usr/lib, usr/include, et al, within DIR])],
164  case ${with_sysroot} in
165  /) ;;
166  */) with_sysroot=`echo $with_sysroot | sed 's,/$,,'` ;;
167  esac
168  case ${with_sysroot} in
169  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
170  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
171  esac
172    
173  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
174  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
175         
176  case ${TARGET_SYSTEM_ROOT} in
177  "${test_prefix}"|"${test_prefix}/"*|\
178  "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
179  '${prefix}'|'${prefix}/'*|\
180  '${exec_prefix}'|'${exec_prefix}/'*)
181    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
182    TARGET_SYSTEM_ROOT_DEFINE="$t"
183    ;;
184  esac
185 ], [
186  TARGET_SYSTEM_ROOT=
187  TARGET_SYSTEM_ROOT_DEFINE=
188  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
190 AC_SUBST(TARGET_SYSTEM_ROOT)
191 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
192 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
194 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
195 # passed in by the toplevel make and thus we'd get different behavior
196 # depending on where we built the sources.
197 gcc_gxx_include_dir=
198 # Specify the g++ header file directory
199 AC_ARG_WITH(gxx-include-dir,
200 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
201                 [specifies directory to put g++ header files])],
202 [case "${withval}" in
203 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
204 no)     ;;
205 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
206 esac])
208 # If both --with-sysroot and --with-gxx-include-dir are passed, we interpolate
209 # the former in the latter and, upon success, compute gcc_gxx_include_dir as
210 # relative to the sysroot.
211 gcc_gxx_include_dir_add_sysroot=0
213 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
214 if test x${gcc_gxx_include_dir} = x; then
215   if test x${enable_version_specific_runtime_libs} = xyes; then
216     gcc_gxx_include_dir='${libsubdir}/include/c++'
217   else
218     libstdcxx_incdir='include/c++/$(version)'
219     if test x$host != x$target; then
220        libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
221     fi
222     gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
223   fi
224 elif test "${with_sysroot+set}" = set; then
225   gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
226   if test "${gcc_gxx_without_sysroot}"; then
227     gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
228     gcc_gxx_include_dir_add_sysroot=1
229   fi
232 # Configuration for an alternate set of C++ headers.
233 gcc_gxx_libcxx_include_dir=
234 # Specify the alternate g++ header file directory
235 AC_ARG_WITH(gxx-libcxx-include-dir,
236 [AS_HELP_STRING([--with-gxx-libcxx-include-dir=DIR],
237                 [specifies directory to find libc++ header files])],
238 [case "${withval}" in
239 yes)    AC_MSG_ERROR(bad value ${withval} given for libc++ include directory) ;;
240 *)      gcc_gxx_libcxx_include_dir=$with_gxx_libcxx_include_dir ;;
241 esac])
243 # --with-gxx-libcxx-include-dir controls the enabling of the -stdlib option.
244 # if --with-gxx-libcxx-include-dir is 'no' we disable the stdlib option.
245 # if --with-gxx-libcxx-include-dir is unset we enable the stdlib option
246 # based on the platform (to be available on platform versions where it is the
247 # default for the system tools). We also use a default path within the compiler
248 # install tree.
249 # Otherwise, we use the path provided and enable the stdlib option.
250 # If both --with-sysroot and --with-gxx-libcxx-include-dir are passed, we
251 # check to see if the latter starts with the former and, upon success, compute
252 # gcc_gxx_libcxx_include_dir as relative to the sysroot.
253 gcc_gxx_libcxx_include_dir_add_sysroot=0
254 gcc_enable_stdlib_opt=0
255 if test x${gcc_gxx_libcxx_include_dir} != x; then
256   if test x${gcc_gxx_libcxx_include_dir} = xno; then
257     # set defaults for the dir, but the option is disabled anyway.
258     gcc_gxx_libcxx_include_dir=
259   else
260     gcc_enable_stdlib_opt=1
261   fi
262 else
263   case $target in
264     *-darwin1[[1-9]]* | *-darwin2*)
265        # Default this on for Darwin versions which default to libcxx,
266        # and embed the path in the compiler install so that we get a
267        # self-contained toolchain.
268        gcc_enable_stdlib_opt=1
269        ;;
270     *) ;;
271   esac
273 AC_DEFINE_UNQUOTED(ENABLE_STDLIB_OPTION, $gcc_enable_stdlib_opt,
274           [Define if the -stdlib= option should be enabled.])
276 # Sysroot behaviour as for gxx-include-dir
277 if test x${gcc_gxx_libcxx_include_dir} = x; then
278   # default path,embedded in the compiler tree.
279   libcxx_incdir='include/c++/v1'
280   if test x${enable_version_specific_runtime_libs} = xyes; then
281     gcc_gxx_libcxx_include_dir='${libsubdir}/$libcxx_incdir'
282   else
283     if test x$host != x$target; then
284        libcxx_incdir="$target_alias/$libcxx_incdir"
285     fi
286     gcc_gxx_libcxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libcxx_incdir"
287   fi
288 elif test "${with_sysroot+set}" = set; then
289   gcc_gxx_libcxx_without_sysroot=`expr "${gcc_gxx_libcxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
290   if test "${gcc_gxx_libcxx_without_sysroot}"; then
291     gcc_gxx_libcxx_include_dir="${gcc_gxx_libcxx_without_sysroot}"
292     gcc_gxx_libcxx_include_dir_add_sysroot=1
293   fi
296 AC_ARG_WITH(cpp_install_dir,
297 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
298                 [install the user visible C preprocessor in DIR
299                  (relative to PREFIX) as well as PREFIX/bin])],
300 [if test x$withval = xyes; then
301   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
302 elif test x$withval != xno; then
303   cpp_install_dir=$withval
304 fi])
306 # We would like to our source tree to be readonly.  However when releases or
307 # pre-releases are generated, the flex/bison generated files as well as the 
308 # various formats of manuals need to be included along with the rest of the
309 # sources.  Therefore we have --enable-generated-files-in-srcdir to do 
310 # just that.
312 AC_MSG_CHECKING([whether to place generated files in the source directory])
313   dnl generated-files-in-srcdir is disabled by default
314   AC_ARG_ENABLE(generated-files-in-srcdir, 
315     [AS_HELP_STRING([--enable-generated-files-in-srcdir],
316                     [put copies of generated files in source dir
317                      intended for creating source tarballs for users
318                      without texinfo bison or flex])],
319       generated_files_in_srcdir=$enableval,
320       generated_files_in_srcdir=no)
322 AC_MSG_RESULT($generated_files_in_srcdir)
324 if test "$generated_files_in_srcdir" = "yes"; then
325   GENINSRC=''
326 else
327   GENINSRC='#'
329 AC_SUBST(GENINSRC)
331 # -------------------
332 # Find default linker
333 # -------------------
335 # With GNU ld
336 AC_ARG_WITH(gnu-ld,
337 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
338 gnu_ld_flag="$with_gnu_ld",
339 gnu_ld_flag=no)
341 case $target in
342     *darwin*)
343         ld64_flag=yes # Darwin can only use a ld64-compatible linker.
344         dsymutil_flag=yes # Darwin uses dsymutil to link debug.
345         ;;
346     *)
347         ld64_flag=no
348         dsymutil_flag=no
349         ;;
350 esac
352 # With pre-defined ld
353 AC_ARG_WITH(ld,
354 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
355 DEFAULT_LINKER="$with_ld")
356 if test x"${DEFAULT_LINKER+set}" = x"set"; then
357   if test ! -x "$DEFAULT_LINKER"; then
358     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
359   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
360     gnu_ld_flag=yes
361   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep ld64- > /dev/null; then
362     ld64_flag=yes
363   fi
364   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
365         [Define to enable the use of a default linker.])
368 AC_MSG_CHECKING([whether a default linker was specified])
369 if test x"${DEFAULT_LINKER+set}" = x"set"; then
370   if test x"$gnu_ld_flag" = x"no"; then
371     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
372   else
373     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
374   fi
375 else
376   AC_MSG_RESULT(no)
379 # With demangler in GNU ld
380 AC_ARG_WITH(demangler-in-ld,
381 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
382 demangler_in_ld="$with_demangler_in_ld",
383 demangler_in_ld=yes)
385 # Allow the user to specify a dsymutil executable (used on Darwin only, so far)
386 AC_ARG_WITH(dsymutil,
387 [AS_HELP_STRING([--with-dsymutil], [arrange to use the specified dsymutil (full pathname)])],
388 DEFAULT_DSYMUTIL="$with_dsymutil")
390 dsymutil_vers=
391 if test x"${DEFAULT_DSYMUTIL+set}" = x"set"; then
392   if test ! -x "$DEFAULT_DSYMUTIL"; then
393     AC_MSG_ERROR([cannot execute: $DEFAULT_DSYMUTIL: check --with-dsymutil or env. var. DEFAULT_DSYMUTIL])
394   else
395     if dsymutil_vers=`$DEFAULT_DSYMUTIL -v /dev/null 2>&1`; then
396       dsymutil_flag=yes
397     fi
398   fi
399   AC_DEFINE_UNQUOTED(DEFAULT_DSYMUTIL,"$DEFAULT_DSYMUTIL",
400         [Define to enable the use of a default debug linker.])
403 AC_MSG_CHECKING([whether a default dsymutil was specified])
404 if test x"${DEFAULT_DSYMUTIL+set}" = x"set"; then
405   AC_MSG_RESULT([yes ($DEFAULT_DSYMUTIL)])
406 else
407   AC_MSG_RESULT(no)
410 # ----------------------
411 # Find default assembler
412 # ----------------------
414 # With GNU as
415 AC_ARG_WITH(gnu-as,
416 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
417 gas_flag="$with_gnu_as",
418 gas_flag=no)
420 AC_ARG_WITH(as,
421 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
422 DEFAULT_ASSEMBLER="$with_as")
423 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
424   if test ! -x "$DEFAULT_ASSEMBLER"; then
425     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
426   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
427     gas_flag=yes
428   fi
429   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
430         [Define to enable the use of a default assembler.])
433 AC_MSG_CHECKING([whether a default assembler was specified])
434 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
435   if test x"$gas_flag" = x"no"; then
436     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
437   else
438     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
439   fi
440 else
441   AC_MSG_RESULT(no)
444 # ---------------
445 # Find C compiler
446 # ---------------
448 # If a non-executable a.out is present (e.g. created by GNU as above even if
449 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
450 # file, even when creating an executable, so an execution test fails.
451 # Remove possible default executable files to avoid this.
453 # FIXME: This really belongs into AC_PROG_CC and can be removed once
454 # Autoconf includes it.
455 rm -f a.out a.exe b.out
457 # Find the native compiler
458 AC_PROG_CC
459 AC_PROG_CXX
460 ACX_PROG_GNAT([-I"$srcdir"/ada/libgnat])
461 ACX_PROG_GDC([-I"$srcdir"/d])
463 # Do configure tests with the C++ compiler, since that's what we build with.
464 AC_LANG(C++)
466 # Remove all -O flags: for historical reasons, unless bootstrapping we prefer
467 # optimizations to be activated explicitly by the toplevel.
468 case "$CC" in
469   */prev-gcc/xgcc*) ;;
470   *)
471     new_CFLAGS=
472     for flag in $CFLAGS; do
473       case $flag in
474         -O*) ;;
475         *) new_CFLAGS="$new_CFLAGS $flag" ;;
476       esac
477     done
478     CFLAGS=$new_CFLAGS
479     new_CXXFLAGS=
480     for flag in $CXXFLAGS; do
481       case $flag in
482         -O*) ;;
483         *) new_CXXFLAGS="$new_CXXFLAGS $flag" ;;
484       esac
485     done
486     CXXFLAGS=$new_CXXFLAGS
487     ;;
488 esac
489 AC_SUBST(CFLAGS)
490 AC_SUBST(CXXFLAGS)
491 AC_SUBST(GDCFLAGS)
493 # Determine PICFLAG for target gnatlib.
494 GCC_PICFLAG_FOR_TARGET
495 AC_SUBST(PICFLAG_FOR_TARGET)
497 # -------------------------
498 # Check C compiler features
499 # -------------------------
501 AC_USE_SYSTEM_EXTENSIONS
503 AC_PROG_CPP
504 AC_C_INLINE
506 AC_SYS_LARGEFILE
507 AC_CHECK_SIZEOF(ino_t)
508 AC_CHECK_SIZEOF(dev_t)
510 # Select the right stat being able to handle 64bit inodes, if needed.
511 if test "$enable_largefile" != no; then
512   case "$host, $build" in
513     *-*-aix*,*|*,*-*-aix*)
514       if test "$ac_cv_sizeof_ino_t" = "4" -a "$ac_cv_sizeof_dev_t" = 4; then
515         AC_DEFINE(HOST_STAT_FOR_64BIT_INODES, stat64x,
516           [Define which stat syscall is able to handle 64bit indodes.])
517       fi;;
518   esac
522 # sizeof(char) is 1 by definition.
523 AC_CHECK_SIZEOF(void *)
524 AC_CHECK_SIZEOF(short)
525 AC_CHECK_SIZEOF(int)
526 AC_CHECK_SIZEOF(long)
527 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
528 GCC_STDINT_TYPES
529 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
530   AC_MSG_ERROR([uint64_t or int64_t not found])
533 # check what underlying integer type int64_t uses
534 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
535 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
536 #ifdef HAVE_STDINT_H
537 #include <stdint.h>
538 #endif
539 template <typename T> struct X { };
540 template <>
541 struct X<long> { typedef long t; };
542 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
543 if test "$ac_cv_int64_t_type" = "long"; then
544   AC_DEFINE(INT64_T_IS_LONG, 1,
545   [Define if int64_t uses long as underlying type.])
546 else
547 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
548 #ifdef HAVE_STDINT_H
549 #include <stdint.h>
550 #endif
551 template <typename T> struct X { };
552 template <>
553 struct X<long long> { typedef long long t; };
554 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
557 AC_CACHE_CHECK(for std::swap in <utility>, ac_cv_std_swap_in_utility, [
558 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
559 #include <utility>
560 ]], [[int a, b; std::swap(a,b);]])],[ac_cv_std_swap_in_utility=yes],[ac_cv_std_swap_in_utility=no])])
561 if test $ac_cv_std_swap_in_utility = yes; then
562   AC_DEFINE(HAVE_SWAP_IN_UTILITY, 1,
563   [Define if <utility> defines std::swap.])
566 # Check whether compiler is affected by placement new aliasing bug (PR 29286).
567 # If the host compiler is affected by the bug, and we build with optimization
568 # enabled (which happens e.g. when cross-compiling), the pool allocator may
569 # get miscompiled.  Use -fno-strict-aliasing to work around this problem.
570 # Since there is no reliable feature check for the presence of this bug,
571 # we simply use a GCC version number check.  (This should never trigger for
572 # stages 2 or 3 of a native bootstrap.)
573 aliasing_flags=
574 if test "$GCC" = yes; then
575   saved_CXXFLAGS="$CXXFLAGS"
577   # The following test compilation will succeed if and only if $CXX accepts
578   # -fno-strict-aliasing *and* is older than GCC 4.3.
579   CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
580   AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug])
581   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
582 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
583 #error compiler not affected by placement new aliasing bug
584 #endif
585 ])],
586     [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'],
587     [AC_MSG_RESULT([no])])
589   CXXFLAGS="$saved_CXXFLAGS"
591 AC_SUBST(aliasing_flags)
595 # ---------------------
596 # Warnings and checking
597 # ---------------------
599 # Check $CC warning features (if it's GCC).
600 # We want to use -pedantic, but we don't want warnings about
601 # * 'long long'
602 # * variadic macros
603 # * overlong strings
604 # So, we only use -pedantic if we can disable those warnings.
606 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
607 AC_ARG_ENABLE(build-format-warnings,
608   AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
609   [],[enable_build_format_warnings=yes])
610 AS_IF([test $enable_build_format_warnings = no],
611       [wf_opt=-Wno-format],[wf_opt=])
612 ACX_PROG_CXX_WARNING_OPTS(
613         m4_quote(m4_do([-W -Wall -Wno-error=narrowing -Wwrite-strings ],
614                        [-Wcast-qual $wf_opt])),
615                        [loose_warn])
616 ACX_PROG_CC_WARNING_OPTS(
617         m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes ],
618                        [])), [c_loose_warn])
619 ACX_PROG_CXX_WARNING_OPTS(
620         m4_quote(m4_do([-Wmissing-format-attribute ], [-Wconditionally-supported ],
621                        [-Woverloaded-virtual])), [strict_warn])
622 ACX_PROG_CC_WARNING_OPTS(
623         m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
624 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
625         m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ], 
626                        [-Wno-overlength-strings])), [strict_warn])
627 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
629 # The above macros do nothing if the compiler is not GCC.  However, the
630 # Makefile has more goo to add other flags, so these variables are used
631 # to enable warnings only for GCC.
632 warn_cflags=
633 warn_cxxflags=
634 if test "x$GCC" = "xyes"; then
635   warn_cflags='$(GCC_WARN_CFLAGS)'
636   warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
638 AC_SUBST(warn_cflags)
639 AC_SUBST(warn_cxxflags)
641 # Disable exceptions and RTTI if building with g++
642 ACX_PROG_CC_WARNING_OPTS(
643         m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
644                        [noexception_flags])
645         
646 # Enable expensive internal checks
647 is_release=
648 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
649   is_release=yes
652 AC_ARG_ENABLE(checking,
653 [AS_HELP_STRING([[--enable-checking[=LIST]]],
654                 [enable expensive run-time checks.  With LIST,
655                  enable only specific categories of checks.
656                  Categories are: yes,no,all,none,release.
657                  Flags are: assert,df,extra,fold,gc,gcac,gimple,misc,
658                  rtlflag,rtl,runtime,tree,valgrind,types])],
659 [ac_checking_flags="${enableval}"],[
660 # Determine the default checks.
661 if test x$is_release = x ; then
662   ac_checking_flags=yes,extra
663 else
664   ac_checking_flags=release
665 fi])
666 IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
667 for check in release $ac_checking_flags
669         case $check in
670         # these set all the flags to specific states
671         yes)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
672                         ac_fold_checking= ; ac_gc_checking=1 ; ac_extra_checking= ;
673                         ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
674                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
675                         ac_tree_checking=1 ; ac_valgrind_checking= ;
676                         ac_types_checking=1 ;;
677         no|none)        ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
678                         ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
679                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
680                         ac_rtlflag_checking= ; ac_runtime_checking= ;
681                         ac_tree_checking= ; ac_valgrind_checking= ;
682                         ac_types_checking= ;;
683         all)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
684                         ac_fold_checking=1 ; ac_gc_checking=1 ; ac_extra_checking=1 ;
685                         ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
686                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
687                         ac_tree_checking=1 ; ac_valgrind_checking= ;
688                         ac_types_checking=1 ;;
689         release)        ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
690                         ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
691                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
692                         ac_rtlflag_checking= ; ac_runtime_checking=1 ;
693                         ac_tree_checking= ; ac_valgrind_checking= ;
694                         ac_types_checking= ;;
695         # these enable particular checks
696         assert)         ac_assert_checking=1 ;;
697         df)             ac_df_checking=1 ;;
698         extra)          ac_extra_checking=1 ;;
699         fold)           ac_fold_checking=1 ;;
700         gc)             ac_gc_checking=1 ;;
701         gcac)           ac_gc_always_collect=1 ;;
702         gimple)         ac_gimple_checking=1 ;;
703         misc)           ac_checking=1 ;;
704         rtl)            ac_rtl_checking=1 ;;
705         rtlflag)        ac_rtlflag_checking=1 ;;
706         runtime)        ac_runtime_checking=1 ;;
707         tree)           ac_tree_checking=1 ;;
708         types)          ac_types_checking=1 ;;
709         valgrind)       ac_valgrind_checking=1 ;;
710         *)      AC_MSG_ERROR(unknown check category $check) ;;
711         esac
712 done
713 IFS="$ac_save_IFS"
715 if test x$ac_checking != x ; then
716   AC_DEFINE(CHECKING_P, 1,
717 [Define to 0/1 if you want more run-time sanity checks.  This one gets a grab
718 bag of miscellaneous but relatively cheap checks.])
719 else
720   AC_DEFINE(CHECKING_P, 0)
722 if test x$ac_extra_checking != x ; then
723   AC_DEFINE(ENABLE_EXTRA_CHECKING, 1,
724 [Define to 0/1 if you want extra run-time checking that might affect code
725 generation.])
726 else
727   AC_DEFINE(ENABLE_EXTRA_CHECKING, 0)
729 if test x$ac_df_checking != x ; then
730   AC_DEFINE(ENABLE_DF_CHECKING, 1,
731 [Define if you want more run-time sanity checks for dataflow.])
733 if test x$ac_assert_checking != x ; then
734   AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
735 [Define if you want assertions enabled.  This is a cheap check.])
737 if test x$ac_gimple_checking != x ; then
738   AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
739 [Define if you want operations on GIMPLE (the basic data structure of
740 the high-level optimizers) to be checked for dynamic type safety at
741 runtime.  This is moderately expensive.])
743 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
744 if test x$ac_runtime_checking != x ; then
745   AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
746 [Define if you want runtime assertions enabled.  This is a cheap check.])
748 if test x$ac_tree_checking != x ; then
749   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
750 [Define if you want all operations on trees (the basic data
751    structure of the front ends) to be checked for dynamic type safety
752    at runtime.  This is moderately expensive.
753    ])
754   TREECHECKING=yes
756 if test x$ac_types_checking != x ; then
757   AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
758 [Define if you want all gimple types to be verified after gimplifiation.
759    This is cheap.
760    ])
762 AC_SUBST(TREECHECKING)
763 if test x$ac_rtl_checking != x ; then
764   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
765 [Define if you want all operations on RTL (the basic data structure
766    of the optimizer and back end) to be checked for dynamic type safety
767    at runtime.  This is quite expensive.])
769 if test x$ac_rtlflag_checking != x ; then
770   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
771 [Define if you want RTL flag accesses to be checked against the RTL
772    codes that are supported for each access macro.  This is relatively
773    cheap.])
775 if test x$ac_gc_checking != x ; then
776   AC_DEFINE(ENABLE_GC_CHECKING, 1,
777 [Define if you want the garbage collector to do object poisoning and
778    other memory allocation checks.  This is quite expensive.])
780 if test x$ac_gc_always_collect != x ; then
781   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
782 [Define if you want the garbage collector to operate in maximally
783    paranoid mode, validating the entire heap and collecting garbage at
784    every opportunity.  This is extremely expensive.])
786 if test x$ac_fold_checking != x ; then
787   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
788 [Define if you want fold checked that it never destructs its argument.
789    This is quite expensive.])
791 valgrind_path_defines=
792 valgrind_command=
793 if test x$ac_valgrind_checking != x ; then
794   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
795         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
796   if test "x$valgrind_path" = "x"; then
797     AC_MSG_ERROR([*** Cannot find valgrind])
798   fi
799   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
800   valgrind_command="$valgrind_path -q"
801   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
802 [Define if you want to run subprograms and generated programs
803    through valgrind (a memory checker).  This is extremely expensive.])
805 AC_SUBST(valgrind_path_defines)
806 AC_SUBST(valgrind_command)
808 # Enable code coverage collection
809 AC_ARG_ENABLE(coverage,
810 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
811                 [enable compiler's code coverage collection.
812                  Use to measure compiler performance and locate
813                  unused parts of the compiler. With LEVEL, specify
814                  optimization. Values are opt, noopt,
815                  default is noopt])],
816 [case "${enableval}" in
817   yes|noopt)
818     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0 -fkeep-static-functions"
819     ;;
820   opt)
821     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2 -fkeep-static-functions"
822     ;;
823   no)
824     # a.k.a. --disable-coverage
825     coverage_flags=""
826     ;;
827   *)
828     AC_MSG_ERROR(unknown coverage setting $enableval)
829     ;;
830 esac],
831 [coverage_flags=""])
832 AC_SUBST(coverage_flags)
834 AC_ARG_ENABLE(gather-detailed-mem-stats, 
835 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
836                 [enable detailed memory allocation stats gathering])], [],
837 [enable_gather_detailed_mem_stats=no])
838 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
839 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
840 [Define to enable detailed memory allocation stats gathering.])
842 AC_ARG_ENABLE(valgrind-annotations,
843 [AS_HELP_STRING([--enable-valgrind-annotations],
844                 [enable valgrind runtime interaction])], [],
845 [enable_valgrind_annotations=no])
846 AC_CHECK_HEADER(valgrind/memcheck.h)
847 if test x$enable_valgrind_annotations != xno \
848     || test x$ac_valgrind_checking != x; then
849   if test $ac_cv_header_valgrind_memcheck_h = no; then
850     AC_MSG_ERROR([*** Cannot find valgrind/memcheck.h])
851   fi
852   AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
853 [Define to get calls to the valgrind runtime enabled.])
856 # -------------------------------
857 # Miscenalleous configure options
858 # -------------------------------
860 # Determine whether or not multilibs are enabled.
861 AC_ARG_ENABLE(multilib,
862 [AS_HELP_STRING([--enable-multilib],
863                 [enable library support for multiple ABIs])],
864 [], [enable_multilib=yes])
865 AC_SUBST(enable_multilib)
867 # Determine whether or not multiarch is enabled.
868 AC_ARG_ENABLE(multiarch,
869 [AS_HELP_STRING([--enable-multiarch],
870                 [enable support for multiarch paths])],
871 [case "${enableval}" in
872 yes|no|auto) enable_multiarch=$enableval;;
873 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
874 esac], [enable_multiarch=auto])
875 if test x${enable_multiarch} = xauto; then
876   if test x${with_native_system_header_dir} != x; then
877     ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
878     enable_multiarch=no
879   fi
880   if test x$host != x$target && test "x$with_sysroot" = x; then
881     ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
882     enable_multiarch=no
883   fi
885 if test x${enable_multiarch} = xyes; then
886   AC_DEFINE(ENABLE_MULTIARCH, 1, [If --with-multiarch option is used])
888 AC_MSG_CHECKING(for multiarch configuration)
889 AC_SUBST(enable_multiarch)
890 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
892 # needed for setting the multiarch name for soft-float/hard-float ABIs
893 AC_SUBST(with_cpu)
894 AC_SUBST(with_float)
896 # default stack clash protection guard size as power of twos in bytes.
897 # Please keep these in sync with params.def.
898 stk_clash_min=12
899 stk_clash_max=30
901 # Keep the default value when the option is not used to 0, this allows us to
902 # distinguish between the cases where the user specifially set a value via
903 # configure and when the normal default value is used.
904 AC_ARG_WITH(stack-clash-protection-guard-size,
905 [AS_HELP_STRING([--with-stack-clash-protection-guard-size=size],
906 [Set the default stack clash protection guard size for specific targets as a power of two in bytes.])],
907 [DEFAULT_STK_CLASH_GUARD_SIZE="$with_stack_clash_protection_guard_size"], [DEFAULT_STK_CLASH_GUARD_SIZE=0])
908 if test $DEFAULT_STK_CLASH_GUARD_SIZE -ne 0 \
909      && (test $DEFAULT_STK_CLASH_GUARD_SIZE -lt $stk_clash_min \
910          || test $DEFAULT_STK_CLASH_GUARD_SIZE -gt $stk_clash_max); then
911   AC_MSG_ERROR(m4_normalize([
912                 Invalid value $DEFAULT_STK_CLASH_GUARD_SIZE for --with-stack-clash-protection-guard-size. \
913                 Must be between $stk_clash_min and $stk_clash_max.]))
916 AC_DEFINE_UNQUOTED(DEFAULT_STK_CLASH_GUARD_SIZE, $DEFAULT_STK_CLASH_GUARD_SIZE,
917         [Define to larger than zero set the default stack clash protector size.])
919 # Specify the number of splits of match.pd to generate.
920 AC_ARG_WITH(matchpd-partitions,
921 [AS_HELP_STRING([--with-matchpd-partitions=num],
922 [Set the number of partitions to make for gimple and generic when splitting match.pd. [default=10]])],
923 [DEFAULT_MATCHPD_PARTITIONS="$with_matchpd_partitions"], [DEFAULT_MATCHPD_PARTITIONS=10])
924 if (test $DEFAULT_MATCHPD_PARTITIONS -lt 1); then
925   AC_MSG_ERROR(m4_normalize([
926                 Invalid value $DEFAULT_MATCHPD_PARTITIONS for --with-matchpd-partitions. \
927                 Cannot be negative.]))
930 AC_SUBST(DEFAULT_MATCHPD_PARTITIONS)
932 # Specify the number of splits of insn-emit.cc and insn-recog.cc to generate.
933 AC_ARG_WITH(insnemit-partitions,
934 [AS_HELP_STRING([--with-insnemit-partitions=num],
935 [Set the number of partitions of insn-emit.cc for genemit and genrecog to create. [default=10]])],
936 [DEFAULT_INSNEMIT_PARTITIONS="$with_insnemit_partitions"], [DEFAULT_INSNEMIT_PARTITIONS=10])
937 if (test $DEFAULT_INSNEMIT_PARTITIONS -lt 1); then
938   AC_MSG_ERROR(m4_normalize([
939                 Invalid value $DEFAULT_INSNEMIT_PARTITIONS for --with-insnemit-partitions. \
940                 Cannot be negative.]))
943 AC_SUBST(DEFAULT_INSNEMIT_PARTITIONS)
945 # Enable __cxa_atexit for C++.
946 AC_ARG_ENABLE(__cxa_atexit,
947 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
948 [], [])
950 # Enable C extension for decimal float if target supports it.
951 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
953 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
954 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
955 [Define to 1 to enable decimal float extension to C.])
957 # Use default_decimal_float for dependency.
958 enable_decimal_float=$default_decimal_float
960 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
961 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
962 [Define to 1 to specify that we are using the BID decimal floating
963 point format instead of DPD])
965 # Enable C extension for fixed-point arithmetic.
966 AC_ARG_ENABLE(fixed-point,
967 [AS_HELP_STRING([--enable-fixed-point],
968                 [enable fixed-point arithmetic extension to C])],
971   case $target in
972     arm*)
973       enable_fixed_point=yes
974       ;;
976     mips*-*-*)
977       enable_fixed_point=yes
978       ;;
979     loongarch*-*-*)
980       enable_fixed_point=yes
981       ;;
982     *)
983       AC_MSG_WARN([fixed-point is not supported for this target, ignored])
984       enable_fixed_point=no
985       ;;
986   esac
988 AC_SUBST(enable_fixed_point)
990 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
991 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
992 [Define to 1 to enable fixed-point arithmetic extension to C.])
994 # Enable threads
995 # Pass with no value to take the default
996 # Pass with a value to specify a thread package
997 AC_ARG_ENABLE(threads,
998 [AS_HELP_STRING([[--enable-threads[=LIB]]],
999                 [enable thread usage for target GCC,
1000                  using LIB thread package])],,
1001 [enable_threads=''])
1003 AC_ARG_ENABLE(tls,
1004 [AS_HELP_STRING([--enable-tls],
1005                 [enable or disable generation of tls code
1006                  overriding the assembler check for tls support])],
1008   case $enable_tls in
1009     yes | no) ;;
1010     *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
1011 Valid choices are 'yes' and 'no'.]) ;;
1012   esac
1013 ], [enable_tls=''])
1015 AC_ARG_ENABLE(vtable-verify,
1016 [AS_HELP_STRING([--enable-vtable-verify],
1017                 [enable vtable verification feature])],,
1018 [enable_vtable_verify=no])
1019 vtable_verify=`if test x$enable_vtable_verify = xyes; then echo 1; else echo 0; fi`
1020 AC_DEFINE_UNQUOTED(ENABLE_VTABLE_VERIFY, $vtable_verify,
1021 [Define 0/1 if vtable verification feature is enabled.])
1023 AC_ARG_ENABLE(analyzer,
1024 [AS_HELP_STRING([--disable-analyzer],
1025                 [disable -fanalyzer static analyzer])],
1026 if test x$enable_analyzer = xno; then
1027         analyzer=0
1028 else
1029         analyzer=1
1031 analyzer=1)
1032 AC_DEFINE_UNQUOTED(ENABLE_ANALYZER, $analyzer,
1033 [Define 0/1 if static analyzer feature is enabled.])
1035 AC_ARG_ENABLE(objc-gc,
1036 [AS_HELP_STRING([--enable-objc-gc],
1037                 [enable the use of Boehm's garbage collector with
1038                  the GNU Objective-C runtime])],
1039 if test x$enable_objc_gc = xno; then
1040         objc_boehm_gc=''
1041 else
1042         objc_boehm_gc=1
1044 objc_boehm_gc='')
1046 AC_ARG_WITH(dwarf2,
1047 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2 (or later)])],
1048 dwarf2="$with_dwarf2",
1049 dwarf2=no)
1051 AC_ARG_ENABLE(shared,
1052 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
1054   case $enable_shared in
1055   yes | no) ;;
1056   *)
1057     enable_shared=no
1058     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1059     for pkg in $enableval; do
1060       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
1061         enable_shared=yes
1062       fi
1063     done
1064     IFS="$ac_save_ifs"
1065     ;;
1066   esac
1067 ], [enable_shared=yes])
1068 AC_SUBST(enable_shared)
1070 AC_ARG_ENABLE(gcov,
1071 [  --disable-gcov          don't provide libgcov and related host tools],
1072 [], [case $target in
1073        bpf-*-*)
1074          enable_gcov=no
1075        ;;
1076        *)
1077          enable_gcov=yes
1078        ;;
1079      esac])
1081 AC_SUBST(enable_gcov)
1083 AC_ARG_WITH(specs,
1084   [AS_HELP_STRING([--with-specs=SPECS],
1085                   [add SPECS to driver command-line processing])],
1086   [CONFIGURE_SPECS=$withval],
1087   [CONFIGURE_SPECS=]
1089 AC_SUBST(CONFIGURE_SPECS)
1091 ACX_PKGVERSION([GCC])
1092 ACX_BUGURL([https://gcc.gnu.org/bugs/])
1094 # Allow overriding the default URL for documentation
1095 AC_ARG_WITH(documentation-root-url,
1096     AS_HELP_STRING([--with-documentation-root-url=URL],
1097                    [Root for documentation URLs]),
1098     [case "$withval" in
1099       yes) AC_MSG_ERROR([documentation root URL not specified]) ;;
1100       no)  AC_MSG_ERROR([documentation root URL not specified]) ;;
1101       */)  DOCUMENTATION_ROOT_URL="$withval" ;;
1102       *)   AC_MSG_ERROR([documentation root URL does not end with /]) ;;
1103      esac],[
1104      docroot_url_suffix=
1105 changequote(,)dnl
1106      case "$gcc_version" in
1107        *.[123456].0) docroot_url_suffix="gcc-$gcc_version/";;
1108        *.[123456].1) docroot_url_suffix="gcc-`echo $gcc_version | sed 's/1$/0/'`/";;
1109      esac
1110 changequote([,])dnl
1111      DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/$docroot_url_suffix"
1113 AC_DEFINE_UNQUOTED(DOCUMENTATION_ROOT_URL,"$DOCUMENTATION_ROOT_URL",
1114         [Define to the root for documentation URLs.])
1116 # Allow overriding the default URL for GCC changes
1117 AC_ARG_WITH(changes-root-url,
1118     AS_HELP_STRING([--with-changes-root-url=URL],
1119                    [Root for GCC changes URLs]),
1120     [case "$withval" in
1121       yes) AC_MSG_ERROR([changes root URL not specified]) ;;
1122       no)  AC_MSG_ERROR([changes root URL not specified]) ;;
1123       */)  CHANGES_ROOT_URL="$withval" ;;
1124       *)   AC_MSG_ERROR([changes root URL does not end with /]) ;;
1125      esac],
1126      CHANGES_ROOT_URL="https://gcc.gnu.org/"
1128 AC_DEFINE_UNQUOTED(CHANGES_ROOT_URL,"$CHANGES_ROOT_URL",
1129         [Define to the root for URLs about GCC changes.])
1131 # Sanity check enable_languages in case someone does not run the toplevel
1132 # configure # script.
1133 AC_ARG_ENABLE(languages,
1134 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
1135 [case ,${enable_languages}, in
1136        ,,|,yes,)
1137                 # go safe -- we cannot be much sure without the toplevel
1138                 # configure's
1139                 # analysis of which target libs are present and usable
1140                 enable_languages=c
1141                 ;;
1142          *,all,*)
1143                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
1144                 ;;
1145         *,c,*)
1146                 ;;
1147         *)
1148                 enable_languages=c,${enable_languages}
1149                 ;;
1150 esac],
1151 [enable_languages=c])
1153 # If top-level libada has been disabled, then wire in install-gnatlib
1154 # invocation with `make install', so that one can build and install
1155 # the library manually with `make -C gcc all gnatlib gnattools install'.
1156 if test x"$enable_libada" = xno; then
1157   gnat_install_lib=gnat-install-lib
1158 else
1159   gnat_install_lib=
1161 AC_SUBST(gnat_install_lib)
1163 if test x"$enable_as_accelerator_for" != x; then
1164   AC_DEFINE(ACCEL_COMPILER, 1,
1165     [Define if this compiler should be built as the offload target compiler.])
1166   enable_as_accelerator=yes
1167   sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
1168   program_transform_name=`echo $program_transform_name | sed $sedscript`
1169   accel_dir_suffix=/accel/${target_noncanonical}
1170   real_target_noncanonical=${enable_as_accelerator_for}
1172 AC_SUBST(enable_as_accelerator)
1173 AC_SUBST(real_target_noncanonical)
1174 AC_SUBST(accel_dir_suffix)
1176 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
1177   tgt=`echo $tgt | sed 's/=.*//'`
1179   enable_offloading=1
1180   case "$tgt" in
1181     amdgcn*)
1182         omp_device_property=omp-device-properties-gcn
1183         omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/gcn/t-omp-device"
1184         ;;
1185     nvptx*)
1186         omp_device_property=omp-device-properties-nvptx
1187         omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/nvptx/t-omp-device"
1188         ;;
1189     *)
1190         AC_MSG_ERROR([unknown offload target specified])
1191         ;;
1192   esac
1193   omp_device_properties="${omp_device_properties} ${tgt}=${omp_device_property}"
1194   omp_device_property_deps="${omp_device_property_deps} ${omp_device_property}"
1196   if test x"$offload_targets" = x; then
1197     offload_targets=$tgt
1198   else
1199     offload_targets="$offload_targets,$tgt"
1200   fi
1201 done
1202 AC_SUBST(omp_device_properties)
1203 AC_SUBST(omp_device_property_deps)
1205 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
1206   [Define to offload targets, separated by commas.])
1207 if test x"$enable_offloading" != x; then
1208   AC_DEFINE(ENABLE_OFFLOADING, 1,
1209     [Define this to enable support for offloading.])
1210 else
1211   AC_DEFINE(ENABLE_OFFLOADING, 0,
1212     [Define this to enable support for offloading.])
1215 if test "x$enable_offload_defaulted" = xyes; then
1216   AC_DEFINE(OFFLOAD_DEFAULTED, 1,
1217     [Define to 1 to if -foffload is defaulted])
1220 AC_ARG_WITH(multilib-list,
1221 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, ARM, AVR, nvptx, OR1K, RISC-V, SH and x86-64 only)])],
1223 with_multilib_list=default)
1225 AC_ARG_WITH(multilib-generator,
1226 [AS_HELP_STRING([--with-multilib-generator], [Multi-libs configuration string (RISC-V only)])],
1228 with_multilib_generator=default)
1230 # -------------------------
1231 # Checks for other programs
1232 # -------------------------
1234 AC_PROG_MAKE_SET
1236 # Find some useful tools
1237 AC_PROG_AWK
1238 # We need awk to create options.cc and options.h.
1239 # Bail out if it's missing.
1240 case ${AWK} in
1241   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
1242 esac
1244 gcc_AC_PROG_LN_S
1245 ACX_PROG_LN($LN_S)
1246 AC_PROG_RANLIB
1247 ranlib_flags=""
1248 AC_SUBST(ranlib_flags)
1249      
1250 gcc_AC_PROG_INSTALL
1252 # See if cmp has --ignore-initial.
1253 gcc_AC_PROG_CMP_IGNORE_INITIAL
1255 # See if we have the mktemp command.
1256 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
1258 # See if makeinfo has been installed and is modern enough
1259 # that we can use it.
1260 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
1261   [GNU texinfo.* \([0-9][0-9.]*\)],
1262   [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
1263 if test $gcc_cv_prog_makeinfo_modern = no; then
1264   AC_MSG_WARN([
1265 *** Makeinfo is missing or too old.
1266 *** Info documentation will not be built.])
1267   BUILD_INFO=no-info
1268 else
1269   BUILD_INFO=info
1271 AC_SUBST(BUILD_INFO)
1273 # Determine whether makeinfo supports the CONTENTS_OUTPUT_LOCATION variable.
1274 # If it does, we want to pass it to makeinfo in order to restore the old
1275 # behavior of @{summary,}contents placement.
1276 MAKEINFO_TOC_INLINE_FLAG=
1277 AS_IF([test x"$MAKEINFO" != x], [
1278   AC_CACHE_CHECK([for CONTENTS_OUTPUT_LOCATION support in $MAKEINFO],
1279                  [gcc_cv_texi_add_toc_inline_flags], [
1280     # Detect the unknown variable CONTENTS_OUTPUT_LOCATION warning
1281     if "$MAKEINFO" -c CONTENTS_OUTPUT_LOCATION=inline </dev/null 2>&1 \
1282        | grep CONTENTS_OUTPUT_LOCATION >/dev/null; then
1283       gcc_cv_texi_add_toc_inline_flags=no
1284     else
1285       gcc_cv_texi_add_toc_inline_flags=yes
1286     fi
1287   ])
1288   if test x"$gcc_cv_texi_add_toc_inline_flags" = xyes; then
1289     MAKEINFO_TOC_INLINE_FLAG='-c CONTENTS_OUTPUT_LOCATION=inline'
1290   fi
1292 AC_SUBST([MAKEINFO_TOC_INLINE_FLAG])
1294 # Is pod2man recent enough to regenerate manpages?
1295 AC_MSG_CHECKING([for recent Pod::Man])
1296 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1297   AC_MSG_RESULT(yes)
1298   GENERATED_MANPAGES=generated-manpages
1299 else
1300   AC_MSG_RESULT(no)
1301   GENERATED_MANPAGES=
1303 AC_SUBST(GENERATED_MANPAGES)
1305 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1307 # How about lex?
1308 dnl Don't use AC_PROG_LEX; we insist on flex.
1309 dnl LEXLIB is not useful in gcc.
1310 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1312 # Bison?
1313 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1315 # Python3?
1316 ACX_CHECK_PROG_VER(PYTHON, python3, --version,
1317   [Python.* \([0-9][0-9.]*\)],
1318   [3.[4-9]*|3.[1-9][0-9]*|[4-9].*|[1-9][0-9]*])
1319 if test $gcc_cv_prog_python3_modern = no; then
1320   AC_MSG_WARN([
1321 *** Python3 is missing.
1322 *** Documentation for modula-2 will not include the target SYSTEM module.])
1323   HAVE_PYTHON=no
1324 else
1325   HAVE_PYTHON=yes
1327 AC_SUBST(HAVE_PYTHON)
1329 # Binutils are not build modules, unlike bison/flex/makeinfo.  So we
1330 # check for build == host before using them.
1332 # NM
1333 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1334   && test -d ../binutils ; then
1335   NM='../binutils/nm-new'
1336 else
1337   AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1340 # AR
1341 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1342   && test -d ../binutils ; then
1343   AR='../binutils/ar'
1344 else
1345   AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1348 # The jit documentation looks better if built with sphinx, but can be
1349 # built with texinfo if sphinx is not available.
1350 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1351 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1353 # --------------------
1354 # Checks for C headers
1355 # --------------------
1357 # Need to reject headers which give warnings, so that the -Werror bootstrap
1358 # works later. *sigh*  This needs to come before all header checks.
1359 AC_PROG_CPP_WERROR
1361 AC_HEADER_STDC
1362 AC_HEADER_TIME
1363 ACX_HEADER_STRING
1364 AC_HEADER_SYS_WAIT
1365 AC_HEADER_TIOCGWINSZ
1366 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1367                  fcntl.h ftw.h unistd.h sys/auxv.h sys/file.h sys/time.h sys/mman.h \
1368                  sys/resource.h sys/param.h sys/times.h sys/stat.h sys/locking.h \
1369                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1371 # Check for thread headers.
1372 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1373 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1375 # These tests can't be done till we know if we have limits.h.
1376 gcc_AC_C_CHAR_BIT
1377 AC_C_BIGENDIAN
1379 # ----------------------
1380 # Checks for C++ headers
1381 # ----------------------
1383 dnl Autoconf will give an error in the configure script if there is no
1384 dnl C++ preprocessor.  Hack to prevent that.
1385 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1386 AC_PROG_CXXCPP
1387 m4_popdef([AC_MSG_ERROR])[]dnl
1389 AC_CHECK_HEADERS(unordered_map)
1390 AC_CHECK_HEADERS(tr1/unordered_map)
1391 AC_CHECK_HEADERS(ext/hash_map)
1393 # --------
1394 # Dependency checking.
1395 # --------
1397 ZW_CREATE_DEPDIR
1398 AC_CONFIG_COMMANDS([gccdepdir],[
1399   ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1400   for lang in $subdirs c-family common analyzer text-art rtl-ssa sym-exec
1401   do
1402       ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1403   done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1405 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1407 # --------
1408 # UNSORTED
1409 # --------
1412 # These libraries may be used by collect2.
1413 # We may need a special search path to get them linked.
1414 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1415 [save_LIBS="$LIBS"
1416 for libs in '' -lld -lmld \
1417                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1418                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1420         LIBS="$libs"
1421         AC_TRY_LINK_FUNC(ldopen,
1422                 [gcc_cv_collect2_libs="$libs"; break])
1423 done
1424 LIBS="$save_LIBS"
1425 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1426 case $gcc_cv_collect2_libs in
1427         "none required")        ;;
1428         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1429 esac
1430 AC_SUBST(COLLECT2_LIBS)
1432 # When building Ada code on Alpha, we need exc_resume which is usually in
1433 # -lexc.  So test for it.
1434 save_LIBS="$LIBS"
1435 LIBS=
1436 AC_SEARCH_LIBS(exc_resume, exc)
1437 GNAT_LIBEXC="$LIBS"
1438 LIBS="$save_LIBS"
1439 AC_SUBST(GNAT_LIBEXC)
1441 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1442 save_LIBS="$LIBS"
1443 LIBS=
1444 AC_SEARCH_LIBS(kstat_open, kstat)
1445 EXTRA_GCC_LIBS="$LIBS"
1446 LIBS="$save_LIBS"
1447 AC_SUBST(EXTRA_GCC_LIBS)
1449 # Some systems put ldexp and frexp in libm instead of libc; assume
1450 # they're both in the same place.  jcf-dump needs them.
1451 save_LIBS="$LIBS"
1452 LIBS=
1453 AC_SEARCH_LIBS(ldexp, m)
1454 LDEXP_LIB="$LIBS"
1455 LIBS="$save_LIBS"
1456 AC_SUBST(LDEXP_LIB)
1458 # Some systems need dlopen
1459 save_LIBS="$LIBS"
1460 LIBS=
1461 AC_SEARCH_LIBS(dlopen, dl)
1462 DL_LIB="$LIBS"
1463 LIBS="$save_LIBS"
1464 AC_SUBST(DL_LIB)
1466 # Use <inttypes.h> only if it exists,
1467 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1468 # PRId64
1469 AC_MSG_CHECKING(for inttypes.h)
1470 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1471 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1472 [[#define __STDC_FORMAT_MACROS
1473 #include <sys/types.h>
1474 #include <inttypes.h>]],
1475   [[intmax_t i = -1;
1476 #ifndef PRId64
1477 choke me
1478 #endif]])],
1479   [gcc_cv_header_inttypes_h=yes],
1480   [gcc_cv_header_inttypes_h=no])])
1481 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1482 if test $gcc_cv_header_inttypes_h = yes; then
1483   AC_DEFINE(HAVE_INTTYPES_H, 1,
1484         [Define if you have a working <inttypes.h> header file.])
1487 # Look for the ZSTD package.
1488 ZSTD_INCLUDE=
1489 ZSTD_LIB=
1490 AC_SUBST(ZSTD_INCLUDE)
1491 AC_SUBST(ZSTD_LIB)
1492 ZSTD_CPPFLAGS=
1493 ZSTD_LDFLAGS=
1494 AC_SUBST(ZSTD_CPPFLAGS)
1495 AC_SUBST(ZSTD_LDFLAGS)
1496 AC_ARG_WITH(zstd,
1497         [AS_HELP_STRING([--with-zstd=PATH],
1498                 [specify prefix directory for installed zstd library.
1499                  Equivalent to --with-zstd-include=PATH/include
1500                  plus --with-zstd-lib=PATH/lib])])
1501 AC_ARG_WITH(zstd-include,
1502         [AS_HELP_STRING([--with-zstd-include=PATH],
1503                 [specify directory for installed zstd include files])])
1504 AC_ARG_WITH(zstd-lib,
1505         [AS_HELP_STRING([--with-zstd-lib=PATH],
1506                 [specify directory for the installed zstd library])])
1507 case "x$with_zstd" in
1508   x) ;;
1509   xno)
1510     ZSTD_INCLUDE=
1511     ZSTD_LIB=
1512     ;;
1513   *) ZSTD_INCLUDE=$with_zstd/include
1514      ZSTD_LIB=$with_zstd/lib
1515      ;;
1516 esac
1518 if test "x$with_zstd" != xno; then
1519 if test "x$with_zstd_include" != x; then
1520   ZSTD_INCLUDE=$with_zstd_include
1522 if test "x$with_zstd_lib" != x; then
1523   ZSTD_LIB=$with_zstd_lib
1525 if test "x$ZSTD_INCLUDE" != x \
1526    && test "x$ZSTD_INCLUDE" != xno; then
1527   ZSTD_CPPFLAGS=-I$ZSTD_INCLUDE
1529 if test "x$ZSTD_LIB" != x \
1530    && test "x$ZSTD_LIB" != xno; then
1531   ZSTD_LDFLAGS=-L$ZSTD_LIB
1534 CXXFLAGS="$CXXFLAGS $ZSTD_CPPFLAGS"
1535 LDFLAGS="$LDFLAGS $ZSTD_LDFLAGS"
1537 # LTO can use zstd compression algorithm
1538 save_LIBS="$LIBS"
1539 LIBS=
1540 AC_SEARCH_LIBS(ZSTD_compress, zstd,, gcc_cv_header_zstd_h=no)
1541 ZSTD_LIB="$LIBS"
1542 LIBS="$save_LIBS"
1543 AC_SUBST(ZSTD_LIB)
1545 AC_MSG_CHECKING(for zstd.h)
1546 AC_CACHE_VAL(gcc_cv_header_zstd_h,
1547 # We require version 1.3.0 or later.  This is the first version that has
1548 # ZSTD_getFrameContentSize.
1549 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1550 [[#include <zstd.h>
1551 #if ZSTD_VERSION_NUMBER < 10300
1552 #error "need zstd 1.3.0 or better"
1553 #endif]])],
1554   [gcc_cv_header_zstd_h=yes],
1555   [gcc_cv_header_zstd_h=no])])
1556 AC_MSG_RESULT($gcc_cv_header_zstd_h)
1557 if test $gcc_cv_header_zstd_h = yes; then
1558   AC_DEFINE(HAVE_ZSTD_H, 1,
1559         [Define if you have a working <zstd.h> header file.])
1560 elif test "x$with_zstd" != x; then
1561     as_fn_error $? "Unable to find zstd.h.  See config.log for details." "$LINENO" 5
1565 dnl Disabled until we have a complete test for buggy enum bitfields.
1566 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1568 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1569   ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1570   fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1571   fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1572   putchar_unlocked putc_unlocked)
1573 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1574         popen sysconf strsignal getrusage nl_langinfo \
1575         gettimeofday mbstowcs wcswidth mmap posix_fallocate setlocale \
1576         gcc_UNLOCKED_FUNCS madvise mallinfo mallinfo2 fstatat getauxval \
1577         clock_gettime munmap msync)
1579 # At least for glibc, clock_gettime is in librt.  But don't pull that
1580 # in if it still doesn't give us the function we want.
1581 if test $ac_cv_func_clock_gettime = no; then
1582   AC_CHECK_LIB(rt, clock_gettime,
1583     [LIBS="-lrt $LIBS"
1584      AC_DEFINE(HAVE_CLOCK_GETTIME, 1,
1585                [Define to 1 if you have the `clock_gettime' function.])])
1588 if test x$ac_cv_func_mbstowcs = xyes; then
1589   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1590 [    AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1591 int main()
1593   mbstowcs(0, "", 0);
1594   return 0;
1595 }]])],
1596     [gcc_cv_func_mbstowcs_works=yes],
1597     [gcc_cv_func_mbstowcs_works=no],
1598     [gcc_cv_func_mbstowcs_works=yes])])
1599   if test x$gcc_cv_func_mbstowcs_works = xyes; then
1600     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1601   [Define this macro if mbstowcs does not crash when its
1602    first argument is NULL.])
1603   fi
1606 AC_CHECK_TYPE(ssize_t, int)
1607 AC_CHECK_TYPE(caddr_t, char *)
1608 AC_CHECK_TYPE(sighander_t,
1609   AC_DEFINE(HAVE_SIGHANDLER_T, 1,
1610     [Define if <sys/signal.h> defines sighandler_t]),
1611     ,signal.h)
1613 GCC_AC_FUNC_MMAP_BLACKLIST
1615 case "${host}" in
1616 *-*-*vms*)
1617   # Under VMS, vfork works very differently than on Unix. The standard test 
1618   # won't work, and it isn't easily adaptable. It makes more sense to
1619   # just force it.
1620   ac_cv_func_vfork_works=yes
1621   ;;
1622 esac
1623 AC_FUNC_FORK
1625 AM_ICONV
1627 # Until we have in-tree GNU iconv:
1628 LIBICONV_DEP=
1629 if test -f "$LTLIBICONV"; then
1630   LIBICONV_DEP=$LTLIBICONV
1632 AC_SUBST(LIBICONV_DEP)
1634 AM_LC_MESSAGES
1636 AM_LANGINFO_CODESET
1638 # We will need to find libiberty.h and ansidecl.h
1639 saved_CFLAGS="$CFLAGS"
1640 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1641 saved_CXXFLAGS="$CXXFLAGS"
1642 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1644 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1645 # normal autoconf function for these.  But force definition of
1646 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1647 # basename handling in libiberty.h.
1648 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1649 #undef HAVE_DECL_BASENAME
1650 #define HAVE_DECL_BASENAME 1
1651 #include "ansidecl.h"
1652 #include "system.h"])
1654 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1655         madvise mkstemps stpcpy strnlen strsignal strverscmp \
1656         strtol strtoul strtoll strtoull setenv unsetenv \
1657         errno snprintf vsnprintf vasprintf malloc realloc calloc \
1658         free getopt clock getpagesize ffs fmemopen gcc_UNLOCKED_FUNCS, , ,[
1659 #include "ansidecl.h"
1660 #include "system.h"])
1662 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1663 #include "ansidecl.h"
1664 #include "system.h"
1665 #ifdef HAVE_SYS_RESOURCE_H
1666 #include <sys/resource.h>
1667 #endif
1670 gcc_AC_CHECK_DECLS(mallinfo mallinfo2, , ,[
1671 #include "ansidecl.h"
1672 #include "system.h"
1673 #ifdef HAVE_MALLOC_H
1674 #include <malloc.h>
1675 #endif
1678 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1679 #include "ansidecl.h"
1680 #include "system.h"
1681 #ifdef HAVE_SYS_RESOURCE_H
1682 #include <sys/resource.h>
1683 #endif
1684 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1685 [Define to `long' if <sys/resource.h> doesn't define.])])
1687 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1688 # FREAD and FWRITE macros.  Fortunately, for GCC's single usage of ldgetname
1689 # in collect2.cc, <fcntl.h> isn't visible, but the configure test below needs
1690 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1691 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1692 #include "ansidecl.h"
1693 #include "system.h"
1694 #ifdef HAVE_LDFCN_H
1695 #undef FREAD
1696 #undef FWRITE
1697 #include <ldfcn.h>
1698 #endif
1701 gcc_AC_CHECK_DECLS(times, , ,[
1702 #include "ansidecl.h"
1703 #include "system.h"
1704 #ifdef HAVE_SYS_TIMES_H
1705 #include <sys/times.h>
1706 #endif
1709 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1710 #include "ansidecl.h"
1711 #include "system.h"
1712 #include <signal.h>
1715 # More time-related stuff.
1716 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1717 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1718 #include "ansidecl.h"
1719 #include "system.h"
1720 #ifdef HAVE_SYS_TIMES_H
1721 #include <sys/times.h>
1722 #endif
1723 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1724 if test $ac_cv_struct_tms = yes; then
1725   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1726   [Define if <sys/times.h> defines struct tms.])
1729 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1730 # revisit after autoconf 2.50.
1731 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1732 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1733 #include "ansidecl.h"
1734 #include "system.h"
1735 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1736 if test $gcc_cv_type_clock_t = yes; then
1737   AC_DEFINE(HAVE_CLOCK_T, 1,
1738   [Define if <time.h> defines clock_t.])
1741 # Check if F_SETLKW is supported by fcntl.
1742 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1743 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1744 #include <fcntl.h>]], [[
1745 struct flock fl;
1746 fl.l_whence = 0;
1747 fl.l_start = 0;
1748 fl.l_len = 0;
1749 fl.l_pid = 0;
1750 return fcntl (1, F_SETLKW, &fl);]])],
1751 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1752 if test $ac_cv_f_setlkw = yes; then
1753   AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1754   [Define if F_SETLKW supported by fcntl.])
1757 # Check if O_CLOEXEC is defined by fcntl
1758 AC_CACHE_CHECK(for O_CLOEXEC, ac_cv_o_cloexec, [
1759 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1760 #include <fcntl.h>]], [[
1761 return open ("/dev/null", O_RDONLY | O_CLOEXEC);]])],
1762 [ac_cv_o_cloexec=yes],[ac_cv_o_cloexec=no])])
1763 if test $ac_cv_o_cloexec = yes; then
1764   AC_DEFINE(HOST_HAS_O_CLOEXEC, 1,
1765   [Define if O_CLOEXEC supported by fcntl.])
1768 # Check if O_NONBLOCK is defined by fcntl
1769 AC_CHECK_HEADERS([fcntl.h])
1770 AC_CHECK_DECL(O_NONBLOCK,,,[#include <fcntl.h>])
1771 if test $ac_cv_have_decl_O_NONBLOCK = yes; then
1772   AC_DEFINE(HOST_HAS_O_NONBLOCK, 1,
1773   [Define if O_NONBLOCK supported by fcntl.])
1777 # C++ Modules would like some networking features to provide the mapping
1778 # server.  You can still use modules without them though.
1779 # The following network-related checks could probably do with some
1780 # Windows and other non-linux defenses and checking.
1782 # Local socket connectivity wants AF_UNIX networking
1783 # Check for AF_UNIX networking
1784 AC_CACHE_CHECK(for AF_UNIX, ac_cv_af_unix, [
1785 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1786 #include <sys/types.h>
1787 #include <sys/socket.h>
1788 #include <sys/un.h>
1789 #include <netinet/in.h>]],[[
1790 sockaddr_un un;
1791 un.sun_family = AF_UNSPEC;
1792 int fd = socket (AF_UNIX, SOCK_STREAM, 0);
1793 connect (fd, (sockaddr *)&un, sizeof (un));]])],
1794 [ac_cv_af_unix=yes],
1795 [ac_cv_af_unix=no])])
1796 if test $ac_cv_af_unix = yes; then
1797   AC_DEFINE(HAVE_AF_UNIX, 1,
1798   [Define if AF_UNIX supported.])
1801 # Remote socket connectivity wants AF_INET6 networking
1802 # Check for AF_INET6 networking
1803 AC_CACHE_CHECK(for AF_INET6, ac_cv_af_inet6, [
1804 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1805 #include <sys/types.h>
1806 #include <sys/socket.h>
1807 #include <netinet/in.h>
1808 #include <netdb.h>]],[[
1809 sockaddr_in6 in6;
1810 in6.sin6_family = AF_UNSPEC;
1811 struct addrinfo *addrs = 0;
1812 struct addrinfo hints;
1813 hints.ai_flags = 0;
1814 hints.ai_family = AF_INET6;
1815 hints.ai_socktype = SOCK_STREAM;
1816 hints.ai_protocol = 0;
1817 hints.ai_canonname = 0;
1818 hints.ai_addr = 0;
1819 hints.ai_next = 0;
1820 int e = getaddrinfo ("localhost", 0, &hints, &addrs);
1821 const char *str = gai_strerror (e);
1822 freeaddrinfo (addrs);
1823 int fd = socket (AF_INET6, SOCK_STREAM, 0);
1824 connect (fd, (sockaddr *)&in6, sizeof (in6));]])],
1825 [ac_cv_af_inet6=yes],
1826 [ac_cv_af_inet6=no])])
1827 if test $ac_cv_af_inet6 = yes; then
1828   AC_DEFINE(HAVE_AF_INET6, 1,
1829   [Define if AF_INET6 supported.])
1832 # Check if _LK_LOCK is supported by _locking
1833 AC_CACHE_CHECK(for _LK_LOCK, ac_cv_lk_lock, [
1834 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1835 #include <io.h>
1836 #include <sys/locking.h>]], [[
1837   int fd;
1838   return _locking (fd, _LK_LOCK, 0);]])],
1839 [ac_cv_lk_lock=yes],[ac_cv_lk_lock=no])])
1840 if test $ac_cv_lk_lock = yes; then
1841   AC_DEFINE(HOST_HAS_LK_LOCK, 1,
1842   [Define if _LK_LOC supported by _locking.])
1845 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1846 CFLAGS="$saved_CFLAGS"
1847 CXXFLAGS="$saved_CXXFLAGS"
1849 # mkdir takes a single argument on some systems. 
1850 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1852 # File extensions
1853 manext='.1'
1854 objext='.o'
1855 AC_SUBST(manext)
1856 AC_SUBST(objext)
1858 # With Setjmp/Longjmp based exception handling.
1859 AC_ARG_ENABLE(sjlj-exceptions,
1860 [AS_HELP_STRING([--enable-sjlj-exceptions],
1861                 [arrange to use setjmp/longjmp exception handling])],
1862 [force_sjlj_exceptions=yes],
1863 [case $target in
1864   lm32*-*-*)
1865      force_sjlj_exceptions=yes
1866      enableval=yes
1867      ;;
1868   *)
1869     force_sjlj_exceptions=no
1870     ;;
1871 esac])
1872 if test $force_sjlj_exceptions = yes; then
1873   sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1874   AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1875     [Define 0/1 to force the choice for exception handling model.])
1878 # Windows32 UTF-8 manifest support for running the driver and compiler
1879 # executables with the UTF-8 active code page on mingw hosts.
1880 # Non-mingw hosts ignore this option.
1881 # The shell variables this sets are picked up from the mingw branches
1882 # of config.host so they have to be set before it gets sourced.
1883 AC_ARG_ENABLE(win32-utf8-manifest,
1884 [AS_HELP_STRING([--disable-win32-utf8-manifest],
1885                 [disable embedding a utf8 manifest on mingw hosts])
1886 AS_HELP_STRING([--enable-win32-utf8-manifest],
1887                [enable embedding a utf8 manifest on mingw hosts (default)])],,)
1889 if test "x$enable_win32_utf8_manifest" != xno; then
1890   host_xmake_mingw=i386/x-mingw32-utf8
1891   host_extra_gcc_objs_mingw=utf8rc-mingw32.o
1892   host_extra_objs_mingw=utf8-mingw32.o
1895 # --------------------------------------------------------
1896 # Build, host, and target specific configuration fragments
1897 # --------------------------------------------------------
1899 # Collect build-machine-specific information.
1900 . ${srcdir}/config.build || exit 1
1902 # Collect host-machine-specific information.
1903 . ${srcdir}/config.host || exit 1
1905 target_gtfiles=
1907 # Collect target-machine-specific information.
1908 . ${srcdir}/config.gcc || exit 1
1910 extra_objs="${host_extra_objs} ${extra_objs}"
1911 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1913 # Default the target-machine variables that were not explicitly set.
1914 if test x"$tm_file" = x
1915 then tm_file=$cpu_type/$cpu_type.h; fi
1917 if test x"$extra_headers" = x
1918 then extra_headers=; fi
1920 if test x$md_file = x
1921 then md_file=$cpu_type/$cpu_type.md; fi
1923 if test x$out_file = x
1924 then out_file=$cpu_type/$cpu_type.cc; fi
1926 if test x"$tmake_file" = x
1927 then tmake_file=$cpu_type/t-$cpu_type
1930 # Support --enable-initfini-array.
1931 if test x$enable_initfini_array != xno; then
1932   tm_file="${tm_file} initfini-array.h"
1935 if test x"$dwarf2" = xyes
1936 then tm_file="$tm_file tm-dwarf2.h"
1939 # Say what files are being used for the output code and MD file.
1940 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1941 echo "Using \`$srcdir/config/$md_file' as machine description file."
1943 # If any of the xm_file variables contain nonexistent files, warn
1944 # about them and drop them.
1947 for x in $build_xm_file; do
1948   if    test -f $srcdir/config/$x
1949   then      bx="$bx $x"
1950   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1951   fi
1952 done
1953 build_xm_file="$bx"
1956 for x in $host_xm_file; do
1957   if    test -f $srcdir/config/$x
1958   then      hx="$hx $x"
1959   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1960   fi
1961 done
1962 host_xm_file="$hx"
1965 for x in $xm_file; do
1966   if    test -f $srcdir/config/$x
1967   then      tx="$tx $x"
1968   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1969   fi
1970 done
1971 xm_file="$tx"
1973 count=a
1974 for f in $tm_file; do
1975         count=${count}x
1976 done
1977 if test $count = ax; then
1978         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1979 else
1980         echo "Using the following target machine macro files:"
1981         for f in $tm_file; do
1982                 echo "  $srcdir/config/$f"
1983         done
1986 if test x$use_long_long_for_widest_fast_int = xyes; then
1987         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1988 [Define to 1 if the 'long long' type is wider than 'long' but still
1989 efficiently supported by the host hardware.])
1992 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1993 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1995 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1996 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1998 count=a
1999 for f in $host_xm_file; do
2000         count=${count}x
2001 done
2002 if test $count = a; then
2003         :
2004 elif test $count = ax; then
2005         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
2006 else
2007         echo "Using the following host machine macro files:"
2008         for f in $host_xm_file; do
2009                 echo "  $srcdir/config/$f"
2010         done
2012 echo "Using ${out_host_hook_obj} for host machine hooks."
2014 if test "$host_xm_file" != "$build_xm_file"; then
2015         count=a
2016         for f in $build_xm_file; do
2017                 count=${count}x
2018         done
2019         if test $count = a; then
2020                 :
2021         elif test $count = ax; then
2022                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
2023         else
2024                 echo "Using the following build machine macro files:"
2025                 for f in $build_xm_file; do
2026                         echo "  $srcdir/config/$f"
2027                 done
2028         fi
2031 if test -n "$configured_native_system_header_dir"; then
2032   native_system_header_dir=$configured_native_system_header_dir
2034 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
2035 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
2037 case ${host} in
2038   powerpc*-*-darwin*)
2039     AC_CACHE_CHECK([whether mcontext_t fields have underscores],
2040       gcc_cv_mcontext_underscores,
2041       AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2042 #include <sys/cdefs.h>
2043 #include <sys/signal.h>
2044 #include <ucontext.h>
2045 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
2046 ])],
2047         gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
2048       if test $gcc_cv_mcontext_underscores = yes; then
2049         AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
2050           [mcontext_t fields start with __])
2051       fi
2052     ;;
2053 esac
2055 # ---------
2056 # Threading
2057 # ---------
2059 # Check if a valid thread package
2060 case ${enable_threads} in
2061   "" | no)
2062     # No threads
2063     target_thread_file='single'
2064     ;;
2065   yes)
2066     # default
2067     target_thread_file='single'
2068     ;;
2069   aix | dce | lynx | mipssde | posix | rtems | \
2070   single | tpf | vxworks | win32 | mcf)
2071     target_thread_file=${enable_threads}
2072     ;;
2073   *)
2074     echo "${enable_threads} is an unknown thread package" 1>&2
2075     exit 1
2076     ;;
2077 esac
2079 if test x${thread_file} = x; then
2080   # No thread file set by target-specific clauses in config.gcc,
2081   # so use file chosen by default logic above
2082   thread_file=${target_thread_file}
2085 # --------
2086 # UNSORTED
2087 # --------
2089 use_cxa_atexit=no
2090 if test x$enable___cxa_atexit = xyes || \
2091    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
2092   if test x$host = x$target; then
2093     case $host in
2094       # mingw32 doesn't have __cxa_atexit but uses atexit registration
2095       # keyed to flag_use_cxa_atexit
2096       *-*-mingw32*)
2097         use_cxa_atexit=yes
2098         ;;
2099       powerpc-ibm-aix*)
2100         use_cxa_atexit=yes
2101         ;;
2102       *)
2103         AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
2104           [echo "__cxa_atexit can't be enabled on this target"])
2105         ;;
2106     esac
2107   else
2108     # We can't check for __cxa_atexit when building a cross, so assume
2109     # it is available 
2110     use_cxa_atexit=yes
2111   fi
2112   if test x$use_cxa_atexit = xyes; then
2113     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
2114       [Define if you want to use __cxa_atexit, rather than atexit, to
2115       register C++ destructors for local statics and global objects.
2116       This is essential for fully standards-compliant handling of
2117       destructors, but requires __cxa_atexit in libc.])
2118   fi
2121 # Look for a file containing extra machine modes.
2122 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
2123   extra_modes_file='$(srcdir)'/config/${extra_modes}
2124   AC_SUBST(extra_modes_file)
2125   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
2126   [Define to the name of a file containing a list of extra machine modes
2127    for this architecture.])
2130 # Convert extra_options into a form suitable for Makefile use.
2131 extra_opt_files=
2132 all_opt_files=
2133 for f in $extra_options; do
2134   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
2135   all_opt_files="$all_opt_files $srcdir/config/$f"
2136 done
2137 AC_SUBST(extra_opt_files)
2139 # auto-host.h is the file containing items generated by autoconf and is
2140 # the first file included by config.h.
2141 # If host=build, it is correct to have bconfig include auto-host.h
2142 # as well.  If host!=build, we are in error and need to do more 
2143 # work to find out the build config parameters.
2144 if test x$host = x$build
2145 then
2146         build_auto=auto-host.h
2147         HAVE_AUTO_BUILD='# '
2148 else
2149         # We create a subdir, then run autoconf in the subdir.
2150         # To prevent recursion we set host and build for the new
2151         # invocation of configure to the build for this invocation
2152         # of configure. 
2153         tempdir=build.$$
2154         rm -rf $tempdir
2155         mkdir $tempdir
2156         cd $tempdir
2157         case ${srcdir} in
2158         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
2159         *) realsrcdir=../${srcdir};;
2160         esac
2161         # Clearing GMPINC is necessary to prevent host headers being
2162         # used by the build compiler.  Defining GENERATOR_FILE stops
2163         # system.h from including gmp.h.
2164         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
2165         CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
2166         LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
2167         GMPINC="" CPPFLAGS="${CPPFLAGS_FOR_BUILD} -DGENERATOR_FILE" \
2168         ${realsrcdir}/configure \
2169                 --enable-languages=${enable_languages-all} \
2170                 ${enable_obsolete+--enable-obsolete="$enable_obsolete"} \
2171                 ${enable_option_checking+--enable-option-checking="$enable_option_checking"} \
2172                 --target=$target_alias --host=$build_alias \
2173                 --build=$build_alias || exit # retaining $tempdir
2175         # We just finished tests for the build machine, so rename
2176         # the file auto-build.h in the gcc directory.
2177         mv auto-host.h ../auto-build.h
2178         cd ..
2179         rm -rf $tempdir
2180         build_auto=auto-build.h
2181         HAVE_AUTO_BUILD=
2183 AC_SUBST(build_subdir)
2184 AC_SUBST(HAVE_AUTO_BUILD)
2186 tm_file="${tm_file} defaults.h"
2187 tm_p_file="${tm_p_file} tm-preds.h"
2188 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
2189 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
2190 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
2191 # put this back in temporarily.
2192 xm_file="auto-host.h ansidecl.h ${xm_file}"
2194 # --------
2195 # UNSORTED
2196 # --------
2198 changequote(,)dnl
2199 # Compile in configure arguments.
2200 if test -f configargs.h ; then
2201         # Being re-configured.
2202         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
2203         gcc_reconf_arguments=`echo "$gcc_config_arguments" | sed -e 's/^.*\( : (reconfigured) .*$\)/\1/'`
2204         if [ "$gcc_reconf_arguments" != " : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" ]; then
2205                 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
2206         fi
2207 else
2208         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
2211 # Double all backslashes and backslash all quotes to turn
2212 # gcc_config_arguments into a C string.
2213 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
2214 $gcc_config_arguments
2216 gcc_config_arguments_str=`cat conftest.out`
2217 rm -f conftest.out
2219 cat > configargs.h <<EOF
2220 /* Generated automatically. */
2221 static const char configuration_arguments[] = "$gcc_config_arguments_str";
2222 static const char thread_model[] = "$thread_file";
2224 static const struct {
2225   const char *name, *value;
2226 } configure_default_options[] = $configure_default_options;
2228 changequote([,])dnl
2230 changequote(,)dnl
2231 gcc_BASEVER=`cat $srcdir/BASE-VER`
2232 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
2233 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
2234 if test -f $srcdir/REVISION ; then
2235         gcc_REVISION=`cat $srcdir/REVISION`
2236 else
2237         gcc_REVISION=""
2239 cat > plugin-version.h <<EOF
2240 #include "configargs.h"
2242 #define GCCPLUGIN_VERSION_MAJOR   `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
2243 #define GCCPLUGIN_VERSION_MINOR   `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
2244 #define GCCPLUGIN_VERSION_PATCHLEVEL   `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
2245 #define GCCPLUGIN_VERSION  (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
2247 static char basever[] = "$gcc_BASEVER";
2248 static char datestamp[] = "$gcc_DATESTAMP";
2249 static char devphase[] = "$gcc_DEVPHASE";
2250 static char revision[] = "$gcc_REVISION";
2252 /* FIXME plugins: We should make the version information more precise.
2253    One way to do is to add a checksum. */
2255 static struct plugin_gcc_version gcc_version = {basever, datestamp,
2256                                                 devphase, revision,
2257                                                 configuration_arguments};
2259 changequote([,])dnl
2261 # Determine what GCC version number to use in filesystem paths.
2262 GCC_BASE_VER
2264 # Internationalization
2265 ZW_GNU_GETTEXT_SISTER_DIR
2267 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
2268 # -liconv on the link line twice.
2269 case "$LIBINTL" in *$LIBICONV*)
2270         LIBICONV= ;;
2271 esac
2273 AC_ARG_ENABLE(secureplt,
2274 [AS_HELP_STRING([--enable-secureplt],
2275                 [enable -msecure-plt by default for PowerPC])],
2276 [], [])
2278 AC_ARG_ENABLE(mingw-wildcard,
2279 [AS_HELP_STRING([--enable-mingw-wildcard],
2280                 [Set whether to expand wildcard on command-line.
2281                  Default to platform configuration])],
2282 [],[enable_mingw_wildcard=platform])
2283 AS_IF([test x"$enable_mingw_wildcard" != xplatform ],
2284       [AC_DEFINE_UNQUOTED(MINGW_DOWILDCARD,
2285                  $(test x"$enable_mingw_wildcard" = xno; echo $?),
2286                  [Value to set mingw's _dowildcard to.])])
2288 AC_ARG_ENABLE(large-address-aware,
2289 [AS_HELP_STRING([--enable-large-address-aware],
2290                 [Link mingw executables with --large-address-aware])])
2291 AS_IF([test x"$enable_large_address_aware" = xyes],
2292   [AC_DEFINE([MINGW_DEFAULT_LARGE_ADDR_AWARE], 1,
2293     [Define if we should link mingw executables with --large-address-aware])])
2295 AC_ARG_ENABLE(leading-mingw64-underscores,
2296   AS_HELP_STRING([--enable-leading-mingw64-underscores],
2297                  [enable leading underscores on 64 bit mingw targets]),
2298   [],[])
2299 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
2300   [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
2301     [Define if we should use leading underscore on 64 bit mingw targets])])
2303 AC_ARG_ENABLE(cld,
2304 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
2305 [enable_cld=no])
2307 AC_ARG_ENABLE(frame-pointer,
2308 [AS_HELP_STRING([--enable-frame-pointer],
2309                 [enable -fno-omit-frame-pointer by default for x86])], [],
2311 case $target_os in
2312 linux* | gnu* | darwin[[8912]]* | cygwin* | mingw*)
2313   # Enable -fomit-frame-pointer by default for these systems with DWARF2.
2314   enable_frame_pointer=no
2315   ;;
2317   enable_frame_pointer=yes
2318   ;;
2319 esac
2322 case $target in
2323 i[[34567]]86-*-* | x86_64-*-*)
2324         if test "x$enable_cld" = xyes; then
2325                 tm_defines="${tm_defines} USE_IX86_CLD=1"
2326         fi
2327         if test "x$enable_frame_pointer" = xyes; then
2328                 tm_defines="${tm_defines} USE_IX86_FRAME_POINTER=1"
2329         fi
2330         ;;
2331 esac
2333 # Windows32 Registry support for specifying GCC installation paths.
2334 AC_ARG_ENABLE(win32-registry,
2335 [AS_HELP_STRING([--disable-win32-registry],
2336                 [disable lookup of installation paths in the
2337                  Registry on Windows hosts])
2338 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
2339 AS_HELP_STRING([--enable-win32-registry=KEY],
2340                [use KEY instead of GCC version as the last portion
2341                 of the registry key])],,)
2343 case $host_os in
2344   win32 | pe | cygwin* | mingw32*)
2345     if test "x$enable_win32_registry" != xno; then
2346       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
2347     fi
2349     if test "x$enable_win32_registry" != xno; then
2350       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
2351   [Define to 1 if installation paths should be looked up in the Windows
2352    Registry. Ignored on non-Windows hosts.])
2354       if test "x$enable_win32_registry" != xyes \
2355          && test "x$enable_win32_registry" != x; then
2356         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
2357   [Define to be the last component of the Windows registry key under which
2358    to look for installation paths.  The full key used will be 
2359    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
2360    The default is the GCC version number.])
2361       fi
2362     fi
2363   ;;
2364 esac
2366 # Get an absolute path to the GCC top-level source directory
2367 holddir=`${PWDCMD-pwd}`
2368 cd $srcdir
2369 topdir=`${PWDCMD-pwd}`
2370 cd $holddir
2372 # Conditionalize the makefile for this host machine.
2373 xmake_file=
2374 for f in ${host_xmake_file}
2376         if test -f ${srcdir}/config/$f
2377         then
2378                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
2379         fi
2380 done
2382 # Conditionalize the makefile for this target machine.
2383 tmake_file_=
2384 for f in ${tmake_file}
2386         if test -f ${srcdir}/config/$f
2387         then
2388                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
2389         fi
2390 done
2391 tmake_file="${tmake_file_}${omp_device_property_tmake_file}"
2393 out_object_file=`basename $out_file .cc`.o
2394 common_out_object_file=`basename $common_out_file .cc`.o
2396 tm_file_list="options.h"
2397 tm_include_list="options.h insn-constants.h"
2398 for f in $tm_file; do
2399   case $f in
2400     ./* )
2401        f=`echo $f | sed 's/^..//'`
2402        tm_file_list="${tm_file_list} $f"
2403        tm_include_list="${tm_include_list} $f"
2404        ;;
2405     defaults.h )
2406        tm_file_list="${tm_file_list} \$(srcdir)/$f"
2407        tm_include_list="${tm_include_list} $f"
2408        ;;
2409     * )
2410        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
2411        tm_include_list="${tm_include_list} config/$f"
2412        ;;
2413   esac
2414 done
2416 tm_p_file_list=
2417 tm_p_include_list=
2418 for f in $tm_p_file; do
2419   case $f in
2420     tm-preds.h )
2421        tm_p_file_list="${tm_p_file_list} $f"
2422        tm_p_include_list="${tm_p_include_list} $f"
2423        ;;
2424     * )
2425        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
2426        tm_p_include_list="${tm_p_include_list} config/$f"
2427   esac
2428 done
2430 tm_d_file_list=
2431 tm_d_include_list=
2432 for f in $tm_d_file; do
2433   case $f in
2434     * )
2435        tm_d_file_list="${tm_d_file_list} \$(srcdir)/config/$f"
2436        tm_d_include_list="${tm_d_include_list} config/$f"
2437        ;;
2438   esac
2439 done
2441 tm_rust_file_list=
2442 tm_rust_include_list=
2443 for f in $tm_rust_file; do
2444   case $f in
2445     * )
2446        tm_rust_file_list="${tm_rust_file_list} \$(srcdir)/config/$f"
2447        tm_rust_include_list="${tm_rust_include_list} config/$f"
2448        ;;
2449   esac
2450 done
2452 xm_file_list=
2453 xm_include_list=
2454 for f in $xm_file; do
2455   case $f in
2456     ansidecl.h )
2457        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
2458        xm_include_list="${xm_include_list} $f"
2459        ;;
2460     auto-host.h )
2461        xm_file_list="${xm_file_list} $f"
2462        xm_include_list="${xm_include_list} $f"
2463        ;;
2464     * )
2465        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
2466        xm_include_list="${xm_include_list} config/$f"
2467        ;;
2468   esac
2469 done
2471 host_xm_file_list=
2472 host_xm_include_list=
2473 for f in $host_xm_file; do
2474   case $f in
2475     ansidecl.h )
2476        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
2477        host_xm_include_list="${host_xm_include_list} $f"
2478        ;;
2479     auto-host.h )
2480        host_xm_file_list="${host_xm_file_list} $f"
2481        host_xm_include_list="${host_xm_include_list} $f"
2482        ;;
2483     * )
2484        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
2485        host_xm_include_list="${host_xm_include_list} config/$f"
2486        ;;
2487   esac
2488 done
2490 build_xm_file_list=
2491 for f in $build_xm_file; do
2492   case $f in
2493     ansidecl.h )
2494        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
2495        build_xm_include_list="${build_xm_include_list} $f"
2496        ;;
2497     auto-build.h | auto-host.h )
2498        build_xm_file_list="${build_xm_file_list} $f"
2499        build_xm_include_list="${build_xm_include_list} $f"
2500        ;;
2501     * )
2502        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
2503        build_xm_include_list="${build_xm_include_list} config/$f"
2504        ;;
2505   esac
2506 done
2508 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
2509 # cross-compiler which does not use the native headers and libraries.
2510 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
2511 CROSS=                                          AC_SUBST(CROSS)
2512 ALL=all.internal                                AC_SUBST(ALL)
2513 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
2514 BUILD_SYSTEM_HEADER_DIR=$SYSTEM_HEADER_DIR      AC_SUBST(BUILD_SYSTEM_HEADER_DIR)
2516 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x ||
2517    test x$build != x$host || test "x$with_build_sysroot" != x; then
2518   if test "x$with_build_sysroot" != x; then
2519     BUILD_SYSTEM_HEADER_DIR=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
2520   else
2521     BUILD_SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2522   fi
2524   if test x$host != x$target
2525   then
2526     CROSS="-DCROSS_DIRECTORY_STRUCTURE"
2527     ALL=all.cross
2528     SYSTEM_HEADER_DIR=$BUILD_SYSTEM_HEADER_DIR
2529   elif test "x$TARGET_SYSTEM_ROOT" != x; then
2530     SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2531   fi
2533   if test "x$with_build_sysroot" != "x"; then
2534     target_header_dir="${with_build_sysroot}${native_system_header_dir}"
2535   elif test "x$with_sysroot" = x; then
2536     target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
2537   elif test "x$with_sysroot" = xyes; then
2538     target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
2539   else
2540     target_header_dir="${with_sysroot}${native_system_header_dir}"
2541   fi
2542 else
2543   target_header_dir=${native_system_header_dir}
2546 # If this is a cross-compiler that does not
2547 # have its own set of headers then define
2548 # inhibit_libc
2550 # If this is using newlib, without having the headers available now,
2551 # then define inhibit_libc in LIBGCC2_CFLAGS.
2552 # This prevents libgcc2 from containing any code which requires libc
2553 # support.
2554 : ${inhibit_libc=false}
2555 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2556        test x$with_newlib = xyes ; } &&
2557      { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
2558        inhibit_libc=true
2560 AC_SUBST(inhibit_libc)
2562 # When building gcc with a cross-compiler, we need to adjust things so
2563 # that the generator programs are still built with the native compiler.
2564 # Also, we cannot run fixincludes.
2566 # These are the normal (build=host) settings:
2567 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
2568 CXX_FOR_BUILD='$(CXX)'          AC_SUBST(CXX_FOR_BUILD)
2569 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
2570 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2571 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
2572 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
2574 # And these apply if build != host, or we are generating coverage data
2575 if test x$build != x$host || test "x$coverage_flags" != x
2576 then
2577     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS-$@) $(CFLAGS_FOR_BUILD)'
2578     BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS-$@) $(CXXFLAGS_FOR_BUILD)'
2579     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2583 if test x$enable_fixincludes = xno;
2584 then
2585     STMP_FIXINC=''
2588 # Expand extra_headers to include complete path.
2589 # This substitutes for lots of t-* files.
2590 extra_headers_list=
2591 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2592 for file in ${extra_headers} ; do
2593   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2594 done
2596 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2597 if test x"$use_gcc_tgmath" = xyes
2598 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2601 # Define collect2 in Makefile.
2602 case $host_can_use_collect2 in
2603   no) collect2= ;;
2604   *) collect2='collect2$(exeext)' ;;
2605 esac
2606 AC_SUBST([collect2])
2608 # Add a definition of USE_COLLECT2 if system wants one.
2609 case $use_collect2 in
2610   no) use_collect2= ;;
2611   "") ;;
2612   *) 
2613     host_xm_defines="${host_xm_defines} USE_COLLECT2"
2614     xm_defines="${xm_defines} USE_COLLECT2"
2615     case $host_can_use_collect2 in
2616       no)
2617         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2618         ;;
2619     esac
2620     ;;
2621 esac
2623 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2624 [Define to the name of the LTO plugin DSO that must be
2625   passed to the linker's -plugin=LIB option.])
2627 # ---------------------------
2628 # Assembler & linker features
2629 # ---------------------------
2631 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2632 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2633 # However when ld-new is first executed from the build tree, libtool will
2634 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2635 # to the build tree.  While doing this we need to use the previous-stage
2636 # linker, or we have an infinite loop.  The presence of a shell script as
2637 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2638 # the gcc/collect-ld script.  So we need to know how libtool works, or
2639 # exec-tool will fail.
2641 m4_defun([_LT_CONFIG_COMMANDS], [])
2642 AC_PROG_LIBTOOL
2643 AC_SUBST(objdir)
2644 AC_SUBST(enable_fast_install)
2646 AM_CONDITIONAL([ENABLE_DARWIN_AT_RPATH], [test x$enable_darwin_at_rpath = xyes])
2647 DARWIN_DO_EXTRA_RPATH=0
2648 AC_ARG_WITH(darwin-extra-rpath,
2649 [AS_HELP_STRING(
2650   [[--with-darwin-extra-rpath=[ARG]]],
2651    [Specify a runpath directory, additional to those provided by the compiler])],
2652 [if test x"$withval" != x; then
2653    DARWIN_ADD_RPATH="$withval"
2654    DARWIN_DO_EXTRA_RPATH=1
2655  fi])
2656 AC_DEFINE_UNQUOTED(DARWIN_DO_EXTRA_RPATH, $DARWIN_DO_EXTRA_RPATH,
2657   [Should add an extra runpath directory])
2658 AC_DEFINE_UNQUOTED(DARWIN_ADD_RPATH, "$DARWIN_ADD_RPATH",
2659   [Specify a runpath directory, additional to those provided by the compiler])
2661 # Identify the assembler which will work hand-in-glove with the newly
2662 # built GCC, so that we can examine its features.  This is the assembler
2663 # which will be driven by the driver program.
2665 # If build != host, and we aren't building gas in-tree, we identify a
2666 # build->target assembler and hope that it will have the same features
2667 # as the host->target assembler we'll be using.
2668 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2670 m4_pattern_allow([AS_FOR_TARGET])dnl
2671 AS_VAR_SET_IF(gcc_cv_as,, [
2672 if test -x "$DEFAULT_ASSEMBLER"; then
2673         gcc_cv_as="$DEFAULT_ASSEMBLER"
2674 elif test -f $gcc_cv_as_gas_srcdir/configure.ac \
2675      && test -f ../gas/Makefile \
2676      && test x$build = x$host; then
2677         gcc_cv_as=../gas/as-new$build_exeext
2678 elif test -x as$build_exeext; then
2679         # Build using assembler in the current directory.
2680         gcc_cv_as=./as$build_exeext
2681 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2682         gcc_cv_as="$AS_FOR_TARGET"
2683 else
2684         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2685 fi])
2687 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2688 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2689 case "$ORIGINAL_AS_FOR_TARGET" in
2690   ./as | ./as$build_exeext) ;;
2691   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2692 esac 
2694 default_ld=
2695 AC_ARG_ENABLE(ld,
2696 [[  --enable-ld[=ARG]       build ld [ARG={default,yes,no}]]],
2697 [case "${enableval}" in
2698  no)
2699    default_ld=ld.gold
2700    ;;
2701  esac])
2703 install_gold_as_default=no
2704 AC_ARG_ENABLE(gold,
2705 [[  --enable-gold[=ARG]     build gold [ARG={default,yes,no}]]],
2706 [case "${enableval}" in
2707  default)
2708    install_gold_as_default=yes
2709    ;;
2710  yes)
2711    if test x${default_ld} != x; then
2712      install_gold_as_default=yes
2713    fi
2714    ;;
2715  no)
2716    ;;
2717  *)
2718    AC_MSG_ERROR([invalid --enable-gold argument])
2719    ;;
2720  esac])
2722 # Identify the linker which will work hand-in-glove with the newly
2723 # built GCC, so that we can examine its features.  This is the linker
2724 # which will be driven by the driver program.
2726 # If build != host, and we aren't building gas in-tree, we identify a
2727 # build->target linker and hope that it will have the same features
2728 # as the host->target linker we'll be using.
2729 gcc_cv_gld_major_version=
2730 gcc_cv_gld_minor_version=
2731 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2732 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2733 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2735 AS_VAR_SET_IF(gcc_cv_ld,, [
2736 if test -x "$DEFAULT_LINKER"; then
2737         gcc_cv_ld="$DEFAULT_LINKER"
2738 elif test $install_gold_as_default = yes \
2739      && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2740      && test -f ../gold/Makefile \
2741      && test x$build = x$host; then
2742         gcc_cv_ld=../gold/ld-new$build_exeext
2743 elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \
2744      && test -f ../ld/Makefile \
2745      && test x$build = x$host; then
2746         gcc_cv_ld=../ld/ld-new$build_exeext
2747 elif test -x collect-ld$build_exeext; then
2748         # Build using linker in the current directory.
2749         gcc_cv_ld=./collect-ld$build_exeext
2750 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2751         gcc_cv_ld="$LD_FOR_TARGET"
2752 else
2753         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2754 fi])
2756 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2757 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2758 # if the PLUGIN_LD is set ld-new, just have it as ld
2759 # as that is the installed named.
2760 if test x$PLUGIN_LD_SUFFIX = xld-new \
2761    || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2762   PLUGIN_LD_SUFFIX=ld
2764 AC_ARG_WITH(plugin-ld,
2765 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2766 [if test x"$withval" != x; then
2767    ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2768    PLUGIN_LD_SUFFIX="$withval"
2769  fi])
2770 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2771 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2773 # Check to see if we are using gold instead of ld
2774 AC_MSG_CHECKING(whether we are using gold)
2775 ld_is_gold=no
2776 if test x$gcc_cv_ld != x; then
2777   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2778      | grep "GNU gold" > /dev/null; then
2779     ld_is_gold=yes
2780   fi
2782 AC_MSG_RESULT($ld_is_gold)
2784 # Check to see if we are using mold instead of ld
2785 AC_MSG_CHECKING(whether we are using mold)
2786 ld_is_mold=no
2787 if test x$gcc_cv_ld != x; then
2788   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2789      | grep "mold" > /dev/null; then
2790     ld_is_mold=yes
2791   fi
2793 AC_MSG_RESULT($ld_is_mold)
2796 AC_MSG_CHECKING(gold linker with split stack support as non default)
2797 # Check to see if default ld is not gold, but gold is
2798 # available and has support for split stack.  If gcc was configured
2799 # with gold then no checking is done.
2801 if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then
2803 # For platforms other than powerpc64*, enable as appropriate.
2805   gold_non_default=no
2806   ld_gold=`which ${gcc_cv_ld}.gold`
2807 # Make sure this gold has minimal split stack support
2808   if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then
2809     ld_vers=`$ld_gold --version | sed 1q`
2810     gold_vers=`echo $ld_vers | sed -n \
2811           -e 's,^[[^)]]*[[  ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'`
2812     case $target in
2813 # check that the gold version contains the complete split stack support
2814 # on powerpc64 big and little endian
2815       powerpc64*-*-*)
2816         case "$gold_vers" in
2817           2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes
2818           ;;
2819           *) gold_non_default=no
2820           ;;
2821         esac
2822         ;;
2823     esac
2824   fi
2825   if test $gold_non_default = yes; then
2826     AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1,
2827             [Define if the gold linker supports split stack and is available as a non-default])
2828   fi
2830 AC_MSG_RESULT($gold_non_default)
2832 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2833 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2834 case "$ORIGINAL_LD_FOR_TARGET" in
2835   ./collect-ld | ./collect-ld$build_exeext) ;;
2836   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2837 esac 
2839 AC_MSG_CHECKING(what linker to use)
2840 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2841    || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2842         # Single tree build which includes ld.  We want to prefer it
2843         # over whatever linker top-level may have detected, since
2844         # we'll use what we're building after installation anyway.
2845         AC_MSG_RESULT(newly built ld)
2846         in_tree_ld=yes
2847         in_tree_ld_is_elf=no
2848         if (grep 'EMUL = .*elf' ../ld/Makefile \
2849             || grep 'EMUL = .*linux' ../ld/Makefile \
2850             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2851           in_tree_ld_is_elf=yes
2852         elif test "$ld_is_gold" = yes; then
2853           in_tree_ld_is_elf=yes
2854         fi
2855         for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.ac $gcc_cv_ld_gld_srcdir/Makefile.in
2856         do
2857 changequote(,)dnl
2858                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2859                 if test x$gcc_cv_gld_version != x; then
2860                         break
2861                 fi
2862         done
2863         case $gcc_cv_gld_version in
2864           VERSION=[0-9]*) ;;
2865 changequote([,])dnl
2866           *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2867 changequote(,)dnl
2868         esac
2869         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2870         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2871 changequote([,])dnl
2872         ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2873         ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2874 else
2875         AC_MSG_RESULT($gcc_cv_ld)
2876         in_tree_ld=no
2877         gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2878         ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2879         ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2882 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2883 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2885 # Figure out what nm we will be using.
2886 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2887 AS_VAR_SET_IF(gcc_cv_nm,, [
2888 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2889      && test -f ../binutils/Makefile \
2890      && test x$build = x$host; then
2891         gcc_cv_nm=../binutils/nm-new$build_exeext
2892 elif test -x nm$build_exeext; then
2893         gcc_cv_nm=./nm$build_exeext
2894 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2895         gcc_cv_nm="$NM_FOR_TARGET"
2896 else
2897         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2898 fi])
2900 AC_MSG_CHECKING(what nm to use)
2901 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2902         # Single tree build which includes binutils.
2903         AC_MSG_RESULT(newly built nm)
2904         in_tree_nm=yes
2905 else
2906         AC_MSG_RESULT($gcc_cv_nm)
2907         in_tree_nm=no
2910 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2911 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2912 case "$ORIGINAL_NM_FOR_TARGET" in
2913   ./nm | ./nm$build_exeext) ;;
2914   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2915 esac
2918 # Figure out what objdump we will be using.
2919 AS_VAR_SET_IF(gcc_cv_objdump,, [
2920 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2921      && test -f ../binutils/Makefile \
2922      && test x$build = x$host; then
2923         # Single tree build which includes binutils.
2924         gcc_cv_objdump=../binutils/objdump$build_exeext
2925 elif test -x objdump$build_exeext; then
2926         gcc_cv_objdump=./objdump$build_exeext
2927 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2928         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2929 else
2930         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2931 fi])
2933 AC_MSG_CHECKING(what objdump to use)
2934 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2935         # Single tree build which includes binutils.
2936         AC_MSG_RESULT(newly built objdump)
2937 elif test x$gcc_cv_objdump = x; then
2938         AC_MSG_RESULT(not found)
2939 else
2940         AC_MSG_RESULT($gcc_cv_objdump)
2943 # Figure out what readelf we will be using.
2944 AS_VAR_SET_IF(gcc_cv_readelf,, [
2945 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2946      && test -f ../binutils/Makefile \
2947      && test x$build = x$host; then
2948         # Single tree build which includes binutils.
2949         gcc_cv_readelf=../binutils/readelf$build_exeext
2950 elif test -x readelf$build_exeext; then
2951         gcc_cv_readelf=./readelf$build_exeext
2952 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2953         gcc_cv_readelf="$READELF_FOR_TARGET"
2954 else
2955         AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2956 fi])
2958 AC_MSG_CHECKING(what readelf to use)
2959 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2960         # Single tree build which includes binutils.
2961         AC_MSG_RESULT(newly built readelf)
2962 elif test x$gcc_cv_readelf = x; then
2963         AC_MSG_RESULT(not found)
2964 else
2965         AC_MSG_RESULT($gcc_cv_readelf)
2968 # Figure out what otool we will be using.
2969 AS_VAR_SET_IF(gcc_cv_otool,, [
2970 if test -x otool$build_exeext; then
2971         gcc_cv_otool=./otool$build_exeext
2972 elif ( set dummy $OTOOL_FOR_TARGET; test -x $[2] ); then
2973         gcc_cv_otool="$OTOOL_FOR_TARGET"
2974 else
2975         AC_PATH_PROG(gcc_cv_otool, $OTOOL_FOR_TARGET)
2976 fi])
2978 AC_MSG_CHECKING(what otool to use)
2979 if test x$gcc_cv_otool = x; then
2980         AC_MSG_RESULT(not found)
2981 else
2982         AC_MSG_RESULT($gcc_cv_otool)
2985 # Figure out the dsymutil we will use.
2986 AS_VAR_SET_IF(gcc_cv_dsymutil,, [
2987 if test -x "$DEFAULT_DSYMUTIL"; then
2988     gcc_cv_dsymutil="$DEFAULT_DSYMUTIL"
2989 elif test -x dsymutil$build_exeext; then
2990     gcc_cv_dsymutil=./dsymutil$build_exeext
2991 elif ( set dummy $DSYMUTIL_FOR_TARGET; test -x $[2] ); then
2992     gcc_cv_dsymutil=$DSYMUTIL_FOR_TARGET
2993 elif ( set dummy $DSYMUTIL; test -x $[2] ); then
2994     gcc_cv_dsymutil=$DSYMUTIL
2995 else
2996     AC_PATH_PROG(gcc_cv_dsymutil, $DSYMUTIL_FOR_TARGET)
2997 fi])
2999 ORIGINAL_DSYMUTIL_FOR_TARGET=$gcc_cv_dsymutil
3000 AC_SUBST(ORIGINAL_DSYMUTIL_FOR_TARGET)
3001 case "$ORIGINAL_DSYMUTIL_FOR_TARGET" in
3002   ./dsymutil | ./dsymutil$build_exeext) ;;
3003   *) AC_CONFIG_FILES(dsymutil:exec-tool.in, [chmod +x dsymutil]) ;;
3004 esac 
3006 # Figure out what assembler alignment features are present.
3007 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,,
3008 [.balign 4
3009 .p2align 2],,
3010 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
3011   [Define if your assembler supports .balign and .p2align.])])
3013 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,,
3014  [.p2align 4,,7],,
3015 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
3016   [Define if your assembler supports specifying the maximum number
3017    of bytes to skip when using the GAS .p2align command.])])
3019 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,,
3020  [.literal16],,
3021 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
3022   [Define if your assembler supports .literal16.])])
3024 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,,
3025  [conftest_label1: .word 0
3026 .subsection -1
3027 conftest_label2: .word 0
3028 .previous],
3029  [if test x$gcc_cv_nm != x; then
3030     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
3031     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
3032     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
3033     then :
3034     else gcc_cv_as_subsection_m1=yes
3035     fi
3036     rm -f conftest.nm1 conftest.nm2
3037   fi],
3038  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
3039   [Define if your assembler supports .subsection and .subsection -1 starts
3040    emitting at the beginning of your section.])])
3042 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,,
3043  [      .weak foobar],,
3044 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
3046 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,,
3047  [      .weakref foobar, barfnot],,
3048 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
3050 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,,
3051  [      .SPACE $TEXT$
3052         .NSUBSPA $CODE$,COMDAT],,
3053 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
3055 # .hidden needs to be supported in both the assembler and the linker,
3056 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
3057 # This is irritatingly difficult to feature test for; we have to check the
3058 # date string after the version number.  If we've got an in-tree
3059 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
3060 # to be safe.
3061 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
3062 case "${target}" in
3063   *-*-aix*)
3064     conftest_s='        .globl foobar,hidden'
3065     ;;
3066   *)
3067     conftest_s='        .hidden foobar
3068 foobar:'
3069     ;;
3070 esac
3071 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,, [$conftest_s])
3072 case "${target}" in
3073   *-*-darwin*)
3074     # Darwin as has some visibility support, though with a different syntax.
3075     gcc_cv_as_hidden=yes
3076     ;;
3077 esac
3079 gcc_GAS_CHECK_FEATURE([.base64], gcc_cv_as_base64,,
3080  [      .section .rodata
3081         .base64 "Tm9uIHB1ZG9yIGVzdCBuaWwgc2NpcmUsIHB1ZG9yIG5pbCBkaXNjZXJlIHZlbGxlLgo="],,
3082 [AC_DEFINE(HAVE_GAS_BASE64, 1, [Define if your assembler supports .base64.])])
3084 gcc_GAS_CHECK_FEATURE([.cv_ucomp], gcc_cv_as_cv_ucomp,,[.cv_ucomp 0],,
3085 [AC_DEFINE(HAVE_GAS_CV_UCOMP, 1, [Define if your assembler supports .cv_ucomp.])])
3087 # gnu_indirect_function type is an extension proposed at
3088 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
3089 # selection of function implementation
3090 AC_ARG_ENABLE(gnu-indirect-function,
3091  [AS_HELP_STRING([--enable-gnu-indirect-function],
3092                  [enable the use of the @gnu_indirect_function to glibc systems])],
3093  [case $enable_gnu_indirect_function in
3094     yes | no) ;;
3095     *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
3096 Valid choices are 'yes' and 'no'.]) ;;
3097   esac],
3098  [enable_gnu_indirect_function="$default_gnu_indirect_function"])
3100 case "${target}" in
3101   riscv*-*-linux*)
3102     AC_MSG_CHECKING(linker ifunc IRELATIVE support)
3103     cat > conftest.s <<EOF
3104         .text
3105         .type   foo_resolver, @function
3106 foo_resolver:
3107         ret
3108         .size   foo_resolver, .-foo_resolver
3110         .globl  foo
3111         .type   foo, %gnu_indirect_function
3112         .set    foo, foo_resolver
3114         .globl  bar
3115         .type   bar, @function
3116 bar:
3117         call    foo
3118         ret
3119         .size   bar, .-bar
3121     if test x$gcc_cv_as != x \
3122        && test x$gcc_cv_ld != x \
3123        && test x$gcc_cv_readelf != x \
3124        && $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
3125        && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
3126        && $gcc_cv_readelf --relocs --wide conftest \
3127           | grep R_RISCV_IRELATIVE > /dev/null 2>&1; then
3128       enable_gnu_indirect_function=yes
3129     fi
3130     rm -f conftest conftest.o conftest.s
3131     AC_MSG_RESULT($enable_gnu_indirect_function)
3132     ;;
3133 esac
3135 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
3136 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
3137 [Define if your system supports gnu indirect functions.])
3140 changequote(,)dnl
3141 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
3142 if test $in_tree_ld != yes ; then
3143   if echo "$ld_ver" | grep GNU > /dev/null; then
3144     if test x"$ld_is_gold" = xyes; then
3145       # GNU gold --version looks like this:
3146       #
3147       # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
3148       #
3149       # We extract the binutils version which is more familiar and specific
3150       # than the gold version.
3151       ld_vers=`echo $ld_ver | sed -n \
3152           -e 's,^[^)]*[  ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3153     else
3154       # GNU ld --version looks like this:
3155       #
3156       # GNU ld (GNU Binutils) 2.21.51.20110225
3157       ld_vers=`echo $ld_ver | sed -n \
3158           -e 's,^.*[     ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3159     fi
3160     ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)\(-*\)\([01][0-9]\)\2\([0-3][0-9]\).*$,\1\3\4,p'`
3161     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3162     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3163     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
3164   else
3165     case "${target}" in
3166       *-*-solaris2*)
3167         # Solaris 2 ld -V output looks like this for a regular version:
3168         #
3169         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
3170         #
3171         # but test versions add stuff at the end:
3172         #
3173         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
3174         #
3175         # ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version
3176         # numbers can be used in ld.so.1 feature checks even if a different
3177         # linker is configured.
3178         ld_ver=`$gcc_cv_ld -V 2>&1`
3179         if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
3180           ld_vers=`echo $ld_ver | sed -n \
3181             -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
3182           ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3183           ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3184         fi
3185         ;;
3186     esac
3187   fi
3189 changequote([,])dnl
3191 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
3192 [[if test $in_tree_ld = yes ; then
3193   gcc_cv_ld_hidden=no
3194   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 13 -o "$gcc_cv_gld_major_version" -gt 2 \
3195      && test $in_tree_ld_is_elf = yes; then
3196      gcc_cv_ld_hidden=yes
3197   fi
3198 else
3199   gcc_cv_ld_hidden=yes
3200   if test x"$ld_is_gold" = xyes; then
3201     :
3202   elif test x"$ld_is_mold" = xyes; then
3203     :
3204   elif echo "$ld_ver" | grep GNU > /dev/null; then
3205     if test 0"$ld_date" -lt 20020404; then
3206       if test -n "$ld_date"; then
3207         # If there was date string, but was earlier than 2002-04-04, fail
3208         gcc_cv_ld_hidden=no
3209       elif test -z "$ld_vers"; then
3210         # If there was no date string nor ld version number, something is wrong
3211         gcc_cv_ld_hidden=no
3212       else
3213         test -z "$ld_vers_patch" && ld_vers_patch=0
3214         if test "$ld_vers_major" -lt 2; then
3215           gcc_cv_ld_hidden=no
3216         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
3217           gcc_cv_ld_hidden="no"
3218         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
3219           gcc_cv_ld_hidden=no
3220         fi
3221       fi
3222     fi
3223   else
3224     case "${target}" in
3225       *-*-aix[789]*)
3226         gcc_cv_ld_hidden=yes
3227         ;;
3228       *-*-darwin*)
3229         # Darwin ld has some visibility support.
3230         gcc_cv_ld_hidden=yes
3231         ;;
3232       hppa64*-*-hpux* | ia64*-*-hpux*)
3233         gcc_cv_ld_hidden=yes
3234         ;;
3235       *-*-solaris2*)
3236         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
3237         # .symbolic was only added in Solaris 9 12/02.
3238         gcc_cv_ld_hidden=yes
3239         ;;
3240       *)
3241         gcc_cv_ld_hidden=no
3242         ;;
3243     esac
3244   fi
3245 fi]])
3246 libgcc_visibility=no
3247 AC_SUBST(libgcc_visibility)
3248 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
3249 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
3250   libgcc_visibility=yes
3251   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
3252   [Define if your assembler and linker support .hidden.])
3255 AC_MSG_CHECKING(linker read-only and read-write section mixing)
3256 gcc_cv_ld_ro_rw_mix=unknown
3257 if test $in_tree_ld = yes ; then
3258   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 \
3259      && test $in_tree_ld_is_elf = yes; then
3260     gcc_cv_ld_ro_rw_mix=read-write
3261   fi
3262 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3263   echo '.section myfoosect, "a"' > conftest1.s
3264   echo '.section myfoosect, "aw"' > conftest2.s
3265   echo '.byte 1' >> conftest2.s
3266   echo '.section myfoosect, "a"' > conftest3.s
3267   echo '.byte 0' >> conftest3.s
3268   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
3269      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
3270      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1; then
3271     if $gcc_cv_ld -shared -o conftest1.so conftest1.o \
3272        conftest2.o conftest3.o > /dev/null 2>&1 \
3273        || $gcc_cv_ld -r -o conftest1.so conftest1.o \
3274           conftest2.o conftest3.o > /dev/null 2>&1; then
3275       gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
3276                            | sed -e '/myfoosect/!d' -e N`
3277       if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
3278         if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
3279           gcc_cv_ld_ro_rw_mix=read-only
3280         else
3281           gcc_cv_ld_ro_rw_mix=read-write
3282         fi
3283       fi
3284     fi
3285   fi
3286 changequote(,)dnl
3287   rm -f conftest.* conftest[123].*
3288 changequote([,])dnl
3290 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
3291         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
3292   [Define if your linker links a mix of read-only
3293    and read-write sections into a read-write section.])
3295 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
3297 gcc_AC_INITFINI_ARRAY
3299 # Some assemblers (GNU as for LoongArch) generates relocations for
3300 # leb128 symbol arithmetic for relaxation, we need to disable relaxation
3301 # probing leb128 support then.
3302 case $target in
3303   loongarch*-*-*)
3304     gcc_GAS_CHECK_FEATURE([-mno-relax support],
3305       gcc_cv_as_mno_relax,[-mno-relax],[.text],,
3306       [check_leb128_asflags=-mno-relax])
3307     ;;
3308   *)
3309     check_leb128_asflags=
3310     ;;
3311 esac
3313 # Check if we have .[us]leb128, and support symbol arithmetic with it.
3314 # Older versions of GAS and some non-GNU assemblers, have a bugs handling
3315 # these directives, even when they appear to accept them.
3316 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
3317 [$check_leb128_asflags],
3318 [       .data
3319         .uleb128 L2 - L1
3321         .uleb128 1280
3322         .sleb128 -1010
3324         .uleb128 0x8000000000000000
3327 if test "x$gcc_cv_objdump" != x; then
3328   if $gcc_cv_objdump -s conftest.o 2>/dev/null \
3329      | grep '04800a8e 78808080 80808080 808001' >/dev/null; then
3330     gcc_cv_as_leb128=yes
3331   fi
3332 elif test "x$gcc_cv_otool" != x; then
3333   if $gcc_cv_otool -d conftest.o 2>/dev/null \
3334      | grep '04 80 0a 8e 78 80 80 80 80 80 80 80 80 80 01' >/dev/null; then
3335     gcc_cv_as_leb128=yes
3336   fi
3337 else
3338   # play safe, assume the assembler is broken.
3339   :
3342  [AC_DEFINE(HAVE_AS_LEB128, 1,
3343    [Define if your assembler supports .sleb128 and .uleb128.])],
3344  [AC_DEFINE(HAVE_AS_LEB128, 0,
3345    [Define if your assembler supports .sleb128 and .uleb128.])])
3347 # Determine if an .eh_frame section is read-only.
3348 gcc_fn_eh_frame_ro () {
3349   $gcc_cv_as $1 -o conftest.o conftest.s > /dev/null 2>&1 && \
3350     $gcc_cv_objdump -h conftest.o 2>/dev/null | \
3351     sed -e '/.eh_frame/!d' -e N | grep READONLY > /dev/null
3354 # Check if we have assembler support for unwind directives.
3355 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,,
3356 [       .text
3357         .cfi_startproc
3358         .cfi_offset 0, 0
3359         .cfi_same_value 1
3360         .cfi_def_cfa 1, 2
3361         .cfi_escape 1, 2, 3, 4, 5
3362         .cfi_endproc],
3363 [case "$target" in
3364   *-*-solaris*)
3365     # If the linker used on Solaris (like Sun ld) isn't capable of merging
3366     # read-only and read-write sections, we need to make sure that the
3367     # assembler used emits read-write .eh_frame sections.
3368     if test "x$gcc_cv_ld_ro_rw_mix" = xread-write; then
3369       gcc_cv_as_cfi_directive=yes
3370     elif test "x$gcc_cv_objdump" = x; then
3371       # No objdump, err on the side of caution.
3372       gcc_cv_as_cfi_directive=no
3373     else
3374       if test x$gas = xyes; then
3375         as_32_opt="--32"
3376         as_64_opt="--64"
3377       else
3378         as_32_opt="-m32"
3379         as_64_opt="-m64"
3380       fi
3381       case "$target" in
3382         sparc*-*-solaris2.*)
3383           # On Solaris/SPARC, .eh_frame sections should always be read-write.
3384           if gcc_fn_eh_frame_ro $as_32_opt \
3385              || gcc_fn_eh_frame_ro $as_64_opt; then
3386             gcc_cv_as_cfi_directive=no
3387           else
3388             gcc_cv_as_cfi_directive=yes
3389           fi
3390           ;;
3391         i?86-*-solaris2.* | x86_64-*-solaris2.*)
3392           # On Solaris/x86, make sure that GCC and assembler agree on using
3393           # read-only .eh_frame sections for 64-bit.
3394           if gcc_fn_eh_frame_ro $as_32_opt; then
3395             gcc_cv_as_cfi_directive=no
3396           elif gcc_fn_eh_frame_ro $as_64_opt; then
3397             gcc_cv_as_cfi_directive=yes
3398           else
3399             gcc_cv_as_cfi_directive=no
3400           fi
3401           ;;
3402       esac
3403     fi
3404     ;;
3405   *-*-*)
3406     gcc_cv_as_cfi_directive=yes
3407     ;;
3408 esac])
3409 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
3410 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,,
3411 [       .text
3412         .cfi_startproc
3413         .cfi_adjust_cfa_offset 64
3414         .skip 75040, 0
3415         .cfi_adjust_cfa_offset 128
3416         .cfi_endproc],
3418 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
3419     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
3420    gcc_cv_as_cfi_advance_working=yes
3423 else
3424   # no objdump, err on the side of caution
3425   gcc_cv_as_cfi_advance_working=no
3427 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
3428 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
3429   [`if test $gcc_cv_as_cfi_directive = yes \
3430        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
3431   [Define 0/1 if your assembler supports CFI directives.])
3433 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
3434 gcc_GAS_CHECK_FEATURE([cfi personality directive],
3435   gcc_cv_as_cfi_personality_directive,,
3436 [       .text
3437         .cfi_startproc
3438         .cfi_personality 0, symbol
3439         .cfi_endproc])
3440 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
3441   [`if test $gcc_cv_as_cfi_personality_directive = yes; then echo 1; else echo 0; fi`],
3442   [Define 0/1 if your assembler supports .cfi_personality.])
3444 gcc_GAS_CHECK_FEATURE([cfi sections directive],
3445   gcc_cv_as_cfi_sections_directive,,
3446 [       .text
3447         .cfi_sections .debug_frame, .eh_frame
3448         .cfi_startproc
3449         .cfi_endproc],
3450 [case $target_os in
3451   win32 | pe | cygwin* | mingw32*)
3452     # Need to check that we generated the correct relocation for the
3453     # .debug_frame section.  This was fixed for binutils 2.21.
3454     gcc_cv_as_cfi_sections_directive=no
3455     if test "x$gcc_cv_objdump" != x; then
3456      if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
3457         grep -i secrel > /dev/null; then
3458       gcc_cv_as_cfi_sections_directive=yes
3459      fi
3460     fi
3461     ;;
3462   *)
3463     gcc_cv_as_cfi_sections_directive=yes
3464     ;;
3465 esac])
3466 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
3467 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
3468   [`if test $gcc_cv_as_cfi_sections_directive = yes; then echo 1; else echo 0; fi`],
3469   [Define 0/1 if your assembler supports .cfi_sections.])
3471 # GAS versions up to and including 2.11.0 may mis-optimize
3472 # .eh_frame data.
3473 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,,
3474 [       .text
3475 .LFB1:
3476         .4byte  0
3477 .L1:
3478         .4byte  0
3479 .LFE1:
3480         .section        .eh_frame,"aw",@progbits
3481 __FRAME_BEGIN__:
3482         .4byte  .LECIE1-.LSCIE1
3483 .LSCIE1:
3484         .4byte  0x0
3485         .byte   0x1
3486         .ascii "z\0"
3487         .byte   0x1
3488         .byte   0x78
3489         .byte   0x1a
3490         .byte   0x0
3491         .byte   0x4
3492         .4byte  1
3493         .p2align 1
3494 .LECIE1:
3495 .LSFDE1:
3496         .4byte  .LEFDE1-.LASFDE1
3497 .LASFDE1:
3498         .4byte  .LASFDE1-__FRAME_BEGIN__
3499         .4byte  .LFB1
3500         .4byte  .LFE1-.LFB1
3501         .byte   0x4
3502         .4byte  .LFE1-.LFB1
3503         .byte   0x4
3504         .4byte  .L1-.LFB1
3505 .LEFDE1:],
3506 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
3507 cat > conftest.lit <<EOF
3508  0000 10000000 00000000 017a0001 781a0004  .........z..x...
3509  0010 01000000 12000000 18000000 00000000  ................
3510  0020 08000000 04080000 0044               .........D      @&t@
3512 cat > conftest.big <<EOF
3513  0000 00000010 00000000 017a0001 781a0004  .........z..x...
3514  0010 00000001 00000012 00000018 00000000  ................
3515  0020 00000008 04000000 0844               .........D      @&t@
3517   # If the assembler didn't choke, and we can objdump,
3518   # and we got the correct data, then succeed.
3519   # The text in the here-document typically retains its unix-style line
3520   # endings, while the output of objdump will use host line endings.
3521   # Therefore, use diff -b for the comparisons.
3522   if test x$gcc_cv_objdump != x \
3523   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
3524      | tail -3 > conftest.got \
3525   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
3526     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
3527   then
3528     gcc_cv_as_eh_frame=yes
3529   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
3530     gcc_cv_as_eh_frame=buggy
3531   else
3532     # Uh oh, what do we do now?
3533     gcc_cv_as_eh_frame=no
3534   fi])
3536 if test $gcc_cv_as_eh_frame = buggy; then
3537   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
3538   [Define if your assembler mis-optimizes .eh_frame data.])
3541 # Test if the assembler supports the section flag 'e' or #exclude for
3542 # specifying an excluded section.
3543 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_e,
3544  [--fatal-warnings],
3545  [.section foo1,"e"
3546   .byte 0,0,0,0])
3547 if test $gcc_cv_as_section_exclude_e = no; then
3548   case "${target}" in
3549     # Solaris as uses #exclude instead.
3550     *-*-solaris2*)
3551       case "${target}" in
3552         sparc*-*-solaris2*)
3553           conftest_s='.section "foo1", #exclude'
3554           ;;
3555         i?86-*-solaris2* | x86_64-*-solaris2*)
3556           conftest_s='.section foo1, #exclude'
3557           ;;      
3558       esac
3559       ;;
3560     esac
3561   gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_hash,,
3562     [$conftest_s
3563      .byte 0,0,0,0])
3565 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3566   [`if test $gcc_cv_as_section_exclude_e = yes || test $gcc_cv_as_section_exclude_hash = yes; then echo 1; else echo 0; fi`],
3567 [Define if your assembler supports specifying the exclude section flag.])
3569 # Test if the assembler supports the section flag 'R' for specifying
3570 # section with SHF_GNU_RETAIN.
3571 case "${target}" in
3572   # Solaris may use GNU assembler with Solairs ld.  Even if GNU
3573   # assembler supports the section flag 'R', it doesn't mean that
3574   # Solairs ld supports it.
3575   *-*-solaris2*)
3576     gcc_cv_as_shf_gnu_retain=no
3577     ;;
3578   *)
3579     gcc_GAS_CHECK_FEATURE([section 'R' flag], gcc_cv_as_shf_gnu_retain,
3580       [--fatal-warnings],
3581       [.section .foo,"awR",%progbits
3582 .byte 0])
3583     ;;
3584 esac
3585 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_GNU_RETAIN,
3586   [`if test $gcc_cv_as_shf_gnu_retain = yes; then echo 1; else echo 0; fi`],
3587   [Define 0/1 if your assembler supports marking sections with SHF_GNU_RETAIN flag.])
3589 # Test if the assembler supports the section flag 'o' for specifying
3590 # section with link-order.
3591 case "${target}" in
3592   # Solaris may use GNU assembler with Solairs ld.  Even if GNU
3593   # assembler supports the section flag 'o', it doesn't mean that
3594   # Solairs ld supports it.
3595   *-*-solaris2*)
3596     gcc_cv_as_section_link_order=no
3597     ;;
3598   *)
3599     gcc_GAS_CHECK_FEATURE([section 'o' flag], gcc_cv_as_section_link_order,
3600       [--fatal-warnings],
3601       [.section .foo,"a"
3602 .byte 0
3603 .section __patchable_function_entries,"awo",%progbits,.foo
3604 .byte 0])
3605     ;;
3606 esac
3607 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_LINK_ORDER,
3608   [`if test $gcc_cv_as_section_link_order = yes; then echo 1; else echo 0; fi`],
3609   [Define 0/1 if your assembler supports 'o' flag in .section directive.])
3611 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3612  [--fatal-warnings],
3613  [.section .rodata.str, "aMS", @progbits, 1])
3614 if test $gcc_cv_as_shf_merge = no; then
3615   gcc_GAS_CHECK_FEATURE(section merging support (%progbits),
3616     gcc_cv_as_shf_merge_percent,
3617     [--fatal-warnings],
3618     [.section .rodata.str, "aMS", %progbits, 1])
3620 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
3621   [`if test $gcc_cv_as_shf_merge = yes \
3622     || test $gcc_cv_as_shf_merge_percent = yes; then echo 1; else echo 0; fi`],
3623 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
3625 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
3626  gcc_cv_as_comdat_group,
3627  [--fatal-warnings],
3628  [.section .text,"axG",@progbits,.foo,comdat])
3629 if test $gcc_cv_as_comdat_group = yes; then
3630   gcc_cv_as_comdat_group_percent=no
3631   gcc_cv_as_comdat_group_group=no
3632 else
3633  gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
3634    gcc_cv_as_comdat_group_percent,
3635    [--fatal-warnings],
3636    [.section .text,"axG",%progbits,.foo,comdat])
3637  if test $gcc_cv_as_comdat_group_percent = yes; then
3638    gcc_cv_as_comdat_group_group=no
3639  else
3640    case "${target}" in
3641      # Sun as uses a completely different syntax.
3642      *-*-solaris2*)
3643        case "${target}" in
3644          sparc*-*-solaris2*)
3645            conftest_s='
3646                .group foo,".text%foo",#comdat
3647                .section ".text%foo", #alloc,#execinstr,#progbits
3648                .globl foo
3649              foo:
3650              '
3651            ;;
3652          i?86-*-solaris2* | x86_64-*-solaris2*)
3653            conftest_s='
3654                .group foo,.text%foo,#comdat
3655                .section .text%foo, "ax", @progbits
3656                .globl  foo
3657              foo:
3658              '
3659            ;;
3660        esac
3661        gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
3662          gcc_cv_as_comdat_group_group,
3663          , [$conftest_s])
3664        ;;
3665    esac
3666    if test -z "${gcc_cv_as_comdat_group_group+set}"; then
3667      gcc_cv_as_comdat_group_group=no
3668    fi
3669  fi
3671 if test x"$ld_is_gold" = xyes; then
3672   comdat_group=yes
3673 elif test x"$ld_is_mold" = xyes; then
3674   comdat_group=yes
3675 elif test $in_tree_ld = yes ; then
3676   comdat_group=no
3677   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
3678      && test $in_tree_ld_is_elf = yes; then
3679      comdat_group=yes
3680   fi
3681 elif echo "$ld_ver" | grep GNU > /dev/null; then
3682   comdat_group=yes
3683   if test 0"$ld_date" -lt 20050308; then
3684     if test -n "$ld_date"; then
3685       # If there was date string, but was earlier than 2005-03-08, fail
3686       comdat_group=no
3687     elif test "$ld_vers_major" -lt 2; then
3688       comdat_group=no
3689     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
3690       comdat_group=no
3691     fi
3692   fi
3693 else
3694 changequote(,)dnl
3695   case "${target}" in
3696     *-*-solaris2.1[1-9]*)
3697       comdat_group=no
3698       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
3699       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
3700       # version 1.688.
3701       #
3702       # If using Sun as for COMDAT group as emitted by GCC, one needs at
3703       # least ld version 1.2267.
3704       if test "$ld_vers_major" -gt 1; then
3705         comdat_group=yes
3706       elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
3707         comdat_group=yes
3708       elif test "$ld_vers_minor" -ge 2267; then
3709         comdat_group=yes
3710       fi
3711       ;;
3712     *)
3713       # Assume linkers other than GNU ld don't support COMDAT group.
3714       comdat_group=no
3715       ;;
3716   esac
3717 changequote([,])dnl
3719 # Allow overriding the automatic COMDAT group tests above.
3720 AC_ARG_ENABLE(comdat,
3721   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
3722   [comdat_group="$enable_comdat"])
3723 if test $comdat_group = no; then
3724   gcc_cv_as_comdat_group=no
3725   gcc_cv_as_comdat_group_percent=no
3726   gcc_cv_as_comdat_group_group=no
3728 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
3729   [`if test $gcc_cv_as_comdat_group = yes \
3730     || test $gcc_cv_as_comdat_group_percent = yes \
3731     || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
3732 [Define 0/1 if your assembler and linker support COMDAT groups.])
3734 gcc_GAS_CHECK_FEATURE([line table is_stmt support],
3735  gcc_cv_as_is_stmt,,
3736 [       .text
3737         .file 1 "conf.c"
3738         .loc 1 1 0 is_stmt 1],,
3739 [AC_DEFINE(HAVE_GAS_LOC_STMT, 1,
3740   [Define if your assembler supports the .loc is_stmt sub-directive.])])
3742 gcc_GAS_CHECK_FEATURE([line table discriminator support],
3743  gcc_cv_as_discriminator,,
3744 [       .text
3745         .file 1 "conf.c"
3746         .loc 1 1 0 discriminator 1],,
3747 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
3748   [Define if your assembler supports the .loc discriminator sub-directive.])])
3750 # Catch the newlib flag of the same name so we can gate GCC features on it.
3751 AC_ARG_ENABLE(newlib-nano-formatted-io,
3752 [AS_HELP_STRING([--enable-newlib-nano-formatted-io], [Use nano version
3753  formatted IO])],
3754 [case "${enableval}" in
3755   yes|no)
3756     ;;
3757   *)
3758     AC_MSG_ERROR([unknown newlib-nano-formatted-io setting $enableval])
3759     ;;
3760 esac], [])
3762 # Thread-local storage - the check is heavily parameterized.
3763 conftest_s=
3764 tls_as_opt=
3765 case "$target" in
3766 changequote(,)dnl
3767   alpha*-*-*)
3768     conftest_s='
3769         .section ".tdata","awT",@progbits
3770 foo:    .long   25
3771         .text
3772         ldq     $27,__tls_get_addr($29)         !literal!1
3773         lda     $16,foo($29)                    !tlsgd!1
3774         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
3775         ldq     $27,__tls_get_addr($29)         !literal!2
3776         lda     $16,foo($29)                    !tlsldm!2
3777         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
3778         ldq     $1,foo($29)                     !gotdtprel
3779         ldah    $2,foo($29)                     !dtprelhi
3780         lda     $3,foo($2)                      !dtprello
3781         lda     $4,foo($29)                     !dtprel
3782         ldq     $1,foo($29)                     !gottprel
3783         ldah    $2,foo($29)                     !tprelhi
3784         lda     $3,foo($2)                      !tprello
3785         lda     $4,foo($29)                     !tprel'
3786         tls_as_opt=--fatal-warnings
3787         ;;
3788   arc*-*-*)
3789     conftest_s='
3790         add_s r0,r0, @foo@tpoff'
3791         ;;
3792   cris-*-*|crisv32-*-*)
3793     conftest_s='
3794         .section ".tdata","awT",@progbits
3795 x:      .long   25
3796         .text
3797         move.d x:IE,$r10
3798         nop'
3799         tls_as_opt=--fatal-warnings
3800         ;;
3801   frv*-*-*)
3802     conftest_s='
3803         .section ".tdata","awT",@progbits
3804 x:      .long   25
3805         .text
3806         call    #gettlsoff(x)'
3807         ;;
3808   hppa*-*-linux*)
3809     conftest_s='
3810 t1:     .reg    %r20
3811 t2:     .reg    %r21
3812 gp:     .reg    %r19
3813         .section ".tdata","awT",@progbits
3814 foo:    .long   25
3815         .text
3816         .align  4
3817         addil LT%foo-$tls_gdidx$,gp
3818         ldo RT%foo-$tls_gdidx$(%r1),%arg0
3819         b __tls_get_addr
3820         nop             
3821         addil LT%foo-$tls_ldidx$,gp
3822         b __tls_get_addr
3823         ldo RT%foo-$tls_ldidx$(%r1),%arg0
3824         addil LR%foo-$tls_dtpoff$,%ret0
3825         ldo RR%foo-$tls_dtpoff$(%r1),%t1
3826         mfctl %cr27,%t1                 
3827         addil LT%foo-$tls_ieoff$,gp
3828         ldw RT%foo-$tls_ieoff$(%r1),%t2
3829         add %t1,%t2,%t3                 
3830         mfctl %cr27,%t1                 
3831         addil LR%foo-$tls_leoff$,%t1
3832         ldo RR%foo-$tls_leoff$(%r1),%t2'
3833         tls_as_opt=--fatal-warnings
3834         ;;
3835   arm*-*-*)
3836     conftest_s='
3837         .section ".tdata","awT",%progbits
3838 foo:    .long   25
3839         .text
3840 .word foo(gottpoff)
3841 .word foo(tpoff)
3842 .word foo(tlsgd)
3843 .word foo(tlsldm)
3844 .word foo(tlsldo)'
3845         ;;
3846   i[34567]86-*-* | x86_64-*-*)
3847     case "$target" in
3848       i[34567]86-*-solaris2.* | x86_64-*-solaris2.*)
3849         on_solaris=yes
3850         ;;
3851       *)
3852         on_solaris=no
3853         ;;
3854     esac
3855     if test x$on_solaris = xyes && test x$gas_flag = xno; then
3856       conftest_s='
3857         .section .tdata,"awt",@progbits'
3858       tls_section_flag=t
3859 changequote([,])dnl
3860       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3861 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3862 changequote(,)dnl
3863     else
3864       conftest_s='
3865         .section ".tdata","awT",@progbits'
3866       tls_section_flag=T
3867       tls_as_opt="--fatal-warnings"
3868     fi
3869     case "$target" in
3870       i[34567]86-*-*)
3871         if test x$on_solaris = xyes; then
3872           case $gas_flag in
3873             yes) tls_as_opt="$tls_as_opt --32" ;;
3874           esac
3875         fi
3876         conftest_s="$conftest_s
3877 foo:    .long   25
3878         .text
3879         movl    %gs:0, %eax
3880         leal    foo@tlsgd(,%ebx,1), %eax
3881         leal    foo@tlsldm(%ebx), %eax
3882         leal    foo@dtpoff(%eax), %edx
3883         movl    foo@gottpoff(%ebx), %eax
3884         subl    foo@gottpoff(%ebx), %eax
3885         addl    foo@gotntpoff(%ebx), %eax
3886         movl    foo@indntpoff, %eax
3887         movl    \$foo@tpoff, %eax
3888         subl    \$foo@tpoff, %eax
3889         leal    foo@ntpoff(%ecx), %eax"
3890         ;;
3891       x86_64-*-*)
3892         if test x$on_solaris = xyes; then
3893           case $gas_flag in
3894             yes) tls_as_opt="$tls_as_opt --64" ;;
3895             no)  tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3896           esac    
3897         fi
3898         conftest_s="$conftest_s
3899 foo:    .long   25
3900         .text
3901         movq    %fs:0, %rax
3902         leaq    foo@tlsgd(%rip), %rdi
3903         leaq    foo@tlsld(%rip), %rdi
3904         leaq    foo@dtpoff(%rax), %rdx
3905         movq    foo@gottpoff(%rip), %rax
3906         movq    \$foo@tpoff, %rax"
3907         ;;
3908     esac
3909     ;;
3910   ia64-*-*)
3911     conftest_s='
3912         .section ".tdata","awT",@progbits
3913 foo:    data8   25
3914         .text
3915         addl    r16 = @ltoff(@dtpmod(foo#)), gp
3916         addl    r17 = @ltoff(@dtprel(foo#)), gp
3917         addl    r18 = @ltoff(@tprel(foo#)), gp
3918         addl    r19 = @dtprel(foo#), gp
3919         adds    r21 = @dtprel(foo#), r13
3920         movl    r23 = @dtprel(foo#)
3921         addl    r20 = @tprel(foo#), gp
3922         adds    r22 = @tprel(foo#), r13
3923         movl    r24 = @tprel(foo#)'
3924         tls_as_opt=--fatal-warnings
3925         ;;
3926   loongarch*-*-*)
3927     conftest_s='
3928         .section .tdata,"awT",@progbits
3929 x:      .word 2
3930         .text
3931         la.tls.gd $a0,x
3932         bl __tls_get_addr'
3933         tls_first_major=0
3934         tls_first_minor=0
3935         tls_as_opt='--fatal-warnings'
3936         ;;
3937   microblaze*-*-*)
3938     conftest_s='
3939         .section .tdata,"awT",@progbits
3941         .word 2
3942         .text
3943         addik r5,r20,x@TLSGD
3944         addik r5,r20,x@TLSLDM'
3945         tls_as_opt='--fatal-warnings'
3946         ;;
3947   mips*-*-*)
3948     conftest_s='
3949         .section .tdata,"awT",@progbits
3951         .word 2
3952         .text
3953         addiu $4, $28, %tlsgd(x)
3954         addiu $4, $28, %tlsldm(x)
3955         lui $4, %dtprel_hi(x)
3956         addiu $4, $4, %dtprel_lo(x)
3957         lw $4, %gottprel(x)($28)
3958         lui $4, %tprel_hi(x)
3959         addiu $4, $4, %tprel_lo(x)'
3960         tls_as_opt='-32 --fatal-warnings'
3961         ;;
3962   m68k-*-*)
3963     conftest_s='
3964         .section .tdata,"awT",@progbits
3966         .word 2
3967         .text
3968 foo:
3969         move.l x@TLSGD(%a5),%a0
3970         move.l x@TLSLDM(%a5),%a0
3971         move.l x@TLSLDO(%a5),%a0
3972         move.l x@TLSIE(%a5),%a0
3973         move.l x@TLSLE(%a5),%a0'
3974         tls_as_opt='--fatal-warnings'
3975         ;;
3976   aarch64*-*-*)
3977     conftest_s='
3978         .section ".tdata","awT",%progbits
3979 foo:    .long   25
3980         .text
3981         adrp  x0, :tlsgd:x
3982         add   x0, x0, #:tlsgd_lo12:x
3983         bl    __tls_get_addr
3984         nop'
3985         tls_as_opt='--fatal-warnings'
3986         ;;
3987   or1k*-*-*)
3988     conftest_s='
3989         .section ".tdata","awT",@progbits
3990 foo:    .long   25
3991         .text
3992         l.movhi r3, tpoffha(foo)
3993         l.add   r3, r3, r10
3994         l.lwz   r4, tpofflo(foo)(r3)'
3995     tls_as_opt=--fatal-warnings
3996     ;;
3997   powerpc-ibm-aix*)
3998     conftest_s='
3999         .extern __get_tpointer
4000         .toc
4001 LC..1:
4002         .tc a[TC],a[TL]@le
4003         .csect .text[PR]
4004 .tlstest:
4005         lwz 9,LC..1(2)
4006         bla __get_tpointer
4007         lwzx 3,9,3
4008         .globl a
4009         .csect a[TL],4
4011         .space 4'
4012         ;;
4013   powerpc64*-*-*)
4014     conftest_s='
4015         .section ".tdata","awT",@progbits
4016         .align 3
4017 ld0:    .space 8
4018 ld1:    .space 8
4019 x1:     .space 8
4020 x2:     .space 8
4021 x3:     .space 8
4022         .text
4023         addi 3,2,ld0@got@tlsgd
4024         bl .__tls_get_addr
4025         nop
4026         addi 3,2,ld1@toc
4027         bl .__tls_get_addr
4028         nop
4029         addi 3,2,x1@got@tlsld
4030         bl .__tls_get_addr
4031         nop
4032         addi 9,3,x1@dtprel
4033         bl .__tls_get_addr
4034         nop
4035         addis 9,3,x2@dtprel@ha
4036         addi 9,9,x2@dtprel@l
4037         bl .__tls_get_addr
4038         nop
4039         ld 9,x3@got@dtprel(2)
4040         add 9,9,3
4041         bl .__tls_get_addr
4042         nop'
4043         tls_as_opt="-a64 --fatal-warnings"
4044         ;;
4045   powerpc*-*-*)
4046     conftest_s='
4047         .section ".tdata","awT",@progbits
4048         .align 2
4049 ld0:    .space 4
4050 ld1:    .space 4
4051 x1:     .space 4
4052 x2:     .space 4
4053 x3:     .space 4
4054         .text
4055         addi 3,31,ld0@got@tlsgd
4056         bl __tls_get_addr
4057         addi 3,31,x1@got@tlsld
4058         bl __tls_get_addr
4059         addi 9,3,x1@dtprel
4060         addis 9,3,x2@dtprel@ha
4061         addi 9,9,x2@dtprel@l
4062         lwz 9,x3@got@tprel(31)
4063         add 9,9,x@tls
4064         addi 9,2,x1@tprel
4065         addis 9,2,x2@tprel@ha
4066         addi 9,9,x2@tprel@l'
4067         tls_as_opt="-a32 --fatal-warnings"
4068         ;;
4069   riscv*-*-*)
4070     conftest_s='
4071         .section .tdata,"awT",@progbits
4072 x:      .word 2
4073         .text
4074         la.tls.gd a0,x
4075         call __tls_get_addr'
4076         tls_as_opt='--fatal-warnings'
4077         ;;
4078   s390-*-*)
4079     conftest_s='
4080         .section ".tdata","awT",@progbits
4081 foo:    .long   25
4082         .text
4083         .long   foo@TLSGD
4084         .long   foo@TLSLDM
4085         .long   foo@DTPOFF
4086         .long   foo@NTPOFF
4087         .long   foo@GOTNTPOFF
4088         .long   foo@INDNTPOFF
4089         l       %r1,foo@GOTNTPOFF(%r12)
4090         l       %r1,0(%r1):tls_load:foo
4091         bas     %r14,0(%r1,%r13):tls_gdcall:foo
4092         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
4093         tls_as_opt="-m31 --fatal-warnings"
4094         ;;
4095   s390x-*-*)
4096     conftest_s='
4097         .section ".tdata","awT",@progbits
4098 foo:    .long   25
4099         .text
4100         .quad   foo@TLSGD
4101         .quad   foo@TLSLDM
4102         .quad   foo@DTPOFF
4103         .quad   foo@NTPOFF
4104         .quad   foo@GOTNTPOFF
4105         lg      %r1,foo@GOTNTPOFF(%r12)
4106         larl    %r1,foo@INDNTPOFF
4107         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
4108         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
4109         tls_as_opt="-m64 -Aesame --fatal-warnings"
4110         ;;
4111   sh-*-* | sh[123456789lbe]*-*-*)
4112     conftest_s='
4113         .section ".tdata","awT",@progbits
4114 foo:    .long   25
4115         .text
4116         .long   foo@TLSGD
4117         .long   foo@TLSLDM
4118         .long   foo@DTPOFF
4119         .long   foo@GOTTPOFF
4120         .long   foo@TPOFF'
4121         tls_as_opt=--fatal-warnings
4122         ;;
4123   sparc*-*-*)
4124     case "$target" in
4125       sparc*-sun-solaris2.*)
4126         on_solaris=yes
4127         ;;
4128       *)
4129         on_solaris=no
4130         ;;
4131     esac
4132     if test x$on_solaris = xyes && test x$gas_flag = xno; then
4133       conftest_s='
4134         .section ".tdata",#alloc,#write,#tls'
4135     else
4136       conftest_s='
4137         .section ".tdata","awT",@progbits'
4138         tls_as_opt="-32 --fatal-warnings"
4139     fi
4140     conftest_s="$conftest_s
4141 foo:    .long   25
4142         .text
4143         sethi   %tgd_hi22(foo), %o0
4144         add     %o0, %tgd_lo10(foo), %o1
4145         add     %l7, %o1, %o0, %tgd_add(foo)
4146         call    __tls_get_addr, %tgd_call(foo)
4147         sethi   %tldm_hi22(foo), %l1
4148         add     %l1, %tldm_lo10(foo), %l2
4149         add     %l7, %l2, %o0, %tldm_add(foo)
4150         call    __tls_get_addr, %tldm_call(foo)
4151         sethi   %tldo_hix22(foo), %l3
4152         xor     %l3, %tldo_lox10(foo), %l4
4153         add     %o0, %l4, %l5, %tldo_add(foo)
4154         sethi   %tie_hi22(foo), %o3
4155         add     %o3, %tie_lo10(foo), %o3
4156         ld      [%l7 + %o3], %o2, %tie_ld(foo)
4157         add     %g7, %o2, %o4, %tie_add(foo)
4158         sethi   %tle_hix22(foo), %l1
4159         xor     %l1, %tle_lox10(foo), %o5
4160         ld      [%g7 + %o5], %o1"
4161         ;;
4162   xtensa*-*-*)
4163     conftest_s='
4164         .section ".tdata","awT",@progbits
4165 foo:    .long   25
4166         .text
4167         movi    a8, foo@TLSFUNC
4168         movi    a10, foo@TLSARG
4169         callx8.tls a8, foo@TLSCALL'
4170         ;;
4171 changequote([,])dnl
4172 esac
4173 set_have_as_tls=no
4174 if test "x$enable_tls" = xno ; then
4175   : # TLS explicitly disabled.
4176 elif test "x$enable_tls" = xyes ; then
4177   set_have_as_tls=yes # TLS explicitly enabled.
4178 elif test -z "$conftest_s"; then
4179   : # If we don't have a check, assume no support.
4180 else
4181   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
4182   [$tls_as_opt], [$conftest_s],,
4183   [set_have_as_tls=yes])
4185 if test $set_have_as_tls = yes ; then
4186   AC_DEFINE(HAVE_AS_TLS, 1,
4187             [Define if your assembler and linker support thread-local storage.])
4190 # Target-specific assembler checks.
4192 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
4193 gcc_cv_ld_static_dynamic=no
4194 gcc_cv_ld_static_option='-Bstatic'
4195 gcc_cv_ld_dynamic_option='-Bdynamic'
4196 if test $in_tree_ld = yes ; then
4197   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2; then
4198     gcc_cv_ld_static_dynamic=yes
4199   fi
4200 elif test x$gcc_cv_ld != x; then
4201   # Check if linker supports -Bstatic/-Bdynamic option
4202   if $gcc_cv_ld --help 2>&1 | grep -- -Bstatic > /dev/null \
4203      && $gcc_cv_ld --help 2>&1 | grep -- -Bdynamic > /dev/null; then
4204       gcc_cv_ld_static_dynamic=yes
4205   else
4206     case "$target" in
4207       # AIX ld uses -b flags
4208       *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
4209         gcc_cv_ld_static_dynamic=yes
4210         gcc_cv_ld_static_option="-bstatic"
4211         gcc_cv_ld_dynamic_option="-bdynamic"
4212         ;;
4213       # HP-UX ld uses -a flags to select between shared and archive.
4214       *-*-hpux*)
4215         if test x"$gnu_ld" = xno; then
4216           gcc_cv_ld_static_dynamic=yes
4217           gcc_cv_ld_static_option="-aarchive_shared"
4218           gcc_cv_ld_dynamic_option="-adefault"
4219         fi
4220         ;;
4221       # Solaris 2 ld always supports -Bstatic/-Bdynamic.
4222       *-*-solaris2*)
4223         gcc_cv_ld_static_dynamic=yes
4224         ;;
4225     esac
4226   fi
4228 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
4229         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
4230 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
4231         AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
4232 [Define to the linker option to disable use of shared objects.])
4233         AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
4234 [Define to the linker option to enable use of shared objects.])
4236 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
4238 AC_MSG_CHECKING(linker --version-script option)
4239 gcc_cv_ld_version_script=no
4240 ld_version_script_option=''
4241 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4242   gcc_cv_ld_version_script=yes
4243   ld_version_script_option='--version-script'
4244 elif test x$gcc_cv_ld != x; then
4245   case "$target" in
4246     # Solaris 2 ld always supports -M.  It also supports a subset of
4247     # --version-script since Solaris 11.4, but requires
4248     # -z gnu-version-script-compat to activate.
4249     *-*-solaris2*)
4250       gcc_cv_ld_version_script=yes
4251       ld_version_script_option='-M'
4252       ;;
4253   esac
4255 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4256 AC_MSG_RESULT($gcc_cv_ld_version_script)
4257 AC_SUBST(ld_version_script_option)
4259 AC_MSG_CHECKING(linker soname option)
4260 gcc_cv_ld_soname=no
4261 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4262   gcc_cv_ld_soname=yes
4263   ld_soname_option='-soname'
4264 elif test x$gcc_cv_ld != x; then
4265   case "$target" in
4266     *-*-darwin*)
4267       gcc_cv_ld_soname=yes
4268       ld_soname_option='-install_name'
4269       ;;
4270     # Solaris 2 ld always supports -h.  It also supports --soname for GNU
4271     # ld compatiblity since some Solaris 10 update.
4272     *-*-solaris2*)
4273       gcc_cv_ld_soname=yes
4274       ld_soname_option='-h'
4275       ;;
4276   esac
4278 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4279 AC_MSG_RESULT($gcc_cv_ld_soname)
4280 AC_SUBST(ld_soname_option)
4282 if test x"$demangler_in_ld" = xyes; then
4283   AC_MSG_CHECKING(linker --demangle support)
4284   gcc_cv_ld_demangle=no
4285   if test $in_tree_ld = yes; then
4286     if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 14 -o "$gcc_cv_gld_major_version" -gt 2; then \
4287       gcc_cv_ld_demangle=yes
4288     fi
4289   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
4290     # Check if the GNU linker supports --demangle option
4291     if $gcc_cv_ld --help 2>&1 | grep no-demangle > /dev/null; then
4292       gcc_cv_ld_demangle=yes
4293     fi
4294   fi
4295   if test x"$gcc_cv_ld_demangle" = xyes; then
4296     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
4297 [Define if your linker supports --demangle option.])
4298   fi
4299   AC_MSG_RESULT($gcc_cv_ld_demangle)
4302 AC_MSG_CHECKING(linker plugin support)
4303 gcc_cv_lto_plugin=0
4304 if test -f liblto_plugin.la; then
4305   save_ld_ver="$ld_ver"
4306   save_ld_vers_major="$ld_vers_major"
4307   save_ld_vers_minor="$ld_vers_minor"
4308   save_ld_is_gold="$ld_is_gold"
4310   ld_is_gold=no
4312   if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
4313     ld_ver="GNU ld"
4314     # FIXME: ld_is_gold?
4315     ld_vers_major="$gcc_cv_gld_major_version"
4316     ld_vers_minor="$gcc_cv_gld_minor_version"
4317   else
4318     # Determine plugin linker version.
4319     # FIXME: Partial duplicate from above, generalize.
4320 changequote(,)dnl
4321     ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
4322     if echo "$ld_ver" | grep GNU > /dev/null; then
4323       if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
4324         ld_is_gold=yes
4325         ld_vers=`echo $ld_ver | sed -n \
4326             -e 's,^[^)]*[        ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
4327       else
4328         ld_vers=`echo $ld_ver | sed -n \
4329             -e 's,^.*[   ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
4330       fi
4331       ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
4332       ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
4333     fi
4334 changequote([,])dnl
4335   fi
4337   # Determine plugin support.
4338   if echo "$ld_ver" | grep GNU > /dev/null; then
4339     # Require GNU ld or gold 2.21+ for plugin support by default.
4340     if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
4341       gcc_cv_lto_plugin=2
4342     elif test "$ld_is_mold" = yes; then
4343       gcc_cv_lto_plugin=2
4344     # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
4345     elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
4346       gcc_cv_lto_plugin=1
4347     fi
4348   fi
4350   ld_ver="$save_ld_ver"
4351   ld_vers_major="$save_ld_vers_major"
4352   ld_vers_minor="$save_ld_vers_minor"
4353   ld_is_gold="$save_ld_is_gold"
4355 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
4356   [Define to the level of your linker's plugin support.])
4357 AC_MSG_RESULT($gcc_cv_lto_plugin)
4359 # Target OS-specific assembler checks.
4361 case "$target_os" in
4362   darwin*)
4363     gcc_GAS_CHECK_FEATURE([-mmacosx-version-min option],
4364       gcc_cv_as_mmacosx_version_min,
4365       [-mmacosx-version-min=10.1], [.text],,
4366       [AC_DEFINE(HAVE_AS_MMACOSX_VERSION_MIN_OPTION, 1,
4367         [Define if your macOS assembler supports the -mmacos-version-min option.])])
4368     if test x$gcc_cv_as_mmacosx_version_min = "xyes"; then
4369        gcc_GAS_CHECK_FEATURE([.build_version],
4370            gcc_cv_as_darwin_build_version,
4371            [-mmacosx-version-min=10.14],
4372            [ .build_version macos, 10, 14 sdk_version 10, 14],,
4373       [AC_DEFINE(HAVE_AS_MACOS_BUILD_VERSION, 1,
4374         [Define if your macOS assembler supports .build_version directives])])
4375     fi
4376     ;;
4377 esac
4379 # Target CPU-specific assembler checks.
4381 case "$target" in
4382   aarch64*-*-*)
4383     gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,
4384                           [-mabi=lp64], [.text],,,)
4385     if test x$gcc_cv_as_aarch64_mabi = xyes; then
4386       AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
4387                 [Define if your assembler supports the -mabi option.])
4388     else
4389       if test x$with_abi = xilp32; then
4390         AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4391                      Upgrade the Assembler.])
4392       fi
4393       if test x"$with_multilib_list" = xdefault; then
4394         TM_MULTILIB_CONFIG=lp64
4395       else
4396         aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
4397         for aarch64_multilib in ${aarch64_multilibs}; do
4398           case ${aarch64_multilib} in
4399             ilp32)
4400               AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4401                             Upgrade the Assembler.])
4402               ;;
4403             *)
4404               ;;
4405           esac
4406         done
4407       fi
4408     fi
4409     # Check if we have binutils support for relocations types needed by -fpic
4410     gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,
4411     [
4412         .text
4413         ldr     x0, [[x2, #:gotpage_lo15:globalsym]]
4414     ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1,
4415         [Define if your assembler supports relocs needed by -fpic.])])
4416     # Enable Branch Target Identification Mechanism and Return Address
4417     # Signing by default.
4418     AC_ARG_ENABLE(standard-branch-protection,
4419     [
4420 AS_HELP_STRING([--enable-standard-branch-protection],
4421         [enable Branch Target Identification Mechanism, Return Address Signing, and Guarded Control Stack by default for AArch64])
4422 AS_HELP_STRING([--disable-standard-branch-protection],
4423         [disable Branch Target Identification Mechanism, Return Address Signing, and Guarded Control Stack by default for AArch64])
4424     ],
4425       [
4426         case $enableval in
4427           yes)
4428             tm_defines="${tm_defines} TARGET_ENABLE_BTI=1 TARGET_ENABLE_PAC_RET=1 TARGET_ENABLE_GCS=1"
4429             ;;
4430           no)
4431             ;;
4432           *)
4433             AC_MSG_ERROR(['$enableval' is an invalid value for --enable-standard-branch-protection.\
4434   Valid choices are 'yes' and 'no'.])
4435             ;;
4436         esac
4437       ],
4438     [])
4439     # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
4440     AC_ARG_ENABLE(fix-cortex-a53-835769,
4441     [
4442 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
4443         [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4444 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
4445         [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4446     ],
4447       [
4448         case $enableval in
4449           yes)
4450             tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
4451             ;;
4452           no)
4453             ;;
4454           *)
4455             AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
4456   Valid choices are 'yes' and 'no'.])
4457             ;;
4459         esac
4460       ],
4461     [])
4462     # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
4463     AC_ARG_ENABLE(fix-cortex-a53-843419,
4464     [
4465 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
4466         [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4467 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
4468         [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4469     ],
4470       [
4471         case $enableval in
4472           yes)
4473             tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
4474             ;;
4475           no)
4476             ;;
4477           *)
4478             AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
4479   Valid choices are 'yes' and 'no'.])
4480             ;;
4482         esac
4483       ],
4484     [])
4485     ;;
4487   # All TARGET_ABI_OSF targets.
4488   alpha*-*-linux* | alpha*-*-*bsd*)
4489     gcc_GAS_CHECK_FEATURE([explicit relocation support],
4490         gcc_cv_as_alpha_explicit_relocs,,
4491 [       .set nomacro
4492         .text
4493         extbl   $3, $2, $3      !lituse_bytoff!1
4494         ldq     $2, a($29)      !literal!1
4495         ldq     $4, b($29)      !literal!2
4496         ldq_u   $3, 0($2)       !lituse_base!1
4497         ldq     $27, f($29)     !literal!5
4498         jsr     $26, ($27), f   !lituse_jsr!5
4499         ldah    $29, 0($26)     !gpdisp!3
4500         lda     $0, c($29)      !gprel
4501         ldah    $1, d($29)      !gprelhigh
4502         lda     $1, d($1)       !gprellow
4503         lda     $29, 0($29)     !gpdisp!3],,
4504     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
4505   [Define if your assembler supports explicit relocations.])])
4506     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
4507         gcc_cv_as_alpha_jsrdirect_relocs,,
4508 [       .set nomacro
4509         .text
4510         ldq     $27, a($29)     !literal!1
4511         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
4512     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
4513   [Define if your assembler supports the lituse_jsrdirect relocation.])])
4514     ;;
4516   avr-*-*)
4517     gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,
4518       [--mlink-relax], [.text],,
4519       [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
4520                 [Define if your avr assembler supports --mlink-relax option.])])
4522     gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,
4523       [-mrmw], [.text],,
4524       [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
4525                 [Define if your avr assembler supports -mrmw option.])])
4527     gcc_GAS_CHECK_FEATURE([__gcc_isr pseudo instruction],
4528       gcc_cv_as_avr_mgccisr,
4529       [-mgcc-isr], [.text
4530                     __gcc_isr 1
4531                     __gcc_isr 2
4532                     __gcc_isr 0,r24
4533                    ],,
4534       [AC_DEFINE(HAVE_AS_AVR_MGCCISR_OPTION, 1,
4535                 [Define if your avr assembler supports -mgcc-isr option.])])
4537     avr_ld_ver="`$gcc_cv_ld -v | sed -e 's:^.* ::'`"
4538     # Check how default linker description file implements .rodata for
4539     # avrxmega3 (PR21472).  avr-gcc assumes .rodata is *not* loaded to
4540     # RAM so avr-gcc skips __do_copy_data for .rodata objects.
4541     AC_MSG_CHECKING(binutils for avrxmega3 .rodata support)
4542     cat > conftest.s <<EOF
4543         .section .rodata,"a",@progbits
4544         .global xxvaryy
4545     ;; avr-nm should print "... R xxvaryy", not "... D xxvaryy".
4546     xxvaryy:
4547         .word 1
4549     rm -f conftest.nm
4550     AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega3 conftest.s -o conftest.o])
4551     AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega3 conftest.o -o conftest.elf])
4552     AC_TRY_COMMAND([$gcc_cv_nm conftest.elf > conftest.nm])
4553     if test -s conftest.nm
4554     then
4555         if grep ' R xxvaryy' conftest.nm > /dev/null; then
4556             AC_MSG_RESULT(yes)
4557             AC_DEFINE(HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH, 1,
4558                 [Define if your default avr linker script for avrxmega3 leaves .rodata in flash.])
4559         else
4560             AC_MSG_RESULT(no: avrxmega3 .rodata located in RAM)
4561             echo "$as_me: nm output was" >&AS_MESSAGE_LOG_FD
4562             cat conftest.nm >&AS_MESSAGE_LOG_FD
4563             AC_MSG_WARN([[support for avrxmega3 .rodata in flash needs Binutils 2.29 or higher (have $avr_ld_ver)]])
4564         fi
4565     else
4566         AC_MSG_RESULT(test failed)
4567         echo "$as_me: failed program was" >&AS_MESSAGE_LOG_FD
4568         cat conftest.s >&AS_MESSAGE_LOG_FD
4569         AC_MSG_WARN([[see `config.log' for details]])
4570     fi
4571     rm -f conftest.s conftest.o conftest.elf conftest.nm
4573     # Check for emulation avrxmega2_flmap.
4574     AC_MSG_CHECKING(binutils for avrxmega2_flmap support (PR31124))
4575     cat > conftest.s <<EOF
4576         .section .text,"ax",@progbits
4577         ldi r16, __flmap_value_with_lock
4579     AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega2 conftest.s -o conftest.o])
4580     AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega2_flmap conftest.o -o conftest.elf])
4581     if test -s conftest.elf
4582     then
4583         AC_MSG_RESULT(yes)
4584         AC_DEFINE(HAVE_LD_AVR_AVRXMEGA2_FLMAP, 1,
4585             [Define if your linker supports emulation avrxmega2_flmap.])
4586     else
4587         AC_MSG_RESULT(no)
4588         AC_MSG_WARN([[support for avrxmega2_flmap requires Binutils 2.42 or higher (have $avr_ld_ver)]])
4589         AC_MSG_WARN([[see `config.log' for details]])
4590     fi
4591     rm -f conftest.o conftest.elf
4593     # Check for emulation avrxmega4_flmap.
4594     AC_MSG_CHECKING(binutils for avrxmega4_flmap support (PR31124))
4595     AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega4 conftest.s -o conftest.o])
4596     AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega4_flmap conftest.o -o conftest.elf])
4597     if test -s conftest.elf
4598     then
4599         AC_MSG_RESULT(yes)
4600         AC_DEFINE(HAVE_LD_AVR_AVRXMEGA4_FLMAP, 1,
4601             [Define if your linker supports emulation avrxmega4_flmap.])
4602     else
4603         AC_MSG_RESULT(no)
4604         AC_MSG_WARN([[support for avrxmega4_flmap requires Binutils 2.42 or higher (have $avr_ld_ver)]])
4605         AC_MSG_WARN([[see `config.log' for details]])
4606     fi
4607     rm -f conftest.s conftest.o conftest.elf
4608     ;;
4610   cris-*-*)
4611     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
4612       gcc_cv_as_cris_no_mul_bug,
4613       [-no-mul-bug-abort], [.text],,
4614       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
4615                 [Define if your assembler supports the -no-mul-bug-abort option.])])
4616     ;;
4618   sparc*-*-*)
4619     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,
4620       [-relax], [.text],,
4621       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
4622                 [Define if your assembler supports -relax option.])])
4624     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
4625       gcc_cv_as_sparc_gotdata_op,
4626       [-K PIC],
4627 [.text
4628 .align 4
4629 foo:
4630         nop
4631 bar:
4632         sethi %gdop_hix22(foo), %g1
4633         xor    %g1, %gdop_lox10(foo), %g1
4634         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
4635       [if test x$gcc_cv_ld != x \
4636        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4637          if test x$gcc_cv_objdump != x; then
4638            if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
4639               | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
4640                gcc_cv_as_sparc_gotdata_op=no
4641            else
4642                gcc_cv_as_sparc_gotdata_op=yes
4643            fi
4644          fi
4645        fi
4646        rm -f conftest],
4647       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
4648                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
4650     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
4651       gcc_cv_as_sparc_ua_pcrel,
4652       [-K PIC],
4653 [.text
4654 foo:
4655         nop
4656 .data
4657 .align 4
4658 .byte 0
4659 .uaword %r_disp32(foo)],
4660       [if test x$gcc_cv_ld != x \
4661        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4662          gcc_cv_as_sparc_ua_pcrel=yes
4663        fi
4664        rm -f conftest],
4665       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
4666                 [Define if your assembler and linker support unaligned PC relative relocs.])
4668       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
4669         gcc_cv_as_sparc_ua_pcrel_hidden,
4670         [-K PIC],
4671 [.data
4672 .align 4
4673 .byte 0x31
4674 .uaword %r_disp32(foo)
4675 .byte 0x32, 0x33, 0x34
4676 .global foo
4677 .hidden foo
4678 foo:
4679 .skip 4],
4680         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4681          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
4682          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
4683             | grep ' 31000000 07323334' > /dev/null 2>&1; then
4684             if $gcc_cv_objdump -R conftest 2> /dev/null \
4685                | grep 'DISP32' > /dev/null 2>&1; then
4686                 :
4687             else
4688                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
4689             fi
4690          fi
4691          rm -f conftest],
4692          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
4693                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
4694     ]) # unaligned pcrel relocs
4696     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
4697       gcc_cv_as_sparc_offsetable_lo10,
4698       [-xarch=v9],
4699 [.text
4700         or %g1, %lo(ab) + 12, %g1
4701         or %g1, %lo(ab + 12), %g1],
4702       [if test x$gcc_cv_objdump != x \
4703        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
4704           | grep ' 82106000 82106000' > /dev/null 2>&1; then
4705          gcc_cv_as_sparc_offsetable_lo10=yes
4706        fi],
4707        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
4708                  [Define if your assembler supports offsetable %lo().])])
4710     gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
4711       gcc_cv_as_sparc_fmaf,
4712       [-xarch=v9d],
4713       [.text
4714        .register %g2, #scratch
4715        .register %g3, #scratch
4716        .align 4
4717        fmaddd %f0, %f2, %f4, %f6
4718        addxccc %g1, %g2, %g3
4719        fsrl32 %f2, %f4, %f8
4720        fnaddd %f10, %f12, %f14],,
4721       [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
4722                 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
4724     gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
4725       gcc_cv_as_sparc_sparc4,
4726       [-xarch=sparc4],
4727       [.text
4728        .register %g2, #scratch
4729        .register %g3, #scratch
4730        .align 4
4731        cxbe %g2, %g3, 1f
4732 1:     cwbneg %g2, %g3, 1f
4733 1:     sha1
4734        md5
4735        aes_kexpand0 %f4, %f6, %f8
4736        des_round %f38, %f40, %f42, %f44
4737        camellia_f %f54, %f56, %f58, %f60
4738        kasumi_fi_xor %f46, %f48, %f50, %f52],,
4739       [AC_DEFINE(HAVE_AS_SPARC4, 1,
4740                 [Define if your assembler supports SPARC4 instructions.])])
4742     gcc_GAS_CHECK_FEATURE([SPARC5 and VIS 4.0 instructions],
4743       gcc_cv_as_sparc_sparc5,
4744       [-xarch=sparc5],
4745       [.text
4746        .register %g2, #scratch
4747        .register %g3, #scratch
4748        .align 4
4749        subxc %g1, %g2, %g3
4750        fpadd8 %f0, %f2, %f4],,
4751       [AC_DEFINE(HAVE_AS_SPARC5_VIS4, 1,
4752                 [Define if your assembler supports SPARC5 and VIS 4.0 instructions.])])
4754     gcc_GAS_CHECK_FEATURE([SPARC6 instructions],
4755       gcc_cv_as_sparc_sparc6,
4756       [-xarch=sparc6],
4757       [.text
4758        .register %g2, #scratch
4759        .register %g3, #scratch
4760        .align 4
4761        rd %entropy, %g1
4762        fpsll64x %f0, %f2, %f4],,
4763       [AC_DEFINE(HAVE_AS_SPARC6, 1,
4764                 [Define if your assembler supports SPARC6 instructions.])])
4766     gcc_GAS_CHECK_FEATURE([LEON instructions],
4767       gcc_cv_as_sparc_leon,
4768       [-Aleon],
4769       [.text
4770        .register %g2, #scratch
4771        .register %g3, #scratch
4772        .align 4
4773        smac %g2, %g3, %g1
4774        umac %g2, %g3, %g1
4775        casa [[%g2]] 0xb, %g3, %g1],,
4776       [AC_DEFINE(HAVE_AS_LEON, 1,
4777                 [Define if your assembler supports LEON instructions.])])
4778     ;;
4780 changequote(,)dnl
4781   i[34567]86-*-* | x86_64-*-*)
4782 changequote([,])dnl
4783     case $target_os in
4784       cygwin*)
4785         # Full C++ conformance when using a shared libstdc++-v3 requires some
4786         # support from the Cygwin DLL, which in more recent versions exports
4787         # wrappers to aid in interposing and redirecting operators new, delete,
4788         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
4789         # are configuring for a version of Cygwin that exports the wrappers.
4790         if test x$host = x$target && test x$host_cpu = xi686; then
4791           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
4792         else
4793           # Can't check presence of libc functions during cross-compile, so
4794           # we just have to assume we're building for an up-to-date target.
4795           gcc_ac_cygwin_dll_wrappers=yes
4796         fi
4797         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
4798           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
4799           [Define if you want to generate code by default that assumes that the
4800            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
4801     esac
4802     case $target_os in
4803       cygwin* | pe | mingw32*)
4804         # Recent binutils allows the three-operand form of ".comm" on PE.  This
4805         # definition is used unconditionally to initialise the default state of
4806         # the target option variable that governs usage of the feature.
4807         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,,
4808           [.comm foo,1,32])
4809         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
4810           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
4811           [Define if your assembler supports specifying the alignment
4812            of objects allocated using the GAS .comm command.])
4813         # Used for DWARF 2 in PE
4814         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
4815           gcc_cv_as_ix86_pe_secrel32,,
4816 [.text
4817 foo:    nop
4818 .data
4819         .secrel32 foo],
4820           [if test x$gcc_cv_ld != x \
4821            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
4822              gcc_cv_as_ix86_pe_secrel32=yes
4823            fi
4824            rm -f conftest],
4825           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
4826             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
4827         # Test if the assembler supports the extended form of the .section
4828         # directive that specifies section alignment.  LTO support uses this,
4829         # but normally only after installation, so we warn but don't fail the
4830         # configure if LTO is enabled but the assembler does not support it.
4831         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
4832           -fatal-warnings,[.section lto_test,"dr0"])
4833         if test x$gcc_cv_as_section_has_align != xyes; then
4834           case ",$enable_languages," in
4835             *,lto,*)
4836               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
4837               ;;
4838           esac
4839         fi
4840         ;;
4841     esac
4842     case $target_os in
4843        darwin2* | darwin19*)
4844         gcc_GAS_CHECK_FEATURE([llvm assembler x86-pad-for-align option],
4845           gcc_cv_as_mllvm_x86_pad_for_align,
4846           [-mllvm -x86-pad-for-align=false], [.text],,
4847           [AC_DEFINE(HAVE_AS_MLLVM_X86_PAD_FOR_ALIGN, 1,
4848             [Define if your macOS assembler supports -mllvm -x86-pad-for-align=false.])])
4849        ;;
4850     esac
4852     gcc_GAS_CHECK_FEATURE([-xbrace_comment], gcc_cv_as_ix86_xbrace_comment,
4853       [-xbrace_comment=no], [.text],,
4854       [AC_DEFINE(HAVE_AS_XBRACE_COMMENT_OPTION, 1,
4855                 [Define if your assembler supports -xbrace_comment option.])])
4857     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
4858        gcc_cv_as_ix86_filds,,
4859        [filds (%ebp); fists (%ebp)],,
4860        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
4861          [Define if your assembler uses filds and fists mnemonics.])])
4863     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
4864        gcc_cv_as_ix86_fildq,,
4865        [fildq (%ebp); fistpq (%ebp)],,
4866        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
4867          [Define if your assembler uses fildq and fistq mnemonics.])])
4869     gcc_GAS_CHECK_FEATURE([cmov syntax],
4870       gcc_cv_as_ix86_cmov_sun_syntax,,
4871       [cmovl.l %edx, %eax],,
4872       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
4873         [Define if your assembler supports the Sun syntax for cmov.])])
4875     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
4876       gcc_cv_as_ix86_ffreep,,
4877       [ffreep %st(1)],,
4878       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
4879         [Define if your assembler supports the ffreep mnemonic.])])
4881     gcc_GAS_CHECK_FEATURE([.quad directive],
4882       gcc_cv_as_ix86_quad,,
4883       [.quad 0],,
4884       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
4885         [Define if your assembler supports the .quad directive.])])
4887     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
4888       gcc_cv_as_ix86_sahf,,
4889       [.code64
4890        sahf],,
4891       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
4892         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
4894     gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
4895       gcc_cv_as_ix86_interunit_movq,,
4896       [.code64
4897        movq %mm0, %rax
4898        movq %rax, %xmm0])
4899     AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
4900       [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
4901       [Define if your assembler supports interunit movq mnemonic.])
4903     gcc_GAS_CHECK_FEATURE([hle prefixes],
4904       gcc_cv_as_ix86_hle,,
4905       [lock xacquire cmpxchg %esi, (%ecx)],,
4906       [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
4907         [Define if your assembler supports HLE prefixes.])])
4909     gcc_GAS_CHECK_FEATURE([swap suffix],
4910       gcc_cv_as_ix86_swap,,
4911       [movl.s %esp, %ebp],,
4912       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
4913         [Define if your assembler supports the swap suffix.])])
4915     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
4916       gcc_cv_as_ix86_diff_sect_delta,,
4917       [.section .rodata
4918 .L1:
4919         .long .L2-.L1
4920         .long .L3-.L1
4921         .text
4922 .L3:    nop
4923 .L2:    nop],,
4924       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4925         [Define if your assembler supports the subtraction of symbols in different sections.])])
4927     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4928         gcc_cv_as_ix86_rep_lock_prefix,,
4929         [rep movsl
4930          rep ret
4931          rep nop
4932          rep bsf %ecx, %eax
4933          rep bsr %ecx, %eax
4934          lock addl %edi, (%eax,%esi)
4935          lock orl $0, (%esp)],,
4936         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4937           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4939     gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4940         gcc_cv_as_ix86_ud2,,
4941         [ud2],,
4942       [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4943         [Define if your assembler supports the 'ud2' mnemonic.])])
4945     # Enforce 32-bit output with gas and gld.
4946     if test x$gas = xyes; then
4947       as_ix86_gas_32_opt="--32"
4948     fi
4949     if echo "$ld_ver" | grep GNU > /dev/null; then
4950       if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4951         ld_ix86_gld_32_opt="-melf_i386_sol2"
4952       else
4953         ld_ix86_gld_32_opt="-melf_i386"
4954       fi
4955     fi
4957     gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4958         gcc_cv_as_ix86_tlsgdplt,
4959         [$as_ix86_gas_32_opt],
4960         [call    tls_gd@tlsgdplt],
4961         [if test x$gcc_cv_ld != x \
4962          && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4963            gcc_cv_as_ix86_tlsgdplt=yes
4964          fi
4965          rm -f conftest],
4966       [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4967         [Define if your assembler and linker support @tlsgdplt.])])
4969     conftest_s='
4970         .section .tdata,"aw'$tls_section_flag'",@progbits
4971 tls_ld:
4972         .section .text,"ax",@progbits
4973          call    tls_ld@tlsldmplt'
4975     gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4976         gcc_cv_as_ix86_tlsldmplt,
4977         [$as_ix86_gas_32_opt],
4978         [$conftest_s],
4979         [if test x$gcc_cv_ld != x \
4980          && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4981            gcc_cv_as_ix86_tlsldmplt=yes
4982          fi
4983          rm -f conftest])
4984     AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4985       [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4986       [Define to 1 if your assembler and linker support @tlsldmplt.])
4988     conftest_s='
4989         .section .text,"ax",@progbits
4990         .globl  _start
4991         .type   _start, @function
4992 _start:      
4993         leal    value@tlsldm(%ebx), %eax
4994         call    ___tls_get_addr@plt
4996         .section .tdata,"aw'$tls_section_flag'",@progbits
4997         .type   value, @object
4998 value:'
4999     gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
5000         gcc_cv_as_ix86_tlsldm,
5001         [$as_ix86_gas_32_opt],
5002         [$conftest_s],
5003         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
5004             && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
5005            if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
5006               || dis conftest 2>/dev/null | grep nop > /dev/null; then
5007              gcc_cv_as_ix86_tlsldm=yes
5008            fi
5009          fi
5010          rm -f conftest])
5011     AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
5012       [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
5013       [Define to 1 if your assembler and linker support @tlsldm.])
5015     conftest_s='
5016         .data
5017 bar:
5018         .byte 1
5019         .text
5020         .global _start
5021 _start:
5022          cmpl $0, bar@GOT
5023          jmp *_start@GOT'
5024     gcc_GAS_CHECK_FEATURE([R_386_GOT32X reloc],
5025         gcc_cv_as_ix86_got32x,
5026         [$as_ix86_gas_32_opt],
5027         [$conftest_s],
5028         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
5029             && test x$gcc_cv_readelf != x \
5030             && $gcc_cv_readelf --relocs --wide conftest.o 2>&1 \
5031                | grep R_386_GOT32X > /dev/null 2>&1 \
5032             && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
5033            if $gcc_cv_objdump -dw conftest 2>&1 \
5034               | grep 0xffffff > /dev/null 2>&1; then
5035              gcc_cv_as_ix86_got32x=no
5036            else
5037              gcc_cv_as_ix86_got32x=yes
5038            fi
5039          fi
5040          rm -f conftest])
5041     AC_DEFINE_UNQUOTED(HAVE_AS_IX86_GOT32X,
5042       [`if test x"$gcc_cv_as_ix86_got32x" = xyes; then echo 1; else echo 0; fi`],
5043       [Define 0/1 if your assembler and linker support @GOT.])
5045     # Check if gas and gld support "addq %r23,foo@GOTTPOFF(%rip), %r15"
5046     # with R_X86_64_CODE_6_GOTTPOFF relocation.
5047     if echo "$ld_ver" | grep GNU > /dev/null; then
5048       if $gcc_cv_ld -V 2>/dev/null | grep elf_x86_64_sol2 > /dev/null; then
5049         ld_ix86_gld_64_opt="-melf_x86_64_sol2"
5050       else
5051         ld_ix86_gld_64_opt="-melf_x86_64"
5052       fi
5053     fi
5054     # Enforce 64-bit output with gas and gld.
5055     if test x$gas = xyes; then
5056       as_ix86_gas_64_opt="--64"
5057     fi
5058     conftest_s='
5059         .text
5060         .globl  _start
5061         .type _start, @function
5062 _start:
5063         addq    %r23,foo@GOTTPOFF(%rip), %r15
5064         .section .tdata,"awT",@progbits
5065         .type foo, @object
5066 foo:
5067         .quad 0'
5068     gcc_GAS_CHECK_FEATURE([R_X86_64_CODE_6_GOTTPOFF reloc],
5069         gcc_cv_as_x86_64_code_6_gottpoff,
5070         [$as_ix86_gas_64_opt],
5071         [$conftest_s],
5072         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
5073             && test x$gcc_cv_readelf != x \
5074             && $gcc_cv_readelf --relocs --wide conftest.o 2>&1 \
5075                | grep R_X86_64_CODE_6_GOTTPOFF > /dev/null 2>&1 \
5076             && $gcc_cv_ld $ld_ix86_gld_64_opt -o conftest conftest.o > /dev/null 2>&1; then
5077            if $gcc_cv_objdump -dw conftest 2>&1 \
5078               | grep "add \+\$0xf\+8,%r23,%r15" > /dev/null 2>&1; then
5079              gcc_cv_as_x86_64_code_6_gottpoff=yes
5080            else
5081              gcc_cv_as_x86_64_code_6_gottpoff=no
5082            fi
5083          fi
5084          rm -f conftest])
5085     AC_DEFINE_UNQUOTED(HAVE_AS_R_X86_64_CODE_6_GOTTPOFF,
5086       [`if test x"$gcc_cv_as_x86_64_code_6_gottpoff" = xyes; then echo 1; else echo 0; fi`],
5087       [Define 0/1 if your assembler and linker support R_X86_64_CODE_6_GOTTPOFF.])
5089     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
5090       gcc_cv_as_ix86_gotoff_in_data,
5091       [$as_ix86_gas_32_opt],
5092 [       .text
5093 .L0:
5094         nop
5095         .data
5096         .long .L0@GOTOFF])
5097     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
5098       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
5099       [Define true if the assembler supports '.long foo@GOTOFF'.])
5101     conftest_s='
5102         .section .text,"ax",@progbits
5103         .globl  _start
5104         .type   _start, @function
5105 _start:
5106         leal    ld@tlsldm(%ecx), %eax
5107         call    *___tls_get_addr@GOT(%ecx)
5108         leal    gd@tlsgd(%ecx), %eax
5109         call    *___tls_get_addr@GOT(%ecx)
5111         .section .tdata,"aw'$tls_section_flag'",@progbits
5112         .type   ld, @object
5114         .byte 0
5115         .globl  gd
5116         .type   gd, @object
5118         .byte 0'
5119     gcc_GAS_CHECK_FEATURE([calling ___tls_get_addr via GOT],
5120         gcc_cv_as_ix86_tls_get_addr_via_got,
5121         [$as_ix86_gas_32_opt],
5122         [$conftest_s],
5123         [if test x$gcc_cv_ld != x \
5124             && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
5125            gcc_cv_as_ix86_tls_get_addr_via_got=yes
5126          fi
5127          rm -f conftest])
5128     AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLS_GET_ADDR_GOT,
5129       [`if test x"$gcc_cv_as_ix86_tls_get_addr_via_got" = xyes; then echo 1; else echo 0; fi`],
5130       [Define 0/1 if your assembler and linker support calling ___tls_get_addr via GOT.])
5131     ;;
5133   ia64*-*-*)
5134     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
5135         gcc_cv_as_ia64_ltoffx_ldxmov_relocs,,
5136 [       .text
5137         addl r15 = @ltoffx(x#), gp
5138         ;;
5139         ld8.mov r16 = [[r15]], x#
5141     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
5142           [Define if your assembler supports ltoffx and ldxmov relocations.])])
5144     ;;
5146   powerpc*-*-*)
5148     case $target in
5149       *-*-darwin*)
5150         gcc_GAS_CHECK_FEATURE([.machine directive support],
5151           gcc_cv_as_machine_directive,,
5152           [     .machine ppc7400])
5153         if test x$gcc_cv_as_machine_directive != xyes; then
5154           echo "*** This target requires an assembler supporting \".machine\"" >&2
5155           echo you can get it from: https://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
5156           test x$build = x$target && exit 1
5157         fi
5158         ;;
5159     esac
5161     case $target in
5162       *-*-aix*) conftest_s='    .machine "pwr5"
5163         .csect .text[[PR]]
5164         mfcr 3,128';;
5165       *-*-darwin*) conftest_s=' .text
5166         mfcr r3,128';;
5167       *) conftest_s='   .machine power4
5168         .text
5169         mfcr 3,128';;
5170     esac
5172     gcc_GAS_CHECK_FEATURE([mfcr field support],
5173       gcc_cv_as_powerpc_mfcrf,,
5174       [$conftest_s],,
5175       [AC_DEFINE(HAVE_AS_MFCRF, 1,
5176           [Define if your assembler supports mfcr field.])])
5178     case $target in
5179       *-*-aix*) conftest_s='    .machine "pwr10"
5180         .csect .text[[PR]]
5181         tend. 0';;
5182       *-*-darwin*) conftest_s=' .text
5183         tend. 0';;
5184       *) conftest_s='   .machine power10
5185         .text
5186         tend. 0';;
5187     esac
5189     gcc_GAS_CHECK_FEATURE([htm support on Power10],
5190       gcc_cv_as_power10_htm,,
5191       [$conftest_s],,
5192       [AC_DEFINE(HAVE_AS_POWER10_HTM, 1,
5193           [Define if your assembler supports htm insns on power10.])])
5195     case $target in
5196       *-*-aix*) conftest_s='    .csect .text[[PR]]
5197 LCF..0:
5198         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
5199       *-*-darwin*)
5200         conftest_s='    .text
5201 LCF0:
5202         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
5203       *) conftest_s='   .text
5204 .LCF0:
5205         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
5206     esac
5208     gcc_GAS_CHECK_FEATURE([rel16 relocs],
5209       gcc_cv_as_powerpc_rel16, -a32,
5210       [$conftest_s],,
5211       [AC_DEFINE(HAVE_AS_REL16, 1,
5212           [Define if your assembler supports R_PPC_REL16 relocs.])])
5214     case $target in
5215       *-*-aix*) conftest_s='    .machine "pwr7"
5216         .csect .text[[PR]]
5217         lxvd2x 1,2,3';;
5218       *) conftest_s='   .machine power7
5219         .text
5220         lxvd2x 1,2,3';;
5221     esac
5223     gcc_GAS_CHECK_FEATURE([vector-scalar support],
5224       gcc_cv_as_powerpc_vsx, -a32,
5225       [$conftest_s],,
5226       [AC_DEFINE(HAVE_AS_VSX, 1,
5227           [Define if your assembler supports VSX instructions.])])
5229     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5230       gcc_cv_as_powerpc_gnu_attribute,,
5231       [.gnu_attribute 4,1],,
5232       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5233           [Define if your assembler supports .gnu_attribute.])])
5235     gcc_GAS_CHECK_FEATURE([prologue entry point marker support],
5236       gcc_cv_as_powerpc_entry_markers,-a64 --fatal-warnings,
5237       [ .reloc .,R_PPC64_ENTRY; nop],,
5238       [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1,
5239           [Define if your assembler supports the R_PPC64_ENTRY relocation.])])
5241     gcc_GAS_CHECK_FEATURE([plt sequence marker support],
5242       gcc_cv_as_powerpc_pltseq_markers,-a32 --fatal-warnings,
5243       [ .reloc .,R_PPC_PLTSEQ; nop],,
5244       [AC_DEFINE(HAVE_AS_PLTSEQ, 1,
5245           [Define if your assembler supports R_PPC*_PLTSEQ relocations.])])
5247     case $target in
5248       *-*-aix*)
5249         gcc_GAS_CHECK_FEATURE([AIX .ref support],
5250           gcc_cv_as_aix_ref,,
5251           [     .csect stuff[[rw]]
5252              stuff:
5253                 .long 1
5254                 .extern sym
5255                 .ref sym
5256           ],,
5257           [AC_DEFINE(HAVE_AS_REF, 1,
5258             [Define if your assembler supports .ref])])
5260         gcc_GAS_CHECK_FEATURE([AIX DWARF location lists section support],
5261           gcc_cv_as_aix_dwloc,,
5262           [     .dwsect 0xA0000
5263         Lframe..0:
5264                 .vbyte 4,Lframe..0
5265           ],,
5266           [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
5267             [Define if your assembler supports AIX debug frame section label reference.])])
5268         ;;
5269     esac
5270     ;;
5272   mips*-*-*)
5273     gcc_GAS_CHECK_FEATURE([explicit relocation support: %pcrel_hi/%pcrel_lo],
5274       gcc_cv_as_mips_explicit_relocs_pcrel,,
5275 [       lui $4,%pcrel_hi(foo)],,
5276       [AC_DEFINE(MIPS_EXPLICIT_RELOCS, MIPS_EXPLICIT_RELOCS_PCREL,
5277                  [Define if assembler supports %pcrel_hi/%pcrel_lo.])])
5279     if test x$gcc_cv_as_mips_explicit_relocs_pcrel = xno; then \
5280     gcc_GAS_CHECK_FEATURE([explicit relocation support: %gp_rel],
5281       gcc_cv_as_mips_explicit_relocs,,
5282 [       lw $4,%gp_rel(foo)($4)],,
5283       [AC_DEFINE(MIPS_EXPLICIT_RELOCS, MIPS_EXPLICIT_RELOCS_BASE,
5284                  [Define if assembler supports %reloc.])])
5285     else
5286       gcc_cv_as_mips_explicit_relocs=yes
5287     fi
5289     if test x$gcc_cv_as_mips_explicit_relocs = xno; then \
5290       AC_DEFINE(MIPS_EXPLICIT_RELOCS, MIPS_EXPLICIT_RELOCS_NONE,
5291                 [Define if assembler supports %reloc.])
5292     fi
5294     gcc_GAS_CHECK_FEATURE([-mno-shared support],
5295       gcc_cv_as_mips_no_shared,[-mno-shared], [nop],,
5296       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
5297                  [Define if the assembler understands -mno-shared.])])
5299     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5300       gcc_cv_as_mips_gnu_attribute,,
5301       [.gnu_attribute 4,1],,
5302       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5303           [Define if your assembler supports .gnu_attribute.])])
5305     gcc_GAS_CHECK_FEATURE([.module support],
5306       gcc_cv_as_mips_dot_module,[-32],
5307       [.module mips2
5308        .module fp=xx],,
5309       [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
5310           [Define if your assembler supports .module.])])
5311     if test x$gcc_cv_as_mips_dot_module = xno \
5312        && test x$with_fp_32 != x; then
5313       AC_MSG_ERROR(
5314         [Requesting --with-fp-32= requires assembler support for .module.])
5315     fi
5317     gcc_GAS_CHECK_FEATURE([.micromips support],
5318       gcc_cv_as_micromips_support,[--fatal-warnings],
5319       [.set micromips],,
5320       [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
5321           [Define if your assembler supports the .set micromips directive])])
5323     gcc_GAS_CHECK_FEATURE([.dtprelword support],
5324       gcc_cv_as_mips_dtprelword,,
5325       [.section .tdata,"awT",@progbits
5327         .word 2
5328         .text
5329         .dtprelword x+0x8000],,
5330       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
5331           [Define if your assembler supports .dtprelword.])])
5333     gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
5334       gcc_cv_as_mips_dspr1_mult,,
5335 [       .set    mips32r2
5336         .set    nodspr2
5337         .set    dsp
5338         madd    $ac3,$4,$5
5339         maddu   $ac3,$4,$5
5340         msub    $ac3,$4,$5
5341         msubu   $ac3,$4,$5
5342         mult    $ac3,$4,$5
5343         multu   $ac3,$4,$5],,
5344       [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
5345           [Define if your assembler supports DSPR1 mult.])])
5347     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
5348     gcc_cv_as_ld_jalr_reloc=no
5349     if test $gcc_cv_as_mips_explicit_relocs = yes; then
5350       if test $in_tree_ld = yes ; then
5351         if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 20 -o "$gcc_cv_gld_major_version" -gt 2 \
5352            && test $in_tree_ld_is_elf = yes; then
5353           gcc_cv_as_ld_jalr_reloc=yes
5354         fi
5355       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
5356         echo '  .ent x' > conftest.s
5357         echo 'x:        lw $2,%got_disp(y)($3)' >> conftest.s
5358         echo '  lw $25,%call16(y)($28)' >> conftest.s
5359         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
5360         echo '1:        jalr $25' >> conftest.s
5361         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
5362         echo '1:        jalr $25' >> conftest.s
5363         echo '  .end x' >> conftest.s
5364         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
5365            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
5366           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
5367              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
5368             gcc_cv_as_ld_jalr_reloc=yes
5369           fi
5370         fi
5371         rm -f conftest.*
5372       fi
5373     fi
5374     if test $gcc_cv_as_ld_jalr_reloc = yes; then
5375       if test x$target_cpu_default = x; then
5376         target_cpu_default=MASK_RELAX_PIC_CALLS
5377       else
5378         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
5379       fi
5380     fi
5381     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
5383     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
5384       [gcc_cv_ld_mips_personality_relaxation],
5385       [gcc_cv_ld_mips_personality_relaxation=no
5386        if test $in_tree_ld = yes ; then
5387          if test "$gcc_cv_gld_major_version" -eq 2 \
5388                  -a "$gcc_cv_gld_minor_version" -ge 21 \
5389                  -o "$gcc_cv_gld_major_version" -gt 2; then
5390            gcc_cv_ld_mips_personality_relaxation=yes
5391          fi
5392        elif test x$gcc_cv_as != x \
5393                  -a x$gcc_cv_ld != x \
5394                  -a x$gcc_cv_readelf != x ; then
5395          cat > conftest.s <<EOF
5396         .cfi_startproc
5397         .cfi_personality 0x80,indirect_ptr
5398         .ent test
5399 test:
5400         nop
5401         .end test
5402         .cfi_endproc
5404         .section .data,"aw",@progbits
5405 indirect_ptr:
5406         .dc.a personality
5408          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
5409             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
5410            if $gcc_cv_readelf -d conftest 2>&1 \
5411               | grep TEXTREL > /dev/null 2>&1; then
5412              :
5413            elif $gcc_cv_readelf --relocs conftest 2>&1 \
5414                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
5415              :
5416            else
5417              gcc_cv_ld_mips_personality_relaxation=yes
5418            fi
5419          fi
5420        fi
5421        rm -f conftest.s conftest.o conftest])
5422     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
5423             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
5424       [Define if your linker can relax absolute .eh_frame personality
5425 pointers into PC-relative form.])
5426     fi
5428     gcc_GAS_CHECK_FEATURE([-mnan= support],
5429       gcc_cv_as_mips_nan,
5430       [-mnan=2008],,,
5431       [AC_DEFINE(HAVE_AS_NAN, 1,
5432                  [Define if the assembler understands -mnan=.])])
5433     if test x$gcc_cv_as_mips_nan = xno \
5434        && test x$with_nan != x; then
5435       AC_MSG_ERROR(
5436         [Requesting --with-nan= requires assembler support for -mnan=])
5437     fi
5438     ;;
5439     msp430-*-*)
5440     # Earlier GAS versions generically support .gnu_attribute, but the
5441     # msp430 assembler will not do anything with it.
5442     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5443       gcc_cv_as_msp430_gnu_attribute,,
5444       [.gnu_attribute 4,1],,
5445       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5446           [Define if your assembler supports .gnu_attribute.])])
5447     gcc_GAS_CHECK_FEATURE([.mspabi_attribute support],
5448       gcc_cv_as_msp430_mspabi_attribute,,
5449       [.mspabi_attribute 4,2],,
5450       [AC_DEFINE(HAVE_AS_MSPABI_ATTRIBUTE, 1,
5451           [Define if your assembler supports .mspabi_attribute.])])
5452     if test x$enable_newlib_nano_formatted_io = xyes; then
5453       AC_DEFINE(HAVE_NEWLIB_NANO_FORMATTED_IO, 1, [Define if GCC has been
5454 configured with --enable-newlib-nano-formatted-io.])
5455       fi
5456     ;;
5457     riscv*-*-*)
5458     gcc_GAS_CHECK_FEATURE([.attribute support],
5459       gcc_cv_as_riscv_attribute,,
5460       [.attribute stack_align,4],,
5461       [AC_DEFINE(HAVE_AS_RISCV_ATTRIBUTE, 1,
5462           [Define if your assembler supports .attribute.])])
5463     gcc_GAS_CHECK_FEATURE([-misa-spec= support],
5464       gcc_cv_as_riscv_isa_spec,
5465       [-misa-spec=2.2],,,
5466       [AC_DEFINE(HAVE_AS_MISA_SPEC, 1,
5467                  [Define if the assembler understands -misa-spec=.])])
5468     gcc_GAS_CHECK_FEATURE([-march=rv32i_zifencei support],
5469       gcc_cv_as_riscv_march_zifencei,
5470       [-march=rv32i_zifencei2p0],,,
5471       [AC_DEFINE(HAVE_AS_MARCH_ZIFENCEI, 1,
5472                  [Define if the assembler understands -march=rv*_zifencei.])])
5473     gcc_GAS_CHECK_FEATURE([-march=rv32i_zaamo_zalrsc support],
5474       gcc_cv_as_riscv_march_zaamo_zalrsc,
5475       [-march=rv32i_zaamo_zalrsc],,,
5476       [AC_DEFINE(HAVE_AS_MARCH_ZAAMO_ZALRSC, 1,
5477                  [Define if the assembler understands -march=rv*_zaamo_zalrsc.])])
5478     gcc_GAS_CHECK_FEATURE([-march=rv32i_b support],
5479       gcc_cv_as_riscv_march_b,
5480       [-march=rv32i_b],,,
5481       [AC_DEFINE(HAVE_AS_MARCH_B, 1,
5482                  [Define if the assembler understands -march=rv*_b.])])
5483     ;;
5484     loongarch*-*-*)
5485     gcc_GAS_CHECK_FEATURE([.dtprelword support],
5486       gcc_cv_as_loongarch_dtprelword, [2,18,0],,
5487       [.section .tdata,"awT",@progbits
5489         .word 2
5490         .text
5491         .dtprelword x+0x8000],,
5492       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
5493           [Define if your assembler supports .dtprelword.])])
5494     gcc_GAS_CHECK_FEATURE([explicit relocation support],
5495       gcc_cv_as_loongarch_explicit_relocs,,
5496       [a:pcalau12i $t0,%pc_hi20(a)],,
5497       [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
5498           [Define if your assembler supports explicit relocation.])])
5499     gcc_GAS_CHECK_FEATURE([call36 relocation support],
5500       gcc_cv_as_loongarch_call36,,
5501       [pcaddu18i $r1, %call36(a)
5502        jirl $r1, $r1, 0],,
5503       [AC_DEFINE(HAVE_AS_SUPPORT_CALL36, 1,
5504           [Define if your assembler supports call36 relocation.])])
5505     gcc_GAS_CHECK_FEATURE([eh_frame pcrel encoding support],
5506       gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support,,
5507       [.cfi_startproc
5508        .cfi_personality 0x9b,a
5509        .cfi_lsda 0x1b,b
5510        .cfi_endproc],,
5511       [AC_DEFINE(HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT, 1,
5512           [Define if your assembler supports eh_frame pcrel encoding.])])
5513     gcc_GAS_CHECK_FEATURE([-mrelax option], gcc_cv_as_loongarch_relax,
5514       [-mrelax], [.text],,
5515       [AC_DEFINE(HAVE_AS_MRELAX_OPTION, 1,
5516                 [Define if your assembler supports -mrelax option.])])
5517     gcc_GAS_CHECK_FEATURE([conditional branch relaxation support],
5518       gcc_cv_as_loongarch_cond_branch_relax,
5519       [--fatal-warnings],
5520       [a:
5521        .rept 32769
5522        nop
5523        .endr
5524        beq $a0,$a1,a],,
5525       [AC_DEFINE(HAVE_AS_COND_BRANCH_RELAXATION, 1,
5526                 [Define if your assembler supports conditional branch relaxation.])])
5527     gcc_GAS_CHECK_FEATURE([tls le relaxation support],
5528       gcc_cv_as_loongarch_tls_le_relaxation_support,,
5529       [lu12i.w $t0,%le_hi20_r(a)],,
5530       [AC_DEFINE(HAVE_AS_TLS_LE_RELAXATION, 1,
5531           [Define if your assembler supports tls le relocation.])])
5532     ;;
5533     s390*-*-*)
5534     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5535       gcc_cv_as_s390_gnu_attribute,,
5536       [.gnu_attribute 8,1],,
5537       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5538           [Define if your assembler supports .gnu_attribute.])])
5539     gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
5540       gcc_cv_as_s390_machine_machinemode,,
5541       [ .machinemode push
5542         .machinemode pop
5543         .machine push
5544         .machine pop],,
5545       [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
5546           [Define if your assembler supports .machine and .machinemode.])])
5547     gcc_GAS_CHECK_FEATURE([architecture modifiers support],
5548       gcc_cv_as_s390_architecture_modifiers,,
5549       [ .machine z13+vx ],,
5550       [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
5551           [Define if your assembler supports architecture modifiers.])])
5552     gcc_GAS_CHECK_FEATURE([vector load/store alignment hints],
5553       gcc_cv_as_s390_vector_loadstore_alignment_hints,,
5554       [ vl %v24,0(%r15),3 ],,
5555       [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS, 1,
5556           [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument.])])
5557     gcc_GAS_CHECK_FEATURE([vector load/store alignment hints on z13],
5558       gcc_cv_as_s390_vector_loadstore_alignment_hints_on_z13, [-mzarch -march=z13],
5559       [ vl %v24,0(%r15),3 ],,
5560       [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS_ON_Z13, 1,
5561           [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument on z13.])])
5563     ;;
5564 esac
5566 # Mips, LoongArch and HP-UX need the GNU assembler.
5567 # Linux on IA64 might be able to use the Intel assembler.
5569 case "$target" in
5570   mips*-*-* | loongarch*-*-* | *-*-hpux* )
5571     if test x$gas_flag = xyes \
5572        || test x"$host" != x"$build" \
5573        || test ! -x "$gcc_cv_as" \
5574        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
5575       :
5576     else
5577       echo "*** This configuration requires the GNU assembler" >&2
5578       exit 1
5579     fi
5580     ;;
5581 esac
5583 # AMD GCN needs the LLVM assembler and linker.
5584 # Test that LLVM is at least 13.0.1.
5585 case "$target" in
5586   amdgcn-* | gcn-*)
5587     AC_MSG_CHECKING(llvm assembler version)
5588     gcc_cv_as_version="unknown"
5589     if test x$gcc_cv_as != x; then
5590       gcc_cv_as_version=`$gcc_cv_as --version 2>&1 | sed -ne '/version/s/.* \([[0-9]]\)/\1/p' || echo error`
5591       case "$gcc_cv_as_version" in
5592         13.0.[[1-9]]*) ;;          # 13.0.1+
5593         13.[[1-9]]*) ;;            # 13.1+
5594         1[[4-9]]*) ;;              # 14..19
5595         [[2-9]][[0-9]]*) ;;        # 20..99
5596         [[1-9]][[0-9]][[0-9]]*) ;; # 100+
5597         error) AC_MSG_ERROR([cannot determine LLVM version]) ;;
5598         *) AC_MSG_ERROR([LLVM 13.0.1 or later is required (found LLVM $gcc_cv_as_version)]) ;;
5599       esac
5600     fi
5601     AC_MSG_RESULT([$gcc_cv_as_version, ok])
5602     ;;
5603 esac
5605 case "$target" in
5606   arm*)
5607     gcc_GAS_CHECK_FEATURE([assembler for arm accepts context-specific architecture extensions],
5608       gcc_cv_as_arm_option_extensions,
5609       [-march=armv8.1-m.main+mve],
5610       [.text
5611         .thumb
5612         .syntax unified
5613         vmov.f32 s0, s1],,
5614       [AC_DEFINE(HAVE_GAS_ARM_EXTENDED_ARCH, 1,
5615        [Define if your Arm assembler permits context-specific feature extensions.])])
5616 esac
5618 # ??? Not all targets support dwarf2 debug_line, even within a version
5619 # of gas.  Moreover, we need to emit a valid instruction to trigger any
5620 # info to the output file.  So, as supported targets are added to gas 2.11,
5621 # add some instruction here to (also) show we expect this might work.
5622 # ??? Once 2.11 is released, probably need to add first known working
5623 # version to the per-target configury.
5624 case "$cpu_type" in
5625   aarch64 | alpha | arc | arm | avr | bfin | cris | csky | i386 | loongarch | m32c \
5626   | m68k | microblaze | mips | nds32 | pa | riscv | rs6000 | score | sparc \
5627   | visium | xstormy16 | xtensa | ft32)
5628     insn="nop"
5629     ;;
5630   ia64 | s390)
5631     insn="nop 0"
5632     ;;
5633   mmix)
5634     insn="swym 0"
5635     ;;
5636 esac
5637 if test x"$insn" != x; then
5638  conftest_s="\
5639         .file 1 \"conftest.s\"
5640         .loc 1 3 0
5641         $insn"
5642  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
5643   gcc_cv_as_dwarf2_debug_line,,
5644   [$conftest_s],
5645   [if test x$gcc_cv_objdump != x \
5646    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
5647       | grep debug_line > /dev/null 2>&1; then
5648      gcc_cv_as_dwarf2_debug_line=yes
5649    elif test x$gcc_cv_otool != x \
5650    && $gcc_cv_otool -l conftest.o 2> /dev/null \
5651       | grep debug_line > /dev/null 2>&1; then
5652      gcc_cv_as_dwarf2_debug_line=yes
5653    fi])
5655 # The .debug_line file table must be in the exact order that
5656 # we specified the files, since these indices are also used
5657 # by DW_AT_decl_file.  Approximate this test by testing if
5658 # the assembler bitches if the same index is assigned twice.
5659  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
5660   gcc_cv_as_dwarf2_file_buggy,,
5661 [       .file 1 "foo.s"
5662         .file 1 "bar.s"])
5664  if test $gcc_cv_as_dwarf2_debug_line = yes \
5665  && test $gcc_cv_as_dwarf2_file_buggy = no; then
5666     AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
5667   [Define if your assembler supports dwarf2 .file/.loc directives,
5668    and preserves file table indices exactly as given.])
5670     if test $gcc_cv_as_leb128 = yes; then
5671         conftest_s="\
5672         .file 1 \"conftest.s\"
5673         .loc 1 3 0 view .LVU1
5674         $insn
5675         .data
5676         .uleb128 .LVU1
5677         .uleb128 .LVU1
5679         gcc_GAS_CHECK_FEATURE([dwarf2 debug_view support],
5680           gcc_cv_as_dwarf2_debug_view,,
5681           [$conftest_s],,
5682           [AC_DEFINE(HAVE_AS_DWARF2_DEBUG_VIEW, 1,
5683   [Define if your assembler supports views in dwarf2 .loc directives.])])
5684     fi
5685  fi
5687  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
5688   gcc_cv_as_gdwarf2_flag,
5689   [--gdwarf2], [$insn],,
5690   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
5691 [Define if your assembler supports the --gdwarf2 option.])])
5693  gcc_GAS_CHECK_FEATURE([--gdwarf-5 option],
5694   gcc_cv_as_gdwarf_5_flag,
5695   [--gdwarf-5], [$insn],
5696   [if test x$gcc_cv_objdump != x \
5697       && $gcc_cv_objdump -Wi conftest.o 2>&1 \
5698          | grep DW_TAG_compile_unit > /dev/null 2>&1; then
5699      gcc_cv_as_gdwarf_5_flag=yes;
5700    fi],[AC_DEFINE(HAVE_AS_GDWARF_5_DEBUG_FLAG, 1,
5701 [Define if your assembler supports the --gdwarf-5 option.])])
5703  case $target_os in
5704    win32 | pe | cygwin* | mingw32*)
5705      section_flags=\"dr\"
5706      function_type=".def foo; .scl 2; .type 32; .endef"
5707      function_size="";;
5708    *)
5709      section_flags=\"\",%progbits
5710      function_type=".type foo, %function"
5711      function_size=".size foo, .-foo";;
5712  esac
5713  dwarf4_debug_info_size=0x46
5714  dwarf4_high_pc_form=7
5715  dwarf4_debug_aranges_size=0x2c
5716  dwarf4_line_sz=9
5717  for dwarf4_addr_size in 8 4; do
5718    conftest_s="\
5719         .file   \"a.c\"
5720         .text
5721 .Ltext0:
5722         .p2align 4
5723         .globl  foo
5724         $function_type
5725 foo:
5726 .LFB0:
5727 .LM1:
5728         $insn
5729 .LM2:
5730 .LFE0:
5731         $function_size
5732 .Letext0:
5733         .section        .debug_info,$section_flags
5734 .Ldebug_info0:
5735         .4byte  $dwarf4_debug_info_size
5736         .2byte  0x4
5737         .4byte  .Ldebug_abbrev0
5738         .byte   0x$dwarf4_addr_size
5739         .byte   0x1
5740         .ascii \"GNU C17\\0\"
5741         .byte   0xc
5742         .ascii \"a.c\\0\"
5743         .ascii \"/\\0\"
5744         .${dwarf4_addr_size}byte        .Ltext0
5745         .${dwarf4_addr_size}byte        .Letext0-.Ltext0
5746         .4byte  .Ldebug_line0
5747         .byte   0x2
5748         .ascii \"foo\\0\"
5749         .byte   0x1
5750         .byte   0x2
5751         .byte   0x1
5752         .${dwarf4_addr_size}byte        .LFB0
5753         .${dwarf4_addr_size}byte        .LFE0-.LFB0
5754         .byte   0x1
5755         .byte   0x9c
5756         .byte   0
5757         .section        .debug_abbrev,$section_flags
5758 .Ldebug_abbrev0:
5759         .byte   0x1
5760         .byte   0x11
5761         .byte   0x1
5762         .byte   0x25
5763         .byte   0x8
5764         .byte   0x13
5765         .byte   0xb
5766         .byte   0x3
5767         .byte   0x8
5768         .byte   0x1b
5769         .byte   0x8
5770         .byte   0x11
5771         .byte   0x1
5772         .byte   0x12
5773         .byte   0x$dwarf4_high_pc_form
5774         .byte   0x10
5775         .byte   0x17
5776         .byte   0
5777         .byte   0
5778         .byte   0x2
5779         .byte   0x2e
5780         .byte   0
5781         .byte   0x3f
5782         .byte   0x19
5783         .byte   0x3
5784         .byte   0x8
5785         .byte   0x3a
5786         .byte   0xb
5787         .byte   0x3b
5788         .byte   0xb
5789         .byte   0x39
5790         .byte   0xb
5791         .byte   0x11
5792         .byte   0x1
5793         .byte   0x12
5794         .byte   0x$dwarf4_high_pc_form
5795         .byte   0x40
5796         .byte   0x18
5797         .byte   0
5798         .byte   0
5799         .byte   0
5800         .section        .debug_aranges,$section_flags
5801         .4byte  $dwarf4_debug_aranges_size
5802         .2byte  0x2
5803         .4byte  .Ldebug_info0
5804         .byte   0x8
5805         .byte   0
5806         .2byte  0
5807         .2byte  0
5808         .${dwarf4_addr_size}byte        .Ltext0
5809         .${dwarf4_addr_size}byte        .Letext0-.Ltext0
5810         .${dwarf4_addr_size}byte        0
5811         .${dwarf4_addr_size}byte        0
5812         .section        .debug_line,$section_flags
5813 .Ldebug_line0:
5814         .4byte  .LELT0-.LSLT0
5815 .LSLT0:
5816         .2byte  0x4
5817         .4byte  .LELTP0-.LASLTP0
5818 .LASLTP0:
5819         .byte   0x1
5820         .byte   0x1
5821         .byte   0x1
5822         .byte   0xf6
5823         .byte   0xf2
5824         .byte   0xd
5825         .byte   0
5826         .byte   0x1
5827         .byte   0x1
5828         .byte   0x1
5829         .byte   0x1
5830         .byte   0
5831         .byte   0
5832         .byte   0
5833         .byte   0x1
5834         .byte   0
5835         .byte   0
5836         .byte   0x1
5837         .byte   0
5838         .ascii \"a.c\\0\"
5839         .byte   0
5840         .byte   0
5841         .byte   0
5842         .byte   0
5843 .LELTP0:
5844         .byte   0
5845         .byte   0x$dwarf4_line_sz
5846         .byte   0x2
5847         .${dwarf4_addr_size}byte        .LM1
5848         .byte   0x18
5849         .byte   0x5
5850         .byte   0x1
5851         .byte   0
5852         .byte   0x$dwarf4_line_sz
5853         .byte   0x2
5854         .${dwarf4_addr_size}byte        .LM2
5855         .byte   0x1
5856         .byte   0x5
5857         .byte   0x1
5858         .byte   0
5859         .byte   0x$dwarf4_line_sz
5860         .byte   0x2
5861         .${dwarf4_addr_size}byte        .Letext0
5862         .byte   0
5863         .byte   0x1
5864         .byte   0x1
5865 .LELT0:
5866         .section        .debug_str,$section_flags
5867         .ident  \"GCC\"
5869    dwarf4_success=no
5870    if test $dwarf4_addr_size = 4; then
5871      gcc_GAS_CHECK_FEATURE([assembly of compiler generated 32-bit .debug_line],
5872       gcc_cv_as_debug_line_32_flag,,
5873       [$conftest_s],,
5874       [dwarf4_success=yes])
5875    else
5876      gcc_GAS_CHECK_FEATURE([assembly of compiler generated 64-bit .debug_line],
5877       gcc_cv_as_debug_line_64_flag,,
5878       [$conftest_s],,
5879       [dwarf4_success=yes])
5880    fi
5881    if test $dwarf4_success = yes; then
5882      dwarf4_success=no
5883      gcc_GAS_CHECK_FEATURE([--gdwarf-4 not refusing compiler generated .debug_line],
5884       gcc_cv_as_dwarf_4_debug_line_flag,
5885       [--gdwarf-4], [$conftest_s],,
5886       [dwarf4_success=yes])
5887      break
5888    fi
5889    dwarf4_debug_info_size=0x36
5890    dwarf4_high_pc_form=6
5891    dwarf4_debug_aranges_size=0x1c
5892    dwarf4_line_sz=5
5893  done
5895  if test $dwarf4_success = yes; then
5896    conftest_s="\
5897         .file   \"foo.c\"
5898         .text
5899 bar:
5900 #APP
5901 # 82 \"xxx.h\" 1
5902         $insn
5903 # 0 \"\" 2
5904 #NO_APP
5905         $insn
5906 foo:
5907         .file 1 \"foo.c\"
5908         $insn
5909         .file 2 \"foo.h\"
5910         ret
5912    dwarf4_success=no
5913    gcc_GAS_CHECK_FEATURE([--gdwarf-4 with the APP marker],
5914      gcc_cv_as_dwarf_4_app_flag,
5915      [--gdwarf-4], [$conftest_s],, [dwarf4_success=yes])
5916  fi
5918  if test $dwarf4_success = yes; then
5919    conftest_s="\
5920         .text
5921         .globl  foo
5922         $function_type
5923 foo:
5924         $insn
5925         $function_size
5926         .file   1 \"foo.c\"
5928    gcc_GAS_CHECK_FEATURE([working --gdwarf-4/--gdwarf-5 for all sources],
5929      gcc_cv_as_working_gdwarf_n_flag,
5930      [--gdwarf-4],
5931      [$conftest_s],
5932      [changequote(,)dnl
5933       if test x$gcc_cv_objdump != x \
5934          && $gcc_cv_objdump -W conftest.o 2>&1 \
5935                 | grep conftest.s > /dev/null 2>&1; then
5936         gcc_cv_as_working_gdwarf_n_flag=no
5937       else
5938         gcc_cv_as_working_gdwarf_n_flag=yes
5939       fi
5940       changequote([,])dnl])
5941    if test $gcc_cv_as_working_gdwarf_n_flag = yes; then
5942      AC_DEFINE(HAVE_AS_WORKING_DWARF_N_FLAG, 1,
5943 [Define if your assembler supports --gdwarf-4/--gdwarf-5 even with
5944  compiler generated .debug_line.])
5945    fi
5946  fi
5948  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
5949   gcc_cv_as_debug_prefix_map_flag,
5950   [--debug-prefix-map /a=/b], [$insn],,
5951   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
5952 [Define if your assembler supports the --debug-prefix-map option.])])
5955 gcc_GAS_CHECK_FEATURE([compressed debug sections],
5956   gcc_cv_as_compress_debug,,,
5957   [# gas compiled without zlib cannot compress debug sections and warns
5958    # about it, but still exits successfully.  So check for this, too.
5959    if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
5960    then
5961      gcc_cv_as_compress_debug=0
5962    elif $gcc_cv_as --compress-debug-sections=zlib -o conftest.o conftest.s > /dev/null 2>&1
5963    then
5964      gcc_cv_as_compress_debug=1
5965      gcc_cv_as_compress_debug_option="--compress-debug-sections"
5966      gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5967      # Since binutils 2.40, gas supports --compress-debug-sections=zstd.
5968      if $gcc_cv_as --compress-debug-sections=zstd -o conftest.o conftest.s > /dev/null 2>&1
5969      then
5970        gcc_cv_as_compress_debug=2
5971      fi
5972    else
5973      gcc_cv_as_compress_debug=0
5974    fi])
5975 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
5976 [Define to the level of your assembler's compressed debug section support.])
5977 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
5978 [Define to the assembler option to enable compressed debug sections.])
5979 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
5980 [Define to the assembler option to disable compressed debug sections.])
5982 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,,
5983 [.lcomm bar,4,16],,
5984 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
5985   [Define if your assembler supports .lcomm with an alignment field.])])
5987 if test x$with_sysroot = x && test x$host = x$target \
5988    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
5989    && test "$prefix" != "NONE"; then
5990   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
5991 [Define to PREFIX/include if cpp should also search that directory.])
5994 # Determine the version of glibc, if any, used on the target.
5995 AC_MSG_CHECKING([for target glibc version])
5996 AC_ARG_WITH([glibc-version],
5997   [AS_HELP_STRING([--with-glibc-version=M.N],
5998     [assume GCC used with glibc version M.N or later])], [
5999 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
6000   glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
6001   glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
6002 else
6003   AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
6004 fi], [
6005 glibc_version_major=0
6006 glibc_version_minor=0
6007 [if test -f $target_header_dir/features.h \
6008   && glibc_version_major_define=`$EGREP '^[     ]*#[    ]*define[       ]+__GLIBC__[    ]+[0-9]' $target_header_dir/features.h` \
6009   && glibc_version_minor_define=`$EGREP '^[     ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+[0-9]' $target_header_dir/features.h`; then
6010   glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[      ]*//'`
6011   glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[        ]*//'`
6012 fi]])
6013 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
6014 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
6015 [GNU C Library major version number used on the target, or 0.])
6016 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
6017 [GNU C Library minor version number used on the target, or 0.])
6019 AC_ARG_ENABLE(gnu-unique-object,
6020  [AS_HELP_STRING([--enable-gnu-unique-object],
6021    [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
6022  [case $enable_gnu_unique_object in
6023     yes | no) ;;
6024     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
6025 Valid choices are 'yes' and 'no'.]) ;;
6026   esac],
6027  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,,
6028    [.type foo, '$target_type_format_char'gnu_unique_object],,
6029 # We need to unquote above to to use the definition from config.gcc.
6030 # Also check for ld.so support, i.e. glibc 2.11 or higher.
6031    [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
6032    )])
6033 if test x$enable_gnu_unique_object = xyes; then
6034   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
6035    [Define if your assembler supports @gnu_unique_object.])
6038 AC_CACHE_CHECK([assembler for tolerance to line number 0],
6039  [gcc_cv_as_line_zero],
6040  [gcc_cv_as_line_zero=no
6041   if test "x$gcc_cv_as" != x; then
6042     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
6043     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
6044        test "x`cat conftest.out`" = x
6045     then
6046       gcc_cv_as_line_zero=yes
6047     else
6048       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
6049       cat conftest.s >&AS_MESSAGE_LOG_FD
6050       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
6051       cat conftest.out >&AS_MESSAGE_LOG_FD
6052     fi
6053     rm -f conftest.o conftest.s conftest.out
6054   fi])
6055 if test "x$gcc_cv_as_line_zero" = xyes; then
6056   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
6057 [Define if the assembler won't complain about a line such as # 0 "" 2.])
6060 AC_MSG_CHECKING(support for thin archives)
6061 thin_archive_support=no
6062 echo 'int main (void) { return 0; }' > conftest.c
6063 if ($AR --version | sed 1q | grep "GNU ar" \
6064     && $CC $CFLAGS -c conftest.c \
6065     && $AR rcT conftest.a conftest.o \
6066     && $CC $CFLAGS $LDFLAGS -o conftest conftest.a) >/dev/null 2>&1; then
6067   thin_archive_support=yes
6069 rm -f conftest.c conftest.o conftest.a conftest
6070 AC_MSG_RESULT($thin_archive_support)
6071 AC_SUBST(thin_archive_support)
6073 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
6074 gcc_cv_ld_eh_frame_hdr=no
6075 if test $in_tree_ld = yes ; then
6076   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 12 -o "$gcc_cv_gld_major_version" -gt 2 \
6077      && test $in_tree_ld_is_elf = yes; then
6078     gcc_cv_ld_eh_frame_hdr=yes
6079   fi
6080 elif test x$gcc_cv_ld != x; then
6081   if echo "$ld_ver" | grep GNU > /dev/null; then
6082     # Check if linker supports --eh-frame-hdr option
6083     if $gcc_cv_ld --help 2>&1 | grep eh-frame-hdr > /dev/null; then
6084       gcc_cv_ld_eh_frame_hdr=yes
6085     fi
6086   else
6087     case "$target" in
6088       *-*-solaris2*)
6089         # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
6090         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
6091           gcc_cv_ld_eh_frame_hdr=yes
6092         fi
6093         ;;
6094     esac
6095   fi
6097 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
6098 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
6099         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
6100 [Define if your linker supports .eh_frame_hdr.])
6102 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
6104 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
6105 gcc_cv_ld_eh_frame_ciev3=no
6106 if test $in_tree_ld = yes ; then
6107   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
6108      && test $in_tree_ld_is_elf = yes; then
6109     gcc_cv_ld_eh_frame_ciev3=yes
6110   fi
6111 elif test x$gcc_cv_ld != x; then
6112   if echo "$ld_ver" | grep GNU > /dev/null; then
6113     gcc_cv_ld_eh_frame_ciev3=yes
6114     if test 0"$ld_date" -lt 20040513; then
6115       if test -n "$ld_date"; then
6116         # If there was date string, but was earlier than 2004-05-13, fail
6117         gcc_cv_ld_eh_frame_ciev3=no
6118       elif test "$ld_vers_major" -lt 2; then
6119         gcc_cv_ld_eh_frame_ciev3=no
6120       elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
6121         gcc_cv_ld_eh_frame_ciev3=no
6122       fi
6123     fi
6124   else
6125     case "$target" in
6126       *-*-solaris2*)
6127         # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
6128         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
6129           gcc_cv_ld_eh_frame_ciev3=yes
6130         fi
6131         ;;
6132     esac
6133   fi
6135 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
6136   [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
6137   [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
6138 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
6140 AC_MSG_CHECKING(linker position independent executable support)
6141 gcc_cv_ld_pie=no
6142 if test $in_tree_ld = yes ; then
6143   case "$target" in
6144     # Full PIE support on Solaris was only introduced in gld 2.26.
6145     *-*-solaris2*)  gcc_gld_pie_min_version=26 ;;
6146     *)              gcc_gld_pie_min_version=15 ;;
6147   esac
6148   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge "$gcc_gld_pie_min_version" -o "$gcc_cv_gld_major_version" -gt 2 \
6149      && test $in_tree_ld_is_elf = yes; then
6150     gcc_cv_ld_pie=yes
6151   fi
6152 elif test x$gcc_cv_ld != x; then
6153   # Check if linker supports -pie option
6154   if $gcc_cv_ld --help 2>&1 | grep -- -pie > /dev/null; then
6155     gcc_cv_ld_pie=yes
6156     case "$target" in
6157       *-*-solaris2*)
6158         if echo "$ld_ver" | grep GNU > /dev/null \
6159           && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
6160           gcc_cv_ld_pie=no
6161         fi
6162         ;;
6163     esac
6164   else
6165     case "$target" in
6166       *-*-solaris2.1[[1-9]]*)
6167         # Solaris 11.3 added PIE support.
6168         if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
6169           gcc_cv_ld_pie=yes
6170         fi
6171         ;;
6172     esac
6173   fi
6175 if test x"$gcc_cv_ld_pie" = xyes; then
6176         AC_DEFINE(HAVE_LD_PIE, 1,
6177 [Define if your linker supports PIE option.])
6179 AC_MSG_RESULT($gcc_cv_ld_pie)
6181 AC_MSG_CHECKING(linker PIE support with copy reloc)
6182 gcc_cv_ld_pie_copyreloc=no
6183 if test $gcc_cv_ld_pie = yes ; then
6184   if test $in_tree_ld = yes ; then
6185     if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
6186       gcc_cv_ld_pie_copyreloc=yes
6187     fi
6188   elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6189     # Check if linker supports -pie option with copy reloc
6190     case "$target" in
6191     i?86-*-linux* | x86_64-*-linux*)
6192       cat > conftest1.s <<EOF
6193         .globl  a_glob
6194         .data
6195         .type   a_glob, @object
6196         .size   a_glob, 4
6197 a_glob:
6198         .long   2
6200       cat > conftest2.s <<EOF
6201         .text
6202         .globl  main
6203         .type   main, @function
6204 main:
6205         movl    %eax, a_glob(%rip)
6206         .size   main, .-main
6207         .globl  ptr
6208         .section        .data.rel,"aw",@progbits
6209         .type   ptr, @object
6210 ptr:
6211         .quad   a_glob
6213       if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6214          && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
6215          && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6216          && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
6217         gcc_cv_ld_pie_copyreloc=yes
6218       fi
6219       rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
6220       ;;
6221     esac
6222   fi
6224 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
6225   [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
6226   [Define 0/1 if your linker supports -pie option with copy reloc.])
6227 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
6229 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
6230 gcc_cv_ld_eh_gc_sections=no
6231 if test $in_tree_ld = yes ; then
6232   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 17 -o "$gcc_cv_gld_major_version" -gt 2 \
6233      && test $in_tree_ld_is_elf = yes; then
6234     gcc_cv_ld_eh_gc_sections=yes
6235   fi
6236 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
6237   cat > conftest.s <<EOF
6238         .section        .text
6239 .globl _start
6240         .type _start, @function
6241 _start:
6242         .long foo
6243         .size _start, .-_start
6244         .section        .text.foo,"ax",@progbits
6245         .type foo, @function
6246 foo:
6247         .long 0
6248         .size foo, .-foo
6249         .section        .gcc_except_table.foo,"a",@progbits
6250 .L0:
6251         .long 0
6252         .section        .eh_frame,"a",@progbits
6253         .long .L0
6255   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6256     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6257          | grep "gc-sections option ignored" > /dev/null; then
6258       gcc_cv_ld_eh_gc_sections=no
6259     elif $gcc_cv_objdump -h conftest 2> /dev/null \
6260          | grep gcc_except_table > /dev/null; then
6261       gcc_cv_ld_eh_gc_sections=yes
6262       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
6263       if test x$gcc_cv_as_comdat_group != xyes; then
6264         gcc_cv_ld_eh_gc_sections=no
6265         cat > conftest.s <<EOF
6266         .section        .text
6267 .globl _start
6268         .type _start, @function
6269 _start:
6270         .long foo
6271         .size _start, .-_start
6272         .section        .gnu.linkonce.t.foo,"ax",@progbits
6273         .type foo, @function
6274 foo:
6275         .long 0
6276         .size foo, .-foo
6277         .section        .gcc_except_table.foo,"a",@progbits
6278 .L0:
6279         .long 0
6280         .section        .eh_frame,"a",@progbits
6281         .long .L0
6283         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6284           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6285                | grep "gc-sections option ignored" > /dev/null; then
6286             gcc_cv_ld_eh_gc_sections=no
6287           elif $gcc_cv_objdump -h conftest 2> /dev/null \
6288                | grep gcc_except_table > /dev/null; then
6289             gcc_cv_ld_eh_gc_sections=yes
6290           fi
6291         fi
6292       fi
6293     fi
6294   fi
6295   rm -f conftest.s conftest.o conftest
6297 case "$target" in
6298   hppa*-*-linux*)
6299     # ??? This apparently exposes a binutils bug with PC-relative relocations.
6300     gcc_cv_ld_eh_gc_sections=no
6301     ;;
6302 esac
6303 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
6304         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
6305   [Define if your linker supports garbage collection of
6306    sections in presence of EH frames.])
6308 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
6310 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
6311 gcc_cv_ld_eh_gc_sections_bug=no
6312 if test $in_tree_ld = yes ; then
6313   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -lt 19 -o "$gcc_cv_gld_major_version" -lt 2 \
6314      && test $in_tree_ld_is_elf = yes; then
6315     gcc_cv_ld_eh_gc_sections_bug=yes
6316   fi
6317 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x -a x$gcc_cv_as_comdat_group = xyes; then
6318   gcc_cv_ld_eh_gc_sections_bug=yes
6319   cat > conftest.s <<EOF
6320         .section        .text
6321 .globl _start
6322         .type _start, @function
6323 _start:
6324         .long foo
6325         .size _start, .-_start
6326         .section        .text.startup.foo,"ax",@progbits
6327         .type foo, @function
6328 foo:
6329         .long 0
6330         .size foo, .-foo
6331         .section        .gcc_except_table.foo,"a",@progbits
6332 .L0:
6333         .long 0
6334         .section        .eh_frame,"a",@progbits
6335         .long .L0
6337   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6338     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6339          | grep "gc-sections option ignored" > /dev/null; then
6340       :
6341     elif $gcc_cv_objdump -h conftest 2> /dev/null \
6342          | grep gcc_except_table > /dev/null; then
6343       gcc_cv_ld_eh_gc_sections_bug=no
6344     fi
6345   fi
6346   rm -f conftest.s conftest.o conftest
6348 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
6349         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
6350   [Define if your linker has buggy garbage collection of
6351    sections support when .text.startup.foo like sections are used.])
6353 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
6355 AC_MSG_CHECKING(linker for compressed debug sections)
6356 # GNU ld/gold support --compressed-debug-sections=zlib since binutils 2.26.
6357 if $gcc_cv_ld --help 2>&1 | grep -- '--compress-debug-sections.*\<zlib-gabi\>' > /dev/null; then
6358     gcc_cv_ld_compress_debug=1
6359     gcc_cv_ld_compress_debug_option="--compress-debug-sections"
6360     # Detect zstd debug section compression support
6361     if $gcc_cv_ld --help 2>&1 | grep -- '--compress-debug-sections.*\<zstd\>' > /dev/null; then
6362       gcc_cv_ld_compress_debug=2
6363     fi
6364 else
6365 changequote(,)dnl
6366   case "${target}" in
6367     *-*-solaris2*)
6368       # Introduced in Solaris 11.2.
6369       if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
6370         gcc_cv_ld_compress_debug=1
6371         gcc_cv_ld_compress_debug_option="-z compress-sections"
6372       else
6373         gcc_cv_ld_compress_debug=0
6374       fi
6375       ;;
6376     *)
6377       # Assume linkers other than GNU ld don't support compessed debug
6378       # sections.
6379       gcc_cv_ld_compress_debug=0
6380       ;;
6381   esac
6382 changequote([,])dnl
6384 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
6385 [Define to the level of your linker's compressed debug section support.])
6386 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
6387 [Define to the linker option to enable compressed debug sections.])
6388 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
6390 if test x"$ld64_flag" = x"yes"; then
6392   # Set defaults for possibly untestable items.
6393   gcc_cv_ld64_export_dynamic=0
6394   gcc_cv_ld64_platform_version=0
6395   gcc_cv_ld64_demangle=0
6397   if test "$build" = "$host"; then
6398     darwin_try_test=1
6399   else
6400     darwin_try_test=0
6401   fi
6403   # On Darwin, because of FAT library support, it is often possible to execute
6404   # exes from compatible archs even when the host differs from the build system.
6405   case "$build","$host" in
6406     x86_64-*-darwin*,i?86-*-darwin* | powerpc64*-*-darwin*,powerpc*-*-darwin*)
6407         darwin_try_test=1;;
6408     *) ;;
6409   esac
6411   # If the configurer specified a minimum ld64 version to be supported, then use
6412   # that to determine feature support.
6413   if test x"${gcc_cv_ld64_version}" != x; then
6414     AC_MSG_CHECKING(ld64 specified version)
6415     gcc_cv_ld64_major=`echo "$gcc_cv_ld64_version" | sed -e 's/\..*//'`
6416     AC_MSG_RESULT($gcc_cv_ld64_major)
6417     if test "$gcc_cv_ld64_major" -ge 97; then
6418       gcc_cv_ld64_demangle=1
6419     fi
6420     if test "$gcc_cv_ld64_major" -ge 236; then
6421       gcc_cv_ld64_export_dynamic=1
6422     fi
6423     if test "$gcc_cv_ld64_major" -ge 512; then
6424       gcc_cv_ld64_platform_version=1
6425     fi
6426   elif test -x "$gcc_cv_ld" -a "$darwin_try_test" -eq 1; then
6427     # If the version was not specified, try to find it.
6428     AC_MSG_CHECKING(linker version)
6429     if test x"${gcc_cv_ld64_version}" = x; then
6430       gcc_cv_ld64_version=`$gcc_cv_ld -v 2>&1 | $EGREP 'ld64|dyld' \
6431       | sed -e 's/.*ld64-//' -e 's/.*dyld-//'| awk '{print $1}'`
6432     fi
6433     AC_MSG_RESULT($gcc_cv_ld64_version)
6435     AC_MSG_CHECKING(linker for -demangle support)
6436     gcc_cv_ld64_demangle=1
6437     if $gcc_cv_ld -demangle < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6438       gcc_cv_ld64_demangle=0
6439     fi
6440     AC_MSG_RESULT($gcc_cv_ld64_demangle)
6442     AC_MSG_CHECKING(linker for -export_dynamic support)
6443     gcc_cv_ld64_export_dynamic=1
6444     if $gcc_cv_ld -export_dynamic < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6445       gcc_cv_ld64_export_dynamic=0
6446     fi
6447     AC_MSG_RESULT($gcc_cv_ld64_export_dynamic)
6449     AC_MSG_CHECKING(linker for -platform_version support)
6450     gcc_cv_ld64_platform_version=1
6451     if $gcc_cv_ld -platform_version macos 10.5 0.0 < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6452       gcc_cv_ld64_platform_version=0
6453     fi
6454     AC_MSG_RESULT($gcc_cv_ld64_platform_version)
6455   fi
6457   if test x"${gcc_cv_ld64_version}" != x; then
6458     AC_DEFINE_UNQUOTED(LD64_VERSION, "${gcc_cv_ld64_version}",
6459       [Define to ld64 version.])
6460   fi
6462   AC_DEFINE_UNQUOTED(LD64_HAS_DEMANGLE, $gcc_cv_ld64_demangle,
6463   [Define to 1 if ld64 supports '-demangle'.])
6465   AC_DEFINE_UNQUOTED(LD64_HAS_EXPORT_DYNAMIC, $gcc_cv_ld64_export_dynamic,
6466   [Define to 1 if ld64 supports '-export_dynamic'.])
6468   AC_DEFINE_UNQUOTED(LD64_HAS_PLATFORM_VERSION, $gcc_cv_ld64_platform_version,
6469   [Define to 1 if ld64 supports '-platform_version'.])
6472 if test x"$dsymutil_flag" = x"yes"; then
6474     # If the user specified a dsymutil path, then we will already have the
6475     # version string, otherwise, pick it up.
6476     if test x"$gcc_cv_dsymutil" = x; then
6477         AC_MSG_WARN([dsymutil is a required tool for this system, but not found])
6478         dsymutil_vers="tool unspecified"
6479     elif test x"$dsymutil_vers" = x; then
6480         dsymutil_vers=`$gcc_cv_dsymutil -v /dev/null 2>&1`
6481     fi
6483     dsymutil_temp=`echo $dsymutil_vers | sed 1q`
6484     AC_MSG_CHECKING(dsymutil version "$dsymutil_temp")
6485     if echo $dsymutil_temp | grep dwarfutils- > /dev/null; then
6486       dsymutil_kind=DWARFUTILS
6487       dsymutil_vers=`echo $dsymutil_temp | sed 's/.*dwarfutils-\([[0-9\.]]*\).*/\1/'`
6488     elif echo $dsymutil_temp | grep clang- > /dev/null; then
6489       dsymutil_kind=CLANG
6490       dsymutil_vers=`echo $dsymutil_temp | sed 's/.*clang-\([[0-9\.]]*\).*/\1/'`
6491     elif echo $dsymutil_temp | grep 'LLVM version ' > /dev/null; then
6492       dsymutil_kind=LLVM
6493       dsymutil_vers=`echo $dsymutil_temp | sed 's/.*LLVM\ version\ \([[0-9\.]]*\).*/\1/'`
6494     else
6495       dsymutil_kind=DET_UNKNOWN
6496       dsymutil_vers="0.0"
6497     fi
6498     dsymutil_major=`expr "$dsymutil_vers" : '\([[0-9]]*\)'`
6499     dsymutil_minor=`expr "$dsymutil_vers" : '[[0-9]]*\.\([[0-9]]*\)'`
6500     dsymutil_tiny=`expr "$dsymutil_vers" : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
6501     if test x"${dsymutil_minor}" = x; then
6502       dsymutil_minor=0
6503     fi
6504     if test x"${dsymutil_tiny}" = x; then
6505       dsymutil_tiny=0
6506     fi
6507     AC_DEFINE_UNQUOTED(DSYMUTIL_VERSION, [$dsymutil_kind,${dsymutil_major},${dsymutil_minor},${dsymutil_tiny}],
6508         [Define to the dsymutil version.])
6509     AC_MSG_RESULT($dsymutil_vers : $dsymutil_kind ${dsymutil_major} ${dsymutil_minor} ${dsymutil_tiny} )
6512 case $target_os in
6513   win32 | pe | cygwin* | mingw32*)
6514     AC_MSG_CHECKING(broken PE linker dwarf5 support)
6515     gcc_cv_ld_broken_pe_dwarf5=yes
6516     if test $in_tree_ld = yes ; then
6517       if grep -q '\.debug_loclists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6518            $gcc_cv_ld_gld_srcdir/scripttempl/pe*.sc \
6519          && grep -q '\.debug_rnglists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6520               $gcc_cv_ld_gld_srcdir/scripttempl/pe*.sc; then
6521         gcc_cv_ld_broken_pe_dwarf5=no
6522       fi
6523     else
6524       if $gcc_cv_ld --verbose 2>&1 | grep -q '\.debug_loclists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6525          && $gcc_cv_ld --verbose 2>&1 | grep -q '\.debug_rnglists.*BLOCK.*__section_alignment__.*NOLOAD.*:'; then
6526         gcc_cv_ld_broken_pe_dwarf5=no
6527       fi
6528     fi
6529     if test x$gcc_cv_ld_broken_pe_dwarf5 = xyes; then
6530       AC_DEFINE(HAVE_LD_BROKEN_PE_DWARF5, 1,
6531                 [Define if the PE linker has broken DWARF 5 support.])
6532     fi
6533     AC_MSG_RESULT($gcc_cv_ld_broken_pe_dwarf5)
6535     AC_MSG_CHECKING(PE linker --disable-dynamicbase support)
6536     gcc_cv_ld_disable_dynamicbase=no
6537     if test $in_tree_ld = yes; then
6538       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 36 -o "$gcc_cv_gld_major_version" -gt 2; then \
6539         gcc_cv_ld_disable_dynamicbase=yes
6540       fi
6541     else
6542       if $gcc_cv_ld --help 2>&1 | grep -q 'disable\-]dynamicbase' > /dev/null; then
6543         gcc_cv_ld_disable_dynamicbase=yes
6544       fi
6545     fi
6546     if test x"$gcc_cv_ld_disable_dynamicbase" = xyes; then
6547       AC_DEFINE(HAVE_LD_PE_DISABLE_DYNAMICBASE, 1,
6548                 [Define if the PE linker supports --disable-dynamicbase option.])
6549     fi
6550     AC_MSG_RESULT($gcc_cv_ld_disable_dynamicbase)
6551     ;;
6552 esac
6554 # --------
6555 # UNSORTED
6556 # --------
6558 AC_CACHE_CHECK(linker --as-needed support,
6559 gcc_cv_ld_as_needed,
6560 [gcc_cv_ld_as_needed=no
6561 gcc_cv_ld_as_needed_option='--as-needed'
6562 gcc_cv_ld_no_as_needed_option='--no-as-needed'
6563 if test $in_tree_ld = yes ; then
6564   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
6565      && test $in_tree_ld_is_elf = yes; then
6566     gcc_cv_ld_as_needed=yes
6567     if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 28; then
6568       gcc_cv_ld_as_needed_option='--push-state --as-needed'
6569       gcc_cv_ld_no_as_needed_option='--pop-state'
6570     fi
6571   fi
6572 elif test x$gcc_cv_ld != x; then
6573   # Check if linker supports --as-needed and --no-as-needed options
6574   if $gcc_cv_ld --help 2>&1 | grep as-needed > /dev/null; then
6575     gcc_cv_ld_as_needed=yes
6576     if $gcc_cv_ld --help 2>&1 | grep push-state > /dev/null \
6577        && $gcc_cv_ld --help 2>&1 | grep pop-state > /dev/null \
6578        && echo "$ld_ver" | grep GNU > /dev/null \
6579        && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 28; then
6580       # Use these options only when both ld.bfd and ld.gold support
6581       # --push-state/--pop-state, which unfortunately wasn't added
6582       # at the same time.
6583       gcc_cv_ld_as_needed_option='--push-state --as-needed'
6584       gcc_cv_ld_no_as_needed_option='--pop-state'
6585     fi
6586   fi
6587   case "$target:$gnu_ld" in
6588     *-*-solaris2*:no)
6589       # Solaris 2 ld always supports -z ignore/-z record.  Prefer the native
6590       # forms.
6591       gcc_cv_ld_as_needed=yes
6592       gcc_cv_ld_as_needed_option="-z ignore"
6593       gcc_cv_ld_no_as_needed_option="-z record"
6594       ;;
6595   esac
6597 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
6598 # dl_iterate_phdr, i.e. since Solaris 11.
6599 case "$target" in
6600   *-*-solaris2.1[[1-9]]*)
6601     case "$target" in
6602     i?86-*-* | x86_64-*-*)
6603       if echo "$ld_ver" | grep GNU > /dev/null; then
6604         # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
6605         gcc_cv_ld_as_needed=no
6606       fi
6607       ;;
6608     esac
6609     ;;
6610   *-*-solaris2*)
6611     gcc_cv_ld_as_needed=no
6612     ;;
6613 esac
6615 if test x"$gcc_cv_ld_as_needed" = xyes; then
6616         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
6617 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
6618         AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
6619 [Define to the linker option to ignore unused dependencies.])
6620         AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
6621 [Define to the linker option to keep unused dependencies.])
6624 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
6625 saved_LDFLAGS="$LDFLAGS"
6626 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
6627   LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
6628   AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
6629     [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
6630 done
6631 LDFLAGS="$saved_LDFLAGS"
6632 if test "x$gcc_cv_ld_clearcap" = xyes; then
6633   AC_DEFINE([HAVE_LD_CLEARCAP], 1,
6634 [Define if the linker supports clearing hardware capabilities via mapfile.])
6635   AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
6637 AC_MSG_RESULT($gcc_cv_ld_clearcap)
6639 case "$target" in
6640   powerpc*-*-*)
6641     case "$target" in
6642       *le-*-linux*)
6643         emul_name="-melf32lppc"
6644         ;;
6645       *)
6646         emul_name="-melf32ppc"
6647         ;;
6648     esac
6649     AC_CACHE_CHECK(linker .gnu.attributes long double support,
6650     gcc_cv_ld_ppc_attr,
6651     [gcc_cv_ld_ppc_attr=no
6652     if test x"$ld_is_gold" = xyes; then
6653       gcc_cv_ld_ppc_attr=yes
6654     elif test $in_tree_ld = yes ; then
6655       if test "$gcc_cv_gld_major_version" -eq 2 \
6656                 -a "$gcc_cv_gld_minor_version" -ge 28 \
6657                 -o "$gcc_cv_gld_major_version" -gt 2; then
6658         gcc_cv_ld_ppc_attr=yes
6659       fi
6660     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6661       # check that merging the long double .gnu_attribute doesn't warn
6662       cat > conftest1.s <<EOF
6663         .gnu_attribute 4,1
6665       cat > conftest2.s <<EOF
6666         .gnu_attribute 4,9
6668       if $gcc_cv_as -a32 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6669          && $gcc_cv_as -a32 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6670          && $gcc_cv_ld $emul_name -r -o conftest.o conftest1.o conftest2.o > /dev/null 2> conftest.err \
6671          && test ! -s conftest.err; then
6672         gcc_cv_ld_ppc_attr=yes
6673       fi
6674       rm -f conftest.err conftest.o conftest1.o conftest2.o conftest1.s conftest2.s
6675     fi
6676     ])
6677     if test x$gcc_cv_ld_ppc_attr = xyes; then
6678       AC_DEFINE(HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE, 1,
6679     [Define if your PowerPC linker has .gnu.attributes long double support.])
6680     fi
6681     ;;
6682 esac
6684 case "$target:$tm_file" in
6685   powerpc64*-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
6686   case "$target" in
6687      *le-*-linux*)
6688      emul_name="-melf64lppc"
6689       ;;
6690      *-*-linux*)
6691      emul_name="-melf64ppc"
6692       ;;
6693      *le-*-freebsd*)
6694      emul_name="-melf64lppc_fbsd"
6695       ;;
6696      *-*-freebsd*)
6697      emul_name="-melf64ppc_fbsd"
6698       ;;
6699   esac
6700     AC_CACHE_CHECK(linker support for omitting dot symbols,
6701     gcc_cv_ld_no_dot_syms,
6702     [gcc_cv_ld_no_dot_syms=no
6703     if test x"$ld_is_gold" = xyes; then
6704       gcc_cv_ld_no_dot_syms=yes
6705     elif test $in_tree_ld = yes ; then
6706       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2; then
6707         gcc_cv_ld_no_dot_syms=yes
6708       fi
6709     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6710       cat > conftest1.s <<EOF
6711         .text
6712         bl .foo
6714       cat > conftest2.s <<EOF
6715         .section ".opd","aw"
6716         .align 3
6717         .globl foo
6718         .type foo,@function
6719 foo:
6720         .quad .LEfoo,.TOC.@tocbase,0
6721         .text
6722 .LEfoo:
6723         blr
6724         .size foo,.-.LEfoo
6726       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6727          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6728          && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
6729         gcc_cv_ld_no_dot_syms=yes
6730       fi
6731       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
6732     fi
6733     ])
6734     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
6735       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
6736     [Define if your PowerPC64 linker only needs function descriptor syms.])
6737     fi
6739     AC_CACHE_CHECK(linker large toc support,
6740     gcc_cv_ld_large_toc,
6741     [gcc_cv_ld_large_toc=no
6742     if test x"$ld_is_gold" = xyes; then
6743       gcc_cv_ld_large_toc=yes
6744     elif test $in_tree_ld = yes ; then
6745       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 21 -o "$gcc_cv_gld_major_version" -gt 2; then
6746         gcc_cv_ld_large_toc=yes
6747       fi
6748     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6749       cat > conftest.s <<EOF
6750         .section ".tbss","awT",@nobits
6751         .align 3
6752 ie0:    .space 8
6753         .global _start
6754         .text
6755 _start:
6756         addis 9,13,ie0@got@tprel@ha
6757         ld 9,ie0@got@tprel@l(9)
6759       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6760          && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
6761         gcc_cv_ld_large_toc=yes
6762       fi
6763       rm -f conftest conftest.o conftest.s
6764     fi
6765     ])
6766     if test x"$gcc_cv_ld_large_toc" = xyes; then
6767       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6768     [Define if your PowerPC64 linker supports a large TOC.])
6769     fi
6771     AC_CACHE_CHECK(linker toc pointer alignment,
6772     gcc_cv_ld_toc_align,
6773     [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
6774       cat > conftest.s <<EOF
6775         .global _start
6776         .text
6777 _start:
6778         addis 9,2,x@got@ha
6779         .section .data.rel.ro,"aw",@progbits
6780         .p2align 16
6781         .space 32768
6782 x:      .quad .TOC.
6784       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6785          && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
6786         gcc_cv_ld_toc_align=`$gcc_cv_nm conftest | ${AWK} '/\.TOC\./ { match ($0, "0[[[:xdigit:]]]*", a); print strtonum ("0x" substr(a[[0]], length(a[[0]])-3)) }'`
6787       fi
6788       rm -f conftest conftest.o conftest.s
6789     fi
6790     ])
6791     if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
6792       AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
6793     [Define to .TOC. alignment forced by your linker.])
6794     fi
6795     ;;
6796 esac
6798 case "$target" in
6799   *-*-aix*)
6800     AC_CACHE_CHECK(linker large toc support,
6801     gcc_cv_ld_large_toc,
6802     [gcc_cv_ld_large_toc=no
6803     if test x$gcc_cv_as != x ; then
6804       cat > conftest.s <<EOF
6805         .toc
6806 LC..1:
6807         .tc a[[TC]],a[[RW]]
6808         .extern a[[RW]]
6809         .csect .text[[PR]]
6810 .largetoctest:
6811         addis 9,LC..1@u(2)
6812         ld 3,LC..1@l(9)
6814       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
6815         gcc_cv_ld_large_toc=yes
6816       fi
6817       rm -f conftest conftest.o conftest.s
6818     fi
6819     ])
6820     if test x"$gcc_cv_ld_large_toc" = xyes; then
6821       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6822     [Define if your PowerPC64 linker supports a large TOC.])
6823     fi
6824     ;;
6825 esac
6827 AC_CACHE_CHECK(linker --build-id support,
6828   gcc_cv_ld_buildid,
6829   [gcc_cv_ld_buildid=no
6830   if test $in_tree_ld = yes ; then
6831     if test "$gcc_cv_gld_major_version" -eq 2 -a \
6832        "$gcc_cv_gld_minor_version" -ge 18 -o \
6833        "$gcc_cv_gld_major_version" -gt 2 \
6834        && test $in_tree_ld_is_elf = yes; then
6835       gcc_cv_ld_buildid=yes
6836     fi
6837   elif test x$gcc_cv_ld != x; then
6838     if $gcc_cv_ld --help 2>&1 | grep build-id > /dev/null; then
6839       gcc_cv_ld_buildid=yes
6840     fi
6841   fi])
6842 if test x"$gcc_cv_ld_buildid" = xyes; then
6843   AC_DEFINE(HAVE_LD_BUILDID, 1,
6844   [Define if your linker supports --build-id.])
6847 AC_ARG_ENABLE(linker-build-id,
6848 [AS_HELP_STRING([--enable-linker-build-id],
6849                 [compiler will always pass --build-id to linker])],
6851 enable_linker_build_id=no)
6853 if test x"$enable_linker_build_id" = xyes; then
6854   if test x"$gcc_cv_ld_buildid" = xyes; then
6855     AC_DEFINE(ENABLE_LD_BUILDID, 1,
6856     [Define if gcc should always pass --build-id to linker.])
6857   else
6858     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
6859   fi
6862 # In binutils 2.21, GNU ld gained support for new emulations fully
6863 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
6864 AC_CACHE_CHECK(linker *_sol2 emulation support,
6865   gcc_cv_ld_sol2_emulation,
6866   [gcc_cv_ld_sol2_emulation=no
6867   if test $in_tree_ld = yes ; then
6868     if test "$gcc_cv_gld_major_version" -eq 2 -a \
6869        "$gcc_cv_gld_minor_version" -ge 21 -o \
6870        "$gcc_cv_gld_major_version" -gt 2 \
6871        && test $in_tree_ld_is_elf = yes; then
6872       gcc_cv_ld_sol2_emulation=yes
6873     fi
6874   elif test x$gcc_cv_ld != x; then
6875     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
6876        grep _sol2 > /dev/null; then
6877       gcc_cv_ld_sol2_emulation=yes
6878     fi
6879   fi])
6880 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
6881   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
6882   [Define if your linker supports the *_sol2 emulations.])
6885 AC_CACHE_CHECK(linker --sysroot support,
6886   gcc_cv_ld_sysroot,
6887   [gcc_cv_ld_sysroot=no
6888   if test $in_tree_ld = yes ; then
6889       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 ; then
6890         gcc_cv_ld_sysroot=yes
6891       fi
6892   elif test x$gcc_cv_ld != x; then 
6893     if $gcc_cv_ld --help 2>&1 | grep sysroot > /dev/null; then
6894       gcc_cv_ld_sysroot=yes
6895     fi
6896   fi])
6897 if test x"$gcc_cv_ld_sysroot" = xyes; then
6898   AC_DEFINE(HAVE_LD_SYSROOT, 1,
6899   [Define if your linker supports --sysroot.])
6900 fi        
6902 case $target in
6903 *-*-solaris2*)
6904   # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
6905   AC_CACHE_CHECK([system-provided CRTs on Solaris],
6906     gcc_cv_solaris_crts,
6907     [gcc_cv_solaris_crts=no
6908      if test x$host != x$target; then
6909        if test "x$with_sysroot" = xyes; then
6910          target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
6911        else
6912          target_sysroot="${with_sysroot}"
6913        fi
6914      fi
6915      target_libdir="$target_sysroot/usr/lib"
6916      # At the time they were added, gcrt1.o became a symlink for backwards
6917      # compatibility on x86, while crt1.o was added on sparc, so check for that.
6918      case $target in
6919        i?86-*-solaris2* | x86_64-*-solaris2*)
6920          if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
6921          ;;
6922        sparc*-*-solaris2*)
6923          if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
6924          ;;
6925      esac])
6926   ;;
6927 esac
6928 if test x$gcc_cv_solaris_crts = xyes; then
6929   AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
6930             [Define if the system-provided CRTs are present on Solaris.])
6933 AC_ARG_ENABLE(libssp,
6934 [AS_HELP_STRING([--enable-libssp], [enable linking against libssp])],
6935 [case "${enableval}" in
6936   yes|no)
6937     ;;
6938   *)
6939     AC_MSG_ERROR([unknown libssp setting $enableval])
6940     ;;
6941 esac], [])
6943 # Test for stack protector support in target C library.
6944 AC_CACHE_CHECK(__stack_chk_fail in target C library,
6945   gcc_cv_libc_provides_ssp,
6946   [gcc_cv_libc_provides_ssp=no
6947   if test "x$enable_libssp" = "xno"; then
6948     gcc_cv_libc_provides_ssp=yes
6949   elif test "x$enable_libssp" = "xyes"; then
6950     gcc_cv_libc_provides_ssp=no
6951   else
6952     case "$target" in
6953        *-*-musl*)
6954          # All versions of musl provide stack protector
6955          gcc_cv_libc_provides_ssp=yes;;
6956        *-*-linux* | *-*-kfreebsd*-gnu)
6957       # glibc 2.4 and later provides __stack_chk_fail and
6958       # either __stack_chk_guard, or TLS access to stack guard canary.
6959       GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
6960       [if test -f $target_header_dir/features.h \
6961          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
6962             $target_header_dir/features.h > /dev/null; then
6963         if $EGREP '^[   ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
6964              $target_header_dir/features.h > /dev/null && \
6965              test -f $target_header_dir/bits/uClibc_config.h && \
6966              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
6967              $target_header_dir/bits/uClibc_config.h > /dev/null; then
6968           gcc_cv_libc_provides_ssp=yes
6969         fi
6970       # all versions of Bionic support stack protector
6971       elif test -f $target_header_dir/sys/cdefs.h \
6972         && $EGREP '^[  ]*#[    ]*define[       ]+__BIONIC__[   ]+1' \
6973            $target_header_dir/sys/cdefs.h > /dev/null; then
6974          gcc_cv_libc_provides_ssp=yes
6975       fi]])
6976         ;;
6977        *-*-gnu*)
6978          # Avoid complicated tests (see
6979          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
6980          # simply assert that glibc does provide this, which is true for all
6981          # realistically usable GNU/Hurd configurations.
6982          # All supported versions of musl provide it as well
6983          gcc_cv_libc_provides_ssp=yes;;
6984        *-*-darwin* | *-*-freebsd* | *-*-netbsd*)
6985          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
6986            [echo "no __stack_chk_fail on this target"])
6987         ;;
6988        *) gcc_cv_libc_provides_ssp=no ;;
6989     esac
6990   fi])
6992 if test x$gcc_cv_libc_provides_ssp = xyes; then
6993   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
6994             [Define if your target C library provides stack protector support])
6997 # Check whether --enable-default-ssp was given.
6998 AC_ARG_ENABLE(default-ssp,
6999 [AS_HELP_STRING([--enable-default-ssp],
7000   [enable Stack Smashing Protection as default])],[
7001 if test x$gcc_cv_libc_provides_ssp = xyes; then
7002   case "$target" in
7003     ia64*-*-*) enable_default_ssp=no ;;
7004     *) enable_default_ssp=$enableval ;;
7005   esac
7006 else
7007   enable_default_ssp=no
7008 fi],
7009 enable_default_ssp=no)
7010 if test x$enable_default_ssp = xyes ; then
7011   AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
7012       [Define if your target supports default stack protector and it is enabled.])
7014 AC_SUBST([enable_default_ssp])
7016 # Test for <sys/sdt.h> on the target.
7017 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
7018 AC_CACHE_CHECK([sys/sdt.h in the target C library], [gcc_cv_sys_sdt_h], [
7019   gcc_cv_sys_sdt_h=no
7020   if test -f $target_header_dir/sys/sdt.h; then
7021     gcc_cv_sys_sdt_h=yes
7022   fi
7024 AS_IF([test x$gcc_cv_sys_sdt_h = xyes], [
7025   AC_DEFINE([HAVE_SYS_SDT_H], [1],
7026             [Define if your target C library provides sys/sdt.h])
7029 # Check if TFmode long double should be used by default or not.
7030 # Some glibc targets used DFmode long double, but with glibc 2.4
7031 # and later they can use TFmode.
7032 case "$target" in
7033   powerpc*-*-linux* | \
7034   sparc*-*-linux* | \
7035   s390*-*-linux* | \
7036   alpha*-*-linux*)
7037     AC_ARG_WITH(long-double-128,
7038       [AS_HELP_STRING([--with-long-double-128],
7039                       [use 128-bit long double by default])],
7040       gcc_cv_target_ldbl128="$with_long_double_128", [
7041       case "$target" in
7042         s390*-*-linux-musl*)
7043           gcc_cv_target_ldbl128=yes
7044           ;;
7045         powerpc*-*-linux-musl*)
7046           gcc_cv_target_ldbl128=no
7047           ;;
7048         *)]
7049       [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
7050       [gcc_cv_target_ldbl128=no
7051       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
7052         $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
7053       && gcc_cv_target_ldbl128=yes
7054       ]])]
7055       [
7056           ;;
7057       esac
7058       ])
7059     ;;
7060 esac
7061 if test x$gcc_cv_target_ldbl128 = xyes; then
7062   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
7063             [Define if TFmode long double should be the default])
7066 # Check if TFmode long double target should use the IBM extended double or IEEE
7067 # 128-bit floating point formats if long doubles are 128-bits long.  The long
7068 # double type can only be switched on powerpc64 bit Linux systems where VSX is
7069 # supported.  Other PowerPC systems do not build the IEEE 128-bit emulator in
7070 # libgcc.
7071 AC_ARG_WITH([long-double-format],
7072   [AS_HELP_STRING([--with-long-double-format={ieee,ibm}]
7073                   [Specify whether PowerPC long double uses IEEE or IBM format])],[
7074 case "$target:$with_long_double_format" in
7075   powerpc64le-*-linux*:ieee | powerpc64le-*-linux*:ibm)
7076     :
7077     ;;
7078   powerpc64-*-linux*:ieee | powerpc64-*-linux*:ibm)
7079     # IEEE 128-bit emulation is only built on 64-bit VSX Linux systems
7080     case "$with_cpu" in
7081       power7 | power8 | power9 | power1*)
7082         :
7083         ;;
7084       *)
7085         AC_MSG_ERROR([Configuration option --with-long-double-format is only \
7086 supported if the default cpu is power7 or newer])
7087         with_long_double_format=""
7088         ;;
7089       esac
7090       ;;
7091   powerpc64*-*-linux*:*)
7092     AC_MSG_ERROR([--with-long-double-format argument should be ibm or ieee])
7093     with_long_double_format=""
7094     ;;
7095   *)
7096     AC_MSG_ERROR([Configure option --with-long-double-format is only supported \
7097 on 64-bit PowerPC VSX Linux systems])
7098     with_long_double_format=""
7099     ;;
7100 esac],
7101   [])
7103 # Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP
7104 # values in the TCB.  Currently, only GLIBC 2.23 and later support this.
7105 gcc_cv_libc_provides_hwcap_in_tcb=no
7106 case "$target" in
7107   powerpc*-*-linux*)
7108     GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], )
7109     ;;
7110 esac
7111 if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then
7112   AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1,
7113             [Define if your target C Library provides the AT_HWCAP value in the TCB])
7116 # Check if the target LIBC handles PT_GNU_STACK.
7117 gcc_cv_libc_gnustack=unknown
7118 case "$target" in
7119   mips*-*-linux-musl*)
7120     gcc_cv_libc_gnustack=yes
7121     ;;
7122   mips*-*-linux*)
7123     GCC_GLIBC_VERSION_GTE_IFELSE([2], [31], [gcc_cv_libc_gnustack=yes], )
7124     ;;
7125 esac
7126 if test x$gcc_cv_libc_gnustack = xyes; then
7127   AC_DEFINE(TARGET_LIBC_GNUSTACK, 1,
7128             [Define if your target C Library properly handles PT_GNU_STACK])
7131 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
7132 gcc_cv_target_dl_iterate_phdr=unknown
7133 case "$target" in
7134   *-*-solaris2*)
7135     gcc_cv_target_dl_iterate_phdr=yes
7136     ;;
7137   *-*-dragonfly* | *-*-freebsd*)
7138     if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
7139       gcc_cv_target_dl_iterate_phdr=yes
7140     else
7141       gcc_cv_target_dl_iterate_phdr=no
7142     fi
7143     ;;
7144   *-linux-musl*)
7145     gcc_cv_target_dl_iterate_phdr=yes
7146     ;;
7147 esac
7148 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
7149 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
7150    AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
7151 [Define if your target C library provides the `dl_iterate_phdr' function.])
7153 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
7155 # We no longer support different GC mechanisms.  Emit an error if
7156 # the user configures with --with-gc.
7157 AC_ARG_WITH(gc,
7158 [AS_HELP_STRING([--with-gc={page,zone}],
7159                 [this option is not supported anymore.  It used to choose
7160                  the garbage collection mechanism to use with the compiler])],
7161 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
7164 # Libraries to use on the host.  This will normally be set by the top
7165 # level Makefile.  Here we simply capture the value for our Makefile.
7166 if test -z "${HOST_LIBS+set}"; then
7167   HOST_LIBS=
7169 AC_SUBST(HOST_LIBS)
7171 # Use the system's zlib library.
7172 AM_ZLIB
7174 dnl Very limited version of automake's enable-maintainer-mode
7176 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
7177   dnl maintainer-mode is disabled by default
7178   AC_ARG_ENABLE(maintainer-mode,
7179 [AS_HELP_STRING([--enable-maintainer-mode],
7180                 [enable make rules and dependencies not useful
7181                  (and sometimes confusing) to the casual installer])],
7182       maintainer_mode=$enableval,
7183       maintainer_mode=no)
7185 AC_MSG_RESULT($maintainer_mode)
7187 if test "$maintainer_mode" = "yes"; then
7188   MAINT=''
7189 else
7190   MAINT='#'
7192 AC_SUBST(MAINT)dnl
7194 dnl Variables for tags utilities; copied from automake 1.16.4+'s init.m4
7195 if test -z "$CTAGS"; then
7196   CTAGS=ctags
7198 AC_SUBST([CTAGS])
7199 if test -z "$ETAGS"; then
7200   ETAGS=etags
7202 AC_SUBST([ETAGS])
7203 if test -z "$CSCOPE"; then
7204   CSCOPE=cscope
7206 AC_SUBST([CSCOPE])
7208 dnl Whether to prevent multiple front-ends from linking at the same time
7210 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
7211   AC_ARG_ENABLE(link-mutex,
7212 [AS_HELP_STRING([--enable-link-mutex],
7213                 [avoid linking multiple front-ends at once to avoid thrashing
7214                  on the build machine])],
7215       do_link_mutex=$enableval,
7216       do_link_mutex=no)
7217 AC_MSG_RESULT($do_link_mutex)
7219 if test "$do_link_mutex" = "yes"; then
7220    DO_LINK_MUTEX=true
7221    AC_MSG_WARN([--enable-link-mutex is deprecated and will be removed in the next release, use --enable-link-serialization instead])
7222 else
7223    DO_LINK_MUTEX=false
7225 AC_SUBST(DO_LINK_MUTEX)
7227 dnl Whether to prevent multiple GCC front-ends from linking at the same time
7229 AC_MSG_CHECKING([whether to serialize linking of multiple front-ends])
7230   AC_ARG_ENABLE(link-serialization,
7231 [AS_HELP_STRING([--enable-link-serialization],
7232                 [avoid linking multiple GCC front-ends at once using make
7233                  dependencies to avoid thrashing on the build machine])],
7234       do_link_serialization=$enableval,
7235       do_link_serialization=no)
7236 AC_MSG_RESULT($do_link_serialization)
7238 case "$do_link_serialization" in
7239   yes)
7240     DO_LINK_SERIALIZATION=1;;
7241   [[1-9]] | [[1-9]][[0-9]] | [[1-9]][[0-9]][[0-9]])
7242     DO_LINK_SERIALIZATION=$do_link_serialization;;
7243   no)
7244     DO_LINK_SERIALIZATION=;;
7245   *)
7246     AC_MSG_ERROR(bad value ${do_link_serialization} given for --enable-link-serialization) ;;
7247 esac
7248 AC_SUBST(DO_LINK_SERIALIZATION)
7250 # --------------
7251 # Language hooks
7252 # --------------
7254 # Make empty files to contain the specs and options for each language.
7255 # Then add #include lines to for a compiler that has specs and/or options.
7257 subdirs=
7258 lang_opt_files=
7259 lang_specs_files=
7260 lang_tree_files=
7261 # These (without "all_") are set in each config-lang.in.
7262 # `language' must be a single word so is spelled singularly.
7263 all_languages=
7264 all_compilers=
7265 all_outputs='Makefile'
7266 # List of language configure and makefile fragments.
7267 all_lang_configurefrags=
7268 all_lang_makefrags=
7269 # Additional files for gengtype
7270 all_gtfiles="$target_gtfiles"
7272 # These are the languages that are set in --enable-languages,
7273 # and are available in the GCC tree.
7274 all_selected_languages=
7276 # Add the language fragments.
7277 # Languages are added via two mechanisms.  Some information must be
7278 # recorded in makefile variables, these are defined in config-lang.in.
7279 # We accumulate them and plug them into the main Makefile.
7280 # The other mechanism is a set of hooks for each of the main targets
7281 # like `clean', `install', etc.
7283 language_hooks="Make-hooks"
7285 for lang in ${srcdir}/*/config-lang.in
7287 changequote(,)dnl
7288         test "$lang" = "${srcdir}/*/config-lang.in" && continue
7290         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
7291         if test "x$lang_alias" = x
7292         then
7293               echo "$lang doesn't set \$language." 1>&2
7294               exit 1
7295         fi
7296         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
7297         subdirs="$subdirs $subdir"
7299         # $gcc_subdir is where the gcc integration files are to be found
7300         # for a language, both for internal compiler purposes (compiler
7301         # sources implementing front-end to GCC tree converters), and for
7302         # build infrastructure purposes (Make-lang.in, etc.)
7303         #
7304         # This will be <subdir> (relative to $srcdir) if a line like 
7305         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
7306         # is found in <langdir>/config-lang.in, and will remain <langdir>
7307         # otherwise.
7308         #
7309         # Except for the language alias (fetched above), the regular
7310         # "config-lang.in" contents are always retrieved from $gcc_subdir,
7311         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
7312         # only this and the language alias.
7314         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
7315         if [ "$gcc_subdir" = "" ]; then
7316            gcc_subdir="$subdir"
7317         fi
7319         case ",$enable_languages," in
7320         *,$lang_alias,*)
7321             all_selected_languages="$all_selected_languages $lang_alias"
7322             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
7323                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
7324             fi
7325             ;;
7326         esac
7327 changequote([,])dnl
7329         language=
7330         boot_language=
7331         compilers=
7332         outputs=
7333         gtfiles=
7334         subdir_requires=
7335         . ${srcdir}/$gcc_subdir/config-lang.in
7336         if test "x$language" = x
7337         then
7338                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
7339                 exit 1
7340         fi
7342         ok=:
7343         case ",$enable_languages," in
7344                 *,$lang_alias,*) ;;
7345                 *)
7346                         for i in $subdir_requires; do
7347                                 test -f "${srcdir}/$i/config-lang.in" && continue
7348                                 ok=false
7349                                 break
7350                         done
7351                 ;;
7352         esac
7353         $ok || continue
7355         all_lang_configurefrags="$all_lang_configurefrags \$(srcdir)/$gcc_subdir/config-lang.in"
7356         if test "x$language" = xc && test -n "$all_lang_makefrags"; then
7357             # Put c/Make-lang.in fragment first to match serialization languages order.
7358             all_lang_makefrags="\$(srcdir)/$gcc_subdir/Make-lang.in $all_lang_makefrags"
7359         else
7360             all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
7361         fi
7362         if test -f $srcdir/$gcc_subdir/lang.opt; then
7363             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
7364             all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
7365         fi
7366         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
7367             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
7368         fi
7369         all_languages="$all_languages $language"
7370         all_compilers="$all_compilers $compilers"
7371         all_outputs="$all_outputs $outputs"
7372         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
7373         case ",$enable_languages," in
7374                 *,lto,*)
7375                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
7376                     enable_lto=yes
7377                     AC_SUBST(enable_lto)
7378                     ;;
7379                 *) ;;
7380         esac
7381 done
7383 check_languages=
7384 for language in $all_selected_languages
7386         check_languages="$check_languages check-$language"
7387 done
7388 if test x$enable_libgdiagnostics = xyes; then
7389         check_languages="$check_languages check-libgdiagnostics check-sarif-replay"
7392 selftest_languages=
7393 for language in $all_selected_languages
7395         selftest_languages="$selftest_languages selftest-$language"
7396 done
7398 # We link each language in with a set of hooks, reached indirectly via
7399 # lang.${target}.  Only do so for selected languages.
7401 rm -f Make-hooks
7402 touch Make-hooks
7403 target_list="all.cross start.encap rest.encap tags \
7404         install-common install-man install-info install-dvi install-pdf \
7405         install-html dvi pdf html uninstall info man srcextra srcman srcinfo \
7406         mostlyclean clean distclean maintainer-clean install-plugin"
7408 for t in $target_list
7410         x=
7411         for lang in $all_selected_languages
7412         do
7413                 x="$x $lang.$t"
7414         done
7415         echo "lang.$t: $x" >> Make-hooks
7416 done
7418 echo "ifeq (\$(DO_LINK_SERIALIZATION),)" >> Make-hooks
7419 echo "SERIAL_LIST =" >> Make-hooks
7420 echo else >> Make-hooks
7421 lang_cnt=0
7422 lang_list=
7423 prev=c
7424 serialization_languages=c
7425 for lang in $all_selected_languages
7427         test $lang = c && continue
7428         if test $lang = lto; then
7429                 serialization_languages="$serialization_languages lto1 lto2"
7430         else
7431                 serialization_languages="$serialization_languages $lang"
7432         fi
7433 done
7434 for lang in $serialization_languages
7436         test $lang = c && continue
7437         lang_cnt=`expr $lang_cnt + 1`
7438         lang_list=" $prev$lang_list"
7439         prev=${lang}
7440 done
7441 echo "SERIAL_LIST = \$(wordlist \$(DO_LINK_SERIALIZATION),$lang_cnt,$lang_list)" >> Make-hooks
7442 echo endif >> Make-hooks
7443 echo "SERIAL_COUNT = `expr $lang_cnt + 1`" >> Make-hooks
7444 echo "INDEX.c = 0" >> Make-hooks
7445 lang_idx=1
7446 for lang in $serialization_languages
7448         test $lang = c && continue
7449         echo "$lang.prev = \$(if \$(word $lang_cnt,\$(SERIAL_LIST)),\$(\$(word $lang_cnt,\$(SERIAL_LIST)).serial))" >> Make-hooks
7450         echo "INDEX.$lang = $lang_idx" >> Make-hooks
7451         lang_cnt=`expr $lang_cnt - 1`
7452         lang_idx=`expr $lang_idx + 1`
7453 done
7455 # --------
7456 # Option include files
7457 # --------
7459 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
7460 option_includes="option-includes.mk"
7461 AC_SUBST_FILE(option_includes)
7463 # --------
7464 # UNSORTED
7465 # --------
7467 # Create .gdbinit.
7469 echo "dir ." > .gdbinit
7470 echo "dir ${srcdir}" >> .gdbinit
7471 if test x$gdb_needs_out_file_path = xyes
7472 then
7473         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
7475 if test "x$subdirs" != x; then
7476         for s in $subdirs
7477         do
7478                 echo "dir ${srcdir}/$s" >> .gdbinit
7479         done
7481 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
7482 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
7484 # Put a breakpoint on __asan_report_error to help with debugging buffer
7485 # overflow.
7486 case "$CFLAGS" in
7487 *-fsanitize=address*)
7488   echo "source ${srcdir}/gdbasan.in" >> .gdbinit
7489   ;;
7490 esac
7492 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
7493 AC_SUBST(gcc_tooldir)
7494 AC_SUBST(dollar)
7496 # Find a directory in which to install a shared libgcc.
7498 AC_ARG_ENABLE(version-specific-runtime-libs,
7499 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
7500                 [specify that runtime libraries should be
7501                  installed in a compiler-specific directory])])
7503 # Substitute configuration variables
7504 AC_SUBST(subdirs)
7505 AC_SUBST(srcdir)
7506 AC_SUBST(all_compilers)
7507 AC_SUBST(all_gtfiles)
7508 AC_SUBST(all_lang_configurefrags)
7509 AC_SUBST(all_lang_makefrags)
7510 AC_SUBST(all_languages)
7511 AC_SUBST(all_selected_languages)
7512 AC_SUBST(build_exeext)
7513 AC_SUBST(build_install_headers_dir)
7514 AC_SUBST(build_xm_file_list)
7515 AC_SUBST(build_xm_include_list)
7516 AC_SUBST(build_xm_defines)
7517 AC_SUBST(build_file_translate)
7518 AC_SUBST(check_languages)
7519 AC_SUBST(selftest_languages)
7520 AC_SUBST(cpp_install_dir)
7521 AC_SUBST(xmake_file)
7522 AC_SUBST(tmake_file)
7523 AC_SUBST(TM_ENDIAN_CONFIG)
7524 AC_SUBST(TM_MULTILIB_CONFIG)
7525 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
7526 AC_SUBST(extra_gcc_objs)
7527 AC_SUBST(user_headers_inc_next_pre)
7528 AC_SUBST(user_headers_inc_next_post)
7529 AC_SUBST(extra_headers_list)
7530 AC_SUBST(extra_objs)
7531 AC_SUBST(extra_programs)
7532 AC_SUBST(float_h_file)
7533 AC_SUBST(gcc_config_arguments)
7534 AC_SUBST(gcc_gxx_include_dir)
7535 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
7536 AC_SUBST(gcc_gxx_libcxx_include_dir)
7537 AC_SUBST(gcc_gxx_libcxx_include_dir_add_sysroot)
7538 AC_SUBST(host_exeext)
7539 AC_SUBST(host_xm_file_list)
7540 AC_SUBST(host_xm_include_list)
7541 AC_SUBST(host_xm_defines)
7542 AC_SUBST(out_host_hook_obj)
7543 AC_SUBST(install)
7544 AC_SUBST(lang_opt_files)
7545 AC_SUBST(lang_specs_files)
7546 AC_SUBST(lang_tree_files)
7547 AC_SUBST(local_prefix)
7548 AC_SUBST(md_file)
7549 AC_SUBST(objc_boehm_gc)
7550 AC_SUBST(out_file)
7551 AC_SUBST(out_object_file)
7552 AC_SUBST(common_out_file)
7553 AC_SUBST(common_out_object_file)
7554 AC_SUBST(tm_file_list)
7555 AC_SUBST(tm_include_list)
7556 AC_SUBST(tm_defines)
7557 AC_SUBST(tm_p_file_list)
7558 AC_SUBST(tm_p_include_list)
7559 AC_SUBST(tm_d_file_list)
7560 AC_SUBST(tm_d_include_list)
7561 AC_SUBST(tm_rust_file_list)
7562 AC_SUBST(tm_rust_include_list)
7563 AC_SUBST(xm_file_list)
7564 AC_SUBST(xm_include_list)
7565 AC_SUBST(xm_defines)
7566 AC_SUBST(use_gcc_stdint)
7567 AC_SUBST(c_target_objs)
7568 AC_SUBST(cxx_target_objs)
7569 AC_SUBST(fortran_target_objs)
7570 AC_SUBST(d_target_objs)
7571 AC_SUBST(rust_target_objs)
7572 AC_SUBST(target_cpu_default)
7574 AC_SUBST_FILE(language_hooks)
7576 # Echo link setup.
7577 if test x${build} = x${host} ; then
7578   if test x${host} = x${target} ; then
7579     echo "Links are now set up to build a native compiler for ${target}." 1>&2
7580   else
7581     echo "Links are now set up to build a cross-compiler" 1>&2
7582     echo " from ${host} to ${target}." 1>&2
7583   fi
7584 else
7585   if test x${host} = x${target} ; then
7586     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
7587     echo " for ${target}." 1>&2
7588   else
7589     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
7590     echo " from ${host} to ${target}." 1>&2
7591   fi
7594 AC_ARG_VAR(GMPLIBS,[How to link GMP])
7595 AC_ARG_VAR(GMPINC,[How to find GMP include files])
7597 AC_ARG_VAR(ISLLIBS,[How to link isl])
7598 AC_ARG_VAR(ISLINC,[How to find isl include files])
7599 if test "x${ISLLIBS}" != "x" ; then 
7600    AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
7603 GCC_ENABLE_PLUGINS
7604 AC_SUBST(pluginlibs)
7605 AC_SUBST(enable_plugin)
7606 if test x"$enable_plugin" = x"yes"; then
7607   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
7611 # Enable --enable-host-shared
7612 AC_ARG_ENABLE(host-shared,
7613 [AS_HELP_STRING([--enable-host-shared],
7614                 [build host code as shared libraries])])
7615 AC_SUBST(enable_host_shared)
7617 # Enable --enable-host-pie
7618 AC_ARG_ENABLE(host-pie,
7619 [AS_HELP_STRING([--enable-host-pie],
7620                 [build host code as PIE])])
7621 AC_SUBST(enable_host_pie)
7623 AC_ARG_ENABLE(libgdiagnostics,
7624 [AS_HELP_STRING([--enable-libgdiagnostics],
7625                 [build libgdiagnostics shared library])])
7626 AC_SUBST(enable_libgdiagnostics)
7628 if test "$enable_libgdiagnostics" = "yes"; then
7629   LIBGDIAGNOSTICS='libgdiagnostics sarif-replay'
7630 else
7631   LIBGDIAGNOSTICS=''
7633 AC_SUBST(LIBGDIAGNOSTICS)
7636 # Enable --enable-host-bind-now
7637 AC_ARG_ENABLE(host-bind-now,
7638 [AS_HELP_STRING([--enable-host-bind-now],
7639                 [link host code as BIND_NOW])])
7640 AC_SUBST(enable_host_bind_now)
7642 AC_ARG_ENABLE(libquadmath-support,
7643 [AS_HELP_STRING([--disable-libquadmath-support],
7644   [disable libquadmath support for Fortran])],
7645 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
7646 ENABLE_LIBQUADMATH_SUPPORT=yes)
7647 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
7648   AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
7649             [Define to 1 to enable libquadmath support])
7653 # Specify what hash style to use by default.
7654 AC_ARG_WITH([linker-hash-style],
7655 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
7656                 [specify the linker hash style])],
7657 [case x"$withval" in
7658    xsysv)
7659      LINKER_HASH_STYLE=sysv
7660      ;;
7661    xgnu)
7662      LINKER_HASH_STYLE=gnu
7663      ;;
7664    xboth)
7665      LINKER_HASH_STYLE=both
7666      ;;
7667    *)
7668      AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
7669      ;;
7670  esac],
7671 [LINKER_HASH_STYLE=''])
7672 if test x"${LINKER_HASH_STYLE}" != x; then
7673   AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
7674                                          [The linker hash style])
7677 # Specify what should be the default of -fdiagnostics-color option.
7678 AC_ARG_WITH([diagnostics-color],
7679 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
7680                 [specify the default of -fdiagnostics-color option
7681                  auto-if-env stands for -fdiagnostics-color=auto if
7682                  GCC_COLOR environment variable is present and
7683                  -fdiagnostics-color=never otherwise])],
7684 [case x"$withval" in
7685    xnever)
7686      DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
7687      ;;
7688    xauto)
7689      DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
7690      ;;
7691    xauto-if-env)
7692      DIAGNOSTICS_COLOR_DEFAULT=-1
7693      ;;
7694    xalways)
7695      DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
7696      ;;
7697    *)
7698      AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
7699      ;;
7700  esac],
7701 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
7702 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
7703                    [The default for -fdiagnostics-color option])
7705 # Specify what should be the default of -fdiagnostics-urls option.
7706 AC_ARG_WITH([diagnostics-urls],
7707 [AC_HELP_STRING([--with-diagnostics-urls={never,auto,auto-if-env,always}],
7708                 [specify the default of -fdiagnostics-urls option
7709                  auto-if-env stands for -fdiagnostics-urls=auto if
7710                  GCC_URLS or TERM_URLS environment variable is present and
7711                  -fdiagnostics-urls=never otherwise])],
7712 [case x"$withval" in
7713    xnever)
7714      DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_NO
7715      ;;
7716    xauto)
7717      DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO
7718      ;;
7719    xauto-if-env)
7720      DIAGNOSTICS_URLS_DEFAULT=-1
7721      ;;
7722    xalways)
7723      DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_YES
7724      ;;
7725    *)
7726      AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-urls])
7727      ;;
7728  esac],
7729 [DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO])
7730 AC_DEFINE_UNQUOTED(DIAGNOSTICS_URLS_DEFAULT, $DIAGNOSTICS_URLS_DEFAULT,
7731                    [The default for -fdiagnostics-urls option])
7733 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
7734 # of jit/jit-playback.cc.
7735 gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"`
7736 echo "gcc_driver_version: ${gcc_driver_version}"
7737 cat > gcc-driver-name.h <<EOF
7738 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_driver_version}${exeext}"
7741 # Check whether --enable-default-pie was given.
7742 AC_ARG_ENABLE(default-pie,
7743 [AS_HELP_STRING([--enable-default-pie],
7744   [enable Position Independent Executable as default])],
7745 enable_default_pie=$enableval,
7746 enable_default_pie=no)
7747 if test x$enable_default_pie = xyes ; then
7748   AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
7749       [Define if your target supports default PIE and it is enabled.])
7751 AC_SUBST([enable_default_pie])
7753 # Check if -fno-PIE works.
7754 AC_CACHE_CHECK([for -fno-PIE option],
7755   [gcc_cv_c_no_fpie],
7756   [saved_CXXFLAGS="$CXXFLAGS"
7757    CXXFLAGS="$CXXFLAGS -fno-PIE"
7758    AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7759      [gcc_cv_c_no_fpie=yes],
7760      [gcc_cv_c_no_fpie=no])
7761    CXXFLAGS="$saved_CXXFLAGS"])
7763 # Check if -no-pie works.
7764 AC_CACHE_CHECK([for -no-pie option],
7765   [gcc_cv_no_pie],
7766   [saved_LDFLAGS="$LDFLAGS"
7767    LDFLAGS="$LDFLAGS -no-pie"
7768    AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7769      [gcc_cv_no_pie=yes],
7770      [gcc_cv_no_pie=no])
7771    LDFLAGS="$saved_LDFLAGS"])
7773 if test x$enable_host_shared = xyes; then
7774   PICFLAG=-fPIC
7775 elif test x$enable_host_pie = xyes; then
7776   PICFLAG=-fPIE
7777 elif test x$gcc_cv_c_no_fpie = xyes; then
7778   PICFLAG=-fno-PIE
7779 else
7780   PICFLAG=
7783 AC_SUBST([PICFLAG])
7785 if test x$enable_host_pie = xyes; then
7786   LD_PICFLAG=-pie
7787 elif test x$gcc_cv_no_pie = xyes; then
7788   LD_PICFLAG=-no-pie
7789 else
7790   LD_PICFLAG=
7793 if test x$enable_host_bind_now = xyes; then
7794   LD_PICFLAG="$LD_PICFLAG -Wl,-z,now"
7797 AC_SUBST([LD_PICFLAG])
7799 # Enable Intel CET on Intel CET enabled host if jit is enabled.
7800 GCC_CET_HOST_FLAGS(CET_HOST_FLAGS)
7801 case x$enable_languages in
7802 *jit*)
7803   ;;
7805   CET_HOST_FLAGS=
7806   ;;
7807 esac
7808 AC_SUBST(CET_HOST_FLAGS)
7810 # Check linker supports '-z bndplt'
7811 ld_bndplt_support=no
7812 AC_MSG_CHECKING(linker -z bndplt option)
7813 if test x"$ld_is_gold" = xno; then
7814   if test $in_tree_ld = yes ; then
7815     if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
7816       ld_bndplt_support=yes
7817     fi
7818   elif test x$gcc_cv_ld != x; then
7819     # Check if linker supports -z bndplt option
7820     if $gcc_cv_ld --help 2>&1 | grep -- '-z bndplt' > /dev/null; then
7821       ld_bndplt_support=yes
7822     fi
7823   fi
7825 if test x"$ld_bndplt_support" = xyes; then
7826   AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
7827         [Define if your linker supports -z bndplt])
7829 AC_MSG_RESULT($ld_bndplt_support)
7831 # Check linker supports '--push-state'/'--pop-state'
7832 ld_pushpopstate_support=no
7833 AC_MSG_CHECKING(linker --push-state/--pop-state options)
7834 if test x"$ld_is_gold" = xno; then
7835   if test $in_tree_ld = yes ; then
7836     if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
7837       ld_pushpopstate_support=yes
7838     fi
7839   elif test x$gcc_cv_ld != x; then
7840     # Check if linker supports --push-state/--pop-state options
7841     if $gcc_cv_ld --help 2>&1 | grep -- '--push-state' > /dev/null; then
7842       ld_pushpopstate_support=yes
7843     fi
7844   fi
7846 if test x"$ld_pushpopstate_support" = xyes; then
7847   AC_DEFINE(HAVE_LD_PUSHPOPSTATE_SUPPORT, 1,
7848         [Define if your linker supports --push-state/--pop-state])
7850 AC_MSG_RESULT($ld_pushpopstate_support)
7852 # On s390, float_t has historically been statically defined as double for no
7853 # good reason. To comply with the C standard in the light of this definition,
7854 # gcc has evaluated float expressions in double precision when in
7855 # standards-compatible mode or when given -fexcess-precision=standard. To enable
7856 # a smooth transition towards the new model used by most architectures, where
7857 # gcc describes its behavior via the macro __FLT_EVAL_METHOD__ and glibc derives
7858 # float_t from that, this behavior can be configured with
7859 # --enable-s390-excess-float-precision. When given as enabled, that flag selects
7860 # the old model. When omitted, native builds and cross compiles that have target
7861 # libc headers will detect whether libc clamps float_t to double and in that
7862 # case maintain the old model. Otherwise, they will default to the new model.
7863 AC_ARG_ENABLE(s390-excess-float-precision,
7864   [AS_HELP_STRING([--enable-s390-excess-float-precision],
7865                   [on s390 targets, evaluate float with double precision
7866                    when in standards-conforming mode])],
7867   [],[enable_s390_excess_float_precision=auto])
7869 case $target in
7870   s390*-linux*)
7871   if test x"$enable_s390_excess_float_precision" = xauto; then
7872     # Can we autodetect the behavior of the target libc?
7873     if test "$target" = "$host" -a "$host" = "$build"; then
7874       enable_s390_excess_float_precision=autodetect
7875     elif test "x$with_headers" != xno; then
7876       # cross build. are target headers available?
7877       # carefully coerce the build-system compiler to use target headers
7878       saved_CXXFLAGS="$CXXFLAGS"
7879       fixed_XGCC_FLAGS_FOR_TARGET=`echo "$XGCC_FLAGS_FOR_TARGET" | sed 's/-B/-idirafter/g'`
7880       CROSS_TEST_CXXFLAGS="-nostdinc $fixed_XGCC_FLAGS_FOR_TARGET"
7881       CXXFLAGS="$CROSS_TEST_CXXFLAGS"
7882       AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
7883 #include <math.h>
7884 ]])], [enable_s390_excess_float_precision=autodetect], [])
7885       CXXFLAGS="$saved_CXXFLAGS"
7886     fi
7888     if test x"$enable_s390_excess_float_precision" = xautodetect; then
7889       saved_CXXFLAGS="$CXXFLAGS"
7890       if ! test "$target" = "$host" -a "$host" = "$build"; then
7891         CXXFLAGS="$CROSS_TEST_CXXFLAGS"
7892         unset CROSS_TEST_CXXFLAGS
7893       fi
7894       AC_CACHE_CHECK([for glibc clamping float_t to double],
7895         gcc_cv_float_t_clamped_to_double, [
7896         AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
7897 #define __FLT_EVAL_METHOD__ 0
7898 #include <math.h>
7899 int dummy[sizeof(float_t) == sizeof(double) ? 1 : -1];
7900 ]])],
7901           [gcc_cv_float_t_clamped_to_double=yes],
7902           [gcc_cv_float_t_clamped_to_double=no])])
7903       CXXFLAGS="$saved_CXXFLAGS"
7904       enable_s390_excess_float_precision="$gcc_cv_float_t_clamped_to_double"
7905     else
7906       # no way to detect behavior of target libc, default to new model
7907       enable_s390_excess_float_precision=no
7908     fi
7909   fi
7911   GCC_TARGET_TEMPLATE(ENABLE_S390_EXCESS_FLOAT_PRECISION)
7912   if test x"$enable_s390_excess_float_precision" = xyes; then
7913     AC_DEFINE(ENABLE_S390_EXCESS_FLOAT_PRECISION, 1,
7914 [Define to enable evaluating float expressions with double precision in
7915 standards-compatible mode on s390 targets.])
7916   fi
7917   ;;
7918 esac
7920 # Check if the linker supports '-z now'
7921 ld_now_support=no
7922 AC_MSG_CHECKING(linker -z now option)
7923 if test x"$ld_is_gold" = xyes; then
7924   ld_now_support=yes
7925 elif test $in_tree_ld = yes ; then
7926   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 14 -o "$gcc_cv_gld_major_version" -gt 2; then
7927     ld_now_support=yes
7928   fi
7929 elif test x$gcc_cv_ld != x; then
7930   # Check if linker supports -z now
7931   if $gcc_cv_ld --help 2>&1 | grep -- '-z now' > /dev/null; then
7932     ld_now_support=yes
7933   fi
7935 AC_DEFINE_UNQUOTED(HAVE_LD_NOW_SUPPORT,
7936   [`if test x"$ld_now_support" = xyes; then echo 1; else echo 0; fi`],
7937   [Define 0/1 if your linker supports -z now])
7938 AC_MSG_RESULT($ld_now_support)
7940 # Check if the linker supports '-z relro'
7941 ld_relro_support=no
7942 AC_MSG_CHECKING(linker -z relro option)
7943 if test x"$ld_is_gold" = xyes; then
7944   ld_relro_support=yes
7945 elif test $in_tree_ld = yes ; then
7946   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 15 -o "$gcc_cv_gld_major_version" -gt 2; then
7947     ld_relro_support=yes
7948   fi
7949 elif test x$gcc_cv_ld != x; then
7950   # Check if linker supports -z relro
7951   if $gcc_cv_ld --help 2>&1 | grep -- '-z relro' > /dev/null; then
7952     ld_relro_support=yes
7953   fi
7955 AC_DEFINE_UNQUOTED(HAVE_LD_RELRO_SUPPORT,
7956   [`if test x"$ld_relro_support" = xyes; then echo 1; else echo 0; fi`],
7957   [Define 0/1 if your linker supports -z relro])
7958 AC_MSG_RESULT($ld_relro_support)
7960 case $target_os in
7961 linux* | gnu*)
7962   # -fhardened is only supported on GNU/Linux.
7963   fhardened_support=yes
7964   ;;
7966   fhardened_support=no
7967   ;;
7968 esac
7970 AC_DEFINE_UNQUOTED(HAVE_FHARDENED_SUPPORT,
7971   [`if test x"$fhardened_support" = xyes; then echo 1; else echo 0; fi`],
7972   [Define 0/1 if -fhardened is supported])
7973 AC_MSG_RESULT($fhardened_support)
7975 # Configure the subdirectories
7976 # AC_CONFIG_SUBDIRS($subdirs)
7978 # Create the Makefile
7979 # and configure language subdirectories
7980 AC_CONFIG_FILES($all_outputs)
7982 AC_CONFIG_COMMANDS([default],
7984 case ${CONFIG_HEADERS} in
7985   *auto-host.h:config.in*)
7986   echo > cstamp-h ;;
7987 esac
7988 # Make sure all the subdirs exist.
7989 for d in $subdirs doc build common c-family
7991     test -d $d || mkdir $d
7992 done
7993 ], 
7994 [subdirs='$subdirs'])
7995 AC_OUTPUT