2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2020 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.c)
28 AC_CONFIG_HEADER(auto-host.h:config.in)
30 gcc_version=`cat $srcdir/BASE-VER`
32 # Determine the host, build, and target systems
37 # Determine the noncanonical host name, for Ada.
40 # Determine the noncanonical target name, for directory use.
41 ACX_NONCANONICAL_TARGET
43 # Used for constructing correct paths for offload compilers.
44 real_target_noncanonical=${target_noncanonical}
47 # Determine the target- and build-specific subdirectories
50 # Set program_transform_name
53 # Check for bogus environment variables.
54 # Test if LIBRARY_PATH contains the notation for the current directory
55 # since this would lead to problems installing/building glibc.
56 # LIBRARY_PATH contains the current directory if one of the following
58 # - one of the terminals (":" and ";") is the first or last sign
59 # - two terminals occur directly after each other
60 # - the path contains an element with a dot in it
61 AC_MSG_CHECKING(LIBRARY_PATH variable)
63 case ${LIBRARY_PATH} in
64 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
65 library_path_setting="contains current directory"
68 library_path_setting="ok"
72 AC_MSG_RESULT($library_path_setting)
73 if test "$library_path_setting" != "ok"; then
75 *** LIBRARY_PATH shouldn't contain the current directory when
76 *** building gcc. Please change the environment variable
77 *** and run configure again.])
80 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
81 # since this would lead to problems installing/building glibc.
82 # GCC_EXEC_PREFIX contains the current directory if one of the following
84 # - one of the terminals (":" and ";") is the first or last sign
85 # - two terminals occur directly after each other
86 # - the path contains an element with a dot in it
87 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
89 case ${GCC_EXEC_PREFIX} in
90 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
91 gcc_exec_prefix_setting="contains current directory"
94 gcc_exec_prefix_setting="ok"
98 AC_MSG_RESULT($gcc_exec_prefix_setting)
99 if test "$gcc_exec_prefix_setting" != "ok"; then
101 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
102 *** building gcc. Please change the environment variable
103 *** and run configure again.])
110 # Specify the local prefix
112 AC_ARG_WITH(local-prefix,
113 [AS_HELP_STRING([--with-local-prefix=DIR],
114 [specifies directory to put local include])],
115 [case "${withval}" in
116 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
118 *) local_prefix=$with_local_prefix ;;
121 # Default local prefix if it is empty
122 if test x$local_prefix = x; then
123 local_prefix=/usr/local
126 AC_ARG_WITH([native-system-header-dir],
127 [ --with-native-system-header-dir=dir
128 use dir as the directory to look for standard
129 system header files in. Defaults to /usr/include.],
131 case ${with_native_system_header_dir} in
132 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
133 /* | [[A-Za-z]]:[[\\/]]*) ;;
134 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
136 configured_native_system_header_dir="${withval}"
137 ], [configured_native_system_header_dir=])
139 AC_ARG_WITH(build-sysroot,
140 [AS_HELP_STRING([--with-build-sysroot=sysroot],
141 [use sysroot as the system root during the build])],
142 [if test x"$withval" != x ; then
143 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
145 [SYSROOT_CFLAGS_FOR_TARGET=])
146 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
148 if test "x$prefix" = xNONE; then
149 test_prefix=/usr/local
153 if test "x$exec_prefix" = xNONE; then
154 test_exec_prefix=$test_prefix
156 test_exec_prefix=$exec_prefix
160 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
161 [search for usr/lib, usr/include, et al, within DIR])],
163 case ${with_sysroot} in
165 */) with_sysroot=`echo $with_sysroot | sed 's,/$,,'` ;;
167 case ${with_sysroot} in
168 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
169 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
172 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
173 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
175 case ${TARGET_SYSTEM_ROOT} in
176 "${test_prefix}"|"${test_prefix}/"*|\
177 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
178 '${prefix}'|'${prefix}/'*|\
179 '${exec_prefix}'|'${exec_prefix}/'*)
180 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
181 TARGET_SYSTEM_ROOT_DEFINE="$t"
186 TARGET_SYSTEM_ROOT_DEFINE=
187 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
189 AC_SUBST(TARGET_SYSTEM_ROOT)
190 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
191 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
193 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
194 # passed in by the toplevel make and thus we'd get different behavior
195 # depending on where we built the sources.
197 # Specify the g++ header file directory
198 AC_ARG_WITH(gxx-include-dir,
199 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
200 [specifies directory to put g++ header files])],
201 [case "${withval}" in
202 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
204 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
207 # If both --with-sysroot and --with-gxx-include-dir are passed, we interpolate
208 # the former in the latter and, upon success, compute gcc_gxx_include_dir as
209 # relative to the sysroot.
210 gcc_gxx_include_dir_add_sysroot=0
212 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
213 if test x${gcc_gxx_include_dir} = x; then
214 if test x${enable_version_specific_runtime_libs} = xyes; then
215 gcc_gxx_include_dir='${libsubdir}/include/c++'
217 libstdcxx_incdir='include/c++/$(version)'
218 if test x$host != x$target; then
219 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
221 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
223 elif test "${with_sysroot+set}" = set; then
224 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
225 if test "${gcc_gxx_without_sysroot}"; then
226 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
227 gcc_gxx_include_dir_add_sysroot=1
231 AC_ARG_WITH(cpp_install_dir,
232 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
233 [install the user visible C preprocessor in DIR
234 (relative to PREFIX) as well as PREFIX/bin])],
235 [if test x$withval = xyes; then
236 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
237 elif test x$withval != xno; then
238 cpp_install_dir=$withval
241 # We would like to our source tree to be readonly. However when releases or
242 # pre-releases are generated, the flex/bison generated files as well as the
243 # various formats of manuals need to be included along with the rest of the
244 # sources. Therefore we have --enable-generated-files-in-srcdir to do
247 AC_MSG_CHECKING([whether to place generated files in the source directory])
248 dnl generated-files-in-srcdir is disabled by default
249 AC_ARG_ENABLE(generated-files-in-srcdir,
250 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
251 [put copies of generated files in source dir
252 intended for creating source tarballs for users
253 without texinfo bison or flex])],
254 generated_files_in_srcdir=$enableval,
255 generated_files_in_srcdir=no)
257 AC_MSG_RESULT($generated_files_in_srcdir)
259 if test "$generated_files_in_srcdir" = "yes"; then
266 # -------------------
267 # Find default linker
268 # -------------------
272 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
273 gnu_ld_flag="$with_gnu_ld",
277 *darwin*) ld64_flag=yes;; # Darwin can only use a ld64-compatible linker.
281 # With pre-defined ld
283 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
284 DEFAULT_LINKER="$with_ld")
285 if test x"${DEFAULT_LINKER+set}" = x"set"; then
286 if test ! -x "$DEFAULT_LINKER"; then
287 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
288 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
290 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep ld64- > /dev/null; then
293 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
294 [Define to enable the use of a default linker.])
297 AC_MSG_CHECKING([whether a default linker was specified])
298 if test x"${DEFAULT_LINKER+set}" = x"set"; then
299 if test x"$gnu_ld_flag" = x"no"; then
300 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
302 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
308 # With demangler in GNU ld
309 AC_ARG_WITH(demangler-in-ld,
310 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
311 demangler_in_ld="$with_demangler_in_ld",
314 # ----------------------
315 # Find default assembler
316 # ----------------------
320 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
321 gas_flag="$with_gnu_as",
325 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
326 DEFAULT_ASSEMBLER="$with_as")
327 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
328 if test ! -x "$DEFAULT_ASSEMBLER"; then
329 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
330 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
333 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
334 [Define to enable the use of a default assembler.])
337 AC_MSG_CHECKING([whether a default assembler was specified])
338 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
339 if test x"$gas_flag" = x"no"; then
340 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
342 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
352 # If a non-executable a.out is present (e.g. created by GNU as above even if
353 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
354 # file, even when creating an executable, so an execution test fails.
355 # Remove possible default executable files to avoid this.
357 # FIXME: This really belongs into AC_PROG_CC and can be removed once
358 # Autoconf includes it.
359 rm -f a.out a.exe b.out
361 # Find the native compiler
364 ACX_PROG_GNAT([-I"$srcdir"/ada/libgnat])
366 # Do configure tests with the C++ compiler, since that's what we build with.
369 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
370 # optimizations to be activated explicitly by the toplevel.
373 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
374 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
379 # Determine PICFLAG for target gnatlib.
380 GCC_PICFLAG_FOR_TARGET
381 AC_SUBST(PICFLAG_FOR_TARGET)
383 # -------------------------
384 # Check C compiler features
385 # -------------------------
387 AC_USE_SYSTEM_EXTENSIONS
394 # sizeof(char) is 1 by definition.
395 AC_CHECK_SIZEOF(void *)
396 AC_CHECK_SIZEOF(short)
398 AC_CHECK_SIZEOF(long)
399 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
401 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
402 AC_MSG_ERROR([uint64_t or int64_t not found])
405 # check what underlying integer type int64_t uses
406 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
407 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
411 template <typename T> struct X { };
413 struct X<long> { typedef long t; };
414 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
415 if test "$ac_cv_int64_t_type" = "long"; then
416 AC_DEFINE(INT64_T_IS_LONG, 1,
417 [Define if int64_t uses long as underlying type.])
419 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
423 template <typename T> struct X { };
425 struct X<long long> { typedef long long t; };
426 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
429 AC_CACHE_CHECK(for std::swap in <utility>, ac_cv_std_swap_in_utility, [
430 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
432 ]], [[int a, b; std::swap(a,b);]])],[ac_cv_std_swap_in_utility=yes],[ac_cv_std_swap_in_utility=no])])
433 if test $ac_cv_std_swap_in_utility = yes; then
434 AC_DEFINE(HAVE_SWAP_IN_UTILITY, 1,
435 [Define if <utility> defines std::swap.])
438 # Check whether compiler is affected by placement new aliasing bug (PR 29286).
439 # If the host compiler is affected by the bug, and we build with optimization
440 # enabled (which happens e.g. when cross-compiling), the pool allocator may
441 # get miscompiled. Use -fno-strict-aliasing to work around this problem.
442 # Since there is no reliable feature check for the presence of this bug,
443 # we simply use a GCC version number check. (This should never trigger for
444 # stages 2 or 3 of a native bootstrap.)
446 if test "$GCC" = yes; then
447 saved_CXXFLAGS="$CXXFLAGS"
449 # The following test compilation will succeed if and only if $CXX accepts
450 # -fno-strict-aliasing *and* is older than GCC 4.3.
451 CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
452 AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug])
453 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
454 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
455 #error compiler not affected by placement new aliasing bug
458 [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'],
459 [AC_MSG_RESULT([no])])
461 CXXFLAGS="$saved_CXXFLAGS"
463 AC_SUBST(aliasing_flags)
467 # ---------------------
468 # Warnings and checking
469 # ---------------------
471 # Check $CC warning features (if it's GCC).
472 # We want to use -pedantic, but we don't want warnings about
476 # * C++11 narrowing conversions in { }
477 # So, we only use -pedantic if we can disable those warnings.
479 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
480 AC_ARG_ENABLE(build-format-warnings,
481 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
482 [],[enable_build_format_warnings=yes])
483 AS_IF([test $enable_build_format_warnings = no],
484 [wf_opt=-Wno-format],[wf_opt=])
485 ACX_PROG_CXX_WARNING_OPTS(
486 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings ],
487 [-Wcast-qual -Wno-error=format-diag $wf_opt])),
489 ACX_PROG_CC_WARNING_OPTS(
490 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes ],
491 [-Wno-error=format-diag])), [c_loose_warn])
492 ACX_PROG_CXX_WARNING_OPTS(
493 m4_quote(m4_do([-Wmissing-format-attribute ],
494 [-Woverloaded-virtual])), [strict_warn])
495 ACX_PROG_CC_WARNING_OPTS(
496 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
497 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
498 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
499 [-Wno-overlength-strings])), [strict_warn])
500 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
502 # The above macros do nothing if the compiler is not GCC. However, the
503 # Makefile has more goo to add other flags, so these variables are used
504 # to enable warnings only for GCC.
507 if test "x$GCC" = "xyes"; then
508 warn_cflags='$(GCC_WARN_CFLAGS)'
509 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
511 AC_SUBST(warn_cflags)
512 AC_SUBST(warn_cxxflags)
514 # Disable exceptions and RTTI if building with g++
515 ACX_PROG_CC_WARNING_OPTS(
516 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
519 # Enable expensive internal checks
521 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
525 AC_ARG_ENABLE(checking,
526 [AS_HELP_STRING([[--enable-checking[=LIST]]],
527 [enable expensive run-time checks. With LIST,
528 enable only specific categories of checks.
529 Categories are: yes,no,all,none,release.
530 Flags are: assert,df,extra,fold,gc,gcac,gimple,misc,
531 rtlflag,rtl,runtime,tree,valgrind,types])],
532 [ac_checking_flags="${enableval}"],[
533 # Determine the default checks.
534 if test x$is_release = x ; then
535 ac_checking_flags=yes,extra
537 ac_checking_flags=release
539 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
540 for check in release $ac_checking_flags
543 # these set all the flags to specific states
544 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
545 ac_fold_checking= ; ac_gc_checking=1 ; ac_extra_checking= ;
546 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
547 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
548 ac_tree_checking=1 ; ac_valgrind_checking= ;
549 ac_types_checking=1 ;;
550 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
551 ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
552 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
553 ac_rtlflag_checking= ; ac_runtime_checking= ;
554 ac_tree_checking= ; ac_valgrind_checking= ;
555 ac_types_checking= ;;
556 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
557 ac_fold_checking=1 ; ac_gc_checking=1 ; ac_extra_checking=1 ;
558 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
559 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
560 ac_tree_checking=1 ; ac_valgrind_checking= ;
561 ac_types_checking=1 ;;
562 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
563 ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
564 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
565 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
566 ac_tree_checking= ; ac_valgrind_checking= ;
567 ac_types_checking= ;;
568 # these enable particular checks
569 assert) ac_assert_checking=1 ;;
570 df) ac_df_checking=1 ;;
571 extra) ac_extra_checking=1 ;;
572 fold) ac_fold_checking=1 ;;
573 gc) ac_gc_checking=1 ;;
574 gcac) ac_gc_always_collect=1 ;;
575 gimple) ac_gimple_checking=1 ;;
576 misc) ac_checking=1 ;;
577 rtl) ac_rtl_checking=1 ;;
578 rtlflag) ac_rtlflag_checking=1 ;;
579 runtime) ac_runtime_checking=1 ;;
580 tree) ac_tree_checking=1 ;;
581 types) ac_types_checking=1 ;;
582 valgrind) ac_valgrind_checking=1 ;;
583 *) AC_MSG_ERROR(unknown check category $check) ;;
589 if test x$ac_checking != x ; then
590 AC_DEFINE(CHECKING_P, 1,
591 [Define to 0/1 if you want more run-time sanity checks. This one gets a grab
592 bag of miscellaneous but relatively cheap checks.])
593 nocommon_flag=-fno-common
595 AC_DEFINE(CHECKING_P, 0)
597 AC_SUBST(nocommon_flag)
598 if test x$ac_extra_checking != x ; then
599 AC_DEFINE(ENABLE_EXTRA_CHECKING, 1,
600 [Define to 0/1 if you want extra run-time checking that might affect code
603 AC_DEFINE(ENABLE_EXTRA_CHECKING, 0)
605 if test x$ac_df_checking != x ; then
606 AC_DEFINE(ENABLE_DF_CHECKING, 1,
607 [Define if you want more run-time sanity checks for dataflow.])
609 if test x$ac_assert_checking != x ; then
610 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
611 [Define if you want assertions enabled. This is a cheap check.])
613 if test x$ac_gimple_checking != x ; then
614 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
615 [Define if you want operations on GIMPLE (the basic data structure of
616 the high-level optimizers) to be checked for dynamic type safety at
617 runtime. This is moderately expensive.])
619 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
620 if test x$ac_runtime_checking != x ; then
621 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
622 [Define if you want runtime assertions enabled. This is a cheap check.])
624 if test x$ac_tree_checking != x ; then
625 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
626 [Define if you want all operations on trees (the basic data
627 structure of the front ends) to be checked for dynamic type safety
628 at runtime. This is moderately expensive.
632 if test x$ac_types_checking != x ; then
633 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
634 [Define if you want all gimple types to be verified after gimplifiation.
638 AC_SUBST(TREECHECKING)
639 if test x$ac_rtl_checking != x ; then
640 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
641 [Define if you want all operations on RTL (the basic data structure
642 of the optimizer and back end) to be checked for dynamic type safety
643 at runtime. This is quite expensive.])
645 if test x$ac_rtlflag_checking != x ; then
646 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
647 [Define if you want RTL flag accesses to be checked against the RTL
648 codes that are supported for each access macro. This is relatively
651 if test x$ac_gc_checking != x ; then
652 AC_DEFINE(ENABLE_GC_CHECKING, 1,
653 [Define if you want the garbage collector to do object poisoning and
654 other memory allocation checks. This is quite expensive.])
656 if test x$ac_gc_always_collect != x ; then
657 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
658 [Define if you want the garbage collector to operate in maximally
659 paranoid mode, validating the entire heap and collecting garbage at
660 every opportunity. This is extremely expensive.])
662 if test x$ac_fold_checking != x ; then
663 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
664 [Define if you want fold checked that it never destructs its argument.
665 This is quite expensive.])
667 valgrind_path_defines=
670 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
671 dnl # an if statement. This was the source of very frustrating bugs
672 dnl # in converting to autoconf 2.5x!
673 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
675 # It is certainly possible that there's valgrind but no valgrind.h.
676 # GCC relies on making annotations so we must have both.
677 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
678 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
679 [[#include <valgrind/memcheck.h>
680 #ifndef VALGRIND_DISCARD
681 #error VALGRIND_DISCARD not defined
683 [gcc_cv_header_valgrind_memcheck_h=yes],
684 [gcc_cv_header_valgrind_memcheck_h=no])
685 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
686 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
687 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
688 [[#include <memcheck.h>
689 #ifndef VALGRIND_DISCARD
690 #error VALGRIND_DISCARD not defined
692 [gcc_cv_header_memcheck_h=yes],
693 [gcc_cv_header_memcheck_h=no])
694 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
695 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
696 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
697 [Define if valgrind's valgrind/memcheck.h header is installed.])
699 if test $gcc_cv_header_memcheck_h = yes; then
700 AC_DEFINE(HAVE_MEMCHECK_H, 1,
701 [Define if valgrind's memcheck.h header is installed.])
704 if test x$ac_valgrind_checking != x ; then
705 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
706 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
707 if test "x$valgrind_path" = "x" \
708 || (test $have_valgrind_h = no \
709 && test $gcc_cv_header_memcheck_h = no \
710 && test $gcc_cv_header_valgrind_memcheck_h = no); then
711 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
713 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
714 valgrind_command="$valgrind_path -q"
715 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
716 [Define if you want to run subprograms and generated programs
717 through valgrind (a memory checker). This is extremely expensive.])
719 AC_SUBST(valgrind_path_defines)
720 AC_SUBST(valgrind_command)
722 # Enable code coverage collection
723 AC_ARG_ENABLE(coverage,
724 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
725 [enable compiler's code coverage collection.
726 Use to measure compiler performance and locate
727 unused parts of the compiler. With LEVEL, specify
728 optimization. Values are opt, noopt,
730 [case "${enableval}" in
732 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0 -fkeep-static-functions"
735 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2 -fkeep-static-functions"
738 # a.k.a. --disable-coverage
742 AC_MSG_ERROR(unknown coverage setting $enableval)
746 AC_SUBST(coverage_flags)
748 AC_ARG_ENABLE(gather-detailed-mem-stats,
749 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
750 [enable detailed memory allocation stats gathering])], [],
751 [enable_gather_detailed_mem_stats=no])
752 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
753 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
754 [Define to enable detailed memory allocation stats gathering.])
756 AC_ARG_ENABLE(valgrind-annotations,
757 [AS_HELP_STRING([--enable-valgrind-annotations],
758 [enable valgrind runtime interaction])], [],
759 [enable_valgrind_annotations=no])
760 if test x$enable_valgrind_annotations != xno \
761 || test x$ac_valgrind_checking != x; then
762 if (test $have_valgrind_h = no \
763 && test $gcc_cv_header_memcheck_h = no \
764 && test $gcc_cv_header_valgrind_memcheck_h = no); then
765 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
767 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
768 [Define to get calls to the valgrind runtime enabled.])
771 # -------------------------------
772 # Miscenalleous configure options
773 # -------------------------------
777 [AS_HELP_STRING([--with-stabs],
778 [arrange to use stabs instead of host debug format])],
782 # Determine whether or not multilibs are enabled.
783 AC_ARG_ENABLE(multilib,
784 [AS_HELP_STRING([--enable-multilib],
785 [enable library support for multiple ABIs])],
786 [], [enable_multilib=yes])
787 AC_SUBST(enable_multilib)
789 # Determine whether or not multiarch is enabled.
790 AC_ARG_ENABLE(multiarch,
791 [AS_HELP_STRING([--enable-multiarch],
792 [enable support for multiarch paths])],
793 [case "${enableval}" in
794 yes|no|auto) enable_multiarch=$enableval;;
795 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
796 esac], [enable_multiarch=auto])
797 if test x${enable_multiarch} = xauto; then
798 if test x${with_native_system_header_dir} != x; then
799 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
802 if test x$host != x$target && test "x$with_sysroot" = x; then
803 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
807 AC_MSG_CHECKING(for multiarch configuration)
808 AC_SUBST(enable_multiarch)
809 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
811 # needed for setting the multiarch name for soft-float/hard-float ABIs
815 # default stack clash protection guard size as power of twos in bytes.
816 # Please keep these in sync with params.def.
820 # Keep the default value when the option is not used to 0, this allows us to
821 # distinguish between the cases where the user specifially set a value via
822 # configure and when the normal default value is used.
823 AC_ARG_WITH(stack-clash-protection-guard-size,
824 [AS_HELP_STRING([--with-stack-clash-protection-guard-size=size],
825 [Set the default stack clash protection guard size for specific targets as a power of two in bytes.])],
826 [DEFAULT_STK_CLASH_GUARD_SIZE="$with_stack_clash_protection_guard_size"], [DEFAULT_STK_CLASH_GUARD_SIZE=0])
827 if test $DEFAULT_STK_CLASH_GUARD_SIZE -ne 0 \
828 && (test $DEFAULT_STK_CLASH_GUARD_SIZE -lt $stk_clash_min \
829 || test $DEFAULT_STK_CLASH_GUARD_SIZE -gt $stk_clash_max); then
830 AC_MSG_ERROR(m4_normalize([
831 Invalid value $DEFAULT_STK_CLASH_GUARD_SIZE for --with-stack-clash-protection-guard-size. \
832 Must be between $stk_clash_min and $stk_clash_max.]))
835 AC_DEFINE_UNQUOTED(DEFAULT_STK_CLASH_GUARD_SIZE, $DEFAULT_STK_CLASH_GUARD_SIZE,
836 [Define to larger than zero set the default stack clash protector size.])
838 # Enable __cxa_atexit for C++.
839 AC_ARG_ENABLE(__cxa_atexit,
840 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
843 # Enable C extension for decimal float if target supports it.
844 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
846 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
847 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
848 [Define to 1 to enable decimal float extension to C.])
850 # Use default_decimal_float for dependency.
851 enable_decimal_float=$default_decimal_float
853 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
854 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
855 [Define to 1 to specify that we are using the BID decimal floating
856 point format instead of DPD])
858 # Enable C extension for fixed-point arithmetic.
859 AC_ARG_ENABLE(fixed-point,
860 [AS_HELP_STRING([--enable-fixed-point],
861 [enable fixed-point arithmetic extension to C])],
866 enable_fixed_point=yes
870 enable_fixed_point=yes
873 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
874 enable_fixed_point=no
878 AC_SUBST(enable_fixed_point)
880 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
881 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
882 [Define to 1 to enable fixed-point arithmetic extension to C.])
885 # Pass with no value to take the default
886 # Pass with a value to specify a thread package
887 AC_ARG_ENABLE(threads,
888 [AS_HELP_STRING([[--enable-threads[=LIB]]],
889 [enable thread usage for target GCC,
890 using LIB thread package])],,
894 [AS_HELP_STRING([--enable-tls],
895 [enable or disable generation of tls code
896 overriding the assembler check for tls support])],
900 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
901 Valid choices are 'yes' and 'no'.]) ;;
905 AC_ARG_ENABLE(vtable-verify,
906 [AS_HELP_STRING([--enable-vtable-verify],
907 [enable vtable verification feature])],,
908 [enable_vtable_verify=no])
909 vtable_verify=`if test x$enable_vtable_verify = xyes; then echo 1; else echo 0; fi`
910 AC_DEFINE_UNQUOTED(ENABLE_VTABLE_VERIFY, $vtable_verify,
911 [Define 0/1 if vtable verification feature is enabled.])
913 AC_ARG_ENABLE(analyzer,
914 [AS_HELP_STRING([--disable-analyzer],
915 [disable -fanalyzer static analyzer])],
916 if test x$enable_analyzer = xno; then
922 AC_DEFINE_UNQUOTED(ENABLE_ANALYZER, $analyzer,
923 [Define 0/1 if static analyzer feature is enabled.])
925 AC_ARG_ENABLE(objc-gc,
926 [AS_HELP_STRING([--enable-objc-gc],
927 [enable the use of Boehm's garbage collector with
928 the GNU Objective-C runtime])],
929 if test x$enable_objc_gc = xno; then
937 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
938 dwarf2="$with_dwarf2",
941 AC_ARG_ENABLE(shared,
942 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
944 case $enable_shared in
948 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
949 for pkg in $enableval; do
950 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
957 ], [enable_shared=yes])
958 AC_SUBST(enable_shared)
961 [ --disable-gcov don't provide libgcov and related host tools],
962 [], [enable_gcov=yes])
963 AC_SUBST(enable_gcov)
966 [AS_HELP_STRING([--with-specs=SPECS],
967 [add SPECS to driver command-line processing])],
968 [CONFIGURE_SPECS=$withval],
971 AC_SUBST(CONFIGURE_SPECS)
973 ACX_PKGVERSION([GCC])
974 ACX_BUGURL([https://gcc.gnu.org/bugs/])
976 # Allow overriding the default URL for documentation
977 AC_ARG_WITH(documentation-root-url,
978 AS_HELP_STRING([--with-documentation-root-url=URL],
979 [Root for documentation URLs]),
981 yes) AC_MSG_ERROR([documentation root URL not specified]) ;;
982 no) AC_MSG_ERROR([documentation root URL not specified]) ;;
983 */) DOCUMENTATION_ROOT_URL="$withval" ;;
984 *) AC_MSG_ERROR([documentation root URL does not end with /]) ;;
986 DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/"
988 AC_DEFINE_UNQUOTED(DOCUMENTATION_ROOT_URL,"$DOCUMENTATION_ROOT_URL",
989 [Define to the root for documentation URLs.])
991 # Allow overriding the default URL for GCC changes
992 AC_ARG_WITH(changes-root-url,
993 AS_HELP_STRING([--with-changes-root-url=URL],
994 [Root for GCC changes URLs]),
996 yes) AC_MSG_ERROR([changes root URL not specified]) ;;
997 no) AC_MSG_ERROR([changes root URL not specified]) ;;
998 */) CHANGES_ROOT_URL="$withval" ;;
999 *) AC_MSG_ERROR([changes root URL does not end with /]) ;;
1001 CHANGES_ROOT_URL="https://gcc.gnu.org/"
1003 AC_DEFINE_UNQUOTED(CHANGES_ROOT_URL,"$CHANGES_ROOT_URL",
1004 [Define to the root for URLs about GCC changes.])
1006 # Sanity check enable_languages in case someone does not run the toplevel
1007 # configure # script.
1008 AC_ARG_ENABLE(languages,
1009 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
1010 [case ,${enable_languages}, in
1012 # go safe -- we cannot be much sure without the toplevel
1014 # analysis of which target libs are present and usable
1018 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
1023 enable_languages=c,${enable_languages}
1026 [enable_languages=c])
1028 # If top-level libada has been disabled, then wire in install-gnatlib
1029 # invocation with `make install', so that one can build and install
1030 # the library manually with `make -C gcc all gnatlib gnattools install'.
1031 if test x"$enable_libada" = xno; then
1032 gnat_install_lib=gnat-install-lib
1036 AC_SUBST(gnat_install_lib)
1038 if test x"$enable_as_accelerator_for" != x; then
1039 AC_DEFINE(ACCEL_COMPILER, 1,
1040 [Define if this compiler should be built as the offload target compiler.])
1041 enable_as_accelerator=yes
1044 # In this case we expect offload compiler to be built as native, so we
1045 # need to rename the driver to avoid clashes with host's drivers.
1046 program_transform_name="s&^&${target}-&" ;;
1048 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
1049 program_transform_name=`echo $program_transform_name | sed $sedscript`
1050 accel_dir_suffix=/accel/${target_noncanonical}
1051 real_target_noncanonical=${enable_as_accelerator_for}
1053 AC_SUBST(enable_as_accelerator)
1054 AC_SUBST(real_target_noncanonical)
1055 AC_SUBST(accel_dir_suffix)
1057 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
1058 tgt=`echo $tgt | sed 's/=.*//'`
1062 *-intelmic-* | *-intelmicemul-*)
1063 omp_device_property=omp-device-properties-i386
1064 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/i386/t-omp-device"
1067 omp_device_property=omp-device-properties-gcn
1068 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/gcn/t-omp-device"
1071 omp_device_property=omp-device-properties-nvptx
1072 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/nvptx/t-omp-device"
1075 AC_MSG_ERROR([unknown offload target specified])
1078 omp_device_properties="${omp_device_properties} ${tgt}=${omp_device_property}"
1079 omp_device_property_deps="${omp_device_property_deps} ${omp_device_property}"
1081 if test x"$offload_targets" = x; then
1082 offload_targets=$tgt
1084 offload_targets="$offload_targets,$tgt"
1087 AC_SUBST(omp_device_properties)
1088 AC_SUBST(omp_device_property_deps)
1090 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
1091 [Define to offload targets, separated by commas.])
1092 if test x"$enable_offloading" != x; then
1093 AC_DEFINE(ENABLE_OFFLOADING, 1,
1094 [Define this to enable support for offloading.])
1096 AC_DEFINE(ENABLE_OFFLOADING, 0,
1097 [Define this to enable support for offloading.])
1100 AC_ARG_WITH(multilib-list,
1101 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
1103 with_multilib_list=default)
1105 AC_ARG_WITH(multilib-generator,
1106 [AS_HELP_STRING([--with-multilib-generator], [Multi-libs configuration string (RISC-V only)])],
1108 with_multilib_generator=default)
1110 # -------------------------
1111 # Checks for other programs
1112 # -------------------------
1116 # Find some useful tools
1118 # We need awk to create options.c and options.h.
1119 # Bail out if it's missing.
1121 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
1128 AC_SUBST(ranlib_flags)
1132 # See if cmp has --ignore-initial.
1133 gcc_AC_PROG_CMP_IGNORE_INITIAL
1135 # See if we have the mktemp command.
1136 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
1138 # See if makeinfo has been installed and is modern enough
1139 # that we can use it.
1140 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
1141 [GNU texinfo.* \([0-9][0-9.]*\)],
1142 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
1143 if test $gcc_cv_prog_makeinfo_modern = no; then
1145 *** Makeinfo is missing or too old.
1146 *** Info documentation will not be built.])
1151 AC_SUBST(BUILD_INFO)
1153 # Is pod2man recent enough to regenerate manpages?
1154 AC_MSG_CHECKING([for recent Pod::Man])
1155 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1157 GENERATED_MANPAGES=generated-manpages
1162 AC_SUBST(GENERATED_MANPAGES)
1164 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1167 dnl Don't use AC_PROG_LEX; we insist on flex.
1168 dnl LEXLIB is not useful in gcc.
1169 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1172 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1174 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
1175 # check for build == host before using them.
1178 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1179 && test -d ../binutils ; then
1180 NM='${objdir}/../binutils/nm-new'
1182 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1186 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1187 && test -d ../binutils ; then
1188 AR='${objdir}/../binutils/ar'
1190 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1193 # The jit documentation looks better if built with sphinx, but can be
1194 # built with texinfo if sphinx is not available.
1195 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1196 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1198 # --------------------
1199 # Checks for C headers
1200 # --------------------
1202 # Need to reject headers which give warnings, so that the -Werror bootstrap
1203 # works later. *sigh* This needs to come before all header checks.
1210 AC_HEADER_TIOCGWINSZ
1211 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1212 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1213 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1214 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1216 # Check for thread headers.
1217 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1218 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1220 # These tests can't be done till we know if we have limits.h.
1224 # ----------------------
1225 # Checks for C++ headers
1226 # ----------------------
1228 dnl Autoconf will give an error in the configure script if there is no
1229 dnl C++ preprocessor. Hack to prevent that.
1230 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1232 m4_popdef([AC_MSG_ERROR])[]dnl
1234 AC_CHECK_HEADERS(unordered_map)
1235 AC_CHECK_HEADERS(tr1/unordered_map)
1236 AC_CHECK_HEADERS(ext/hash_map)
1239 # Dependency checking.
1243 AC_CONFIG_COMMANDS([gccdepdir],[
1244 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1245 for lang in $subdirs c-family common analyzer
1247 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1248 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1250 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1257 # These libraries may be used by collect2.
1258 # We may need a special search path to get them linked.
1259 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1261 for libs in '' -lld -lmld \
1262 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1263 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1266 AC_TRY_LINK_FUNC(ldopen,
1267 [gcc_cv_collect2_libs="$libs"; break])
1270 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1271 case $gcc_cv_collect2_libs in
1273 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1275 AC_SUBST(COLLECT2_LIBS)
1277 # When building Ada code on Alpha, we need exc_resume which is usually in
1278 # -lexc. So test for it.
1281 AC_SEARCH_LIBS(exc_resume, exc)
1284 AC_SUBST(GNAT_LIBEXC)
1286 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1289 AC_SEARCH_LIBS(kstat_open, kstat)
1290 EXTRA_GCC_LIBS="$LIBS"
1292 AC_SUBST(EXTRA_GCC_LIBS)
1294 # Some systems put ldexp and frexp in libm instead of libc; assume
1295 # they're both in the same place. jcf-dump needs them.
1298 AC_SEARCH_LIBS(ldexp, m)
1303 # Some systems need dlopen
1306 AC_SEARCH_LIBS(dlopen, dl)
1311 # Use <inttypes.h> only if it exists,
1312 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1314 AC_MSG_CHECKING(for inttypes.h)
1315 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1316 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1317 [[#define __STDC_FORMAT_MACROS
1318 #include <sys/types.h>
1319 #include <inttypes.h>]],
1324 [gcc_cv_header_inttypes_h=yes],
1325 [gcc_cv_header_inttypes_h=no])])
1326 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1327 if test $gcc_cv_header_inttypes_h = yes; then
1328 AC_DEFINE(HAVE_INTTYPES_H, 1,
1329 [Define if you have a working <inttypes.h> header file.])
1332 # Look for the ZSTD package.
1335 AC_SUBST(ZSTD_INCLUDE)
1339 AC_SUBST(ZSTD_CPPFLAGS)
1340 AC_SUBST(ZSTD_LDFLAGS)
1342 [AS_HELP_STRING([--with-zstd=PATH],
1343 [specify prefix directory for installed zstd library.
1344 Equivalent to --with-zstd-include=PATH/include
1345 plus --with-zstd-lib=PATH/lib])])
1346 AC_ARG_WITH(zstd-include,
1347 [AS_HELP_STRING([--with-zstd-include=PATH],
1348 [specify directory for installed zstd include files])])
1349 AC_ARG_WITH(zstd-lib,
1350 [AS_HELP_STRING([--with-zstd-lib=PATH],
1351 [specify directory for the installed zstd library])])
1352 case "x$with_zstd" in
1358 *) ZSTD_INCLUDE=$with_zstd/include
1359 ZSTD_LIB=$with_zstd/lib
1363 if test "x$with_zstd" != xno; then
1364 if test "x$with_zstd_include" != x; then
1365 ZSTD_INCLUDE=$with_zstd_include
1367 if test "x$with_zstd_lib" != x; then
1368 ZSTD_LIB=$with_zstd_lib
1370 if test "x$ZSTD_INCLUDE" != x \
1371 && test "x$ZSTD_INCLUDE" != xno; then
1372 ZSTD_CPPFLAGS=-I$ZSTD_INCLUDE
1374 if test "x$ZSTD_LIB" != x \
1375 && test "x$ZSTD_LIB" != xno; then
1376 ZSTD_LDFLAGS=-L$ZSTD_LIB
1379 CXXFLAGS="$CXXFLAGS $ZSTD_CPPFLAGS"
1380 LDFLAGS="$LDFLAGS $ZSTD_LDFLAGS"
1382 AC_MSG_CHECKING(for zstd.h)
1383 AC_CACHE_VAL(gcc_cv_header_zstd_h,
1384 # We require version 1.3.0 or later. This is the first version that has
1385 # ZSTD_getFrameContentSize.
1386 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1388 #if ZSTD_VERSION_NUMBER < 10300
1389 #error "need zstd 1.3.0 or better"
1391 [gcc_cv_header_zstd_h=yes],
1392 [gcc_cv_header_zstd_h=no])])
1393 AC_MSG_RESULT($gcc_cv_header_zstd_h)
1394 if test $gcc_cv_header_zstd_h = yes; then
1395 AC_DEFINE(HAVE_ZSTD_H, 1,
1396 [Define if you have a working <zstd.h> header file.])
1397 elif test "x$with_zstd" != x; then
1398 as_fn_error $? "Unable to find zstd.h. See config.log for details." "$LINENO" 5
1401 # LTO can use zstd compression algorithm
1404 AC_SEARCH_LIBS(ZSTD_compress, zstd)
1410 dnl Disabled until we have a complete test for buggy enum bitfields.
1411 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1413 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1414 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1415 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1416 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1417 putchar_unlocked putc_unlocked)
1418 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1419 popen sysconf strsignal getrusage nl_langinfo \
1420 gettimeofday mbstowcs wcswidth mmap setlocale \
1421 gcc_UNLOCKED_FUNCS madvise mallinfo mallinfo2)
1423 if test x$ac_cv_func_mbstowcs = xyes; then
1424 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1425 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1431 [gcc_cv_func_mbstowcs_works=yes],
1432 [gcc_cv_func_mbstowcs_works=no],
1433 [gcc_cv_func_mbstowcs_works=yes])])
1434 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1435 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1436 [Define this macro if mbstowcs does not crash when its
1437 first argument is NULL.])
1441 AC_CHECK_TYPE(ssize_t, int)
1442 AC_CHECK_TYPE(caddr_t, char *)
1444 GCC_AC_FUNC_MMAP_BLACKLIST
1448 # Under VMS, vfork works very differently than on Unix. The standard test
1449 # won't work, and it isn't easily adaptable. It makes more sense to
1451 ac_cv_func_vfork_works=yes
1458 # Until we have in-tree GNU iconv:
1460 if test -f "$LTLIBICONV"; then
1461 LIBICONV_DEP=$LTLIBICONV
1463 AC_SUBST(LIBICONV_DEP)
1469 # We will need to find libiberty.h and ansidecl.h
1470 saved_CFLAGS="$CFLAGS"
1471 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1472 saved_CXXFLAGS="$CXXFLAGS"
1473 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1475 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1476 # normal autoconf function for these. But force definition of
1477 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1478 # basename handling in libiberty.h.
1479 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1480 #undef HAVE_DECL_BASENAME
1481 #define HAVE_DECL_BASENAME 1
1482 #include "ansidecl.h"
1483 #include "system.h"])
1485 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1486 madvise stpcpy strnlen strsignal strverscmp \
1487 strtol strtoul strtoll strtoull setenv unsetenv \
1488 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1489 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1490 #include "ansidecl.h"
1491 #include "system.h"])
1493 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1494 #include "ansidecl.h"
1496 #ifdef HAVE_SYS_RESOURCE_H
1497 #include <sys/resource.h>
1501 gcc_AC_CHECK_DECLS(mallinfo mallinfo2, , ,[
1502 #include "ansidecl.h"
1504 #ifdef HAVE_MALLOC_H
1509 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1510 #include "ansidecl.h"
1512 #ifdef HAVE_SYS_RESOURCE_H
1513 #include <sys/resource.h>
1515 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1516 [Define to `long' if <sys/resource.h> doesn't define.])])
1518 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1519 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1520 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1521 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1522 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1523 #include "ansidecl.h"
1532 gcc_AC_CHECK_DECLS(times, , ,[
1533 #include "ansidecl.h"
1535 #ifdef HAVE_SYS_TIMES_H
1536 #include <sys/times.h>
1540 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1541 #include "ansidecl.h"
1546 # More time-related stuff.
1547 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1548 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1549 #include "ansidecl.h"
1551 #ifdef HAVE_SYS_TIMES_H
1552 #include <sys/times.h>
1554 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1555 if test $ac_cv_struct_tms = yes; then
1556 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1557 [Define if <sys/times.h> defines struct tms.])
1560 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1561 # revisit after autoconf 2.50.
1562 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1563 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1564 #include "ansidecl.h"
1566 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1567 if test $gcc_cv_type_clock_t = yes; then
1568 AC_DEFINE(HAVE_CLOCK_T, 1,
1569 [Define if <time.h> defines clock_t.])
1572 # Check if F_SETLKW is supported by fcntl.
1573 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1574 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1575 #include <fcntl.h>]], [[
1581 return fcntl (1, F_SETLKW, &fl);]])],
1582 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1583 if test $ac_cv_f_setlkw = yes; then
1584 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1585 [Define if F_SETLKW supported by fcntl.])
1588 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1589 CFLAGS="$saved_CFLAGS"
1590 CXXFLAGS="$saved_CXXFLAGS"
1592 # mkdir takes a single argument on some systems.
1593 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1601 # With Setjmp/Longjmp based exception handling.
1602 AC_ARG_ENABLE(sjlj-exceptions,
1603 [AS_HELP_STRING([--enable-sjlj-exceptions],
1604 [arrange to use setjmp/longjmp exception handling])],
1607 if test $enableval != yes; then
1608 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1613 force_sjlj_exceptions=yes],
1616 force_sjlj_exceptions=yes
1620 force_sjlj_exceptions=yes
1624 force_sjlj_exceptions=no
1627 if test $force_sjlj_exceptions = yes; then
1628 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1629 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1630 [Define 0/1 to force the choice for exception handling model.])
1633 # --------------------------------------------------------
1634 # Build, host, and target specific configuration fragments
1635 # --------------------------------------------------------
1637 # Collect build-machine-specific information.
1638 . ${srcdir}/config.build || exit 1
1640 # Collect host-machine-specific information.
1641 . ${srcdir}/config.host || exit 1
1645 # Collect target-machine-specific information.
1646 . ${srcdir}/config.gcc || exit 1
1648 extra_objs="${host_extra_objs} ${extra_objs}"
1649 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1651 # Default the target-machine variables that were not explicitly set.
1652 if test x"$tm_file" = x
1653 then tm_file=$cpu_type/$cpu_type.h; fi
1655 if test x"$extra_headers" = x
1656 then extra_headers=; fi
1658 if test x$md_file = x
1659 then md_file=$cpu_type/$cpu_type.md; fi
1661 if test x$out_file = x
1662 then out_file=$cpu_type/$cpu_type.c; fi
1664 if test x"$tmake_file" = x
1665 then tmake_file=$cpu_type/t-$cpu_type
1668 # Support --enable-initfini-array.
1669 if test x$enable_initfini_array != xno; then
1670 tm_file="${tm_file} initfini-array.h"
1673 if test x"$dwarf2" = xyes
1674 then tm_file="$tm_file tm-dwarf2.h"
1677 # Say what files are being used for the output code and MD file.
1678 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1679 echo "Using \`$srcdir/config/$md_file' as machine description file."
1681 # If any of the xm_file variables contain nonexistent files, warn
1682 # about them and drop them.
1685 for x in $build_xm_file; do
1686 if test -f $srcdir/config/$x
1688 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1694 for x in $host_xm_file; do
1695 if test -f $srcdir/config/$x
1697 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1703 for x in $xm_file; do
1704 if test -f $srcdir/config/$x
1706 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1712 for f in $tm_file; do
1715 if test $count = ax; then
1716 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1718 echo "Using the following target machine macro files:"
1719 for f in $tm_file; do
1720 echo " $srcdir/config/$f"
1724 if test x$use_long_long_for_widest_fast_int = xyes; then
1725 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1726 [Define to 1 if the 'long long' type is wider than 'long' but still
1727 efficiently supported by the host hardware.])
1730 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1731 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1733 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1734 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1737 for f in $host_xm_file; do
1740 if test $count = a; then
1742 elif test $count = ax; then
1743 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1745 echo "Using the following host machine macro files:"
1746 for f in $host_xm_file; do
1747 echo " $srcdir/config/$f"
1750 echo "Using ${out_host_hook_obj} for host machine hooks."
1752 if test "$host_xm_file" != "$build_xm_file"; then
1754 for f in $build_xm_file; do
1757 if test $count = a; then
1759 elif test $count = ax; then
1760 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1762 echo "Using the following build machine macro files:"
1763 for f in $build_xm_file; do
1764 echo " $srcdir/config/$f"
1769 if test -n "$configured_native_system_header_dir"; then
1770 native_system_header_dir=$configured_native_system_header_dir
1772 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1773 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1777 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1778 gcc_cv_mcontext_underscores,
1779 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1780 #include <sys/cdefs.h>
1781 #include <sys/signal.h>
1782 #include <ucontext.h>
1783 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1785 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1786 if test $gcc_cv_mcontext_underscores = yes; then
1787 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1788 [mcontext_t fields start with __])
1797 # Check if a valid thread package
1798 case ${enable_threads} in
1801 target_thread_file='single'
1805 target_thread_file='single'
1807 aix | dce | lynx | mipssde | posix | rtems | \
1808 single | tpf | vxworks | win32)
1809 target_thread_file=${enable_threads}
1812 echo "${enable_threads} is an unknown thread package" 1>&2
1817 if test x${thread_file} = x; then
1818 # No thread file set by target-specific clauses in config.gcc,
1819 # so use file chosen by default logic above
1820 thread_file=${target_thread_file}
1828 if test x$enable___cxa_atexit = xyes || \
1829 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1830 if test x$host = x$target; then
1832 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1833 # keyed to flag_use_cxa_atexit
1841 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1842 [echo "__cxa_atexit can't be enabled on this target"])
1846 # We can't check for __cxa_atexit when building a cross, so assume
1850 if test x$use_cxa_atexit = xyes; then
1851 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1852 [Define if you want to use __cxa_atexit, rather than atexit, to
1853 register C++ destructors for local statics and global objects.
1854 This is essential for fully standards-compliant handling of
1855 destructors, but requires __cxa_atexit in libc.])
1859 # Look for a file containing extra machine modes.
1860 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1861 extra_modes_file='$(srcdir)'/config/${extra_modes}
1862 AC_SUBST(extra_modes_file)
1863 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1864 [Define to the name of a file containing a list of extra machine modes
1865 for this architecture.])
1868 # Convert extra_options into a form suitable for Makefile use.
1871 for f in $extra_options; do
1872 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1873 all_opt_files="$all_opt_files $srcdir/config/$f"
1875 AC_SUBST(extra_opt_files)
1877 # auto-host.h is the file containing items generated by autoconf and is
1878 # the first file included by config.h.
1879 # If host=build, it is correct to have bconfig include auto-host.h
1880 # as well. If host!=build, we are in error and need to do more
1881 # work to find out the build config parameters.
1882 if test x$host = x$build
1884 build_auto=auto-host.h
1885 HAVE_AUTO_BUILD='# '
1887 # We create a subdir, then run autoconf in the subdir.
1888 # To prevent recursion we set host and build for the new
1889 # invocation of configure to the build for this invocation
1896 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1897 *) realsrcdir=../${srcdir};;
1899 # Clearing GMPINC is necessary to prevent host headers being
1900 # used by the build compiler. Defining GENERATOR_FILE stops
1901 # system.h from including gmp.h.
1902 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1903 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1904 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1905 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1906 ${realsrcdir}/configure \
1907 --enable-languages=${enable_languages-all} \
1908 ${enable_obsolete+--enable-obsolete="$enable_obsolete"} \
1909 ${enable_option_checking+--enable-option-checking="$enable_option_checking"} \
1910 --target=$target_alias --host=$build_alias \
1911 --build=$build_alias || exit # retaining $tempdir
1913 # We just finished tests for the build machine, so rename
1914 # the file auto-build.h in the gcc directory.
1915 mv auto-host.h ../auto-build.h
1918 build_auto=auto-build.h
1921 AC_SUBST(build_subdir)
1922 AC_SUBST(HAVE_AUTO_BUILD)
1924 tm_file="${tm_file} defaults.h"
1925 tm_p_file="${tm_p_file} tm-preds.h"
1926 tm_d_file="${tm_d_file} defaults.h"
1927 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1928 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1929 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1930 # put this back in temporarily.
1931 xm_file="auto-host.h ansidecl.h ${xm_file}"
1938 # Compile in configure arguments.
1939 if test -f configargs.h ; then
1940 # Being re-configured.
1941 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1942 gcc_reconf_arguments=`echo "$gcc_config_arguments" | sed -e 's/^.*\( : (reconfigured) .*$\)/\1/'`
1943 if [ "$gcc_reconf_arguments" != " : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" ]; then
1944 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1947 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1950 # Double all backslashes and backslash all quotes to turn
1951 # gcc_config_arguments into a C string.
1952 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1953 $gcc_config_arguments
1955 gcc_config_arguments_str=`cat conftest.out`
1958 cat > configargs.h <<EOF
1959 /* Generated automatically. */
1960 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1961 static const char thread_model[] = "$thread_file";
1963 static const struct {
1964 const char *name, *value;
1965 } configure_default_options[] = $configure_default_options;
1970 gcc_BASEVER=`cat $srcdir/BASE-VER`
1971 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1972 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1973 if test -f $srcdir/REVISION ; then
1974 gcc_REVISION=`cat $srcdir/REVISION`
1978 cat > plugin-version.h <<EOF
1979 #include "configargs.h"
1981 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1982 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1983 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1984 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1986 static char basever[] = "$gcc_BASEVER";
1987 static char datestamp[] = "$gcc_DATESTAMP";
1988 static char devphase[] = "$gcc_DEVPHASE";
1989 static char revision[] = "$gcc_REVISION";
1991 /* FIXME plugins: We should make the version information more precise.
1992 One way to do is to add a checksum. */
1994 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1996 configuration_arguments};
2000 # Determine what GCC version number to use in filesystem paths.
2003 # Internationalization
2004 ZW_GNU_GETTEXT_SISTER_DIR
2006 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
2007 # -liconv on the link line twice.
2008 case "$LIBINTL" in *$LIBICONV*)
2012 AC_ARG_ENABLE(secureplt,
2013 [AS_HELP_STRING([--enable-secureplt],
2014 [enable -msecure-plt by default for PowerPC])],
2017 AC_ARG_ENABLE(mingw-wildcard,
2018 [AS_HELP_STRING([--enable-mingw-wildcard],
2019 [Set whether to expand wildcard on command-line.
2020 Default to platform configuration])],
2021 [],[enable_mingw_wildcard=platform])
2022 AS_IF([test x"$enable_mingw_wildcard" != xplatform ],
2023 [AC_DEFINE_UNQUOTED(MINGW_DOWILDCARD,
2024 $(test x"$enable_mingw_wildcard" = xno; echo $?),
2025 [Value to set mingw's _dowildcard to.])])
2027 AC_ARG_ENABLE(large-address-aware,
2028 [AS_HELP_STRING([--enable-large-address-aware],
2029 [Link mingw executables with --large-address-aware])])
2030 AS_IF([test x"$enable_large_address_aware" = xyes],
2031 [AC_DEFINE([MINGW_DEFAULT_LARGE_ADDR_AWARE], 1,
2032 [Define if we should link mingw executables with --large-address-aware])])
2034 AC_ARG_ENABLE(leading-mingw64-underscores,
2035 AS_HELP_STRING([--enable-leading-mingw64-underscores],
2036 [enable leading underscores on 64 bit mingw targets]),
2038 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
2039 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
2040 [Define if we should use leading underscore on 64 bit mingw targets])])
2043 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
2046 AC_ARG_ENABLE(frame-pointer,
2047 [AS_HELP_STRING([--enable-frame-pointer],
2048 [enable -fno-omit-frame-pointer by default for x86])], [],
2051 linux* | gnu* | darwin[[8912]]* | cygwin* | mingw*)
2052 # Enable -fomit-frame-pointer by default for these systems with DWARF2.
2053 enable_frame_pointer=no
2056 enable_frame_pointer=yes
2062 i[[34567]]86-*-* | x86_64-*-*)
2063 if test "x$enable_cld" = xyes; then
2064 tm_defines="${tm_defines} USE_IX86_CLD=1"
2066 if test "x$enable_frame_pointer" = xyes; then
2067 tm_defines="${tm_defines} USE_IX86_FRAME_POINTER=1"
2072 # Windows32 Registry support for specifying GCC installation paths.
2073 AC_ARG_ENABLE(win32-registry,
2074 [AS_HELP_STRING([--disable-win32-registry],
2075 [disable lookup of installation paths in the
2076 Registry on Windows hosts])
2077 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
2078 AS_HELP_STRING([--enable-win32-registry=KEY],
2079 [use KEY instead of GCC version as the last portion
2080 of the registry key])],,)
2083 win32 | pe | cygwin* | mingw32*)
2084 if test "x$enable_win32_registry" != xno; then
2085 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
2088 if test "x$enable_win32_registry" != xno; then
2089 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
2090 [Define to 1 if installation paths should be looked up in the Windows
2091 Registry. Ignored on non-Windows hosts.])
2093 if test "x$enable_win32_registry" != xyes \
2094 && test "x$enable_win32_registry" != x; then
2095 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
2096 [Define to be the last component of the Windows registry key under which
2097 to look for installation paths. The full key used will be
2098 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
2099 The default is the GCC version number.])
2105 # Get an absolute path to the GCC top-level source directory
2106 holddir=`${PWDCMD-pwd}`
2108 topdir=`${PWDCMD-pwd}`
2111 # Conditionalize the makefile for this host machine.
2113 for f in ${host_xmake_file}
2115 if test -f ${srcdir}/config/$f
2117 xmake_file="${xmake_file} \$(srcdir)/config/$f"
2121 # Conditionalize the makefile for this target machine.
2123 for f in ${tmake_file}
2125 if test -f ${srcdir}/config/$f
2127 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
2130 tmake_file="${tmake_file_}${omp_device_property_tmake_file}"
2132 out_object_file=`basename $out_file .c`.o
2133 common_out_object_file=`basename $common_out_file .c`.o
2135 tm_file_list="options.h"
2136 tm_include_list="options.h insn-constants.h"
2137 for f in $tm_file; do
2140 f=`echo $f | sed 's/^..//'`
2141 tm_file_list="${tm_file_list} $f"
2142 tm_include_list="${tm_include_list} $f"
2145 tm_file_list="${tm_file_list} \$(srcdir)/$f"
2146 tm_include_list="${tm_include_list} $f"
2149 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
2150 tm_include_list="${tm_include_list} config/$f"
2157 for f in $tm_p_file; do
2160 tm_p_file_list="${tm_p_file_list} $f"
2161 tm_p_include_list="${tm_p_include_list} $f"
2164 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
2165 tm_p_include_list="${tm_p_include_list} config/$f"
2170 tm_d_include_list="options.h insn-constants.h"
2171 for f in $tm_d_file; do
2174 tm_d_file_list="${tm_d_file_list} \$(srcdir)/$f"
2175 tm_d_include_list="${tm_d_include_list} $f"
2178 tm_d_file_list="${tm_d_file_list} \$(srcdir)/config/$f"
2179 tm_d_include_list="${tm_d_include_list} config/$f"
2186 for f in $xm_file; do
2189 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
2190 xm_include_list="${xm_include_list} $f"
2193 xm_file_list="${xm_file_list} $f"
2194 xm_include_list="${xm_include_list} $f"
2197 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
2198 xm_include_list="${xm_include_list} config/$f"
2204 host_xm_include_list=
2205 for f in $host_xm_file; do
2208 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
2209 host_xm_include_list="${host_xm_include_list} $f"
2212 host_xm_file_list="${host_xm_file_list} $f"
2213 host_xm_include_list="${host_xm_include_list} $f"
2216 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
2217 host_xm_include_list="${host_xm_include_list} config/$f"
2223 for f in $build_xm_file; do
2226 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
2227 build_xm_include_list="${build_xm_include_list} $f"
2229 auto-build.h | auto-host.h )
2230 build_xm_file_list="${build_xm_file_list} $f"
2231 build_xm_include_list="${build_xm_include_list} $f"
2234 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
2235 build_xm_include_list="${build_xm_include_list} config/$f"
2240 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
2241 # cross-compiler which does not use the native headers and libraries.
2242 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
2243 CROSS= AC_SUBST(CROSS)
2244 ALL=all.internal AC_SUBST(ALL)
2245 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
2246 BUILD_SYSTEM_HEADER_DIR=$SYSTEM_HEADER_DIR AC_SUBST(BUILD_SYSTEM_HEADER_DIR)
2248 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x ||
2249 test x$build != x$host || test "x$with_build_sysroot" != x; then
2250 if test "x$with_build_sysroot" != x; then
2251 BUILD_SYSTEM_HEADER_DIR=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
2253 BUILD_SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2256 if test x$host != x$target
2258 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
2260 SYSTEM_HEADER_DIR=$BUILD_SYSTEM_HEADER_DIR
2261 elif test "x$TARGET_SYSTEM_ROOT" != x; then
2262 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2265 if test "x$with_build_sysroot" != "x"; then
2266 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
2267 elif test "x$with_sysroot" = x; then
2268 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
2269 elif test "x$with_sysroot" = xyes; then
2270 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
2272 target_header_dir="${with_sysroot}${native_system_header_dir}"
2275 target_header_dir=${native_system_header_dir}
2278 # If this is a cross-compiler that does not
2279 # have its own set of headers then define
2282 # If this is using newlib, without having the headers available now,
2283 # then define inhibit_libc in LIBGCC2_CFLAGS.
2284 # This prevents libgcc2 from containing any code which requires libc
2286 : ${inhibit_libc=false}
2287 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2288 test x$with_newlib = xyes ; } &&
2289 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
2292 AC_SUBST(inhibit_libc)
2294 # When building gcc with a cross-compiler, we need to adjust things so
2295 # that the generator programs are still built with the native compiler.
2296 # Also, we cannot run fixincludes.
2298 # These are the normal (build=host) settings:
2299 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2300 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2301 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2302 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2303 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2304 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2306 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS)' AC_SUBST(BUILD_NO_PIE_CFLAGS)
2307 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG)' AC_SUBST(BUILD_NO_PIE_FLAG)
2309 # And these apply if build != host, or we are generating coverage data
2310 if test x$build != x$host || test "x$coverage_flags" != x
2312 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2313 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2314 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2316 NO_PIE_CFLAGS_FOR_BUILD=${NO_PIE_CFLAGS_FOR_BUILD-${NO_PIE_CFLAGS}}
2317 NO_PIE_FLAG_FOR_BUILD=${NO_PIE_FLAG_FOR_BUILD-${NO_PIE_FLAG}}
2318 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS_FOR_BUILD)'
2319 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG_FOR_BUILD)'
2321 AC_SUBST(NO_PIE_CFLAGS_FOR_BUILD)
2322 AC_SUBST(NO_PIE_FLAG_FOR_BUILD)
2324 # Expand extra_headers to include complete path.
2325 # This substitutes for lots of t-* files.
2327 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2328 for file in ${extra_headers} ; do
2329 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2332 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2333 if test x"$use_gcc_tgmath" = xyes
2334 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2337 # Define collect2 in Makefile.
2338 case $host_can_use_collect2 in
2340 *) collect2='collect2$(exeext)' ;;
2342 AC_SUBST([collect2])
2344 # Add a definition of USE_COLLECT2 if system wants one.
2345 case $use_collect2 in
2346 no) use_collect2= ;;
2349 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2350 xm_defines="${xm_defines} USE_COLLECT2"
2351 case $host_can_use_collect2 in
2353 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2359 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2360 [Define to the name of the LTO plugin DSO that must be
2361 passed to the linker's -plugin=LIB option.])
2363 # ---------------------------
2364 # Assembler & linker features
2365 # ---------------------------
2367 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2368 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2369 # However when ld-new is first executed from the build tree, libtool will
2370 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2371 # to the build tree. While doing this we need to use the previous-stage
2372 # linker, or we have an infinite loop. The presence of a shell script as
2373 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2374 # the gcc/collect-ld script. So we need to know how libtool works, or
2375 # exec-tool will fail.
2377 m4_defun([_LT_CONFIG_COMMANDS], [])
2380 AC_SUBST(enable_fast_install)
2382 # Identify the assembler which will work hand-in-glove with the newly
2383 # built GCC, so that we can examine its features. This is the assembler
2384 # which will be driven by the driver program.
2386 # If build != host, and we aren't building gas in-tree, we identify a
2387 # build->target assembler and hope that it will have the same features
2388 # as the host->target assembler we'll be using.
2389 gcc_cv_gas_major_version=
2390 gcc_cv_gas_minor_version=
2391 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2393 m4_pattern_allow([AS_FOR_TARGET])dnl
2394 AS_VAR_SET_IF(gcc_cv_as,, [
2395 if test -x "$DEFAULT_ASSEMBLER"; then
2396 gcc_cv_as="$DEFAULT_ASSEMBLER"
2397 elif test -f $gcc_cv_as_gas_srcdir/configure.ac \
2398 && test -f ../gas/Makefile \
2399 && test x$build = x$host; then
2400 gcc_cv_as=../gas/as-new$build_exeext
2401 elif test -x as$build_exeext; then
2402 # Build using assembler in the current directory.
2403 gcc_cv_as=./as$build_exeext
2404 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2405 gcc_cv_as="$AS_FOR_TARGET"
2407 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2410 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2411 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2412 case "$ORIGINAL_AS_FOR_TARGET" in
2413 ./as | ./as$build_exeext) ;;
2414 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2417 AC_MSG_CHECKING(what assembler to use)
2418 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2419 # Single tree build which includes gas. We want to prefer it
2420 # over whatever linker top-level may have detected, since
2421 # we'll use what we're building after installation anyway.
2422 AC_MSG_RESULT(newly built gas)
2424 _gcc_COMPUTE_GAS_VERSION
2425 in_tree_gas_is_elf=no
2426 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2427 || (grep 'obj_format = multi' ../gas/Makefile \
2428 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2430 in_tree_gas_is_elf=yes
2433 AC_MSG_RESULT($gcc_cv_as)
2439 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2440 [case "${enableval}" in
2446 install_gold_as_default=no
2448 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2449 [case "${enableval}" in
2451 install_gold_as_default=yes
2454 if test x${default_ld} != x; then
2455 install_gold_as_default=yes
2461 AC_MSG_ERROR([invalid --enable-gold argument])
2465 # Identify the linker which will work hand-in-glove with the newly
2466 # built GCC, so that we can examine its features. This is the linker
2467 # which will be driven by the driver program.
2469 # If build != host, and we aren't building gas in-tree, we identify a
2470 # build->target linker and hope that it will have the same features
2471 # as the host->target linker we'll be using.
2472 gcc_cv_gld_major_version=
2473 gcc_cv_gld_minor_version=
2474 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2475 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2476 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2478 AS_VAR_SET_IF(gcc_cv_ld,, [
2479 if test -x "$DEFAULT_LINKER"; then
2480 gcc_cv_ld="$DEFAULT_LINKER"
2481 elif test $install_gold_as_default = yes \
2482 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2483 && test -f ../gold/Makefile \
2484 && test x$build = x$host; then
2485 gcc_cv_ld=../gold/ld-new$build_exeext
2486 elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \
2487 && test -f ../ld/Makefile \
2488 && test x$build = x$host; then
2489 gcc_cv_ld=../ld/ld-new$build_exeext
2490 elif test -x collect-ld$build_exeext; then
2491 # Build using linker in the current directory.
2492 gcc_cv_ld=./collect-ld$build_exeext
2493 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2494 gcc_cv_ld="$LD_FOR_TARGET"
2496 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2499 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2500 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2501 # if the PLUGIN_LD is set ld-new, just have it as ld
2502 # as that is the installed named.
2503 if test x$PLUGIN_LD_SUFFIX = xld-new \
2504 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2507 AC_ARG_WITH(plugin-ld,
2508 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2509 [if test x"$withval" != x; then
2510 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2511 PLUGIN_LD_SUFFIX="$withval"
2513 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2514 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2516 # Check to see if we are using gold instead of ld
2517 AC_MSG_CHECKING(whether we are using gold)
2519 if test x$gcc_cv_ld != x; then
2520 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2521 | grep "GNU gold" > /dev/null; then
2525 AC_MSG_RESULT($ld_is_gold)
2527 AC_MSG_CHECKING(gold linker with split stack support as non default)
2528 # Check to see if default ld is not gold, but gold is
2529 # available and has support for split stack. If gcc was configured
2530 # with gold then no checking is done.
2532 if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then
2534 # For platforms other than powerpc64*, enable as appropriate.
2537 ld_gold=`which ${gcc_cv_ld}.gold`
2538 # Make sure this gold has minimal split stack support
2539 if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then
2540 ld_vers=`$ld_gold --version | sed 1q`
2541 gold_vers=`echo $ld_vers | sed -n \
2542 -e 's,^[[^)]]*[[ ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'`
2544 # check that the gold version contains the complete split stack support
2545 # on powerpc64 big and little endian
2547 case "$gold_vers" in
2548 2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes
2550 *) gold_non_default=no
2556 if test $gold_non_default = yes; then
2557 AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1,
2558 [Define if the gold linker supports split stack and is available as a non-default])
2561 AC_MSG_RESULT($gold_non_default)
2563 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2564 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2565 case "$ORIGINAL_LD_FOR_TARGET" in
2566 ./collect-ld | ./collect-ld$build_exeext) ;;
2567 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2570 AC_MSG_CHECKING(what linker to use)
2571 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2572 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2573 # Single tree build which includes ld. We want to prefer it
2574 # over whatever linker top-level may have detected, since
2575 # we'll use what we're building after installation anyway.
2576 AC_MSG_RESULT(newly built ld)
2578 in_tree_ld_is_elf=no
2579 if (grep 'EMUL = .*elf' ../ld/Makefile \
2580 || grep 'EMUL = .*linux' ../ld/Makefile \
2581 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2582 in_tree_ld_is_elf=yes
2583 elif test "$ld_is_gold" = yes; then
2584 in_tree_ld_is_elf=yes
2586 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
2589 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2590 if test x$gcc_cv_gld_version != x; then
2594 case $gcc_cv_gld_version in
2597 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2600 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2601 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2603 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2604 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2606 AC_MSG_RESULT($gcc_cv_ld)
2608 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2609 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2610 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2613 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2614 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2616 # Figure out what nm we will be using.
2617 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2618 AS_VAR_SET_IF(gcc_cv_nm,, [
2619 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2620 && test -f ../binutils/Makefile \
2621 && test x$build = x$host; then
2622 gcc_cv_nm=../binutils/nm-new$build_exeext
2623 elif test -x nm$build_exeext; then
2624 gcc_cv_nm=./nm$build_exeext
2625 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2626 gcc_cv_nm="$NM_FOR_TARGET"
2628 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2631 AC_MSG_CHECKING(what nm to use)
2632 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2633 # Single tree build which includes binutils.
2634 AC_MSG_RESULT(newly built nm)
2637 AC_MSG_RESULT($gcc_cv_nm)
2641 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2642 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2643 case "$ORIGINAL_NM_FOR_TARGET" in
2644 ./nm | ./nm$build_exeext) ;;
2645 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2649 # Figure out what objdump we will be using.
2650 AS_VAR_SET_IF(gcc_cv_objdump,, [
2651 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2652 && test -f ../binutils/Makefile \
2653 && test x$build = x$host; then
2654 # Single tree build which includes binutils.
2655 gcc_cv_objdump=../binutils/objdump$build_exeext
2656 elif test -x objdump$build_exeext; then
2657 gcc_cv_objdump=./objdump$build_exeext
2658 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2659 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2661 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2664 AC_MSG_CHECKING(what objdump to use)
2665 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2666 # Single tree build which includes binutils.
2667 AC_MSG_RESULT(newly built objdump)
2668 elif test x$gcc_cv_objdump = x; then
2669 AC_MSG_RESULT(not found)
2671 AC_MSG_RESULT($gcc_cv_objdump)
2674 # Figure out what readelf we will be using.
2675 AS_VAR_SET_IF(gcc_cv_readelf,, [
2676 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2677 && test -f ../binutils/Makefile \
2678 && test x$build = x$host; then
2679 # Single tree build which includes binutils.
2680 gcc_cv_readelf=../binutils/readelf$build_exeext
2681 elif test -x readelf$build_exeext; then
2682 gcc_cv_readelf=./readelf$build_exeext
2683 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2684 gcc_cv_readelf="$READELF_FOR_TARGET"
2686 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2689 AC_MSG_CHECKING(what readelf to use)
2690 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2691 # Single tree build which includes binutils.
2692 AC_MSG_RESULT(newly built readelf)
2693 elif test x$gcc_cv_readelf = x; then
2694 AC_MSG_RESULT(not found)
2696 AC_MSG_RESULT($gcc_cv_readelf)
2699 # Figure out what otool we will be using.
2700 AS_VAR_SET_IF(gcc_cv_otool,, [
2701 if test -x otool$build_exeext; then
2702 gcc_cv_otool=./otool$build_exeext
2703 elif ( set dummy $OTOOL_FOR_TARGET; test -x $[2] ); then
2704 gcc_cv_otool="$OTOOL_FOR_TARGET"
2706 AC_PATH_PROG(gcc_cv_otool, $OTOOL_FOR_TARGET)
2709 AC_MSG_CHECKING(what otool to use)
2710 if test x$gcc_cv_otool = x; then
2711 AC_MSG_RESULT(not found)
2713 AC_MSG_RESULT($gcc_cv_otool)
2716 # Figure out what assembler alignment features are present.
2717 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2721 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2722 [Define if your assembler supports .balign and .p2align.])])
2724 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2727 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2728 [Define if your assembler supports specifying the maximum number
2729 of bytes to skip when using the GAS .p2align command.])])
2731 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2734 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2735 [Define if your assembler supports .literal16.])])
2737 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2739 [conftest_label1: .word 0
2741 conftest_label2: .word 0
2743 [if test x$gcc_cv_nm != x; then
2744 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2745 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2746 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2748 else gcc_cv_as_subsection_m1=yes
2750 rm -f conftest.nm1 conftest.nm2
2752 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2753 [Define if your assembler supports .subsection and .subsection -1 starts
2754 emitting at the beginning of your section.])])
2756 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2759 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2761 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2763 [ .weakref foobar, barfnot],,
2764 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2766 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2769 .NSUBSPA $CODE$,COMDAT],,
2770 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2772 # .hidden needs to be supported in both the assembler and the linker,
2773 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2774 # This is irritatingly difficult to feature test for; we have to check the
2775 # date string after the version number. If we've got an in-tree
2776 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2778 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2781 conftest_s=' .globl foobar,hidden'
2784 conftest_s=' .hidden foobar
2788 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2789 [elf,2,13,0],, [$conftest_s])
2792 # Darwin as has some visibility support, though with a different syntax.
2793 gcc_cv_as_hidden=yes
2797 # gnu_indirect_function type is an extension proposed at
2798 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2799 # selection of function implementation
2800 AC_ARG_ENABLE(gnu-indirect-function,
2801 [AS_HELP_STRING([--enable-gnu-indirect-function],
2802 [enable the use of the @gnu_indirect_function to glibc systems])],
2803 [case $enable_gnu_indirect_function in
2805 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2806 Valid choices are 'yes' and 'no'.]) ;;
2808 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2812 AC_MSG_CHECKING(linker ifunc IRELATIVE support)
2813 cat > conftest.s <<EOF
2815 .type foo_resolver, @function
2818 .size foo_resolver, .-foo_resolver
2821 .type foo, %gnu_indirect_function
2822 .set foo, foo_resolver
2825 .type bar, @function
2831 if test x$gcc_cv_as != x \
2832 && test x$gcc_cv_ld != x \
2833 && test x$gcc_cv_readelf != x \
2834 && $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2835 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
2836 && $gcc_cv_readelf --relocs --wide conftest \
2837 | grep R_RISCV_IRELATIVE > /dev/null 2>&1; then
2838 enable_gnu_indirect_function=yes
2840 rm -f conftest conftest.o conftest.s
2841 AC_MSG_RESULT($enable_gnu_indirect_function)
2845 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2846 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2847 [Define if your system supports gnu indirect functions.])
2851 if test $in_tree_ld != yes ; then
2852 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2853 if echo "$ld_ver" | grep GNU > /dev/null; then
2854 if test x"$ld_is_gold" = xyes; then
2855 # GNU gold --version looks like this:
2857 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2859 # We extract the binutils version which is more familiar and specific
2860 # than the gold version.
2861 ld_vers=`echo $ld_ver | sed -n \
2862 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2864 # GNU ld --version looks like this:
2866 # GNU ld (GNU Binutils) 2.21.51.20110225
2867 ld_vers=`echo $ld_ver | sed -n \
2868 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2870 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'`
2871 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2872 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2873 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2877 # Solaris 2 ld -V output looks like this for a regular version:
2879 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2881 # but test versions add stuff at the end:
2883 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2885 # ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version
2886 # numbers can be used in ld.so.1 feature checks even if a different
2887 # linker is configured.
2888 ld_ver=`$gcc_cv_ld -V 2>&1`
2889 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2890 ld_vers=`echo $ld_ver | sed -n \
2891 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2892 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2893 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2901 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2902 [[if test $in_tree_ld = yes ; then
2904 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 \
2905 && test $in_tree_ld_is_elf = yes; then
2906 gcc_cv_ld_hidden=yes
2909 gcc_cv_ld_hidden=yes
2910 if test x"$ld_is_gold" = xyes; then
2912 elif echo "$ld_ver" | grep GNU > /dev/null; then
2913 if test 0"$ld_date" -lt 20020404; then
2914 if test -n "$ld_date"; then
2915 # If there was date string, but was earlier than 2002-04-04, fail
2917 elif test -z "$ld_vers"; then
2918 # If there was no date string nor ld version number, something is wrong
2921 test -z "$ld_vers_patch" && ld_vers_patch=0
2922 if test "$ld_vers_major" -lt 2; then
2924 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2925 gcc_cv_ld_hidden="no"
2926 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2934 gcc_cv_ld_hidden=yes
2937 # Darwin ld has some visibility support.
2938 gcc_cv_ld_hidden=yes
2940 hppa64*-*-hpux* | ia64*-*-hpux*)
2941 gcc_cv_ld_hidden=yes
2944 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2945 # .symbolic was only added in Solaris 9 12/02.
2946 gcc_cv_ld_hidden=yes
2954 libgcc_visibility=no
2955 AC_SUBST(libgcc_visibility)
2956 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2957 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2958 libgcc_visibility=yes
2959 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2960 [Define if your assembler and linker support .hidden.])
2963 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2964 gcc_cv_ld_ro_rw_mix=unknown
2965 if test $in_tree_ld = yes ; then
2966 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 \
2967 && test $in_tree_ld_is_elf = yes; then
2968 gcc_cv_ld_ro_rw_mix=read-write
2970 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2971 echo '.section myfoosect, "a"' > conftest1.s
2972 echo '.section myfoosect, "aw"' > conftest2.s
2973 echo '.byte 1' >> conftest2.s
2974 echo '.section myfoosect, "a"' > conftest3.s
2975 echo '.byte 0' >> conftest3.s
2976 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2977 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2978 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2979 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2980 conftest2.o conftest3.o > /dev/null 2>&1; then
2981 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2982 | sed -e '/myfoosect/!d' -e N`
2983 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2984 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2985 gcc_cv_ld_ro_rw_mix=read-only
2987 gcc_cv_ld_ro_rw_mix=read-write
2992 rm -f conftest.* conftest[123].*
2995 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2996 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2997 [Define if your linker links a mix of read-only
2998 and read-write sections into a read-write section.])
3000 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
3002 gcc_AC_INITFINI_ARRAY
3004 # Check if we have .[us]leb128, and support symbol arithmetic with it.
3005 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
3013 [[# GAS versions before 2.11 do not support uleb128,
3014 # despite appearing to.
3015 # ??? There exists an elf-specific test that will crash
3016 # the assembler. Perhaps it's better to figure out whether
3017 # arbitrary sections are supported and try the test.
3018 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
3019 if echo "$as_ver" | grep GNU > /dev/null; then
3020 as_vers=`echo $as_ver | sed -n \
3021 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3022 as_major=`expr "$as_vers" : '\([0-9]*\)'`
3023 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
3024 if test $as_major -eq 2 && test $as_minor -lt 11
3026 else gcc_cv_as_leb128=yes
3029 [AC_DEFINE(HAVE_AS_LEB128, 1,
3030 [Define if your assembler supports .sleb128 and .uleb128.])],
3031 [AC_DEFINE(HAVE_AS_LEB128, 0,
3032 [Define if your assembler supports .sleb128 and .uleb128.])])
3034 # Determine if an .eh_frame section is read-only.
3035 gcc_fn_eh_frame_ro () {
3036 $gcc_cv_as $1 -o conftest.o conftest.s > /dev/null 2>&1 && \
3037 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
3038 sed -e '/.eh_frame/!d' -e N | grep READONLY > /dev/null
3041 # Check if we have assembler support for unwind directives.
3042 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
3049 .cfi_escape 1, 2, 3, 4, 5
3053 # If the linker used on Solaris (like Sun ld) isn't capable of merging
3054 # read-only and read-write sections, we need to make sure that the
3055 # assembler used emits read-write .eh_frame sections.
3056 if test "x$gcc_cv_ld_ro_rw_mix" = xread-write; then
3057 gcc_cv_as_cfi_directive=yes
3058 elif test "x$gcc_cv_objdump" = x; then
3059 # No objdump, err on the side of caution.
3060 gcc_cv_as_cfi_directive=no
3062 if test x$gas = xyes; then
3070 sparc*-*-solaris2.*)
3071 # On Solaris/SPARC, .eh_frame sections should always be read-write.
3072 if gcc_fn_eh_frame_ro $as_32_opt \
3073 || gcc_fn_eh_frame_ro $as_64_opt; then
3074 gcc_cv_as_cfi_directive=no
3076 gcc_cv_as_cfi_directive=yes
3079 i?86-*-solaris2.* | x86_64-*-solaris2.*)
3080 # On Solaris/x86, make sure that GCC and assembler agree on using
3081 # read-only .eh_frame sections for 64-bit.
3082 if gcc_fn_eh_frame_ro $as_32_opt; then
3083 gcc_cv_as_cfi_directive=no
3084 elif gcc_fn_eh_frame_ro $as_64_opt; then
3085 gcc_cv_as_cfi_directive=yes
3087 gcc_cv_as_cfi_directive=no
3094 gcc_cv_as_cfi_directive=yes
3097 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
3098 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
3102 .cfi_adjust_cfa_offset 64
3104 .cfi_adjust_cfa_offset 128
3107 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
3108 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
3109 gcc_cv_as_cfi_advance_working=yes
3113 # no objdump, err on the side of caution
3114 gcc_cv_as_cfi_advance_working=no
3116 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
3117 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
3118 [`if test $gcc_cv_as_cfi_directive = yes \
3119 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
3120 [Define 0/1 if your assembler supports CFI directives.])
3122 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
3123 gcc_GAS_CHECK_FEATURE([cfi personality directive],
3124 gcc_cv_as_cfi_personality_directive, ,,
3127 .cfi_personality 0, symbol
3129 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
3130 [`if test $gcc_cv_as_cfi_personality_directive = yes; then echo 1; else echo 0; fi`],
3131 [Define 0/1 if your assembler supports .cfi_personality.])
3133 gcc_GAS_CHECK_FEATURE([cfi sections directive],
3134 gcc_cv_as_cfi_sections_directive, ,,
3136 .cfi_sections .debug_frame, .eh_frame
3140 win32 | pe | cygwin* | mingw32*)
3141 # Need to check that we generated the correct relocation for the
3142 # .debug_frame section. This was fixed for binutils 2.21.
3143 gcc_cv_as_cfi_sections_directive=no
3144 if test "x$gcc_cv_objdump" != x; then
3145 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
3146 grep secrel > /dev/null; then
3147 gcc_cv_as_cfi_sections_directive=yes
3152 gcc_cv_as_cfi_sections_directive=yes
3155 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
3156 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
3157 [`if test $gcc_cv_as_cfi_sections_directive = yes; then echo 1; else echo 0; fi`],
3158 [Define 0/1 if your assembler supports .cfi_sections.])
3160 # GAS versions up to and including 2.11.0 may mis-optimize
3162 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
3170 .section .eh_frame,"aw",@progbits
3172 .4byte .LECIE1-.LSCIE1
3186 .4byte .LEFDE1-.LASFDE1
3188 .4byte .LASFDE1-__FRAME_BEGIN__
3196 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
3197 cat > conftest.lit <<EOF
3198 0000 10000000 00000000 017a0001 781a0004 .........z..x...
3199 0010 01000000 12000000 18000000 00000000 ................
3200 0020 08000000 04080000 0044 .........D @&t@
3202 cat > conftest.big <<EOF
3203 0000 00000010 00000000 017a0001 781a0004 .........z..x...
3204 0010 00000001 00000012 00000018 00000000 ................
3205 0020 00000008 04000000 0844 .........D @&t@
3207 # If the assembler didn't choke, and we can objdump,
3208 # and we got the correct data, then succeed.
3209 # The text in the here-document typically retains its unix-style line
3210 # endings, while the output of objdump will use host line endings.
3211 # Therefore, use diff -b for the comparisons.
3212 if test x$gcc_cv_objdump != x \
3213 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
3214 | tail -3 > conftest.got \
3215 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
3216 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
3218 gcc_cv_as_eh_frame=yes
3219 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
3220 gcc_cv_as_eh_frame=buggy
3222 # Uh oh, what do we do now?
3223 gcc_cv_as_eh_frame=no
3226 if test $gcc_cv_as_eh_frame = buggy; then
3227 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
3228 [Define if your assembler mis-optimizes .eh_frame data.])
3231 # Test if the assembler supports the section flag 'e' or #exclude for
3232 # specifying an excluded section.
3233 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_e,
3234 [2,22,51], [--fatal-warnings],
3237 if test $gcc_cv_as_section_exclude_e = no; then
3239 # Solaris as uses #exclude instead.
3243 conftest_s='.section "foo1", #exclude'
3245 i?86-*-solaris2* | x86_64-*-solaris2*)
3246 conftest_s='.section foo1, #exclude'
3251 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_hash,,,
3255 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3256 [`if test $gcc_cv_as_section_exclude_e = yes || test $gcc_cv_as_section_exclude_hash = yes; then echo 1; else echo 0; fi`],
3257 [Define if your assembler supports specifying the exclude section flag.])
3259 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3260 [elf,2,12,0], [--fatal-warnings],
3261 [.section .rodata.str, "aMS", @progbits, 1])
3262 if test $gcc_cv_as_shf_merge = no; then
3263 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3264 [elf,2,12,0], [--fatal-warnings],
3265 [.section .rodata.str, "aMS", %progbits, 1])
3267 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
3268 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
3269 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
3271 gcc_cv_ld_aligned_shf_merge=yes
3273 # SHF_MERGE support is broken in Solaris ld up to Solaris 11.3/SPARC for
3275 sparc*-*-solaris2.11*)
3276 if test x"$gnu_ld" = xno \
3277 && test "$ld_vers_major" -lt 2 && test "$ld_vers_minor" -lt 3159; then
3278 gcc_cv_ld_aligned_shf_merge=no
3282 AC_DEFINE_UNQUOTED(HAVE_LD_ALIGNED_SHF_MERGE,
3283 [`if test $gcc_cv_ld_aligned_shf_merge = yes; then echo 1; else echo 0; fi`],
3284 [Define 0/1 if your linker supports the SHF_MERGE flag with section alignment > 1.])
3286 gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,,
3287 [.stabs "gcc2_compiled.",60,0,0,0],,
3288 [AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1,
3289 [Define if your assembler supports .stabs.])])
3291 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
3292 gcc_cv_as_comdat_group,
3293 [elf,2,16,0], [--fatal-warnings],
3294 [.section .text,"axG",@progbits,.foo,comdat])
3295 if test $gcc_cv_as_comdat_group = yes; then
3296 gcc_cv_as_comdat_group_percent=no
3297 gcc_cv_as_comdat_group_group=no
3299 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
3300 gcc_cv_as_comdat_group_percent,
3301 [elf,2,16,0], [--fatal-warnings],
3302 [.section .text,"axG",%progbits,.foo,comdat])
3303 if test $gcc_cv_as_comdat_group_percent = yes; then
3304 gcc_cv_as_comdat_group_group=no
3307 # Sun as uses a completely different syntax.
3312 .group foo,".text%foo",#comdat
3313 .section ".text%foo", #alloc,#execinstr,#progbits
3318 i?86-*-solaris2* | x86_64-*-solaris2*)
3320 .group foo,.text%foo,#comdat
3321 .section .text%foo, "ax", @progbits
3327 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
3328 gcc_cv_as_comdat_group_group,
3332 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
3333 gcc_cv_as_comdat_group_group=no
3337 if test x"$ld_is_gold" = xyes; then
3339 elif test $in_tree_ld = yes ; then
3341 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 \
3342 && test $in_tree_ld_is_elf = yes; then
3345 elif echo "$ld_ver" | grep GNU > /dev/null; then
3347 if test 0"$ld_date" -lt 20050308; then
3348 if test -n "$ld_date"; then
3349 # If there was date string, but was earlier than 2005-03-08, fail
3351 elif test "$ld_vers_major" -lt 2; then
3353 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
3360 *-*-solaris2.1[1-9]*)
3362 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
3363 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
3366 # If using Sun as for COMDAT group as emitted by GCC, one needs at
3367 # least ld version 1.2267.
3368 if test "$ld_vers_major" -gt 1; then
3370 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
3372 elif test "$ld_vers_minor" -ge 2267; then
3377 # Assume linkers other than GNU ld don't support COMDAT group.
3383 # Allow overriding the automatic COMDAT group tests above.
3384 AC_ARG_ENABLE(comdat,
3385 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
3386 [comdat_group="$enable_comdat"])
3387 if test $comdat_group = no; then
3388 gcc_cv_as_comdat_group=no
3389 gcc_cv_as_comdat_group_percent=no
3390 gcc_cv_as_comdat_group_group=no
3392 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
3393 [`if test $gcc_cv_as_comdat_group = yes \
3394 || test $gcc_cv_as_comdat_group_percent = yes \
3395 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
3396 [Define 0/1 if your assembler and linker support COMDAT groups.])
3398 # Restrict this test to Solaris/x86: other targets define this statically.
3400 i?86-*-solaris2* | x86_64-*-solaris2*)
3401 AC_MSG_CHECKING(support for hidden thunks in linkonce sections)
3402 if test $in_tree_ld = yes || echo "$ld_ver" | grep GNU > /dev/null; then
3406 # Full support for hidden thunks in linkonce sections only appeared in
3407 # Solaris 11/OpenSolaris.
3408 *-*-solaris2.1[[1-9]]*)
3416 AC_MSG_RESULT($hidden_linkonce)
3417 AC_DEFINE_UNQUOTED(USE_HIDDEN_LINKONCE,
3418 [`if test $hidden_linkonce = yes; then echo 1; else echo 0; fi`],
3419 [Define 0/1 if your linker supports hidden thunks in linkonce sections.])
3423 gcc_GAS_CHECK_FEATURE([line table is_stmt support],
3428 .loc 1 1 0 is_stmt 1],,
3429 [AC_DEFINE(HAVE_GAS_LOC_STMT, 1,
3430 [Define if your assembler supports the .loc is_stmt sub-directive.])])
3432 gcc_GAS_CHECK_FEATURE([line table discriminator support],
3433 gcc_cv_as_discriminator,
3437 .loc 1 1 0 discriminator 1],,
3438 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
3439 [Define if your assembler supports the .loc discriminator sub-directive.])])
3441 # Catch the newlib flag of the same name so we can gate GCC features on it.
3442 AC_ARG_ENABLE(newlib-nano-formatted-io,
3443 [AS_HELP_STRING([--enable-newlib-nano-formatted-io], [Use nano version
3445 [case "${enableval}" in
3449 AC_MSG_ERROR([unknown newlib-nano-formatted-io setting $enableval])
3453 # Thread-local storage - the check is heavily parameterized.
3462 .section ".tdata","awT",@progbits
3465 ldq $27,__tls_get_addr($29) !literal!1
3466 lda $16,foo($29) !tlsgd!1
3467 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3468 ldq $27,__tls_get_addr($29) !literal!2
3469 lda $16,foo($29) !tlsldm!2
3470 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
3471 ldq $1,foo($29) !gotdtprel
3472 ldah $2,foo($29) !dtprelhi
3473 lda $3,foo($2) !dtprello
3474 lda $4,foo($29) !dtprel
3475 ldq $1,foo($29) !gottprel
3476 ldah $2,foo($29) !tprelhi
3477 lda $3,foo($2) !tprello
3478 lda $4,foo($29) !tprel'
3481 tls_as_opt=--fatal-warnings
3485 add_s r0,r0, @foo@tpoff'
3489 cris-*-*|crisv32-*-*)
3491 .section ".tdata","awT",@progbits
3498 tls_as_opt=--fatal-warnings
3502 .section ".tdata","awT",@progbits
3514 .section ".tdata","awT",@progbits
3518 addil LT%foo-$tls_gdidx$,gp
3519 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3522 addil LT%foo-$tls_ldidx$,gp
3524 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3525 addil LR%foo-$tls_dtpoff$,%ret0
3526 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3528 addil LT%foo-$tls_ieoff$,gp
3529 ldw RT%foo-$tls_ieoff$(%r1),%t2
3532 addil LR%foo-$tls_leoff$,%t1
3533 ldo RR%foo-$tls_leoff$(%r1),%t2'
3536 tls_as_opt=--fatal-warnings
3540 .section ".tdata","awT",%progbits
3551 i[34567]86-*-* | x86_64-*-*)
3553 i[34567]86-*-solaris2.* | x86_64-*-solaris2.*)
3560 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3562 .section .tdata,"awt",@progbits'
3567 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3568 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3572 .section ".tdata","awT",@progbits'
3576 tls_as_opt="--fatal-warnings"
3580 if test x$on_solaris = xyes; then
3582 yes) tls_as_opt="$tls_as_opt --32" ;;
3585 conftest_s="$conftest_s
3589 leal foo@tlsgd(,%ebx,1), %eax
3590 leal foo@tlsldm(%ebx), %eax
3591 leal foo@dtpoff(%eax), %edx
3592 movl foo@gottpoff(%ebx), %eax
3593 subl foo@gottpoff(%ebx), %eax
3594 addl foo@gotntpoff(%ebx), %eax
3595 movl foo@indntpoff, %eax
3596 movl \$foo@tpoff, %eax
3597 subl \$foo@tpoff, %eax
3598 leal foo@ntpoff(%ecx), %eax"
3601 if test x$on_solaris = xyes; then
3603 yes) tls_as_opt="$tls_as_opt --64" ;;
3604 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3607 conftest_s="$conftest_s
3611 leaq foo@tlsgd(%rip), %rdi
3612 leaq foo@tlsld(%rip), %rdi
3613 leaq foo@dtpoff(%rax), %rdx
3614 movq foo@gottpoff(%rip), %rax
3615 movq \$foo@tpoff, %rax"
3621 .section ".tdata","awT",@progbits
3624 addl r16 = @ltoff(@dtpmod(foo#)), gp
3625 addl r17 = @ltoff(@dtprel(foo#)), gp
3626 addl r18 = @ltoff(@tprel(foo#)), gp
3627 addl r19 = @dtprel(foo#), gp
3628 adds r21 = @dtprel(foo#), r13
3629 movl r23 = @dtprel(foo#)
3630 addl r20 = @tprel(foo#), gp
3631 adds r22 = @tprel(foo#), r13
3632 movl r24 = @tprel(foo#)'
3635 tls_as_opt=--fatal-warnings
3639 .section .tdata,"awT",@progbits
3643 addik r5,r20,x@TLSGD
3644 addik r5,r20,x@TLSLDM'
3647 tls_as_opt='--fatal-warnings'
3651 .section .tdata,"awT",@progbits
3655 addiu $4, $28, %tlsgd(x)
3656 addiu $4, $28, %tlsldm(x)
3657 lui $4, %dtprel_hi(x)
3658 addiu $4, $4, %dtprel_lo(x)
3659 lw $4, %gottprel(x)($28)
3660 lui $4, %tprel_hi(x)
3661 addiu $4, $4, %tprel_lo(x)'
3664 tls_as_opt='-32 --fatal-warnings'
3668 .section .tdata,"awT",@progbits
3673 move.l x@TLSGD(%a5),%a0
3674 move.l x@TLSLDM(%a5),%a0
3675 move.l x@TLSLDO(%a5),%a0
3676 move.l x@TLSIE(%a5),%a0
3677 move.l x@TLSLE(%a5),%a0'
3680 tls_as_opt='--fatal-warnings'
3684 .section ".tdata","awT",@progbits'
3687 tls_as_opt="--fatal-warnings"
3691 .section ".tdata","awT",%progbits
3695 add x0, x0, #:tlsgd_lo12:x
3700 tls_as_opt='--fatal-warnings'
3704 .section ".tdata","awT",@progbits
3707 l.movhi r3, tpoffha(foo)
3709 l.lwz r4, tpofflo(foo)(r3)'
3712 tls_as_opt=--fatal-warnings
3716 .extern __get_tpointer
3734 .section ".tdata","awT",@progbits
3742 addi 3,2,ld0@got@tlsgd
3748 addi 3,2,x1@got@tlsld
3754 addis 9,3,x2@dtprel@ha
3755 addi 9,9,x2@dtprel@l
3758 ld 9,x3@got@dtprel(2)
3764 tls_as_opt="-a64 --fatal-warnings"
3768 .section ".tdata","awT",@progbits
3776 addi 3,31,ld0@got@tlsgd
3778 addi 3,31,x1@got@tlsld
3781 addis 9,3,x2@dtprel@ha
3782 addi 9,9,x2@dtprel@l
3783 lwz 9,x3@got@tprel(31)
3786 addis 9,2,x2@tprel@ha
3787 addi 9,9,x2@tprel@l'
3790 tls_as_opt="-a32 --fatal-warnings"
3794 .section .tdata,"awT",@progbits
3798 call __tls_get_addr'
3801 tls_as_opt='--fatal-warnings'
3805 .section ".tdata","awT",@progbits
3814 l %r1,foo@GOTNTPOFF(%r12)
3815 l %r1,0(%r1):tls_load:foo
3816 bas %r14,0(%r1,%r13):tls_gdcall:foo
3817 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3820 tls_as_opt="-m31 --fatal-warnings"
3824 .section ".tdata","awT",@progbits
3832 lg %r1,foo@GOTNTPOFF(%r12)
3833 larl %r1,foo@INDNTPOFF
3834 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3835 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3838 tls_as_opt="-m64 -Aesame --fatal-warnings"
3840 sh-*-* | sh[123456789lbe]*-*-*)
3842 .section ".tdata","awT",@progbits
3852 tls_as_opt=--fatal-warnings
3856 sparc*-sun-solaris2.*)
3863 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3865 .section ".tdata",#alloc,#write,#tls'
3870 .section ".tdata","awT",@progbits'
3873 tls_as_opt="-32 --fatal-warnings"
3875 conftest_s="$conftest_s
3878 sethi %tgd_hi22(foo), %o0
3879 add %o0, %tgd_lo10(foo), %o1
3880 add %l7, %o1, %o0, %tgd_add(foo)
3881 call __tls_get_addr, %tgd_call(foo)
3882 sethi %tldm_hi22(foo), %l1
3883 add %l1, %tldm_lo10(foo), %l2
3884 add %l7, %l2, %o0, %tldm_add(foo)
3885 call __tls_get_addr, %tldm_call(foo)
3886 sethi %tldo_hix22(foo), %l3
3887 xor %l3, %tldo_lox10(foo), %l4
3888 add %o0, %l4, %l5, %tldo_add(foo)
3889 sethi %tie_hi22(foo), %o3
3890 add %o3, %tie_lo10(foo), %o3
3891 ld [%l7 + %o3], %o2, %tie_ld(foo)
3892 add %g7, %o2, %o4, %tie_add(foo)
3893 sethi %tle_hix22(foo), %l1
3894 xor %l1, %tle_lox10(foo), %o5
3895 ld [%g7 + %o5], %o1"
3899 .section ".tdata","awT",@progbits
3902 addli r0, zero, tls_gd(foo)
3903 auli r0, zero, tls_gd_ha16(foo)
3904 addli r0, r0, tls_gd_lo16(foo)
3906 addli r0, zero, tls_ie(foo)
3907 auli r0, r0, tls_ie_ha16(foo)
3908 addli r0, r0, tls_ie_lo16(foo)'
3911 tls_as_opt="--fatal-warnings"
3915 .section ".tdata","awT",@progbits
3918 shl16insli r0, zero, hw0_last_tls_gd(foo)
3919 shl16insli r0, zero, hw1_last_tls_gd(foo)
3920 shl16insli r0, r0, hw0_tls_gd(foo)
3922 shl16insli r0, zero, hw1_last_tls_ie(foo)
3923 shl16insli r0, r0, hw0_tls_ie(foo)'
3926 tls_as_opt="--fatal-warnings"
3930 .section ".tdata","awT",@progbits
3933 movi a8, foo@TLSFUNC
3934 movi a10, foo@TLSARG
3935 callx8.tls a8, foo@TLSCALL'
3942 if test "x$enable_tls" = xno ; then
3943 : # TLS explicitly disabled.
3944 elif test "x$enable_tls" = xyes ; then
3945 set_have_as_tls=yes # TLS explicitly enabled.
3946 elif test -z "$tls_first_major"; then
3947 : # If we don't have a check, assume no support.
3949 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3950 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3951 [set_have_as_tls=yes])
3953 if test $set_have_as_tls = yes ; then
3954 AC_DEFINE(HAVE_AS_TLS, 1,
3955 [Define if your assembler and linker support thread-local storage.])
3958 # Target-specific assembler checks.
3960 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3961 gcc_cv_ld_static_dynamic=no
3962 gcc_cv_ld_static_option='-Bstatic'
3963 gcc_cv_ld_dynamic_option='-Bdynamic'
3964 if test $in_tree_ld = yes ; then
3965 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
3966 gcc_cv_ld_static_dynamic=yes
3968 elif test x$gcc_cv_ld != x; then
3969 # Check if linker supports -Bstatic/-Bdynamic option
3970 if $gcc_cv_ld --help 2>&1 | grep -- -Bstatic > /dev/null \
3971 && $gcc_cv_ld --help 2>&1 | grep -- -Bdynamic > /dev/null; then
3972 gcc_cv_ld_static_dynamic=yes
3975 # AIX ld uses -b flags
3976 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3977 gcc_cv_ld_static_dynamic=yes
3978 gcc_cv_ld_static_option="-bstatic"
3979 gcc_cv_ld_dynamic_option="-bdynamic"
3981 # HP-UX ld uses -a flags to select between shared and archive.
3983 if test x"$gnu_ld" = xno; then
3984 gcc_cv_ld_static_dynamic=yes
3985 gcc_cv_ld_static_option="-aarchive_shared"
3986 gcc_cv_ld_dynamic_option="-adefault"
3989 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3991 gcc_cv_ld_static_dynamic=yes
3996 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3997 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3998 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3999 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
4000 [Define to the linker option to disable use of shared objects.])
4001 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
4002 [Define to the linker option to enable use of shared objects.])
4004 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
4006 AC_MSG_CHECKING(linker --version-script option)
4007 gcc_cv_ld_version_script=no
4008 ld_version_script_option=''
4009 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4010 gcc_cv_ld_version_script=yes
4011 ld_version_script_option='--version-script'
4012 elif test x$gcc_cv_ld != x; then
4014 # Solaris 2 ld always supports -M. It also supports a subset of
4015 # --version-script since Solaris 11.4, but requires
4016 # -z gnu-version-script-compat to activate.
4018 gcc_cv_ld_version_script=yes
4019 ld_version_script_option='-M'
4023 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4024 AC_MSG_RESULT($gcc_cv_ld_version_script)
4025 AC_SUBST(ld_version_script_option)
4027 AC_MSG_CHECKING(linker soname option)
4029 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4030 gcc_cv_ld_soname=yes
4031 ld_soname_option='-soname'
4032 elif test x$gcc_cv_ld != x; then
4035 gcc_cv_ld_soname=yes
4036 ld_soname_option='-install_name'
4038 # Solaris 2 ld always supports -h. It also supports --soname for GNU
4039 # ld compatiblity since some Solaris 10 update.
4041 gcc_cv_ld_soname=yes
4042 ld_soname_option='-h'
4046 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4047 AC_MSG_RESULT($gcc_cv_ld_soname)
4048 AC_SUBST(ld_soname_option)
4050 if test x"$demangler_in_ld" = xyes; then
4051 AC_MSG_CHECKING(linker --demangle support)
4052 gcc_cv_ld_demangle=no
4053 if test $in_tree_ld = yes; then
4054 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 \
4055 gcc_cv_ld_demangle=yes
4057 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
4058 # Check if the GNU linker supports --demangle option
4059 if $gcc_cv_ld --help 2>&1 | grep no-demangle > /dev/null; then
4060 gcc_cv_ld_demangle=yes
4063 if test x"$gcc_cv_ld_demangle" = xyes; then
4064 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
4065 [Define if your linker supports --demangle option.])
4067 AC_MSG_RESULT($gcc_cv_ld_demangle)
4070 AC_MSG_CHECKING(linker plugin support)
4072 if test -f liblto_plugin.la; then
4073 save_ld_ver="$ld_ver"
4074 save_ld_vers_major="$ld_vers_major"
4075 save_ld_vers_minor="$ld_vers_minor"
4076 save_ld_is_gold="$ld_is_gold"
4080 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
4082 # FIXME: ld_is_gold?
4083 ld_vers_major="$gcc_cv_gld_major_version"
4084 ld_vers_minor="$gcc_cv_gld_minor_version"
4086 # Determine plugin linker version.
4087 # FIXME: Partial duplicate from above, generalize.
4089 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
4090 if echo "$ld_ver" | grep GNU > /dev/null; then
4091 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
4093 ld_vers=`echo $ld_ver | sed -n \
4094 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
4096 ld_vers=`echo $ld_ver | sed -n \
4097 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
4099 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
4100 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
4105 # Determine plugin support.
4106 if echo "$ld_ver" | grep GNU > /dev/null; then
4107 # Require GNU ld or gold 2.21+ for plugin support by default.
4108 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
4110 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
4111 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
4116 ld_ver="$save_ld_ver"
4117 ld_vers_major="$save_ld_vers_major"
4118 ld_vers_minor="$save_ld_vers_minor"
4119 ld_is_gold="$save_ld_is_gold"
4121 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
4122 [Define to the level of your linker's plugin support.])
4123 AC_MSG_RESULT($gcc_cv_lto_plugin)
4125 # Target OS-specific assembler checks.
4127 case "$target_os" in
4129 gcc_GAS_CHECK_FEATURE([-mmacosx-version-min option],
4130 gcc_cv_as_mmacosx_version_min,,
4131 [-mmacosx-version-min=10.1], [.text],,
4132 [AC_DEFINE(HAVE_AS_MMACOSX_VERSION_MIN_OPTION, 1,
4133 [Define if your Mac OS X assembler supports the -mmacos-version-min option.])])
4137 # Target CPU-specific assembler checks.
4141 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
4142 [-mabi=lp64], [.text],,,)
4143 if test x$gcc_cv_as_aarch64_mabi = xyes; then
4144 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
4145 [Define if your assembler supports the -mabi option.])
4147 if test x$with_abi = xilp32; then
4148 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4149 Upgrade the Assembler.])
4151 if test x"$with_multilib_list" = xdefault; then
4152 TM_MULTILIB_CONFIG=lp64
4154 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
4155 for aarch64_multilib in ${aarch64_multilibs}; do
4156 case ${aarch64_multilib} in
4158 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4159 Upgrade the Assembler.])
4167 # Check if we have binutils support for relocations types needed by -fpic
4168 gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,,
4171 ldr x0, [[x2, #:gotpage_lo15:globalsym]]
4172 ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1,
4173 [Define if your assembler supports relocs needed by -fpic.])])
4174 # Enable Branch Target Identification Mechanism and Return Address
4175 # Signing by default.
4176 AC_ARG_ENABLE(standard-branch-protection,
4178 AS_HELP_STRING([--enable-standard-branch-protection],
4179 [enable Branch Target Identification Mechanism and Return Address Signing by default for AArch64])
4180 AS_HELP_STRING([--disable-standard-branch-protection],
4181 [disable Branch Target Identification Mechanism and Return Address Signing by default for AArch64])
4186 tm_defines="${tm_defines} TARGET_ENABLE_BTI=1 TARGET_ENABLE_PAC_RET=1"
4191 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-standard-branch-protection.\
4192 Valid choices are 'yes' and 'no'.])
4197 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
4198 AC_ARG_ENABLE(fix-cortex-a53-835769,
4200 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
4201 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4202 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
4203 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4208 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
4213 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
4214 Valid choices are 'yes' and 'no'.])
4220 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
4221 AC_ARG_ENABLE(fix-cortex-a53-843419,
4223 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
4224 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4225 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
4226 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4231 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
4236 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
4237 Valid choices are 'yes' and 'no'.])
4245 # All TARGET_ABI_OSF targets.
4246 alpha*-*-linux* | alpha*-*-*bsd*)
4247 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4248 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
4251 extbl $3, $2, $3 !lituse_bytoff!1
4252 ldq $2, a($29) !literal!1
4253 ldq $4, b($29) !literal!2
4254 ldq_u $3, 0($2) !lituse_base!1
4255 ldq $27, f($29) !literal!5
4256 jsr $26, ($27), f !lituse_jsr!5
4257 ldah $29, 0($26) !gpdisp!3
4258 lda $0, c($29) !gprel
4259 ldah $1, d($29) !gprelhigh
4260 lda $1, d($1) !gprellow
4261 lda $29, 0($29) !gpdisp!3],,
4262 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
4263 [Define if your assembler supports explicit relocations.])])
4264 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
4265 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
4268 ldq $27, a($29) !literal!1
4269 jsr $26, ($27), a !lituse_jsrdirect!1],,
4270 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
4271 [Define if your assembler supports the lituse_jsrdirect relocation.])])
4275 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,,
4276 [--mlink-relax], [.text],,
4277 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
4278 [Define if your avr assembler supports --mlink-relax option.])])
4280 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,,
4282 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
4283 [Define if your avr assembler supports -mrmw option.])])
4285 gcc_GAS_CHECK_FEATURE([__gcc_isr pseudo instruction],
4286 gcc_cv_as_avr_mgccisr,,
4292 [AC_DEFINE(HAVE_AS_AVR_MGCCISR_OPTION, 1,
4293 [Define if your avr assembler supports -mgcc-isr option.])])
4295 # Check how default linker description file implements .rodata for
4296 # avrxmega3 (PR21472). avr-gcc assumes .rodata is *not* loaded to
4297 # RAM so avr-gcc skips __do_copy_data for .rodata objects.
4298 AC_MSG_CHECKING(binutils for avrxmega3 .rodata support)
4299 cat > conftest.s <<EOF
4300 .section .rodata,"a",@progbits
4302 ;; avr-nm should print "... R xxvaryy", not "... D xxvaryy".
4307 AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega3 conftest.s -o conftest.o])
4308 AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega3 conftest.o -o conftest.elf])
4309 AC_TRY_COMMAND([$gcc_cv_nm conftest.elf > conftest.nm])
4310 if test -s conftest.nm
4312 if grep ' R xxvaryy' conftest.nm > /dev/null; then
4314 AC_DEFINE(HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH, 1,
4315 [Define if your default avr linker script for avrxmega3 leaves .rodata in flash.])
4317 AC_MSG_RESULT(no: avrxmega3 .rodata located in RAM)
4318 echo "$as_me: nm output was" >&AS_MESSAGE_LOG_FD
4319 cat conftest.nm >&AS_MESSAGE_LOG_FD
4320 avr_ld_ver="`$gcc_cv_ld -v | sed -e 's:^.* ::'`"
4321 AC_MSG_WARN([[support for avrxmega3 .rodata in flash needs Binutils 2.29 or higher (have $avr_ld_ver)]])
4324 AC_MSG_RESULT(test failed)
4325 echo "$as_me: failed program was" >&AS_MESSAGE_LOG_FD
4326 cat conftest.s >&AS_MESSAGE_LOG_FD
4327 AC_MSG_WARN([[see `config.log' for details]])
4329 rm -f conftest.s conftest.o conftest.elf conftest.nm
4333 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
4334 gcc_cv_as_cris_no_mul_bug,[2,15,91],
4335 [-no-mul-bug-abort], [.text],,
4336 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
4337 [Define if your assembler supports the -no-mul-bug-abort option.])])
4341 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
4343 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
4344 [Define if your assembler supports -relax option.])])
4346 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
4347 gcc_cv_as_sparc_gotdata_op,,
4354 sethi %gdop_hix22(foo), %g1
4355 xor %g1, %gdop_lox10(foo), %g1
4356 ld [[%l7 + %g1]], %g2, %gdop(foo)],
4357 [if test x$gcc_cv_ld != x \
4358 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4359 if test x$gcc_cv_objdump != x; then
4360 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
4361 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
4362 gcc_cv_as_sparc_gotdata_op=no
4364 gcc_cv_as_sparc_gotdata_op=yes
4369 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
4370 [Define if your assembler and linker support GOTDATA_OP relocs.])])
4372 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
4373 gcc_cv_as_sparc_ua_pcrel,,
4381 .uaword %r_disp32(foo)],
4382 [if test x$gcc_cv_ld != x \
4383 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4384 gcc_cv_as_sparc_ua_pcrel=yes
4387 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
4388 [Define if your assembler and linker support unaligned PC relative relocs.])
4390 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
4391 gcc_cv_as_sparc_ua_pcrel_hidden,,
4396 .uaword %r_disp32(foo)
4397 .byte 0x32, 0x33, 0x34
4402 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4403 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
4404 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
4405 | grep ' 31000000 07323334' > /dev/null 2>&1; then
4406 if $gcc_cv_objdump -R conftest 2> /dev/null \
4407 | grep 'DISP32' > /dev/null 2>&1; then
4410 gcc_cv_as_sparc_ua_pcrel_hidden=yes
4414 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
4415 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
4416 ]) # unaligned pcrel relocs
4418 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
4419 gcc_cv_as_sparc_offsetable_lo10,,
4422 or %g1, %lo(ab) + 12, %g1
4423 or %g1, %lo(ab + 12), %g1],
4424 [if test x$gcc_cv_objdump != x \
4425 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
4426 | grep ' 82106000 82106000' > /dev/null 2>&1; then
4427 gcc_cv_as_sparc_offsetable_lo10=yes
4429 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
4430 [Define if your assembler supports offsetable %lo().])])
4432 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
4433 gcc_cv_as_sparc_fmaf,,
4436 .register %g2, #scratch
4437 .register %g3, #scratch
4439 fmaddd %f0, %f2, %f4, %f6
4440 addxccc %g1, %g2, %g3
4441 fsrl32 %f2, %f4, %f8
4442 fnaddd %f10, %f12, %f14],,
4443 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
4444 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
4446 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
4447 gcc_cv_as_sparc_sparc4,,
4450 .register %g2, #scratch
4451 .register %g3, #scratch
4454 1: cwbneg %g2, %g3, 1f
4457 aes_kexpand0 %f4, %f6, %f8
4458 des_round %f38, %f40, %f42, %f44
4459 camellia_f %f54, %f56, %f58, %f60
4460 kasumi_fi_xor %f46, %f48, %f50, %f52],,
4461 [AC_DEFINE(HAVE_AS_SPARC4, 1,
4462 [Define if your assembler supports SPARC4 instructions.])])
4464 gcc_GAS_CHECK_FEATURE([SPARC5 and VIS 4.0 instructions],
4465 gcc_cv_as_sparc_sparc5,,
4468 .register %g2, #scratch
4469 .register %g3, #scratch
4472 fpadd8 %f0, %f2, %f4],,
4473 [AC_DEFINE(HAVE_AS_SPARC5_VIS4, 1,
4474 [Define if your assembler supports SPARC5 and VIS 4.0 instructions.])])
4476 gcc_GAS_CHECK_FEATURE([SPARC6 instructions],
4477 gcc_cv_as_sparc_sparc6,,
4480 .register %g2, #scratch
4481 .register %g3, #scratch
4484 fpsll64x %f0, %f2, %f4],,
4485 [AC_DEFINE(HAVE_AS_SPARC6, 1,
4486 [Define if your assembler supports SPARC6 instructions.])])
4488 gcc_GAS_CHECK_FEATURE([LEON instructions],
4489 gcc_cv_as_sparc_leon,,
4492 .register %g2, #scratch
4493 .register %g3, #scratch
4497 casa [[%g2]] 0xb, %g3, %g1],,
4498 [AC_DEFINE(HAVE_AS_LEON, 1,
4499 [Define if your assembler supports LEON instructions.])])
4503 i[34567]86-*-* | x86_64-*-*)
4507 # Full C++ conformance when using a shared libstdc++-v3 requires some
4508 # support from the Cygwin DLL, which in more recent versions exports
4509 # wrappers to aid in interposing and redirecting operators new, delete,
4510 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
4511 # are configuring for a version of Cygwin that exports the wrappers.
4512 if test x$host = x$target && test x$host_cpu = xi686; then
4513 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
4515 # Can't check presence of libc functions during cross-compile, so
4516 # we just have to assume we're building for an up-to-date target.
4517 gcc_ac_cygwin_dll_wrappers=yes
4519 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
4520 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
4521 [Define if you want to generate code by default that assumes that the
4522 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
4525 cygwin* | pe | mingw32*)
4526 # Recent binutils allows the three-operand form of ".comm" on PE. This
4527 # definition is used unconditionally to initialise the default state of
4528 # the target option variable that governs usage of the feature.
4529 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
4530 [2,19,52],,[.comm foo,1,32])
4531 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
4532 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
4533 [Define if your assembler supports specifying the alignment
4534 of objects allocated using the GAS .comm command.])
4535 # Used for DWARF 2 in PE
4536 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
4537 gcc_cv_as_ix86_pe_secrel32,
4543 [if test x$gcc_cv_ld != x \
4544 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
4545 gcc_cv_as_ix86_pe_secrel32=yes
4548 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
4549 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
4550 # Test if the assembler supports the extended form of the .section
4551 # directive that specifies section alignment. LTO support uses this,
4552 # but normally only after installation, so we warn but don't fail the
4553 # configure if LTO is enabled but the assembler does not support it.
4554 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
4555 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
4556 if test x$gcc_cv_as_section_has_align != xyes; then
4557 case ",$enable_languages," in
4559 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
4566 gcc_GAS_CHECK_FEATURE([-xbrace_comment], gcc_cv_as_ix86_xbrace_comment,,
4567 [-xbrace_comment=no], [.text],,
4568 [AC_DEFINE(HAVE_AS_XBRACE_COMMENT_OPTION, 1,
4569 [Define if your assembler supports -xbrace_comment option.])])
4571 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
4572 gcc_cv_as_ix86_filds,,,
4573 [filds (%ebp); fists (%ebp)],,
4574 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
4575 [Define if your assembler uses filds and fists mnemonics.])])
4577 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
4578 gcc_cv_as_ix86_fildq,,,
4579 [fildq (%ebp); fistpq (%ebp)],,
4580 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
4581 [Define if your assembler uses fildq and fistq mnemonics.])])
4583 gcc_GAS_CHECK_FEATURE([cmov syntax],
4584 gcc_cv_as_ix86_cmov_sun_syntax,,,
4585 [cmovl.l %edx, %eax],,
4586 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
4587 [Define if your assembler supports the Sun syntax for cmov.])])
4589 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
4590 gcc_cv_as_ix86_ffreep,,,
4592 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
4593 [Define if your assembler supports the ffreep mnemonic.])])
4595 gcc_GAS_CHECK_FEATURE([.quad directive],
4596 gcc_cv_as_ix86_quad,,,
4598 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
4599 [Define if your assembler supports the .quad directive.])])
4601 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
4602 gcc_cv_as_ix86_sahf,,,
4605 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
4606 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
4608 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
4609 gcc_cv_as_ix86_interunit_movq,,,
4613 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
4614 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
4615 [Define if your assembler supports interunit movq mnemonic.])
4617 gcc_GAS_CHECK_FEATURE([hle prefixes],
4618 gcc_cv_as_ix86_hle,,,
4619 [lock xacquire cmpxchg %esi, (%ecx)],,
4620 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
4621 [Define if your assembler supports HLE prefixes.])])
4623 gcc_GAS_CHECK_FEATURE([swap suffix],
4624 gcc_cv_as_ix86_swap,,,
4625 [movl.s %esp, %ebp],,
4626 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
4627 [Define if your assembler supports the swap suffix.])])
4629 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
4630 gcc_cv_as_ix86_diff_sect_delta,,,
4638 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4639 [Define if your assembler supports the subtraction of symbols in different sections.])])
4641 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4642 gcc_cv_as_ix86_rep_lock_prefix,,,
4648 lock addl %edi, (%eax,%esi)
4649 lock orl $0, (%esp)],,
4650 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4651 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4653 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4654 gcc_cv_as_ix86_ud2,,,
4656 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4657 [Define if your assembler supports the 'ud2' mnemonic.])])
4659 # Enforce 32-bit output with gas and gld.
4660 if test x$gas = xyes; then
4661 as_ix86_gas_32_opt="--32"
4663 if echo "$ld_ver" | grep GNU > /dev/null; then
4664 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4665 ld_ix86_gld_32_opt="-melf_i386_sol2"
4667 ld_ix86_gld_32_opt="-melf_i386"
4671 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4672 gcc_cv_as_ix86_tlsgdplt,,
4673 [$as_ix86_gas_32_opt],
4674 [call tls_gd@tlsgdplt],
4675 [if test x$gcc_cv_ld != x \
4676 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4677 gcc_cv_as_ix86_tlsgdplt=yes
4680 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4681 [Define if your assembler and linker support @tlsgdplt.])])
4684 .section .tdata,"aw'$tls_section_flag'",@progbits
4686 .section .text,"ax",@progbits
4687 call tls_ld@tlsldmplt'
4689 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4690 gcc_cv_as_ix86_tlsldmplt,,
4691 [$as_ix86_gas_32_opt],
4693 [if test x$gcc_cv_ld != x \
4694 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4695 gcc_cv_as_ix86_tlsldmplt=yes
4698 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4699 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4700 [Define to 1 if your assembler and linker support @tlsldmplt.])
4703 .section .text,"ax",@progbits
4705 .type _start, @function
4707 leal value@tlsldm(%ebx), %eax
4708 call ___tls_get_addr@plt
4710 .section .tdata,"aw'$tls_section_flag'",@progbits
4711 .type value, @object
4713 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4714 gcc_cv_as_ix86_tlsldm,,
4715 [$as_ix86_gas_32_opt],
4717 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4718 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4719 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4720 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4721 gcc_cv_as_ix86_tlsldm=yes
4725 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4726 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4727 [Define to 1 if your assembler and linker support @tlsldm.])
4738 gcc_GAS_CHECK_FEATURE([R_386_GOT32X reloc],
4739 gcc_cv_as_ix86_got32x,,
4740 [$as_ix86_gas_32_opt],
4742 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4743 && test x$gcc_cv_readelf != x \
4744 && $gcc_cv_readelf --relocs --wide conftest.o 2>&1 \
4745 | grep R_386_GOT32X > /dev/null 2>&1 \
4746 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
4747 if $gcc_cv_objdump -dw conftest 2>&1 \
4748 | grep 0xffffff > /dev/null 2>&1; then
4749 gcc_cv_as_ix86_got32x=no
4751 gcc_cv_as_ix86_got32x=yes
4755 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_GOT32X,
4756 [`if test x"$gcc_cv_as_ix86_got32x" = xyes; then echo 1; else echo 0; fi`],
4757 [Define 0/1 if your assembler and linker support @GOT.])
4759 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
4760 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
4761 [$as_ix86_gas_32_opt],
4767 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
4768 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
4769 [Define true if the assembler supports '.long foo@GOTOFF'.])
4772 .section .text,"ax",@progbits
4774 .type _start, @function
4776 leal ld@tlsldm(%ecx), %eax
4777 call *___tls_get_addr@GOT(%ecx)
4778 leal gd@tlsgd(%ecx), %eax
4779 call *___tls_get_addr@GOT(%ecx)
4781 .section .tdata,"aw'$tls_section_flag'",@progbits
4789 gcc_GAS_CHECK_FEATURE([calling ___tls_get_addr via GOT],
4790 gcc_cv_as_ix86_tls_get_addr_via_got,,
4791 [$as_ix86_gas_32_opt],
4793 [if test x$gcc_cv_ld != x \
4794 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
4795 gcc_cv_as_ix86_tls_get_addr_via_got=yes
4798 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLS_GET_ADDR_GOT,
4799 [`if test x"$gcc_cv_as_ix86_tls_get_addr_via_got" = xyes; then echo 1; else echo 0; fi`],
4800 [Define 0/1 if your assembler and linker support calling ___tls_get_addr via GOT.])
4804 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4805 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4807 addl r15 = @ltoffx(x#), gp
4809 ld8.mov r16 = [[r15]], x#
4811 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4812 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4820 gcc_GAS_CHECK_FEATURE([.machine directive support],
4821 gcc_cv_as_machine_directive,,,
4822 [ .machine ppc7400])
4823 if test x$gcc_cv_as_machine_directive != xyes; then
4824 echo "*** This target requires an assembler supporting \".machine\"" >&2
4825 echo you can get it from: https://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4826 test x$build = x$target && exit 1
4832 *-*-aix*) conftest_s=' .machine "pwr5"
4835 *-*-darwin*) conftest_s=' .text
4837 *) conftest_s=' .machine power4
4842 gcc_GAS_CHECK_FEATURE([mfcr field support],
4843 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4845 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4846 [Define if your assembler supports mfcr field.])])
4849 *-*-aix*) conftest_s=' .csect .text[[PR]]
4851 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4855 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4856 *) conftest_s=' .text
4858 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4861 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4862 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4864 [AC_DEFINE(HAVE_AS_REL16, 1,
4865 [Define if your assembler supports R_PPC_REL16 relocs.])])
4868 *-*-aix*) conftest_s=' .machine "pwr7"
4871 *) conftest_s=' .machine power7
4876 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4877 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4879 [AC_DEFINE(HAVE_AS_VSX, 1,
4880 [Define if your assembler supports VSX instructions.])])
4882 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4883 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4884 [.gnu_attribute 4,1],,
4885 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4886 [Define if your assembler supports .gnu_attribute.])])
4888 gcc_GAS_CHECK_FEATURE([prologue entry point marker support],
4889 gcc_cv_as_powerpc_entry_markers, [2,26,0],-a64 --fatal-warnings,
4890 [ .reloc .,R_PPC64_ENTRY; nop],,
4891 [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1,
4892 [Define if your assembler supports the R_PPC64_ENTRY relocation.])])
4894 gcc_GAS_CHECK_FEATURE([plt sequence marker support],
4895 gcc_cv_as_powerpc_pltseq_markers, [2,31,0],-a32 --fatal-warnings,
4896 [ .reloc .,R_PPC_PLTSEQ; nop],,
4897 [AC_DEFINE(HAVE_AS_PLTSEQ, 1,
4898 [Define if your assembler supports R_PPC*_PLTSEQ relocations.])])
4902 gcc_GAS_CHECK_FEATURE([AIX .ref support],
4903 gcc_cv_as_aix_ref, [2,21,0],,
4904 [ .csect stuff[[rw]]
4910 [AC_DEFINE(HAVE_AS_REF, 1,
4911 [Define if your assembler supports .ref])])
4913 gcc_GAS_CHECK_FEATURE([AIX DWARF location lists section support],
4914 gcc_cv_as_aix_dwloc, [2,21,0],,
4919 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
4920 [Define if your assembler supports AIX debug frame section label reference.])])
4926 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4927 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4928 [ lw $4,%gp_rel(foo)($4)],,
4929 [if test x$target_cpu_default = x
4930 then target_cpu_default=MASK_EXPLICIT_RELOCS
4931 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4934 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4935 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4936 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4937 [Define if the assembler understands -mno-shared.])])
4939 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4940 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4941 [.gnu_attribute 4,1],,
4942 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4943 [Define if your assembler supports .gnu_attribute.])])
4945 gcc_GAS_CHECK_FEATURE([.module support],
4946 gcc_cv_as_mips_dot_module,,[-32],
4949 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4950 [Define if your assembler supports .module.])])
4951 if test x$gcc_cv_as_mips_dot_module = xno \
4952 && test x$with_fp_32 != x; then
4954 [Requesting --with-fp-32= requires assembler support for .module.])
4957 gcc_GAS_CHECK_FEATURE([.micromips support],
4958 gcc_cv_as_micromips_support,,[--fatal-warnings],
4960 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4961 [Define if your assembler supports the .set micromips directive])])
4963 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4964 gcc_cv_as_mips_dtprelword, [2,18,0],,
4965 [.section .tdata,"awT",@progbits
4969 .dtprelword x+0x8000],,
4970 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4971 [Define if your assembler supports .dtprelword.])])
4973 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4974 gcc_cv_as_mips_dspr1_mult,,,
4984 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4985 [Define if your assembler supports DSPR1 mult.])])
4987 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4988 gcc_cv_as_ld_jalr_reloc=no
4989 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4990 if test $in_tree_ld = yes ; then
4991 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 \
4992 && test $in_tree_ld_is_elf = yes; then
4993 gcc_cv_as_ld_jalr_reloc=yes
4995 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4996 echo ' .ent x' > conftest.s
4997 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4998 echo ' lw $25,%call16(y)($28)' >> conftest.s
4999 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
5000 echo '1: jalr $25' >> conftest.s
5001 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
5002 echo '1: jalr $25' >> conftest.s
5003 echo ' .end x' >> conftest.s
5004 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
5005 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
5006 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
5007 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
5008 gcc_cv_as_ld_jalr_reloc=yes
5014 if test $gcc_cv_as_ld_jalr_reloc = yes; then
5015 if test x$target_cpu_default = x; then
5016 target_cpu_default=MASK_RELAX_PIC_CALLS
5018 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
5021 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
5023 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
5024 [gcc_cv_ld_mips_personality_relaxation],
5025 [gcc_cv_ld_mips_personality_relaxation=no
5026 if test $in_tree_ld = yes ; then
5027 if test "$gcc_cv_gld_major_version" -eq 2 \
5028 -a "$gcc_cv_gld_minor_version" -ge 21 \
5029 -o "$gcc_cv_gld_major_version" -gt 2; then
5030 gcc_cv_ld_mips_personality_relaxation=yes
5032 elif test x$gcc_cv_as != x \
5033 -a x$gcc_cv_ld != x \
5034 -a x$gcc_cv_readelf != x ; then
5035 cat > conftest.s <<EOF
5037 .cfi_personality 0x80,indirect_ptr
5044 .section .data,"aw",@progbits
5048 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
5049 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
5050 if $gcc_cv_readelf -d conftest 2>&1 \
5051 | grep TEXTREL > /dev/null 2>&1; then
5053 elif $gcc_cv_readelf --relocs conftest 2>&1 \
5054 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
5057 gcc_cv_ld_mips_personality_relaxation=yes
5061 rm -f conftest.s conftest.o conftest])
5062 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
5063 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
5064 [Define if your linker can relax absolute .eh_frame personality
5065 pointers into PC-relative form.])
5068 gcc_GAS_CHECK_FEATURE([-mnan= support],
5069 gcc_cv_as_mips_nan,,
5071 [AC_DEFINE(HAVE_AS_NAN, 1,
5072 [Define if the assembler understands -mnan=.])])
5073 if test x$gcc_cv_as_mips_nan = xno \
5074 && test x$with_nan != x; then
5076 [Requesting --with-nan= requires assembler support for -mnan=])
5080 # Earlier GAS versions generically support .gnu_attribute, but the
5081 # msp430 assembler will not do anything with it.
5082 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5083 gcc_cv_as_msp430_gnu_attribute, [2,33,50],,
5084 [.gnu_attribute 4,1],,
5085 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5086 [Define if your assembler supports .gnu_attribute.])])
5087 gcc_GAS_CHECK_FEATURE([.mspabi_attribute support],
5088 gcc_cv_as_msp430_mspabi_attribute, [2,33,50],,
5089 [.mspabi_attribute 4,2],,
5090 [AC_DEFINE(HAVE_AS_MSPABI_ATTRIBUTE, 1,
5091 [Define if your assembler supports .mspabi_attribute.])])
5092 if test x$enable_newlib_nano_formatted_io = xyes; then
5093 AC_DEFINE(HAVE_NEWLIB_NANO_FORMATTED_IO, 1, [Define if GCC has been
5094 configured with --enable-newlib-nano-formatted-io.])
5098 # Versions 2.33 and earlier lacked support for the %gotoff relocation
5099 # syntax that is documented in the ABI specification.
5100 gcc_GAS_CHECK_FEATURE([support for %gotoff relocations in constant data],
5101 gcc_cv_as_nios2_gotoff_relocation,,,
5104 .long %gotoff(foo)],,
5105 [AC_DEFINE(HAVE_AS_NIOS2_GOTOFF_RELOCATION, 1,
5106 [Define if your assembler supports %gotoff relocation syntax.])])
5109 gcc_GAS_CHECK_FEATURE([.attribute support],
5110 gcc_cv_as_riscv_attribute, [2,32,0],,
5111 [.attribute stack_align,4],,
5112 [AC_DEFINE(HAVE_AS_RISCV_ATTRIBUTE, 1,
5113 [Define if your assembler supports .attribute.])])
5116 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5117 gcc_cv_as_s390_gnu_attribute, [2,18,0],,
5118 [.gnu_attribute 8,1],,
5119 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5120 [Define if your assembler supports .gnu_attribute.])])
5121 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
5122 gcc_cv_as_s390_machine_machinemode, [2,24,0],,
5127 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
5128 [Define if your assembler supports .machine and .machinemode.])])
5129 gcc_GAS_CHECK_FEATURE([architecture modifiers support],
5130 gcc_cv_as_s390_architecture_modifiers, [2,26,0],,
5131 [ .machine z13+vx ],,
5132 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
5133 [Define if your assembler supports architecture modifiers.])])
5134 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints],
5135 gcc_cv_as_s390_vector_loadstore_alignment_hints, [2,31,0],,
5136 [ vl %v24,0(%r15),3 ],,
5137 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS, 1,
5138 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument.])])
5139 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints on z13],
5140 gcc_cv_as_s390_vector_loadstore_alignment_hints_on_z13,, [-mzarch -march=z13],
5141 [ vl %v24,0(%r15),3 ],,
5142 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS_ON_Z13, 1,
5143 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument on z13.])])
5148 # Mips and HP-UX need the GNU assembler.
5149 # Linux on IA64 might be able to use the Intel assembler.
5152 mips*-*-* | *-*-hpux* )
5153 if test x$gas_flag = xyes \
5154 || test x"$host" != x"$build" \
5155 || test ! -x "$gcc_cv_as" \
5156 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
5159 echo "*** This configuration requires the GNU assembler" >&2
5165 # ??? Not all targets support dwarf2 debug_line, even within a version
5166 # of gas. Moreover, we need to emit a valid instruction to trigger any
5167 # info to the output file. So, as supported targets are added to gas 2.11,
5168 # add some instruction here to (also) show we expect this might work.
5169 # ??? Once 2.11 is released, probably need to add first known working
5170 # version to the per-target configury.
5172 aarch64 | alpha | arc | arm | avr | bfin | cris | csky | i386 | m32c | m68k \
5173 | microblaze | mips | nds32 | nios2 | pa | riscv | rs6000 | score | sparc \
5174 | tilegx | tilepro | visium | xstormy16 | xtensa)
5184 if test x"$insn" != x; then
5186 .file 1 \"conftest.s\"
5189 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
5190 gcc_cv_as_dwarf2_debug_line,
5191 [elf,2,11,0],, [$conftest_s],
5192 [if test x$gcc_cv_objdump != x \
5193 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
5194 | grep debug_line > /dev/null 2>&1; then
5195 gcc_cv_as_dwarf2_debug_line=yes
5196 elif test x$gcc_cv_otool != x \
5197 && $gcc_cv_otool -l conftest.o 2> /dev/null \
5198 | grep debug_line > /dev/null 2>&1; then
5199 gcc_cv_as_dwarf2_debug_line=yes
5202 # The .debug_line file table must be in the exact order that
5203 # we specified the files, since these indices are also used
5204 # by DW_AT_decl_file. Approximate this test by testing if
5205 # the assembler bitches if the same index is assigned twice.
5206 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
5207 gcc_cv_as_dwarf2_file_buggy,,,
5211 if test $gcc_cv_as_dwarf2_debug_line = yes \
5212 && test $gcc_cv_as_dwarf2_file_buggy = no; then
5213 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
5214 [Define if your assembler supports dwarf2 .file/.loc directives,
5215 and preserves file table indices exactly as given.])
5217 if test $gcc_cv_as_leb128 = yes; then
5219 .file 1 \"conftest.s\"
5220 .loc 1 3 0 view .LVU1
5226 gcc_GAS_CHECK_FEATURE([dwarf2 debug_view support],
5227 gcc_cv_as_dwarf2_debug_view,
5228 [elf,2,27,0],,[$conftest_s],,
5229 [AC_DEFINE(HAVE_AS_DWARF2_DEBUG_VIEW, 1,
5230 [Define if your assembler supports views in dwarf2 .loc directives.])])
5234 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
5235 gcc_cv_as_gdwarf2_flag,
5236 [elf,2,11,0], [--gdwarf2], [$insn],,
5237 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
5238 [Define if your assembler supports the --gdwarf2 option.])])
5240 gcc_GAS_CHECK_FEATURE([--gdwarf-5 option],
5241 gcc_cv_as_gdwarf_5_flag,
5242 [elf,2,36,0], [--gdwarf-5], [$insn],,
5243 [AC_DEFINE(HAVE_AS_GDWARF_5_DEBUG_FLAG, 1,
5244 [Define if your assembler supports the --gdwarf-5 option.])])
5246 dwarf4_debug_info_size=0x46
5247 dwarf4_high_pc_form=7
5248 dwarf4_debug_aranges_size=0x2c
5250 for dwarf4_addr_size in 8 4; do
5257 .type foo, %function
5266 .section .debug_info,\"\",%progbits
5268 .4byte $dwarf4_debug_info_size
5270 .4byte .Ldebug_abbrev0
5271 .byte 0x$dwarf4_addr_size
5273 .ascii \"GNU C17\\0\"
5277 .${dwarf4_addr_size}byte .Ltext0
5278 .${dwarf4_addr_size}byte .Letext0-.Ltext0
5279 .4byte .Ldebug_line0
5285 .${dwarf4_addr_size}byte .LFB0
5286 .${dwarf4_addr_size}byte .LFE0-.LFB0
5290 .section .debug_abbrev,\"\",%progbits
5306 .byte 0x$dwarf4_high_pc_form
5327 .byte 0x$dwarf4_high_pc_form
5333 .section .debug_aranges,\"\",%progbits
5334 .4byte $dwarf4_debug_aranges_size
5336 .4byte .Ldebug_info0
5341 .${dwarf4_addr_size}byte .Ltext0
5342 .${dwarf4_addr_size}byte .Letext0-.Ltext0
5343 .${dwarf4_addr_size}byte 0
5344 .${dwarf4_addr_size}byte 0
5345 .section .debug_line,\"\",%progbits
5347 .4byte .LELT0-.LSLT0
5350 .4byte .LELTP0-.LASLTP0
5378 .byte 0x$dwarf4_line_sz
5380 .${dwarf4_addr_size}byte .LM1
5385 .byte 0x$dwarf4_line_sz
5387 .${dwarf4_addr_size}byte .LM2
5392 .byte 0x$dwarf4_line_sz
5394 .${dwarf4_addr_size}byte .Letext0
5399 .section .debug_str,\"\",%progbits
5403 if test $dwarf4_addr_size = 4; then
5404 gcc_GAS_CHECK_FEATURE([assembly of compiler generated 32-bit .debug_line],
5405 gcc_cv_as_debug_line_32_flag,
5406 [elf,2,36,0], [], [$conftest_s],,
5407 [dwarf4_success=yes])
5409 gcc_GAS_CHECK_FEATURE([assembly of compiler generated 64-bit .debug_line],
5410 gcc_cv_as_debug_line_64_flag,
5411 [elf,2,36,0], [], [$conftest_s],,
5412 [dwarf4_success=yes])
5414 if test $dwarf4_success = yes; then
5416 gcc_GAS_CHECK_FEATURE([--gdwarf-4 not refusing compiler generated .debug_line],
5417 gcc_cv_as_dwarf_4_debug_line_flag,
5418 [elf,2,36,0], [--gdwarf-4], [$conftest_s],,
5419 [dwarf4_success=yes])
5422 dwarf4_debug_info_size=0x36
5423 dwarf4_high_pc_form=6
5424 dwarf4_debug_aranges_size=0x1c
5428 if test $dwarf4_success = yes; then
5446 gcc_GAS_CHECK_FEATURE([--gdwarf-4 with the APP marker],
5447 gcc_cv_as_dwarf_4_app_flag,,
5448 [--gdwarf-4], [$conftest_s],, [dwarf4_success=yes])
5451 if test $dwarf4_success = yes; then
5455 .type foo, %function
5461 gcc_GAS_CHECK_FEATURE([working --gdwarf-4/--gdwarf-5 for all sources],
5462 gcc_cv_as_working_gdwarf_n_flag,,
5466 if test x$gcc_cv_readelf != x \
5467 && $gcc_cv_readelf -w conftest.o 2>&1 \
5468 | grep conftest.s > /dev/null 2>&1; then
5469 gcc_cv_as_working_gdwarf_n_flag=no
5471 gcc_cv_as_working_gdwarf_n_flag=yes
5473 changequote([,])dnl])
5474 if test $gcc_cv_as_working_gdwarf_n_flag = yes; then
5475 AC_DEFINE(HAVE_AS_WORKING_DWARF_N_FLAG, 1,
5476 [Define if your assembler supports --gdwarf-4/--gdwarf-5 even with
5477 compiler generated .debug_line.])
5481 gcc_GAS_CHECK_FEATURE([--gstabs option],
5482 gcc_cv_as_gstabs_flag,
5483 [elf,2,11,0], [--gstabs], [$insn],,
5484 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
5485 [Define if your assembler supports the --gstabs option.])])
5487 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
5488 gcc_cv_as_debug_prefix_map_flag,
5489 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
5490 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
5491 [Define if your assembler supports the --debug-prefix-map option.])])
5494 gcc_GAS_CHECK_FEATURE([compressed debug sections],
5495 gcc_cv_as_compress_debug,,,,
5496 [# gas compiled without zlib cannot compress debug sections and warns
5497 # about it, but still exits successfully. So check for this, too.
5498 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
5500 gcc_cv_as_compress_debug=0
5501 # Since binutils 2.26, gas supports --compress-debug-sections=type,
5502 # defaulting to the ELF gABI format.
5503 elif $gcc_cv_as --compress-debug-sections=zlib-gnu -o conftest.o conftest.s > /dev/null 2>&1
5505 gcc_cv_as_compress_debug=2
5506 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5507 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5508 # Before binutils 2.26, gas only supported --compress-debug-options and
5509 # emitted the traditional GNU format.
5510 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
5512 gcc_cv_as_compress_debug=1
5513 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5514 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5516 gcc_cv_as_compress_debug=0
5518 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
5519 [Define to the level of your assembler's compressed debug section support.])
5520 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
5521 [Define to the assembler option to enable compressed debug sections.])
5522 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
5523 [Define to the assembler option to disable compressed debug sections.])
5525 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
5528 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
5529 [Define if your assembler supports .lcomm with an alignment field.])])
5531 if test x$with_sysroot = x && test x$host = x$target \
5532 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
5533 && test "$prefix" != "NONE"; then
5534 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
5535 [Define to PREFIX/include if cpp should also search that directory.])
5538 # Determine the version of glibc, if any, used on the target.
5539 AC_MSG_CHECKING([for target glibc version])
5540 AC_ARG_WITH([glibc-version],
5541 [AS_HELP_STRING([--with-glibc-version=M.N],
5542 [assume GCC used with glibc version M.N or later])], [
5543 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
5544 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
5545 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
5547 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
5549 glibc_version_major=0
5550 glibc_version_minor=0
5551 [if test -f $target_header_dir/features.h \
5552 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
5553 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
5554 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
5555 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
5557 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
5558 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
5559 [GNU C Library major version number used on the target, or 0.])
5560 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
5561 [GNU C Library minor version number used on the target, or 0.])
5563 AC_ARG_ENABLE(gnu-unique-object,
5564 [AS_HELP_STRING([--enable-gnu-unique-object],
5565 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
5566 [case $enable_gnu_unique_object in
5568 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
5569 Valid choices are 'yes' and 'no'.]) ;;
5571 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
5573 [.type foo, '$target_type_format_char'gnu_unique_object],,
5574 # We need to unquote above to to use the definition from config.gcc.
5575 # Also check for ld.so support, i.e. glibc 2.11 or higher.
5576 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
5578 if test x$enable_gnu_unique_object = xyes; then
5579 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
5580 [Define if your assembler supports @gnu_unique_object.])
5583 AC_CACHE_CHECK([assembler for tolerance to line number 0],
5584 [gcc_cv_as_line_zero],
5585 [gcc_cv_as_line_zero=no
5586 if test $in_tree_gas = yes; then
5587 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
5588 elif test "x$gcc_cv_as" != x; then
5589 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
5590 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
5591 test "x`cat conftest.out`" = x
5593 gcc_cv_as_line_zero=yes
5595 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
5596 cat conftest.s >&AS_MESSAGE_LOG_FD
5597 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
5598 cat conftest.out >&AS_MESSAGE_LOG_FD
5600 rm -f conftest.o conftest.s conftest.out
5602 if test "x$gcc_cv_as_line_zero" = xyes; then
5603 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
5604 [Define if the assembler won't complain about a line such as # 0 "" 2.])
5607 AC_MSG_CHECKING(support for thin archives)
5608 thin_archive_support=no
5609 echo 'int main (void) { return 0; }' > conftest.c
5610 if ($AR --version | sed 1q | grep "GNU ar" \
5611 && $CC $CFLAGS -c conftest.c \
5612 && $AR rcT conftest.a conftest.o \
5613 && $CC $CFLAGS $LDFLAGS -o conftest conftest.a) >/dev/null 2>&1; then
5614 thin_archive_support=yes
5616 rm -f conftest.c conftest.o conftest.a conftest
5617 AC_MSG_RESULT($thin_archive_support)
5618 AC_SUBST(thin_archive_support)
5620 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
5621 gcc_cv_ld_eh_frame_hdr=no
5622 if test $in_tree_ld = yes ; then
5623 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 \
5624 && test $in_tree_ld_is_elf = yes; then
5625 gcc_cv_ld_eh_frame_hdr=yes
5627 elif test x$gcc_cv_ld != x; then
5628 if echo "$ld_ver" | grep GNU > /dev/null; then
5629 # Check if linker supports --eh-frame-hdr option
5630 if $gcc_cv_ld --help 2>&1 | grep eh-frame-hdr > /dev/null; then
5631 gcc_cv_ld_eh_frame_hdr=yes
5636 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
5637 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
5638 gcc_cv_ld_eh_frame_hdr=yes
5644 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
5645 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
5646 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
5647 [Define if your linker supports .eh_frame_hdr.])
5649 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
5651 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
5652 gcc_cv_ld_eh_frame_ciev3=no
5653 if test $in_tree_ld = yes ; then
5654 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 \
5655 && test $in_tree_ld_is_elf = yes; then
5656 gcc_cv_ld_eh_frame_ciev3=yes
5658 elif test x$gcc_cv_ld != x; then
5659 if echo "$ld_ver" | grep GNU > /dev/null; then
5660 gcc_cv_ld_eh_frame_ciev3=yes
5661 if test 0"$ld_date" -lt 20040513; then
5662 if test -n "$ld_date"; then
5663 # If there was date string, but was earlier than 2004-05-13, fail
5664 gcc_cv_ld_eh_frame_ciev3=no
5665 elif test "$ld_vers_major" -lt 2; then
5666 gcc_cv_ld_eh_frame_ciev3=no
5667 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
5668 gcc_cv_ld_eh_frame_ciev3=no
5674 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
5675 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
5676 gcc_cv_ld_eh_frame_ciev3=yes
5682 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
5683 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
5684 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
5685 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
5687 AC_MSG_CHECKING(linker position independent executable support)
5689 if test $in_tree_ld = yes ; then
5691 # Full PIE support on Solaris was only introduced in gld 2.26.
5692 *-*-solaris2*) gcc_gld_pie_min_version=26 ;;
5693 *) gcc_gld_pie_min_version=15 ;;
5695 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 \
5696 && test $in_tree_ld_is_elf = yes; then
5699 elif test x$gcc_cv_ld != x; then
5700 # Check if linker supports -pie option
5701 if $gcc_cv_ld --help 2>&1 | grep -- -pie > /dev/null; then
5705 if echo "$ld_ver" | grep GNU > /dev/null \
5706 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
5713 *-*-solaris2.1[[1-9]]*)
5714 # Solaris 11.3 added PIE support.
5715 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
5722 if test x"$gcc_cv_ld_pie" = xyes; then
5723 AC_DEFINE(HAVE_LD_PIE, 1,
5724 [Define if your linker supports PIE option.])
5726 AC_MSG_RESULT($gcc_cv_ld_pie)
5728 AC_MSG_CHECKING(linker PIE support with copy reloc)
5729 gcc_cv_ld_pie_copyreloc=no
5730 if test $gcc_cv_ld_pie = yes ; then
5731 if test $in_tree_ld = yes ; then
5732 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
5733 gcc_cv_ld_pie_copyreloc=yes
5735 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5736 # Check if linker supports -pie option with copy reloc
5738 i?86-*-linux* | x86_64-*-linux*)
5739 cat > conftest1.s <<EOF
5742 .type a_glob, @object
5747 cat > conftest2.s <<EOF
5750 .type main, @function
5752 movl %eax, a_glob(%rip)
5755 .section .data.rel,"aw",@progbits
5760 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5761 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
5762 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5763 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
5764 gcc_cv_ld_pie_copyreloc=yes
5766 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
5771 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
5772 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
5773 [Define 0/1 if your linker supports -pie option with copy reloc.])
5774 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
5776 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
5777 gcc_cv_ld_eh_gc_sections=no
5778 if test $in_tree_ld = yes ; then
5779 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 \
5780 && test $in_tree_ld_is_elf = yes; then
5781 gcc_cv_ld_eh_gc_sections=yes
5783 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
5784 cat > conftest.s <<EOF
5787 .type _start, @function
5790 .size _start, .-_start
5791 .section .text.foo,"ax",@progbits
5792 .type foo, @function
5796 .section .gcc_except_table.foo,"a",@progbits
5799 .section .eh_frame,"a",@progbits
5802 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5803 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5804 | grep "gc-sections option ignored" > /dev/null; then
5805 gcc_cv_ld_eh_gc_sections=no
5806 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5807 | grep gcc_except_table > /dev/null; then
5808 gcc_cv_ld_eh_gc_sections=yes
5809 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
5810 if test x$gcc_cv_as_comdat_group != xyes; then
5811 gcc_cv_ld_eh_gc_sections=no
5812 cat > conftest.s <<EOF
5815 .type _start, @function
5818 .size _start, .-_start
5819 .section .gnu.linkonce.t.foo,"ax",@progbits
5820 .type foo, @function
5824 .section .gcc_except_table.foo,"a",@progbits
5827 .section .eh_frame,"a",@progbits
5830 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5831 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5832 | grep "gc-sections option ignored" > /dev/null; then
5833 gcc_cv_ld_eh_gc_sections=no
5834 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5835 | grep gcc_except_table > /dev/null; then
5836 gcc_cv_ld_eh_gc_sections=yes
5842 rm -f conftest.s conftest.o conftest
5846 # ??? This apparently exposes a binutils bug with PC-relative relocations.
5847 gcc_cv_ld_eh_gc_sections=no
5850 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
5851 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
5852 [Define if your linker supports garbage collection of
5853 sections in presence of EH frames.])
5855 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
5857 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
5858 gcc_cv_ld_eh_gc_sections_bug=no
5859 if test $in_tree_ld = yes ; then
5860 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 \
5861 && test $in_tree_ld_is_elf = yes; then
5862 gcc_cv_ld_eh_gc_sections_bug=yes
5864 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
5865 gcc_cv_ld_eh_gc_sections_bug=yes
5866 cat > conftest.s <<EOF
5869 .type _start, @function
5872 .size _start, .-_start
5873 .section .text.startup.foo,"ax",@progbits
5874 .type foo, @function
5878 .section .gcc_except_table.foo,"a",@progbits
5881 .section .eh_frame,"a",@progbits
5884 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5885 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5886 | grep "gc-sections option ignored" > /dev/null; then
5888 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5889 | grep gcc_except_table > /dev/null; then
5890 gcc_cv_ld_eh_gc_sections_bug=no
5893 rm -f conftest.s conftest.o conftest
5895 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
5896 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
5897 [Define if your linker has buggy garbage collection of
5898 sections support when .text.startup.foo like sections are used.])
5900 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
5902 AC_MSG_CHECKING(linker for compressed debug sections)
5903 # gold/gld support compressed debug sections since binutils 2.19/2.21
5904 # In binutils 2.26, gld gained support for the ELF gABI format.
5905 if test $in_tree_ld = yes ; then
5906 gcc_cv_ld_compress_debug=0
5907 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 19 -o "$gcc_cv_gld_major_version" -gt 2 \
5908 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
5909 gcc_cv_ld_compress_debug=2
5910 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5911 elif test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 26 -o "$gcc_cv_gld_major_version" -gt 2 \
5912 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = no; then
5913 gcc_cv_ld_compress_debug=3
5914 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5915 elif test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 21 -o "$gcc_cv_gld_major_version" -gt 2 \
5916 && test $in_tree_ld_is_elf = yes; then
5917 gcc_cv_ld_compress_debug=1
5919 elif echo "$ld_ver" | grep GNU > /dev/null; then
5920 if test "$ld_vers_major" -lt 2 \
5921 || test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
5922 gcc_cv_ld_compress_debug=0
5923 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
5924 gcc_cv_ld_compress_debug=1
5926 gcc_cv_ld_compress_debug=3
5927 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5929 if test $ld_is_gold = yes; then
5930 gcc_cv_ld_compress_debug=2
5931 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5937 # Introduced in Solaris 11.2.
5938 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
5939 gcc_cv_ld_compress_debug=3
5940 gcc_cv_ld_compress_debug_option="-z compress-sections"
5942 gcc_cv_ld_compress_debug=0
5946 # Assume linkers other than GNU ld don't support compessed debug
5948 gcc_cv_ld_compress_debug=0
5953 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
5954 [Define to the level of your linker's compressed debug section support.])
5955 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
5956 [Define to the linker option to enable compressed debug sections.])
5957 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
5959 if test x"$ld64_flag" = x"yes"; then
5961 # Set defaults for possibly untestable items.
5962 gcc_cv_ld64_export_dynamic=0
5964 if test "$build" = "$host"; then
5970 # On Darwin, because of FAT library support, it is often possible to execute
5971 # exes from compatible archs even when the host differs from the build system.
5972 case "$build","$host" in
5973 x86_64-*-darwin*,i?86-*-darwin* | powerpc64*-*-darwin*,powerpc*-*-darwin*)
5978 # If the configurer specified a minimum ld64 version to be supported, then use
5979 # that to determine feature support.
5980 if test x"${gcc_cv_ld64_version}" != x; then
5981 AC_MSG_CHECKING(ld64 specified version)
5982 gcc_cv_ld64_major=`echo "$gcc_cv_ld64_version" | sed -e 's/\..*//'`
5983 AC_MSG_RESULT($gcc_cv_ld64_major)
5984 if test "$gcc_cv_ld64_major" -ge 236; then
5985 gcc_cv_ld64_export_dynamic=1
5987 elif test -x "$gcc_cv_ld" -a "$darwin_try_test" -eq 1; then
5988 # If the version was not specified, try to find it.
5989 AC_MSG_CHECKING(linker version)
5990 if test x"${gcc_cv_ld64_version}" = x; then
5991 gcc_cv_ld64_version=`$gcc_cv_ld -v 2>&1 | grep ld64 | sed s/.*ld64-// | awk '{print $1}'`
5993 AC_MSG_RESULT($gcc_cv_ld64_version)
5995 AC_MSG_CHECKING(linker for -export_dynamic support)
5996 gcc_cv_ld64_export_dynamic=1
5997 if $gcc_cv_ld -export_dynamic < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
5998 gcc_cv_ld64_export_dynamic=0
6000 AC_MSG_RESULT($gcc_cv_ld64_export_dynamic)
6003 if test x"${gcc_cv_ld64_version}" != x; then
6004 AC_DEFINE_UNQUOTED(LD64_VERSION, "${gcc_cv_ld64_version}",
6005 [Define to ld64 version.])
6008 AC_DEFINE_UNQUOTED(LD64_HAS_EXPORT_DYNAMIC, $gcc_cv_ld64_export_dynamic,
6009 [Define to 1 if ld64 supports '-export_dynamic'.])
6016 AC_CACHE_CHECK(linker --as-needed support,
6017 gcc_cv_ld_as_needed,
6018 [gcc_cv_ld_as_needed=no
6019 gcc_cv_ld_as_needed_option='--as-needed'
6020 gcc_cv_ld_no_as_needed_option='--no-as-needed'
6021 if test $in_tree_ld = yes ; then
6022 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 \
6023 && test $in_tree_ld_is_elf = yes; then
6024 gcc_cv_ld_as_needed=yes
6025 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 28; then
6026 gcc_cv_ld_as_needed_option='--push-state --as-needed'
6027 gcc_cv_ld_no_as_needed_option='--pop-state'
6030 elif test x$gcc_cv_ld != x; then
6031 # Check if linker supports --as-needed and --no-as-needed options
6032 if $gcc_cv_ld --help 2>&1 | grep as-needed > /dev/null; then
6033 gcc_cv_ld_as_needed=yes
6034 if $gcc_cv_ld --help 2>&1 | grep push-state > /dev/null \
6035 && $gcc_cv_ld --help 2>&1 | grep pop-state > /dev/null \
6036 && echo "$ld_ver" | grep GNU > /dev/null \
6037 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 28; then
6038 # Use these options only when both ld.bfd and ld.gold support
6039 # --push-state/--pop-state, which unfortunately wasn't added
6041 gcc_cv_ld_as_needed_option='--push-state --as-needed'
6042 gcc_cv_ld_no_as_needed_option='--pop-state'
6045 case "$target:$gnu_ld" in
6047 # Solaris 2 ld always supports -z ignore/-z record. Prefer the native
6049 gcc_cv_ld_as_needed=yes
6050 gcc_cv_ld_as_needed_option="-z ignore"
6051 gcc_cv_ld_no_as_needed_option="-z record"
6055 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
6056 # dl_iterate_phdr, i.e. since Solaris 11.
6058 *-*-solaris2.1[[1-9]]*)
6060 i?86-*-* | x86_64-*-*)
6061 if echo "$ld_ver" | grep GNU > /dev/null; then
6062 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
6063 gcc_cv_ld_as_needed=no
6069 gcc_cv_ld_as_needed=no
6073 if test x"$gcc_cv_ld_as_needed" = xyes; then
6074 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
6075 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
6076 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
6077 [Define to the linker option to ignore unused dependencies.])
6078 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
6079 [Define to the linker option to keep unused dependencies.])
6082 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
6083 saved_LDFLAGS="$LDFLAGS"
6084 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
6085 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
6086 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
6087 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
6089 LDFLAGS="$saved_LDFLAGS"
6090 if test "x$gcc_cv_ld_clearcap" = xyes; then
6091 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
6092 [Define if the linker supports clearing hardware capabilities via mapfile.])
6093 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
6095 AC_MSG_RESULT($gcc_cv_ld_clearcap)
6101 emul_name="-melf32lppc"
6104 emul_name="-melf32ppc"
6107 AC_CACHE_CHECK(linker .gnu.attributes long double support,
6109 [gcc_cv_ld_ppc_attr=no
6110 if test x"$ld_is_gold" = xyes; then
6111 gcc_cv_ld_ppc_attr=yes
6112 elif test $in_tree_ld = yes ; then
6113 if test "$gcc_cv_gld_major_version" -eq 2 \
6114 -a "$gcc_cv_gld_minor_version" -ge 28 \
6115 -o "$gcc_cv_gld_major_version" -gt 2; then
6116 gcc_cv_ld_ppc_attr=yes
6118 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6119 # check that merging the long double .gnu_attribute doesn't warn
6120 cat > conftest1.s <<EOF
6123 cat > conftest2.s <<EOF
6126 if $gcc_cv_as -a32 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6127 && $gcc_cv_as -a32 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6128 && $gcc_cv_ld $emul_name -r -o conftest.o conftest1.o conftest2.o > /dev/null 2> conftest.err \
6129 && test ! -s conftest.err; then
6130 gcc_cv_ld_ppc_attr=yes
6132 rm -f conftest.err conftest.o conftest1.o conftest2.o conftest1.s conftest2.s
6135 if test x$gcc_cv_ld_ppc_attr = xyes; then
6136 AC_DEFINE(HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE, 1,
6137 [Define if your PowerPC linker has .gnu.attributes long double support.])
6142 case "$target:$tm_file" in
6143 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
6146 emul_name="-melf64lppc"
6149 emul_name="-melf64ppc"
6152 emul_name="-melf64ppc_fbsd"
6155 AC_CACHE_CHECK(linker support for omitting dot symbols,
6156 gcc_cv_ld_no_dot_syms,
6157 [gcc_cv_ld_no_dot_syms=no
6158 if test x"$ld_is_gold" = xyes; then
6159 gcc_cv_ld_no_dot_syms=yes
6160 elif test $in_tree_ld = yes ; then
6161 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
6162 gcc_cv_ld_no_dot_syms=yes
6164 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6165 cat > conftest1.s <<EOF
6169 cat > conftest2.s <<EOF
6170 .section ".opd","aw"
6175 .quad .LEfoo,.TOC.@tocbase,0
6181 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6182 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6183 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
6184 gcc_cv_ld_no_dot_syms=yes
6186 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
6189 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
6190 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
6191 [Define if your PowerPC64 linker only needs function descriptor syms.])
6194 AC_CACHE_CHECK(linker large toc support,
6195 gcc_cv_ld_large_toc,
6196 [gcc_cv_ld_large_toc=no
6197 if test x"$ld_is_gold" = xyes; then
6198 gcc_cv_ld_large_toc=yes
6199 elif test $in_tree_ld = yes ; then
6200 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
6201 gcc_cv_ld_large_toc=yes
6203 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6204 cat > conftest.s <<EOF
6205 .section ".tbss","awT",@nobits
6211 addis 9,13,ie0@got@tprel@ha
6212 ld 9,ie0@got@tprel@l(9)
6214 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6215 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
6216 gcc_cv_ld_large_toc=yes
6218 rm -f conftest conftest.o conftest.s
6221 if test x"$gcc_cv_ld_large_toc" = xyes; then
6222 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6223 [Define if your PowerPC64 linker supports a large TOC.])
6226 AC_CACHE_CHECK(linker toc pointer alignment,
6227 gcc_cv_ld_toc_align,
6228 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
6229 cat > conftest.s <<EOF
6234 .section .data.rel.ro,"aw",@progbits
6239 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6240 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
6241 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)) }'`
6243 rm -f conftest conftest.o conftest.s
6246 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
6247 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
6248 [Define to .TOC. alignment forced by your linker.])
6255 AC_CACHE_CHECK(linker large toc support,
6256 gcc_cv_ld_large_toc,
6257 [gcc_cv_ld_large_toc=no
6258 if test x$gcc_cv_as != x ; then
6259 cat > conftest.s <<EOF
6269 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
6270 gcc_cv_ld_large_toc=yes
6272 rm -f conftest conftest.o conftest.s
6275 if test x"$gcc_cv_ld_large_toc" = xyes; then
6276 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6277 [Define if your PowerPC64 linker supports a large TOC.])
6282 AC_CACHE_CHECK(linker --build-id support,
6284 [gcc_cv_ld_buildid=no
6285 if test $in_tree_ld = yes ; then
6286 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6287 "$gcc_cv_gld_minor_version" -ge 18 -o \
6288 "$gcc_cv_gld_major_version" -gt 2 \
6289 && test $in_tree_ld_is_elf = yes; then
6290 gcc_cv_ld_buildid=yes
6292 elif test x$gcc_cv_ld != x; then
6293 if $gcc_cv_ld --help 2>&1 | grep build-id > /dev/null; then
6294 gcc_cv_ld_buildid=yes
6297 if test x"$gcc_cv_ld_buildid" = xyes; then
6298 AC_DEFINE(HAVE_LD_BUILDID, 1,
6299 [Define if your linker supports --build-id.])
6302 AC_ARG_ENABLE(linker-build-id,
6303 [AS_HELP_STRING([--enable-linker-build-id],
6304 [compiler will always pass --build-id to linker])],
6306 enable_linker_build_id=no)
6308 if test x"$enable_linker_build_id" = xyes; then
6309 if test x"$gcc_cv_ld_buildid" = xyes; then
6310 AC_DEFINE(ENABLE_LD_BUILDID, 1,
6311 [Define if gcc should always pass --build-id to linker.])
6313 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
6317 # In binutils 2.21, GNU ld gained support for new emulations fully
6318 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
6319 AC_CACHE_CHECK(linker *_sol2 emulation support,
6320 gcc_cv_ld_sol2_emulation,
6321 [gcc_cv_ld_sol2_emulation=no
6322 if test $in_tree_ld = yes ; then
6323 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6324 "$gcc_cv_gld_minor_version" -ge 21 -o \
6325 "$gcc_cv_gld_major_version" -gt 2 \
6326 && test $in_tree_ld_is_elf = yes; then
6327 gcc_cv_ld_sol2_emulation=yes
6329 elif test x$gcc_cv_ld != x; then
6330 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
6331 grep _sol2 > /dev/null; then
6332 gcc_cv_ld_sol2_emulation=yes
6335 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
6336 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
6337 [Define if your linker supports the *_sol2 emulations.])
6340 AC_CACHE_CHECK(linker --sysroot support,
6342 [gcc_cv_ld_sysroot=no
6343 if test $in_tree_ld = yes ; then
6344 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
6345 gcc_cv_ld_sysroot=yes
6347 elif test x$gcc_cv_ld != x; then
6348 if $gcc_cv_ld --help 2>&1 | grep sysroot > /dev/null; then
6349 gcc_cv_ld_sysroot=yes
6352 if test x"$gcc_cv_ld_sysroot" = xyes; then
6353 AC_DEFINE(HAVE_LD_SYSROOT, 1,
6354 [Define if your linker supports --sysroot.])
6359 # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
6360 AC_CACHE_CHECK([system-provided CRTs on Solaris],
6361 gcc_cv_solaris_crts,
6362 [gcc_cv_solaris_crts=no
6363 if test x$host != x$target; then
6364 if test "x$with_sysroot" = xyes; then
6365 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
6367 target_sysroot="${with_sysroot}"
6370 target_libdir="$target_sysroot/usr/lib"
6371 # At the time they were added, gcrt1.o became a symlink for backwards
6372 # compatibility on x86, while crt1.o was added on sparc, so check for that.
6374 i?86-*-solaris2* | x86_64-*-solaris2*)
6375 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
6378 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
6383 if test x$gcc_cv_solaris_crts = xyes; then
6384 AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
6385 [Define if the system-provided CRTs are present on Solaris.])
6388 AC_ARG_ENABLE(libssp,
6389 [AS_HELP_STRING([--enable-libssp], [enable linking against libssp])],
6390 [case "${enableval}" in
6394 AC_MSG_ERROR([unknown libssp setting $enableval])
6398 # Test for stack protector support in target C library.
6399 AC_CACHE_CHECK(__stack_chk_fail in target C library,
6400 gcc_cv_libc_provides_ssp,
6401 [gcc_cv_libc_provides_ssp=no
6402 if test "x$enable_libssp" = "xno"; then
6403 gcc_cv_libc_provides_ssp=yes
6404 elif test "x$enable_libssp" = "xyes"; then
6405 gcc_cv_libc_provides_ssp=no
6409 # All versions of musl provide stack protector
6410 gcc_cv_libc_provides_ssp=yes;;
6411 *-*-linux* | *-*-kfreebsd*-gnu)
6412 # glibc 2.4 and later provides __stack_chk_fail and
6413 # either __stack_chk_guard, or TLS access to stack guard canary.
6414 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
6415 [if test -f $target_header_dir/features.h \
6416 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
6417 $target_header_dir/features.h > /dev/null; then
6418 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
6419 $target_header_dir/features.h > /dev/null && \
6420 test -f $target_header_dir/bits/uClibc_config.h && \
6421 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
6422 $target_header_dir/bits/uClibc_config.h > /dev/null; then
6423 gcc_cv_libc_provides_ssp=yes
6425 # all versions of Bionic support stack protector
6426 elif test -f $target_header_dir/sys/cdefs.h \
6427 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
6428 $target_header_dir/sys/cdefs.h > /dev/null; then
6429 gcc_cv_libc_provides_ssp=yes
6433 # Avoid complicated tests (see
6434 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
6435 # simply assert that glibc does provide this, which is true for all
6436 # realistically usable GNU/Hurd configurations.
6437 # All supported versions of musl provide it as well
6438 gcc_cv_libc_provides_ssp=yes;;
6439 *-*-darwin* | *-*-freebsd* | *-*-netbsd*)
6440 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
6441 [echo "no __stack_chk_fail on this target"])
6443 *) gcc_cv_libc_provides_ssp=no ;;
6447 if test x$gcc_cv_libc_provides_ssp = xyes; then
6448 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
6449 [Define if your target C library provides stack protector support])
6452 # Check whether --enable-default-ssp was given.
6453 AC_ARG_ENABLE(default-ssp,
6454 [AS_HELP_STRING([--enable-default-ssp],
6455 [enable Stack Smashing Protection as default])],[
6456 if test x$gcc_cv_libc_provides_ssp = xyes; then
6458 ia64*-*-*) enable_default_ssp=no ;;
6459 *) enable_default_ssp=$enableval ;;
6462 enable_default_ssp=no
6464 enable_default_ssp=no)
6465 if test x$enable_default_ssp = xyes ; then
6466 AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
6467 [Define if your target supports default stack protector and it is enabled.])
6469 AC_SUBST([enable_default_ssp])
6471 # Test for <sys/sdt.h> on the target.
6472 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
6473 AC_MSG_CHECKING(sys/sdt.h in the target C library)
6475 if test -f $target_header_dir/sys/sdt.h; then
6477 AC_DEFINE(HAVE_SYS_SDT_H, 1,
6478 [Define if your target C library provides sys/sdt.h])
6480 AC_MSG_RESULT($have_sys_sdt_h)
6482 # Check if TFmode long double should be used by default or not.
6483 # Some glibc targets used DFmode long double, but with glibc 2.4
6484 # and later they can use TFmode.
6486 powerpc*-*-linux* | \
6490 AC_ARG_WITH(long-double-128,
6491 [AS_HELP_STRING([--with-long-double-128],
6492 [use 128-bit long double by default])],
6493 gcc_cv_target_ldbl128="$with_long_double_128", [
6495 s390*-*-linux-musl*)
6496 gcc_cv_target_ldbl128=yes
6498 powerpc*-*-linux-musl*)
6499 gcc_cv_target_ldbl128=no
6502 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
6503 [gcc_cv_target_ldbl128=no
6504 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
6505 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
6506 && gcc_cv_target_ldbl128=yes
6514 if test x$gcc_cv_target_ldbl128 = xyes; then
6515 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
6516 [Define if TFmode long double should be the default])
6519 # Check if TFmode long double target should use the IBM extended double or IEEE
6520 # 128-bit floating point formats if long doubles are 128-bits long. The long
6521 # double type can only be switched on powerpc64 bit Linux systems where VSX is
6522 # supported. Other PowerPC systems do not build the IEEE 128-bit emulator in
6524 AC_ARG_WITH([long-double-format],
6525 [AS_HELP_STRING([--with-long-double-format={ieee,ibm}]
6526 [Specify whether PowerPC long double uses IEEE or IBM format])],[
6527 case "$target:$with_long_double_format" in
6528 powerpc64le-*-linux*:ieee | powerpc64le-*-linux*:ibm)
6531 powerpc64-*-linux*:ieee | powerpc64-*-linux*:ibm)
6532 # IEEE 128-bit emulation is only built on 64-bit VSX Linux systems
6534 power7 | power8 | power9 | power1*)
6538 AC_MSG_ERROR([Configuration option --with-long-double-format is only \
6539 supported if the default cpu is power7 or newer])
6540 with_long_double_format=""
6544 powerpc64*-*-linux*:*)
6545 AC_MSG_ERROR([--with-long-double-format argument should be ibm or ieee])
6546 with_long_double_format=""
6549 AC_MSG_ERROR([Configure option --with-long-double-format is only supported \
6550 on 64-bit PowerPC VSX Linux systems])
6551 with_long_double_format=""
6556 # Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP
6557 # values in the TCB. Currently, only GLIBC 2.23 and later support this.
6558 gcc_cv_libc_provides_hwcap_in_tcb=no
6561 GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], )
6564 if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then
6565 AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1,
6566 [Define if your target C Library provides the AT_HWCAP value in the TCB])
6569 # Check if the target LIBC handles PT_GNU_STACK.
6570 gcc_cv_libc_gnustack=unknown
6573 GCC_GLIBC_VERSION_GTE_IFELSE([2], [31], [gcc_cv_libc_gnustack=yes], )
6576 if test x$gcc_cv_libc_gnustack = xyes; then
6577 AC_DEFINE(TARGET_LIBC_GNUSTACK, 1,
6578 [Define if your target C Library properly handles PT_GNU_STACK])
6581 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
6582 gcc_cv_target_dl_iterate_phdr=unknown
6585 # <link.h> needs both a dl_iterate_phdr declaration and support for
6586 # compilation with largefile support.
6587 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
6588 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
6589 gcc_cv_target_dl_iterate_phdr=yes
6591 gcc_cv_target_dl_iterate_phdr=no
6594 *-*-dragonfly* | *-*-freebsd*)
6595 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
6596 gcc_cv_target_dl_iterate_phdr=yes
6598 gcc_cv_target_dl_iterate_phdr=no
6602 gcc_cv_target_dl_iterate_phdr=yes
6605 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
6606 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
6607 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
6608 [Define if your target C library provides the `dl_iterate_phdr' function.])
6610 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
6612 # We no longer support different GC mechanisms. Emit an error if
6613 # the user configures with --with-gc.
6615 [AS_HELP_STRING([--with-gc={page,zone}],
6616 [this option is not supported anymore. It used to choose
6617 the garbage collection mechanism to use with the compiler])],
6618 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
6621 # Libraries to use on the host. This will normally be set by the top
6622 # level Makefile. Here we simply capture the value for our Makefile.
6623 if test -z "${HOST_LIBS+set}"; then
6628 # Use the system's zlib library.
6631 dnl Very limited version of automake's enable-maintainer-mode
6633 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
6634 dnl maintainer-mode is disabled by default
6635 AC_ARG_ENABLE(maintainer-mode,
6636 [AS_HELP_STRING([--enable-maintainer-mode],
6637 [enable make rules and dependencies not useful
6638 (and sometimes confusing) to the casual installer])],
6639 maintainer_mode=$enableval,
6642 AC_MSG_RESULT($maintainer_mode)
6644 if test "$maintainer_mode" = "yes"; then
6651 dnl Whether to prevent multiple front-ends from linking at the same time
6653 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
6654 AC_ARG_ENABLE(link-mutex,
6655 [AS_HELP_STRING([--enable-link-mutex],
6656 [avoid linking multiple front-ends at once to avoid thrashing
6657 on the build machine])],
6658 do_link_mutex=$enableval,
6660 AC_MSG_RESULT($do_link_mutex)
6662 if test "$do_link_mutex" = "yes"; then
6667 AC_SUBST(DO_LINK_MUTEX)
6673 # Make empty files to contain the specs and options for each language.
6674 # Then add #include lines to for a compiler that has specs and/or options.
6680 # These (without "all_") are set in each config-lang.in.
6681 # `language' must be a single word so is spelled singularly.
6684 all_outputs='Makefile'
6685 # List of language configure and makefile fragments.
6686 all_lang_configurefrags=
6688 # Additional files for gengtype
6689 all_gtfiles="$target_gtfiles"
6691 # These are the languages that are set in --enable-languages,
6692 # and are available in the GCC tree.
6693 all_selected_languages=
6695 # Add the language fragments.
6696 # Languages are added via two mechanisms. Some information must be
6697 # recorded in makefile variables, these are defined in config-lang.in.
6698 # We accumulate them and plug them into the main Makefile.
6699 # The other mechanism is a set of hooks for each of the main targets
6700 # like `clean', `install', etc.
6702 language_hooks="Make-hooks"
6704 for lang in ${srcdir}/*/config-lang.in
6707 test "$lang" = "${srcdir}/*/config-lang.in" && continue
6709 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
6710 if test "x$lang_alias" = x
6712 echo "$lang doesn't set \$language." 1>&2
6715 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
6716 subdirs="$subdirs $subdir"
6718 # $gcc_subdir is where the gcc integration files are to be found
6719 # for a language, both for internal compiler purposes (compiler
6720 # sources implementing front-end to GCC tree converters), and for
6721 # build infrastructure purposes (Make-lang.in, etc.)
6723 # This will be <subdir> (relative to $srcdir) if a line like
6724 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
6725 # is found in <langdir>/config-lang.in, and will remain <langdir>
6728 # Except for the language alias (fetched above), the regular
6729 # "config-lang.in" contents are always retrieved from $gcc_subdir,
6730 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
6731 # only this and the language alias.
6733 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
6734 if [ "$gcc_subdir" = "" ]; then
6735 gcc_subdir="$subdir"
6738 case ",$enable_languages," in
6740 all_selected_languages="$all_selected_languages $lang_alias"
6741 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
6742 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
6754 . ${srcdir}/$gcc_subdir/config-lang.in
6755 if test "x$language" = x
6757 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
6762 case ",$enable_languages," in
6765 for i in $subdir_requires; do
6766 test -f "${srcdir}/$i/config-lang.in" && continue
6774 all_lang_configurefrags="$all_lang_configurefrags \$(srcdir)/$gcc_subdir/config-lang.in"
6775 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
6776 if test -f $srcdir/$gcc_subdir/lang.opt; then
6777 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
6778 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
6780 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
6781 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
6783 all_languages="$all_languages $language"
6784 all_compilers="$all_compilers $compilers"
6785 all_outputs="$all_outputs $outputs"
6786 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
6787 case ",$enable_languages," in
6789 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
6791 AC_SUBST(enable_lto)
6798 for language in $all_selected_languages
6800 check_languages="$check_languages check-$language"
6804 for language in $all_selected_languages
6806 selftest_languages="$selftest_languages selftest-$language"
6809 # We link each language in with a set of hooks, reached indirectly via
6810 # lang.${target}. Only do so for selected languages.
6814 target_list="all.cross start.encap rest.encap tags \
6815 install-common install-man install-info install-pdf install-html dvi \
6816 pdf html uninstall info man srcextra srcman srcinfo \
6817 mostlyclean clean distclean maintainer-clean install-plugin"
6819 for t in $target_list
6822 for lang in $all_selected_languages
6826 echo "lang.$t: $x" >> Make-hooks
6830 # Option include files
6833 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
6834 option_includes="option-includes.mk"
6835 AC_SUBST_FILE(option_includes)
6843 echo "dir ." > .gdbinit
6844 echo "dir ${srcdir}" >> .gdbinit
6845 if test x$gdb_needs_out_file_path = xyes
6847 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
6849 if test "x$subdirs" != x; then
6852 echo "dir ${srcdir}/$s" >> .gdbinit
6855 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
6856 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
6858 # Put a breakpoint on __asan_report_error to help with debugging buffer
6861 *-fsanitize=address*)
6862 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
6866 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
6867 AC_SUBST(gcc_tooldir)
6870 # Find a directory in which to install a shared libgcc.
6872 AC_ARG_ENABLE(version-specific-runtime-libs,
6873 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
6874 [specify that runtime libraries should be
6875 installed in a compiler-specific directory])])
6877 # Substitute configuration variables
6880 AC_SUBST(all_compilers)
6881 AC_SUBST(all_gtfiles)
6882 AC_SUBST(all_lang_configurefrags)
6883 AC_SUBST(all_lang_makefrags)
6884 AC_SUBST(all_languages)
6885 AC_SUBST(all_selected_languages)
6886 AC_SUBST(build_exeext)
6887 AC_SUBST(build_install_headers_dir)
6888 AC_SUBST(build_xm_file_list)
6889 AC_SUBST(build_xm_include_list)
6890 AC_SUBST(build_xm_defines)
6891 AC_SUBST(build_file_translate)
6892 AC_SUBST(check_languages)
6893 AC_SUBST(selftest_languages)
6894 AC_SUBST(cpp_install_dir)
6895 AC_SUBST(xmake_file)
6896 AC_SUBST(tmake_file)
6897 AC_SUBST(TM_ENDIAN_CONFIG)
6898 AC_SUBST(TM_MULTILIB_CONFIG)
6899 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
6900 AC_SUBST(extra_gcc_objs)
6901 AC_SUBST(user_headers_inc_next_pre)
6902 AC_SUBST(user_headers_inc_next_post)
6903 AC_SUBST(extra_headers_list)
6904 AC_SUBST(extra_objs)
6905 AC_SUBST(extra_programs)
6906 AC_SUBST(float_h_file)
6907 AC_SUBST(gcc_config_arguments)
6908 AC_SUBST(gcc_gxx_include_dir)
6909 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
6910 AC_SUBST(host_exeext)
6911 AC_SUBST(host_xm_file_list)
6912 AC_SUBST(host_xm_include_list)
6913 AC_SUBST(host_xm_defines)
6914 AC_SUBST(out_host_hook_obj)
6916 AC_SUBST(lang_opt_files)
6917 AC_SUBST(lang_specs_files)
6918 AC_SUBST(lang_tree_files)
6919 AC_SUBST(local_prefix)
6921 AC_SUBST(objc_boehm_gc)
6923 AC_SUBST(out_object_file)
6924 AC_SUBST(common_out_file)
6925 AC_SUBST(common_out_object_file)
6926 AC_SUBST(tm_file_list)
6927 AC_SUBST(tm_include_list)
6928 AC_SUBST(tm_defines)
6929 AC_SUBST(tm_p_file_list)
6930 AC_SUBST(tm_p_include_list)
6931 AC_SUBST(tm_d_file_list)
6932 AC_SUBST(tm_d_include_list)
6933 AC_SUBST(xm_file_list)
6934 AC_SUBST(xm_include_list)
6935 AC_SUBST(xm_defines)
6936 AC_SUBST(use_gcc_stdint)
6937 AC_SUBST(c_target_objs)
6938 AC_SUBST(cxx_target_objs)
6939 AC_SUBST(fortran_target_objs)
6940 AC_SUBST(d_target_objs)
6941 AC_SUBST(target_cpu_default)
6943 AC_SUBST_FILE(language_hooks)
6946 if test x${build} = x${host} ; then
6947 if test x${host} = x${target} ; then
6948 echo "Links are now set up to build a native compiler for ${target}." 1>&2
6950 echo "Links are now set up to build a cross-compiler" 1>&2
6951 echo " from ${host} to ${target}." 1>&2
6954 if test x${host} = x${target} ; then
6955 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
6956 echo " for ${target}." 1>&2
6958 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
6959 echo " from ${host} to ${target}." 1>&2
6963 AC_ARG_VAR(GMPLIBS,[How to link GMP])
6964 AC_ARG_VAR(GMPINC,[How to find GMP include files])
6966 AC_ARG_VAR(ISLLIBS,[How to link isl])
6967 AC_ARG_VAR(ISLINC,[How to find isl include files])
6968 if test "x${ISLLIBS}" != "x" ; then
6969 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
6973 AC_SUBST(pluginlibs)
6974 AC_SUBST(enable_plugin)
6975 if test x"$enable_plugin" = x"yes"; then
6976 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
6980 # Enable --enable-host-shared
6981 AC_ARG_ENABLE(host-shared,
6982 [AS_HELP_STRING([--enable-host-shared],
6983 [build host code as shared libraries])],
6984 [PICFLAG=-fPIC], [PICFLAG=])
6985 AC_SUBST(enable_host_shared)
6989 AC_ARG_ENABLE(libquadmath-support,
6990 [AS_HELP_STRING([--disable-libquadmath-support],
6991 [disable libquadmath support for Fortran])],
6992 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
6993 ENABLE_LIBQUADMATH_SUPPORT=yes)
6994 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
6995 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
6996 [Define to 1 to enable libquadmath support])
7000 # Specify what hash style to use by default.
7001 AC_ARG_WITH([linker-hash-style],
7002 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
7003 [specify the linker hash style])],
7004 [case x"$withval" in
7006 LINKER_HASH_STYLE=sysv
7009 LINKER_HASH_STYLE=gnu
7012 LINKER_HASH_STYLE=both
7015 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
7018 [LINKER_HASH_STYLE=''])
7019 if test x"${LINKER_HASH_STYLE}" != x; then
7020 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
7021 [The linker hash style])
7024 # Specify what should be the default of -fdiagnostics-color option.
7025 AC_ARG_WITH([diagnostics-color],
7026 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
7027 [specify the default of -fdiagnostics-color option
7028 auto-if-env stands for -fdiagnostics-color=auto if
7029 GCC_COLOR environment variable is present and
7030 -fdiagnostics-color=never otherwise])],
7031 [case x"$withval" in
7033 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
7036 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
7039 DIAGNOSTICS_COLOR_DEFAULT=-1
7042 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
7045 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
7048 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
7049 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
7050 [The default for -fdiagnostics-color option])
7052 # Specify what should be the default of -fdiagnostics-urls option.
7053 AC_ARG_WITH([diagnostics-urls],
7054 [AC_HELP_STRING([--with-diagnostics-urls={never,auto,auto-if-env,always}],
7055 [specify the default of -fdiagnostics-urls option
7056 auto-if-env stands for -fdiagnostics-urls=auto if
7057 GCC_URLS or TERM_URLS environment variable is present and
7058 -fdiagnostics-urls=never otherwise])],
7059 [case x"$withval" in
7061 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_NO
7064 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO
7067 DIAGNOSTICS_URLS_DEFAULT=-1
7070 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_YES
7073 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-urls])
7076 [DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO])
7077 AC_DEFINE_UNQUOTED(DIAGNOSTICS_URLS_DEFAULT, $DIAGNOSTICS_URLS_DEFAULT,
7078 [The default for -fdiagnostics-urls option])
7080 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
7081 # of jit/jit-playback.c.
7082 gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"`
7083 echo "gcc_driver_version: ${gcc_driver_version}"
7084 cat > gcc-driver-name.h <<EOF
7085 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_driver_version}${exeext}"
7088 # Check whether --enable-default-pie was given.
7089 AC_ARG_ENABLE(default-pie,
7090 [AS_HELP_STRING([--enable-default-pie],
7091 [enable Position Independent Executable as default])],
7092 enable_default_pie=$enableval,
7093 enable_default_pie=no)
7094 if test x$enable_default_pie = xyes ; then
7095 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
7096 [Define if your target supports default PIE and it is enabled.])
7098 AC_SUBST([enable_default_pie])
7100 # Check if -fno-PIE works.
7101 AC_CACHE_CHECK([for -fno-PIE option],
7103 [saved_CXXFLAGS="$CXXFLAGS"
7104 CXXFLAGS="$CXXFLAGS -fno-PIE"
7105 AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7106 [gcc_cv_c_no_fpie=yes],
7107 [gcc_cv_c_no_fpie=no])
7108 CXXFLAGS="$saved_CXXFLAGS"])
7109 if test "$gcc_cv_c_no_fpie" = "yes"; then
7110 NO_PIE_CFLAGS="-fno-PIE"
7112 AC_SUBST([NO_PIE_CFLAGS])
7114 # Check if -no-pie works.
7115 AC_CACHE_CHECK([for -no-pie option],
7117 [saved_LDFLAGS="$LDFLAGS"
7118 LDFLAGS="$LDFLAGS -no-pie"
7119 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7120 [gcc_cv_no_pie=yes],
7122 LDFLAGS="$saved_LDFLAGS"])
7123 if test "$gcc_cv_no_pie" = "yes"; then
7124 NO_PIE_FLAG="-no-pie"
7126 AC_SUBST([NO_PIE_FLAG])
7128 # Enable Intel CET on Intel CET enabled host if jit is enabled.
7129 GCC_CET_HOST_FLAGS(CET_HOST_FLAGS)
7130 case x$enable_languages in
7137 AC_SUBST(CET_HOST_FLAGS)
7139 # Check linker supports '-z bndplt'
7140 ld_bndplt_support=no
7141 AC_MSG_CHECKING(linker -z bndplt option)
7142 if test x"$ld_is_gold" = xno; then
7143 if test $in_tree_ld = yes ; then
7144 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
7145 ld_bndplt_support=yes
7147 elif test x$gcc_cv_ld != x; then
7148 # Check if linker supports -a bndplt option
7149 if $gcc_cv_ld --help 2>&1 | grep -- '-z bndplt' > /dev/null; then
7150 ld_bndplt_support=yes
7154 if test x"$ld_bndplt_support" = xyes; then
7155 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
7156 [Define if your linker supports -z bndplt])
7158 AC_MSG_RESULT($ld_bndplt_support)
7160 # Check linker supports '--push-state'/'--pop-state'
7161 ld_pushpopstate_support=no
7162 AC_MSG_CHECKING(linker --push-state/--pop-state options)
7163 if test x"$ld_is_gold" = xno; then
7164 if test $in_tree_ld = yes ; then
7165 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
7166 ld_pushpopstate_support=yes
7168 elif test x$gcc_cv_ld != x; then
7169 # Check if linker supports --push-state/--pop-state options
7170 if $gcc_cv_ld --help 2>&1 | grep -- '--push-state' > /dev/null; then
7171 ld_pushpopstate_support=yes
7175 if test x"$ld_pushpopstate_support" = xyes; then
7176 AC_DEFINE(HAVE_LD_PUSHPOPSTATE_SUPPORT, 1,
7177 [Define if your linker supports --push-state/--pop-state])
7179 AC_MSG_RESULT($ld_pushpopstate_support)
7181 # Configure the subdirectories
7182 # AC_CONFIG_SUBDIRS($subdirs)
7184 # Create the Makefile
7185 # and configure language subdirectories
7186 AC_CONFIG_FILES($all_outputs)
7188 AC_CONFIG_COMMANDS([default],
7190 case ${CONFIG_HEADERS} in
7191 *auto-host.h:config.in*)
7194 # Make sure all the subdirs exist.
7195 for d in $subdirs doc build common c-family
7197 test -d $d || mkdir $d
7200 [subdirs='$subdirs'])