2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2022 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3. If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
27 AC_CONFIG_SRCDIR(tree.cc)
28 AC_CONFIG_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 # Configuration for an alternate set of C++ headers.
232 gcc_gxx_libcxx_include_dir=
233 # Specify the alternate g++ header file directory
234 AC_ARG_WITH(gxx-libcxx-include-dir,
235 [AS_HELP_STRING([--with-gxx-libcxx-include-dir=DIR],
236 [specifies directory to find libc++ header files])],
237 [case "${withval}" in
238 yes) AC_MSG_ERROR(bad value ${withval} given for libc++ include directory) ;;
240 *) gcc_gxx_libcxx_include_dir=$with_gxx_libcxx_include_dir ;;
243 # If both --with-sysroot and --with-gxx-libcxx-include-dir are passed, we
244 # check to see if the latter starts with the former and, upon success, compute
245 # gcc_gxx_libcxx_include_dir as relative to the sysroot.
246 gcc_gxx_libcxx_include_dir_add_sysroot=0
248 if test x${gcc_gxx_libcxx_include_dir} != x; then
249 AC_DEFINE(ENABLE_STDLIB_OPTION, 1,
250 [Define if the -stdlib= option should be enabled.])
252 AC_DEFINE(ENABLE_STDLIB_OPTION, 0)
254 # ??? This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
255 if test x${gcc_gxx_libcxx_include_dir} = x; then
256 if test x${enable_version_specific_runtime_libs} = xyes; then
257 gcc_gxx_libcxx_include_dir='${libsubdir}/libc++_include/c++/v1'
259 libcxx_incdir='libc++_include/c++/$(version)/v1'
260 if test x$host != x$target; then
261 libcxx_incdir="$target_alias/$libcxx_incdir"
263 gcc_gxx_libcxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libcxx_incdir"
265 elif test "${with_sysroot+set}" = set; then
266 gcc_gxx_libcxx_without_sysroot=`expr "${gcc_gxx_libcxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
267 if test "${gcc_gxx_libcxx_without_sysroot}"; then
268 gcc_gxx_libcxx_include_dir="${gcc_gxx_libcxx_without_sysroot}"
269 gcc_gxx_libcxx_include_dir_add_sysroot=1
273 AC_ARG_WITH(cpp_install_dir,
274 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
275 [install the user visible C preprocessor in DIR
276 (relative to PREFIX) as well as PREFIX/bin])],
277 [if test x$withval = xyes; then
278 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
279 elif test x$withval != xno; then
280 cpp_install_dir=$withval
283 # We would like to our source tree to be readonly. However when releases or
284 # pre-releases are generated, the flex/bison generated files as well as the
285 # various formats of manuals need to be included along with the rest of the
286 # sources. Therefore we have --enable-generated-files-in-srcdir to do
289 AC_MSG_CHECKING([whether to place generated files in the source directory])
290 dnl generated-files-in-srcdir is disabled by default
291 AC_ARG_ENABLE(generated-files-in-srcdir,
292 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
293 [put copies of generated files in source dir
294 intended for creating source tarballs for users
295 without texinfo bison or flex])],
296 generated_files_in_srcdir=$enableval,
297 generated_files_in_srcdir=no)
299 AC_MSG_RESULT($generated_files_in_srcdir)
301 if test "$generated_files_in_srcdir" = "yes"; then
308 # -------------------
309 # Find default linker
310 # -------------------
314 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
315 gnu_ld_flag="$with_gnu_ld",
320 ld64_flag=yes # Darwin can only use a ld64-compatible linker.
321 dsymutil_flag=yes # Darwin uses dsymutil to link debug.
329 # With pre-defined ld
331 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
332 DEFAULT_LINKER="$with_ld")
333 if test x"${DEFAULT_LINKER+set}" = x"set"; then
334 if test ! -x "$DEFAULT_LINKER"; then
335 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
336 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
338 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep ld64- > /dev/null; then
341 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
342 [Define to enable the use of a default linker.])
345 AC_MSG_CHECKING([whether a default linker was specified])
346 if test x"${DEFAULT_LINKER+set}" = x"set"; then
347 if test x"$gnu_ld_flag" = x"no"; then
348 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
350 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
356 # With demangler in GNU ld
357 AC_ARG_WITH(demangler-in-ld,
358 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
359 demangler_in_ld="$with_demangler_in_ld",
362 # Allow the user to specify a dsymutil executable (used on Darwin only, so far)
363 AC_ARG_WITH(dsymutil,
364 [AS_HELP_STRING([--with-dsymutil], [arrange to use the specified dsymutil (full pathname)])],
365 DEFAULT_DSYMUTIL="$with_dsymutil")
368 if test x"${DEFAULT_DSYMUTIL+set}" = x"set"; then
369 if test ! -x "$DEFAULT_DSYMUTIL"; then
370 AC_MSG_ERROR([cannot execute: $DEFAULT_DSYMUTIL: check --with-dsymutil or env. var. DEFAULT_DSYMUTIL])
372 if dsymutil_vers=`$DEFAULT_DSYMUTIL -v /dev/null 2>&1`; then
376 AC_DEFINE_UNQUOTED(DEFAULT_DSYMUTIL,"$DEFAULT_DSYMUTIL",
377 [Define to enable the use of a default debug linker.])
380 AC_MSG_CHECKING([whether a default dsymutil was specified])
381 if test x"${DEFAULT_DSYMUTIL+set}" = x"set"; then
382 AC_MSG_RESULT([yes ($DEFAULT_DSYMUTIL)])
387 # ----------------------
388 # Find default assembler
389 # ----------------------
393 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
394 gas_flag="$with_gnu_as",
398 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
399 DEFAULT_ASSEMBLER="$with_as")
400 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
401 if test ! -x "$DEFAULT_ASSEMBLER"; then
402 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
403 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
406 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
407 [Define to enable the use of a default assembler.])
410 AC_MSG_CHECKING([whether a default assembler was specified])
411 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
412 if test x"$gas_flag" = x"no"; then
413 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
415 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
425 # If a non-executable a.out is present (e.g. created by GNU as above even if
426 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
427 # file, even when creating an executable, so an execution test fails.
428 # Remove possible default executable files to avoid this.
430 # FIXME: This really belongs into AC_PROG_CC and can be removed once
431 # Autoconf includes it.
432 rm -f a.out a.exe b.out
434 # Find the native compiler
437 ACX_PROG_GNAT([-I"$srcdir"/ada/libgnat])
438 ACX_PROG_GDC([-I"$srcdir"/d])
440 # Do configure tests with the C++ compiler, since that's what we build with.
443 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
444 # optimizations to be activated explicitly by the toplevel.
447 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
448 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
454 # Determine PICFLAG for target gnatlib.
455 GCC_PICFLAG_FOR_TARGET
456 AC_SUBST(PICFLAG_FOR_TARGET)
458 # -------------------------
459 # Check C compiler features
460 # -------------------------
462 AC_USE_SYSTEM_EXTENSIONS
468 AC_CHECK_SIZEOF(ino_t)
469 AC_CHECK_SIZEOF(dev_t)
471 # Select the right stat being able to handle 64bit inodes, if needed.
472 if test "$enable_largefile" != no; then
473 case "$host, $build" in
474 *-*-aix*,*|*,*-*-aix*)
475 if test "$ac_cv_sizeof_ino_t" == "4" -a "$ac_cv_sizeof_dev_t" == 4; then
476 AC_DEFINE(HOST_STAT_FOR_64BIT_INODES, stat64x,
477 [Define which stat syscall is able to handle 64bit indodes.])
483 # sizeof(char) is 1 by definition.
484 AC_CHECK_SIZEOF(void *)
485 AC_CHECK_SIZEOF(short)
487 AC_CHECK_SIZEOF(long)
488 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
490 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
491 AC_MSG_ERROR([uint64_t or int64_t not found])
494 # check what underlying integer type int64_t uses
495 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
496 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
500 template <typename T> struct X { };
502 struct X<long> { typedef long t; };
503 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
504 if test "$ac_cv_int64_t_type" = "long"; then
505 AC_DEFINE(INT64_T_IS_LONG, 1,
506 [Define if int64_t uses long as underlying type.])
508 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
512 template <typename T> struct X { };
514 struct X<long long> { typedef long long t; };
515 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
518 AC_CACHE_CHECK(for std::swap in <utility>, ac_cv_std_swap_in_utility, [
519 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
521 ]], [[int a, b; std::swap(a,b);]])],[ac_cv_std_swap_in_utility=yes],[ac_cv_std_swap_in_utility=no])])
522 if test $ac_cv_std_swap_in_utility = yes; then
523 AC_DEFINE(HAVE_SWAP_IN_UTILITY, 1,
524 [Define if <utility> defines std::swap.])
527 # Check whether compiler is affected by placement new aliasing bug (PR 29286).
528 # If the host compiler is affected by the bug, and we build with optimization
529 # enabled (which happens e.g. when cross-compiling), the pool allocator may
530 # get miscompiled. Use -fno-strict-aliasing to work around this problem.
531 # Since there is no reliable feature check for the presence of this bug,
532 # we simply use a GCC version number check. (This should never trigger for
533 # stages 2 or 3 of a native bootstrap.)
535 if test "$GCC" = yes; then
536 saved_CXXFLAGS="$CXXFLAGS"
538 # The following test compilation will succeed if and only if $CXX accepts
539 # -fno-strict-aliasing *and* is older than GCC 4.3.
540 CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
541 AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug])
542 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
543 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
544 #error compiler not affected by placement new aliasing bug
547 [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'],
548 [AC_MSG_RESULT([no])])
550 CXXFLAGS="$saved_CXXFLAGS"
552 AC_SUBST(aliasing_flags)
556 # ---------------------
557 # Warnings and checking
558 # ---------------------
560 # Check $CC warning features (if it's GCC).
561 # We want to use -pedantic, but we don't want warnings about
565 # * C++11 narrowing conversions in { }
566 # So, we only use -pedantic if we can disable those warnings.
568 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
569 AC_ARG_ENABLE(build-format-warnings,
570 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
571 [],[enable_build_format_warnings=yes])
572 AS_IF([test $enable_build_format_warnings = no],
573 [wf_opt=-Wno-format],[wf_opt=])
574 ACX_PROG_CXX_WARNING_OPTS(
575 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings ],
576 [-Wcast-qual $wf_opt])),
578 ACX_PROG_CC_WARNING_OPTS(
579 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes ],
580 [])), [c_loose_warn])
581 ACX_PROG_CXX_WARNING_OPTS(
582 m4_quote(m4_do([-Wmissing-format-attribute ],
583 [-Woverloaded-virtual])), [strict_warn])
584 ACX_PROG_CC_WARNING_OPTS(
585 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
586 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
587 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
588 [-Wno-overlength-strings])), [strict_warn])
589 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
591 # The above macros do nothing if the compiler is not GCC. However, the
592 # Makefile has more goo to add other flags, so these variables are used
593 # to enable warnings only for GCC.
596 if test "x$GCC" = "xyes"; then
597 warn_cflags='$(GCC_WARN_CFLAGS)'
598 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
600 AC_SUBST(warn_cflags)
601 AC_SUBST(warn_cxxflags)
603 # Disable exceptions and RTTI if building with g++
604 ACX_PROG_CC_WARNING_OPTS(
605 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
608 # Enable expensive internal checks
610 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
614 AC_ARG_ENABLE(checking,
615 [AS_HELP_STRING([[--enable-checking[=LIST]]],
616 [enable expensive run-time checks. With LIST,
617 enable only specific categories of checks.
618 Categories are: yes,no,all,none,release.
619 Flags are: assert,df,extra,fold,gc,gcac,gimple,misc,
620 rtlflag,rtl,runtime,tree,valgrind,types])],
621 [ac_checking_flags="${enableval}"],[
622 # Determine the default checks.
623 if test x$is_release = x ; then
624 ac_checking_flags=yes,extra
626 ac_checking_flags=release
628 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
629 for check in release $ac_checking_flags
632 # these set all the flags to specific states
633 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
634 ac_fold_checking= ; ac_gc_checking=1 ; ac_extra_checking= ;
635 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
636 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
637 ac_tree_checking=1 ; ac_valgrind_checking= ;
638 ac_types_checking=1 ;;
639 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
640 ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
641 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
642 ac_rtlflag_checking= ; ac_runtime_checking= ;
643 ac_tree_checking= ; ac_valgrind_checking= ;
644 ac_types_checking= ;;
645 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
646 ac_fold_checking=1 ; ac_gc_checking=1 ; ac_extra_checking=1 ;
647 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
648 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
649 ac_tree_checking=1 ; ac_valgrind_checking= ;
650 ac_types_checking=1 ;;
651 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
652 ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
653 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
654 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
655 ac_tree_checking= ; ac_valgrind_checking= ;
656 ac_types_checking= ;;
657 # these enable particular checks
658 assert) ac_assert_checking=1 ;;
659 df) ac_df_checking=1 ;;
660 extra) ac_extra_checking=1 ;;
661 fold) ac_fold_checking=1 ;;
662 gc) ac_gc_checking=1 ;;
663 gcac) ac_gc_always_collect=1 ;;
664 gimple) ac_gimple_checking=1 ;;
665 misc) ac_checking=1 ;;
666 rtl) ac_rtl_checking=1 ;;
667 rtlflag) ac_rtlflag_checking=1 ;;
668 runtime) ac_runtime_checking=1 ;;
669 tree) ac_tree_checking=1 ;;
670 types) ac_types_checking=1 ;;
671 valgrind) ac_valgrind_checking=1 ;;
672 *) AC_MSG_ERROR(unknown check category $check) ;;
678 if test x$ac_checking != x ; then
679 AC_DEFINE(CHECKING_P, 1,
680 [Define to 0/1 if you want more run-time sanity checks. This one gets a grab
681 bag of miscellaneous but relatively cheap checks.])
682 nocommon_flag=-fno-common
684 AC_DEFINE(CHECKING_P, 0)
686 AC_SUBST(nocommon_flag)
687 if test x$ac_extra_checking != x ; then
688 AC_DEFINE(ENABLE_EXTRA_CHECKING, 1,
689 [Define to 0/1 if you want extra run-time checking that might affect code
692 AC_DEFINE(ENABLE_EXTRA_CHECKING, 0)
694 if test x$ac_df_checking != x ; then
695 AC_DEFINE(ENABLE_DF_CHECKING, 1,
696 [Define if you want more run-time sanity checks for dataflow.])
698 if test x$ac_assert_checking != x ; then
699 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
700 [Define if you want assertions enabled. This is a cheap check.])
702 if test x$ac_gimple_checking != x ; then
703 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
704 [Define if you want operations on GIMPLE (the basic data structure of
705 the high-level optimizers) to be checked for dynamic type safety at
706 runtime. This is moderately expensive.])
708 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
709 if test x$ac_runtime_checking != x ; then
710 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
711 [Define if you want runtime assertions enabled. This is a cheap check.])
713 if test x$ac_tree_checking != x ; then
714 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
715 [Define if you want all operations on trees (the basic data
716 structure of the front ends) to be checked for dynamic type safety
717 at runtime. This is moderately expensive.
721 if test x$ac_types_checking != x ; then
722 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
723 [Define if you want all gimple types to be verified after gimplifiation.
727 AC_SUBST(TREECHECKING)
728 if test x$ac_rtl_checking != x ; then
729 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
730 [Define if you want all operations on RTL (the basic data structure
731 of the optimizer and back end) to be checked for dynamic type safety
732 at runtime. This is quite expensive.])
734 if test x$ac_rtlflag_checking != x ; then
735 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
736 [Define if you want RTL flag accesses to be checked against the RTL
737 codes that are supported for each access macro. This is relatively
740 if test x$ac_gc_checking != x ; then
741 AC_DEFINE(ENABLE_GC_CHECKING, 1,
742 [Define if you want the garbage collector to do object poisoning and
743 other memory allocation checks. This is quite expensive.])
745 if test x$ac_gc_always_collect != x ; then
746 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
747 [Define if you want the garbage collector to operate in maximally
748 paranoid mode, validating the entire heap and collecting garbage at
749 every opportunity. This is extremely expensive.])
751 if test x$ac_fold_checking != x ; then
752 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
753 [Define if you want fold checked that it never destructs its argument.
754 This is quite expensive.])
756 valgrind_path_defines=
759 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
760 dnl # an if statement. This was the source of very frustrating bugs
761 dnl # in converting to autoconf 2.5x!
762 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
764 # It is certainly possible that there's valgrind but no valgrind.h.
765 # GCC relies on making annotations so we must have both.
766 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
767 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
768 [[#include <valgrind/memcheck.h>
769 #ifndef VALGRIND_DISCARD
770 #error VALGRIND_DISCARD not defined
772 [gcc_cv_header_valgrind_memcheck_h=yes],
773 [gcc_cv_header_valgrind_memcheck_h=no])
774 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
775 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
776 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
777 [[#include <memcheck.h>
778 #ifndef VALGRIND_DISCARD
779 #error VALGRIND_DISCARD not defined
781 [gcc_cv_header_memcheck_h=yes],
782 [gcc_cv_header_memcheck_h=no])
783 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
784 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
785 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
786 [Define if valgrind's valgrind/memcheck.h header is installed.])
788 if test $gcc_cv_header_memcheck_h = yes; then
789 AC_DEFINE(HAVE_MEMCHECK_H, 1,
790 [Define if valgrind's memcheck.h header is installed.])
793 if test x$ac_valgrind_checking != x ; then
794 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
795 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
796 if test "x$valgrind_path" = "x" \
797 || (test $have_valgrind_h = no \
798 && test $gcc_cv_header_memcheck_h = no \
799 && test $gcc_cv_header_valgrind_memcheck_h = no); then
800 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
802 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
803 valgrind_command="$valgrind_path -q"
804 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
805 [Define if you want to run subprograms and generated programs
806 through valgrind (a memory checker). This is extremely expensive.])
808 AC_SUBST(valgrind_path_defines)
809 AC_SUBST(valgrind_command)
811 # Enable code coverage collection
812 AC_ARG_ENABLE(coverage,
813 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
814 [enable compiler's code coverage collection.
815 Use to measure compiler performance and locate
816 unused parts of the compiler. With LEVEL, specify
817 optimization. Values are opt, noopt,
819 [case "${enableval}" in
821 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0 -fkeep-static-functions"
824 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2 -fkeep-static-functions"
827 # a.k.a. --disable-coverage
831 AC_MSG_ERROR(unknown coverage setting $enableval)
835 AC_SUBST(coverage_flags)
837 AC_ARG_ENABLE(gather-detailed-mem-stats,
838 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
839 [enable detailed memory allocation stats gathering])], [],
840 [enable_gather_detailed_mem_stats=no])
841 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
842 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
843 [Define to enable detailed memory allocation stats gathering.])
845 AC_ARG_ENABLE(valgrind-annotations,
846 [AS_HELP_STRING([--enable-valgrind-annotations],
847 [enable valgrind runtime interaction])], [],
848 [enable_valgrind_annotations=no])
849 if test x$enable_valgrind_annotations != xno \
850 || test x$ac_valgrind_checking != x; then
851 if (test $have_valgrind_h = no \
852 && test $gcc_cv_header_memcheck_h = no \
853 && test $gcc_cv_header_valgrind_memcheck_h = no); then
854 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
856 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
857 [Define to get calls to the valgrind runtime enabled.])
860 # -------------------------------
861 # Miscenalleous configure options
862 # -------------------------------
864 # Determine whether or not multilibs are enabled.
865 AC_ARG_ENABLE(multilib,
866 [AS_HELP_STRING([--enable-multilib],
867 [enable library support for multiple ABIs])],
868 [], [enable_multilib=yes])
869 AC_SUBST(enable_multilib)
871 # Determine whether or not multiarch is enabled.
872 AC_ARG_ENABLE(multiarch,
873 [AS_HELP_STRING([--enable-multiarch],
874 [enable support for multiarch paths])],
875 [case "${enableval}" in
876 yes|no|auto) enable_multiarch=$enableval;;
877 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
878 esac], [enable_multiarch=auto])
879 if test x${enable_multiarch} = xauto; then
880 if test x${with_native_system_header_dir} != x; then
881 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
884 if test x$host != x$target && test "x$with_sysroot" = x; then
885 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
889 AC_MSG_CHECKING(for multiarch configuration)
890 AC_SUBST(enable_multiarch)
891 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
893 # needed for setting the multiarch name for soft-float/hard-float ABIs
897 # default stack clash protection guard size as power of twos in bytes.
898 # Please keep these in sync with params.def.
902 # Keep the default value when the option is not used to 0, this allows us to
903 # distinguish between the cases where the user specifially set a value via
904 # configure and when the normal default value is used.
905 AC_ARG_WITH(stack-clash-protection-guard-size,
906 [AS_HELP_STRING([--with-stack-clash-protection-guard-size=size],
907 [Set the default stack clash protection guard size for specific targets as a power of two in bytes.])],
908 [DEFAULT_STK_CLASH_GUARD_SIZE="$with_stack_clash_protection_guard_size"], [DEFAULT_STK_CLASH_GUARD_SIZE=0])
909 if test $DEFAULT_STK_CLASH_GUARD_SIZE -ne 0 \
910 && (test $DEFAULT_STK_CLASH_GUARD_SIZE -lt $stk_clash_min \
911 || test $DEFAULT_STK_CLASH_GUARD_SIZE -gt $stk_clash_max); then
912 AC_MSG_ERROR(m4_normalize([
913 Invalid value $DEFAULT_STK_CLASH_GUARD_SIZE for --with-stack-clash-protection-guard-size. \
914 Must be between $stk_clash_min and $stk_clash_max.]))
917 AC_DEFINE_UNQUOTED(DEFAULT_STK_CLASH_GUARD_SIZE, $DEFAULT_STK_CLASH_GUARD_SIZE,
918 [Define to larger than zero set the default stack clash protector size.])
920 # Enable __cxa_atexit for C++.
921 AC_ARG_ENABLE(__cxa_atexit,
922 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
925 # Enable C extension for decimal float if target supports it.
926 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
928 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
929 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
930 [Define to 1 to enable decimal float extension to C.])
932 # Use default_decimal_float for dependency.
933 enable_decimal_float=$default_decimal_float
935 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
936 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
937 [Define to 1 to specify that we are using the BID decimal floating
938 point format instead of DPD])
940 # Enable C extension for fixed-point arithmetic.
941 AC_ARG_ENABLE(fixed-point,
942 [AS_HELP_STRING([--enable-fixed-point],
943 [enable fixed-point arithmetic extension to C])],
948 enable_fixed_point=yes
952 enable_fixed_point=yes
955 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
956 enable_fixed_point=no
960 AC_SUBST(enable_fixed_point)
962 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
963 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
964 [Define to 1 to enable fixed-point arithmetic extension to C.])
967 # Pass with no value to take the default
968 # Pass with a value to specify a thread package
969 AC_ARG_ENABLE(threads,
970 [AS_HELP_STRING([[--enable-threads[=LIB]]],
971 [enable thread usage for target GCC,
972 using LIB thread package])],,
976 [AS_HELP_STRING([--enable-tls],
977 [enable or disable generation of tls code
978 overriding the assembler check for tls support])],
982 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
983 Valid choices are 'yes' and 'no'.]) ;;
987 AC_ARG_ENABLE(vtable-verify,
988 [AS_HELP_STRING([--enable-vtable-verify],
989 [enable vtable verification feature])],,
990 [enable_vtable_verify=no])
991 vtable_verify=`if test x$enable_vtable_verify = xyes; then echo 1; else echo 0; fi`
992 AC_DEFINE_UNQUOTED(ENABLE_VTABLE_VERIFY, $vtable_verify,
993 [Define 0/1 if vtable verification feature is enabled.])
995 AC_ARG_ENABLE(analyzer,
996 [AS_HELP_STRING([--disable-analyzer],
997 [disable -fanalyzer static analyzer])],
998 if test x$enable_analyzer = xno; then
1004 AC_DEFINE_UNQUOTED(ENABLE_ANALYZER, $analyzer,
1005 [Define 0/1 if static analyzer feature is enabled.])
1007 AC_ARG_ENABLE(objc-gc,
1008 [AS_HELP_STRING([--enable-objc-gc],
1009 [enable the use of Boehm's garbage collector with
1010 the GNU Objective-C runtime])],
1011 if test x$enable_objc_gc = xno; then
1019 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
1020 dwarf2="$with_dwarf2",
1023 AC_ARG_ENABLE(shared,
1024 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
1026 case $enable_shared in
1030 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1031 for pkg in $enableval; do
1032 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
1039 ], [enable_shared=yes])
1040 AC_SUBST(enable_shared)
1043 [ --disable-gcov don't provide libgcov and related host tools],
1044 [], [case $target in
1053 AC_SUBST(enable_gcov)
1056 [AS_HELP_STRING([--with-specs=SPECS],
1057 [add SPECS to driver command-line processing])],
1058 [CONFIGURE_SPECS=$withval],
1061 AC_SUBST(CONFIGURE_SPECS)
1063 ACX_PKGVERSION([GCC])
1064 ACX_BUGURL([https://gcc.gnu.org/bugs/])
1066 # Allow overriding the default URL for documentation
1067 AC_ARG_WITH(documentation-root-url,
1068 AS_HELP_STRING([--with-documentation-root-url=URL],
1069 [Root for documentation URLs]),
1071 yes) AC_MSG_ERROR([documentation root URL not specified]) ;;
1072 no) AC_MSG_ERROR([documentation root URL not specified]) ;;
1073 */) DOCUMENTATION_ROOT_URL="$withval" ;;
1074 *) AC_MSG_ERROR([documentation root URL does not end with /]) ;;
1076 DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/"
1078 AC_DEFINE_UNQUOTED(DOCUMENTATION_ROOT_URL,"$DOCUMENTATION_ROOT_URL",
1079 [Define to the root for documentation URLs.])
1081 # Allow overriding the default URL for GCC changes
1082 AC_ARG_WITH(changes-root-url,
1083 AS_HELP_STRING([--with-changes-root-url=URL],
1084 [Root for GCC changes URLs]),
1086 yes) AC_MSG_ERROR([changes root URL not specified]) ;;
1087 no) AC_MSG_ERROR([changes root URL not specified]) ;;
1088 */) CHANGES_ROOT_URL="$withval" ;;
1089 *) AC_MSG_ERROR([changes root URL does not end with /]) ;;
1091 CHANGES_ROOT_URL="https://gcc.gnu.org/"
1093 AC_DEFINE_UNQUOTED(CHANGES_ROOT_URL,"$CHANGES_ROOT_URL",
1094 [Define to the root for URLs about GCC changes.])
1096 # Sanity check enable_languages in case someone does not run the toplevel
1097 # configure # script.
1098 AC_ARG_ENABLE(languages,
1099 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
1100 [case ,${enable_languages}, in
1102 # go safe -- we cannot be much sure without the toplevel
1104 # analysis of which target libs are present and usable
1108 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
1113 enable_languages=c,${enable_languages}
1116 [enable_languages=c])
1118 # If top-level libada has been disabled, then wire in install-gnatlib
1119 # invocation with `make install', so that one can build and install
1120 # the library manually with `make -C gcc all gnatlib gnattools install'.
1121 if test x"$enable_libada" = xno; then
1122 gnat_install_lib=gnat-install-lib
1126 AC_SUBST(gnat_install_lib)
1128 if test x"$enable_as_accelerator_for" != x; then
1129 AC_DEFINE(ACCEL_COMPILER, 1,
1130 [Define if this compiler should be built as the offload target compiler.])
1131 enable_as_accelerator=yes
1134 # In this case we expect offload compiler to be built as native, so we
1135 # need to rename the driver to avoid clashes with host's drivers.
1136 program_transform_name="s&^&${target}-&" ;;
1138 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
1139 program_transform_name=`echo $program_transform_name | sed $sedscript`
1140 accel_dir_suffix=/accel/${target_noncanonical}
1141 real_target_noncanonical=${enable_as_accelerator_for}
1143 AC_SUBST(enable_as_accelerator)
1144 AC_SUBST(real_target_noncanonical)
1145 AC_SUBST(accel_dir_suffix)
1147 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
1148 tgt=`echo $tgt | sed 's/=.*//'`
1152 *-intelmic-* | *-intelmicemul-*)
1153 omp_device_property=omp-device-properties-i386
1154 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/i386/t-omp-device"
1157 omp_device_property=omp-device-properties-gcn
1158 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/gcn/t-omp-device"
1161 omp_device_property=omp-device-properties-nvptx
1162 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/nvptx/t-omp-device"
1165 AC_MSG_ERROR([unknown offload target specified])
1168 omp_device_properties="${omp_device_properties} ${tgt}=${omp_device_property}"
1169 omp_device_property_deps="${omp_device_property_deps} ${omp_device_property}"
1171 if test x"$offload_targets" = x; then
1172 offload_targets=$tgt
1174 offload_targets="$offload_targets,$tgt"
1177 AC_SUBST(omp_device_properties)
1178 AC_SUBST(omp_device_property_deps)
1180 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
1181 [Define to offload targets, separated by commas.])
1182 if test x"$enable_offloading" != x; then
1183 AC_DEFINE(ENABLE_OFFLOADING, 1,
1184 [Define this to enable support for offloading.])
1186 AC_DEFINE(ENABLE_OFFLOADING, 0,
1187 [Define this to enable support for offloading.])
1190 if test "x$enable_offload_defaulted" = xyes; then
1191 AC_DEFINE(OFFLOAD_DEFAULTED, 1,
1192 [Define to 1 to if -foffload is defaulted])
1195 AC_ARG_WITH(multilib-list,
1196 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, ARM, AVR, OR1K, RISC-V, SH and x86-64 only)])],
1198 with_multilib_list=default)
1200 AC_ARG_WITH(multilib-generator,
1201 [AS_HELP_STRING([--with-multilib-generator], [Multi-libs configuration string (RISC-V only)])],
1203 with_multilib_generator=default)
1205 # -------------------------
1206 # Checks for other programs
1207 # -------------------------
1211 # Find some useful tools
1213 # We need awk to create options.cc and options.h.
1214 # Bail out if it's missing.
1216 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
1223 AC_SUBST(ranlib_flags)
1227 # See if cmp has --ignore-initial.
1228 gcc_AC_PROG_CMP_IGNORE_INITIAL
1230 # See if we have the mktemp command.
1231 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
1233 # See if makeinfo has been installed and is modern enough
1234 # that we can use it.
1235 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
1236 [GNU texinfo.* \([0-9][0-9.]*\)],
1237 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
1238 if test $gcc_cv_prog_makeinfo_modern = no; then
1240 *** Makeinfo is missing or too old.
1241 *** Info documentation will not be built.])
1246 AC_SUBST(BUILD_INFO)
1248 # Is pod2man recent enough to regenerate manpages?
1249 AC_MSG_CHECKING([for recent Pod::Man])
1250 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1252 GENERATED_MANPAGES=generated-manpages
1257 AC_SUBST(GENERATED_MANPAGES)
1259 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1262 dnl Don't use AC_PROG_LEX; we insist on flex.
1263 dnl LEXLIB is not useful in gcc.
1264 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1267 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1269 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
1270 # check for build == host before using them.
1273 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1274 && test -d ../binutils ; then
1275 NM='${objdir}/../binutils/nm-new'
1277 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1281 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1282 && test -d ../binutils ; then
1283 AR='${objdir}/../binutils/ar'
1285 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1288 # The jit documentation looks better if built with sphinx, but can be
1289 # built with texinfo if sphinx is not available.
1290 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1291 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1293 # --------------------
1294 # Checks for C headers
1295 # --------------------
1297 # Need to reject headers which give warnings, so that the -Werror bootstrap
1298 # works later. *sigh* This needs to come before all header checks.
1305 AC_HEADER_TIOCGWINSZ
1306 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1307 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1308 sys/resource.h sys/param.h sys/times.h sys/stat.h sys/locking.h \
1309 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1311 # Check for thread headers.
1312 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1313 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1315 # These tests can't be done till we know if we have limits.h.
1319 # ----------------------
1320 # Checks for C++ headers
1321 # ----------------------
1323 dnl Autoconf will give an error in the configure script if there is no
1324 dnl C++ preprocessor. Hack to prevent that.
1325 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1327 m4_popdef([AC_MSG_ERROR])[]dnl
1329 AC_CHECK_HEADERS(unordered_map)
1330 AC_CHECK_HEADERS(tr1/unordered_map)
1331 AC_CHECK_HEADERS(ext/hash_map)
1334 # Dependency checking.
1338 AC_CONFIG_COMMANDS([gccdepdir],[
1339 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1340 for lang in $subdirs c-family common analyzer rtl-ssa
1342 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1343 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1345 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1352 # These libraries may be used by collect2.
1353 # We may need a special search path to get them linked.
1354 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1356 for libs in '' -lld -lmld \
1357 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1358 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1361 AC_TRY_LINK_FUNC(ldopen,
1362 [gcc_cv_collect2_libs="$libs"; break])
1365 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1366 case $gcc_cv_collect2_libs in
1368 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1370 AC_SUBST(COLLECT2_LIBS)
1372 # When building Ada code on Alpha, we need exc_resume which is usually in
1373 # -lexc. So test for it.
1376 AC_SEARCH_LIBS(exc_resume, exc)
1379 AC_SUBST(GNAT_LIBEXC)
1381 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1384 AC_SEARCH_LIBS(kstat_open, kstat)
1385 EXTRA_GCC_LIBS="$LIBS"
1387 AC_SUBST(EXTRA_GCC_LIBS)
1389 # Solaris needs libsocket and libnsl for socket functions before 11.4.
1390 # C++ needs those for libcody.
1398 # Some systems put ldexp and frexp in libm instead of libc; assume
1399 # they're both in the same place. jcf-dump needs them.
1402 AC_SEARCH_LIBS(ldexp, m)
1407 # Some systems need dlopen
1410 AC_SEARCH_LIBS(dlopen, dl)
1415 # Use <inttypes.h> only if it exists,
1416 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1418 AC_MSG_CHECKING(for inttypes.h)
1419 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1420 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1421 [[#define __STDC_FORMAT_MACROS
1422 #include <sys/types.h>
1423 #include <inttypes.h>]],
1428 [gcc_cv_header_inttypes_h=yes],
1429 [gcc_cv_header_inttypes_h=no])])
1430 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1431 if test $gcc_cv_header_inttypes_h = yes; then
1432 AC_DEFINE(HAVE_INTTYPES_H, 1,
1433 [Define if you have a working <inttypes.h> header file.])
1436 # Look for the ZSTD package.
1439 AC_SUBST(ZSTD_INCLUDE)
1443 AC_SUBST(ZSTD_CPPFLAGS)
1444 AC_SUBST(ZSTD_LDFLAGS)
1446 [AS_HELP_STRING([--with-zstd=PATH],
1447 [specify prefix directory for installed zstd library.
1448 Equivalent to --with-zstd-include=PATH/include
1449 plus --with-zstd-lib=PATH/lib])])
1450 AC_ARG_WITH(zstd-include,
1451 [AS_HELP_STRING([--with-zstd-include=PATH],
1452 [specify directory for installed zstd include files])])
1453 AC_ARG_WITH(zstd-lib,
1454 [AS_HELP_STRING([--with-zstd-lib=PATH],
1455 [specify directory for the installed zstd library])])
1456 case "x$with_zstd" in
1462 *) ZSTD_INCLUDE=$with_zstd/include
1463 ZSTD_LIB=$with_zstd/lib
1467 if test "x$with_zstd" != xno; then
1468 if test "x$with_zstd_include" != x; then
1469 ZSTD_INCLUDE=$with_zstd_include
1471 if test "x$with_zstd_lib" != x; then
1472 ZSTD_LIB=$with_zstd_lib
1474 if test "x$ZSTD_INCLUDE" != x \
1475 && test "x$ZSTD_INCLUDE" != xno; then
1476 ZSTD_CPPFLAGS=-I$ZSTD_INCLUDE
1478 if test "x$ZSTD_LIB" != x \
1479 && test "x$ZSTD_LIB" != xno; then
1480 ZSTD_LDFLAGS=-L$ZSTD_LIB
1483 CXXFLAGS="$CXXFLAGS $ZSTD_CPPFLAGS"
1484 LDFLAGS="$LDFLAGS $ZSTD_LDFLAGS"
1486 AC_MSG_CHECKING(for zstd.h)
1487 AC_CACHE_VAL(gcc_cv_header_zstd_h,
1488 # We require version 1.3.0 or later. This is the first version that has
1489 # ZSTD_getFrameContentSize.
1490 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1492 #if ZSTD_VERSION_NUMBER < 10300
1493 #error "need zstd 1.3.0 or better"
1495 [gcc_cv_header_zstd_h=yes],
1496 [gcc_cv_header_zstd_h=no])])
1497 AC_MSG_RESULT($gcc_cv_header_zstd_h)
1498 if test $gcc_cv_header_zstd_h = yes; then
1499 AC_DEFINE(HAVE_ZSTD_H, 1,
1500 [Define if you have a working <zstd.h> header file.])
1501 elif test "x$with_zstd" != x; then
1502 as_fn_error $? "Unable to find zstd.h. See config.log for details." "$LINENO" 5
1505 # LTO can use zstd compression algorithm
1508 AC_SEARCH_LIBS(ZSTD_compress, zstd)
1514 dnl Disabled until we have a complete test for buggy enum bitfields.
1515 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1517 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1518 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1519 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1520 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1521 putchar_unlocked putc_unlocked)
1522 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1523 popen sysconf strsignal getrusage nl_langinfo \
1524 gettimeofday mbstowcs wcswidth mmap posix_fallocate setlocale \
1525 gcc_UNLOCKED_FUNCS madvise mallinfo mallinfo2 fstatat)
1527 if test x$ac_cv_func_mbstowcs = xyes; then
1528 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1529 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1535 [gcc_cv_func_mbstowcs_works=yes],
1536 [gcc_cv_func_mbstowcs_works=no],
1537 [gcc_cv_func_mbstowcs_works=yes])])
1538 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1539 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1540 [Define this macro if mbstowcs does not crash when its
1541 first argument is NULL.])
1545 AC_CHECK_TYPE(ssize_t, int)
1546 AC_CHECK_TYPE(caddr_t, char *)
1547 AC_CHECK_TYPE(sighander_t,
1548 AC_DEFINE(HAVE_SIGHANDLER_T, 1,
1549 [Define if <sys/signal.h> defines sighandler_t]),
1552 GCC_AC_FUNC_MMAP_BLACKLIST
1556 # Under VMS, vfork works very differently than on Unix. The standard test
1557 # won't work, and it isn't easily adaptable. It makes more sense to
1559 ac_cv_func_vfork_works=yes
1566 # Until we have in-tree GNU iconv:
1568 if test -f "$LTLIBICONV"; then
1569 LIBICONV_DEP=$LTLIBICONV
1571 AC_SUBST(LIBICONV_DEP)
1577 # We will need to find libiberty.h and ansidecl.h
1578 saved_CFLAGS="$CFLAGS"
1579 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1580 saved_CXXFLAGS="$CXXFLAGS"
1581 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1583 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1584 # normal autoconf function for these. But force definition of
1585 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1586 # basename handling in libiberty.h.
1587 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1588 #undef HAVE_DECL_BASENAME
1589 #define HAVE_DECL_BASENAME 1
1590 #include "ansidecl.h"
1591 #include "system.h"])
1593 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1594 madvise stpcpy strnlen strsignal strverscmp \
1595 strtol strtoul strtoll strtoull setenv unsetenv \
1596 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1597 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1598 #include "ansidecl.h"
1599 #include "system.h"])
1601 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1602 #include "ansidecl.h"
1604 #ifdef HAVE_SYS_RESOURCE_H
1605 #include <sys/resource.h>
1609 gcc_AC_CHECK_DECLS(mallinfo mallinfo2, , ,[
1610 #include "ansidecl.h"
1612 #ifdef HAVE_MALLOC_H
1617 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1618 #include "ansidecl.h"
1620 #ifdef HAVE_SYS_RESOURCE_H
1621 #include <sys/resource.h>
1623 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1624 [Define to `long' if <sys/resource.h> doesn't define.])])
1626 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1627 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1628 # in collect2.cc, <fcntl.h> isn't visible, but the configure test below needs
1629 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1630 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1631 #include "ansidecl.h"
1640 gcc_AC_CHECK_DECLS(times, , ,[
1641 #include "ansidecl.h"
1643 #ifdef HAVE_SYS_TIMES_H
1644 #include <sys/times.h>
1648 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1649 #include "ansidecl.h"
1654 # More time-related stuff.
1655 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1656 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1657 #include "ansidecl.h"
1659 #ifdef HAVE_SYS_TIMES_H
1660 #include <sys/times.h>
1662 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1663 if test $ac_cv_struct_tms = yes; then
1664 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1665 [Define if <sys/times.h> defines struct tms.])
1668 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1669 # revisit after autoconf 2.50.
1670 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1671 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1672 #include "ansidecl.h"
1674 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1675 if test $gcc_cv_type_clock_t = yes; then
1676 AC_DEFINE(HAVE_CLOCK_T, 1,
1677 [Define if <time.h> defines clock_t.])
1680 # Check if F_SETLKW is supported by fcntl.
1681 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1682 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1683 #include <fcntl.h>]], [[
1689 return fcntl (1, F_SETLKW, &fl);]])],
1690 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1691 if test $ac_cv_f_setlkw = yes; then
1692 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1693 [Define if F_SETLKW supported by fcntl.])
1696 # Check if O_CLOEXEC is defined by fcntl
1697 AC_CACHE_CHECK(for O_CLOEXEC, ac_cv_o_cloexec, [
1698 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1699 #include <fcntl.h>]], [[
1700 return open ("/dev/null", O_RDONLY | O_CLOEXEC);]])],
1701 [ac_cv_o_cloexec=yes],[ac_cv_o_cloexec=no])])
1702 if test $ac_cv_o_cloexec = yes; then
1703 AC_DEFINE(HOST_HAS_O_CLOEXEC, 1,
1704 [Define if O_CLOEXEC supported by fcntl.])
1707 # C++ Modules would like some networking features to provide the mapping
1708 # server. You can still use modules without them though.
1709 # The following network-related checks could probably do with some
1710 # Windows and other non-linux defenses and checking.
1712 # Local socket connectivity wants AF_UNIX networking
1713 # Check for AF_UNIX networking
1714 AC_CACHE_CHECK(for AF_UNIX, ac_cv_af_unix, [
1715 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1716 #include <sys/types.h>
1717 #include <sys/socket.h>
1719 #include <netinet/in.h>]],[[
1721 un.sun_family = AF_UNSPEC;
1722 int fd = socket (AF_UNIX, SOCK_STREAM, 0);
1723 connect (fd, (sockaddr *)&un, sizeof (un));]])],
1724 [ac_cv_af_unix=yes],
1725 [ac_cv_af_unix=no])])
1726 if test $ac_cv_af_unix = yes; then
1727 AC_DEFINE(HAVE_AF_UNIX, 1,
1728 [Define if AF_UNIX supported.])
1731 # Remote socket connectivity wants AF_INET6 networking
1732 # Check for AF_INET6 networking
1733 AC_CACHE_CHECK(for AF_INET6, ac_cv_af_inet6, [
1734 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1735 #include <sys/types.h>
1736 #include <sys/socket.h>
1737 #include <netinet/in.h>
1738 #include <netdb.h>]],[[
1740 in6.sin6_family = AF_UNSPEC;
1741 struct addrinfo *addrs = 0;
1742 struct addrinfo hints;
1744 hints.ai_family = AF_INET6;
1745 hints.ai_socktype = SOCK_STREAM;
1746 hints.ai_protocol = 0;
1747 hints.ai_canonname = 0;
1750 int e = getaddrinfo ("localhost", 0, &hints, &addrs);
1751 const char *str = gai_strerror (e);
1752 freeaddrinfo (addrs);
1753 int fd = socket (AF_INET6, SOCK_STREAM, 0);
1754 connect (fd, (sockaddr *)&in6, sizeof (in6));]])],
1755 [ac_cv_af_inet6=yes],
1756 [ac_cv_af_inet6=no])])
1757 if test $ac_cv_af_inet6 = yes; then
1758 AC_DEFINE(HAVE_AF_INET6, 1,
1759 [Define if AF_INET6 supported.])
1762 # Check if _LK_LOCK is supported by _locking
1763 AC_CACHE_CHECK(for _LK_LOCK, ac_cv_lk_lock, [
1764 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1766 #include <sys/locking.h>]], [[
1768 return _locking (fd, _LK_LOCK, 0);]])],
1769 [ac_cv_lk_lock=yes],[ac_cv_lk_lock=no])])
1770 if test $ac_cv_lk_lock = yes; then
1771 AC_DEFINE(HOST_HAS_LK_LOCK, 1,
1772 [Define if _LK_LOC supported by _locking.])
1775 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1776 CFLAGS="$saved_CFLAGS"
1777 CXXFLAGS="$saved_CXXFLAGS"
1779 # mkdir takes a single argument on some systems.
1780 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1788 # With Setjmp/Longjmp based exception handling.
1789 AC_ARG_ENABLE(sjlj-exceptions,
1790 [AS_HELP_STRING([--enable-sjlj-exceptions],
1791 [arrange to use setjmp/longjmp exception handling])],
1794 if test $enableval != yes; then
1795 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1800 force_sjlj_exceptions=yes],
1803 force_sjlj_exceptions=yes
1807 force_sjlj_exceptions=yes
1811 force_sjlj_exceptions=no
1814 if test $force_sjlj_exceptions = yes; then
1815 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1816 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1817 [Define 0/1 to force the choice for exception handling model.])
1820 # --------------------------------------------------------
1821 # Build, host, and target specific configuration fragments
1822 # --------------------------------------------------------
1824 # Collect build-machine-specific information.
1825 . ${srcdir}/config.build || exit 1
1827 # Collect host-machine-specific information.
1828 . ${srcdir}/config.host || exit 1
1832 # Collect target-machine-specific information.
1833 . ${srcdir}/config.gcc || exit 1
1835 extra_objs="${host_extra_objs} ${extra_objs}"
1836 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1838 # Default the target-machine variables that were not explicitly set.
1839 if test x"$tm_file" = x
1840 then tm_file=$cpu_type/$cpu_type.h; fi
1842 if test x"$extra_headers" = x
1843 then extra_headers=; fi
1845 if test x$md_file = x
1846 then md_file=$cpu_type/$cpu_type.md; fi
1848 if test x$out_file = x
1849 then out_file=$cpu_type/$cpu_type.cc; fi
1851 if test x"$tmake_file" = x
1852 then tmake_file=$cpu_type/t-$cpu_type
1855 # Support --enable-initfini-array.
1856 if test x$enable_initfini_array != xno; then
1857 tm_file="${tm_file} initfini-array.h"
1860 if test x"$dwarf2" = xyes
1861 then tm_file="$tm_file tm-dwarf2.h"
1864 # Say what files are being used for the output code and MD file.
1865 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1866 echo "Using \`$srcdir/config/$md_file' as machine description file."
1868 # If any of the xm_file variables contain nonexistent files, warn
1869 # about them and drop them.
1872 for x in $build_xm_file; do
1873 if test -f $srcdir/config/$x
1875 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1881 for x in $host_xm_file; do
1882 if test -f $srcdir/config/$x
1884 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1890 for x in $xm_file; do
1891 if test -f $srcdir/config/$x
1893 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1899 for f in $tm_file; do
1902 if test $count = ax; then
1903 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1905 echo "Using the following target machine macro files:"
1906 for f in $tm_file; do
1907 echo " $srcdir/config/$f"
1911 if test x$use_long_long_for_widest_fast_int = xyes; then
1912 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1913 [Define to 1 if the 'long long' type is wider than 'long' but still
1914 efficiently supported by the host hardware.])
1917 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1918 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1920 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1921 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1924 for f in $host_xm_file; do
1927 if test $count = a; then
1929 elif test $count = ax; then
1930 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1932 echo "Using the following host machine macro files:"
1933 for f in $host_xm_file; do
1934 echo " $srcdir/config/$f"
1937 echo "Using ${out_host_hook_obj} for host machine hooks."
1939 if test "$host_xm_file" != "$build_xm_file"; then
1941 for f in $build_xm_file; do
1944 if test $count = a; then
1946 elif test $count = ax; then
1947 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1949 echo "Using the following build machine macro files:"
1950 for f in $build_xm_file; do
1951 echo " $srcdir/config/$f"
1956 if test -n "$configured_native_system_header_dir"; then
1957 native_system_header_dir=$configured_native_system_header_dir
1959 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1960 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1964 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1965 gcc_cv_mcontext_underscores,
1966 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1967 #include <sys/cdefs.h>
1968 #include <sys/signal.h>
1969 #include <ucontext.h>
1970 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1972 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1973 if test $gcc_cv_mcontext_underscores = yes; then
1974 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1975 [mcontext_t fields start with __])
1984 # Check if a valid thread package
1985 case ${enable_threads} in
1988 target_thread_file='single'
1992 target_thread_file='single'
1994 aix | dce | lynx | mipssde | posix | rtems | \
1995 single | tpf | vxworks | win32)
1996 target_thread_file=${enable_threads}
1999 echo "${enable_threads} is an unknown thread package" 1>&2
2004 if test x${thread_file} = x; then
2005 # No thread file set by target-specific clauses in config.gcc,
2006 # so use file chosen by default logic above
2007 thread_file=${target_thread_file}
2015 if test x$enable___cxa_atexit = xyes || \
2016 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
2017 if test x$host = x$target; then
2019 # mingw32 doesn't have __cxa_atexit but uses atexit registration
2020 # keyed to flag_use_cxa_atexit
2028 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
2029 [echo "__cxa_atexit can't be enabled on this target"])
2033 # We can't check for __cxa_atexit when building a cross, so assume
2037 if test x$use_cxa_atexit = xyes; then
2038 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
2039 [Define if you want to use __cxa_atexit, rather than atexit, to
2040 register C++ destructors for local statics and global objects.
2041 This is essential for fully standards-compliant handling of
2042 destructors, but requires __cxa_atexit in libc.])
2046 # Look for a file containing extra machine modes.
2047 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
2048 extra_modes_file='$(srcdir)'/config/${extra_modes}
2049 AC_SUBST(extra_modes_file)
2050 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
2051 [Define to the name of a file containing a list of extra machine modes
2052 for this architecture.])
2055 # Convert extra_options into a form suitable for Makefile use.
2058 for f in $extra_options; do
2059 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
2060 all_opt_files="$all_opt_files $srcdir/config/$f"
2062 AC_SUBST(extra_opt_files)
2064 # auto-host.h is the file containing items generated by autoconf and is
2065 # the first file included by config.h.
2066 # If host=build, it is correct to have bconfig include auto-host.h
2067 # as well. If host!=build, we are in error and need to do more
2068 # work to find out the build config parameters.
2069 if test x$host = x$build
2071 build_auto=auto-host.h
2072 HAVE_AUTO_BUILD='# '
2074 # We create a subdir, then run autoconf in the subdir.
2075 # To prevent recursion we set host and build for the new
2076 # invocation of configure to the build for this invocation
2083 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
2084 *) realsrcdir=../${srcdir};;
2086 # Clearing GMPINC is necessary to prevent host headers being
2087 # used by the build compiler. Defining GENERATOR_FILE stops
2088 # system.h from including gmp.h.
2089 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
2090 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
2091 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
2092 GMPINC="" CPPFLAGS="${CPPFLAGS_FOR_BUILD} -DGENERATOR_FILE" \
2093 ${realsrcdir}/configure \
2094 --enable-languages=${enable_languages-all} \
2095 ${enable_obsolete+--enable-obsolete="$enable_obsolete"} \
2096 ${enable_option_checking+--enable-option-checking="$enable_option_checking"} \
2097 --target=$target_alias --host=$build_alias \
2098 --build=$build_alias || exit # retaining $tempdir
2100 # We just finished tests for the build machine, so rename
2101 # the file auto-build.h in the gcc directory.
2102 mv auto-host.h ../auto-build.h
2105 build_auto=auto-build.h
2108 AC_SUBST(build_subdir)
2109 AC_SUBST(HAVE_AUTO_BUILD)
2111 tm_file="${tm_file} defaults.h"
2112 tm_p_file="${tm_p_file} tm-preds.h"
2113 tm_d_file="${tm_d_file} defaults.h"
2114 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
2115 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
2116 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
2117 # put this back in temporarily.
2118 xm_file="auto-host.h ansidecl.h ${xm_file}"
2125 # Compile in configure arguments.
2126 if test -f configargs.h ; then
2127 # Being re-configured.
2128 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
2129 gcc_reconf_arguments=`echo "$gcc_config_arguments" | sed -e 's/^.*\( : (reconfigured) .*$\)/\1/'`
2130 if [ "$gcc_reconf_arguments" != " : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" ]; then
2131 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
2134 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
2137 # Double all backslashes and backslash all quotes to turn
2138 # gcc_config_arguments into a C string.
2139 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
2140 $gcc_config_arguments
2142 gcc_config_arguments_str=`cat conftest.out`
2145 cat > configargs.h <<EOF
2146 /* Generated automatically. */
2147 static const char configuration_arguments[] = "$gcc_config_arguments_str";
2148 static const char thread_model[] = "$thread_file";
2150 static const struct {
2151 const char *name, *value;
2152 } configure_default_options[] = $configure_default_options;
2157 gcc_BASEVER=`cat $srcdir/BASE-VER`
2158 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
2159 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
2160 if test -f $srcdir/REVISION ; then
2161 gcc_REVISION=`cat $srcdir/REVISION`
2165 cat > plugin-version.h <<EOF
2166 #include "configargs.h"
2168 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
2169 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
2170 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
2171 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
2173 static char basever[] = "$gcc_BASEVER";
2174 static char datestamp[] = "$gcc_DATESTAMP";
2175 static char devphase[] = "$gcc_DEVPHASE";
2176 static char revision[] = "$gcc_REVISION";
2178 /* FIXME plugins: We should make the version information more precise.
2179 One way to do is to add a checksum. */
2181 static struct plugin_gcc_version gcc_version = {basever, datestamp,
2183 configuration_arguments};
2187 # Determine what GCC version number to use in filesystem paths.
2190 # Internationalization
2191 ZW_GNU_GETTEXT_SISTER_DIR
2193 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
2194 # -liconv on the link line twice.
2195 case "$LIBINTL" in *$LIBICONV*)
2199 AC_ARG_ENABLE(secureplt,
2200 [AS_HELP_STRING([--enable-secureplt],
2201 [enable -msecure-plt by default for PowerPC])],
2204 AC_ARG_ENABLE(mingw-wildcard,
2205 [AS_HELP_STRING([--enable-mingw-wildcard],
2206 [Set whether to expand wildcard on command-line.
2207 Default to platform configuration])],
2208 [],[enable_mingw_wildcard=platform])
2209 AS_IF([test x"$enable_mingw_wildcard" != xplatform ],
2210 [AC_DEFINE_UNQUOTED(MINGW_DOWILDCARD,
2211 $(test x"$enable_mingw_wildcard" = xno; echo $?),
2212 [Value to set mingw's _dowildcard to.])])
2214 AC_ARG_ENABLE(large-address-aware,
2215 [AS_HELP_STRING([--enable-large-address-aware],
2216 [Link mingw executables with --large-address-aware])])
2217 AS_IF([test x"$enable_large_address_aware" = xyes],
2218 [AC_DEFINE([MINGW_DEFAULT_LARGE_ADDR_AWARE], 1,
2219 [Define if we should link mingw executables with --large-address-aware])])
2221 AC_ARG_ENABLE(leading-mingw64-underscores,
2222 AS_HELP_STRING([--enable-leading-mingw64-underscores],
2223 [enable leading underscores on 64 bit mingw targets]),
2225 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
2226 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
2227 [Define if we should use leading underscore on 64 bit mingw targets])])
2230 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
2233 AC_ARG_ENABLE(frame-pointer,
2234 [AS_HELP_STRING([--enable-frame-pointer],
2235 [enable -fno-omit-frame-pointer by default for x86])], [],
2238 linux* | gnu* | darwin[[8912]]* | cygwin* | mingw*)
2239 # Enable -fomit-frame-pointer by default for these systems with DWARF2.
2240 enable_frame_pointer=no
2243 enable_frame_pointer=yes
2249 i[[34567]]86-*-* | x86_64-*-*)
2250 if test "x$enable_cld" = xyes; then
2251 tm_defines="${tm_defines} USE_IX86_CLD=1"
2253 if test "x$enable_frame_pointer" = xyes; then
2254 tm_defines="${tm_defines} USE_IX86_FRAME_POINTER=1"
2259 # Windows32 Registry support for specifying GCC installation paths.
2260 AC_ARG_ENABLE(win32-registry,
2261 [AS_HELP_STRING([--disable-win32-registry],
2262 [disable lookup of installation paths in the
2263 Registry on Windows hosts])
2264 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
2265 AS_HELP_STRING([--enable-win32-registry=KEY],
2266 [use KEY instead of GCC version as the last portion
2267 of the registry key])],,)
2270 win32 | pe | cygwin* | mingw32*)
2271 if test "x$enable_win32_registry" != xno; then
2272 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
2275 if test "x$enable_win32_registry" != xno; then
2276 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
2277 [Define to 1 if installation paths should be looked up in the Windows
2278 Registry. Ignored on non-Windows hosts.])
2280 if test "x$enable_win32_registry" != xyes \
2281 && test "x$enable_win32_registry" != x; then
2282 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
2283 [Define to be the last component of the Windows registry key under which
2284 to look for installation paths. The full key used will be
2285 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
2286 The default is the GCC version number.])
2292 # Get an absolute path to the GCC top-level source directory
2293 holddir=`${PWDCMD-pwd}`
2295 topdir=`${PWDCMD-pwd}`
2298 # Conditionalize the makefile for this host machine.
2300 for f in ${host_xmake_file}
2302 if test -f ${srcdir}/config/$f
2304 xmake_file="${xmake_file} \$(srcdir)/config/$f"
2308 # Conditionalize the makefile for this target machine.
2310 for f in ${tmake_file}
2312 if test -f ${srcdir}/config/$f
2314 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
2317 tmake_file="${tmake_file_}${omp_device_property_tmake_file}"
2319 out_object_file=`basename $out_file .cc`.o
2320 common_out_object_file=`basename $common_out_file .cc`.o
2322 tm_file_list="options.h"
2323 tm_include_list="options.h insn-constants.h"
2324 for f in $tm_file; do
2327 f=`echo $f | sed 's/^..//'`
2328 tm_file_list="${tm_file_list} $f"
2329 tm_include_list="${tm_include_list} $f"
2332 tm_file_list="${tm_file_list} \$(srcdir)/$f"
2333 tm_include_list="${tm_include_list} $f"
2336 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
2337 tm_include_list="${tm_include_list} config/$f"
2344 for f in $tm_p_file; do
2347 tm_p_file_list="${tm_p_file_list} $f"
2348 tm_p_include_list="${tm_p_include_list} $f"
2351 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
2352 tm_p_include_list="${tm_p_include_list} config/$f"
2357 tm_d_include_list="options.h insn-constants.h"
2358 for f in $tm_d_file; do
2361 tm_d_file_list="${tm_d_file_list} \$(srcdir)/$f"
2362 tm_d_include_list="${tm_d_include_list} $f"
2365 tm_d_file_list="${tm_d_file_list} \$(srcdir)/config/$f"
2366 tm_d_include_list="${tm_d_include_list} config/$f"
2373 for f in $xm_file; do
2376 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
2377 xm_include_list="${xm_include_list} $f"
2380 xm_file_list="${xm_file_list} $f"
2381 xm_include_list="${xm_include_list} $f"
2384 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
2385 xm_include_list="${xm_include_list} config/$f"
2391 host_xm_include_list=
2392 for f in $host_xm_file; do
2395 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
2396 host_xm_include_list="${host_xm_include_list} $f"
2399 host_xm_file_list="${host_xm_file_list} $f"
2400 host_xm_include_list="${host_xm_include_list} $f"
2403 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
2404 host_xm_include_list="${host_xm_include_list} config/$f"
2410 for f in $build_xm_file; do
2413 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
2414 build_xm_include_list="${build_xm_include_list} $f"
2416 auto-build.h | auto-host.h )
2417 build_xm_file_list="${build_xm_file_list} $f"
2418 build_xm_include_list="${build_xm_include_list} $f"
2421 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
2422 build_xm_include_list="${build_xm_include_list} config/$f"
2427 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
2428 # cross-compiler which does not use the native headers and libraries.
2429 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
2430 CROSS= AC_SUBST(CROSS)
2431 ALL=all.internal AC_SUBST(ALL)
2432 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
2433 BUILD_SYSTEM_HEADER_DIR=$SYSTEM_HEADER_DIR AC_SUBST(BUILD_SYSTEM_HEADER_DIR)
2435 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x ||
2436 test x$build != x$host || test "x$with_build_sysroot" != x; then
2437 if test "x$with_build_sysroot" != x; then
2438 BUILD_SYSTEM_HEADER_DIR=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
2440 BUILD_SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2443 if test x$host != x$target
2445 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
2447 SYSTEM_HEADER_DIR=$BUILD_SYSTEM_HEADER_DIR
2448 elif test "x$TARGET_SYSTEM_ROOT" != x; then
2449 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2452 if test "x$with_build_sysroot" != "x"; then
2453 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
2454 elif test "x$with_sysroot" = x; then
2455 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
2456 elif test "x$with_sysroot" = xyes; then
2457 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
2459 target_header_dir="${with_sysroot}${native_system_header_dir}"
2462 target_header_dir=${native_system_header_dir}
2465 # If this is a cross-compiler that does not
2466 # have its own set of headers then define
2469 # If this is using newlib, without having the headers available now,
2470 # then define inhibit_libc in LIBGCC2_CFLAGS.
2471 # This prevents libgcc2 from containing any code which requires libc
2473 : ${inhibit_libc=false}
2474 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2475 test x$with_newlib = xyes ; } &&
2476 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
2479 AC_SUBST(inhibit_libc)
2481 # When building gcc with a cross-compiler, we need to adjust things so
2482 # that the generator programs are still built with the native compiler.
2483 # Also, we cannot run fixincludes.
2485 # These are the normal (build=host) settings:
2486 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2487 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2488 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2489 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2490 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2491 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2493 # And these apply if build != host, or we are generating coverage data
2494 if test x$build != x$host || test "x$coverage_flags" != x
2496 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS-$@) $(CFLAGS_FOR_BUILD)'
2497 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS-$@) $(CXXFLAGS_FOR_BUILD)'
2498 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2501 # Expand extra_headers to include complete path.
2502 # This substitutes for lots of t-* files.
2504 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2505 for file in ${extra_headers} ; do
2506 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2509 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2510 if test x"$use_gcc_tgmath" = xyes
2511 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2514 # Define collect2 in Makefile.
2515 case $host_can_use_collect2 in
2517 *) collect2='collect2$(exeext)' ;;
2519 AC_SUBST([collect2])
2521 # Add a definition of USE_COLLECT2 if system wants one.
2522 case $use_collect2 in
2523 no) use_collect2= ;;
2526 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2527 xm_defines="${xm_defines} USE_COLLECT2"
2528 case $host_can_use_collect2 in
2530 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2536 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2537 [Define to the name of the LTO plugin DSO that must be
2538 passed to the linker's -plugin=LIB option.])
2540 # ---------------------------
2541 # Assembler & linker features
2542 # ---------------------------
2544 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2545 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2546 # However when ld-new is first executed from the build tree, libtool will
2547 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2548 # to the build tree. While doing this we need to use the previous-stage
2549 # linker, or we have an infinite loop. The presence of a shell script as
2550 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2551 # the gcc/collect-ld script. So we need to know how libtool works, or
2552 # exec-tool will fail.
2554 m4_defun([_LT_CONFIG_COMMANDS], [])
2557 AC_SUBST(enable_fast_install)
2559 # Identify the assembler which will work hand-in-glove with the newly
2560 # built GCC, so that we can examine its features. This is the assembler
2561 # which will be driven by the driver program.
2563 # If build != host, and we aren't building gas in-tree, we identify a
2564 # build->target assembler and hope that it will have the same features
2565 # as the host->target assembler we'll be using.
2566 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2568 m4_pattern_allow([AS_FOR_TARGET])dnl
2569 AS_VAR_SET_IF(gcc_cv_as,, [
2570 if test -x "$DEFAULT_ASSEMBLER"; then
2571 gcc_cv_as="$DEFAULT_ASSEMBLER"
2572 elif test -f $gcc_cv_as_gas_srcdir/configure.ac \
2573 && test -f ../gas/Makefile \
2574 && test x$build = x$host; then
2575 gcc_cv_as=../gas/as-new$build_exeext
2576 elif test -x as$build_exeext; then
2577 # Build using assembler in the current directory.
2578 gcc_cv_as=./as$build_exeext
2579 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2580 gcc_cv_as="$AS_FOR_TARGET"
2582 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2585 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2586 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2587 case "$ORIGINAL_AS_FOR_TARGET" in
2588 ./as | ./as$build_exeext) ;;
2589 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2594 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2595 [case "${enableval}" in
2601 install_gold_as_default=no
2603 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2604 [case "${enableval}" in
2606 install_gold_as_default=yes
2609 if test x${default_ld} != x; then
2610 install_gold_as_default=yes
2616 AC_MSG_ERROR([invalid --enable-gold argument])
2620 # Identify the linker which will work hand-in-glove with the newly
2621 # built GCC, so that we can examine its features. This is the linker
2622 # which will be driven by the driver program.
2624 # If build != host, and we aren't building gas in-tree, we identify a
2625 # build->target linker and hope that it will have the same features
2626 # as the host->target linker we'll be using.
2627 gcc_cv_gld_major_version=
2628 gcc_cv_gld_minor_version=
2629 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2630 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2631 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2633 AS_VAR_SET_IF(gcc_cv_ld,, [
2634 if test -x "$DEFAULT_LINKER"; then
2635 gcc_cv_ld="$DEFAULT_LINKER"
2636 elif test $install_gold_as_default = yes \
2637 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2638 && test -f ../gold/Makefile \
2639 && test x$build = x$host; then
2640 gcc_cv_ld=../gold/ld-new$build_exeext
2641 elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \
2642 && test -f ../ld/Makefile \
2643 && test x$build = x$host; then
2644 gcc_cv_ld=../ld/ld-new$build_exeext
2645 elif test -x collect-ld$build_exeext; then
2646 # Build using linker in the current directory.
2647 gcc_cv_ld=./collect-ld$build_exeext
2648 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2649 gcc_cv_ld="$LD_FOR_TARGET"
2651 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2654 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2655 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2656 # if the PLUGIN_LD is set ld-new, just have it as ld
2657 # as that is the installed named.
2658 if test x$PLUGIN_LD_SUFFIX = xld-new \
2659 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2662 AC_ARG_WITH(plugin-ld,
2663 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2664 [if test x"$withval" != x; then
2665 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2666 PLUGIN_LD_SUFFIX="$withval"
2668 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2669 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2671 # Check to see if we are using gold instead of ld
2672 AC_MSG_CHECKING(whether we are using gold)
2674 if test x$gcc_cv_ld != x; then
2675 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2676 | grep "GNU gold" > /dev/null; then
2680 AC_MSG_RESULT($ld_is_gold)
2682 # Check to see if we are using mold instead of ld
2683 AC_MSG_CHECKING(whether we are using mold)
2685 if test x$gcc_cv_ld != x; then
2686 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2687 | grep "mold" > /dev/null; then
2691 AC_MSG_RESULT($ld_is_mold)
2694 AC_MSG_CHECKING(gold linker with split stack support as non default)
2695 # Check to see if default ld is not gold, but gold is
2696 # available and has support for split stack. If gcc was configured
2697 # with gold then no checking is done.
2699 if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then
2701 # For platforms other than powerpc64*, enable as appropriate.
2704 ld_gold=`which ${gcc_cv_ld}.gold`
2705 # Make sure this gold has minimal split stack support
2706 if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then
2707 ld_vers=`$ld_gold --version | sed 1q`
2708 gold_vers=`echo $ld_vers | sed -n \
2709 -e 's,^[[^)]]*[[ ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'`
2711 # check that the gold version contains the complete split stack support
2712 # on powerpc64 big and little endian
2714 case "$gold_vers" in
2715 2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes
2717 *) gold_non_default=no
2723 if test $gold_non_default = yes; then
2724 AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1,
2725 [Define if the gold linker supports split stack and is available as a non-default])
2728 AC_MSG_RESULT($gold_non_default)
2730 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2731 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2732 case "$ORIGINAL_LD_FOR_TARGET" in
2733 ./collect-ld | ./collect-ld$build_exeext) ;;
2734 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2737 AC_MSG_CHECKING(what linker to use)
2738 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2739 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2740 # Single tree build which includes ld. We want to prefer it
2741 # over whatever linker top-level may have detected, since
2742 # we'll use what we're building after installation anyway.
2743 AC_MSG_RESULT(newly built ld)
2745 in_tree_ld_is_elf=no
2746 if (grep 'EMUL = .*elf' ../ld/Makefile \
2747 || grep 'EMUL = .*linux' ../ld/Makefile \
2748 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2749 in_tree_ld_is_elf=yes
2750 elif test "$ld_is_gold" = yes; then
2751 in_tree_ld_is_elf=yes
2753 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
2756 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2757 if test x$gcc_cv_gld_version != x; then
2761 case $gcc_cv_gld_version in
2764 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2767 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2768 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2770 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2771 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2773 AC_MSG_RESULT($gcc_cv_ld)
2775 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2776 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2777 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2780 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2781 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2783 # Figure out what nm we will be using.
2784 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2785 AS_VAR_SET_IF(gcc_cv_nm,, [
2786 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2787 && test -f ../binutils/Makefile \
2788 && test x$build = x$host; then
2789 gcc_cv_nm=../binutils/nm-new$build_exeext
2790 elif test -x nm$build_exeext; then
2791 gcc_cv_nm=./nm$build_exeext
2792 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2793 gcc_cv_nm="$NM_FOR_TARGET"
2795 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2798 AC_MSG_CHECKING(what nm to use)
2799 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2800 # Single tree build which includes binutils.
2801 AC_MSG_RESULT(newly built nm)
2804 AC_MSG_RESULT($gcc_cv_nm)
2808 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2809 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2810 case "$ORIGINAL_NM_FOR_TARGET" in
2811 ./nm | ./nm$build_exeext) ;;
2812 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2816 # Figure out what objdump we will be using.
2817 AS_VAR_SET_IF(gcc_cv_objdump,, [
2818 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2819 && test -f ../binutils/Makefile \
2820 && test x$build = x$host; then
2821 # Single tree build which includes binutils.
2822 gcc_cv_objdump=../binutils/objdump$build_exeext
2823 elif test -x objdump$build_exeext; then
2824 gcc_cv_objdump=./objdump$build_exeext
2825 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2826 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2828 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2831 AC_MSG_CHECKING(what objdump to use)
2832 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2833 # Single tree build which includes binutils.
2834 AC_MSG_RESULT(newly built objdump)
2835 elif test x$gcc_cv_objdump = x; then
2836 AC_MSG_RESULT(not found)
2838 AC_MSG_RESULT($gcc_cv_objdump)
2841 # Figure out what readelf we will be using.
2842 AS_VAR_SET_IF(gcc_cv_readelf,, [
2843 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2844 && test -f ../binutils/Makefile \
2845 && test x$build = x$host; then
2846 # Single tree build which includes binutils.
2847 gcc_cv_readelf=../binutils/readelf$build_exeext
2848 elif test -x readelf$build_exeext; then
2849 gcc_cv_readelf=./readelf$build_exeext
2850 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2851 gcc_cv_readelf="$READELF_FOR_TARGET"
2853 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2856 AC_MSG_CHECKING(what readelf to use)
2857 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2858 # Single tree build which includes binutils.
2859 AC_MSG_RESULT(newly built readelf)
2860 elif test x$gcc_cv_readelf = x; then
2861 AC_MSG_RESULT(not found)
2863 AC_MSG_RESULT($gcc_cv_readelf)
2866 # Figure out what otool we will be using.
2867 AS_VAR_SET_IF(gcc_cv_otool,, [
2868 if test -x otool$build_exeext; then
2869 gcc_cv_otool=./otool$build_exeext
2870 elif ( set dummy $OTOOL_FOR_TARGET; test -x $[2] ); then
2871 gcc_cv_otool="$OTOOL_FOR_TARGET"
2873 AC_PATH_PROG(gcc_cv_otool, $OTOOL_FOR_TARGET)
2876 AC_MSG_CHECKING(what otool to use)
2877 if test x$gcc_cv_otool = x; then
2878 AC_MSG_RESULT(not found)
2880 AC_MSG_RESULT($gcc_cv_otool)
2883 # Figure out the dsymutil we will use.
2884 AS_VAR_SET_IF(gcc_cv_dsymutil,, [
2885 if test -x "$DEFAULT_DSYMUTIL"; then
2886 gcc_cv_dsymutil="$DEFAULT_DSYMUTIL"
2887 elif test -x dsymutil$build_exeext; then
2888 gcc_cv_dsymutil=./dsymutil$build_exeext
2889 elif ( set dummy $DSYMUTIL_FOR_TARGET; test -x $[2] ); then
2890 gcc_cv_dsymutil=$DSYMUTIL_FOR_TARGET
2891 elif ( set dummy $DSYMUTIL; test -x $[2] ); then
2892 gcc_cv_dsymutil=$DSYMUTIL
2894 AC_PATH_PROG(gcc_cv_dsymutil, $DSYMUTIL_FOR_TARGET)
2897 ORIGINAL_DSYMUTIL_FOR_TARGET=$gcc_cv_dsymutil
2898 AC_SUBST(ORIGINAL_DSYMUTIL_FOR_TARGET)
2899 case "$ORIGINAL_DSYMUTIL_FOR_TARGET" in
2900 ./dsymutil | ./dsymutil$build_exeext) ;;
2901 *) AC_CONFIG_FILES(dsymutil:exec-tool.in, [chmod +x dsymutil]) ;;
2904 # Figure out what assembler alignment features are present.
2905 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,,
2908 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2909 [Define if your assembler supports .balign and .p2align.])])
2911 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,,
2913 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2914 [Define if your assembler supports specifying the maximum number
2915 of bytes to skip when using the GAS .p2align command.])])
2917 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,,
2919 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2920 [Define if your assembler supports .literal16.])])
2922 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,,
2923 [conftest_label1: .word 0
2925 conftest_label2: .word 0
2927 [if test x$gcc_cv_nm != x; then
2928 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2929 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2930 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2932 else gcc_cv_as_subsection_m1=yes
2934 rm -f conftest.nm1 conftest.nm2
2936 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2937 [Define if your assembler supports .subsection and .subsection -1 starts
2938 emitting at the beginning of your section.])])
2940 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,,
2942 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2944 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,,
2945 [ .weakref foobar, barfnot],,
2946 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2948 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,,
2950 .NSUBSPA $CODE$,COMDAT],,
2951 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2953 # .hidden needs to be supported in both the assembler and the linker,
2954 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2955 # This is irritatingly difficult to feature test for; we have to check the
2956 # date string after the version number. If we've got an in-tree
2957 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2959 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2962 conftest_s=' .globl foobar,hidden'
2965 conftest_s=' .hidden foobar
2969 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,, [$conftest_s])
2972 # Darwin as has some visibility support, though with a different syntax.
2973 gcc_cv_as_hidden=yes
2977 # gnu_indirect_function type is an extension proposed at
2978 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2979 # selection of function implementation
2980 AC_ARG_ENABLE(gnu-indirect-function,
2981 [AS_HELP_STRING([--enable-gnu-indirect-function],
2982 [enable the use of the @gnu_indirect_function to glibc systems])],
2983 [case $enable_gnu_indirect_function in
2985 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2986 Valid choices are 'yes' and 'no'.]) ;;
2988 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2992 AC_MSG_CHECKING(linker ifunc IRELATIVE support)
2993 cat > conftest.s <<EOF
2995 .type foo_resolver, @function
2998 .size foo_resolver, .-foo_resolver
3001 .type foo, %gnu_indirect_function
3002 .set foo, foo_resolver
3005 .type bar, @function
3011 if test x$gcc_cv_as != x \
3012 && test x$gcc_cv_ld != x \
3013 && test x$gcc_cv_readelf != x \
3014 && $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
3015 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
3016 && $gcc_cv_readelf --relocs --wide conftest \
3017 | grep R_RISCV_IRELATIVE > /dev/null 2>&1; then
3018 enable_gnu_indirect_function=yes
3020 rm -f conftest conftest.o conftest.s
3021 AC_MSG_RESULT($enable_gnu_indirect_function)
3025 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
3026 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
3027 [Define if your system supports gnu indirect functions.])
3031 if test $in_tree_ld != yes ; then
3032 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
3033 if echo "$ld_ver" | grep GNU > /dev/null; then
3034 if test x"$ld_is_gold" = xyes; then
3035 # GNU gold --version looks like this:
3037 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
3039 # We extract the binutils version which is more familiar and specific
3040 # than the gold version.
3041 ld_vers=`echo $ld_ver | sed -n \
3042 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3044 # GNU ld --version looks like this:
3046 # GNU ld (GNU Binutils) 2.21.51.20110225
3047 ld_vers=`echo $ld_ver | sed -n \
3048 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3050 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'`
3051 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3052 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3053 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
3057 # Solaris 2 ld -V output looks like this for a regular version:
3059 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
3061 # but test versions add stuff at the end:
3063 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
3065 # ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version
3066 # numbers can be used in ld.so.1 feature checks even if a different
3067 # linker is configured.
3068 ld_ver=`$gcc_cv_ld -V 2>&1`
3069 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
3070 ld_vers=`echo $ld_ver | sed -n \
3071 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
3072 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3073 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3081 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
3082 [[if test $in_tree_ld = yes ; then
3084 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 \
3085 && test $in_tree_ld_is_elf = yes; then
3086 gcc_cv_ld_hidden=yes
3089 gcc_cv_ld_hidden=yes
3090 if test x"$ld_is_gold" = xyes; then
3092 elif test x"$ld_is_mold" = xyes; then
3094 elif echo "$ld_ver" | grep GNU > /dev/null; then
3095 if test 0"$ld_date" -lt 20020404; then
3096 if test -n "$ld_date"; then
3097 # If there was date string, but was earlier than 2002-04-04, fail
3099 elif test -z "$ld_vers"; then
3100 # If there was no date string nor ld version number, something is wrong
3103 test -z "$ld_vers_patch" && ld_vers_patch=0
3104 if test "$ld_vers_major" -lt 2; then
3106 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
3107 gcc_cv_ld_hidden="no"
3108 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
3116 gcc_cv_ld_hidden=yes
3119 # Darwin ld has some visibility support.
3120 gcc_cv_ld_hidden=yes
3122 hppa64*-*-hpux* | ia64*-*-hpux*)
3123 gcc_cv_ld_hidden=yes
3126 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
3127 # .symbolic was only added in Solaris 9 12/02.
3128 gcc_cv_ld_hidden=yes
3136 libgcc_visibility=no
3137 AC_SUBST(libgcc_visibility)
3138 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
3139 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
3140 libgcc_visibility=yes
3141 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
3142 [Define if your assembler and linker support .hidden.])
3145 AC_MSG_CHECKING(linker read-only and read-write section mixing)
3146 gcc_cv_ld_ro_rw_mix=unknown
3147 if test $in_tree_ld = yes ; then
3148 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 \
3149 && test $in_tree_ld_is_elf = yes; then
3150 gcc_cv_ld_ro_rw_mix=read-write
3152 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3153 echo '.section myfoosect, "a"' > conftest1.s
3154 echo '.section myfoosect, "aw"' > conftest2.s
3155 echo '.byte 1' >> conftest2.s
3156 echo '.section myfoosect, "a"' > conftest3.s
3157 echo '.byte 0' >> conftest3.s
3158 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
3159 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
3160 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
3161 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
3162 conftest2.o conftest3.o > /dev/null 2>&1; then
3163 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
3164 | sed -e '/myfoosect/!d' -e N`
3165 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
3166 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
3167 gcc_cv_ld_ro_rw_mix=read-only
3169 gcc_cv_ld_ro_rw_mix=read-write
3174 rm -f conftest.* conftest[123].*
3177 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
3178 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
3179 [Define if your linker links a mix of read-only
3180 and read-write sections into a read-write section.])
3182 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
3184 gcc_AC_INITFINI_ARRAY
3186 # Check if we have .[us]leb128, and support symbol arithmetic with it.
3187 # Older versions of GAS and some non-GNU assemblers, have a bugs handling
3188 # these directives, even when they appear to accept them.
3189 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,,
3196 .uleb128 0x8000000000000000
3199 if test "x$gcc_cv_objdump" != x; then
3200 if $gcc_cv_objdump -s conftest.o 2>/dev/null \
3201 | grep '04800a8e 78808080 80808080 808001' >/dev/null; then
3202 gcc_cv_as_leb128=yes
3204 elif test "x$gcc_cv_otool" != x; then
3205 if $gcc_cv_otool -d conftest.o 2>/dev/null \
3206 | grep '04 80 0a 8e 78 80 80 80 80 80 80 80 80 80 01' >/dev/null; then
3207 gcc_cv_as_leb128=yes
3210 # play safe, assume the assembler is broken.
3214 [AC_DEFINE(HAVE_AS_LEB128, 1,
3215 [Define if your assembler supports .sleb128 and .uleb128.])],
3216 [AC_DEFINE(HAVE_AS_LEB128, 0,
3217 [Define if your assembler supports .sleb128 and .uleb128.])])
3219 # Determine if an .eh_frame section is read-only.
3220 gcc_fn_eh_frame_ro () {
3221 $gcc_cv_as $1 -o conftest.o conftest.s > /dev/null 2>&1 && \
3222 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
3223 sed -e '/.eh_frame/!d' -e N | grep READONLY > /dev/null
3226 # Check if we have assembler support for unwind directives.
3227 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,,
3233 .cfi_escape 1, 2, 3, 4, 5
3237 # If the linker used on Solaris (like Sun ld) isn't capable of merging
3238 # read-only and read-write sections, we need to make sure that the
3239 # assembler used emits read-write .eh_frame sections.
3240 if test "x$gcc_cv_ld_ro_rw_mix" = xread-write; then
3241 gcc_cv_as_cfi_directive=yes
3242 elif test "x$gcc_cv_objdump" = x; then
3243 # No objdump, err on the side of caution.
3244 gcc_cv_as_cfi_directive=no
3246 if test x$gas = xyes; then
3254 sparc*-*-solaris2.*)
3255 # On Solaris/SPARC, .eh_frame sections should always be read-write.
3256 if gcc_fn_eh_frame_ro $as_32_opt \
3257 || gcc_fn_eh_frame_ro $as_64_opt; then
3258 gcc_cv_as_cfi_directive=no
3260 gcc_cv_as_cfi_directive=yes
3263 i?86-*-solaris2.* | x86_64-*-solaris2.*)
3264 # On Solaris/x86, make sure that GCC and assembler agree on using
3265 # read-only .eh_frame sections for 64-bit.
3266 if gcc_fn_eh_frame_ro $as_32_opt; then
3267 gcc_cv_as_cfi_directive=no
3268 elif gcc_fn_eh_frame_ro $as_64_opt; then
3269 gcc_cv_as_cfi_directive=yes
3271 gcc_cv_as_cfi_directive=no
3278 gcc_cv_as_cfi_directive=yes
3281 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
3282 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,,
3285 .cfi_adjust_cfa_offset 64
3287 .cfi_adjust_cfa_offset 128
3290 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
3291 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
3292 gcc_cv_as_cfi_advance_working=yes
3296 # no objdump, err on the side of caution
3297 gcc_cv_as_cfi_advance_working=no
3299 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
3300 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
3301 [`if test $gcc_cv_as_cfi_directive = yes \
3302 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
3303 [Define 0/1 if your assembler supports CFI directives.])
3305 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
3306 gcc_GAS_CHECK_FEATURE([cfi personality directive],
3307 gcc_cv_as_cfi_personality_directive,,
3310 .cfi_personality 0, symbol
3312 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
3313 [`if test $gcc_cv_as_cfi_personality_directive = yes; then echo 1; else echo 0; fi`],
3314 [Define 0/1 if your assembler supports .cfi_personality.])
3316 gcc_GAS_CHECK_FEATURE([cfi sections directive],
3317 gcc_cv_as_cfi_sections_directive,,
3319 .cfi_sections .debug_frame, .eh_frame
3323 win32 | pe | cygwin* | mingw32*)
3324 # Need to check that we generated the correct relocation for the
3325 # .debug_frame section. This was fixed for binutils 2.21.
3326 gcc_cv_as_cfi_sections_directive=no
3327 if test "x$gcc_cv_objdump" != x; then
3328 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
3329 grep secrel > /dev/null; then
3330 gcc_cv_as_cfi_sections_directive=yes
3335 gcc_cv_as_cfi_sections_directive=yes
3338 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
3339 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
3340 [`if test $gcc_cv_as_cfi_sections_directive = yes; then echo 1; else echo 0; fi`],
3341 [Define 0/1 if your assembler supports .cfi_sections.])
3343 # GAS versions up to and including 2.11.0 may mis-optimize
3345 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,,
3352 .section .eh_frame,"aw",@progbits
3354 .4byte .LECIE1-.LSCIE1
3368 .4byte .LEFDE1-.LASFDE1
3370 .4byte .LASFDE1-__FRAME_BEGIN__
3378 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
3379 cat > conftest.lit <<EOF
3380 0000 10000000 00000000 017a0001 781a0004 .........z..x...
3381 0010 01000000 12000000 18000000 00000000 ................
3382 0020 08000000 04080000 0044 .........D @&t@
3384 cat > conftest.big <<EOF
3385 0000 00000010 00000000 017a0001 781a0004 .........z..x...
3386 0010 00000001 00000012 00000018 00000000 ................
3387 0020 00000008 04000000 0844 .........D @&t@
3389 # If the assembler didn't choke, and we can objdump,
3390 # and we got the correct data, then succeed.
3391 # The text in the here-document typically retains its unix-style line
3392 # endings, while the output of objdump will use host line endings.
3393 # Therefore, use diff -b for the comparisons.
3394 if test x$gcc_cv_objdump != x \
3395 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
3396 | tail -3 > conftest.got \
3397 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
3398 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
3400 gcc_cv_as_eh_frame=yes
3401 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
3402 gcc_cv_as_eh_frame=buggy
3404 # Uh oh, what do we do now?
3405 gcc_cv_as_eh_frame=no
3408 if test $gcc_cv_as_eh_frame = buggy; then
3409 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
3410 [Define if your assembler mis-optimizes .eh_frame data.])
3413 # Test if the assembler supports the section flag 'e' or #exclude for
3414 # specifying an excluded section.
3415 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_e,
3419 if test $gcc_cv_as_section_exclude_e = no; then
3421 # Solaris as uses #exclude instead.
3425 conftest_s='.section "foo1", #exclude'
3427 i?86-*-solaris2* | x86_64-*-solaris2*)
3428 conftest_s='.section foo1, #exclude'
3433 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_hash,,
3437 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3438 [`if test $gcc_cv_as_section_exclude_e = yes || test $gcc_cv_as_section_exclude_hash = yes; then echo 1; else echo 0; fi`],
3439 [Define if your assembler supports specifying the exclude section flag.])
3441 # Test if the assembler supports the section flag 'R' for specifying
3442 # section with SHF_GNU_RETAIN.
3444 # Solaris may use GNU assembler with Solairs ld. Even if GNU
3445 # assembler supports the section flag 'R', it doesn't mean that
3446 # Solairs ld supports it.
3448 gcc_cv_as_shf_gnu_retain=no
3451 gcc_GAS_CHECK_FEATURE([section 'R' flag], gcc_cv_as_shf_gnu_retain,
3453 [.section .foo,"awR",%progbits
3457 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_GNU_RETAIN,
3458 [`if test $gcc_cv_as_shf_gnu_retain = yes; then echo 1; else echo 0; fi`],
3459 [Define 0/1 if your assembler supports marking sections with SHF_GNU_RETAIN flag.])
3461 # Test if the assembler supports the section flag 'o' for specifying
3462 # section with link-order.
3464 # Solaris may use GNU assembler with Solairs ld. Even if GNU
3465 # assembler supports the section flag 'o', it doesn't mean that
3466 # Solairs ld supports it.
3468 gcc_cv_as_section_link_order=no
3471 gcc_GAS_CHECK_FEATURE([section 'o' flag], gcc_cv_as_section_link_order,
3475 .section __patchable_function_entries,"awo",%progbits,.foo
3479 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_LINK_ORDER,
3480 [`if test $gcc_cv_as_section_link_order = yes; then echo 1; else echo 0; fi`],
3481 [Define 0/1 if your assembler supports 'o' flag in .section directive.])
3483 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3485 [.section .rodata.str, "aMS", @progbits, 1])
3486 if test $gcc_cv_as_shf_merge = no; then
3487 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3489 [.section .rodata.str, "aMS", %progbits, 1])
3491 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
3492 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
3493 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
3495 gcc_cv_ld_aligned_shf_merge=yes
3497 # SHF_MERGE support is broken in Solaris ld up to Solaris 11.3/SPARC for
3499 sparc*-*-solaris2.11*)
3500 if test x"$gnu_ld" = xno \
3501 && test "$ld_vers_major" -lt 2 && test "$ld_vers_minor" -lt 3159; then
3502 gcc_cv_ld_aligned_shf_merge=no
3506 AC_DEFINE_UNQUOTED(HAVE_LD_ALIGNED_SHF_MERGE,
3507 [`if test $gcc_cv_ld_aligned_shf_merge = yes; then echo 1; else echo 0; fi`],
3508 [Define 0/1 if your linker supports the SHF_MERGE flag with section alignment > 1.])
3510 gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive,,
3511 [.stabs "gcc2_compiled.",60,0,0,0],,
3512 [AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1,
3513 [Define if your assembler supports .stabs.])])
3515 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
3516 gcc_cv_as_comdat_group,
3518 [.section .text,"axG",@progbits,.foo,comdat])
3519 if test $gcc_cv_as_comdat_group = yes; then
3520 gcc_cv_as_comdat_group_percent=no
3521 gcc_cv_as_comdat_group_group=no
3523 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
3524 gcc_cv_as_comdat_group_percent,
3526 [.section .text,"axG",%progbits,.foo,comdat])
3527 if test $gcc_cv_as_comdat_group_percent = yes; then
3528 gcc_cv_as_comdat_group_group=no
3531 # Sun as uses a completely different syntax.
3536 .group foo,".text%foo",#comdat
3537 .section ".text%foo", #alloc,#execinstr,#progbits
3542 i?86-*-solaris2* | x86_64-*-solaris2*)
3544 .group foo,.text%foo,#comdat
3545 .section .text%foo, "ax", @progbits
3551 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
3552 gcc_cv_as_comdat_group_group,
3556 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
3557 gcc_cv_as_comdat_group_group=no
3561 if test x"$ld_is_gold" = xyes; then
3563 elif test x"$ld_is_mold" = xyes; then
3565 elif test $in_tree_ld = yes ; then
3567 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 \
3568 && test $in_tree_ld_is_elf = yes; then
3571 elif echo "$ld_ver" | grep GNU > /dev/null; then
3573 if test 0"$ld_date" -lt 20050308; then
3574 if test -n "$ld_date"; then
3575 # If there was date string, but was earlier than 2005-03-08, fail
3577 elif test "$ld_vers_major" -lt 2; then
3579 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
3586 *-*-solaris2.1[1-9]*)
3588 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
3589 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
3592 # If using Sun as for COMDAT group as emitted by GCC, one needs at
3593 # least ld version 1.2267.
3594 if test "$ld_vers_major" -gt 1; then
3596 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
3598 elif test "$ld_vers_minor" -ge 2267; then
3603 # Assume linkers other than GNU ld don't support COMDAT group.
3609 # Allow overriding the automatic COMDAT group tests above.
3610 AC_ARG_ENABLE(comdat,
3611 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
3612 [comdat_group="$enable_comdat"])
3613 if test $comdat_group = no; then
3614 gcc_cv_as_comdat_group=no
3615 gcc_cv_as_comdat_group_percent=no
3616 gcc_cv_as_comdat_group_group=no
3618 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
3619 [`if test $gcc_cv_as_comdat_group = yes \
3620 || test $gcc_cv_as_comdat_group_percent = yes \
3621 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
3622 [Define 0/1 if your assembler and linker support COMDAT groups.])
3624 # Restrict this test to Solaris/x86: other targets define this statically.
3626 i?86-*-solaris2* | x86_64-*-solaris2*)
3627 AC_MSG_CHECKING(support for hidden thunks in linkonce sections)
3628 if test $in_tree_ld = yes || echo "$ld_ver" | grep GNU > /dev/null; then
3632 # Full support for hidden thunks in linkonce sections only appeared in
3633 # Solaris 11/OpenSolaris.
3634 *-*-solaris2.1[[1-9]]*)
3642 AC_MSG_RESULT($hidden_linkonce)
3643 AC_DEFINE_UNQUOTED(USE_HIDDEN_LINKONCE,
3644 [`if test $hidden_linkonce = yes; then echo 1; else echo 0; fi`],
3645 [Define 0/1 if your linker supports hidden thunks in linkonce sections.])
3649 gcc_GAS_CHECK_FEATURE([line table is_stmt support],
3653 .loc 1 1 0 is_stmt 1],,
3654 [AC_DEFINE(HAVE_GAS_LOC_STMT, 1,
3655 [Define if your assembler supports the .loc is_stmt sub-directive.])])
3657 gcc_GAS_CHECK_FEATURE([line table discriminator support],
3658 gcc_cv_as_discriminator,,
3661 .loc 1 1 0 discriminator 1],,
3662 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
3663 [Define if your assembler supports the .loc discriminator sub-directive.])])
3665 # Catch the newlib flag of the same name so we can gate GCC features on it.
3666 AC_ARG_ENABLE(newlib-nano-formatted-io,
3667 [AS_HELP_STRING([--enable-newlib-nano-formatted-io], [Use nano version
3669 [case "${enableval}" in
3673 AC_MSG_ERROR([unknown newlib-nano-formatted-io setting $enableval])
3677 # Thread-local storage - the check is heavily parameterized.
3684 .section ".tdata","awT",@progbits
3687 ldq $27,__tls_get_addr($29) !literal!1
3688 lda $16,foo($29) !tlsgd!1
3689 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3690 ldq $27,__tls_get_addr($29) !literal!2
3691 lda $16,foo($29) !tlsldm!2
3692 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
3693 ldq $1,foo($29) !gotdtprel
3694 ldah $2,foo($29) !dtprelhi
3695 lda $3,foo($2) !dtprello
3696 lda $4,foo($29) !dtprel
3697 ldq $1,foo($29) !gottprel
3698 ldah $2,foo($29) !tprelhi
3699 lda $3,foo($2) !tprello
3700 lda $4,foo($29) !tprel'
3701 tls_as_opt=--fatal-warnings
3705 add_s r0,r0, @foo@tpoff'
3707 cris-*-*|crisv32-*-*)
3709 .section ".tdata","awT",@progbits
3714 tls_as_opt=--fatal-warnings
3718 .section ".tdata","awT",@progbits
3728 .section ".tdata","awT",@progbits
3732 addil LT%foo-$tls_gdidx$,gp
3733 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3736 addil LT%foo-$tls_ldidx$,gp
3738 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3739 addil LR%foo-$tls_dtpoff$,%ret0
3740 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3742 addil LT%foo-$tls_ieoff$,gp
3743 ldw RT%foo-$tls_ieoff$(%r1),%t2
3746 addil LR%foo-$tls_leoff$,%t1
3747 ldo RR%foo-$tls_leoff$(%r1),%t2'
3748 tls_as_opt=--fatal-warnings
3752 .section ".tdata","awT",%progbits
3761 i[34567]86-*-* | x86_64-*-*)
3763 i[34567]86-*-solaris2.* | x86_64-*-solaris2.*)
3770 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3772 .section .tdata,"awt",@progbits'
3775 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3776 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3780 .section ".tdata","awT",@progbits'
3782 tls_as_opt="--fatal-warnings"
3786 if test x$on_solaris = xyes; then
3788 yes) tls_as_opt="$tls_as_opt --32" ;;
3791 conftest_s="$conftest_s
3795 leal foo@tlsgd(,%ebx,1), %eax
3796 leal foo@tlsldm(%ebx), %eax
3797 leal foo@dtpoff(%eax), %edx
3798 movl foo@gottpoff(%ebx), %eax
3799 subl foo@gottpoff(%ebx), %eax
3800 addl foo@gotntpoff(%ebx), %eax
3801 movl foo@indntpoff, %eax
3802 movl \$foo@tpoff, %eax
3803 subl \$foo@tpoff, %eax
3804 leal foo@ntpoff(%ecx), %eax"
3807 if test x$on_solaris = xyes; then
3809 yes) tls_as_opt="$tls_as_opt --64" ;;
3810 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3813 conftest_s="$conftest_s
3817 leaq foo@tlsgd(%rip), %rdi
3818 leaq foo@tlsld(%rip), %rdi
3819 leaq foo@dtpoff(%rax), %rdx
3820 movq foo@gottpoff(%rip), %rax
3821 movq \$foo@tpoff, %rax"
3827 .section ".tdata","awT",@progbits
3830 addl r16 = @ltoff(@dtpmod(foo#)), gp
3831 addl r17 = @ltoff(@dtprel(foo#)), gp
3832 addl r18 = @ltoff(@tprel(foo#)), gp
3833 addl r19 = @dtprel(foo#), gp
3834 adds r21 = @dtprel(foo#), r13
3835 movl r23 = @dtprel(foo#)
3836 addl r20 = @tprel(foo#), gp
3837 adds r22 = @tprel(foo#), r13
3838 movl r24 = @tprel(foo#)'
3839 tls_as_opt=--fatal-warnings
3843 .section .tdata,"awT",@progbits
3847 addik r5,r20,x@TLSGD
3848 addik r5,r20,x@TLSLDM'
3849 tls_as_opt='--fatal-warnings'
3853 .section .tdata,"awT",@progbits
3857 addiu $4, $28, %tlsgd(x)
3858 addiu $4, $28, %tlsldm(x)
3859 lui $4, %dtprel_hi(x)
3860 addiu $4, $4, %dtprel_lo(x)
3861 lw $4, %gottprel(x)($28)
3862 lui $4, %tprel_hi(x)
3863 addiu $4, $4, %tprel_lo(x)'
3864 tls_as_opt='-32 --fatal-warnings'
3868 .section .tdata,"awT",@progbits
3873 move.l x@TLSGD(%a5),%a0
3874 move.l x@TLSLDM(%a5),%a0
3875 move.l x@TLSLDO(%a5),%a0
3876 move.l x@TLSIE(%a5),%a0
3877 move.l x@TLSLE(%a5),%a0'
3878 tls_as_opt='--fatal-warnings'
3882 .section ".tdata","awT",@progbits'
3883 tls_as_opt="--fatal-warnings"
3887 .section ".tdata","awT",%progbits
3891 add x0, x0, #:tlsgd_lo12:x
3894 tls_as_opt='--fatal-warnings'
3898 .section ".tdata","awT",@progbits
3901 l.movhi r3, tpoffha(foo)
3903 l.lwz r4, tpofflo(foo)(r3)'
3904 tls_as_opt=--fatal-warnings
3908 .extern __get_tpointer
3924 .section ".tdata","awT",@progbits
3932 addi 3,2,ld0@got@tlsgd
3938 addi 3,2,x1@got@tlsld
3944 addis 9,3,x2@dtprel@ha
3945 addi 9,9,x2@dtprel@l
3948 ld 9,x3@got@dtprel(2)
3952 tls_as_opt="-a64 --fatal-warnings"
3956 .section ".tdata","awT",@progbits
3964 addi 3,31,ld0@got@tlsgd
3966 addi 3,31,x1@got@tlsld
3969 addis 9,3,x2@dtprel@ha
3970 addi 9,9,x2@dtprel@l
3971 lwz 9,x3@got@tprel(31)
3974 addis 9,2,x2@tprel@ha
3975 addi 9,9,x2@tprel@l'
3976 tls_as_opt="-a32 --fatal-warnings"
3980 .section .tdata,"awT",@progbits
3984 call __tls_get_addr'
3985 tls_as_opt='--fatal-warnings'
3989 .section ".tdata","awT",@progbits
3998 l %r1,foo@GOTNTPOFF(%r12)
3999 l %r1,0(%r1):tls_load:foo
4000 bas %r14,0(%r1,%r13):tls_gdcall:foo
4001 bas %r14,0(%r1,%r13):tls_ldcall:foo'
4002 tls_as_opt="-m31 --fatal-warnings"
4006 .section ".tdata","awT",@progbits
4014 lg %r1,foo@GOTNTPOFF(%r12)
4015 larl %r1,foo@INDNTPOFF
4016 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
4017 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
4018 tls_as_opt="-m64 -Aesame --fatal-warnings"
4020 sh-*-* | sh[123456789lbe]*-*-*)
4022 .section ".tdata","awT",@progbits
4030 tls_as_opt=--fatal-warnings
4034 sparc*-sun-solaris2.*)
4041 if test x$on_solaris = xyes && test x$gas_flag = xno; then
4043 .section ".tdata",#alloc,#write,#tls'
4046 .section ".tdata","awT",@progbits'
4047 tls_as_opt="-32 --fatal-warnings"
4049 conftest_s="$conftest_s
4052 sethi %tgd_hi22(foo), %o0
4053 add %o0, %tgd_lo10(foo), %o1
4054 add %l7, %o1, %o0, %tgd_add(foo)
4055 call __tls_get_addr, %tgd_call(foo)
4056 sethi %tldm_hi22(foo), %l1
4057 add %l1, %tldm_lo10(foo), %l2
4058 add %l7, %l2, %o0, %tldm_add(foo)
4059 call __tls_get_addr, %tldm_call(foo)
4060 sethi %tldo_hix22(foo), %l3
4061 xor %l3, %tldo_lox10(foo), %l4
4062 add %o0, %l4, %l5, %tldo_add(foo)
4063 sethi %tie_hi22(foo), %o3
4064 add %o3, %tie_lo10(foo), %o3
4065 ld [%l7 + %o3], %o2, %tie_ld(foo)
4066 add %g7, %o2, %o4, %tie_add(foo)
4067 sethi %tle_hix22(foo), %l1
4068 xor %l1, %tle_lox10(foo), %o5
4069 ld [%g7 + %o5], %o1"
4073 .section ".tdata","awT",@progbits
4076 addli r0, zero, tls_gd(foo)
4077 auli r0, zero, tls_gd_ha16(foo)
4078 addli r0, r0, tls_gd_lo16(foo)
4080 addli r0, zero, tls_ie(foo)
4081 auli r0, r0, tls_ie_ha16(foo)
4082 addli r0, r0, tls_ie_lo16(foo)'
4083 tls_as_opt="--fatal-warnings"
4087 .section ".tdata","awT",@progbits
4090 shl16insli r0, zero, hw0_last_tls_gd(foo)
4091 shl16insli r0, zero, hw1_last_tls_gd(foo)
4092 shl16insli r0, r0, hw0_tls_gd(foo)
4094 shl16insli r0, zero, hw1_last_tls_ie(foo)
4095 shl16insli r0, r0, hw0_tls_ie(foo)'
4096 tls_as_opt="--fatal-warnings"
4100 .section ".tdata","awT",@progbits
4103 movi a8, foo@TLSFUNC
4104 movi a10, foo@TLSARG
4105 callx8.tls a8, foo@TLSCALL'
4110 if test "x$enable_tls" = xno ; then
4111 : # TLS explicitly disabled.
4112 elif test "x$enable_tls" = xyes ; then
4113 set_have_as_tls=yes # TLS explicitly enabled.
4114 elif test -z "$conftest_s"; then
4115 : # If we don't have a check, assume no support.
4117 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
4118 [$tls_as_opt], [$conftest_s],,
4119 [set_have_as_tls=yes])
4121 if test $set_have_as_tls = yes ; then
4122 AC_DEFINE(HAVE_AS_TLS, 1,
4123 [Define if your assembler and linker support thread-local storage.])
4126 # Target-specific assembler checks.
4128 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
4129 gcc_cv_ld_static_dynamic=no
4130 gcc_cv_ld_static_option='-Bstatic'
4131 gcc_cv_ld_dynamic_option='-Bdynamic'
4132 if test $in_tree_ld = yes ; then
4133 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
4134 gcc_cv_ld_static_dynamic=yes
4136 elif test x$gcc_cv_ld != x; then
4137 # Check if linker supports -Bstatic/-Bdynamic option
4138 if $gcc_cv_ld --help 2>&1 | grep -- -Bstatic > /dev/null \
4139 && $gcc_cv_ld --help 2>&1 | grep -- -Bdynamic > /dev/null; then
4140 gcc_cv_ld_static_dynamic=yes
4143 # AIX ld uses -b flags
4144 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
4145 gcc_cv_ld_static_dynamic=yes
4146 gcc_cv_ld_static_option="-bstatic"
4147 gcc_cv_ld_dynamic_option="-bdynamic"
4149 # HP-UX ld uses -a flags to select between shared and archive.
4151 if test x"$gnu_ld" = xno; then
4152 gcc_cv_ld_static_dynamic=yes
4153 gcc_cv_ld_static_option="-aarchive_shared"
4154 gcc_cv_ld_dynamic_option="-adefault"
4157 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
4159 gcc_cv_ld_static_dynamic=yes
4164 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
4165 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
4166 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
4167 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
4168 [Define to the linker option to disable use of shared objects.])
4169 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
4170 [Define to the linker option to enable use of shared objects.])
4172 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
4174 AC_MSG_CHECKING(linker --version-script option)
4175 gcc_cv_ld_version_script=no
4176 ld_version_script_option=''
4177 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4178 gcc_cv_ld_version_script=yes
4179 ld_version_script_option='--version-script'
4180 elif test x$gcc_cv_ld != x; then
4182 # Solaris 2 ld always supports -M. It also supports a subset of
4183 # --version-script since Solaris 11.4, but requires
4184 # -z gnu-version-script-compat to activate.
4186 gcc_cv_ld_version_script=yes
4187 ld_version_script_option='-M'
4191 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4192 AC_MSG_RESULT($gcc_cv_ld_version_script)
4193 AC_SUBST(ld_version_script_option)
4195 AC_MSG_CHECKING(linker soname option)
4197 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4198 gcc_cv_ld_soname=yes
4199 ld_soname_option='-soname'
4200 elif test x$gcc_cv_ld != x; then
4203 gcc_cv_ld_soname=yes
4204 ld_soname_option='-install_name'
4206 # Solaris 2 ld always supports -h. It also supports --soname for GNU
4207 # ld compatiblity since some Solaris 10 update.
4209 gcc_cv_ld_soname=yes
4210 ld_soname_option='-h'
4214 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4215 AC_MSG_RESULT($gcc_cv_ld_soname)
4216 AC_SUBST(ld_soname_option)
4218 if test x"$demangler_in_ld" = xyes; then
4219 AC_MSG_CHECKING(linker --demangle support)
4220 gcc_cv_ld_demangle=no
4221 if test $in_tree_ld = yes; then
4222 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 \
4223 gcc_cv_ld_demangle=yes
4225 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
4226 # Check if the GNU linker supports --demangle option
4227 if $gcc_cv_ld --help 2>&1 | grep no-demangle > /dev/null; then
4228 gcc_cv_ld_demangle=yes
4231 if test x"$gcc_cv_ld_demangle" = xyes; then
4232 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
4233 [Define if your linker supports --demangle option.])
4235 AC_MSG_RESULT($gcc_cv_ld_demangle)
4238 AC_MSG_CHECKING(linker plugin support)
4240 if test -f liblto_plugin.la; then
4241 save_ld_ver="$ld_ver"
4242 save_ld_vers_major="$ld_vers_major"
4243 save_ld_vers_minor="$ld_vers_minor"
4244 save_ld_is_gold="$ld_is_gold"
4248 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
4250 # FIXME: ld_is_gold?
4251 ld_vers_major="$gcc_cv_gld_major_version"
4252 ld_vers_minor="$gcc_cv_gld_minor_version"
4254 # Determine plugin linker version.
4255 # FIXME: Partial duplicate from above, generalize.
4257 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
4258 if echo "$ld_ver" | grep GNU > /dev/null; then
4259 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
4261 ld_vers=`echo $ld_ver | sed -n \
4262 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
4264 ld_vers=`echo $ld_ver | sed -n \
4265 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
4267 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
4268 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
4273 # Determine plugin support.
4274 if echo "$ld_ver" | grep GNU > /dev/null; then
4275 # Require GNU ld or gold 2.21+ for plugin support by default.
4276 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
4278 elif test "$ld_is_mold" = yes; then
4280 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
4281 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
4286 ld_ver="$save_ld_ver"
4287 ld_vers_major="$save_ld_vers_major"
4288 ld_vers_minor="$save_ld_vers_minor"
4289 ld_is_gold="$save_ld_is_gold"
4291 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
4292 [Define to the level of your linker's plugin support.])
4293 AC_MSG_RESULT($gcc_cv_lto_plugin)
4295 # Target OS-specific assembler checks.
4297 case "$target_os" in
4299 gcc_GAS_CHECK_FEATURE([-mmacosx-version-min option],
4300 gcc_cv_as_mmacosx_version_min,
4301 [-mmacosx-version-min=10.1], [.text],,
4302 [AC_DEFINE(HAVE_AS_MMACOSX_VERSION_MIN_OPTION, 1,
4303 [Define if your Mac OS X assembler supports the -mmacos-version-min option.])])
4307 # Target CPU-specific assembler checks.
4311 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,
4312 [-mabi=lp64], [.text],,,)
4313 if test x$gcc_cv_as_aarch64_mabi = xyes; then
4314 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
4315 [Define if your assembler supports the -mabi option.])
4317 if test x$with_abi = xilp32; then
4318 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4319 Upgrade the Assembler.])
4321 if test x"$with_multilib_list" = xdefault; then
4322 TM_MULTILIB_CONFIG=lp64
4324 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
4325 for aarch64_multilib in ${aarch64_multilibs}; do
4326 case ${aarch64_multilib} in
4328 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4329 Upgrade the Assembler.])
4337 # Check if we have binutils support for relocations types needed by -fpic
4338 gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,
4341 ldr x0, [[x2, #:gotpage_lo15:globalsym]]
4342 ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1,
4343 [Define if your assembler supports relocs needed by -fpic.])])
4344 # Enable Branch Target Identification Mechanism and Return Address
4345 # Signing by default.
4346 AC_ARG_ENABLE(standard-branch-protection,
4348 AS_HELP_STRING([--enable-standard-branch-protection],
4349 [enable Branch Target Identification Mechanism and Return Address Signing by default for AArch64])
4350 AS_HELP_STRING([--disable-standard-branch-protection],
4351 [disable Branch Target Identification Mechanism and Return Address Signing by default for AArch64])
4356 tm_defines="${tm_defines} TARGET_ENABLE_BTI=1 TARGET_ENABLE_PAC_RET=1"
4361 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-standard-branch-protection.\
4362 Valid choices are 'yes' and 'no'.])
4367 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
4368 AC_ARG_ENABLE(fix-cortex-a53-835769,
4370 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
4371 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4372 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
4373 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4378 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
4383 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
4384 Valid choices are 'yes' and 'no'.])
4390 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
4391 AC_ARG_ENABLE(fix-cortex-a53-843419,
4393 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
4394 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4395 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
4396 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4401 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
4406 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
4407 Valid choices are 'yes' and 'no'.])
4415 # All TARGET_ABI_OSF targets.
4416 alpha*-*-linux* | alpha*-*-*bsd*)
4417 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4418 gcc_cv_as_alpha_explicit_relocs,,
4421 extbl $3, $2, $3 !lituse_bytoff!1
4422 ldq $2, a($29) !literal!1
4423 ldq $4, b($29) !literal!2
4424 ldq_u $3, 0($2) !lituse_base!1
4425 ldq $27, f($29) !literal!5
4426 jsr $26, ($27), f !lituse_jsr!5
4427 ldah $29, 0($26) !gpdisp!3
4428 lda $0, c($29) !gprel
4429 ldah $1, d($29) !gprelhigh
4430 lda $1, d($1) !gprellow
4431 lda $29, 0($29) !gpdisp!3],,
4432 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
4433 [Define if your assembler supports explicit relocations.])])
4434 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
4435 gcc_cv_as_alpha_jsrdirect_relocs,,
4438 ldq $27, a($29) !literal!1
4439 jsr $26, ($27), a !lituse_jsrdirect!1],,
4440 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
4441 [Define if your assembler supports the lituse_jsrdirect relocation.])])
4445 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,
4446 [--mlink-relax], [.text],,
4447 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
4448 [Define if your avr assembler supports --mlink-relax option.])])
4450 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,
4452 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
4453 [Define if your avr assembler supports -mrmw option.])])
4455 gcc_GAS_CHECK_FEATURE([__gcc_isr pseudo instruction],
4456 gcc_cv_as_avr_mgccisr,
4462 [AC_DEFINE(HAVE_AS_AVR_MGCCISR_OPTION, 1,
4463 [Define if your avr assembler supports -mgcc-isr option.])])
4465 # Check how default linker description file implements .rodata for
4466 # avrxmega3 (PR21472). avr-gcc assumes .rodata is *not* loaded to
4467 # RAM so avr-gcc skips __do_copy_data for .rodata objects.
4468 AC_MSG_CHECKING(binutils for avrxmega3 .rodata support)
4469 cat > conftest.s <<EOF
4470 .section .rodata,"a",@progbits
4472 ;; avr-nm should print "... R xxvaryy", not "... D xxvaryy".
4477 AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega3 conftest.s -o conftest.o])
4478 AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega3 conftest.o -o conftest.elf])
4479 AC_TRY_COMMAND([$gcc_cv_nm conftest.elf > conftest.nm])
4480 if test -s conftest.nm
4482 if grep ' R xxvaryy' conftest.nm > /dev/null; then
4484 AC_DEFINE(HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH, 1,
4485 [Define if your default avr linker script for avrxmega3 leaves .rodata in flash.])
4487 AC_MSG_RESULT(no: avrxmega3 .rodata located in RAM)
4488 echo "$as_me: nm output was" >&AS_MESSAGE_LOG_FD
4489 cat conftest.nm >&AS_MESSAGE_LOG_FD
4490 avr_ld_ver="`$gcc_cv_ld -v | sed -e 's:^.* ::'`"
4491 AC_MSG_WARN([[support for avrxmega3 .rodata in flash needs Binutils 2.29 or higher (have $avr_ld_ver)]])
4494 AC_MSG_RESULT(test failed)
4495 echo "$as_me: failed program was" >&AS_MESSAGE_LOG_FD
4496 cat conftest.s >&AS_MESSAGE_LOG_FD
4497 AC_MSG_WARN([[see `config.log' for details]])
4499 rm -f conftest.s conftest.o conftest.elf conftest.nm
4503 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
4504 gcc_cv_as_cris_no_mul_bug,
4505 [-no-mul-bug-abort], [.text],,
4506 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
4507 [Define if your assembler supports the -no-mul-bug-abort option.])])
4511 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,
4513 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
4514 [Define if your assembler supports -relax option.])])
4516 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
4517 gcc_cv_as_sparc_gotdata_op,
4524 sethi %gdop_hix22(foo), %g1
4525 xor %g1, %gdop_lox10(foo), %g1
4526 ld [[%l7 + %g1]], %g2, %gdop(foo)],
4527 [if test x$gcc_cv_ld != x \
4528 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4529 if test x$gcc_cv_objdump != x; then
4530 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
4531 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
4532 gcc_cv_as_sparc_gotdata_op=no
4534 gcc_cv_as_sparc_gotdata_op=yes
4539 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
4540 [Define if your assembler and linker support GOTDATA_OP relocs.])])
4542 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
4543 gcc_cv_as_sparc_ua_pcrel,
4551 .uaword %r_disp32(foo)],
4552 [if test x$gcc_cv_ld != x \
4553 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4554 gcc_cv_as_sparc_ua_pcrel=yes
4557 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
4558 [Define if your assembler and linker support unaligned PC relative relocs.])
4560 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
4561 gcc_cv_as_sparc_ua_pcrel_hidden,
4566 .uaword %r_disp32(foo)
4567 .byte 0x32, 0x33, 0x34
4572 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4573 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
4574 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
4575 | grep ' 31000000 07323334' > /dev/null 2>&1; then
4576 if $gcc_cv_objdump -R conftest 2> /dev/null \
4577 | grep 'DISP32' > /dev/null 2>&1; then
4580 gcc_cv_as_sparc_ua_pcrel_hidden=yes
4584 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
4585 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
4586 ]) # unaligned pcrel relocs
4588 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
4589 gcc_cv_as_sparc_offsetable_lo10,
4592 or %g1, %lo(ab) + 12, %g1
4593 or %g1, %lo(ab + 12), %g1],
4594 [if test x$gcc_cv_objdump != x \
4595 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
4596 | grep ' 82106000 82106000' > /dev/null 2>&1; then
4597 gcc_cv_as_sparc_offsetable_lo10=yes
4599 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
4600 [Define if your assembler supports offsetable %lo().])])
4602 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
4603 gcc_cv_as_sparc_fmaf,
4606 .register %g2, #scratch
4607 .register %g3, #scratch
4609 fmaddd %f0, %f2, %f4, %f6
4610 addxccc %g1, %g2, %g3
4611 fsrl32 %f2, %f4, %f8
4612 fnaddd %f10, %f12, %f14],,
4613 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
4614 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
4616 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
4617 gcc_cv_as_sparc_sparc4,
4620 .register %g2, #scratch
4621 .register %g3, #scratch
4624 1: cwbneg %g2, %g3, 1f
4627 aes_kexpand0 %f4, %f6, %f8
4628 des_round %f38, %f40, %f42, %f44
4629 camellia_f %f54, %f56, %f58, %f60
4630 kasumi_fi_xor %f46, %f48, %f50, %f52],,
4631 [AC_DEFINE(HAVE_AS_SPARC4, 1,
4632 [Define if your assembler supports SPARC4 instructions.])])
4634 gcc_GAS_CHECK_FEATURE([SPARC5 and VIS 4.0 instructions],
4635 gcc_cv_as_sparc_sparc5,
4638 .register %g2, #scratch
4639 .register %g3, #scratch
4642 fpadd8 %f0, %f2, %f4],,
4643 [AC_DEFINE(HAVE_AS_SPARC5_VIS4, 1,
4644 [Define if your assembler supports SPARC5 and VIS 4.0 instructions.])])
4646 gcc_GAS_CHECK_FEATURE([SPARC6 instructions],
4647 gcc_cv_as_sparc_sparc6,
4650 .register %g2, #scratch
4651 .register %g3, #scratch
4654 fpsll64x %f0, %f2, %f4],,
4655 [AC_DEFINE(HAVE_AS_SPARC6, 1,
4656 [Define if your assembler supports SPARC6 instructions.])])
4658 gcc_GAS_CHECK_FEATURE([LEON instructions],
4659 gcc_cv_as_sparc_leon,
4662 .register %g2, #scratch
4663 .register %g3, #scratch
4667 casa [[%g2]] 0xb, %g3, %g1],,
4668 [AC_DEFINE(HAVE_AS_LEON, 1,
4669 [Define if your assembler supports LEON instructions.])])
4673 i[34567]86-*-* | x86_64-*-*)
4677 # Full C++ conformance when using a shared libstdc++-v3 requires some
4678 # support from the Cygwin DLL, which in more recent versions exports
4679 # wrappers to aid in interposing and redirecting operators new, delete,
4680 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
4681 # are configuring for a version of Cygwin that exports the wrappers.
4682 if test x$host = x$target && test x$host_cpu = xi686; then
4683 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
4685 # Can't check presence of libc functions during cross-compile, so
4686 # we just have to assume we're building for an up-to-date target.
4687 gcc_ac_cygwin_dll_wrappers=yes
4689 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
4690 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
4691 [Define if you want to generate code by default that assumes that the
4692 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
4695 cygwin* | pe | mingw32*)
4696 # Recent binutils allows the three-operand form of ".comm" on PE. This
4697 # definition is used unconditionally to initialise the default state of
4698 # the target option variable that governs usage of the feature.
4699 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,,
4701 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
4702 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
4703 [Define if your assembler supports specifying the alignment
4704 of objects allocated using the GAS .comm command.])
4705 # Used for DWARF 2 in PE
4706 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
4707 gcc_cv_as_ix86_pe_secrel32,,
4712 [if test x$gcc_cv_ld != x \
4713 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
4714 gcc_cv_as_ix86_pe_secrel32=yes
4717 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
4718 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
4719 # Test if the assembler supports the extended form of the .section
4720 # directive that specifies section alignment. LTO support uses this,
4721 # but normally only after installation, so we warn but don't fail the
4722 # configure if LTO is enabled but the assembler does not support it.
4723 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
4724 -fatal-warnings,[.section lto_test,"dr0"])
4725 if test x$gcc_cv_as_section_has_align != xyes; then
4726 case ",$enable_languages," in
4728 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
4735 darwin2* | darwin19*)
4736 gcc_GAS_CHECK_FEATURE([llvm assembler x86-pad-for-align option],
4737 gcc_cv_as_mllvm_x86_pad_for_align,
4738 [-mllvm -x86-pad-for-align=false], [.text],,
4739 [AC_DEFINE(HAVE_AS_MLLVM_X86_PAD_FOR_ALIGN, 1,
4740 [Define if your Mac OS X assembler supports -mllvm -x86-pad-for-align=false.])])
4744 gcc_GAS_CHECK_FEATURE([-xbrace_comment], gcc_cv_as_ix86_xbrace_comment,
4745 [-xbrace_comment=no], [.text],,
4746 [AC_DEFINE(HAVE_AS_XBRACE_COMMENT_OPTION, 1,
4747 [Define if your assembler supports -xbrace_comment option.])])
4749 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
4750 gcc_cv_as_ix86_filds,,
4751 [filds (%ebp); fists (%ebp)],,
4752 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
4753 [Define if your assembler uses filds and fists mnemonics.])])
4755 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
4756 gcc_cv_as_ix86_fildq,,
4757 [fildq (%ebp); fistpq (%ebp)],,
4758 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
4759 [Define if your assembler uses fildq and fistq mnemonics.])])
4761 gcc_GAS_CHECK_FEATURE([cmov syntax],
4762 gcc_cv_as_ix86_cmov_sun_syntax,,
4763 [cmovl.l %edx, %eax],,
4764 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
4765 [Define if your assembler supports the Sun syntax for cmov.])])
4767 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
4768 gcc_cv_as_ix86_ffreep,,
4770 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
4771 [Define if your assembler supports the ffreep mnemonic.])])
4773 gcc_GAS_CHECK_FEATURE([.quad directive],
4774 gcc_cv_as_ix86_quad,,
4776 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
4777 [Define if your assembler supports the .quad directive.])])
4779 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
4780 gcc_cv_as_ix86_sahf,,
4783 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
4784 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
4786 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
4787 gcc_cv_as_ix86_interunit_movq,,
4791 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
4792 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
4793 [Define if your assembler supports interunit movq mnemonic.])
4795 gcc_GAS_CHECK_FEATURE([hle prefixes],
4796 gcc_cv_as_ix86_hle,,
4797 [lock xacquire cmpxchg %esi, (%ecx)],,
4798 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
4799 [Define if your assembler supports HLE prefixes.])])
4801 gcc_GAS_CHECK_FEATURE([swap suffix],
4802 gcc_cv_as_ix86_swap,,
4803 [movl.s %esp, %ebp],,
4804 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
4805 [Define if your assembler supports the swap suffix.])])
4807 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
4808 gcc_cv_as_ix86_diff_sect_delta,,
4816 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4817 [Define if your assembler supports the subtraction of symbols in different sections.])])
4819 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4820 gcc_cv_as_ix86_rep_lock_prefix,,
4826 lock addl %edi, (%eax,%esi)
4827 lock orl $0, (%esp)],,
4828 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4829 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4831 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4832 gcc_cv_as_ix86_ud2,,
4834 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4835 [Define if your assembler supports the 'ud2' mnemonic.])])
4837 # Enforce 32-bit output with gas and gld.
4838 if test x$gas = xyes; then
4839 as_ix86_gas_32_opt="--32"
4841 if echo "$ld_ver" | grep GNU > /dev/null; then
4842 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4843 ld_ix86_gld_32_opt="-melf_i386_sol2"
4845 ld_ix86_gld_32_opt="-melf_i386"
4849 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4850 gcc_cv_as_ix86_tlsgdplt,
4851 [$as_ix86_gas_32_opt],
4852 [call tls_gd@tlsgdplt],
4853 [if test x$gcc_cv_ld != x \
4854 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4855 gcc_cv_as_ix86_tlsgdplt=yes
4858 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4859 [Define if your assembler and linker support @tlsgdplt.])])
4862 .section .tdata,"aw'$tls_section_flag'",@progbits
4864 .section .text,"ax",@progbits
4865 call tls_ld@tlsldmplt'
4867 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4868 gcc_cv_as_ix86_tlsldmplt,
4869 [$as_ix86_gas_32_opt],
4871 [if test x$gcc_cv_ld != x \
4872 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4873 gcc_cv_as_ix86_tlsldmplt=yes
4876 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4877 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4878 [Define to 1 if your assembler and linker support @tlsldmplt.])
4881 .section .text,"ax",@progbits
4883 .type _start, @function
4885 leal value@tlsldm(%ebx), %eax
4886 call ___tls_get_addr@plt
4888 .section .tdata,"aw'$tls_section_flag'",@progbits
4889 .type value, @object
4891 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4892 gcc_cv_as_ix86_tlsldm,
4893 [$as_ix86_gas_32_opt],
4895 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4896 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4897 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4898 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4899 gcc_cv_as_ix86_tlsldm=yes
4903 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4904 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4905 [Define to 1 if your assembler and linker support @tlsldm.])
4916 gcc_GAS_CHECK_FEATURE([R_386_GOT32X reloc],
4917 gcc_cv_as_ix86_got32x,
4918 [$as_ix86_gas_32_opt],
4920 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4921 && test x$gcc_cv_readelf != x \
4922 && $gcc_cv_readelf --relocs --wide conftest.o 2>&1 \
4923 | grep R_386_GOT32X > /dev/null 2>&1 \
4924 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
4925 if $gcc_cv_objdump -dw conftest 2>&1 \
4926 | grep 0xffffff > /dev/null 2>&1; then
4927 gcc_cv_as_ix86_got32x=no
4929 gcc_cv_as_ix86_got32x=yes
4933 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_GOT32X,
4934 [`if test x"$gcc_cv_as_ix86_got32x" = xyes; then echo 1; else echo 0; fi`],
4935 [Define 0/1 if your assembler and linker support @GOT.])
4937 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
4938 gcc_cv_as_ix86_gotoff_in_data,
4939 [$as_ix86_gas_32_opt],
4945 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
4946 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
4947 [Define true if the assembler supports '.long foo@GOTOFF'.])
4950 .section .text,"ax",@progbits
4952 .type _start, @function
4954 leal ld@tlsldm(%ecx), %eax
4955 call *___tls_get_addr@GOT(%ecx)
4956 leal gd@tlsgd(%ecx), %eax
4957 call *___tls_get_addr@GOT(%ecx)
4959 .section .tdata,"aw'$tls_section_flag'",@progbits
4967 gcc_GAS_CHECK_FEATURE([calling ___tls_get_addr via GOT],
4968 gcc_cv_as_ix86_tls_get_addr_via_got,
4969 [$as_ix86_gas_32_opt],
4971 [if test x$gcc_cv_ld != x \
4972 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
4973 gcc_cv_as_ix86_tls_get_addr_via_got=yes
4976 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLS_GET_ADDR_GOT,
4977 [`if test x"$gcc_cv_as_ix86_tls_get_addr_via_got" = xyes; then echo 1; else echo 0; fi`],
4978 [Define 0/1 if your assembler and linker support calling ___tls_get_addr via GOT.])
4982 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4983 gcc_cv_as_ia64_ltoffx_ldxmov_relocs,,
4985 addl r15 = @ltoffx(x#), gp
4987 ld8.mov r16 = [[r15]], x#
4989 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4990 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4998 gcc_GAS_CHECK_FEATURE([.machine directive support],
4999 gcc_cv_as_machine_directive,,
5000 [ .machine ppc7400])
5001 if test x$gcc_cv_as_machine_directive != xyes; then
5002 echo "*** This target requires an assembler supporting \".machine\"" >&2
5003 echo you can get it from: https://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
5004 test x$build = x$target && exit 1
5010 *-*-aix*) conftest_s=' .machine "pwr5"
5013 *-*-darwin*) conftest_s=' .text
5015 *) conftest_s=' .machine power4
5020 gcc_GAS_CHECK_FEATURE([mfcr field support],
5021 gcc_cv_as_powerpc_mfcrf,,
5023 [AC_DEFINE(HAVE_AS_MFCRF, 1,
5024 [Define if your assembler supports mfcr field.])])
5027 *-*-aix*) conftest_s=' .csect .text[[PR]]
5029 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
5033 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
5034 *) conftest_s=' .text
5036 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
5039 gcc_GAS_CHECK_FEATURE([rel16 relocs],
5040 gcc_cv_as_powerpc_rel16, -a32,
5042 [AC_DEFINE(HAVE_AS_REL16, 1,
5043 [Define if your assembler supports R_PPC_REL16 relocs.])])
5046 *-*-aix*) conftest_s=' .machine "pwr7"
5049 *) conftest_s=' .machine power7
5054 gcc_GAS_CHECK_FEATURE([vector-scalar support],
5055 gcc_cv_as_powerpc_vsx, -a32,
5057 [AC_DEFINE(HAVE_AS_VSX, 1,
5058 [Define if your assembler supports VSX instructions.])])
5060 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5061 gcc_cv_as_powerpc_gnu_attribute,,
5062 [.gnu_attribute 4,1],,
5063 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5064 [Define if your assembler supports .gnu_attribute.])])
5066 gcc_GAS_CHECK_FEATURE([prologue entry point marker support],
5067 gcc_cv_as_powerpc_entry_markers,-a64 --fatal-warnings,
5068 [ .reloc .,R_PPC64_ENTRY; nop],,
5069 [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1,
5070 [Define if your assembler supports the R_PPC64_ENTRY relocation.])])
5072 gcc_GAS_CHECK_FEATURE([plt sequence marker support],
5073 gcc_cv_as_powerpc_pltseq_markers,-a32 --fatal-warnings,
5074 [ .reloc .,R_PPC_PLTSEQ; nop],,
5075 [AC_DEFINE(HAVE_AS_PLTSEQ, 1,
5076 [Define if your assembler supports R_PPC*_PLTSEQ relocations.])])
5080 gcc_GAS_CHECK_FEATURE([AIX .ref support],
5082 [ .csect stuff[[rw]]
5088 [AC_DEFINE(HAVE_AS_REF, 1,
5089 [Define if your assembler supports .ref])])
5091 gcc_GAS_CHECK_FEATURE([AIX DWARF location lists section support],
5092 gcc_cv_as_aix_dwloc,,
5097 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
5098 [Define if your assembler supports AIX debug frame section label reference.])])
5104 gcc_GAS_CHECK_FEATURE([explicit relocation support],
5105 gcc_cv_as_mips_explicit_relocs,,
5106 [ lw $4,%gp_rel(foo)($4)],,
5107 [if test x$target_cpu_default = x
5108 then target_cpu_default=MASK_EXPLICIT_RELOCS
5109 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
5112 gcc_GAS_CHECK_FEATURE([-mno-shared support],
5113 gcc_cv_as_mips_no_shared,[-mno-shared], [nop],,
5114 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
5115 [Define if the assembler understands -mno-shared.])])
5117 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5118 gcc_cv_as_mips_gnu_attribute,,
5119 [.gnu_attribute 4,1],,
5120 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5121 [Define if your assembler supports .gnu_attribute.])])
5123 gcc_GAS_CHECK_FEATURE([.module support],
5124 gcc_cv_as_mips_dot_module,[-32],
5127 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
5128 [Define if your assembler supports .module.])])
5129 if test x$gcc_cv_as_mips_dot_module = xno \
5130 && test x$with_fp_32 != x; then
5132 [Requesting --with-fp-32= requires assembler support for .module.])
5135 gcc_GAS_CHECK_FEATURE([.micromips support],
5136 gcc_cv_as_micromips_support,[--fatal-warnings],
5138 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
5139 [Define if your assembler supports the .set micromips directive])])
5141 gcc_GAS_CHECK_FEATURE([.dtprelword support],
5142 gcc_cv_as_mips_dtprelword,,
5143 [.section .tdata,"awT",@progbits
5147 .dtprelword x+0x8000],,
5148 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
5149 [Define if your assembler supports .dtprelword.])])
5151 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
5152 gcc_cv_as_mips_dspr1_mult,,
5162 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
5163 [Define if your assembler supports DSPR1 mult.])])
5165 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
5166 gcc_cv_as_ld_jalr_reloc=no
5167 if test $gcc_cv_as_mips_explicit_relocs = yes; then
5168 if test $in_tree_ld = yes ; then
5169 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 \
5170 && test $in_tree_ld_is_elf = yes; then
5171 gcc_cv_as_ld_jalr_reloc=yes
5173 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
5174 echo ' .ent x' > conftest.s
5175 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
5176 echo ' lw $25,%call16(y)($28)' >> conftest.s
5177 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
5178 echo '1: jalr $25' >> conftest.s
5179 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
5180 echo '1: jalr $25' >> conftest.s
5181 echo ' .end x' >> conftest.s
5182 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
5183 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
5184 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
5185 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
5186 gcc_cv_as_ld_jalr_reloc=yes
5192 if test $gcc_cv_as_ld_jalr_reloc = yes; then
5193 if test x$target_cpu_default = x; then
5194 target_cpu_default=MASK_RELAX_PIC_CALLS
5196 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
5199 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
5201 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
5202 [gcc_cv_ld_mips_personality_relaxation],
5203 [gcc_cv_ld_mips_personality_relaxation=no
5204 if test $in_tree_ld = yes ; then
5205 if test "$gcc_cv_gld_major_version" -eq 2 \
5206 -a "$gcc_cv_gld_minor_version" -ge 21 \
5207 -o "$gcc_cv_gld_major_version" -gt 2; then
5208 gcc_cv_ld_mips_personality_relaxation=yes
5210 elif test x$gcc_cv_as != x \
5211 -a x$gcc_cv_ld != x \
5212 -a x$gcc_cv_readelf != x ; then
5213 cat > conftest.s <<EOF
5215 .cfi_personality 0x80,indirect_ptr
5222 .section .data,"aw",@progbits
5226 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
5227 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
5228 if $gcc_cv_readelf -d conftest 2>&1 \
5229 | grep TEXTREL > /dev/null 2>&1; then
5231 elif $gcc_cv_readelf --relocs conftest 2>&1 \
5232 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
5235 gcc_cv_ld_mips_personality_relaxation=yes
5239 rm -f conftest.s conftest.o conftest])
5240 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
5241 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
5242 [Define if your linker can relax absolute .eh_frame personality
5243 pointers into PC-relative form.])
5246 gcc_GAS_CHECK_FEATURE([-mnan= support],
5249 [AC_DEFINE(HAVE_AS_NAN, 1,
5250 [Define if the assembler understands -mnan=.])])
5251 if test x$gcc_cv_as_mips_nan = xno \
5252 && test x$with_nan != x; then
5254 [Requesting --with-nan= requires assembler support for -mnan=])
5258 # Earlier GAS versions generically support .gnu_attribute, but the
5259 # msp430 assembler will not do anything with it.
5260 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5261 gcc_cv_as_msp430_gnu_attribute,,
5262 [.gnu_attribute 4,1],,
5263 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5264 [Define if your assembler supports .gnu_attribute.])])
5265 gcc_GAS_CHECK_FEATURE([.mspabi_attribute support],
5266 gcc_cv_as_msp430_mspabi_attribute,,
5267 [.mspabi_attribute 4,2],,
5268 [AC_DEFINE(HAVE_AS_MSPABI_ATTRIBUTE, 1,
5269 [Define if your assembler supports .mspabi_attribute.])])
5270 if test x$enable_newlib_nano_formatted_io = xyes; then
5271 AC_DEFINE(HAVE_NEWLIB_NANO_FORMATTED_IO, 1, [Define if GCC has been
5272 configured with --enable-newlib-nano-formatted-io.])
5276 # Versions 2.33 and earlier lacked support for the %gotoff relocation
5277 # syntax that is documented in the ABI specification.
5278 gcc_GAS_CHECK_FEATURE([support for %gotoff relocations in constant data],
5279 gcc_cv_as_nios2_gotoff_relocation,,
5282 .long %gotoff(foo)],,
5283 [AC_DEFINE(HAVE_AS_NIOS2_GOTOFF_RELOCATION, 1,
5284 [Define if your assembler supports %gotoff relocation syntax.])])
5287 gcc_GAS_CHECK_FEATURE([.attribute support],
5288 gcc_cv_as_riscv_attribute,,
5289 [.attribute stack_align,4],,
5290 [AC_DEFINE(HAVE_AS_RISCV_ATTRIBUTE, 1,
5291 [Define if your assembler supports .attribute.])])
5292 gcc_GAS_CHECK_FEATURE([-misa-spec= support],
5293 gcc_cv_as_riscv_isa_spec,
5295 [AC_DEFINE(HAVE_AS_MISA_SPEC, 1,
5296 [Define if the assembler understands -misa-spec=.])])
5297 gcc_GAS_CHECK_FEATURE([-march=rv32i_zifencei support],
5298 gcc_cv_as_riscv_march_zifencei,
5299 [-march=rv32i_zifencei2p0],,,
5300 [AC_DEFINE(HAVE_AS_MARCH_ZIFENCEI, 1,
5301 [Define if the assembler understands -march=rv*_zifencei.])])
5304 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5305 gcc_cv_as_s390_gnu_attribute,,
5306 [.gnu_attribute 8,1],,
5307 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5308 [Define if your assembler supports .gnu_attribute.])])
5309 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
5310 gcc_cv_as_s390_machine_machinemode,,
5315 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
5316 [Define if your assembler supports .machine and .machinemode.])])
5317 gcc_GAS_CHECK_FEATURE([architecture modifiers support],
5318 gcc_cv_as_s390_architecture_modifiers,,
5319 [ .machine z13+vx ],,
5320 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
5321 [Define if your assembler supports architecture modifiers.])])
5322 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints],
5323 gcc_cv_as_s390_vector_loadstore_alignment_hints,,
5324 [ vl %v24,0(%r15),3 ],,
5325 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS, 1,
5326 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument.])])
5327 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints on z13],
5328 gcc_cv_as_s390_vector_loadstore_alignment_hints_on_z13, [-mzarch -march=z13],
5329 [ vl %v24,0(%r15),3 ],,
5330 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS_ON_Z13, 1,
5331 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument on z13.])])
5336 # Mips and HP-UX need the GNU assembler.
5337 # Linux on IA64 might be able to use the Intel assembler.
5340 mips*-*-* | *-*-hpux* )
5341 if test x$gas_flag = xyes \
5342 || test x"$host" != x"$build" \
5343 || test ! -x "$gcc_cv_as" \
5344 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
5347 echo "*** This configuration requires the GNU assembler" >&2
5353 # This tests if the assembler supports two registers for global_load functions
5354 # (like in LLVM versions <12) or one register (like in LLVM 12).
5357 AC_MSG_CHECKING(assembler fix for global_load functions)
5358 gcc_cv_as_gcn_global_load_fixed=yes
5359 if test x$gcc_cv_as != x; then
5360 cat > conftest.s <<EOF
5361 global_store_dwordx2 v[[1:2]], v[[4:5]], s[[14:15]]
5363 if $gcc_cv_as -triple=amdgcn--amdhsa -filetype=obj -mcpu=gfx900 -o conftest.o conftest.s > /dev/null 2>&1; then
5364 gcc_cv_as_gcn_global_load_fixed=no
5366 rm -f conftest.s conftest.o conftest
5368 global_load_fixed=`if test x$gcc_cv_as_gcn_global_load_fixed = xyes; then echo 1; else echo 0; fi`
5369 AC_DEFINE_UNQUOTED(HAVE_GCN_ASM_GLOBAL_LOAD_FIXED, $global_load_fixed,
5370 [Define if your assembler has fixed global_load functions.])
5371 AC_MSG_RESULT($gcc_cv_as_gcn_global_load_fixed)
5377 # Test the LLVM assembler syntax dialect; they have made a number of
5378 # changes between LLVM 12 & 13 without any backward compatibility.
5379 gcc_GAS_CHECK_FEATURE([assembler amdgcn_target v2/3 syntax],
5380 gcc_cv_as_gcn_asm_v3_syntax,
5381 [-triple=amdgcn--amdhsa -mcpu=gfx906 -mattr=+xnack],
5382 [.amdgcn_target "amdgcn-unknown-amdhsa--gfx906+xnack"],,
5383 [AC_DEFINE(HAVE_GCN_ASM_V3_SYNTAX, 1,
5384 [Define if your assembler expects amdgcn_target gfx908+xnack syntax.])])
5385 gcc_GAS_CHECK_FEATURE([assembler amdgcn_target v4 syntax],
5386 gcc_cv_as_gcn_asm_v4_syntax,
5387 [-triple=amdgcn--amdhsa -mcpu=gfx908 -mattr=+xnack],
5388 [.amdgcn_target "amdgcn-unknown-amdhsa--gfx908:xnack+"],,
5389 [AC_DEFINE(HAVE_GCN_ASM_V4_SYNTAX, 1,
5390 [Define if your assembler expects amdgcn_target gfx908:xnack+ syntax.])])
5392 # Some attribute names changed in the move to v4 ...
5393 if test $gcc_cv_as_gcn_asm_v3_syntax = yes; then
5395 sramattr="+sram-ecc"
5397 elif test $gcc_cv_as_gcn_asm_v4_syntax = yes; then
5399 sramattr=":sramecc+"
5402 AC_MSG_ERROR([Unrecognised assembler version])
5405 # Test whether the LLVM assembler accepts -mattr=+xnack without any
5406 # diagnostic. LLVM 9 & 10 accept the option whether it makes sense or not,
5407 # LLVM 12+ throws a warning for GPUs without support.
5408 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=+xnack for fiji],
5409 gcc_cv_as_gcn_xnack_ecc_fiji,
5410 [-triple=amdgcn--amdhsa -mcpu=fiji -mattr=+xnack 2>conftest.err], [],
5411 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5412 || gcc_cv_as_gcn_xnack_ecc_fiji=yes],
5413 [AC_DEFINE(HAVE_GCN_XNACK_FIJI, 1,
5414 [Define if your assembler allows -mattr=+xnack for fiji.])])
5416 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=+xnack for gfx900],
5417 gcc_cv_as_gcn_xnack_ecc_gfx900,
5418 [-triple=amdgcn--amdhsa -mcpu=gfx900 -mattr=+xnack 2>conftest.err], [],
5419 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5420 || gcc_cv_as_gcn_xnack_ecc_gfx900=yes],
5421 [AC_DEFINE(HAVE_GCN_XNACK_GFX900, 1,
5422 [Define if your assembler allows -mattr=+xnack for gfx900.])])
5424 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=+xnack for gfx906],
5425 gcc_cv_as_gcn_xnack_ecc_gfx906,
5426 [-triple=amdgcn--amdhsa -mcpu=gfx906 -mattr=+xnack 2>conftest.err], [],
5427 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5428 || gcc_cv_as_gcn_xnack_ecc_gfx906=yes],
5429 [AC_DEFINE(HAVE_GCN_XNACK_GFX906, 1,
5430 [Define if your assembler allows -mattr=+xnack for gfx906.])])
5432 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=+xnack for gfx908],
5433 gcc_cv_as_gcn_xnack_ecc_gfx908,
5434 [-triple=amdgcn--amdhsa -mcpu=gfx908 -mattr=+xnack 2>conftest.err], [],
5435 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5436 || gcc_cv_as_gcn_xnack_ecc_gfx908=yes],
5437 [AC_DEFINE(HAVE_GCN_XNACK_GFX908, 1,
5438 [Define if your assembler allows -mattr=+xnack for gfx908.])])
5441 # Test whether the LLVM assembler accepts -mattr=+sramecc without any
5442 # diagnostic. LLVM 9 & 10 accept the option whether it makes sense or not,
5443 # (some?) LLVM 12 rejects it for all GPUs, and LLVM13 throws a warning
5444 # for GPUs without support.
5445 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=$sramopt for fiji],
5446 gcc_cv_as_gcn_sram_ecc_fiji,
5447 [-triple=amdgcn--amdhsa -mcpu=fiji -mattr=$sramopt 2>conftest.err], [],
5448 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5449 || gcc_cv_as_gcn_sram_ecc_fiji=yes],
5450 [AC_DEFINE(HAVE_GCN_SRAM_ECC_FIJI, 1,
5451 [Define if your assembler allows -mattr=+sramecc for fiji.])])
5453 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=$sramopt for gfx900],
5454 gcc_cv_as_gcn_sram_ecc_gfx900,
5455 [-triple=amdgcn--amdhsa -mcpu=gfx900 -mattr=$sramopt 2>conftest.err], [],
5456 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5457 || gcc_cv_as_gcn_sram_ecc_gfx900=yes],
5458 [AC_DEFINE(HAVE_GCN_SRAM_ECC_GFX900, 1,
5459 [Define if your assembler allows -mattr=+sramecc for gfx900.])])
5461 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=$sramopt for gfx906],
5462 gcc_cv_as_gcn_sram_ecc_gfx906,
5463 [-triple=amdgcn--amdhsa -mcpu=gfx906 -mattr=$sramopt 2>conftest.err], [],
5464 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5465 || gcc_cv_as_gcn_sram_ecc_gfx906=yes],
5466 [AC_DEFINE(HAVE_GCN_SRAM_ECC_GFX906, 1,
5467 [Define if your assembler allows -mattr=+sramecc for gfx906.])])
5469 gcc_GAS_CHECK_FEATURE([assembler accepts -mattr=$sramopt for gfx908],
5470 gcc_cv_as_gcn_sram_ecc_gfx908,
5471 [-triple=amdgcn--amdhsa -mcpu=gfx908 -mattr=$sramopt 2>conftest.err], [],
5472 [grep "." conftest.err >&AS_MESSAGE_LOG_FD \
5473 || gcc_cv_as_gcn_sram_ecc_gfx908=yes],
5474 [AC_DEFINE(HAVE_GCN_SRAM_ECC_GFX908, 1,
5475 [Define if your assembler allows -mattr=+sramecc for gfx908.])])
5479 gcc_GAS_CHECK_FEATURE([assembler for arm accepts context-specific architecture extensions],
5480 gcc_cv_as_arm_option_extensions,
5481 [-march=armv8.1-m.main+mve],
5486 [AC_DEFINE(HAVE_GAS_ARM_EXTENDED_ARCH, 1,
5487 [Define if your Arm assembler permits context-specific feature extensions.])])
5490 # ??? Not all targets support dwarf2 debug_line, even within a version
5491 # of gas. Moreover, we need to emit a valid instruction to trigger any
5492 # info to the output file. So, as supported targets are added to gas 2.11,
5493 # add some instruction here to (also) show we expect this might work.
5494 # ??? Once 2.11 is released, probably need to add first known working
5495 # version to the per-target configury.
5497 aarch64 | alpha | arc | arm | avr | bfin | cris | csky | i386 | m32c | m68k \
5498 | microblaze | mips | nds32 | nios2 | pa | riscv | rs6000 | score | sparc \
5499 | tilegx | tilepro | visium | xstormy16 | xtensa)
5509 if test x"$insn" != x; then
5511 .file 1 \"conftest.s\"
5514 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
5515 gcc_cv_as_dwarf2_debug_line,,
5517 [if test x$gcc_cv_objdump != x \
5518 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
5519 | grep debug_line > /dev/null 2>&1; then
5520 gcc_cv_as_dwarf2_debug_line=yes
5521 elif test x$gcc_cv_otool != x \
5522 && $gcc_cv_otool -l conftest.o 2> /dev/null \
5523 | grep debug_line > /dev/null 2>&1; then
5524 gcc_cv_as_dwarf2_debug_line=yes
5527 # The .debug_line file table must be in the exact order that
5528 # we specified the files, since these indices are also used
5529 # by DW_AT_decl_file. Approximate this test by testing if
5530 # the assembler bitches if the same index is assigned twice.
5531 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
5532 gcc_cv_as_dwarf2_file_buggy,,
5536 if test $gcc_cv_as_dwarf2_debug_line = yes \
5537 && test $gcc_cv_as_dwarf2_file_buggy = no; then
5538 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
5539 [Define if your assembler supports dwarf2 .file/.loc directives,
5540 and preserves file table indices exactly as given.])
5542 if test $gcc_cv_as_leb128 = yes; then
5544 .file 1 \"conftest.s\"
5545 .loc 1 3 0 view .LVU1
5551 gcc_GAS_CHECK_FEATURE([dwarf2 debug_view support],
5552 gcc_cv_as_dwarf2_debug_view,,
5554 [AC_DEFINE(HAVE_AS_DWARF2_DEBUG_VIEW, 1,
5555 [Define if your assembler supports views in dwarf2 .loc directives.])])
5559 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
5560 gcc_cv_as_gdwarf2_flag,
5561 [--gdwarf2], [$insn],,
5562 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
5563 [Define if your assembler supports the --gdwarf2 option.])])
5565 gcc_GAS_CHECK_FEATURE([--gdwarf-5 option],
5566 gcc_cv_as_gdwarf_5_flag,
5567 [--gdwarf-5], [$insn],
5568 [if test x$gcc_cv_objdump != x \
5569 && $gcc_cv_objdump -Wi conftest.o 2>&1 \
5570 | grep DW_TAG_compile_unit > /dev/null 2>&1; then
5571 gcc_cv_as_gdwarf_5_flag=yes;
5572 fi],[AC_DEFINE(HAVE_AS_GDWARF_5_DEBUG_FLAG, 1,
5573 [Define if your assembler supports the --gdwarf-5 option.])])
5576 win32 | pe | cygwin* | mingw32*)
5577 section_flags=\"dr\"
5578 function_type=".def foo; .scl 2; .type 32; .endef"
5581 section_flags=\"\",%progbits
5582 function_type=".type foo, %function"
5583 function_size=".size foo, .-foo";;
5585 dwarf4_debug_info_size=0x46
5586 dwarf4_high_pc_form=7
5587 dwarf4_debug_aranges_size=0x2c
5589 for dwarf4_addr_size in 8 4; do
5605 .section .debug_info,$section_flags
5607 .4byte $dwarf4_debug_info_size
5609 .4byte .Ldebug_abbrev0
5610 .byte 0x$dwarf4_addr_size
5612 .ascii \"GNU C17\\0\"
5616 .${dwarf4_addr_size}byte .Ltext0
5617 .${dwarf4_addr_size}byte .Letext0-.Ltext0
5618 .4byte .Ldebug_line0
5624 .${dwarf4_addr_size}byte .LFB0
5625 .${dwarf4_addr_size}byte .LFE0-.LFB0
5629 .section .debug_abbrev,$section_flags
5645 .byte 0x$dwarf4_high_pc_form
5666 .byte 0x$dwarf4_high_pc_form
5672 .section .debug_aranges,$section_flags
5673 .4byte $dwarf4_debug_aranges_size
5675 .4byte .Ldebug_info0
5680 .${dwarf4_addr_size}byte .Ltext0
5681 .${dwarf4_addr_size}byte .Letext0-.Ltext0
5682 .${dwarf4_addr_size}byte 0
5683 .${dwarf4_addr_size}byte 0
5684 .section .debug_line,$section_flags
5686 .4byte .LELT0-.LSLT0
5689 .4byte .LELTP0-.LASLTP0
5717 .byte 0x$dwarf4_line_sz
5719 .${dwarf4_addr_size}byte .LM1
5724 .byte 0x$dwarf4_line_sz
5726 .${dwarf4_addr_size}byte .LM2
5731 .byte 0x$dwarf4_line_sz
5733 .${dwarf4_addr_size}byte .Letext0
5738 .section .debug_str,$section_flags
5742 if test $dwarf4_addr_size = 4; then
5743 gcc_GAS_CHECK_FEATURE([assembly of compiler generated 32-bit .debug_line],
5744 gcc_cv_as_debug_line_32_flag,,
5746 [dwarf4_success=yes])
5748 gcc_GAS_CHECK_FEATURE([assembly of compiler generated 64-bit .debug_line],
5749 gcc_cv_as_debug_line_64_flag,,
5751 [dwarf4_success=yes])
5753 if test $dwarf4_success = yes; then
5755 gcc_GAS_CHECK_FEATURE([--gdwarf-4 not refusing compiler generated .debug_line],
5756 gcc_cv_as_dwarf_4_debug_line_flag,
5757 [--gdwarf-4], [$conftest_s],,
5758 [dwarf4_success=yes])
5761 dwarf4_debug_info_size=0x36
5762 dwarf4_high_pc_form=6
5763 dwarf4_debug_aranges_size=0x1c
5767 if test $dwarf4_success = yes; then
5785 gcc_GAS_CHECK_FEATURE([--gdwarf-4 with the APP marker],
5786 gcc_cv_as_dwarf_4_app_flag,
5787 [--gdwarf-4], [$conftest_s],, [dwarf4_success=yes])
5790 if test $dwarf4_success = yes; then
5800 gcc_GAS_CHECK_FEATURE([working --gdwarf-4/--gdwarf-5 for all sources],
5801 gcc_cv_as_working_gdwarf_n_flag,
5805 if test x$gcc_cv_objdump != x \
5806 && $gcc_cv_objdump -W conftest.o 2>&1 \
5807 | grep conftest.s > /dev/null 2>&1; then
5808 gcc_cv_as_working_gdwarf_n_flag=no
5810 gcc_cv_as_working_gdwarf_n_flag=yes
5812 changequote([,])dnl])
5813 if test $gcc_cv_as_working_gdwarf_n_flag = yes; then
5814 AC_DEFINE(HAVE_AS_WORKING_DWARF_N_FLAG, 1,
5815 [Define if your assembler supports --gdwarf-4/--gdwarf-5 even with
5816 compiler generated .debug_line.])
5820 gcc_GAS_CHECK_FEATURE([--gstabs option],
5821 gcc_cv_as_gstabs_flag,
5822 [--gstabs], [$insn],,
5823 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
5824 [Define if your assembler supports the --gstabs option.])])
5826 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
5827 gcc_cv_as_debug_prefix_map_flag,
5828 [--debug-prefix-map /a=/b], [$insn],,
5829 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
5830 [Define if your assembler supports the --debug-prefix-map option.])])
5833 gcc_GAS_CHECK_FEATURE([compressed debug sections],
5834 gcc_cv_as_compress_debug,,,
5835 [# gas compiled without zlib cannot compress debug sections and warns
5836 # about it, but still exits successfully. So check for this, too.
5837 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
5839 gcc_cv_as_compress_debug=0
5840 # Since binutils 2.26, gas supports --compress-debug-sections=type,
5841 # defaulting to the ELF gABI format.
5842 elif $gcc_cv_as --compress-debug-sections=zlib-gnu -o conftest.o conftest.s > /dev/null 2>&1
5844 gcc_cv_as_compress_debug=2
5845 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5846 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5847 # Before binutils 2.26, gas only supported --compress-debug-options and
5848 # emitted the traditional GNU format.
5849 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
5851 gcc_cv_as_compress_debug=1
5852 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5853 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5855 gcc_cv_as_compress_debug=0
5857 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
5858 [Define to the level of your assembler's compressed debug section support.])
5859 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
5860 [Define to the assembler option to enable compressed debug sections.])
5861 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
5862 [Define to the assembler option to disable compressed debug sections.])
5864 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,,
5866 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
5867 [Define if your assembler supports .lcomm with an alignment field.])])
5869 if test x$with_sysroot = x && test x$host = x$target \
5870 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
5871 && test "$prefix" != "NONE"; then
5872 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
5873 [Define to PREFIX/include if cpp should also search that directory.])
5876 # Determine the version of glibc, if any, used on the target.
5877 AC_MSG_CHECKING([for target glibc version])
5878 AC_ARG_WITH([glibc-version],
5879 [AS_HELP_STRING([--with-glibc-version=M.N],
5880 [assume GCC used with glibc version M.N or later])], [
5881 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
5882 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
5883 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
5885 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
5887 glibc_version_major=0
5888 glibc_version_minor=0
5889 [if test -f $target_header_dir/features.h \
5890 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
5891 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
5892 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
5893 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
5895 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
5896 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
5897 [GNU C Library major version number used on the target, or 0.])
5898 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
5899 [GNU C Library minor version number used on the target, or 0.])
5901 AC_ARG_ENABLE(gnu-unique-object,
5902 [AS_HELP_STRING([--enable-gnu-unique-object],
5903 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
5904 [case $enable_gnu_unique_object in
5906 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
5907 Valid choices are 'yes' and 'no'.]) ;;
5909 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,,
5910 [.type foo, '$target_type_format_char'gnu_unique_object],,
5911 # We need to unquote above to to use the definition from config.gcc.
5912 # Also check for ld.so support, i.e. glibc 2.11 or higher.
5913 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
5915 if test x$enable_gnu_unique_object = xyes; then
5916 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
5917 [Define if your assembler supports @gnu_unique_object.])
5920 AC_CACHE_CHECK([assembler for tolerance to line number 0],
5921 [gcc_cv_as_line_zero],
5922 [gcc_cv_as_line_zero=no
5923 if test "x$gcc_cv_as" != x; then
5924 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
5925 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
5926 test "x`cat conftest.out`" = x
5928 gcc_cv_as_line_zero=yes
5930 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
5931 cat conftest.s >&AS_MESSAGE_LOG_FD
5932 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
5933 cat conftest.out >&AS_MESSAGE_LOG_FD
5935 rm -f conftest.o conftest.s conftest.out
5937 if test "x$gcc_cv_as_line_zero" = xyes; then
5938 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
5939 [Define if the assembler won't complain about a line such as # 0 "" 2.])
5942 AC_MSG_CHECKING(support for thin archives)
5943 thin_archive_support=no
5944 echo 'int main (void) { return 0; }' > conftest.c
5945 if ($AR --version | sed 1q | grep "GNU ar" \
5946 && $CC $CFLAGS -c conftest.c \
5947 && $AR rcT conftest.a conftest.o \
5948 && $CC $CFLAGS $LDFLAGS -o conftest conftest.a) >/dev/null 2>&1; then
5949 thin_archive_support=yes
5951 rm -f conftest.c conftest.o conftest.a conftest
5952 AC_MSG_RESULT($thin_archive_support)
5953 AC_SUBST(thin_archive_support)
5955 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
5956 gcc_cv_ld_eh_frame_hdr=no
5957 if test $in_tree_ld = yes ; then
5958 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 \
5959 && test $in_tree_ld_is_elf = yes; then
5960 gcc_cv_ld_eh_frame_hdr=yes
5962 elif test x$gcc_cv_ld != x; then
5963 if echo "$ld_ver" | grep GNU > /dev/null; then
5964 # Check if linker supports --eh-frame-hdr option
5965 if $gcc_cv_ld --help 2>&1 | grep eh-frame-hdr > /dev/null; then
5966 gcc_cv_ld_eh_frame_hdr=yes
5971 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
5972 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
5973 gcc_cv_ld_eh_frame_hdr=yes
5979 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
5980 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
5981 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
5982 [Define if your linker supports .eh_frame_hdr.])
5984 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
5986 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
5987 gcc_cv_ld_eh_frame_ciev3=no
5988 if test $in_tree_ld = yes ; then
5989 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 \
5990 && test $in_tree_ld_is_elf = yes; then
5991 gcc_cv_ld_eh_frame_ciev3=yes
5993 elif test x$gcc_cv_ld != x; then
5994 if echo "$ld_ver" | grep GNU > /dev/null; then
5995 gcc_cv_ld_eh_frame_ciev3=yes
5996 if test 0"$ld_date" -lt 20040513; then
5997 if test -n "$ld_date"; then
5998 # If there was date string, but was earlier than 2004-05-13, fail
5999 gcc_cv_ld_eh_frame_ciev3=no
6000 elif test "$ld_vers_major" -lt 2; then
6001 gcc_cv_ld_eh_frame_ciev3=no
6002 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
6003 gcc_cv_ld_eh_frame_ciev3=no
6009 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
6010 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
6011 gcc_cv_ld_eh_frame_ciev3=yes
6017 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
6018 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
6019 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
6020 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
6022 AC_MSG_CHECKING(linker position independent executable support)
6024 if test $in_tree_ld = yes ; then
6026 # Full PIE support on Solaris was only introduced in gld 2.26.
6027 *-*-solaris2*) gcc_gld_pie_min_version=26 ;;
6028 *) gcc_gld_pie_min_version=15 ;;
6030 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 \
6031 && test $in_tree_ld_is_elf = yes; then
6034 elif test x$gcc_cv_ld != x; then
6035 # Check if linker supports -pie option
6036 if $gcc_cv_ld --help 2>&1 | grep -- -pie > /dev/null; then
6040 if echo "$ld_ver" | grep GNU > /dev/null \
6041 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
6048 *-*-solaris2.1[[1-9]]*)
6049 # Solaris 11.3 added PIE support.
6050 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
6057 if test x"$gcc_cv_ld_pie" = xyes; then
6058 AC_DEFINE(HAVE_LD_PIE, 1,
6059 [Define if your linker supports PIE option.])
6061 AC_MSG_RESULT($gcc_cv_ld_pie)
6063 AC_MSG_CHECKING(linker PIE support with copy reloc)
6064 gcc_cv_ld_pie_copyreloc=no
6065 if test $gcc_cv_ld_pie = yes ; then
6066 if test $in_tree_ld = yes ; then
6067 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
6068 gcc_cv_ld_pie_copyreloc=yes
6070 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6071 # Check if linker supports -pie option with copy reloc
6073 i?86-*-linux* | x86_64-*-linux*)
6074 cat > conftest1.s <<EOF
6077 .type a_glob, @object
6082 cat > conftest2.s <<EOF
6085 .type main, @function
6087 movl %eax, a_glob(%rip)
6090 .section .data.rel,"aw",@progbits
6095 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6096 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
6097 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6098 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
6099 gcc_cv_ld_pie_copyreloc=yes
6101 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
6106 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
6107 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
6108 [Define 0/1 if your linker supports -pie option with copy reloc.])
6109 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
6111 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
6112 gcc_cv_ld_eh_gc_sections=no
6113 if test $in_tree_ld = yes ; then
6114 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 \
6115 && test $in_tree_ld_is_elf = yes; then
6116 gcc_cv_ld_eh_gc_sections=yes
6118 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
6119 cat > conftest.s <<EOF
6122 .type _start, @function
6125 .size _start, .-_start
6126 .section .text.foo,"ax",@progbits
6127 .type foo, @function
6131 .section .gcc_except_table.foo,"a",@progbits
6134 .section .eh_frame,"a",@progbits
6137 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6138 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6139 | grep "gc-sections option ignored" > /dev/null; then
6140 gcc_cv_ld_eh_gc_sections=no
6141 elif $gcc_cv_objdump -h conftest 2> /dev/null \
6142 | grep gcc_except_table > /dev/null; then
6143 gcc_cv_ld_eh_gc_sections=yes
6144 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
6145 if test x$gcc_cv_as_comdat_group != xyes; then
6146 gcc_cv_ld_eh_gc_sections=no
6147 cat > conftest.s <<EOF
6150 .type _start, @function
6153 .size _start, .-_start
6154 .section .gnu.linkonce.t.foo,"ax",@progbits
6155 .type foo, @function
6159 .section .gcc_except_table.foo,"a",@progbits
6162 .section .eh_frame,"a",@progbits
6165 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6166 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6167 | grep "gc-sections option ignored" > /dev/null; then
6168 gcc_cv_ld_eh_gc_sections=no
6169 elif $gcc_cv_objdump -h conftest 2> /dev/null \
6170 | grep gcc_except_table > /dev/null; then
6171 gcc_cv_ld_eh_gc_sections=yes
6177 rm -f conftest.s conftest.o conftest
6181 # ??? This apparently exposes a binutils bug with PC-relative relocations.
6182 gcc_cv_ld_eh_gc_sections=no
6185 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
6186 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
6187 [Define if your linker supports garbage collection of
6188 sections in presence of EH frames.])
6190 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
6192 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
6193 gcc_cv_ld_eh_gc_sections_bug=no
6194 if test $in_tree_ld = yes ; then
6195 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 \
6196 && test $in_tree_ld_is_elf = yes; then
6197 gcc_cv_ld_eh_gc_sections_bug=yes
6199 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
6200 gcc_cv_ld_eh_gc_sections_bug=yes
6201 cat > conftest.s <<EOF
6204 .type _start, @function
6207 .size _start, .-_start
6208 .section .text.startup.foo,"ax",@progbits
6209 .type foo, @function
6213 .section .gcc_except_table.foo,"a",@progbits
6216 .section .eh_frame,"a",@progbits
6219 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
6220 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
6221 | grep "gc-sections option ignored" > /dev/null; then
6223 elif $gcc_cv_objdump -h conftest 2> /dev/null \
6224 | grep gcc_except_table > /dev/null; then
6225 gcc_cv_ld_eh_gc_sections_bug=no
6228 rm -f conftest.s conftest.o conftest
6230 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
6231 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
6232 [Define if your linker has buggy garbage collection of
6233 sections support when .text.startup.foo like sections are used.])
6235 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
6237 AC_MSG_CHECKING(linker for compressed debug sections)
6238 # gold/gld support compressed debug sections since binutils 2.19/2.21
6239 # In binutils 2.26, gld gained support for the ELF gABI format.
6240 if test $in_tree_ld = yes ; then
6241 gcc_cv_ld_compress_debug=0
6242 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 \
6243 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
6244 gcc_cv_ld_compress_debug=2
6245 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
6246 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 \
6247 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = no; then
6248 gcc_cv_ld_compress_debug=3
6249 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
6250 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 \
6251 && test $in_tree_ld_is_elf = yes; then
6252 gcc_cv_ld_compress_debug=1
6254 elif echo "$ld_ver" | grep GNU > /dev/null; then
6255 if test "$ld_vers_major" -lt 2 \
6256 || test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
6257 gcc_cv_ld_compress_debug=0
6258 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
6259 gcc_cv_ld_compress_debug=1
6261 gcc_cv_ld_compress_debug=3
6262 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
6264 if test $ld_is_gold = yes; then
6265 gcc_cv_ld_compress_debug=2
6266 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
6272 # Introduced in Solaris 11.2.
6273 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
6274 gcc_cv_ld_compress_debug=3
6275 gcc_cv_ld_compress_debug_option="-z compress-sections"
6277 gcc_cv_ld_compress_debug=0
6281 # Assume linkers other than GNU ld don't support compessed debug
6283 gcc_cv_ld_compress_debug=0
6288 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
6289 [Define to the level of your linker's compressed debug section support.])
6290 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
6291 [Define to the linker option to enable compressed debug sections.])
6292 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
6294 if test x"$ld64_flag" = x"yes"; then
6296 # Set defaults for possibly untestable items.
6297 gcc_cv_ld64_export_dynamic=0
6298 gcc_cv_ld64_platform_version=0
6300 if test "$build" = "$host"; then
6306 # On Darwin, because of FAT library support, it is often possible to execute
6307 # exes from compatible archs even when the host differs from the build system.
6308 case "$build","$host" in
6309 x86_64-*-darwin*,i?86-*-darwin* | powerpc64*-*-darwin*,powerpc*-*-darwin*)
6314 # If the configurer specified a minimum ld64 version to be supported, then use
6315 # that to determine feature support.
6316 if test x"${gcc_cv_ld64_version}" != x; then
6317 AC_MSG_CHECKING(ld64 specified version)
6318 gcc_cv_ld64_major=`echo "$gcc_cv_ld64_version" | sed -e 's/\..*//'`
6319 AC_MSG_RESULT($gcc_cv_ld64_major)
6320 if test "$gcc_cv_ld64_major" -ge 236; then
6321 gcc_cv_ld64_export_dynamic=1
6323 if test "$gcc_cv_ld64_major" -ge 512; then
6324 gcc_cv_ld64_platform_version=1
6326 elif test -x "$gcc_cv_ld" -a "$darwin_try_test" -eq 1; then
6327 # If the version was not specified, try to find it.
6328 AC_MSG_CHECKING(linker version)
6329 if test x"${gcc_cv_ld64_version}" = x; then
6330 gcc_cv_ld64_version=`$gcc_cv_ld -v 2>&1 | grep ld64 | sed s/.*ld64-// | awk '{print $1}'`
6332 AC_MSG_RESULT($gcc_cv_ld64_version)
6334 AC_MSG_CHECKING(linker for -export_dynamic support)
6335 gcc_cv_ld64_export_dynamic=1
6336 if $gcc_cv_ld -export_dynamic < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6337 gcc_cv_ld64_export_dynamic=0
6339 AC_MSG_RESULT($gcc_cv_ld64_export_dynamic)
6341 AC_MSG_CHECKING(linker for -platform_version support)
6342 gcc_cv_ld64_platform_version=1
6343 if $gcc_cv_ld -platform_version macos 10.5 0.0 < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
6344 gcc_cv_ld64_platform_version=0
6346 AC_MSG_RESULT($gcc_cv_ld64_platform_version)
6349 if test x"${gcc_cv_ld64_version}" != x; then
6350 AC_DEFINE_UNQUOTED(LD64_VERSION, "${gcc_cv_ld64_version}",
6351 [Define to ld64 version.])
6354 AC_DEFINE_UNQUOTED(LD64_HAS_EXPORT_DYNAMIC, $gcc_cv_ld64_export_dynamic,
6355 [Define to 1 if ld64 supports '-export_dynamic'.])
6357 AC_DEFINE_UNQUOTED(LD64_HAS_PLATFORM_VERSION, $gcc_cv_ld64_platform_version,
6358 [Define to 1 if ld64 supports '-platform_version'.])
6361 if test x"$dsymutil_flag" = x"yes"; then
6363 # If the user specified a dsymutil path, then we will already have the
6364 # version string, otherwise, pick it up.
6365 if test x"$gcc_cv_dsymutil" = x; then
6366 AC_MSG_WARN([dsymutil is a required tool for this system, but not found])
6367 dsymutil_vers="tool unspecified"
6368 elif test x"$dsymutil_vers" = x; then
6369 dsymutil_vers=`$gcc_cv_dsymutil -v /dev/null 2>&1`
6372 dsymutil_temp=`echo $dsymutil_vers | sed 1q`
6373 AC_MSG_CHECKING(dsymutil version "$dsymutil_temp")
6374 if echo $dsymutil_temp | grep dwarfutils- > /dev/null; then
6375 dsymutil_kind=DWARFUTILS
6376 dsymutil_vers=`echo $dsymutil_temp | sed 's/.*dwarfutils-\([[0-9\.]]*\).*/\1/'`
6377 elif echo $dsymutil_temp | grep clang- > /dev/null; then
6379 dsymutil_vers=`echo $dsymutil_temp | sed 's/.*clang-\([[0-9\.]]*\).*/\1/'`
6380 elif echo $dsymutil_temp | grep 'LLVM version ' > /dev/null; then
6382 dsymutil_vers=`echo $dsymutil_temp | sed 's/.*LLVM\ version\ \([[0-9\.]]*\).*/\1/'`
6384 dsymutil_kind=UNKNOWN
6387 dsymutil_major=`expr "$dsymutil_vers" : '\([[0-9]]*\)'`
6388 dsymutil_minor=`expr "$dsymutil_vers" : '[[0-9]]*\.\([[0-9]]*\)'`
6389 dsymutil_tiny=`expr "$dsymutil_vers" : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
6390 if test x"${dsymutil_minor}" = x; then
6393 if test x"${dsymutil_tiny}" = x; then
6396 AC_DEFINE_UNQUOTED(DSYMUTIL_VERSION, [$dsymutil_kind,${dsymutil_major},${dsymutil_minor},${dsymutil_tiny}],
6397 [Define to the dsymutil version.])
6398 AC_MSG_RESULT($dsymutil_vers : $dsymutil_kind ${dsymutil_major} ${dsymutil_minor} ${dsymutil_tiny} )
6402 win32 | pe | cygwin* | mingw32*)
6403 AC_MSG_CHECKING(broken PE linker dwarf5 support)
6404 gcc_cv_ld_broken_pe_dwarf5=yes
6405 if test $in_tree_ld = yes ; then
6406 if grep -q '\.debug_loclists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6407 $gcc_cv_ld_gld_srcdir/scripttempl/pe*.sc \
6408 && grep -q '\.debug_rnglists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6409 $gcc_cv_ld_gld_srcdir/scripttempl/pe*.sc; then
6410 gcc_cv_ld_broken_pe_dwarf5=no
6413 if $gcc_cv_ld --verbose 2>&1 | grep -q '\.debug_loclists.*BLOCK.*__section_alignment__.*NOLOAD.*:' \
6414 && $gcc_cv_ld --verbose 2>&1 | grep -q '\.debug_rnglists.*BLOCK.*__section_alignment__.*NOLOAD.*:'; then
6415 gcc_cv_ld_broken_pe_dwarf5=no
6418 if test x$gcc_cv_ld_broken_pe_dwarf5 = xyes; then
6419 AC_DEFINE(HAVE_LD_BROKEN_PE_DWARF5, 1,
6420 [Define if the PE linker has broken DWARF 5 support.])
6422 AC_MSG_RESULT($gcc_cv_ld_broken_pe_dwarf5)
6424 AC_MSG_CHECKING(PE linker --disable-dynamicbase support)
6425 gcc_cv_ld_disable_dynamicbase=no
6426 if test $in_tree_ld = yes; then
6427 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 36 -o "$gcc_cv_gld_major_version" -gt 2; then \
6428 gcc_cv_ld_disable_dynamicbase=yes
6431 if $gcc_cv_ld --help 2>&1 | grep -q 'disable\-]dynamicbase' > /dev/null; then
6432 gcc_cv_ld_disable_dynamicbase=yes
6435 if test x"$gcc_cv_ld_disable_dynamicbase" = xyes; then
6436 AC_DEFINE(HAVE_LD_PE_DISABLE_DYNAMICBASE, 1,
6437 [Define if the PE linker supports --disable-dynamicbase option.])
6439 AC_MSG_RESULT($gcc_cv_ld_disable_dynamicbase)
6447 AC_CACHE_CHECK(linker --as-needed support,
6448 gcc_cv_ld_as_needed,
6449 [gcc_cv_ld_as_needed=no
6450 gcc_cv_ld_as_needed_option='--as-needed'
6451 gcc_cv_ld_no_as_needed_option='--no-as-needed'
6452 if test $in_tree_ld = yes ; then
6453 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 \
6454 && test $in_tree_ld_is_elf = yes; then
6455 gcc_cv_ld_as_needed=yes
6456 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 28; then
6457 gcc_cv_ld_as_needed_option='--push-state --as-needed'
6458 gcc_cv_ld_no_as_needed_option='--pop-state'
6461 elif test x$gcc_cv_ld != x; then
6462 # Check if linker supports --as-needed and --no-as-needed options
6463 if $gcc_cv_ld --help 2>&1 | grep as-needed > /dev/null; then
6464 gcc_cv_ld_as_needed=yes
6465 if $gcc_cv_ld --help 2>&1 | grep push-state > /dev/null \
6466 && $gcc_cv_ld --help 2>&1 | grep pop-state > /dev/null \
6467 && echo "$ld_ver" | grep GNU > /dev/null \
6468 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 28; then
6469 # Use these options only when both ld.bfd and ld.gold support
6470 # --push-state/--pop-state, which unfortunately wasn't added
6472 gcc_cv_ld_as_needed_option='--push-state --as-needed'
6473 gcc_cv_ld_no_as_needed_option='--pop-state'
6476 case "$target:$gnu_ld" in
6478 # Solaris 2 ld always supports -z ignore/-z record. Prefer the native
6480 gcc_cv_ld_as_needed=yes
6481 gcc_cv_ld_as_needed_option="-z ignore"
6482 gcc_cv_ld_no_as_needed_option="-z record"
6486 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
6487 # dl_iterate_phdr, i.e. since Solaris 11.
6489 *-*-solaris2.1[[1-9]]*)
6491 i?86-*-* | x86_64-*-*)
6492 if echo "$ld_ver" | grep GNU > /dev/null; then
6493 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
6494 gcc_cv_ld_as_needed=no
6500 gcc_cv_ld_as_needed=no
6504 if test x"$gcc_cv_ld_as_needed" = xyes; then
6505 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
6506 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
6507 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
6508 [Define to the linker option to ignore unused dependencies.])
6509 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
6510 [Define to the linker option to keep unused dependencies.])
6513 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
6514 saved_LDFLAGS="$LDFLAGS"
6515 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
6516 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
6517 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
6518 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
6520 LDFLAGS="$saved_LDFLAGS"
6521 if test "x$gcc_cv_ld_clearcap" = xyes; then
6522 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
6523 [Define if the linker supports clearing hardware capabilities via mapfile.])
6524 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
6526 AC_MSG_RESULT($gcc_cv_ld_clearcap)
6532 emul_name="-melf32lppc"
6535 emul_name="-melf32ppc"
6538 AC_CACHE_CHECK(linker .gnu.attributes long double support,
6540 [gcc_cv_ld_ppc_attr=no
6541 if test x"$ld_is_gold" = xyes; then
6542 gcc_cv_ld_ppc_attr=yes
6543 elif test $in_tree_ld = yes ; then
6544 if test "$gcc_cv_gld_major_version" -eq 2 \
6545 -a "$gcc_cv_gld_minor_version" -ge 28 \
6546 -o "$gcc_cv_gld_major_version" -gt 2; then
6547 gcc_cv_ld_ppc_attr=yes
6549 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6550 # check that merging the long double .gnu_attribute doesn't warn
6551 cat > conftest1.s <<EOF
6554 cat > conftest2.s <<EOF
6557 if $gcc_cv_as -a32 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6558 && $gcc_cv_as -a32 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6559 && $gcc_cv_ld $emul_name -r -o conftest.o conftest1.o conftest2.o > /dev/null 2> conftest.err \
6560 && test ! -s conftest.err; then
6561 gcc_cv_ld_ppc_attr=yes
6563 rm -f conftest.err conftest.o conftest1.o conftest2.o conftest1.s conftest2.s
6566 if test x$gcc_cv_ld_ppc_attr = xyes; then
6567 AC_DEFINE(HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE, 1,
6568 [Define if your PowerPC linker has .gnu.attributes long double support.])
6573 case "$target:$tm_file" in
6574 powerpc64*-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
6577 emul_name="-melf64lppc"
6580 emul_name="-melf64ppc"
6583 emul_name="-melf64lppc_fbsd"
6586 emul_name="-melf64ppc_fbsd"
6589 AC_CACHE_CHECK(linker support for omitting dot symbols,
6590 gcc_cv_ld_no_dot_syms,
6591 [gcc_cv_ld_no_dot_syms=no
6592 if test x"$ld_is_gold" = xyes; then
6593 gcc_cv_ld_no_dot_syms=yes
6594 elif test $in_tree_ld = yes ; then
6595 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
6596 gcc_cv_ld_no_dot_syms=yes
6598 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6599 cat > conftest1.s <<EOF
6603 cat > conftest2.s <<EOF
6604 .section ".opd","aw"
6609 .quad .LEfoo,.TOC.@tocbase,0
6615 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
6616 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
6617 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
6618 gcc_cv_ld_no_dot_syms=yes
6620 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
6623 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
6624 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
6625 [Define if your PowerPC64 linker only needs function descriptor syms.])
6628 AC_CACHE_CHECK(linker large toc support,
6629 gcc_cv_ld_large_toc,
6630 [gcc_cv_ld_large_toc=no
6631 if test x"$ld_is_gold" = xyes; then
6632 gcc_cv_ld_large_toc=yes
6633 elif test $in_tree_ld = yes ; then
6634 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
6635 gcc_cv_ld_large_toc=yes
6637 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
6638 cat > conftest.s <<EOF
6639 .section ".tbss","awT",@nobits
6645 addis 9,13,ie0@got@tprel@ha
6646 ld 9,ie0@got@tprel@l(9)
6648 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6649 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
6650 gcc_cv_ld_large_toc=yes
6652 rm -f conftest conftest.o conftest.s
6655 if test x"$gcc_cv_ld_large_toc" = xyes; then
6656 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6657 [Define if your PowerPC64 linker supports a large TOC.])
6660 AC_CACHE_CHECK(linker toc pointer alignment,
6661 gcc_cv_ld_toc_align,
6662 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
6663 cat > conftest.s <<EOF
6668 .section .data.rel.ro,"aw",@progbits
6673 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
6674 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
6675 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)) }'`
6677 rm -f conftest conftest.o conftest.s
6680 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
6681 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
6682 [Define to .TOC. alignment forced by your linker.])
6689 AC_CACHE_CHECK(linker large toc support,
6690 gcc_cv_ld_large_toc,
6691 [gcc_cv_ld_large_toc=no
6692 if test x$gcc_cv_as != x ; then
6693 cat > conftest.s <<EOF
6703 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
6704 gcc_cv_ld_large_toc=yes
6706 rm -f conftest conftest.o conftest.s
6709 if test x"$gcc_cv_ld_large_toc" = xyes; then
6710 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6711 [Define if your PowerPC64 linker supports a large TOC.])
6716 AC_CACHE_CHECK(linker --build-id support,
6718 [gcc_cv_ld_buildid=no
6719 if test $in_tree_ld = yes ; then
6720 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6721 "$gcc_cv_gld_minor_version" -ge 18 -o \
6722 "$gcc_cv_gld_major_version" -gt 2 \
6723 && test $in_tree_ld_is_elf = yes; then
6724 gcc_cv_ld_buildid=yes
6726 elif test x$gcc_cv_ld != x; then
6727 if $gcc_cv_ld --help 2>&1 | grep build-id > /dev/null; then
6728 gcc_cv_ld_buildid=yes
6731 if test x"$gcc_cv_ld_buildid" = xyes; then
6732 AC_DEFINE(HAVE_LD_BUILDID, 1,
6733 [Define if your linker supports --build-id.])
6736 AC_ARG_ENABLE(linker-build-id,
6737 [AS_HELP_STRING([--enable-linker-build-id],
6738 [compiler will always pass --build-id to linker])],
6740 enable_linker_build_id=no)
6742 if test x"$enable_linker_build_id" = xyes; then
6743 if test x"$gcc_cv_ld_buildid" = xyes; then
6744 AC_DEFINE(ENABLE_LD_BUILDID, 1,
6745 [Define if gcc should always pass --build-id to linker.])
6747 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
6751 # In binutils 2.21, GNU ld gained support for new emulations fully
6752 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
6753 AC_CACHE_CHECK(linker *_sol2 emulation support,
6754 gcc_cv_ld_sol2_emulation,
6755 [gcc_cv_ld_sol2_emulation=no
6756 if test $in_tree_ld = yes ; then
6757 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6758 "$gcc_cv_gld_minor_version" -ge 21 -o \
6759 "$gcc_cv_gld_major_version" -gt 2 \
6760 && test $in_tree_ld_is_elf = yes; then
6761 gcc_cv_ld_sol2_emulation=yes
6763 elif test x$gcc_cv_ld != x; then
6764 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
6765 grep _sol2 > /dev/null; then
6766 gcc_cv_ld_sol2_emulation=yes
6769 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
6770 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
6771 [Define if your linker supports the *_sol2 emulations.])
6774 AC_CACHE_CHECK(linker --sysroot support,
6776 [gcc_cv_ld_sysroot=no
6777 if test $in_tree_ld = yes ; then
6778 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
6779 gcc_cv_ld_sysroot=yes
6781 elif test x$gcc_cv_ld != x; then
6782 if $gcc_cv_ld --help 2>&1 | grep sysroot > /dev/null; then
6783 gcc_cv_ld_sysroot=yes
6786 if test x"$gcc_cv_ld_sysroot" = xyes; then
6787 AC_DEFINE(HAVE_LD_SYSROOT, 1,
6788 [Define if your linker supports --sysroot.])
6793 # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
6794 AC_CACHE_CHECK([system-provided CRTs on Solaris],
6795 gcc_cv_solaris_crts,
6796 [gcc_cv_solaris_crts=no
6797 if test x$host != x$target; then
6798 if test "x$with_sysroot" = xyes; then
6799 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
6801 target_sysroot="${with_sysroot}"
6804 target_libdir="$target_sysroot/usr/lib"
6805 # At the time they were added, gcrt1.o became a symlink for backwards
6806 # compatibility on x86, while crt1.o was added on sparc, so check for that.
6808 i?86-*-solaris2* | x86_64-*-solaris2*)
6809 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
6812 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
6817 if test x$gcc_cv_solaris_crts = xyes; then
6818 AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
6819 [Define if the system-provided CRTs are present on Solaris.])
6822 AC_ARG_ENABLE(libssp,
6823 [AS_HELP_STRING([--enable-libssp], [enable linking against libssp])],
6824 [case "${enableval}" in
6828 AC_MSG_ERROR([unknown libssp setting $enableval])
6832 # Test for stack protector support in target C library.
6833 AC_CACHE_CHECK(__stack_chk_fail in target C library,
6834 gcc_cv_libc_provides_ssp,
6835 [gcc_cv_libc_provides_ssp=no
6836 if test "x$enable_libssp" = "xno"; then
6837 gcc_cv_libc_provides_ssp=yes
6838 elif test "x$enable_libssp" = "xyes"; then
6839 gcc_cv_libc_provides_ssp=no
6843 # All versions of musl provide stack protector
6844 gcc_cv_libc_provides_ssp=yes;;
6845 *-*-linux* | *-*-kfreebsd*-gnu)
6846 # glibc 2.4 and later provides __stack_chk_fail and
6847 # either __stack_chk_guard, or TLS access to stack guard canary.
6848 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
6849 [if test -f $target_header_dir/features.h \
6850 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
6851 $target_header_dir/features.h > /dev/null; then
6852 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
6853 $target_header_dir/features.h > /dev/null && \
6854 test -f $target_header_dir/bits/uClibc_config.h && \
6855 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
6856 $target_header_dir/bits/uClibc_config.h > /dev/null; then
6857 gcc_cv_libc_provides_ssp=yes
6859 # all versions of Bionic support stack protector
6860 elif test -f $target_header_dir/sys/cdefs.h \
6861 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
6862 $target_header_dir/sys/cdefs.h > /dev/null; then
6863 gcc_cv_libc_provides_ssp=yes
6867 # Avoid complicated tests (see
6868 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
6869 # simply assert that glibc does provide this, which is true for all
6870 # realistically usable GNU/Hurd configurations.
6871 # All supported versions of musl provide it as well
6872 gcc_cv_libc_provides_ssp=yes;;
6873 *-*-darwin* | *-*-freebsd* | *-*-netbsd*)
6874 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
6875 [echo "no __stack_chk_fail on this target"])
6877 *) gcc_cv_libc_provides_ssp=no ;;
6881 if test x$gcc_cv_libc_provides_ssp = xyes; then
6882 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
6883 [Define if your target C library provides stack protector support])
6886 # Check whether --enable-default-ssp was given.
6887 AC_ARG_ENABLE(default-ssp,
6888 [AS_HELP_STRING([--enable-default-ssp],
6889 [enable Stack Smashing Protection as default])],[
6890 if test x$gcc_cv_libc_provides_ssp = xyes; then
6892 ia64*-*-*) enable_default_ssp=no ;;
6893 *) enable_default_ssp=$enableval ;;
6896 enable_default_ssp=no
6898 enable_default_ssp=no)
6899 if test x$enable_default_ssp = xyes ; then
6900 AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
6901 [Define if your target supports default stack protector and it is enabled.])
6903 AC_SUBST([enable_default_ssp])
6905 # Test for <sys/sdt.h> on the target.
6906 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
6907 AC_MSG_CHECKING(sys/sdt.h in the target C library)
6909 if test -f $target_header_dir/sys/sdt.h; then
6911 AC_DEFINE(HAVE_SYS_SDT_H, 1,
6912 [Define if your target C library provides sys/sdt.h])
6914 AC_MSG_RESULT($have_sys_sdt_h)
6916 # Check if TFmode long double should be used by default or not.
6917 # Some glibc targets used DFmode long double, but with glibc 2.4
6918 # and later they can use TFmode.
6920 powerpc*-*-linux* | \
6924 AC_ARG_WITH(long-double-128,
6925 [AS_HELP_STRING([--with-long-double-128],
6926 [use 128-bit long double by default])],
6927 gcc_cv_target_ldbl128="$with_long_double_128", [
6929 s390*-*-linux-musl*)
6930 gcc_cv_target_ldbl128=yes
6932 powerpc*-*-linux-musl*)
6933 gcc_cv_target_ldbl128=no
6936 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
6937 [gcc_cv_target_ldbl128=no
6938 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
6939 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
6940 && gcc_cv_target_ldbl128=yes
6948 if test x$gcc_cv_target_ldbl128 = xyes; then
6949 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
6950 [Define if TFmode long double should be the default])
6953 # Check if TFmode long double target should use the IBM extended double or IEEE
6954 # 128-bit floating point formats if long doubles are 128-bits long. The long
6955 # double type can only be switched on powerpc64 bit Linux systems where VSX is
6956 # supported. Other PowerPC systems do not build the IEEE 128-bit emulator in
6958 AC_ARG_WITH([long-double-format],
6959 [AS_HELP_STRING([--with-long-double-format={ieee,ibm}]
6960 [Specify whether PowerPC long double uses IEEE or IBM format])],[
6961 case "$target:$with_long_double_format" in
6962 powerpc64le-*-linux*:ieee | powerpc64le-*-linux*:ibm)
6965 powerpc64-*-linux*:ieee | powerpc64-*-linux*:ibm)
6966 # IEEE 128-bit emulation is only built on 64-bit VSX Linux systems
6968 power7 | power8 | power9 | power1*)
6972 AC_MSG_ERROR([Configuration option --with-long-double-format is only \
6973 supported if the default cpu is power7 or newer])
6974 with_long_double_format=""
6978 powerpc64*-*-linux*:*)
6979 AC_MSG_ERROR([--with-long-double-format argument should be ibm or ieee])
6980 with_long_double_format=""
6983 AC_MSG_ERROR([Configure option --with-long-double-format is only supported \
6984 on 64-bit PowerPC VSX Linux systems])
6985 with_long_double_format=""
6990 # Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP
6991 # values in the TCB. Currently, only GLIBC 2.23 and later support this.
6992 gcc_cv_libc_provides_hwcap_in_tcb=no
6995 GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], )
6998 if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then
6999 AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1,
7000 [Define if your target C Library provides the AT_HWCAP value in the TCB])
7003 # Check if the target LIBC handles PT_GNU_STACK.
7004 gcc_cv_libc_gnustack=unknown
7006 mips*-*-linux-musl*)
7007 gcc_cv_libc_gnustack=yes
7010 GCC_GLIBC_VERSION_GTE_IFELSE([2], [31], [gcc_cv_libc_gnustack=yes], )
7013 if test x$gcc_cv_libc_gnustack = xyes; then
7014 AC_DEFINE(TARGET_LIBC_GNUSTACK, 1,
7015 [Define if your target C Library properly handles PT_GNU_STACK])
7018 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
7019 gcc_cv_target_dl_iterate_phdr=unknown
7022 # <link.h> needs both a dl_iterate_phdr declaration and support for
7023 # compilation with largefile support.
7024 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
7025 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
7026 gcc_cv_target_dl_iterate_phdr=yes
7028 gcc_cv_target_dl_iterate_phdr=no
7031 *-*-dragonfly* | *-*-freebsd*)
7032 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
7033 gcc_cv_target_dl_iterate_phdr=yes
7035 gcc_cv_target_dl_iterate_phdr=no
7039 gcc_cv_target_dl_iterate_phdr=yes
7042 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
7043 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
7044 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
7045 [Define if your target C library provides the `dl_iterate_phdr' function.])
7047 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
7049 # We no longer support different GC mechanisms. Emit an error if
7050 # the user configures with --with-gc.
7052 [AS_HELP_STRING([--with-gc={page,zone}],
7053 [this option is not supported anymore. It used to choose
7054 the garbage collection mechanism to use with the compiler])],
7055 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
7058 # Libraries to use on the host. This will normally be set by the top
7059 # level Makefile. Here we simply capture the value for our Makefile.
7060 if test -z "${HOST_LIBS+set}"; then
7065 # Use the system's zlib library.
7068 dnl Very limited version of automake's enable-maintainer-mode
7070 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
7071 dnl maintainer-mode is disabled by default
7072 AC_ARG_ENABLE(maintainer-mode,
7073 [AS_HELP_STRING([--enable-maintainer-mode],
7074 [enable make rules and dependencies not useful
7075 (and sometimes confusing) to the casual installer])],
7076 maintainer_mode=$enableval,
7079 AC_MSG_RESULT($maintainer_mode)
7081 if test "$maintainer_mode" = "yes"; then
7088 dnl Variables for tags utilities; copied from automake 1.16.4+'s init.m4
7089 if test -z "$CTAGS"; then
7093 if test -z "$ETAGS"; then
7097 if test -z "$CSCOPE"; then
7102 dnl Whether to prevent multiple front-ends from linking at the same time
7104 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
7105 AC_ARG_ENABLE(link-mutex,
7106 [AS_HELP_STRING([--enable-link-mutex],
7107 [avoid linking multiple front-ends at once to avoid thrashing
7108 on the build machine])],
7109 do_link_mutex=$enableval,
7111 AC_MSG_RESULT($do_link_mutex)
7113 if test "$do_link_mutex" = "yes"; then
7118 AC_SUBST(DO_LINK_MUTEX)
7120 dnl Whether to prevent multiple GCC front-ends from linking at the same time
7122 AC_MSG_CHECKING([whether to serialize linking of multiple front-ends])
7123 AC_ARG_ENABLE(link-serialization,
7124 [AS_HELP_STRING([--enable-link-serialization],
7125 [avoid linking multiple GCC front-ends at once using make
7126 dependencies to avoid thrashing on the build machine])],
7127 do_link_serialization=$enableval,
7128 do_link_serialization=no)
7129 AC_MSG_RESULT($do_link_serialization)
7131 case "$do_link_serialization" in
7133 DO_LINK_SERIALIZATION=1;;
7134 [[1-9]] | [[1-9]][[0-9]] | [[1-9]][[0-9]][[0-9]])
7135 DO_LINK_SERIALIZATION=$do_link_serialization;;
7137 DO_LINK_SERIALIZATION=;;
7139 AC_MSG_ERROR(bad value ${do_link_serialization} given for --enable-link-serialization) ;;
7141 AC_SUBST(DO_LINK_SERIALIZATION)
7147 # Make empty files to contain the specs and options for each language.
7148 # Then add #include lines to for a compiler that has specs and/or options.
7154 # These (without "all_") are set in each config-lang.in.
7155 # `language' must be a single word so is spelled singularly.
7158 all_outputs='Makefile'
7159 # List of language configure and makefile fragments.
7160 all_lang_configurefrags=
7162 # Additional files for gengtype
7163 all_gtfiles="$target_gtfiles"
7165 # These are the languages that are set in --enable-languages,
7166 # and are available in the GCC tree.
7167 all_selected_languages=
7169 # Add the language fragments.
7170 # Languages are added via two mechanisms. Some information must be
7171 # recorded in makefile variables, these are defined in config-lang.in.
7172 # We accumulate them and plug them into the main Makefile.
7173 # The other mechanism is a set of hooks for each of the main targets
7174 # like `clean', `install', etc.
7176 language_hooks="Make-hooks"
7178 for lang in ${srcdir}/*/config-lang.in
7181 test "$lang" = "${srcdir}/*/config-lang.in" && continue
7183 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
7184 if test "x$lang_alias" = x
7186 echo "$lang doesn't set \$language." 1>&2
7189 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
7190 subdirs="$subdirs $subdir"
7192 # $gcc_subdir is where the gcc integration files are to be found
7193 # for a language, both for internal compiler purposes (compiler
7194 # sources implementing front-end to GCC tree converters), and for
7195 # build infrastructure purposes (Make-lang.in, etc.)
7197 # This will be <subdir> (relative to $srcdir) if a line like
7198 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
7199 # is found in <langdir>/config-lang.in, and will remain <langdir>
7202 # Except for the language alias (fetched above), the regular
7203 # "config-lang.in" contents are always retrieved from $gcc_subdir,
7204 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
7205 # only this and the language alias.
7207 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
7208 if [ "$gcc_subdir" = "" ]; then
7209 gcc_subdir="$subdir"
7212 case ",$enable_languages," in
7214 all_selected_languages="$all_selected_languages $lang_alias"
7215 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
7216 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
7228 . ${srcdir}/$gcc_subdir/config-lang.in
7229 if test "x$language" = x
7231 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
7236 case ",$enable_languages," in
7239 for i in $subdir_requires; do
7240 test -f "${srcdir}/$i/config-lang.in" && continue
7248 all_lang_configurefrags="$all_lang_configurefrags \$(srcdir)/$gcc_subdir/config-lang.in"
7249 if test "x$language" = xc && test -n "$all_lang_makefrags"; then
7250 # Put c/Make-lang.in fragment first to match serialization languages order.
7251 all_lang_makefrags="\$(srcdir)/$gcc_subdir/Make-lang.in $all_lang_makefrags"
7253 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
7255 if test -f $srcdir/$gcc_subdir/lang.opt; then
7256 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
7257 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
7259 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
7260 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
7262 all_languages="$all_languages $language"
7263 all_compilers="$all_compilers $compilers"
7264 all_outputs="$all_outputs $outputs"
7265 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
7266 case ",$enable_languages," in
7268 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
7270 AC_SUBST(enable_lto)
7277 for language in $all_selected_languages
7279 check_languages="$check_languages check-$language"
7283 for language in $all_selected_languages
7285 selftest_languages="$selftest_languages selftest-$language"
7288 # We link each language in with a set of hooks, reached indirectly via
7289 # lang.${target}. Only do so for selected languages.
7293 target_list="all.cross start.encap rest.encap tags \
7294 install-common install-man install-info install-dvi install-pdf \
7295 install-html dvi pdf html uninstall info man srcextra srcman srcinfo \
7296 mostlyclean clean distclean maintainer-clean install-plugin"
7298 for t in $target_list
7301 for lang in $all_selected_languages
7305 echo "lang.$t: $x" >> Make-hooks
7308 echo "ifeq (\$(DO_LINK_SERIALIZATION),)" >> Make-hooks
7309 echo "SERIAL_LIST =" >> Make-hooks
7310 echo else >> Make-hooks
7314 serialization_languages=c
7315 for lang in $all_selected_languages
7317 test $lang = c && continue
7318 if test $lang = lto; then
7319 serialization_languages="$serialization_languages lto1 lto2"
7321 serialization_languages="$serialization_languages $lang"
7324 for lang in $serialization_languages
7326 test $lang = c && continue
7327 lang_cnt=`expr $lang_cnt + 1`
7328 lang_list=" $prev$lang_list"
7331 echo "SERIAL_LIST = \$(wordlist \$(DO_LINK_SERIALIZATION),$lang_cnt,$lang_list)" >> Make-hooks
7332 echo endif >> Make-hooks
7333 echo "SERIAL_COUNT = `expr $lang_cnt + 1`" >> Make-hooks
7334 echo "INDEX.c = 0" >> Make-hooks
7336 for lang in $serialization_languages
7338 test $lang = c && continue
7339 echo "$lang.prev = \$(if \$(word $lang_cnt,\$(SERIAL_LIST)),\$(\$(word $lang_cnt,\$(SERIAL_LIST)).serial))" >> Make-hooks
7340 echo "INDEX.$lang = $lang_idx" >> Make-hooks
7341 lang_cnt=`expr $lang_cnt - 1`
7342 lang_idx=`expr $lang_idx + 1`
7346 # Option include files
7349 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
7350 option_includes="option-includes.mk"
7351 AC_SUBST_FILE(option_includes)
7359 echo "dir ." > .gdbinit
7360 echo "dir ${srcdir}" >> .gdbinit
7361 if test x$gdb_needs_out_file_path = xyes
7363 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
7365 if test "x$subdirs" != x; then
7368 echo "dir ${srcdir}/$s" >> .gdbinit
7371 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
7372 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
7374 # Put a breakpoint on __asan_report_error to help with debugging buffer
7377 *-fsanitize=address*)
7378 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
7382 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
7383 AC_SUBST(gcc_tooldir)
7386 # Find a directory in which to install a shared libgcc.
7388 AC_ARG_ENABLE(version-specific-runtime-libs,
7389 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
7390 [specify that runtime libraries should be
7391 installed in a compiler-specific directory])])
7393 # Substitute configuration variables
7396 AC_SUBST(all_compilers)
7397 AC_SUBST(all_gtfiles)
7398 AC_SUBST(all_lang_configurefrags)
7399 AC_SUBST(all_lang_makefrags)
7400 AC_SUBST(all_languages)
7401 AC_SUBST(all_selected_languages)
7402 AC_SUBST(build_exeext)
7403 AC_SUBST(build_install_headers_dir)
7404 AC_SUBST(build_xm_file_list)
7405 AC_SUBST(build_xm_include_list)
7406 AC_SUBST(build_xm_defines)
7407 AC_SUBST(build_file_translate)
7408 AC_SUBST(check_languages)
7409 AC_SUBST(selftest_languages)
7410 AC_SUBST(cpp_install_dir)
7411 AC_SUBST(xmake_file)
7412 AC_SUBST(tmake_file)
7413 AC_SUBST(TM_ENDIAN_CONFIG)
7414 AC_SUBST(TM_MULTILIB_CONFIG)
7415 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
7416 AC_SUBST(extra_gcc_objs)
7417 AC_SUBST(user_headers_inc_next_pre)
7418 AC_SUBST(user_headers_inc_next_post)
7419 AC_SUBST(extra_headers_list)
7420 AC_SUBST(extra_objs)
7421 AC_SUBST(extra_programs)
7422 AC_SUBST(float_h_file)
7423 AC_SUBST(gcc_config_arguments)
7424 AC_SUBST(gcc_gxx_include_dir)
7425 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
7426 AC_SUBST(gcc_gxx_libcxx_include_dir)
7427 AC_SUBST(gcc_gxx_libcxx_include_dir_add_sysroot)
7428 AC_SUBST(host_exeext)
7429 AC_SUBST(host_xm_file_list)
7430 AC_SUBST(host_xm_include_list)
7431 AC_SUBST(host_xm_defines)
7432 AC_SUBST(out_host_hook_obj)
7434 AC_SUBST(lang_opt_files)
7435 AC_SUBST(lang_specs_files)
7436 AC_SUBST(lang_tree_files)
7437 AC_SUBST(local_prefix)
7439 AC_SUBST(objc_boehm_gc)
7441 AC_SUBST(out_object_file)
7442 AC_SUBST(common_out_file)
7443 AC_SUBST(common_out_object_file)
7444 AC_SUBST(tm_file_list)
7445 AC_SUBST(tm_include_list)
7446 AC_SUBST(tm_defines)
7447 AC_SUBST(tm_p_file_list)
7448 AC_SUBST(tm_p_include_list)
7449 AC_SUBST(tm_d_file_list)
7450 AC_SUBST(tm_d_include_list)
7451 AC_SUBST(xm_file_list)
7452 AC_SUBST(xm_include_list)
7453 AC_SUBST(xm_defines)
7454 AC_SUBST(use_gcc_stdint)
7455 AC_SUBST(c_target_objs)
7456 AC_SUBST(cxx_target_objs)
7457 AC_SUBST(fortran_target_objs)
7458 AC_SUBST(d_target_objs)
7459 AC_SUBST(target_cpu_default)
7461 AC_SUBST_FILE(language_hooks)
7464 if test x${build} = x${host} ; then
7465 if test x${host} = x${target} ; then
7466 echo "Links are now set up to build a native compiler for ${target}." 1>&2
7468 echo "Links are now set up to build a cross-compiler" 1>&2
7469 echo " from ${host} to ${target}." 1>&2
7472 if test x${host} = x${target} ; then
7473 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
7474 echo " for ${target}." 1>&2
7476 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
7477 echo " from ${host} to ${target}." 1>&2
7481 AC_ARG_VAR(GMPLIBS,[How to link GMP])
7482 AC_ARG_VAR(GMPINC,[How to find GMP include files])
7484 AC_ARG_VAR(ISLLIBS,[How to link isl])
7485 AC_ARG_VAR(ISLINC,[How to find isl include files])
7486 if test "x${ISLLIBS}" != "x" ; then
7487 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
7491 AC_SUBST(pluginlibs)
7492 AC_SUBST(enable_plugin)
7493 if test x"$enable_plugin" = x"yes"; then
7494 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
7498 # Enable --enable-host-shared
7499 AC_ARG_ENABLE(host-shared,
7500 [AS_HELP_STRING([--enable-host-shared],
7501 [build host code as shared libraries])],
7502 [PICFLAG=-fPIC], [PICFLAG=])
7503 AC_SUBST(enable_host_shared)
7507 AC_ARG_ENABLE(libquadmath-support,
7508 [AS_HELP_STRING([--disable-libquadmath-support],
7509 [disable libquadmath support for Fortran])],
7510 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
7511 ENABLE_LIBQUADMATH_SUPPORT=yes)
7512 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
7513 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
7514 [Define to 1 to enable libquadmath support])
7518 # Specify what hash style to use by default.
7519 AC_ARG_WITH([linker-hash-style],
7520 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
7521 [specify the linker hash style])],
7522 [case x"$withval" in
7524 LINKER_HASH_STYLE=sysv
7527 LINKER_HASH_STYLE=gnu
7530 LINKER_HASH_STYLE=both
7533 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
7536 [LINKER_HASH_STYLE=''])
7537 if test x"${LINKER_HASH_STYLE}" != x; then
7538 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
7539 [The linker hash style])
7542 # Specify what should be the default of -fdiagnostics-color option.
7543 AC_ARG_WITH([diagnostics-color],
7544 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
7545 [specify the default of -fdiagnostics-color option
7546 auto-if-env stands for -fdiagnostics-color=auto if
7547 GCC_COLOR environment variable is present and
7548 -fdiagnostics-color=never otherwise])],
7549 [case x"$withval" in
7551 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
7554 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
7557 DIAGNOSTICS_COLOR_DEFAULT=-1
7560 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
7563 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
7566 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
7567 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
7568 [The default for -fdiagnostics-color option])
7570 # Specify what should be the default of -fdiagnostics-urls option.
7571 AC_ARG_WITH([diagnostics-urls],
7572 [AC_HELP_STRING([--with-diagnostics-urls={never,auto,auto-if-env,always}],
7573 [specify the default of -fdiagnostics-urls option
7574 auto-if-env stands for -fdiagnostics-urls=auto if
7575 GCC_URLS or TERM_URLS environment variable is present and
7576 -fdiagnostics-urls=never otherwise])],
7577 [case x"$withval" in
7579 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_NO
7582 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO
7585 DIAGNOSTICS_URLS_DEFAULT=-1
7588 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_YES
7591 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-urls])
7594 [DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO])
7595 AC_DEFINE_UNQUOTED(DIAGNOSTICS_URLS_DEFAULT, $DIAGNOSTICS_URLS_DEFAULT,
7596 [The default for -fdiagnostics-urls option])
7598 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
7599 # of jit/jit-playback.cc.
7600 gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"`
7601 echo "gcc_driver_version: ${gcc_driver_version}"
7602 cat > gcc-driver-name.h <<EOF
7603 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_driver_version}${exeext}"
7606 # Check whether --enable-default-pie was given.
7607 AC_ARG_ENABLE(default-pie,
7608 [AS_HELP_STRING([--enable-default-pie],
7609 [enable Position Independent Executable as default])],
7610 enable_default_pie=$enableval,
7611 enable_default_pie=no)
7612 if test x$enable_default_pie = xyes ; then
7613 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
7614 [Define if your target supports default PIE and it is enabled.])
7616 AC_SUBST([enable_default_pie])
7618 # Check if -fno-PIE works.
7619 AC_CACHE_CHECK([for -fno-PIE option],
7621 [saved_CXXFLAGS="$CXXFLAGS"
7622 CXXFLAGS="$CXXFLAGS -fno-PIE"
7623 AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7624 [gcc_cv_c_no_fpie=yes],
7625 [gcc_cv_c_no_fpie=no])
7626 CXXFLAGS="$saved_CXXFLAGS"])
7627 if test "$gcc_cv_c_no_fpie" = "yes"; then
7628 NO_PIE_CFLAGS="-fno-PIE"
7630 AC_SUBST([NO_PIE_CFLAGS])
7632 # Check if -no-pie works.
7633 AC_CACHE_CHECK([for -no-pie option],
7635 [saved_LDFLAGS="$LDFLAGS"
7636 LDFLAGS="$LDFLAGS -no-pie"
7637 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
7638 [gcc_cv_no_pie=yes],
7640 LDFLAGS="$saved_LDFLAGS"])
7641 if test "$gcc_cv_no_pie" = "yes"; then
7642 NO_PIE_FLAG="-no-pie"
7644 AC_SUBST([NO_PIE_FLAG])
7646 # Enable Intel CET on Intel CET enabled host if jit is enabled.
7647 GCC_CET_HOST_FLAGS(CET_HOST_FLAGS)
7648 case x$enable_languages in
7655 AC_SUBST(CET_HOST_FLAGS)
7657 # Check linker supports '-z bndplt'
7658 ld_bndplt_support=no
7659 AC_MSG_CHECKING(linker -z bndplt option)
7660 if test x"$ld_is_gold" = xno; then
7661 if test $in_tree_ld = yes ; then
7662 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
7663 ld_bndplt_support=yes
7665 elif test x$gcc_cv_ld != x; then
7666 # Check if linker supports -a bndplt option
7667 if $gcc_cv_ld --help 2>&1 | grep -- '-z bndplt' > /dev/null; then
7668 ld_bndplt_support=yes
7672 if test x"$ld_bndplt_support" = xyes; then
7673 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
7674 [Define if your linker supports -z bndplt])
7676 AC_MSG_RESULT($ld_bndplt_support)
7678 # Check linker supports '--push-state'/'--pop-state'
7679 ld_pushpopstate_support=no
7680 AC_MSG_CHECKING(linker --push-state/--pop-state options)
7681 if test x"$ld_is_gold" = xno; then
7682 if test $in_tree_ld = yes ; then
7683 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
7684 ld_pushpopstate_support=yes
7686 elif test x$gcc_cv_ld != x; then
7687 # Check if linker supports --push-state/--pop-state options
7688 if $gcc_cv_ld --help 2>&1 | grep -- '--push-state' > /dev/null; then
7689 ld_pushpopstate_support=yes
7693 if test x"$ld_pushpopstate_support" = xyes; then
7694 AC_DEFINE(HAVE_LD_PUSHPOPSTATE_SUPPORT, 1,
7695 [Define if your linker supports --push-state/--pop-state])
7697 AC_MSG_RESULT($ld_pushpopstate_support)
7699 # On s390, float_t has historically been statically defined as double for no
7700 # good reason. To comply with the C standard in the light of this definition,
7701 # gcc has evaluated float expressions in double precision when in
7702 # standards-compatible mode or when given -fexcess-precision=standard. To enable
7703 # a smooth transition towards the new model used by most architectures, where
7704 # gcc describes its behavior via the macro __FLT_EVAL_METHOD__ and glibc derives
7705 # float_t from that, this behavior can be configured with
7706 # --enable-s390-excess-float-precision. When given as enabled, that flag selects
7707 # the old model. When omitted, native builds and cross compiles that have target
7708 # libc headers will detect whether libc clamps float_t to double and in that
7709 # case maintain the old model. Otherwise, they will default to the new model.
7710 AC_ARG_ENABLE(s390-excess-float-precision,
7711 [AS_HELP_STRING([--enable-s390-excess-float-precision],
7712 [on s390 targets, evaluate float with double precision
7713 when in standards-conforming mode])],
7714 [],[enable_s390_excess_float_precision=auto])
7718 if test x"$enable_s390_excess_float_precision" = xauto; then
7719 # Can we autodetect the behavior of the target libc?
7720 if test "$target" = "$host" -a "$host" = "$build"; then
7721 enable_s390_excess_float_precision=autodetect
7722 elif test "x$with_headers" != xno; then
7723 # cross build. are target headers available?
7724 # carefully coerce the build-system compiler to use target headers
7725 saved_CXXFLAGS="$CXXFLAGS"
7726 fixed_XGCC_FLAGS_FOR_TARGET=`echo "$XGCC_FLAGS_FOR_TARGET" | sed 's/-B/-idirafter/g'`
7727 CROSS_TEST_CXXFLAGS="-nostdinc $fixed_XGCC_FLAGS_FOR_TARGET"
7728 CXXFLAGS="$CROSS_TEST_CXXFLAGS"
7729 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
7731 ]])], [enable_s390_excess_float_precision=autodetect], [])
7732 CXXFLAGS="$saved_CXXFLAGS"
7735 if test x"$enable_s390_excess_float_precision" = xautodetect; then
7736 saved_CXXFLAGS="$CXXFLAGS"
7737 if ! test "$target" = "$host" -a "$host" = "$build"; then
7738 CXXFLAGS="$CROSS_TEST_CXXFLAGS"
7739 unset CROSS_TEST_CXXFLAGS
7741 AC_CACHE_CHECK([for glibc clamping float_t to double],
7742 gcc_cv_float_t_clamped_to_double, [
7743 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
7744 #define __FLT_EVAL_METHOD__ 0
7746 int dummy[sizeof(float_t) == sizeof(double) ? 1 : -1];
7748 [gcc_cv_float_t_clamped_to_double=yes],
7749 [gcc_cv_float_t_clamped_to_double=no])])
7750 CXXFLAGS="$saved_CXXFLAGS"
7751 enable_s390_excess_float_precision="$gcc_cv_float_t_clamped_to_double"
7753 # no way to detect behavior of target libc, default to new model
7754 enable_s390_excess_float_precision=no
7758 GCC_TARGET_TEMPLATE(ENABLE_S390_EXCESS_FLOAT_PRECISION)
7759 if test x"$enable_s390_excess_float_precision" = xyes; then
7760 AC_DEFINE(ENABLE_S390_EXCESS_FLOAT_PRECISION, 1,
7761 [Define to enable evaluating float expressions with double precision in
7762 standards-compatible mode on s390 targets.])
7767 # Configure the subdirectories
7768 # AC_CONFIG_SUBDIRS($subdirs)
7770 # Create the Makefile
7771 # and configure language subdirectories
7772 AC_CONFIG_FILES($all_outputs)
7774 AC_CONFIG_COMMANDS([default],
7776 case ${CONFIG_HEADERS} in
7777 *auto-host.h:config.in*)
7780 # Make sure all the subdirs exist.
7781 for d in $subdirs doc build common c-family
7783 test -d $d || mkdir $d
7786 [subdirs='$subdirs'])