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