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
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
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 # --------------------------------
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
38 # Determine the noncanonical host name, for Ada.
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}
48 # Determine the target- and build-specific subdirectories
51 # Set program_transform_name
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
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)
64 case ${LIBRARY_PATH} in
65 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
66 library_path_setting="contains current directory"
69 library_path_setting="ok"
73 AC_MSG_RESULT($library_path_setting)
74 if test "$library_path_setting" != "ok"; then
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
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)
90 case ${GCC_EXEC_PREFIX} in
91 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
92 gcc_exec_prefix_setting="contains current directory"
95 gcc_exec_prefix_setting="ok"
99 AC_MSG_RESULT($gcc_exec_prefix_setting)
100 if test "$gcc_exec_prefix_setting" != "ok"; then
102 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
103 *** building gcc. Please change the environment variable
104 *** and run configure again.])
111 # Specify the 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) ;;
119 *) local_prefix=$with_local_prefix ;;
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]) ;;
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"
146 [SYSROOT_CFLAGS_FOR_TARGET=])
147 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
149 if test "x$prefix" = xNONE; then
150 test_prefix=/usr/local
154 if test "x$exec_prefix" = xNONE; then
155 test_exec_prefix=$test_prefix
157 test_exec_prefix=$exec_prefix
161 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
162 [search for usr/lib, usr/include, et al, within DIR])],
164 case ${with_sysroot} in
166 */) with_sysroot=`echo $with_sysroot | sed 's,/$,,'` ;;
168 case ${with_sysroot} in
169 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
170 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
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)'
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"
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.
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) ;;
205 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
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++'
218 libstdcxx_incdir='include/c++/$(version)'
219 if test x$host != x$target; then
220 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
222 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
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
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 ;;
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
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=
260 gcc_enable_stdlib_opt=1
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
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'
283 if test x$host != x$target; then
284 libcxx_incdir="$target_alias/$libcxx_incdir"
286 gcc_gxx_libcxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libcxx_incdir"
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
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
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
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
331 # -------------------
332 # Find default linker
333 # -------------------
337 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
338 gnu_ld_flag="$with_gnu_ld",
343 ld64_flag=yes # Darwin can only use a ld64-compatible linker.
344 dsymutil_flag=yes # Darwin uses dsymutil to link debug.
352 # With pre-defined 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
361 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep ld64- > /dev/null; then
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)])
373 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
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",
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")
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])
395 if dsymutil_vers=`$DEFAULT_DSYMUTIL -v /dev/null 2>&1`; then
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)])
410 # ----------------------
411 # Find default assembler
412 # ----------------------
416 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
417 gas_flag="$with_gnu_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
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)])
438 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
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
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.
466 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
467 # optimizations to be activated explicitly by the toplevel.
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]]*[[ ]]//" ` ;;
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
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.])
506 # sizeof(char) is 1 by definition.
507 AC_CHECK_SIZEOF(void *)
508 AC_CHECK_SIZEOF(short)
510 AC_CHECK_SIZEOF(long)
511 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
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([[
523 template <typename T> struct X { };
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.])
531 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
535 template <typename T> struct X { };
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([[
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.)
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
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
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])),
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.
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])),
631 # Enable expensive internal checks
633 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
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
649 ac_checking_flags=release
651 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
652 for check in release $ac_checking_flags
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) ;;
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
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
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.
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.
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
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=
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
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
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])
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,
842 [case "${enableval}" in
844 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0 -fkeep-static-functions"
847 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2 -fkeep-static-functions"
850 # a.k.a. --disable-coverage
854 AC_MSG_ERROR(unknown coverage setting $enableval)
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])
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)"
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)"
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
923 # default stack clash protection guard size as power of twos in bytes.
924 # Please keep these in sync with params.def.
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++])],
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])],
1000 enable_fixed_point=yes
1004 enable_fixed_point=yes
1007 enable_fixed_point=yes
1010 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
1011 enable_fixed_point=no
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.])
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=''])
1031 [AS_HELP_STRING([--enable-tls],
1032 [enable or disable generation of tls code
1033 overriding the assembler check for tls support])],
1037 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
1038 Valid choices are 'yes' and 'no'.]) ;;
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
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
1074 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2 (or later)])],
1075 dwarf2="$with_dwarf2",
1078 AC_ARG_ENABLE(shared,
1079 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
1081 case $enable_shared in
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
1094 ], [enable_shared=yes])
1095 AC_SUBST(enable_shared)
1098 [ --disable-gcov don't provide libgcov and related host tools],
1099 [], [case $target in
1108 AC_SUBST(enable_gcov)
1111 [AS_HELP_STRING([--with-specs=SPECS],
1112 [add SPECS to driver command-line processing])],
1113 [CONFIGURE_SPECS=$withval],
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]),
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 /]) ;;
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]),
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 /]) ;;
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
1157 # go safe -- we cannot be much sure without the toplevel
1159 # analysis of which target libs are present and usable
1163 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
1168 enable_languages=c,${enable_languages}
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
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/=.*//'`
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"
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"
1210 AC_MSG_ERROR([unknown offload target specified])
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
1219 offload_targets="$offload_targets,$tgt"
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.])
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 # -------------------------
1256 # Find some useful tools
1258 # We need awk to create options.cc and options.h.
1259 # Bail out if it's missing.
1261 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
1268 AC_SUBST(ranlib_flags)
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
1285 *** Makeinfo is missing or too old.
1286 *** Info documentation will not be built.])
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
1305 gcc_cv_texi_add_toc_inline_flags=yes
1308 if test x"$gcc_cv_texi_add_toc_inline_flags" = xyes; then
1309 MAKEINFO_TOC_INLINE_FLAG='-c CONTENTS_OUTPUT_LOCATION=inline'
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
1318 GENERATED_MANPAGES=generated-manpages
1323 AC_SUBST(GENERATED_MANPAGES)
1325 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
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])
1333 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
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
1341 *** Python3 is missing.
1342 *** Documentation for modula-2 will not include the target SYSTEM module.])
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.
1353 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1354 && test -d ../binutils ; then
1355 NM='${objdir}/../binutils/nm-new'
1357 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1361 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1362 && test -d ../binutils ; then
1363 AR='${objdir}/../binutils/ar'
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.
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.
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
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)
1414 # Dependency checking.
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
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])
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,
1436 for libs in '' -lld -lmld \
1437 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1438 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1441 AC_TRY_LINK_FUNC(ldopen,
1442 [gcc_cv_collect2_libs="$libs"; break])
1445 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1446 case $gcc_cv_collect2_libs in
1448 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
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.
1456 AC_SEARCH_LIBS(exc_resume, exc)
1459 AC_SUBST(GNAT_LIBEXC)
1461 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1464 AC_SEARCH_LIBS(kstat_open, kstat)
1465 EXTRA_GCC_LIBS="$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.
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.
1482 AC_SEARCH_LIBS(ldexp, m)
1487 # Some systems need dlopen
1490 AC_SEARCH_LIBS(dlopen, dl)
1495 # Use <inttypes.h> only if it exists,
1496 # doesn't clash with <sys/types.h>, declares intmax_t and defines
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>]],
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.
1519 AC_SUBST(ZSTD_INCLUDE)
1523 AC_SUBST(ZSTD_CPPFLAGS)
1524 AC_SUBST(ZSTD_LDFLAGS)
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
1542 *) ZSTD_INCLUDE=$with_zstd/include
1543 ZSTD_LIB=$with_zstd/lib
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
1569 AC_SEARCH_LIBS(ZSTD_compress, zstd,, gcc_cv_header_zstd_h=no)
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(
1580 #if ZSTD_VERSION_NUMBER < 10300
1581 #error "need zstd 1.3.0 or better"
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>
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.])
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]),
1632 GCC_AC_FUNC_MMAP_BLACKLIST
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
1639 ac_cv_func_vfork_works=yes
1646 # Until we have in-tree GNU iconv:
1648 if test -f "$LTLIBICONV"; then
1649 LIBICONV_DEP=$LTLIBICONV
1651 AC_SUBST(LIBICONV_DEP)
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"
1684 #ifdef HAVE_SYS_RESOURCE_H
1685 #include <sys/resource.h>
1689 gcc_AC_CHECK_DECLS(mallinfo mallinfo2, , ,[
1690 #include "ansidecl.h"
1692 #ifdef HAVE_MALLOC_H
1697 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1698 #include "ansidecl.h"
1700 #ifdef HAVE_SYS_RESOURCE_H
1701 #include <sys/resource.h>
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"
1720 gcc_AC_CHECK_DECLS(times, , ,[
1721 #include "ansidecl.h"
1723 #ifdef HAVE_SYS_TIMES_H
1724 #include <sys/times.h>
1728 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1729 #include "ansidecl.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"
1739 #ifdef HAVE_SYS_TIMES_H
1740 #include <sys/times.h>
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"
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>]], [[
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>
1808 #include <netinet/in.h>]],[[
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>]],[[
1829 in6.sin6_family = AF_UNSPEC;
1830 struct addrinfo *addrs = 0;
1831 struct addrinfo hints;
1833 hints.ai_family = AF_INET6;
1834 hints.ai_socktype = SOCK_STREAM;
1835 hints.ai_protocol = 0;
1836 hints.ai_canonname = 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([[
1855 #include <sys/locking.h>]], [[
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
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],
1884 force_sjlj_exceptions=yes
1888 force_sjlj_exceptions=no
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
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
1952 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1958 for x in $host_xm_file; do
1959 if test -f $srcdir/config/$x
1961 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1967 for x in $xm_file; do
1968 if test -f $srcdir/config/$x
1970 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1976 for f in $tm_file; do
1979 if test $count = ax; then
1980 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1982 echo "Using the following target machine macro files:"
1983 for f in $tm_file; do
1984 echo " $srcdir/config/$f"
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.])
2001 for f in $host_xm_file; do
2004 if test $count = a; then
2006 elif test $count = ax; then
2007 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
2009 echo "Using the following host machine macro files:"
2010 for f in $host_xm_file; do
2011 echo " $srcdir/config/$f"
2014 echo "Using ${out_host_hook_obj} for host machine hooks."
2016 if test "$host_xm_file" != "$build_xm_file"; then
2018 for f in $build_xm_file; do
2021 if test $count = a; then
2023 elif test $count = ax; then
2024 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
2026 echo "Using the following build machine macro files:"
2027 for f in $build_xm_file; do
2028 echo " $srcdir/config/$f"
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)
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; }
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 __])
2061 # Check if a valid thread package
2062 case ${enable_threads} in
2065 target_thread_file='single'
2069 target_thread_file='single'
2071 aix | dce | lynx | mipssde | posix | rtems | \
2072 single | tpf | vxworks | win32 | mcf)
2073 target_thread_file=${enable_threads}
2076 echo "${enable_threads} is an unknown thread package" 1>&2
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}
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
2096 # mingw32 doesn't have __cxa_atexit but uses atexit registration
2097 # keyed to flag_use_cxa_atexit
2105 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
2106 [echo "__cxa_atexit can't be enabled on this target"])
2110 # We can't check for __cxa_atexit when building a cross, so assume
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.])
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.
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"
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
2148 build_auto=auto-host.h
2149 HAVE_AUTO_BUILD='# '
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
2160 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
2161 *) realsrcdir=../${srcdir};;
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
2182 build_auto=auto-build.h
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}"
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"
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`
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;
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`
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,
2259 configuration_arguments};
2263 # Determine what GCC version number to use in filesystem paths.
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*)
2275 AC_ARG_ENABLE(secureplt,
2276 [AS_HELP_STRING([--enable-secureplt],
2277 [enable -msecure-plt by default for PowerPC])],
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]),
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])])
2306 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
2309 AC_ARG_ENABLE(frame-pointer,
2310 [AS_HELP_STRING([--enable-frame-pointer],
2311 [enable -fno-omit-frame-pointer by default for x86])], [],
2314 linux* | gnu* | darwin[[8912]]* | cygwin* | mingw*)
2315 # Enable -fomit-frame-pointer by default for these systems with DWARF2.
2316 enable_frame_pointer=no
2319 enable_frame_pointer=yes
2325 i[[34567]]86-*-* | x86_64-*-*)
2326 if test "x$enable_cld" = xyes; then
2327 tm_defines="${tm_defines} USE_IX86_CLD=1"
2329 if test "x$enable_frame_pointer" = xyes; then
2330 tm_defines="${tm_defines} USE_IX86_FRAME_POINTER=1"
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])],,)
2346 win32 | pe | cygwin* | mingw32*)
2347 if test "x$enable_win32_registry" != xno; then
2348 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
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.])
2368 # Get an absolute path to the GCC top-level source directory
2369 holddir=`${PWDCMD-pwd}`
2371 topdir=`${PWDCMD-pwd}`
2374 # Conditionalize the makefile for this host machine.
2376 for f in ${host_xmake_file}
2378 if test -f ${srcdir}/config/$f
2380 xmake_file="${xmake_file} \$(srcdir)/config/$f"
2384 # Conditionalize the makefile for this target machine.
2386 for f in ${tmake_file}
2388 if test -f ${srcdir}/config/$f
2390 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
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
2403 f=`echo $f | sed 's/^..//'`
2404 tm_file_list="${tm_file_list} $f"
2405 tm_include_list="${tm_include_list} $f"
2408 tm_file_list="${tm_file_list} \$(srcdir)/$f"
2409 tm_include_list="${tm_include_list} $f"
2412 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
2413 tm_include_list="${tm_include_list} config/$f"
2420 for f in $tm_p_file; do
2423 tm_p_file_list="${tm_p_file_list} $f"
2424 tm_p_include_list="${tm_p_include_list} $f"
2427 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
2428 tm_p_include_list="${tm_p_include_list} config/$f"
2434 for f in $tm_d_file; do
2437 tm_d_file_list="${tm_d_file_list} \$(srcdir)/config/$f"
2438 tm_d_include_list="${tm_d_include_list} config/$f"
2444 tm_rust_include_list=
2445 for f in $tm_rust_file; do
2448 tm_rust_file_list="${tm_rust_file_list} \$(srcdir)/config/$f"
2449 tm_rust_include_list="${tm_rust_include_list} config/$f"
2456 for f in $xm_file; do
2459 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
2460 xm_include_list="${xm_include_list} $f"
2463 xm_file_list="${xm_file_list} $f"
2464 xm_include_list="${xm_include_list} $f"
2467 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
2468 xm_include_list="${xm_include_list} config/$f"
2474 host_xm_include_list=
2475 for f in $host_xm_file; do
2478 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
2479 host_xm_include_list="${host_xm_include_list} $f"
2482 host_xm_file_list="${host_xm_file_list} $f"
2483 host_xm_include_list="${host_xm_include_list} $f"
2486 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
2487 host_xm_include_list="${host_xm_include_list} config/$f"
2493 for f in $build_xm_file; do
2496 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
2497 build_xm_include_list="${build_xm_include_list} $f"
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"
2504 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
2505 build_xm_include_list="${build_xm_include_list} config/$f"
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)'
2523 BUILD_SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2526 if test x$host != x$target
2528 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
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)'
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}"
2542 target_header_dir="${with_sysroot}${native_system_header_dir}"
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
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
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
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
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;
2590 # Expand extra_headers to include complete path.
2591 # This substitutes for lots of t-* files.
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}"
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
2606 *) collect2='collect2$(exeext)' ;;
2608 AC_SUBST([collect2])
2610 # Add a definition of USE_COLLECT2 if system wants one.
2611 case $use_collect2 in
2612 no) use_collect2= ;;
2615 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2616 xm_defines="${xm_defines} USE_COLLECT2"
2617 case $host_can_use_collect2 in
2619 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
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], [])
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,
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
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"
2686 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
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]) ;;
2698 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2699 [case "${enableval}" in
2705 install_gold_as_default=no
2707 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2708 [case "${enableval}" in
2710 install_gold_as_default=yes
2713 if test x${default_ld} != x; then
2714 install_gold_as_default=yes
2720 AC_MSG_ERROR([invalid --enable-gold argument])
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"
2755 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
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
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"
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)
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
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)
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
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.
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'`
2815 # check that the gold version contains the complete split stack support
2816 # on powerpc64 big and little endian
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
2821 *) gold_non_default=no
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])
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]) ;;
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)
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
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
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
2865 case $gcc_cv_gld_version in
2868 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
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]*\)"`
2874 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2875 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2877 AC_MSG_RESULT($gcc_cv_ld)
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"
2899 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
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)
2908 AC_MSG_RESULT($gcc_cv_nm)
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]) ;;
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"
2932 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
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)
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"
2957 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
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)
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"
2977 AC_PATH_PROG(gcc_cv_otool, $OTOOL_FOR_TARGET)
2980 AC_MSG_CHECKING(what otool to use)
2981 if test x$gcc_cv_otool = x; then
2982 AC_MSG_RESULT(not found)
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
2998 AC_PATH_PROG(gcc_cv_dsymutil, $DSYMUTIL_FOR_TARGET)
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]) ;;
3008 # Figure out what assembler alignment features are present.
3009 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,,
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,,
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,,
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
3029 conftest_label2: .word 0
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
3036 else gcc_cv_as_subsection_m1=yes
3038 rm -f conftest.nm1 conftest.nm2
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,,
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,,
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
3063 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
3066 conftest_s=' .globl foobar,hidden'
3069 conftest_s=' .hidden foobar
3073 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,, [$conftest_s])
3076 # Darwin as has some visibility support, though with a different syntax.
3077 gcc_cv_as_hidden=yes
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
3089 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
3090 Valid choices are 'yes' and 'no'.]) ;;
3092 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
3096 AC_MSG_CHECKING(linker ifunc IRELATIVE support)
3097 cat > conftest.s <<EOF
3099 .type foo_resolver, @function
3102 .size foo_resolver, .-foo_resolver
3105 .type foo, %gnu_indirect_function
3106 .set foo, foo_resolver
3109 .type bar, @function
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
3124 rm -f conftest conftest.o conftest.s
3125 AC_MSG_RESULT($enable_gnu_indirect_function)
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.])
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:
3141 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
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'`
3148 # GNU ld --version looks like this:
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'`
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]*\)'`
3161 # Solaris 2 ld -V output looks like this for a regular version:
3163 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
3165 # but test versions add stuff at the end:
3167 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
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]*\)'`
3185 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
3186 [[if test $in_tree_ld = yes ; then
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
3193 gcc_cv_ld_hidden=yes
3194 if test x"$ld_is_gold" = xyes; then
3196 elif test x"$ld_is_mold" = xyes; then
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
3203 elif test -z "$ld_vers"; then
3204 # If there was no date string nor ld version number, something is wrong
3207 test -z "$ld_vers_patch" && ld_vers_patch=0
3208 if test "$ld_vers_major" -lt 2; then
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
3220 gcc_cv_ld_hidden=yes
3223 # Darwin ld has some visibility support.
3224 gcc_cv_ld_hidden=yes
3226 hppa64*-*-hpux* | ia64*-*-hpux*)
3227 gcc_cv_ld_hidden=yes
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
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
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
3275 gcc_cv_ld_ro_rw_mix=read-write
3281 rm -f conftest.* conftest[123].*
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.
3298 gcc_GAS_CHECK_FEATURE([-mno-relax support],
3299 gcc_cv_as_mno_relax,[-mno-relax],[.text],,
3300 [check_leb128_asflags=-mno-relax])
3303 check_leb128_asflags=
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],
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
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
3332 # play safe, assume the assembler is broken.
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,,
3355 .cfi_escape 1, 2, 3, 4, 5
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
3368 if test x$gas = xyes; then
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
3382 gcc_cv_as_cfi_directive=yes
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
3393 gcc_cv_as_cfi_directive=no
3400 gcc_cv_as_cfi_directive=yes
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,,
3407 .cfi_adjust_cfa_offset 64
3409 .cfi_adjust_cfa_offset 128
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
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,,
3432 .cfi_personality 0, symbol
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,,
3441 .cfi_sections .debug_frame, .eh_frame
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
3457 gcc_cv_as_cfi_sections_directive=yes
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
3467 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,,
3474 .section .eh_frame,"aw",@progbits
3476 .4byte .LECIE1-.LSCIE1
3490 .4byte .LEFDE1-.LASFDE1
3492 .4byte .LASFDE1-__FRAME_BEGIN__
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; }
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
3526 # Uh oh, what do we do now?
3527 gcc_cv_as_eh_frame=no
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,
3541 if test $gcc_cv_as_section_exclude_e = no; then
3543 # Solaris as uses #exclude instead.
3547 conftest_s='.section "foo1", #exclude'
3549 i?86-*-solaris2* | x86_64-*-solaris2*)
3550 conftest_s='.section foo1, #exclude'
3555 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_hash,,
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.
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.
3570 gcc_cv_as_shf_gnu_retain=no
3573 gcc_GAS_CHECK_FEATURE([section 'R' flag], gcc_cv_as_shf_gnu_retain,
3575 [.section .foo,"awR",%progbits
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.
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.
3590 gcc_cv_as_section_link_order=no
3593 gcc_GAS_CHECK_FEATURE([section 'o' flag], gcc_cv_as_section_link_order,
3597 .section __patchable_function_entries,"awo",%progbits,.foo
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,
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,
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
3619 # SHF_MERGE support is broken in Solaris ld up to Solaris 11.3/SPARC for
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
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,
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
3640 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
3641 gcc_cv_as_comdat_group_percent,
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
3648 # Sun as uses a completely different syntax.
3653 .group foo,".text%foo",#comdat
3654 .section ".text%foo", #alloc,#execinstr,#progbits
3659 i?86-*-solaris2* | x86_64-*-solaris2*)
3661 .group foo,.text%foo,#comdat
3662 .section .text%foo, "ax", @progbits
3668 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
3669 gcc_cv_as_comdat_group_group,
3673 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
3674 gcc_cv_as_comdat_group_group=no
3678 if test x"$ld_is_gold" = xyes; then
3680 elif test x"$ld_is_mold" = xyes; then
3682 elif test $in_tree_ld = yes ; then
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
3688 elif echo "$ld_ver" | grep GNU > /dev/null; then
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
3694 elif test "$ld_vers_major" -lt 2; then
3696 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
3703 *-*-solaris2.1[1-9]*)
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
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
3713 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
3715 elif test "$ld_vers_minor" -ge 2267; then
3720 # Assume linkers other than GNU ld don't support COMDAT group.
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.
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
3749 # Full support for hidden thunks in linkonce sections only appeared in
3750 # Solaris 11/OpenSolaris.
3751 *-*-solaris2.1[[1-9]]*)
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.])
3766 gcc_GAS_CHECK_FEATURE([line table is_stmt support],
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,,
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
3786 [case "${enableval}" in
3790 AC_MSG_ERROR([unknown newlib-nano-formatted-io setting $enableval])
3794 # Thread-local storage - the check is heavily parameterized.
3801 .section ".tdata","awT",@progbits
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
3822 add_s r0,r0, @foo@tpoff'
3824 cris-*-*|crisv32-*-*)
3826 .section ".tdata","awT",@progbits
3831 tls_as_opt=--fatal-warnings
3835 .section ".tdata","awT",@progbits
3845 .section ".tdata","awT",@progbits
3849 addil LT%foo-$tls_gdidx$,gp
3850 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3853 addil LT%foo-$tls_ldidx$,gp
3855 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3856 addil LR%foo-$tls_dtpoff$,%ret0
3857 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3859 addil LT%foo-$tls_ieoff$,gp
3860 ldw RT%foo-$tls_ieoff$(%r1),%t2
3863 addil LR%foo-$tls_leoff$,%t1
3864 ldo RR%foo-$tls_leoff$(%r1),%t2'
3865 tls_as_opt=--fatal-warnings
3869 .section ".tdata","awT",%progbits
3878 i[34567]86-*-* | x86_64-*-*)
3880 i[34567]86-*-solaris2.* | x86_64-*-solaris2.*)
3887 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3889 .section .tdata,"awt",@progbits'
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.])
3897 .section ".tdata","awT",@progbits'
3899 tls_as_opt="--fatal-warnings"
3903 if test x$on_solaris = xyes; then
3905 yes) tls_as_opt="$tls_as_opt --32" ;;
3908 conftest_s="$conftest_s
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"
3924 if test x$on_solaris = xyes; then
3926 yes) tls_as_opt="$tls_as_opt --64" ;;
3927 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3930 conftest_s="$conftest_s
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"
3944 .section ".tdata","awT",@progbits
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
3960 .section .tdata,"awT",@progbits
3967 tls_as_opt='--fatal-warnings'
3971 .section .tdata,"awT",@progbits
3975 addik r5,r20,x@TLSGD
3976 addik r5,r20,x@TLSLDM'
3977 tls_as_opt='--fatal-warnings'
3981 .section .tdata,"awT",@progbits
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'
3996 .section .tdata,"awT",@progbits
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'
4010 .section ".tdata","awT",@progbits'
4011 tls_as_opt="--fatal-warnings"
4015 .section ".tdata","awT",%progbits
4019 add x0, x0, #:tlsgd_lo12:x
4022 tls_as_opt='--fatal-warnings'
4026 .section ".tdata","awT",@progbits
4029 l.movhi r3, tpoffha(foo)
4031 l.lwz r4, tpofflo(foo)(r3)'
4032 tls_as_opt=--fatal-warnings
4036 .extern __get_tpointer
4052 .section ".tdata","awT",@progbits
4060 addi 3,2,ld0@got@tlsgd
4066 addi 3,2,x1@got@tlsld
4072 addis 9,3,x2@dtprel@ha
4073 addi 9,9,x2@dtprel@l
4076 ld 9,x3@got@dtprel(2)
4080 tls_as_opt="-a64 --fatal-warnings"
4084 .section ".tdata","awT",@progbits
4092 addi 3,31,ld0@got@tlsgd
4094 addi 3,31,x1@got@tlsld
4097 addis 9,3,x2@dtprel@ha
4098 addi 9,9,x2@dtprel@l
4099 lwz 9,x3@got@tprel(31)
4102 addis 9,2,x2@tprel@ha
4103 addi 9,9,x2@tprel@l'
4104 tls_as_opt="-a32 --fatal-warnings"
4108 .section .tdata,"awT",@progbits
4112 call __tls_get_addr'
4113 tls_as_opt='--fatal-warnings'
4117 .section ".tdata","awT",@progbits
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"
4134 .section ".tdata","awT",@progbits
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"
4148 sh-*-* | sh[123456789lbe]*-*-*)
4150 .section ".tdata","awT",@progbits
4158 tls_as_opt=--fatal-warnings
4162 sparc*-sun-solaris2.*)
4169 if test x$on_solaris = xyes && test x$gas_flag = xno; then
4171 .section ".tdata",#alloc,#write,#tls'
4174 .section ".tdata","awT",@progbits'
4175 tls_as_opt="-32 --fatal-warnings"
4177 conftest_s="$conftest_s
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"
4201 .section ".tdata","awT",@progbits
4204 movi a8, foo@TLSFUNC
4205 movi a10, foo@TLSARG
4206 callx8.tls a8, foo@TLSCALL'
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.
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
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
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"
4250 # HP-UX ld uses -a flags to select between shared and archive.
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"
4258 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
4260 gcc_cv_ld_static_dynamic=yes
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
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.
4287 gcc_cv_ld_version_script=yes
4288 ld_version_script_option='-M'
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)
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
4304 gcc_cv_ld_soname=yes
4305 ld_soname_option='-install_name'
4307 # Solaris 2 ld always supports -h. It also supports --soname for GNU
4308 # ld compatiblity since some Solaris 10 update.
4310 gcc_cv_ld_soname=yes
4311 ld_soname_option='-h'
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
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
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.])
4336 AC_MSG_RESULT($gcc_cv_ld_demangle)
4339 AC_MSG_CHECKING(linker plugin support)
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"
4349 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
4351 # FIXME: ld_is_gold?
4352 ld_vers_major="$gcc_cv_gld_major_version"
4353 ld_vers_minor="$gcc_cv_gld_minor_version"
4355 # Determine plugin linker version.
4356 # FIXME: Partial duplicate from above, generalize.
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
4362 ld_vers=`echo $ld_ver | sed -n \
4363 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
4365 ld_vers=`echo $ld_ver | sed -n \
4366 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
4368 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
4369 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
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
4379 elif test "$ld_is_mold" = yes; then
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
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
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])])
4416 # Target CPU-specific assembler checks.
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.])
4426 if test x$with_abi = xilp32; then
4427 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4428 Upgrade the Assembler.])
4430 if test x"$with_multilib_list" = xdefault; then
4431 TM_MULTILIB_CONFIG=lp64
4433 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
4434 for aarch64_multilib in ${aarch64_multilibs}; do
4435 case ${aarch64_multilib} in
4437 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4438 Upgrade the Assembler.])
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,,
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,
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])
4465 tm_defines="${tm_defines} TARGET_ENABLE_BTI=1 TARGET_ENABLE_PAC_RET=1"
4470 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-standard-branch-protection.\
4471 Valid choices are 'yes' and 'no'.])
4476 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
4477 AC_ARG_ENABLE(fix-cortex-a53-835769,
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])
4487 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
4492 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
4493 Valid choices are 'yes' and 'no'.])
4499 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
4500 AC_ARG_ENABLE(fix-cortex-a53-843419,
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])
4510 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
4515 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
4516 Valid choices are 'yes' and 'no'.])
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,,
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,,
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.])])
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,
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,
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
4581 ;; avr-nm should print "... R xxvaryy", not "... D xxvaryy".
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
4591 if grep ' R xxvaryy' conftest.nm > /dev/null; then
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.])
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)]])
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]])
4608 rm -f conftest.s conftest.o conftest.elf conftest.nm
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.])])
4620 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,
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,
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
4643 gcc_cv_as_sparc_gotdata_op=yes
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,
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
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,
4675 .uaword %r_disp32(foo)
4676 .byte 0x32, 0x33, 0x34
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
4689 gcc_cv_as_sparc_ua_pcrel_hidden=yes
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,
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
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,
4715 .register %g2, #scratch
4716 .register %g3, #scratch
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,
4729 .register %g2, #scratch
4730 .register %g3, #scratch
4733 1: cwbneg %g2, %g3, 1f
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,
4747 .register %g2, #scratch
4748 .register %g3, #scratch
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,
4759 .register %g2, #scratch
4760 .register %g3, #scratch
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,
4771 .register %g2, #scratch
4772 .register %g3, #scratch
4776 casa [[%g2]] 0xb, %g3, %g1],,
4777 [AC_DEFINE(HAVE_AS_LEON, 1,
4778 [Define if your assembler supports LEON instructions.])])
4782 i[34567]86-*-* | x86_64-*-*)
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])
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
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.])
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,,
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,,
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
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
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.])
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.])])
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,,
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,,
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,,
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,,
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,,
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,,
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,,
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"
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"
4954 ld_ix86_gld_32_opt="-melf_i386"
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
4967 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4968 [Define if your assembler and linker support @tlsgdplt.])])
4971 .section .tdata,"aw'$tls_section_flag'",@progbits
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],
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
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.])
4990 .section .text,"ax",@progbits
4992 .type _start, @function
4994 leal value@tlsldm(%ebx), %eax
4995 call ___tls_get_addr@plt
4997 .section .tdata,"aw'$tls_section_flag'",@progbits
4998 .type value, @object
5000 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
5001 gcc_cv_as_ix86_tlsldm,
5002 [$as_ix86_gas_32_opt],
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
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.])
5025 gcc_GAS_CHECK_FEATURE([R_386_GOT32X reloc],
5026 gcc_cv_as_ix86_got32x,
5027 [$as_ix86_gas_32_opt],
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
5038 gcc_cv_as_ix86_got32x=yes
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],
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'.])
5059 .section .text,"ax",@progbits
5061 .type _start, @function
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
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],
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
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.])
5091 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
5092 gcc_cv_as_ia64_ltoffx_ldxmov_relocs,,
5094 addl r15 = @ltoffx(x#), gp
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.])])
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
5119 *-*-aix*) conftest_s=' .machine "pwr5"
5122 *-*-darwin*) conftest_s=' .text
5124 *) conftest_s=' .machine power4
5129 gcc_GAS_CHECK_FEATURE([mfcr field support],
5130 gcc_cv_as_powerpc_mfcrf,,
5132 [AC_DEFINE(HAVE_AS_MFCRF, 1,
5133 [Define if your assembler supports mfcr field.])])
5136 *-*-aix*) conftest_s=' .machine "pwr10"
5139 *-*-darwin*) conftest_s=' .text
5141 *) conftest_s=' .machine power10
5146 gcc_GAS_CHECK_FEATURE([htm support on Power10],
5147 gcc_cv_as_power10_htm,,
5149 [AC_DEFINE(HAVE_AS_POWER10_HTM, 1,
5150 [Define if your assembler supports htm insns on power10.])])
5153 *-*-aix*) conftest_s=' .csect .text[[PR]]
5155 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
5159 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
5160 *) conftest_s=' .text
5162 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
5165 gcc_GAS_CHECK_FEATURE([rel16 relocs],
5166 gcc_cv_as_powerpc_rel16, -a32,
5168 [AC_DEFINE(HAVE_AS_REL16, 1,
5169 [Define if your assembler supports R_PPC_REL16 relocs.])])
5172 *-*-aix*) conftest_s=' .machine "pwr7"
5175 *) conftest_s=' .machine power7
5180 gcc_GAS_CHECK_FEATURE([vector-scalar support],
5181 gcc_cv_as_powerpc_vsx, -a32,
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.])])
5206 gcc_GAS_CHECK_FEATURE([AIX .ref support],
5208 [ .csect stuff[[rw]]
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,,
5223 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
5224 [Define if your assembler supports AIX debug frame section label reference.])])
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"
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],
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
5258 [Requesting --with-fp-32= requires assembler support for .module.])
5261 gcc_GAS_CHECK_FEATURE([.micromips support],
5262 gcc_cv_as_micromips_support,[--fatal-warnings],
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
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,,
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
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
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
5322 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
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
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
5341 .cfi_personality 0x80,indirect_ptr
5348 .section .data,"aw",@progbits
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
5357 elif $gcc_cv_readelf --relocs conftest 2>&1 \
5358 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
5361 gcc_cv_ld_mips_personality_relaxation=yes
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.])
5372 gcc_GAS_CHECK_FEATURE([-mnan= support],
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
5380 [Requesting --with-nan= requires assembler support for -mnan=])
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.])
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,,
5408 .long %gotoff(foo)],,
5409 [AC_DEFINE(HAVE_AS_NIOS2_GOTOFF_RELOCATION, 1,
5410 [Define if your assembler supports %gotoff relocation syntax.])])
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,
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.])])
5430 gcc_GAS_CHECK_FEATURE([.dtprelword support],
5431 gcc_cv_as_loongarch_dtprelword, [2,18,0],,
5432 [.section .tdata,"awT",@progbits
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,,
5447 .cfi_personality 0x9b,a
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 gcc_GAS_CHECK_FEATURE([conditional branch relaxation support],
5457 gcc_cv_as_loongarch_cond_branch_relax,
5464 [AC_DEFINE(HAVE_AS_COND_BRANCH_RELAXATION, 1,
5465 [Define if your assembler supports conditional branch relaxation.])])
5468 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5469 gcc_cv_as_s390_gnu_attribute,,
5470 [.gnu_attribute 8,1],,
5471 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5472 [Define if your assembler supports .gnu_attribute.])])
5473 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
5474 gcc_cv_as_s390_machine_machinemode,,
5479 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
5480 [Define if your assembler supports .machine and .machinemode.])])
5481 gcc_GAS_CHECK_FEATURE([architecture modifiers support],
5482 gcc_cv_as_s390_architecture_modifiers,,
5483 [ .machine z13+vx ],,
5484 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
5485 [Define if your assembler supports architecture modifiers.])])
5486 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints],
5487 gcc_cv_as_s390_vector_loadstore_alignment_hints,,
5488 [ vl %v24,0(%r15),3 ],,
5489 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS, 1,
5490 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument.])])
5491 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints on z13],
5492 gcc_cv_as_s390_vector_loadstore_alignment_hints_on_z13, [-mzarch -march=z13],
5493 [ vl %v24,0(%r15),3 ],,
5494 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS_ON_Z13, 1,
5495 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument on z13.])])
5500 # Mips, LoongArch and HP-UX need the GNU assembler.
5501 # Linux on IA64 might be able to use the Intel assembler.
5504 mips*-*-* | loongarch*-*-* | *-*-hpux* )
5505 if test x$gas_flag = xyes \
5506 || test x"$host" != x"$build" \
5507 || test ! -x "$gcc_cv_as" \
5508 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
5511 echo "*** This configuration requires the GNU assembler" >&2
5517 # AMD GCN needs the LLVM assembler and linker.
5518 # Test that LLVM is at least 13.0.1.
5521 AC_MSG_CHECKING(llvm assembler version)
5522 gcc_cv_as_version="unknown"
5523 if test x$gcc_cv_as != x; then
5524 gcc_cv_as_version=`$gcc_cv_as --version 2>&1 | sed -ne '/version/s/.* \([[0-9]]\)/\1/p' || echo error`
5525 case "$gcc_cv_as_version" in
5526 13.0.[[1-9]]*) ;; # 13.0.1+
5527 13.[[1-9]]*) ;; # 13.1+
5528 1[[4-9]]*) ;; # 14..19
5529 [[2-9]][[0-9]]*) ;; # 20..99
5530 [[1-9]][[0-9]][[0-9]]*) ;; # 100+
5531 error) AC_MSG_ERROR([cannot determine LLVM version]) ;;
5532 *) AC_MSG_ERROR([LLVM 13.0.1 or later is required (found LLVM $gcc_cv_as_version)]) ;;
5535 AC_MSG_RESULT([$gcc_cv_as_version, ok])
5541 gcc_GAS_CHECK_FEATURE([assembler for arm accepts context-specific architecture extensions],
5542 gcc_cv_as_arm_option_extensions,
5543 [-march=armv8.1-m.main+mve],
5548 [AC_DEFINE(HAVE_GAS_ARM_EXTENDED_ARCH, 1,
5549 [Define if your Arm assembler permits context-specific feature extensions.])])
5552 # ??? Not all targets support dwarf2 debug_line, even within a version
5553 # of gas. Moreover, we need to emit a valid instruction to trigger any
5554 # info to the output file. So, as supported targets are added to gas 2.11,
5555 # add some instruction here to (also) show we expect this might work.
5556 # ??? Once 2.11 is released, probably need to add first known working
5557 # version to the per-target configury.
5559 aarch64 | alpha | arc | arm | avr | bfin | cris | csky | i386 | loongarch | m32c \
5560 | m68k | microblaze | mips | nds32 | nios2 | pa | riscv | rs6000 | score | sparc \
5561 | visium | xstormy16 | xtensa)
5571 if test x"$insn" != x; then
5573 .file 1 \"conftest.s\"
5576 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
5577 gcc_cv_as_dwarf2_debug_line,,
5579 [if test x$gcc_cv_objdump != x \
5580 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
5581 | grep debug_line > /dev/null 2>&1; then
5582 gcc_cv_as_dwarf2_debug_line=yes
5583 elif test x$gcc_cv_otool != x \
5584 && $gcc_cv_otool -l conftest.o 2> /dev/null \
5585 | grep debug_line > /dev/null 2>&1; then
5586 gcc_cv_as_dwarf2_debug_line=yes
5589 # The .debug_line file table must be in the exact order that
5590 # we specified the files, since these indices are also used
5591 # by DW_AT_decl_file. Approximate this test by testing if
5592 # the assembler bitches if the same index is assigned twice.
5593 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
5594 gcc_cv_as_dwarf2_file_buggy,,
5598 if test $gcc_cv_as_dwarf2_debug_line = yes \
5599 && test $gcc_cv_as_dwarf2_file_buggy = no; then
5600 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
5601 [Define if your assembler supports dwarf2 .file/.loc directives,
5602 and preserves file table indices exactly as given.])
5604 if test $gcc_cv_as_leb128 = yes; then
5606 .file 1 \"conftest.s\"
5607 .loc 1 3 0 view .LVU1
5613 gcc_GAS_CHECK_FEATURE([dwarf2 debug_view support],
5614 gcc_cv_as_dwarf2_debug_view,,
5616 [AC_DEFINE(HAVE_AS_DWARF2_DEBUG_VIEW, 1,
5617 [Define if your assembler supports views in dwarf2 .loc directives.])])
5621 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
5622 gcc_cv_as_gdwarf2_flag,
5623 [--gdwarf2], [$insn],,
5624 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
5625 [Define if your assembler supports the --gdwarf2 option.])])
5627 gcc_GAS_CHECK_FEATURE([--gdwarf-5 option],
5628 gcc_cv_as_gdwarf_5_flag,
5629 [--gdwarf-5], [$insn],
5630 [if test x$gcc_cv_objdump != x \
5631 && $gcc_cv_objdump -Wi conftest.o 2>&1 \
5632 | grep DW_TAG_compile_unit > /dev/null 2>&1; then
5633 gcc_cv_as_gdwarf_5_flag=yes;
5634 fi],[AC_DEFINE(HAVE_AS_GDWARF_5_DEBUG_FLAG, 1,
5635 [Define if your assembler supports the --gdwarf-5 option.])])
5638 win32 | pe | cygwin* | mingw32*)
5639 section_flags=\"dr\"
5640 function_type=".def foo; .scl 2; .type 32; .endef"
5643 section_flags=\"\",%progbits
5644 function_type=".type foo, %function"
5645 function_size=".size foo, .-foo";;
5647 dwarf4_debug_info_size=0x46
5648 dwarf4_high_pc_form=7
5649 dwarf4_debug_aranges_size=0x2c
5651 for dwarf4_addr_size in 8 4; do
5667 .section .debug_info,$section_flags
5669 .4byte $dwarf4_debug_info_size
5671 .4byte .Ldebug_abbrev0
5672 .byte 0x$dwarf4_addr_size
5674 .ascii \"GNU C17\\0\"
5678 .${dwarf4_addr_size}byte .Ltext0
5679 .${dwarf4_addr_size}byte .Letext0-.Ltext0
5680 .4byte .Ldebug_line0
5686 .${dwarf4_addr_size}byte .LFB0
5687 .${dwarf4_addr_size}byte .LFE0-.LFB0
5691 .section .debug_abbrev,$section_flags
5707 .byte 0x$dwarf4_high_pc_form
5728 .byte 0x$dwarf4_high_pc_form
5734 .section .debug_aranges,$section_flags
5735 .4byte $dwarf4_debug_aranges_size
5737 .4byte .Ldebug_info0
5742 .${dwarf4_addr_size}byte .Ltext0
5743 .${dwarf4_addr_size}byte .Letext0-.Ltext0
5744 .${dwarf4_addr_size}byte 0
5745 .${dwarf4_addr_size}byte 0
5746 .section .debug_line,$section_flags
5748 .4byte .LELT0-.LSLT0
5751 .4byte .LELTP0-.LASLTP0
5779 .byte 0x$dwarf4_line_sz
5781 .${dwarf4_addr_size}byte .LM1
5786 .byte 0x$dwarf4_line_sz
5788 .${dwarf4_addr_size}byte .LM2
5793 .byte 0x$dwarf4_line_sz
5795 .${dwarf4_addr_size}byte .Letext0
5800 .section .debug_str,$section_flags
5804 if test $dwarf4_addr_size = 4; then
5805 gcc_GAS_CHECK_FEATURE([assembly of compiler generated 32-bit .debug_line],
5806 gcc_cv_as_debug_line_32_flag,,
5808 [dwarf4_success=yes])
5810 gcc_GAS_CHECK_FEATURE([assembly of compiler generated 64-bit .debug_line],
5811 gcc_cv_as_debug_line_64_flag,,
5813 [dwarf4_success=yes])
5815 if test $dwarf4_success = yes; then
5817 gcc_GAS_CHECK_FEATURE([--gdwarf-4 not refusing compiler generated .debug_line],
5818 gcc_cv_as_dwarf_4_debug_line_flag,
5819 [--gdwarf-4], [$conftest_s],,
5820 [dwarf4_success=yes])
5823 dwarf4_debug_info_size=0x36
5824 dwarf4_high_pc_form=6
5825 dwarf4_debug_aranges_size=0x1c
5829 if test $dwarf4_success = yes; then
5847 gcc_GAS_CHECK_FEATURE([--gdwarf-4 with the APP marker],
5848 gcc_cv_as_dwarf_4_app_flag,
5849 [--gdwarf-4], [$conftest_s],, [dwarf4_success=yes])
5852 if test $dwarf4_success = yes; then
5862 gcc_GAS_CHECK_FEATURE([working --gdwarf-4/--gdwarf-5 for all sources],
5863 gcc_cv_as_working_gdwarf_n_flag,
5867 if test x$gcc_cv_objdump != x \
5868 && $gcc_cv_objdump -W conftest.o 2>&1 \
5869 | grep conftest.s > /dev/null 2>&1; then
5870 gcc_cv_as_working_gdwarf_n_flag=no
5872 gcc_cv_as_working_gdwarf_n_flag=yes
5874 changequote([,])dnl])
5875 if test $gcc_cv_as_working_gdwarf_n_flag = yes; then
5876 AC_DEFINE(HAVE_AS_WORKING_DWARF_N_FLAG, 1,
5877 [Define if your assembler supports --gdwarf-4/--gdwarf-5 even with
5878 compiler generated .debug_line.])
5882 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
5883 gcc_cv_as_debug_prefix_map_flag,
5884 [--debug-prefix-map /a=/b], [$insn],,
5885 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
5886 [Define if your assembler supports the --debug-prefix-map option.])])
5889 gcc_GAS_CHECK_FEATURE([compressed debug sections],
5890 gcc_cv_as_compress_debug,,,
5891 [# gas compiled without zlib cannot compress debug sections and warns
5892 # about it, but still exits successfully. So check for this, too.
5893 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
5895 gcc_cv_as_compress_debug=0
5896 elif $gcc_cv_as --compress-debug-sections=zlib -o conftest.o conftest.s > /dev/null 2>&1
5898 gcc_cv_as_compress_debug=1
5899 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5900 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5901 # Since binutils 2.40, gas supports --compress-debug-sections=zstd.
5902 if $gcc_cv_as --compress-debug-sections=zstd -o conftest.o conftest.s > /dev/null 2>&1
5904 gcc_cv_as_compress_debug=2
5907 gcc_cv_as_compress_debug=0
5909 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
5910 [Define to the level of your assembler's compressed debug section support.])
5911 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
5912 [Define to the assembler option to enable compressed debug sections.])
5913 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
5914 [Define to the assembler option to disable compressed debug sections.])
5916 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,,
5918 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
5919 [Define if your assembler supports .lcomm with an alignment field.])])
5921 if test x$with_sysroot = x && test x$host = x$target \
5922 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
5923 && test "$prefix" != "NONE"; then
5924 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
5925 [Define to PREFIX/include if cpp should also search that directory.])
5928 # Determine the version of glibc, if any, used on the target.
5929 AC_MSG_CHECKING([for target glibc version])
5930 AC_ARG_WITH([glibc-version],
5931 [AS_HELP_STRING([--with-glibc-version=M.N],
5932 [assume GCC used with glibc version M.N or later])], [
5933 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
5934 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
5935 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
5937 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
5939 glibc_version_major=0
5940 glibc_version_minor=0
5941 [if test -f $target_header_dir/features.h \
5942 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
5943 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
5944 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
5945 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
5947 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
5948 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
5949 [GNU C Library major version number used on the target, or 0.])
5950 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
5951 [GNU C Library minor version number used on the target, or 0.])
5953 AC_ARG_ENABLE(gnu-unique-object,
5954 [AS_HELP_STRING([--enable-gnu-unique-object],
5955 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
5956 [case $enable_gnu_unique_object in
5958 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
5959 Valid choices are 'yes' and 'no'.]) ;;
5961 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,,
5962 [.type foo, '$target_type_format_char'gnu_unique_object],,
5963 # We need to unquote above to to use the definition from config.gcc.
5964 # Also check for ld.so support, i.e. glibc 2.11 or higher.
5965 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
5967 if test x$enable_gnu_unique_object = xyes; then
5968 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
5969 [Define if your assembler supports @gnu_unique_object.])
5972 AC_CACHE_CHECK([assembler for tolerance to line number 0],
5973 [gcc_cv_as_line_zero],
5974 [gcc_cv_as_line_zero=no
5975 if test "x$gcc_cv_as" != x; then
5976 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
5977 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
5978 test "x`cat conftest.out`" = x
5980 gcc_cv_as_line_zero=yes
5982 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
5983 cat conftest.s >&AS_MESSAGE_LOG_FD
5984 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
5985 cat conftest.out >&AS_MESSAGE_LOG_FD
5987 rm -f conftest.o conftest.s conftest.out
5989 if test "x$gcc_cv_as_line_zero" = xyes; then
5990 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
5991 [Define if the assembler won't complain about a line such as # 0 "" 2.])
5994 AC_MSG_CHECKING(support for thin archives)
5995 thin_archive_support=no
5996 echo 'int main (void) { return 0; }' > conftest.c
5997 if ($AR --version | sed 1q | grep "GNU ar" \
5998 && $CC $CFLAGS -c conftest.c \
5999 && $AR rcT conftest.a conftest.o \
6000 && $CC $CFLAGS $LDFLAGS -o conftest conftest.a) >/dev/null 2>&1; then
6001 thin_archive_support=yes
6003 rm -f conftest.c conftest.o conftest.a conftest
6004 AC_MSG_RESULT($thin_archive_support)
6005 AC_SUBST(thin_archive_support)
6007 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
6008 gcc_cv_ld_eh_frame_hdr=no
6009 if test $in_tree_ld = yes ; then
6010 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 \
6011 && test $in_tree_ld_is_elf = yes; then
6012 gcc_cv_ld_eh_frame_hdr=yes
6014 elif test x$gcc_cv_ld != x; then
6015 if echo "$ld_ver" | grep GNU > /dev/null; then
6016 # Check if linker supports --eh-frame-hdr option
6017 if $gcc_cv_ld --help 2>&1 | grep eh-frame-hdr > /dev/null; then
6018 gcc_cv_ld_eh_frame_hdr=yes
6023 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
6024 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
6025 gcc_cv_ld_eh_frame_hdr=yes
6031 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
6032 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
6033 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
6034 [Define if your linker supports .eh_frame_hdr.])
6036 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
6038 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
6039 gcc_cv_ld_eh_frame_ciev3=no
6040 if test $in_tree_ld = yes ; then
6041 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 \
6042 && test $in_tree_ld_is_elf = yes; then
6043 gcc_cv_ld_eh_frame_ciev3=yes
6045 elif test x$gcc_cv_ld != x; then
6046 if echo "$ld_ver" | grep GNU > /dev/null; then
6047 gcc_cv_ld_eh_frame_ciev3=yes
6048 if test 0"$ld_date" -lt 20040513; then
6049 if test -n "$ld_date"; then
6050 # If there was date string, but was earlier than 2004-05-13, fail
6051 gcc_cv_ld_eh_frame_ciev3=no
6052 elif test "$ld_vers_major" -lt 2; then
6053 gcc_cv_ld_eh_frame_ciev3=no
6054 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
6055 gcc_cv_ld_eh_frame_ciev3=no
6061 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
6062 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
6063 gcc_cv_ld_eh_frame_ciev3=yes
6069 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
6070 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
6071 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
6072 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
6074 AC_MSG_CHECKING(linker position independent executable support)
6076 if test $in_tree_ld = yes ; then
6078 # Full PIE support on Solaris was only introduced in gld 2.26.
6079 *-*-solaris2*) gcc_gld_pie_min_version=26 ;;
6080 *) gcc_gld_pie_min_version=15 ;;
6082 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 \
6083 && test $in_tree_ld_is_elf = yes; then
6086 elif test x$gcc_cv_ld != x; then
6087 # Check if linker supports -pie option
6088 if $gcc_cv_ld --help 2>&1 | grep -- -pie > /dev/null; then
6092 if echo "$ld_ver" | grep GNU > /dev/null \
6093 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
6100 *-*-solaris2.1[[1-9]]*)
6101 # Solaris 11.3 added PIE support.
6102 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
6109 if test x"$gcc_cv_ld_pie" = xyes; then
6110 AC_DEFINE(HAVE_LD_PIE, 1,
6111 [Define if your linker supports PIE option.])
6113 AC_MSG_RESULT($gcc_cv_ld_pie)
6115 AC_MSG_CHECKING(linker PIE support with copy reloc)
6116 gcc_cv_ld_pie_copyreloc=no
6117 if test $gcc_cv_ld_pie = yes ; then
6118 if test $in_tree_ld = yes ; then
6119 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
6120 gcc_cv_ld_pie_copyreloc=yes
6122 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6123 # Check if linker supports -pie option with copy reloc
6125 i?86-*-linux* | x86_64-*-linux*)
6126 cat > conftest1.s <<EOF
6129 .type a_glob, @object
6134 cat > conftest2.s <<EOF
6137 .type main, @function
6139 movl %eax, a_glob(%rip)
6142 .section .data.rel,"aw",@progbits
6147 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6148 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
6149 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6150 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
6151 gcc_cv_ld_pie_copyreloc=yes
6153 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
6158 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
6159 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
6160 [Define 0/1 if your linker supports -pie option with copy reloc.])
6161 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
6163 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
6164 gcc_cv_ld_eh_gc_sections=no
6165 if test $in_tree_ld = yes ; then
6166 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 \
6167 && test $in_tree_ld_is_elf = yes; then
6168 gcc_cv_ld_eh_gc_sections=yes
6170 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
6171 cat > conftest.s <<EOF
6174 .type _start, @function
6177 .size _start, .-_start
6178 .section .text.foo,"ax",@progbits
6179 .type foo, @function
6183 .section .gcc_except_table.foo,"a",@progbits
6186 .section .eh_frame,"a",@progbits
6189 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6190 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6191 | grep "gc-sections option ignored" > /dev/null; then
6192 gcc_cv_ld_eh_gc_sections=no
6193 elif $gcc_cv_objdump -h conftest 2> /dev/null \
6194 | grep gcc_except_table > /dev/null; then
6195 gcc_cv_ld_eh_gc_sections=yes
6196 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
6197 if test x$gcc_cv_as_comdat_group != xyes; then
6198 gcc_cv_ld_eh_gc_sections=no
6199 cat > conftest.s <<EOF
6202 .type _start, @function
6205 .size _start, .-_start
6206 .section .gnu.linkonce.t.foo,"ax",@progbits
6207 .type foo, @function
6211 .section .gcc_except_table.foo,"a",@progbits
6214 .section .eh_frame,"a",@progbits
6217 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6218 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6219 | grep "gc-sections option ignored" > /dev/null; then
6220 gcc_cv_ld_eh_gc_sections=no
6221 elif $gcc_cv_objdump -h conftest 2> /dev/null \
6222 | grep gcc_except_table > /dev/null; then
6223 gcc_cv_ld_eh_gc_sections=yes
6229 rm -f conftest.s conftest.o conftest
6233 # ??? This apparently exposes a binutils bug with PC-relative relocations.
6234 gcc_cv_ld_eh_gc_sections=no
6237 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
6238 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
6239 [Define if your linker supports garbage collection of
6240 sections in presence of EH frames.])
6242 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
6244 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
6245 gcc_cv_ld_eh_gc_sections_bug=no
6246 if test $in_tree_ld = yes ; then
6247 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 \
6248 && test $in_tree_ld_is_elf = yes; then
6249 gcc_cv_ld_eh_gc_sections_bug=yes
6251 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
6252 gcc_cv_ld_eh_gc_sections_bug=yes
6253 cat > conftest.s <<EOF
6256 .type _start, @function
6259 .size _start, .-_start
6260 .section .text.startup.foo,"ax",@progbits
6261 .type foo, @function
6265 .section .gcc_except_table.foo,"a",@progbits
6268 .section .eh_frame,"a",@progbits
6271 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6272 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6273 | grep "gc-sections option ignored" > /dev/null; then
6275 elif $gcc_cv_objdump -h conftest 2> /dev/null \
6276 | grep gcc_except_table > /dev/null; then
6277 gcc_cv_ld_eh_gc_sections_bug=no
6280 rm -f conftest.s conftest.o conftest
6282 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
6283 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
6284 [Define if your linker has buggy garbage collection of
6285 sections support when .text.startup.foo like sections are used.])
6287 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
6289 AC_MSG_CHECKING(linker for compressed debug sections)
6290 # GNU ld/gold support --compressed-debug-sections=zlib since binutils 2.26.
6291 if $gcc_cv_ld --help 2>&1 | grep -- '--compress-debug-sections.*\<zlib-gabi\>' > /dev/null; then
6292 gcc_cv_ld_compress_debug=1
6293 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
6294 # Detect zstd debug section compression support
6295 if $gcc_cv_ld --help 2>&1 | grep -- '--compress-debug-sections.*\<zstd\>' > /dev/null; then
6296 gcc_cv_ld_compress_debug=2
6302 # Introduced in Solaris 11.2.
6303 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
6304 gcc_cv_ld_compress_debug=1
6305 gcc_cv_ld_compress_debug_option="-z compress-sections"
6307 gcc_cv_ld_compress_debug=0
6311 # Assume linkers other than GNU ld don't support compessed debug
6313 gcc_cv_ld_compress_debug=0
6318 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
6319 [Define to the level of your linker's compressed debug section support.])
6320 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
6321 [Define to the linker option to enable compressed debug sections.])
6322 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
6324 if test x"$ld64_flag" = x"yes"; then
6326 # Set defaults for possibly untestable items.
6327 gcc_cv_ld64_export_dynamic=0
6328 gcc_cv_ld64_platform_version=0
6329 gcc_cv_ld64_demangle=0
6331 if test "$build" = "$host"; then
6337 # On Darwin, because of FAT library support, it is often possible to execute
6338 # exes from compatible archs even when the host differs from the build system.
6339 case "$build","$host" in
6340 x86_64-*-darwin*,i?86-*-darwin* | powerpc64*-*-darwin*,powerpc*-*-darwin*)
6345 # If the configurer specified a minimum ld64 version to be supported, then use
6346 # that to determine feature support.
6347 if test x"${gcc_cv_ld64_version}" != x; then
6348 AC_MSG_CHECKING(ld64 specified version)
6349 gcc_cv_ld64_major=`echo "$gcc_cv_ld64_version" | sed -e 's/\..*//'`
6350 AC_MSG_RESULT($gcc_cv_ld64_major)
6351 if test "$gcc_cv_ld64_major" -ge 97; then
6352 gcc_cv_ld64_demangle=1
6354 if test "$gcc_cv_ld64_major" -ge 236; then
6355 gcc_cv_ld64_export_dynamic=1
6357 if test "$gcc_cv_ld64_major" -ge 512; then
6358 gcc_cv_ld64_platform_version=1
6360 elif test -x "$gcc_cv_ld" -a "$darwin_try_test" -eq 1; then
6361 # If the version was not specified, try to find it.
6362 AC_MSG_CHECKING(linker version)
6363 if test x"${gcc_cv_ld64_version}" = x; then
6364 gcc_cv_ld64_version=`$gcc_cv_ld -v 2>&1 | $EGREP 'ld64|dyld' \
6365 | sed -e 's/.*ld64-//' -e 's/.*dyld-//'| awk '{print $1}'`
6367 AC_MSG_RESULT($gcc_cv_ld64_version)
6369 AC_MSG_CHECKING(linker for -demangle support)
6370 gcc_cv_ld64_demangle=1
6371 if $gcc_cv_ld -demangle < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6372 gcc_cv_ld64_demangle=0
6374 AC_MSG_RESULT($gcc_cv_ld64_demangle)
6376 AC_MSG_CHECKING(linker for -export_dynamic support)
6377 gcc_cv_ld64_export_dynamic=1
6378 if $gcc_cv_ld -export_dynamic < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6379 gcc_cv_ld64_export_dynamic=0
6381 AC_MSG_RESULT($gcc_cv_ld64_export_dynamic)
6383 AC_MSG_CHECKING(linker for -platform_version support)
6384 gcc_cv_ld64_platform_version=1
6385 if $gcc_cv_ld -platform_version macos 10.5 0.0 < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6386 gcc_cv_ld64_platform_version=0
6388 AC_MSG_RESULT($gcc_cv_ld64_platform_version)
6391 if test x"${gcc_cv_ld64_version}" != x; then
6392 AC_DEFINE_UNQUOTED(LD64_VERSION, "${gcc_cv_ld64_version}",
6393 [Define to ld64 version.])
6396 AC_DEFINE_UNQUOTED(LD64_HAS_DEMANGLE, $gcc_cv_ld64_demangle,
6397 [Define to 1 if ld64 supports '-demangle'.])
6399 AC_DEFINE_UNQUOTED(LD64_HAS_EXPORT_DYNAMIC, $gcc_cv_ld64_export_dynamic,
6400 [Define to 1 if ld64 supports '-export_dynamic'.])
6402 AC_DEFINE_UNQUOTED(LD64_HAS_PLATFORM_VERSION, $gcc_cv_ld64_platform_version,
6403 [Define to 1 if ld64 supports '-platform_version'.])
6406 if test x"$dsymutil_flag" = x"yes"; then
6408 # If the user specified a dsymutil path, then we will already have the
6409 # version string, otherwise, pick it up.
6410 if test x"$gcc_cv_dsymutil" = x; then
6411 AC_MSG_WARN([dsymutil is a required tool for this system, but not found])
6412 dsymutil_vers="tool unspecified"
6413 elif test x"$dsymutil_vers" = x; then
6414 dsymutil_vers=`$gcc_cv_dsymutil -v /dev/null 2>&1`
6417 dsymutil_temp=`echo $dsymutil_vers | sed 1q`
6418 AC_MSG_CHECKING(dsymutil version "$dsymutil_temp")
6419 if echo $dsymutil_temp | grep dwarfutils- > /dev/null; then
6420 dsymutil_kind=DWARFUTILS
6421 dsymutil_vers=`echo $dsymutil_temp | sed 's/.*dwarfutils-\([[0-9\.]]*\).*/\1/'`
6422 elif echo $dsymutil_temp | grep clang- > /dev/null; then
6424 dsymutil_vers=`echo $dsymutil_temp | sed 's/.*clang-\([[0-9\.]]*\).*/\1/'`
6425 elif echo $dsymutil_temp | grep 'LLVM version ' > /dev/null; then
6427 dsymutil_vers=`echo $dsymutil_temp | sed 's/.*LLVM\ version\ \([[0-9\.]]*\).*/\1/'`
6429 dsymutil_kind=DET_UNKNOWN
6432 dsymutil_major=`expr "$dsymutil_vers" : '\([[0-9]]*\)'`
6433 dsymutil_minor=`expr "$dsymutil_vers" : '[[0-9]]*\.\([[0-9]]*\)'`
6434 dsymutil_tiny=`expr "$dsymutil_vers" : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
6435 if test x"${dsymutil_minor}" = x; then
6438 if test x"${dsymutil_tiny}" = x; then
6441 AC_DEFINE_UNQUOTED(DSYMUTIL_VERSION, [$dsymutil_kind,${dsymutil_major},${dsymutil_minor},${dsymutil_tiny}],
6442 [Define to the dsymutil version.])
6443 AC_MSG_RESULT($dsymutil_vers : $dsymutil_kind ${dsymutil_major} ${dsymutil_minor} ${dsymutil_tiny} )
6447 win32 | pe | cygwin* | mingw32*)
6448 AC_MSG_CHECKING(broken PE linker dwarf5 support)
6449 gcc_cv_ld_broken_pe_dwarf5=yes
6450 if test $in_tree_ld = yes ; then
6451 if grep -q '\.debug_loclists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6452 $gcc_cv_ld_gld_srcdir/scripttempl/pe*.sc \
6453 && grep -q '\.debug_rnglists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6454 $gcc_cv_ld_gld_srcdir/scripttempl/pe*.sc; then
6455 gcc_cv_ld_broken_pe_dwarf5=no
6458 if $gcc_cv_ld --verbose 2>&1 | grep -q '\.debug_loclists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6459 && $gcc_cv_ld --verbose 2>&1 | grep -q '\.debug_rnglists.*BLOCK.*__section_alignment__.*NOLOAD.*:'; then
6460 gcc_cv_ld_broken_pe_dwarf5=no
6463 if test x$gcc_cv_ld_broken_pe_dwarf5 = xyes; then
6464 AC_DEFINE(HAVE_LD_BROKEN_PE_DWARF5, 1,
6465 [Define if the PE linker has broken DWARF 5 support.])
6467 AC_MSG_RESULT($gcc_cv_ld_broken_pe_dwarf5)
6469 AC_MSG_CHECKING(PE linker --disable-dynamicbase support)
6470 gcc_cv_ld_disable_dynamicbase=no
6471 if test $in_tree_ld = yes; then
6472 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 \
6473 gcc_cv_ld_disable_dynamicbase=yes
6476 if $gcc_cv_ld --help 2>&1 | grep -q 'disable\-]dynamicbase' > /dev/null; then
6477 gcc_cv_ld_disable_dynamicbase=yes
6480 if test x"$gcc_cv_ld_disable_dynamicbase" = xyes; then
6481 AC_DEFINE(HAVE_LD_PE_DISABLE_DYNAMICBASE, 1,
6482 [Define if the PE linker supports --disable-dynamicbase option.])
6484 AC_MSG_RESULT($gcc_cv_ld_disable_dynamicbase)
6492 AC_CACHE_CHECK(linker --as-needed support,
6493 gcc_cv_ld_as_needed,
6494 [gcc_cv_ld_as_needed=no
6495 gcc_cv_ld_as_needed_option='--as-needed'
6496 gcc_cv_ld_no_as_needed_option='--no-as-needed'
6497 if test $in_tree_ld = yes ; then
6498 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 \
6499 && test $in_tree_ld_is_elf = yes; then
6500 gcc_cv_ld_as_needed=yes
6501 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 28; then
6502 gcc_cv_ld_as_needed_option='--push-state --as-needed'
6503 gcc_cv_ld_no_as_needed_option='--pop-state'
6506 elif test x$gcc_cv_ld != x; then
6507 # Check if linker supports --as-needed and --no-as-needed options
6508 if $gcc_cv_ld --help 2>&1 | grep as-needed > /dev/null; then
6509 gcc_cv_ld_as_needed=yes
6510 if $gcc_cv_ld --help 2>&1 | grep push-state > /dev/null \
6511 && $gcc_cv_ld --help 2>&1 | grep pop-state > /dev/null \
6512 && echo "$ld_ver" | grep GNU > /dev/null \
6513 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 28; then
6514 # Use these options only when both ld.bfd and ld.gold support
6515 # --push-state/--pop-state, which unfortunately wasn't added
6517 gcc_cv_ld_as_needed_option='--push-state --as-needed'
6518 gcc_cv_ld_no_as_needed_option='--pop-state'
6521 case "$target:$gnu_ld" in
6523 # Solaris 2 ld always supports -z ignore/-z record. Prefer the native
6525 gcc_cv_ld_as_needed=yes
6526 gcc_cv_ld_as_needed_option="-z ignore"
6527 gcc_cv_ld_no_as_needed_option="-z record"
6531 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
6532 # dl_iterate_phdr, i.e. since Solaris 11.
6534 *-*-solaris2.1[[1-9]]*)
6536 i?86-*-* | x86_64-*-*)
6537 if echo "$ld_ver" | grep GNU > /dev/null; then
6538 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
6539 gcc_cv_ld_as_needed=no
6545 gcc_cv_ld_as_needed=no
6549 if test x"$gcc_cv_ld_as_needed" = xyes; then
6550 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
6551 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
6552 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
6553 [Define to the linker option to ignore unused dependencies.])
6554 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
6555 [Define to the linker option to keep unused dependencies.])
6558 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
6559 saved_LDFLAGS="$LDFLAGS"
6560 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
6561 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
6562 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
6563 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
6565 LDFLAGS="$saved_LDFLAGS"
6566 if test "x$gcc_cv_ld_clearcap" = xyes; then
6567 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
6568 [Define if the linker supports clearing hardware capabilities via mapfile.])
6569 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
6571 AC_MSG_RESULT($gcc_cv_ld_clearcap)
6577 emul_name="-melf32lppc"
6580 emul_name="-melf32ppc"
6583 AC_CACHE_CHECK(linker .gnu.attributes long double support,
6585 [gcc_cv_ld_ppc_attr=no
6586 if test x"$ld_is_gold" = xyes; then
6587 gcc_cv_ld_ppc_attr=yes
6588 elif test $in_tree_ld = yes ; then
6589 if test "$gcc_cv_gld_major_version" -eq 2 \
6590 -a "$gcc_cv_gld_minor_version" -ge 28 \
6591 -o "$gcc_cv_gld_major_version" -gt 2; then
6592 gcc_cv_ld_ppc_attr=yes
6594 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6595 # check that merging the long double .gnu_attribute doesn't warn
6596 cat > conftest1.s <<EOF
6599 cat > conftest2.s <<EOF
6602 if $gcc_cv_as -a32 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6603 && $gcc_cv_as -a32 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6604 && $gcc_cv_ld $emul_name -r -o conftest.o conftest1.o conftest2.o > /dev/null 2> conftest.err \
6605 && test ! -s conftest.err; then
6606 gcc_cv_ld_ppc_attr=yes
6608 rm -f conftest.err conftest.o conftest1.o conftest2.o conftest1.s conftest2.s
6611 if test x$gcc_cv_ld_ppc_attr = xyes; then
6612 AC_DEFINE(HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE, 1,
6613 [Define if your PowerPC linker has .gnu.attributes long double support.])
6618 case "$target:$tm_file" in
6619 powerpc64*-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
6622 emul_name="-melf64lppc"
6625 emul_name="-melf64ppc"
6628 emul_name="-melf64lppc_fbsd"
6631 emul_name="-melf64ppc_fbsd"
6634 AC_CACHE_CHECK(linker support for omitting dot symbols,
6635 gcc_cv_ld_no_dot_syms,
6636 [gcc_cv_ld_no_dot_syms=no
6637 if test x"$ld_is_gold" = xyes; then
6638 gcc_cv_ld_no_dot_syms=yes
6639 elif test $in_tree_ld = yes ; then
6640 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
6641 gcc_cv_ld_no_dot_syms=yes
6643 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6644 cat > conftest1.s <<EOF
6648 cat > conftest2.s <<EOF
6649 .section ".opd","aw"
6654 .quad .LEfoo,.TOC.@tocbase,0
6660 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6661 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6662 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
6663 gcc_cv_ld_no_dot_syms=yes
6665 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
6668 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
6669 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
6670 [Define if your PowerPC64 linker only needs function descriptor syms.])
6673 AC_CACHE_CHECK(linker large toc support,
6674 gcc_cv_ld_large_toc,
6675 [gcc_cv_ld_large_toc=no
6676 if test x"$ld_is_gold" = xyes; then
6677 gcc_cv_ld_large_toc=yes
6678 elif test $in_tree_ld = yes ; then
6679 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
6680 gcc_cv_ld_large_toc=yes
6682 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6683 cat > conftest.s <<EOF
6684 .section ".tbss","awT",@nobits
6690 addis 9,13,ie0@got@tprel@ha
6691 ld 9,ie0@got@tprel@l(9)
6693 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6694 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
6695 gcc_cv_ld_large_toc=yes
6697 rm -f conftest conftest.o conftest.s
6700 if test x"$gcc_cv_ld_large_toc" = xyes; then
6701 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6702 [Define if your PowerPC64 linker supports a large TOC.])
6705 AC_CACHE_CHECK(linker toc pointer alignment,
6706 gcc_cv_ld_toc_align,
6707 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
6708 cat > conftest.s <<EOF
6713 .section .data.rel.ro,"aw",@progbits
6718 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6719 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
6720 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)) }'`
6722 rm -f conftest conftest.o conftest.s
6725 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
6726 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
6727 [Define to .TOC. alignment forced by your linker.])
6734 AC_CACHE_CHECK(linker large toc support,
6735 gcc_cv_ld_large_toc,
6736 [gcc_cv_ld_large_toc=no
6737 if test x$gcc_cv_as != x ; then
6738 cat > conftest.s <<EOF
6748 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
6749 gcc_cv_ld_large_toc=yes
6751 rm -f conftest conftest.o conftest.s
6754 if test x"$gcc_cv_ld_large_toc" = xyes; then
6755 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6756 [Define if your PowerPC64 linker supports a large TOC.])
6761 AC_CACHE_CHECK(linker --build-id support,
6763 [gcc_cv_ld_buildid=no
6764 if test $in_tree_ld = yes ; then
6765 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6766 "$gcc_cv_gld_minor_version" -ge 18 -o \
6767 "$gcc_cv_gld_major_version" -gt 2 \
6768 && test $in_tree_ld_is_elf = yes; then
6769 gcc_cv_ld_buildid=yes
6771 elif test x$gcc_cv_ld != x; then
6772 if $gcc_cv_ld --help 2>&1 | grep build-id > /dev/null; then
6773 gcc_cv_ld_buildid=yes
6776 if test x"$gcc_cv_ld_buildid" = xyes; then
6777 AC_DEFINE(HAVE_LD_BUILDID, 1,
6778 [Define if your linker supports --build-id.])
6781 AC_ARG_ENABLE(linker-build-id,
6782 [AS_HELP_STRING([--enable-linker-build-id],
6783 [compiler will always pass --build-id to linker])],
6785 enable_linker_build_id=no)
6787 if test x"$enable_linker_build_id" = xyes; then
6788 if test x"$gcc_cv_ld_buildid" = xyes; then
6789 AC_DEFINE(ENABLE_LD_BUILDID, 1,
6790 [Define if gcc should always pass --build-id to linker.])
6792 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
6796 # In binutils 2.21, GNU ld gained support for new emulations fully
6797 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
6798 AC_CACHE_CHECK(linker *_sol2 emulation support,
6799 gcc_cv_ld_sol2_emulation,
6800 [gcc_cv_ld_sol2_emulation=no
6801 if test $in_tree_ld = yes ; then
6802 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6803 "$gcc_cv_gld_minor_version" -ge 21 -o \
6804 "$gcc_cv_gld_major_version" -gt 2 \
6805 && test $in_tree_ld_is_elf = yes; then
6806 gcc_cv_ld_sol2_emulation=yes
6808 elif test x$gcc_cv_ld != x; then
6809 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
6810 grep _sol2 > /dev/null; then
6811 gcc_cv_ld_sol2_emulation=yes
6814 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
6815 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
6816 [Define if your linker supports the *_sol2 emulations.])
6819 AC_CACHE_CHECK(linker --sysroot support,
6821 [gcc_cv_ld_sysroot=no
6822 if test $in_tree_ld = yes ; then
6823 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
6824 gcc_cv_ld_sysroot=yes
6826 elif test x$gcc_cv_ld != x; then
6827 if $gcc_cv_ld --help 2>&1 | grep sysroot > /dev/null; then
6828 gcc_cv_ld_sysroot=yes
6831 if test x"$gcc_cv_ld_sysroot" = xyes; then
6832 AC_DEFINE(HAVE_LD_SYSROOT, 1,
6833 [Define if your linker supports --sysroot.])
6838 # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
6839 AC_CACHE_CHECK([system-provided CRTs on Solaris],
6840 gcc_cv_solaris_crts,
6841 [gcc_cv_solaris_crts=no
6842 if test x$host != x$target; then
6843 if test "x$with_sysroot" = xyes; then
6844 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
6846 target_sysroot="${with_sysroot}"
6849 target_libdir="$target_sysroot/usr/lib"
6850 # At the time they were added, gcrt1.o became a symlink for backwards
6851 # compatibility on x86, while crt1.o was added on sparc, so check for that.
6853 i?86-*-solaris2* | x86_64-*-solaris2*)
6854 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
6857 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
6862 if test x$gcc_cv_solaris_crts = xyes; then
6863 AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
6864 [Define if the system-provided CRTs are present on Solaris.])
6867 AC_ARG_ENABLE(libssp,
6868 [AS_HELP_STRING([--enable-libssp], [enable linking against libssp])],
6869 [case "${enableval}" in
6873 AC_MSG_ERROR([unknown libssp setting $enableval])
6877 # Test for stack protector support in target C library.
6878 AC_CACHE_CHECK(__stack_chk_fail in target C library,
6879 gcc_cv_libc_provides_ssp,
6880 [gcc_cv_libc_provides_ssp=no
6881 if test "x$enable_libssp" = "xno"; then
6882 gcc_cv_libc_provides_ssp=yes
6883 elif test "x$enable_libssp" = "xyes"; then
6884 gcc_cv_libc_provides_ssp=no
6888 # All versions of musl provide stack protector
6889 gcc_cv_libc_provides_ssp=yes;;
6890 *-*-linux* | *-*-kfreebsd*-gnu)
6891 # glibc 2.4 and later provides __stack_chk_fail and
6892 # either __stack_chk_guard, or TLS access to stack guard canary.
6893 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
6894 [if test -f $target_header_dir/features.h \
6895 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
6896 $target_header_dir/features.h > /dev/null; then
6897 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
6898 $target_header_dir/features.h > /dev/null && \
6899 test -f $target_header_dir/bits/uClibc_config.h && \
6900 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
6901 $target_header_dir/bits/uClibc_config.h > /dev/null; then
6902 gcc_cv_libc_provides_ssp=yes
6904 # all versions of Bionic support stack protector
6905 elif test -f $target_header_dir/sys/cdefs.h \
6906 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
6907 $target_header_dir/sys/cdefs.h > /dev/null; then
6908 gcc_cv_libc_provides_ssp=yes
6912 # Avoid complicated tests (see
6913 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
6914 # simply assert that glibc does provide this, which is true for all
6915 # realistically usable GNU/Hurd configurations.
6916 # All supported versions of musl provide it as well
6917 gcc_cv_libc_provides_ssp=yes;;
6918 *-*-darwin* | *-*-freebsd* | *-*-netbsd*)
6919 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
6920 [echo "no __stack_chk_fail on this target"])
6922 *) gcc_cv_libc_provides_ssp=no ;;
6926 if test x$gcc_cv_libc_provides_ssp = xyes; then
6927 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
6928 [Define if your target C library provides stack protector support])
6931 # Check whether --enable-default-ssp was given.
6932 AC_ARG_ENABLE(default-ssp,
6933 [AS_HELP_STRING([--enable-default-ssp],
6934 [enable Stack Smashing Protection as default])],[
6935 if test x$gcc_cv_libc_provides_ssp = xyes; then
6937 ia64*-*-*) enable_default_ssp=no ;;
6938 *) enable_default_ssp=$enableval ;;
6941 enable_default_ssp=no
6943 enable_default_ssp=no)
6944 if test x$enable_default_ssp = xyes ; then
6945 AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
6946 [Define if your target supports default stack protector and it is enabled.])
6948 AC_SUBST([enable_default_ssp])
6950 # Test for <sys/sdt.h> on the target.
6951 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
6952 AC_CACHE_CHECK([sys/sdt.h in the target C library], [gcc_cv_sys_sdt_h], [
6954 if test -f $target_header_dir/sys/sdt.h; then
6955 gcc_cv_sys_sdt_h=yes
6958 AS_IF([test x$gcc_cv_sys_sdt_h = xyes], [
6959 AC_DEFINE([HAVE_SYS_SDT_H], [1],
6960 [Define if your target C library provides sys/sdt.h])
6963 # Check if TFmode long double should be used by default or not.
6964 # Some glibc targets used DFmode long double, but with glibc 2.4
6965 # and later they can use TFmode.
6967 powerpc*-*-linux* | \
6971 AC_ARG_WITH(long-double-128,
6972 [AS_HELP_STRING([--with-long-double-128],
6973 [use 128-bit long double by default])],
6974 gcc_cv_target_ldbl128="$with_long_double_128", [
6976 s390*-*-linux-musl*)
6977 gcc_cv_target_ldbl128=yes
6979 powerpc*-*-linux-musl*)
6980 gcc_cv_target_ldbl128=no
6983 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
6984 [gcc_cv_target_ldbl128=no
6985 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
6986 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
6987 && gcc_cv_target_ldbl128=yes
6995 if test x$gcc_cv_target_ldbl128 = xyes; then
6996 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
6997 [Define if TFmode long double should be the default])
7000 # Check if TFmode long double target should use the IBM extended double or IEEE
7001 # 128-bit floating point formats if long doubles are 128-bits long. The long
7002 # double type can only be switched on powerpc64 bit Linux systems where VSX is
7003 # supported. Other PowerPC systems do not build the IEEE 128-bit emulator in
7005 AC_ARG_WITH([long-double-format],
7006 [AS_HELP_STRING([--with-long-double-format={ieee,ibm}]
7007 [Specify whether PowerPC long double uses IEEE or IBM format])],[
7008 case "$target:$with_long_double_format" in
7009 powerpc64le-*-linux*:ieee | powerpc64le-*-linux*:ibm)
7012 powerpc64-*-linux*:ieee | powerpc64-*-linux*:ibm)
7013 # IEEE 128-bit emulation is only built on 64-bit VSX Linux systems
7015 power7 | power8 | power9 | power1*)
7019 AC_MSG_ERROR([Configuration option --with-long-double-format is only \
7020 supported if the default cpu is power7 or newer])
7021 with_long_double_format=""
7025 powerpc64*-*-linux*:*)
7026 AC_MSG_ERROR([--with-long-double-format argument should be ibm or ieee])
7027 with_long_double_format=""
7030 AC_MSG_ERROR([Configure option --with-long-double-format is only supported \
7031 on 64-bit PowerPC VSX Linux systems])
7032 with_long_double_format=""
7037 # Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP
7038 # values in the TCB. Currently, only GLIBC 2.23 and later support this.
7039 gcc_cv_libc_provides_hwcap_in_tcb=no
7042 GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], )
7045 if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then
7046 AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1,
7047 [Define if your target C Library provides the AT_HWCAP value in the TCB])
7050 # Check if the target LIBC handles PT_GNU_STACK.
7051 gcc_cv_libc_gnustack=unknown
7053 mips*-*-linux-musl*)
7054 gcc_cv_libc_gnustack=yes
7057 GCC_GLIBC_VERSION_GTE_IFELSE([2], [31], [gcc_cv_libc_gnustack=yes], )
7060 if test x$gcc_cv_libc_gnustack = xyes; then
7061 AC_DEFINE(TARGET_LIBC_GNUSTACK, 1,
7062 [Define if your target C Library properly handles PT_GNU_STACK])
7065 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
7066 gcc_cv_target_dl_iterate_phdr=unknown
7069 # <link.h> needs both a dl_iterate_phdr declaration and support for
7070 # compilation with largefile support.
7071 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
7072 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
7073 gcc_cv_target_dl_iterate_phdr=yes
7075 gcc_cv_target_dl_iterate_phdr=no
7078 *-*-dragonfly* | *-*-freebsd*)
7079 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
7080 gcc_cv_target_dl_iterate_phdr=yes
7082 gcc_cv_target_dl_iterate_phdr=no
7086 gcc_cv_target_dl_iterate_phdr=yes
7089 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
7090 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
7091 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
7092 [Define if your target C library provides the `dl_iterate_phdr' function.])
7094 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
7096 # We no longer support different GC mechanisms. Emit an error if
7097 # the user configures with --with-gc.
7099 [AS_HELP_STRING([--with-gc={page,zone}],
7100 [this option is not supported anymore. It used to choose
7101 the garbage collection mechanism to use with the compiler])],
7102 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
7105 # Libraries to use on the host. This will normally be set by the top
7106 # level Makefile. Here we simply capture the value for our Makefile.
7107 if test -z "${HOST_LIBS+set}"; then
7112 # Use the system's zlib library.
7115 dnl Very limited version of automake's enable-maintainer-mode
7117 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
7118 dnl maintainer-mode is disabled by default
7119 AC_ARG_ENABLE(maintainer-mode,
7120 [AS_HELP_STRING([--enable-maintainer-mode],
7121 [enable make rules and dependencies not useful
7122 (and sometimes confusing) to the casual installer])],
7123 maintainer_mode=$enableval,
7126 AC_MSG_RESULT($maintainer_mode)
7128 if test "$maintainer_mode" = "yes"; then
7135 dnl Variables for tags utilities; copied from automake 1.16.4+'s init.m4
7136 if test -z "$CTAGS"; then
7140 if test -z "$ETAGS"; then
7144 if test -z "$CSCOPE"; then
7149 dnl Whether to prevent multiple front-ends from linking at the same time
7151 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
7152 AC_ARG_ENABLE(link-mutex,
7153 [AS_HELP_STRING([--enable-link-mutex],
7154 [avoid linking multiple front-ends at once to avoid thrashing
7155 on the build machine])],
7156 do_link_mutex=$enableval,
7158 AC_MSG_RESULT($do_link_mutex)
7160 if test "$do_link_mutex" = "yes"; then
7162 AC_MSG_WARN([--enable-link-mutex is deprecated and will be removed in the next release, use --enable-link-serialization instead])
7166 AC_SUBST(DO_LINK_MUTEX)
7168 dnl Whether to prevent multiple GCC front-ends from linking at the same time
7170 AC_MSG_CHECKING([whether to serialize linking of multiple front-ends])
7171 AC_ARG_ENABLE(link-serialization,
7172 [AS_HELP_STRING([--enable-link-serialization],
7173 [avoid linking multiple GCC front-ends at once using make
7174 dependencies to avoid thrashing on the build machine])],
7175 do_link_serialization=$enableval,
7176 do_link_serialization=no)
7177 AC_MSG_RESULT($do_link_serialization)
7179 case "$do_link_serialization" in
7181 DO_LINK_SERIALIZATION=1;;
7182 [[1-9]] | [[1-9]][[0-9]] | [[1-9]][[0-9]][[0-9]])
7183 DO_LINK_SERIALIZATION=$do_link_serialization;;
7185 DO_LINK_SERIALIZATION=;;
7187 AC_MSG_ERROR(bad value ${do_link_serialization} given for --enable-link-serialization) ;;
7189 AC_SUBST(DO_LINK_SERIALIZATION)
7195 # Make empty files to contain the specs and options for each language.
7196 # Then add #include lines to for a compiler that has specs and/or options.
7202 # These (without "all_") are set in each config-lang.in.
7203 # `language' must be a single word so is spelled singularly.
7206 all_outputs='Makefile'
7207 # List of language configure and makefile fragments.
7208 all_lang_configurefrags=
7210 # Additional files for gengtype
7211 all_gtfiles="$target_gtfiles"
7213 # These are the languages that are set in --enable-languages,
7214 # and are available in the GCC tree.
7215 all_selected_languages=
7217 # Add the language fragments.
7218 # Languages are added via two mechanisms. Some information must be
7219 # recorded in makefile variables, these are defined in config-lang.in.
7220 # We accumulate them and plug them into the main Makefile.
7221 # The other mechanism is a set of hooks for each of the main targets
7222 # like `clean', `install', etc.
7224 language_hooks="Make-hooks"
7226 for lang in ${srcdir}/*/config-lang.in
7229 test "$lang" = "${srcdir}/*/config-lang.in" && continue
7231 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
7232 if test "x$lang_alias" = x
7234 echo "$lang doesn't set \$language." 1>&2
7237 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
7238 subdirs="$subdirs $subdir"
7240 # $gcc_subdir is where the gcc integration files are to be found
7241 # for a language, both for internal compiler purposes (compiler
7242 # sources implementing front-end to GCC tree converters), and for
7243 # build infrastructure purposes (Make-lang.in, etc.)
7245 # This will be <subdir> (relative to $srcdir) if a line like
7246 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
7247 # is found in <langdir>/config-lang.in, and will remain <langdir>
7250 # Except for the language alias (fetched above), the regular
7251 # "config-lang.in" contents are always retrieved from $gcc_subdir,
7252 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
7253 # only this and the language alias.
7255 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
7256 if [ "$gcc_subdir" = "" ]; then
7257 gcc_subdir="$subdir"
7260 case ",$enable_languages," in
7262 all_selected_languages="$all_selected_languages $lang_alias"
7263 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
7264 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
7276 . ${srcdir}/$gcc_subdir/config-lang.in
7277 if test "x$language" = x
7279 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
7284 case ",$enable_languages," in
7287 for i in $subdir_requires; do
7288 test -f "${srcdir}/$i/config-lang.in" && continue
7296 all_lang_configurefrags="$all_lang_configurefrags \$(srcdir)/$gcc_subdir/config-lang.in"
7297 if test "x$language" = xc && test -n "$all_lang_makefrags"; then
7298 # Put c/Make-lang.in fragment first to match serialization languages order.
7299 all_lang_makefrags="\$(srcdir)/$gcc_subdir/Make-lang.in $all_lang_makefrags"
7301 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
7303 if test -f $srcdir/$gcc_subdir/lang.opt; then
7304 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
7305 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
7307 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
7308 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
7310 all_languages="$all_languages $language"
7311 all_compilers="$all_compilers $compilers"
7312 all_outputs="$all_outputs $outputs"
7313 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
7314 case ",$enable_languages," in
7316 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
7318 AC_SUBST(enable_lto)
7325 for language in $all_selected_languages
7327 check_languages="$check_languages check-$language"
7331 for language in $all_selected_languages
7333 selftest_languages="$selftest_languages selftest-$language"
7336 # We link each language in with a set of hooks, reached indirectly via
7337 # lang.${target}. Only do so for selected languages.
7341 target_list="all.cross start.encap rest.encap tags \
7342 install-common install-man install-info install-dvi install-pdf \
7343 install-html dvi pdf html uninstall info man srcextra srcman srcinfo \
7344 mostlyclean clean distclean maintainer-clean install-plugin"
7346 for t in $target_list
7349 for lang in $all_selected_languages
7353 echo "lang.$t: $x" >> Make-hooks
7356 echo "ifeq (\$(DO_LINK_SERIALIZATION),)" >> Make-hooks
7357 echo "SERIAL_LIST =" >> Make-hooks
7358 echo else >> Make-hooks
7362 serialization_languages=c
7363 for lang in $all_selected_languages
7365 test $lang = c && continue
7366 if test $lang = lto; then
7367 serialization_languages="$serialization_languages lto1 lto2"
7369 serialization_languages="$serialization_languages $lang"
7372 for lang in $serialization_languages
7374 test $lang = c && continue
7375 lang_cnt=`expr $lang_cnt + 1`
7376 lang_list=" $prev$lang_list"
7379 echo "SERIAL_LIST = \$(wordlist \$(DO_LINK_SERIALIZATION),$lang_cnt,$lang_list)" >> Make-hooks
7380 echo endif >> Make-hooks
7381 echo "SERIAL_COUNT = `expr $lang_cnt + 1`" >> Make-hooks
7382 echo "INDEX.c = 0" >> Make-hooks
7384 for lang in $serialization_languages
7386 test $lang = c && continue
7387 echo "$lang.prev = \$(if \$(word $lang_cnt,\$(SERIAL_LIST)),\$(\$(word $lang_cnt,\$(SERIAL_LIST)).serial))" >> Make-hooks
7388 echo "INDEX.$lang = $lang_idx" >> Make-hooks
7389 lang_cnt=`expr $lang_cnt - 1`
7390 lang_idx=`expr $lang_idx + 1`
7394 # Option include files
7397 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
7398 option_includes="option-includes.mk"
7399 AC_SUBST_FILE(option_includes)
7407 echo "dir ." > .gdbinit
7408 echo "dir ${srcdir}" >> .gdbinit
7409 if test x$gdb_needs_out_file_path = xyes
7411 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
7413 if test "x$subdirs" != x; then
7416 echo "dir ${srcdir}/$s" >> .gdbinit
7419 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
7420 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
7422 # Put a breakpoint on __asan_report_error to help with debugging buffer
7425 *-fsanitize=address*)
7426 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
7430 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
7431 AC_SUBST(gcc_tooldir)
7434 # Find a directory in which to install a shared libgcc.
7436 AC_ARG_ENABLE(version-specific-runtime-libs,
7437 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
7438 [specify that runtime libraries should be
7439 installed in a compiler-specific directory])])
7441 # Substitute configuration variables
7444 AC_SUBST(all_compilers)
7445 AC_SUBST(all_gtfiles)
7446 AC_SUBST(all_lang_configurefrags)
7447 AC_SUBST(all_lang_makefrags)
7448 AC_SUBST(all_languages)
7449 AC_SUBST(all_selected_languages)
7450 AC_SUBST(build_exeext)
7451 AC_SUBST(build_install_headers_dir)
7452 AC_SUBST(build_xm_file_list)
7453 AC_SUBST(build_xm_include_list)
7454 AC_SUBST(build_xm_defines)
7455 AC_SUBST(build_file_translate)
7456 AC_SUBST(check_languages)
7457 AC_SUBST(selftest_languages)
7458 AC_SUBST(cpp_install_dir)
7459 AC_SUBST(xmake_file)
7460 AC_SUBST(tmake_file)
7461 AC_SUBST(TM_ENDIAN_CONFIG)
7462 AC_SUBST(TM_MULTILIB_CONFIG)
7463 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
7464 AC_SUBST(extra_gcc_objs)
7465 AC_SUBST(user_headers_inc_next_pre)
7466 AC_SUBST(user_headers_inc_next_post)
7467 AC_SUBST(extra_headers_list)
7468 AC_SUBST(extra_objs)
7469 AC_SUBST(extra_programs)
7470 AC_SUBST(float_h_file)
7471 AC_SUBST(gcc_config_arguments)
7472 AC_SUBST(gcc_gxx_include_dir)
7473 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
7474 AC_SUBST(gcc_gxx_libcxx_include_dir)
7475 AC_SUBST(gcc_gxx_libcxx_include_dir_add_sysroot)
7476 AC_SUBST(host_exeext)
7477 AC_SUBST(host_xm_file_list)
7478 AC_SUBST(host_xm_include_list)
7479 AC_SUBST(host_xm_defines)
7480 AC_SUBST(out_host_hook_obj)
7482 AC_SUBST(lang_opt_files)
7483 AC_SUBST(lang_specs_files)
7484 AC_SUBST(lang_tree_files)
7485 AC_SUBST(local_prefix)
7487 AC_SUBST(objc_boehm_gc)
7489 AC_SUBST(out_object_file)
7490 AC_SUBST(common_out_file)
7491 AC_SUBST(common_out_object_file)
7492 AC_SUBST(tm_file_list)
7493 AC_SUBST(tm_include_list)
7494 AC_SUBST(tm_defines)
7495 AC_SUBST(tm_p_file_list)
7496 AC_SUBST(tm_p_include_list)
7497 AC_SUBST(tm_d_file_list)
7498 AC_SUBST(tm_d_include_list)
7499 AC_SUBST(tm_rust_file_list)
7500 AC_SUBST(tm_rust_include_list)
7501 AC_SUBST(xm_file_list)
7502 AC_SUBST(xm_include_list)
7503 AC_SUBST(xm_defines)
7504 AC_SUBST(use_gcc_stdint)
7505 AC_SUBST(c_target_objs)
7506 AC_SUBST(cxx_target_objs)
7507 AC_SUBST(fortran_target_objs)
7508 AC_SUBST(d_target_objs)
7509 AC_SUBST(rust_target_objs)
7510 AC_SUBST(target_cpu_default)
7512 AC_SUBST_FILE(language_hooks)
7515 if test x${build} = x${host} ; then
7516 if test x${host} = x${target} ; then
7517 echo "Links are now set up to build a native compiler for ${target}." 1>&2
7519 echo "Links are now set up to build a cross-compiler" 1>&2
7520 echo " from ${host} to ${target}." 1>&2
7523 if test x${host} = x${target} ; then
7524 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
7525 echo " for ${target}." 1>&2
7527 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
7528 echo " from ${host} to ${target}." 1>&2
7532 AC_ARG_VAR(GMPLIBS,[How to link GMP])
7533 AC_ARG_VAR(GMPINC,[How to find GMP include files])
7535 AC_ARG_VAR(ISLLIBS,[How to link isl])
7536 AC_ARG_VAR(ISLINC,[How to find isl include files])
7537 if test "x${ISLLIBS}" != "x" ; then
7538 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
7542 AC_SUBST(pluginlibs)
7543 AC_SUBST(enable_plugin)
7544 if test x"$enable_plugin" = x"yes"; then
7545 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
7549 # Enable --enable-host-shared
7550 AC_ARG_ENABLE(host-shared,
7551 [AS_HELP_STRING([--enable-host-shared],
7552 [build host code as shared libraries])])
7553 AC_SUBST(enable_host_shared)
7555 # Enable --enable-host-pie
7556 AC_ARG_ENABLE(host-pie,
7557 [AS_HELP_STRING([--enable-host-pie],
7558 [build host code as PIE])])
7559 AC_SUBST(enable_host_pie)
7561 # Enable --enable-host-bind-now
7562 AC_ARG_ENABLE(host-bind-now,
7563 [AS_HELP_STRING([--enable-host-bind-now],
7564 [link host code as BIND_NOW])])
7565 AC_SUBST(enable_host_bind_now)
7567 AC_ARG_ENABLE(libquadmath-support,
7568 [AS_HELP_STRING([--disable-libquadmath-support],
7569 [disable libquadmath support for Fortran])],
7570 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
7571 ENABLE_LIBQUADMATH_SUPPORT=yes)
7572 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
7573 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
7574 [Define to 1 to enable libquadmath support])
7578 # Specify what hash style to use by default.
7579 AC_ARG_WITH([linker-hash-style],
7580 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
7581 [specify the linker hash style])],
7582 [case x"$withval" in
7584 LINKER_HASH_STYLE=sysv
7587 LINKER_HASH_STYLE=gnu
7590 LINKER_HASH_STYLE=both
7593 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
7596 [LINKER_HASH_STYLE=''])
7597 if test x"${LINKER_HASH_STYLE}" != x; then
7598 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
7599 [The linker hash style])
7602 # Specify what should be the default of -fdiagnostics-color option.
7603 AC_ARG_WITH([diagnostics-color],
7604 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
7605 [specify the default of -fdiagnostics-color option
7606 auto-if-env stands for -fdiagnostics-color=auto if
7607 GCC_COLOR environment variable is present and
7608 -fdiagnostics-color=never otherwise])],
7609 [case x"$withval" in
7611 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
7614 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
7617 DIAGNOSTICS_COLOR_DEFAULT=-1
7620 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
7623 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
7626 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
7627 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
7628 [The default for -fdiagnostics-color option])
7630 # Specify what should be the default of -fdiagnostics-urls option.
7631 AC_ARG_WITH([diagnostics-urls],
7632 [AC_HELP_STRING([--with-diagnostics-urls={never,auto,auto-if-env,always}],
7633 [specify the default of -fdiagnostics-urls option
7634 auto-if-env stands for -fdiagnostics-urls=auto if
7635 GCC_URLS or TERM_URLS environment variable is present and
7636 -fdiagnostics-urls=never otherwise])],
7637 [case x"$withval" in
7639 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_NO
7642 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO
7645 DIAGNOSTICS_URLS_DEFAULT=-1
7648 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_YES
7651 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-urls])
7654 [DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO])
7655 AC_DEFINE_UNQUOTED(DIAGNOSTICS_URLS_DEFAULT, $DIAGNOSTICS_URLS_DEFAULT,
7656 [The default for -fdiagnostics-urls option])
7658 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
7659 # of jit/jit-playback.cc.
7660 gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"`
7661 echo "gcc_driver_version: ${gcc_driver_version}"
7662 cat > gcc-driver-name.h <<EOF
7663 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_driver_version}${exeext}"
7666 # Check whether --enable-default-pie was given.
7667 AC_ARG_ENABLE(default-pie,
7668 [AS_HELP_STRING([--enable-default-pie],
7669 [enable Position Independent Executable as default])],
7670 enable_default_pie=$enableval,
7671 enable_default_pie=no)
7672 if test x$enable_default_pie = xyes ; then
7673 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
7674 [Define if your target supports default PIE and it is enabled.])
7676 AC_SUBST([enable_default_pie])
7678 # Check if -fno-PIE works.
7679 AC_CACHE_CHECK([for -fno-PIE option],
7681 [saved_CXXFLAGS="$CXXFLAGS"
7682 CXXFLAGS="$CXXFLAGS -fno-PIE"
7683 AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7684 [gcc_cv_c_no_fpie=yes],
7685 [gcc_cv_c_no_fpie=no])
7686 CXXFLAGS="$saved_CXXFLAGS"])
7688 # Check if -no-pie works.
7689 AC_CACHE_CHECK([for -no-pie option],
7691 [saved_LDFLAGS="$LDFLAGS"
7692 LDFLAGS="$LDFLAGS -no-pie"
7693 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7694 [gcc_cv_no_pie=yes],
7696 LDFLAGS="$saved_LDFLAGS"])
7698 if test x$enable_host_shared = xyes; then
7700 elif test x$enable_host_pie = xyes; then
7702 elif test x$gcc_cv_c_no_fpie = xyes; then
7710 if test x$enable_host_pie = xyes; then
7712 elif test x$gcc_cv_no_pie = xyes; then
7718 if test x$enable_host_bind_now = xyes; then
7719 LD_PICFLAG="$LD_PICFLAG -Wl,-z,now"
7722 AC_SUBST([LD_PICFLAG])
7724 # Enable Intel CET on Intel CET enabled host if jit is enabled.
7725 GCC_CET_HOST_FLAGS(CET_HOST_FLAGS)
7726 case x$enable_languages in
7733 AC_SUBST(CET_HOST_FLAGS)
7735 # Check linker supports '-z bndplt'
7736 ld_bndplt_support=no
7737 AC_MSG_CHECKING(linker -z bndplt option)
7738 if test x"$ld_is_gold" = xno; then
7739 if test $in_tree_ld = yes ; then
7740 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
7741 ld_bndplt_support=yes
7743 elif test x$gcc_cv_ld != x; then
7744 # Check if linker supports -a bndplt option
7745 if $gcc_cv_ld --help 2>&1 | grep -- '-z bndplt' > /dev/null; then
7746 ld_bndplt_support=yes
7750 if test x"$ld_bndplt_support" = xyes; then
7751 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
7752 [Define if your linker supports -z bndplt])
7754 AC_MSG_RESULT($ld_bndplt_support)
7756 # Check linker supports '--push-state'/'--pop-state'
7757 ld_pushpopstate_support=no
7758 AC_MSG_CHECKING(linker --push-state/--pop-state options)
7759 if test x"$ld_is_gold" = xno; then
7760 if test $in_tree_ld = yes ; then
7761 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
7762 ld_pushpopstate_support=yes
7764 elif test x$gcc_cv_ld != x; then
7765 # Check if linker supports --push-state/--pop-state options
7766 if $gcc_cv_ld --help 2>&1 | grep -- '--push-state' > /dev/null; then
7767 ld_pushpopstate_support=yes
7771 if test x"$ld_pushpopstate_support" = xyes; then
7772 AC_DEFINE(HAVE_LD_PUSHPOPSTATE_SUPPORT, 1,
7773 [Define if your linker supports --push-state/--pop-state])
7775 AC_MSG_RESULT($ld_pushpopstate_support)
7777 # On s390, float_t has historically been statically defined as double for no
7778 # good reason. To comply with the C standard in the light of this definition,
7779 # gcc has evaluated float expressions in double precision when in
7780 # standards-compatible mode or when given -fexcess-precision=standard. To enable
7781 # a smooth transition towards the new model used by most architectures, where
7782 # gcc describes its behavior via the macro __FLT_EVAL_METHOD__ and glibc derives
7783 # float_t from that, this behavior can be configured with
7784 # --enable-s390-excess-float-precision. When given as enabled, that flag selects
7785 # the old model. When omitted, native builds and cross compiles that have target
7786 # libc headers will detect whether libc clamps float_t to double and in that
7787 # case maintain the old model. Otherwise, they will default to the new model.
7788 AC_ARG_ENABLE(s390-excess-float-precision,
7789 [AS_HELP_STRING([--enable-s390-excess-float-precision],
7790 [on s390 targets, evaluate float with double precision
7791 when in standards-conforming mode])],
7792 [],[enable_s390_excess_float_precision=auto])
7796 if test x"$enable_s390_excess_float_precision" = xauto; then
7797 # Can we autodetect the behavior of the target libc?
7798 if test "$target" = "$host" -a "$host" = "$build"; then
7799 enable_s390_excess_float_precision=autodetect
7800 elif test "x$with_headers" != xno; then
7801 # cross build. are target headers available?
7802 # carefully coerce the build-system compiler to use target headers
7803 saved_CXXFLAGS="$CXXFLAGS"
7804 fixed_XGCC_FLAGS_FOR_TARGET=`echo "$XGCC_FLAGS_FOR_TARGET" | sed 's/-B/-idirafter/g'`
7805 CROSS_TEST_CXXFLAGS="-nostdinc $fixed_XGCC_FLAGS_FOR_TARGET"
7806 CXXFLAGS="$CROSS_TEST_CXXFLAGS"
7807 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
7809 ]])], [enable_s390_excess_float_precision=autodetect], [])
7810 CXXFLAGS="$saved_CXXFLAGS"
7813 if test x"$enable_s390_excess_float_precision" = xautodetect; then
7814 saved_CXXFLAGS="$CXXFLAGS"
7815 if ! test "$target" = "$host" -a "$host" = "$build"; then
7816 CXXFLAGS="$CROSS_TEST_CXXFLAGS"
7817 unset CROSS_TEST_CXXFLAGS
7819 AC_CACHE_CHECK([for glibc clamping float_t to double],
7820 gcc_cv_float_t_clamped_to_double, [
7821 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
7822 #define __FLT_EVAL_METHOD__ 0
7824 int dummy[sizeof(float_t) == sizeof(double) ? 1 : -1];
7826 [gcc_cv_float_t_clamped_to_double=yes],
7827 [gcc_cv_float_t_clamped_to_double=no])])
7828 CXXFLAGS="$saved_CXXFLAGS"
7829 enable_s390_excess_float_precision="$gcc_cv_float_t_clamped_to_double"
7831 # no way to detect behavior of target libc, default to new model
7832 enable_s390_excess_float_precision=no
7836 GCC_TARGET_TEMPLATE(ENABLE_S390_EXCESS_FLOAT_PRECISION)
7837 if test x"$enable_s390_excess_float_precision" = xyes; then
7838 AC_DEFINE(ENABLE_S390_EXCESS_FLOAT_PRECISION, 1,
7839 [Define to enable evaluating float expressions with double precision in
7840 standards-compatible mode on s390 targets.])
7845 # Configure the subdirectories
7846 # AC_CONFIG_SUBDIRS($subdirs)
7848 # Create the Makefile
7849 # and configure language subdirectories
7850 AC_CONFIG_FILES($all_outputs)
7852 AC_CONFIG_COMMANDS([default],
7854 case ${CONFIG_HEADERS} in
7855 *auto-host.h:config.in*)
7858 # Make sure all the subdirs exist.
7859 for d in $subdirs doc build common c-family
7861 test -d $d || mkdir $d
7864 [subdirs='$subdirs'])