2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2020 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3. If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
27 AC_CONFIG_SRCDIR(tree.c)
28 AC_CONFIG_HEADER(auto-host.h:config.in)
30 gcc_version=`cat $srcdir/BASE-VER`
32 # Determine the host, build, and target systems
37 # Determine the noncanonical host name, for Ada.
40 # Determine the noncanonical target name, for directory use.
41 ACX_NONCANONICAL_TARGET
43 # Used for constructing correct paths for offload compilers.
44 real_target_noncanonical=${target_noncanonical}
47 # Determine the target- and build-specific subdirectories
50 # Set program_transform_name
53 # Check for bogus environment variables.
54 # Test if LIBRARY_PATH contains the notation for the current directory
55 # since this would lead to problems installing/building glibc.
56 # LIBRARY_PATH contains the current directory if one of the following
58 # - one of the terminals (":" and ";") is the first or last sign
59 # - two terminals occur directly after each other
60 # - the path contains an element with a dot in it
61 AC_MSG_CHECKING(LIBRARY_PATH variable)
63 case ${LIBRARY_PATH} in
64 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
65 library_path_setting="contains current directory"
68 library_path_setting="ok"
72 AC_MSG_RESULT($library_path_setting)
73 if test "$library_path_setting" != "ok"; then
75 *** LIBRARY_PATH shouldn't contain the current directory when
76 *** building gcc. Please change the environment variable
77 *** and run configure again.])
80 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
81 # since this would lead to problems installing/building glibc.
82 # GCC_EXEC_PREFIX contains the current directory if one of the following
84 # - one of the terminals (":" and ";") is the first or last sign
85 # - two terminals occur directly after each other
86 # - the path contains an element with a dot in it
87 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
89 case ${GCC_EXEC_PREFIX} in
90 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
91 gcc_exec_prefix_setting="contains current directory"
94 gcc_exec_prefix_setting="ok"
98 AC_MSG_RESULT($gcc_exec_prefix_setting)
99 if test "$gcc_exec_prefix_setting" != "ok"; then
101 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
102 *** building gcc. Please change the environment variable
103 *** and run configure again.])
110 # Specify the local prefix
112 AC_ARG_WITH(local-prefix,
113 [AS_HELP_STRING([--with-local-prefix=DIR],
114 [specifies directory to put local include])],
115 [case "${withval}" in
116 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
118 *) local_prefix=$with_local_prefix ;;
121 # Default local prefix if it is empty
122 if test x$local_prefix = x; then
123 local_prefix=/usr/local
126 AC_ARG_WITH([native-system-header-dir],
127 [ --with-native-system-header-dir=dir
128 use dir as the directory to look for standard
129 system header files in. Defaults to /usr/include.],
131 case ${with_native_system_header_dir} in
132 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
133 /* | [[A-Za-z]]:[[\\/]]*) ;;
134 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
136 configured_native_system_header_dir="${withval}"
137 ], [configured_native_system_header_dir=])
139 AC_ARG_WITH(build-sysroot,
140 [AS_HELP_STRING([--with-build-sysroot=sysroot],
141 [use sysroot as the system root during the build])],
142 [if test x"$withval" != x ; then
143 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
145 [SYSROOT_CFLAGS_FOR_TARGET=])
146 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
148 if test "x$prefix" = xNONE; then
149 test_prefix=/usr/local
153 if test "x$exec_prefix" = xNONE; then
154 test_exec_prefix=$test_prefix
156 test_exec_prefix=$exec_prefix
160 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
161 [search for usr/lib, usr/include, et al, within DIR])],
163 case ${with_sysroot} in
165 */) with_sysroot=`echo $with_sysroot | sed 's,/$,,'` ;;
167 case ${with_sysroot} in
168 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
169 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
172 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
173 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
175 case ${TARGET_SYSTEM_ROOT} in
176 "${test_prefix}"|"${test_prefix}/"*|\
177 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
178 '${prefix}'|'${prefix}/'*|\
179 '${exec_prefix}'|'${exec_prefix}/'*)
180 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
181 TARGET_SYSTEM_ROOT_DEFINE="$t"
186 TARGET_SYSTEM_ROOT_DEFINE=
187 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
189 AC_SUBST(TARGET_SYSTEM_ROOT)
190 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
191 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
193 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
194 # passed in by the toplevel make and thus we'd get different behavior
195 # depending on where we built the sources.
197 # Specify the g++ header file directory
198 AC_ARG_WITH(gxx-include-dir,
199 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
200 [specifies directory to put g++ header files])],
201 [case "${withval}" in
202 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
204 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
207 # If both --with-sysroot and --with-gxx-include-dir are passed, we interpolate
208 # the former in the latter and, upon success, compute gcc_gxx_include_dir as
209 # relative to the sysroot.
210 gcc_gxx_include_dir_add_sysroot=0
212 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
213 if test x${gcc_gxx_include_dir} = x; then
214 if test x${enable_version_specific_runtime_libs} = xyes; then
215 gcc_gxx_include_dir='${libsubdir}/include/c++'
217 libstdcxx_incdir='include/c++/$(version)'
218 if test x$host != x$target; then
219 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
221 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
223 elif test "${with_sysroot+set}" = set; then
224 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
225 if test "${gcc_gxx_without_sysroot}"; then
226 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
227 gcc_gxx_include_dir_add_sysroot=1
231 AC_ARG_WITH(cpp_install_dir,
232 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
233 [install the user visible C preprocessor in DIR
234 (relative to PREFIX) as well as PREFIX/bin])],
235 [if test x$withval = xyes; then
236 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
237 elif test x$withval != xno; then
238 cpp_install_dir=$withval
241 # We would like to our source tree to be readonly. However when releases or
242 # pre-releases are generated, the flex/bison generated files as well as the
243 # various formats of manuals need to be included along with the rest of the
244 # sources. Therefore we have --enable-generated-files-in-srcdir to do
247 AC_MSG_CHECKING([whether to place generated files in the source directory])
248 dnl generated-files-in-srcdir is disabled by default
249 AC_ARG_ENABLE(generated-files-in-srcdir,
250 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
251 [put copies of generated files in source dir
252 intended for creating source tarballs for users
253 without texinfo bison or flex])],
254 generated_files_in_srcdir=$enableval,
255 generated_files_in_srcdir=no)
257 AC_MSG_RESULT($generated_files_in_srcdir)
259 if test "$generated_files_in_srcdir" = "yes"; then
266 # -------------------
267 # Find default linker
268 # -------------------
272 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
273 gnu_ld_flag="$with_gnu_ld",
277 *darwin*) ld64_flag=yes;; # Darwin can only use a ld64-compatible linker.
281 # With pre-defined ld
283 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
284 DEFAULT_LINKER="$with_ld")
285 if test x"${DEFAULT_LINKER+set}" = x"set"; then
286 if test ! -x "$DEFAULT_LINKER"; then
287 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
288 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
290 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep ld64- > /dev/null; then
293 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
294 [Define to enable the use of a default linker.])
297 AC_MSG_CHECKING([whether a default linker was specified])
298 if test x"${DEFAULT_LINKER+set}" = x"set"; then
299 if test x"$gnu_ld_flag" = x"no"; then
300 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
302 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
308 # With demangler in GNU ld
309 AC_ARG_WITH(demangler-in-ld,
310 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
311 demangler_in_ld="$with_demangler_in_ld",
314 # ----------------------
315 # Find default assembler
316 # ----------------------
320 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
321 gas_flag="$with_gnu_as",
325 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
326 DEFAULT_ASSEMBLER="$with_as")
327 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
328 if test ! -x "$DEFAULT_ASSEMBLER"; then
329 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
330 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
333 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
334 [Define to enable the use of a default assembler.])
337 AC_MSG_CHECKING([whether a default assembler was specified])
338 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
339 if test x"$gas_flag" = x"no"; then
340 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
342 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
352 # If a non-executable a.out is present (e.g. created by GNU as above even if
353 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
354 # file, even when creating an executable, so an execution test fails.
355 # Remove possible default executable files to avoid this.
357 # FIXME: This really belongs into AC_PROG_CC and can be removed once
358 # Autoconf includes it.
359 rm -f a.out a.exe b.out
361 # Find the native compiler
364 ACX_PROG_GNAT([-I"$srcdir"/ada/libgnat])
366 # Do configure tests with the C++ compiler, since that's what we build with.
369 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
370 # optimizations to be activated explicitly by the toplevel.
373 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
374 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
379 # Determine PICFLAG for target gnatlib.
380 GCC_PICFLAG_FOR_TARGET
381 AC_SUBST(PICFLAG_FOR_TARGET)
383 # -------------------------
384 # Check C compiler features
385 # -------------------------
387 AC_USE_SYSTEM_EXTENSIONS
389 AX_CXX_COMPILE_STDCXX(11)
396 # sizeof(char) is 1 by definition.
397 AC_CHECK_SIZEOF(void *)
398 AC_CHECK_SIZEOF(short)
400 AC_CHECK_SIZEOF(long)
401 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
403 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
404 AC_MSG_ERROR([uint64_t or int64_t not found])
407 # check what underlying integer type int64_t uses
408 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
409 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
413 template <typename T> struct X { };
415 struct X<long> { typedef long t; };
416 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
417 if test "$ac_cv_int64_t_type" = "long"; then
418 AC_DEFINE(INT64_T_IS_LONG, 1,
419 [Define if int64_t uses long as underlying type.])
421 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
425 template <typename T> struct X { };
427 struct X<long long> { typedef long long t; };
428 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
431 AC_CACHE_CHECK(for std::swap in <utility>, ac_cv_std_swap_in_utility, [
432 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
434 ]], [[int a, b; std::swap(a,b);]])],[ac_cv_std_swap_in_utility=yes],[ac_cv_std_swap_in_utility=no])])
435 if test $ac_cv_std_swap_in_utility = yes; then
436 AC_DEFINE(HAVE_SWAP_IN_UTILITY, 1,
437 [Define if <utility> defines std::swap.])
440 # Check whether compiler is affected by placement new aliasing bug (PR 29286).
441 # If the host compiler is affected by the bug, and we build with optimization
442 # enabled (which happens e.g. when cross-compiling), the pool allocator may
443 # get miscompiled. Use -fno-strict-aliasing to work around this problem.
444 # Since there is no reliable feature check for the presence of this bug,
445 # we simply use a GCC version number check. (This should never trigger for
446 # stages 2 or 3 of a native bootstrap.)
448 if test "$GCC" = yes; then
449 saved_CXXFLAGS="$CXXFLAGS"
451 # The following test compilation will succeed if and only if $CXX accepts
452 # -fno-strict-aliasing *and* is older than GCC 4.3.
453 CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
454 AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug])
455 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
456 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
457 #error compiler not affected by placement new aliasing bug
460 [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'],
461 [AC_MSG_RESULT([no])])
463 CXXFLAGS="$saved_CXXFLAGS"
465 AC_SUBST(aliasing_flags)
469 # ---------------------
470 # Warnings and checking
471 # ---------------------
473 # Check $CC warning features (if it's GCC).
474 # We want to use -pedantic, but we don't want warnings about
478 # * C++11 narrowing conversions in { }
479 # So, we only use -pedantic if we can disable those warnings.
481 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
482 AC_ARG_ENABLE(build-format-warnings,
483 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
484 [],[enable_build_format_warnings=yes])
485 AS_IF([test $enable_build_format_warnings = no],
486 [wf_opt=-Wno-format],[wf_opt=])
487 ACX_PROG_CXX_WARNING_OPTS(
488 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings ],
489 [-Wcast-qual -Wno-error=format-diag $wf_opt])),
491 ACX_PROG_CC_WARNING_OPTS(
492 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes ],
493 [-Wno-error=format-diag])), [c_loose_warn])
494 ACX_PROG_CXX_WARNING_OPTS(
495 m4_quote(m4_do([-Wmissing-format-attribute ],
496 [-Woverloaded-virtual])), [strict_warn])
497 ACX_PROG_CC_WARNING_OPTS(
498 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
499 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
500 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
501 [-Wno-overlength-strings])), [strict_warn])
502 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
504 # The above macros do nothing if the compiler is not GCC. However, the
505 # Makefile has more goo to add other flags, so these variables are used
506 # to enable warnings only for GCC.
509 if test "x$GCC" = "xyes"; then
510 warn_cflags='$(GCC_WARN_CFLAGS)'
511 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
513 AC_SUBST(warn_cflags)
514 AC_SUBST(warn_cxxflags)
516 # Disable exceptions and RTTI if building with g++
517 ACX_PROG_CC_WARNING_OPTS(
518 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
521 # Enable expensive internal checks
523 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
527 AC_ARG_ENABLE(checking,
528 [AS_HELP_STRING([[--enable-checking[=LIST]]],
529 [enable expensive run-time checks. With LIST,
530 enable only specific categories of checks.
531 Categories are: yes,no,all,none,release.
532 Flags are: assert,df,extra,fold,gc,gcac,gimple,misc,
533 rtlflag,rtl,runtime,tree,valgrind,types])],
534 [ac_checking_flags="${enableval}"],[
535 # Determine the default checks.
536 if test x$is_release = x ; then
537 ac_checking_flags=yes,extra
539 ac_checking_flags=release
541 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
542 for check in release $ac_checking_flags
545 # these set all the flags to specific states
546 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
547 ac_fold_checking= ; ac_gc_checking=1 ; ac_extra_checking= ;
548 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
549 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
550 ac_tree_checking=1 ; ac_valgrind_checking= ;
551 ac_types_checking=1 ;;
552 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
553 ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
554 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
555 ac_rtlflag_checking= ; ac_runtime_checking= ;
556 ac_tree_checking= ; ac_valgrind_checking= ;
557 ac_types_checking= ;;
558 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
559 ac_fold_checking=1 ; ac_gc_checking=1 ; ac_extra_checking=1 ;
560 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
561 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
562 ac_tree_checking=1 ; ac_valgrind_checking= ;
563 ac_types_checking=1 ;;
564 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
565 ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ;
566 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
567 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
568 ac_tree_checking= ; ac_valgrind_checking= ;
569 ac_types_checking= ;;
570 # these enable particular checks
571 assert) ac_assert_checking=1 ;;
572 df) ac_df_checking=1 ;;
573 extra) ac_extra_checking=1 ;;
574 fold) ac_fold_checking=1 ;;
575 gc) ac_gc_checking=1 ;;
576 gcac) ac_gc_always_collect=1 ;;
577 gimple) ac_gimple_checking=1 ;;
578 misc) ac_checking=1 ;;
579 rtl) ac_rtl_checking=1 ;;
580 rtlflag) ac_rtlflag_checking=1 ;;
581 runtime) ac_runtime_checking=1 ;;
582 tree) ac_tree_checking=1 ;;
583 types) ac_types_checking=1 ;;
584 valgrind) ac_valgrind_checking=1 ;;
585 *) AC_MSG_ERROR(unknown check category $check) ;;
591 if test x$ac_checking != x ; then
592 AC_DEFINE(CHECKING_P, 1,
593 [Define to 0/1 if you want more run-time sanity checks. This one gets a grab
594 bag of miscellaneous but relatively cheap checks.])
595 nocommon_flag=-fno-common
597 AC_DEFINE(CHECKING_P, 0)
599 AC_SUBST(nocommon_flag)
600 if test x$ac_extra_checking != x ; then
601 AC_DEFINE(ENABLE_EXTRA_CHECKING, 1,
602 [Define to 0/1 if you want extra run-time checking that might affect code
605 AC_DEFINE(ENABLE_EXTRA_CHECKING, 0)
607 if test x$ac_df_checking != x ; then
608 AC_DEFINE(ENABLE_DF_CHECKING, 1,
609 [Define if you want more run-time sanity checks for dataflow.])
611 if test x$ac_assert_checking != x ; then
612 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
613 [Define if you want assertions enabled. This is a cheap check.])
615 if test x$ac_gimple_checking != x ; then
616 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
617 [Define if you want operations on GIMPLE (the basic data structure of
618 the high-level optimizers) to be checked for dynamic type safety at
619 runtime. This is moderately expensive.])
621 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
622 if test x$ac_runtime_checking != x ; then
623 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
624 [Define if you want runtime assertions enabled. This is a cheap check.])
626 if test x$ac_tree_checking != x ; then
627 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
628 [Define if you want all operations on trees (the basic data
629 structure of the front ends) to be checked for dynamic type safety
630 at runtime. This is moderately expensive.
634 if test x$ac_types_checking != x ; then
635 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
636 [Define if you want all gimple types to be verified after gimplifiation.
640 AC_SUBST(TREECHECKING)
641 if test x$ac_rtl_checking != x ; then
642 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
643 [Define if you want all operations on RTL (the basic data structure
644 of the optimizer and back end) to be checked for dynamic type safety
645 at runtime. This is quite expensive.])
647 if test x$ac_rtlflag_checking != x ; then
648 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
649 [Define if you want RTL flag accesses to be checked against the RTL
650 codes that are supported for each access macro. This is relatively
653 if test x$ac_gc_checking != x ; then
654 AC_DEFINE(ENABLE_GC_CHECKING, 1,
655 [Define if you want the garbage collector to do object poisoning and
656 other memory allocation checks. This is quite expensive.])
658 if test x$ac_gc_always_collect != x ; then
659 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
660 [Define if you want the garbage collector to operate in maximally
661 paranoid mode, validating the entire heap and collecting garbage at
662 every opportunity. This is extremely expensive.])
664 if test x$ac_fold_checking != x ; then
665 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
666 [Define if you want fold checked that it never destructs its argument.
667 This is quite expensive.])
669 valgrind_path_defines=
672 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
673 dnl # an if statement. This was the source of very frustrating bugs
674 dnl # in converting to autoconf 2.5x!
675 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
677 # It is certainly possible that there's valgrind but no valgrind.h.
678 # GCC relies on making annotations so we must have both.
679 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
680 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
681 [[#include <valgrind/memcheck.h>
682 #ifndef VALGRIND_DISCARD
683 #error VALGRIND_DISCARD not defined
685 [gcc_cv_header_valgrind_memcheck_h=yes],
686 [gcc_cv_header_valgrind_memcheck_h=no])
687 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
688 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
689 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
690 [[#include <memcheck.h>
691 #ifndef VALGRIND_DISCARD
692 #error VALGRIND_DISCARD not defined
694 [gcc_cv_header_memcheck_h=yes],
695 [gcc_cv_header_memcheck_h=no])
696 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
697 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
698 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
699 [Define if valgrind's valgrind/memcheck.h header is installed.])
701 if test $gcc_cv_header_memcheck_h = yes; then
702 AC_DEFINE(HAVE_MEMCHECK_H, 1,
703 [Define if valgrind's memcheck.h header is installed.])
706 if test x$ac_valgrind_checking != x ; then
707 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
708 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
709 if test "x$valgrind_path" = "x" \
710 || (test $have_valgrind_h = no \
711 && test $gcc_cv_header_memcheck_h = no \
712 && test $gcc_cv_header_valgrind_memcheck_h = no); then
713 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
715 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
716 valgrind_command="$valgrind_path -q"
717 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
718 [Define if you want to run subprograms and generated programs
719 through valgrind (a memory checker). This is extremely expensive.])
721 AC_SUBST(valgrind_path_defines)
722 AC_SUBST(valgrind_command)
724 # Enable code coverage collection
725 AC_ARG_ENABLE(coverage,
726 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
727 [enable compiler's code coverage collection.
728 Use to measure compiler performance and locate
729 unused parts of the compiler. With LEVEL, specify
730 optimization. Values are opt, noopt,
732 [case "${enableval}" in
734 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0 -fkeep-static-functions"
737 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2 -fkeep-static-functions"
740 # a.k.a. --disable-coverage
744 AC_MSG_ERROR(unknown coverage setting $enableval)
748 AC_SUBST(coverage_flags)
750 AC_ARG_ENABLE(gather-detailed-mem-stats,
751 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
752 [enable detailed memory allocation stats gathering])], [],
753 [enable_gather_detailed_mem_stats=no])
754 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
755 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
756 [Define to enable detailed memory allocation stats gathering.])
758 AC_ARG_ENABLE(valgrind-annotations,
759 [AS_HELP_STRING([--enable-valgrind-annotations],
760 [enable valgrind runtime interaction])], [],
761 [enable_valgrind_annotations=no])
762 if test x$enable_valgrind_annotations != xno \
763 || test x$ac_valgrind_checking != x; then
764 if (test $have_valgrind_h = no \
765 && test $gcc_cv_header_memcheck_h = no \
766 && test $gcc_cv_header_valgrind_memcheck_h = no); then
767 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
769 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
770 [Define to get calls to the valgrind runtime enabled.])
773 # -------------------------------
774 # Miscenalleous configure options
775 # -------------------------------
779 [AS_HELP_STRING([--with-stabs],
780 [arrange to use stabs instead of host debug format])],
784 # Determine whether or not multilibs are enabled.
785 AC_ARG_ENABLE(multilib,
786 [AS_HELP_STRING([--enable-multilib],
787 [enable library support for multiple ABIs])],
788 [], [enable_multilib=yes])
789 AC_SUBST(enable_multilib)
791 # Determine whether or not multiarch is enabled.
792 AC_ARG_ENABLE(multiarch,
793 [AS_HELP_STRING([--enable-multiarch],
794 [enable support for multiarch paths])],
795 [case "${enableval}" in
796 yes|no|auto) enable_multiarch=$enableval;;
797 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
798 esac], [enable_multiarch=auto])
799 if test x${enable_multiarch} = xauto; then
800 if test x${with_native_system_header_dir} != x; then
801 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
804 if test x$host != x$target && test "x$with_sysroot" = x; then
805 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
809 AC_MSG_CHECKING(for multiarch configuration)
810 AC_SUBST(enable_multiarch)
811 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
813 # needed for setting the multiarch name for soft-float/hard-float ABIs
817 # default stack clash protection guard size as power of twos in bytes.
818 # Please keep these in sync with params.def.
822 # Keep the default value when the option is not used to 0, this allows us to
823 # distinguish between the cases where the user specifially set a value via
824 # configure and when the normal default value is used.
825 AC_ARG_WITH(stack-clash-protection-guard-size,
826 [AS_HELP_STRING([--with-stack-clash-protection-guard-size=size],
827 [Set the default stack clash protection guard size for specific targets as a power of two in bytes.])],
828 [DEFAULT_STK_CLASH_GUARD_SIZE="$with_stack_clash_protection_guard_size"], [DEFAULT_STK_CLASH_GUARD_SIZE=0])
829 if test $DEFAULT_STK_CLASH_GUARD_SIZE -ne 0 \
830 && (test $DEFAULT_STK_CLASH_GUARD_SIZE -lt $stk_clash_min \
831 || test $DEFAULT_STK_CLASH_GUARD_SIZE -gt $stk_clash_max); then
832 AC_MSG_ERROR(m4_normalize([
833 Invalid value $DEFAULT_STK_CLASH_GUARD_SIZE for --with-stack-clash-protection-guard-size. \
834 Must be between $stk_clash_min and $stk_clash_max.]))
837 AC_DEFINE_UNQUOTED(DEFAULT_STK_CLASH_GUARD_SIZE, $DEFAULT_STK_CLASH_GUARD_SIZE,
838 [Define to larger than zero set the default stack clash protector size.])
840 # Enable __cxa_atexit for C++.
841 AC_ARG_ENABLE(__cxa_atexit,
842 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
845 # Enable C extension for decimal float if target supports it.
846 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
848 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
849 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
850 [Define to 1 to enable decimal float extension to C.])
852 # Use default_decimal_float for dependency.
853 enable_decimal_float=$default_decimal_float
855 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
856 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
857 [Define to 1 to specify that we are using the BID decimal floating
858 point format instead of DPD])
860 # Enable C extension for fixed-point arithmetic.
861 AC_ARG_ENABLE(fixed-point,
862 [AS_HELP_STRING([--enable-fixed-point],
863 [enable fixed-point arithmetic extension to C])],
868 enable_fixed_point=yes
872 enable_fixed_point=yes
875 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
876 enable_fixed_point=no
880 AC_SUBST(enable_fixed_point)
882 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
883 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
884 [Define to 1 to enable fixed-point arithmetic extension to C.])
887 # Pass with no value to take the default
888 # Pass with a value to specify a thread package
889 AC_ARG_ENABLE(threads,
890 [AS_HELP_STRING([[--enable-threads[=LIB]]],
891 [enable thread usage for target GCC,
892 using LIB thread package])],,
896 [AS_HELP_STRING([--enable-tls],
897 [enable or disable generation of tls code
898 overriding the assembler check for tls support])],
902 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
903 Valid choices are 'yes' and 'no'.]) ;;
907 AC_ARG_ENABLE(vtable-verify,
908 [AS_HELP_STRING([--enable-vtable-verify],
909 [enable vtable verification feature])],,
910 [enable_vtable_verify=no])
911 vtable_verify=`if test x$enable_vtable_verify = xyes; then echo 1; else echo 0; fi`
912 AC_DEFINE_UNQUOTED(ENABLE_VTABLE_VERIFY, $vtable_verify,
913 [Define 0/1 if vtable verification feature is enabled.])
915 AC_ARG_ENABLE(analyzer,
916 [AS_HELP_STRING([--disable-analyzer],
917 [disable -fanalyzer static analyzer])],
918 if test x$enable_analyzer = xno; then
924 AC_DEFINE_UNQUOTED(ENABLE_ANALYZER, $analyzer,
925 [Define 0/1 if static analyzer feature is enabled.])
927 AC_ARG_ENABLE(objc-gc,
928 [AS_HELP_STRING([--enable-objc-gc],
929 [enable the use of Boehm's garbage collector with
930 the GNU Objective-C runtime])],
931 if test x$enable_objc_gc = xno; then
939 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
940 dwarf2="$with_dwarf2",
943 AC_ARG_ENABLE(shared,
944 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
946 case $enable_shared in
950 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
951 for pkg in $enableval; do
952 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
959 ], [enable_shared=yes])
960 AC_SUBST(enable_shared)
963 [ --disable-gcov don't provide libgcov and related host tools],
964 [], [enable_gcov=yes])
965 AC_SUBST(enable_gcov)
968 [AS_HELP_STRING([--with-specs=SPECS],
969 [add SPECS to driver command-line processing])],
970 [CONFIGURE_SPECS=$withval],
973 AC_SUBST(CONFIGURE_SPECS)
975 ACX_PKGVERSION([GCC])
976 ACX_BUGURL([https://gcc.gnu.org/bugs/])
978 # Allow overriding the default URL for documentation
979 AC_ARG_WITH(documentation-root-url,
980 AS_HELP_STRING([--with-documentation-root-url=URL],
981 [Root for documentation URLs]),
983 yes) AC_MSG_ERROR([documentation root URL not specified]) ;;
984 no) AC_MSG_ERROR([documentation root URL not specified]) ;;
985 */) DOCUMENTATION_ROOT_URL="$withval" ;;
986 *) AC_MSG_ERROR([documentation root URL does not end with /]) ;;
988 DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/"
990 AC_DEFINE_UNQUOTED(DOCUMENTATION_ROOT_URL,"$DOCUMENTATION_ROOT_URL",
991 [Define to the root for documentation URLs.])
993 # Allow overriding the default URL for GCC changes
994 AC_ARG_WITH(changes-root-url,
995 AS_HELP_STRING([--with-changes-root-url=URL],
996 [Root for GCC changes URLs]),
998 yes) AC_MSG_ERROR([changes root URL not specified]) ;;
999 no) AC_MSG_ERROR([changes root URL not specified]) ;;
1000 */) CHANGES_ROOT_URL="$withval" ;;
1001 *) AC_MSG_ERROR([changes root URL does not end with /]) ;;
1003 CHANGES_ROOT_URL="https://gcc.gnu.org/"
1005 AC_DEFINE_UNQUOTED(CHANGES_ROOT_URL,"$CHANGES_ROOT_URL",
1006 [Define to the root for URLs about GCC changes.])
1008 # Sanity check enable_languages in case someone does not run the toplevel
1009 # configure # script.
1010 AC_ARG_ENABLE(languages,
1011 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
1012 [case ,${enable_languages}, in
1014 # go safe -- we cannot be much sure without the toplevel
1016 # analysis of which target libs are present and usable
1020 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
1025 enable_languages=c,${enable_languages}
1028 [enable_languages=c])
1030 # If top-level libada has been disabled, then wire in install-gnatlib
1031 # invocation with `make install', so that one can build and install
1032 # the library manually with `make -C gcc all gnatlib gnattools install'.
1033 if test x"$enable_libada" = xno; then
1034 gnat_install_lib=gnat-install-lib
1038 AC_SUBST(gnat_install_lib)
1040 if test x"$enable_as_accelerator_for" != x; then
1041 AC_DEFINE(ACCEL_COMPILER, 1,
1042 [Define if this compiler should be built as the offload target compiler.])
1043 enable_as_accelerator=yes
1046 # In this case we expect offload compiler to be built as native, so we
1047 # need to rename the driver to avoid clashes with host's drivers.
1048 program_transform_name="s&^&${target}-&" ;;
1050 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
1051 program_transform_name=`echo $program_transform_name | sed $sedscript`
1052 accel_dir_suffix=/accel/${target_noncanonical}
1053 real_target_noncanonical=${enable_as_accelerator_for}
1055 AC_SUBST(enable_as_accelerator)
1056 AC_SUBST(real_target_noncanonical)
1057 AC_SUBST(accel_dir_suffix)
1059 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
1060 tgt=`echo $tgt | sed 's/=.*//'`
1062 if echo "$tgt" | grep "^hsa" > /dev/null ; then
1067 *-intelmic-* | *-intelmicemul-*)
1068 omp_device_property=omp-device-properties-i386
1069 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/i386/t-omp-device"
1072 omp_device_property=omp-device-properties-gcn
1073 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/gcn/t-omp-device"
1076 omp_device_property=omp-device-properties-nvptx
1077 omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/nvptx/t-omp-device"
1080 AC_MSG_ERROR([unknown offload target specified])
1083 omp_device_properties="${omp_device_properties} ${tgt}=${omp_device_property}"
1084 omp_device_property_deps="${omp_device_property_deps} ${omp_device_property}"
1087 if test x"$offload_targets" = x; then
1088 offload_targets=$tgt
1090 offload_targets="$offload_targets,$tgt"
1093 AC_SUBST(omp_device_properties)
1094 AC_SUBST(omp_device_property_deps)
1096 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
1097 [Define to offload targets, separated by commas.])
1098 if test x"$enable_offloading" != x; then
1099 AC_DEFINE(ENABLE_OFFLOADING, 1,
1100 [Define this to enable support for offloading.])
1102 AC_DEFINE(ENABLE_OFFLOADING, 0,
1103 [Define this to enable support for offloading.])
1106 if test x"$enable_hsa" = x1 ; then
1107 AC_DEFINE(ENABLE_HSA, 1,
1108 [Define this to enable support for generating HSAIL.])
1111 AC_ARG_WITH(multilib-list,
1112 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
1114 with_multilib_list=default)
1116 # -------------------------
1117 # Checks for other programs
1118 # -------------------------
1122 # Find some useful tools
1124 # We need awk to create options.c and options.h.
1125 # Bail out if it's missing.
1127 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
1134 AC_SUBST(ranlib_flags)
1138 # See if cmp has --ignore-initial.
1139 gcc_AC_PROG_CMP_IGNORE_INITIAL
1141 # See if we have the mktemp command.
1142 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
1144 # See if makeinfo has been installed and is modern enough
1145 # that we can use it.
1146 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
1147 [GNU texinfo.* \([0-9][0-9.]*\)],
1148 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
1149 if test $gcc_cv_prog_makeinfo_modern = no; then
1151 *** Makeinfo is missing or too old.
1152 *** Info documentation will not be built.])
1157 AC_SUBST(BUILD_INFO)
1159 # Is pod2man recent enough to regenerate manpages?
1160 AC_MSG_CHECKING([for recent Pod::Man])
1161 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1163 GENERATED_MANPAGES=generated-manpages
1168 AC_SUBST(GENERATED_MANPAGES)
1170 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1173 dnl Don't use AC_PROG_LEX; we insist on flex.
1174 dnl LEXLIB is not useful in gcc.
1175 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1178 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1180 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
1181 # check for build == host before using them.
1184 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1185 && test -d ../binutils ; then
1186 NM='${objdir}/../binutils/nm-new'
1188 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1192 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1193 && test -d ../binutils ; then
1194 AR='${objdir}/../binutils/ar'
1196 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1199 # The jit documentation looks better if built with sphinx, but can be
1200 # built with texinfo if sphinx is not available.
1201 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1202 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1204 # --------------------
1205 # Checks for C headers
1206 # --------------------
1208 # Need to reject headers which give warnings, so that the -Werror bootstrap
1209 # works later. *sigh* This needs to come before all header checks.
1216 AC_HEADER_TIOCGWINSZ
1217 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1218 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1219 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1220 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1222 # Check for thread headers.
1223 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1224 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1226 # These tests can't be done till we know if we have limits.h.
1230 # ----------------------
1231 # Checks for C++ headers
1232 # ----------------------
1234 dnl Autoconf will give an error in the configure script if there is no
1235 dnl C++ preprocessor. Hack to prevent that.
1236 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1238 m4_popdef([AC_MSG_ERROR])[]dnl
1240 AC_CHECK_HEADERS(unordered_map)
1241 AC_CHECK_HEADERS(tr1/unordered_map)
1242 AC_CHECK_HEADERS(ext/hash_map)
1245 # Dependency checking.
1249 AC_CONFIG_COMMANDS([gccdepdir],[
1250 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1251 for lang in $subdirs c-family common analyzer
1253 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1254 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1256 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1263 # These libraries may be used by collect2.
1264 # We may need a special search path to get them linked.
1265 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1267 for libs in '' -lld -lmld \
1268 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1269 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1272 AC_TRY_LINK_FUNC(ldopen,
1273 [gcc_cv_collect2_libs="$libs"; break])
1276 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1277 case $gcc_cv_collect2_libs in
1279 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1281 AC_SUBST(COLLECT2_LIBS)
1283 # When building Ada code on Alpha, we need exc_resume which is usually in
1284 # -lexc. So test for it.
1287 AC_SEARCH_LIBS(exc_resume, exc)
1290 AC_SUBST(GNAT_LIBEXC)
1292 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1295 AC_SEARCH_LIBS(kstat_open, kstat)
1296 EXTRA_GCC_LIBS="$LIBS"
1298 AC_SUBST(EXTRA_GCC_LIBS)
1300 # Some systems put ldexp and frexp in libm instead of libc; assume
1301 # they're both in the same place. jcf-dump needs them.
1304 AC_SEARCH_LIBS(ldexp, m)
1309 # Some systems need dlopen
1312 AC_SEARCH_LIBS(dlopen, dl)
1317 # Use <inttypes.h> only if it exists,
1318 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1320 AC_MSG_CHECKING(for inttypes.h)
1321 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1322 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1323 [[#define __STDC_FORMAT_MACROS
1324 #include <sys/types.h>
1325 #include <inttypes.h>]],
1330 [gcc_cv_header_inttypes_h=yes],
1331 [gcc_cv_header_inttypes_h=no])])
1332 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1333 if test $gcc_cv_header_inttypes_h = yes; then
1334 AC_DEFINE(HAVE_INTTYPES_H, 1,
1335 [Define if you have a working <inttypes.h> header file.])
1338 # Look for the ZSTD package.
1341 AC_SUBST(ZSTD_INCLUDE)
1346 [AS_HELP_STRING([--with-zstd=PATH],
1347 [specify prefix directory for installed zstd library.
1348 Equivalent to --with-zstd-include=PATH/include
1349 plus --with-zstd-lib=PATH/lib])])
1350 AC_ARG_WITH(zstd-include,
1351 [AS_HELP_STRING([--with-zstd-include=PATH],
1352 [specify directory for installed zstd include files])])
1353 AC_ARG_WITH(zstd-lib,
1354 [AS_HELP_STRING([--with-zstd-lib=PATH],
1355 [specify directory for the installed zstd library])])
1356 case "x$with_zstd" in
1362 *) ZSTD_INCLUDE=$with_zstd/include
1363 ZSTD_LIB=$with_zstd/lib
1367 if test "x$with_zstd" != xno; then
1368 if test "x$with_zstd_include" != x; then
1369 ZSTD_INCLUDE=$with_zstd_include
1371 if test "x$with_zstd_lib" != x; then
1372 ZSTD_LIB=$with_zstd_lib
1374 if test "x$ZSTD_INCLUDE" != x \
1375 && test "x$ZSTD_INCLUDE" != xno; then
1376 ZSTD_CPPFLAGS=-I$ZSTD_INCLUDE
1378 if test "x$ZSTD_LIB" != x \
1379 && test "x$ZSTD_LIB" != xno; then
1380 ZSTD_LDFLAGS=-L$ZSTD_LIB
1383 CXXFLAGS="$CXXFLAGS $ZSTD_CPPFLAGS"
1384 LDFLAGS="$LDFLAGS $ZSTD_LDFLAGS"
1386 AC_MSG_CHECKING(for zstd.h)
1387 AC_CACHE_VAL(gcc_cv_header_zstd_h,
1388 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1389 [[#include <zstd.h>]])],
1390 [gcc_cv_header_zstd_h=yes],
1391 [gcc_cv_header_zstd_h=no])])
1392 AC_MSG_RESULT($gcc_cv_header_zstd_h)
1393 if test $gcc_cv_header_zstd_h = yes; then
1394 AC_DEFINE(HAVE_ZSTD_H, 1,
1395 [Define if you have a working <zstd.h> header file.])
1396 elif test "x$with_zstd" != x; then
1397 as_fn_error $? "Unable to find zstd.h. See config.log for details." "$LINENO" 5
1400 # LTO can use zstd compression algorithm
1403 AC_SEARCH_LIBS(ZSTD_compress, zstd)
1409 dnl Disabled until we have a complete test for buggy enum bitfields.
1410 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1412 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1413 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1414 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1415 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1416 putchar_unlocked putc_unlocked)
1417 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1418 popen sysconf strsignal getrusage nl_langinfo \
1419 gettimeofday mbstowcs wcswidth mmap setlocale \
1420 gcc_UNLOCKED_FUNCS madvise mallinfo)
1422 if test x$ac_cv_func_mbstowcs = xyes; then
1423 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1424 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1430 [gcc_cv_func_mbstowcs_works=yes],
1431 [gcc_cv_func_mbstowcs_works=no],
1432 [gcc_cv_func_mbstowcs_works=yes])])
1433 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1434 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1435 [Define this macro if mbstowcs does not crash when its
1436 first argument is NULL.])
1440 AC_CHECK_TYPE(ssize_t, int)
1441 AC_CHECK_TYPE(caddr_t, char *)
1443 GCC_AC_FUNC_MMAP_BLACKLIST
1447 # Under VMS, vfork works very differently than on Unix. The standard test
1448 # won't work, and it isn't easily adaptable. It makes more sense to
1450 ac_cv_func_vfork_works=yes
1457 # Until we have in-tree GNU iconv:
1459 if test -f "$LTLIBICONV"; then
1460 LIBICONV_DEP=$LTLIBICONV
1462 AC_SUBST(LIBICONV_DEP)
1468 # We will need to find libiberty.h and ansidecl.h
1469 saved_CFLAGS="$CFLAGS"
1470 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1471 saved_CXXFLAGS="$CXXFLAGS"
1472 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1474 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1475 # normal autoconf function for these. But force definition of
1476 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1477 # basename handling in libiberty.h.
1478 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1479 #undef HAVE_DECL_BASENAME
1480 #define HAVE_DECL_BASENAME 1
1481 #include "ansidecl.h"
1482 #include "system.h"])
1484 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1485 madvise stpcpy strnlen strsignal strverscmp \
1486 strtol strtoul strtoll strtoull setenv unsetenv \
1487 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1488 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1489 #include "ansidecl.h"
1490 #include "system.h"])
1492 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1493 #include "ansidecl.h"
1495 #ifdef HAVE_SYS_RESOURCE_H
1496 #include <sys/resource.h>
1500 gcc_AC_CHECK_DECLS(mallinfo, , ,[
1501 #include "ansidecl.h"
1503 #ifdef HAVE_MALLOC_H
1508 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1509 #include "ansidecl.h"
1511 #ifdef HAVE_SYS_RESOURCE_H
1512 #include <sys/resource.h>
1514 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1515 [Define to `long' if <sys/resource.h> doesn't define.])])
1517 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1518 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1519 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1520 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1521 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1522 #include "ansidecl.h"
1531 gcc_AC_CHECK_DECLS(times, , ,[
1532 #include "ansidecl.h"
1534 #ifdef HAVE_SYS_TIMES_H
1535 #include <sys/times.h>
1539 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1540 #include "ansidecl.h"
1545 # More time-related stuff.
1546 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1547 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1548 #include "ansidecl.h"
1550 #ifdef HAVE_SYS_TIMES_H
1551 #include <sys/times.h>
1553 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1554 if test $ac_cv_struct_tms = yes; then
1555 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1556 [Define if <sys/times.h> defines struct tms.])
1559 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1560 # revisit after autoconf 2.50.
1561 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1562 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1563 #include "ansidecl.h"
1565 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1566 if test $gcc_cv_type_clock_t = yes; then
1567 AC_DEFINE(HAVE_CLOCK_T, 1,
1568 [Define if <time.h> defines clock_t.])
1571 # Check if F_SETLKW is supported by fcntl.
1572 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1573 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1574 #include <fcntl.h>]], [[
1580 return fcntl (1, F_SETLKW, &fl);]])],
1581 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1582 if test $ac_cv_f_setlkw = yes; then
1583 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1584 [Define if F_SETLKW supported by fcntl.])
1587 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1588 CFLAGS="$saved_CFLAGS"
1589 CXXFLAGS="$saved_CXXFLAGS"
1591 # mkdir takes a single argument on some systems.
1592 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1600 # With Setjmp/Longjmp based exception handling.
1601 AC_ARG_ENABLE(sjlj-exceptions,
1602 [AS_HELP_STRING([--enable-sjlj-exceptions],
1603 [arrange to use setjmp/longjmp exception handling])],
1606 if test $enableval != yes; then
1607 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1612 force_sjlj_exceptions=yes],
1615 force_sjlj_exceptions=yes
1619 force_sjlj_exceptions=yes
1623 force_sjlj_exceptions=no
1626 if test $force_sjlj_exceptions = yes; then
1627 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1628 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1629 [Define 0/1 to force the choice for exception handling model.])
1632 # --------------------------------------------------------
1633 # Build, host, and target specific configuration fragments
1634 # --------------------------------------------------------
1636 # Collect build-machine-specific information.
1637 . ${srcdir}/config.build || exit 1
1639 # Collect host-machine-specific information.
1640 . ${srcdir}/config.host || exit 1
1644 # Collect target-machine-specific information.
1645 . ${srcdir}/config.gcc || exit 1
1647 extra_objs="${host_extra_objs} ${extra_objs}"
1648 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1650 # Default the target-machine variables that were not explicitly set.
1651 if test x"$tm_file" = x
1652 then tm_file=$cpu_type/$cpu_type.h; fi
1654 if test x"$extra_headers" = x
1655 then extra_headers=; fi
1657 if test x$md_file = x
1658 then md_file=$cpu_type/$cpu_type.md; fi
1660 if test x$out_file = x
1661 then out_file=$cpu_type/$cpu_type.c; fi
1663 if test x"$tmake_file" = x
1664 then tmake_file=$cpu_type/t-$cpu_type
1667 # Support --enable-initfini-array.
1668 if test x$enable_initfini_array != xno; then
1669 tm_file="${tm_file} initfini-array.h"
1672 if test x"$dwarf2" = xyes
1673 then tm_file="$tm_file tm-dwarf2.h"
1676 # Say what files are being used for the output code and MD file.
1677 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1678 echo "Using \`$srcdir/config/$md_file' as machine description file."
1680 # If any of the xm_file variables contain nonexistent files, warn
1681 # about them and drop them.
1684 for x in $build_xm_file; do
1685 if test -f $srcdir/config/$x
1687 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1693 for x in $host_xm_file; do
1694 if test -f $srcdir/config/$x
1696 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1702 for x in $xm_file; do
1703 if test -f $srcdir/config/$x
1705 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1711 for f in $tm_file; do
1714 if test $count = ax; then
1715 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1717 echo "Using the following target machine macro files:"
1718 for f in $tm_file; do
1719 echo " $srcdir/config/$f"
1723 if test x$use_long_long_for_widest_fast_int = xyes; then
1724 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1725 [Define to 1 if the 'long long' type is wider than 'long' but still
1726 efficiently supported by the host hardware.])
1729 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1730 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1732 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1733 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1736 for f in $host_xm_file; do
1739 if test $count = a; then
1741 elif test $count = ax; then
1742 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1744 echo "Using the following host machine macro files:"
1745 for f in $host_xm_file; do
1746 echo " $srcdir/config/$f"
1749 echo "Using ${out_host_hook_obj} for host machine hooks."
1751 if test "$host_xm_file" != "$build_xm_file"; then
1753 for f in $build_xm_file; do
1756 if test $count = a; then
1758 elif test $count = ax; then
1759 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1761 echo "Using the following build machine macro files:"
1762 for f in $build_xm_file; do
1763 echo " $srcdir/config/$f"
1768 if test -n "$configured_native_system_header_dir"; then
1769 native_system_header_dir=$configured_native_system_header_dir
1771 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1772 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1776 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1777 gcc_cv_mcontext_underscores,
1778 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1779 #include <sys/cdefs.h>
1780 #include <sys/signal.h>
1781 #include <ucontext.h>
1782 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1784 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1785 if test $gcc_cv_mcontext_underscores = yes; then
1786 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1787 [mcontext_t fields start with __])
1796 # Check if a valid thread package
1797 case ${enable_threads} in
1800 target_thread_file='single'
1804 target_thread_file='single'
1806 aix | dce | lynx | mipssde | posix | rtems | \
1807 single | tpf | vxworks | win32)
1808 target_thread_file=${enable_threads}
1811 echo "${enable_threads} is an unknown thread package" 1>&2
1816 if test x${thread_file} = x; then
1817 # No thread file set by target-specific clauses in config.gcc,
1818 # so use file chosen by default logic above
1819 thread_file=${target_thread_file}
1827 if test x$enable___cxa_atexit = xyes || \
1828 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1829 if test x$host = x$target; then
1831 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1832 # keyed to flag_use_cxa_atexit
1840 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1841 [echo "__cxa_atexit can't be enabled on this target"])
1845 # We can't check for __cxa_atexit when building a cross, so assume
1849 if test x$use_cxa_atexit = xyes; then
1850 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1851 [Define if you want to use __cxa_atexit, rather than atexit, to
1852 register C++ destructors for local statics and global objects.
1853 This is essential for fully standards-compliant handling of
1854 destructors, but requires __cxa_atexit in libc.])
1858 # Look for a file containing extra machine modes.
1859 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1860 extra_modes_file='$(srcdir)'/config/${extra_modes}
1861 AC_SUBST(extra_modes_file)
1862 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1863 [Define to the name of a file containing a list of extra machine modes
1864 for this architecture.])
1867 # Convert extra_options into a form suitable for Makefile use.
1870 for f in $extra_options; do
1871 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1872 all_opt_files="$all_opt_files $srcdir/config/$f"
1874 AC_SUBST(extra_opt_files)
1876 # auto-host.h is the file containing items generated by autoconf and is
1877 # the first file included by config.h.
1878 # If host=build, it is correct to have bconfig include auto-host.h
1879 # as well. If host!=build, we are in error and need to do more
1880 # work to find out the build config parameters.
1881 if test x$host = x$build
1883 build_auto=auto-host.h
1884 HAVE_AUTO_BUILD='# '
1886 # We create a subdir, then run autoconf in the subdir.
1887 # To prevent recursion we set host and build for the new
1888 # invocation of configure to the build for this invocation
1895 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1896 *) realsrcdir=../${srcdir};;
1898 # Clearing GMPINC is necessary to prevent host headers being
1899 # used by the build compiler. Defining GENERATOR_FILE stops
1900 # system.h from including gmp.h.
1901 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1902 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1903 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1904 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1905 ${realsrcdir}/configure \
1906 --enable-languages=${enable_languages-all} \
1907 ${enable_obsolete+--enable-obsolete="$enable_obsolete"} \
1908 ${enable_option_checking+--enable-option-checking="$enable_option_checking"} \
1909 --target=$target_alias --host=$build_alias \
1910 --build=$build_alias || exit # retaining $tempdir
1912 # We just finished tests for the build machine, so rename
1913 # the file auto-build.h in the gcc directory.
1914 mv auto-host.h ../auto-build.h
1917 build_auto=auto-build.h
1920 AC_SUBST(build_subdir)
1921 AC_SUBST(HAVE_AUTO_BUILD)
1923 tm_file="${tm_file} defaults.h"
1924 tm_p_file="${tm_p_file} tm-preds.h"
1925 tm_d_file="${tm_d_file} defaults.h"
1926 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1927 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1928 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1929 # put this back in temporarily.
1930 xm_file="auto-host.h ansidecl.h ${xm_file}"
1937 # Compile in configure arguments.
1938 if test -f configargs.h ; then
1939 # Being re-configured.
1940 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1941 gcc_reconf_arguments=`echo "$gcc_config_arguments" | sed -e 's/^.*\( : (reconfigured) .*$\)/\1/'`
1942 if [ "$gcc_reconf_arguments" != " : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" ]; then
1943 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1946 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1949 # Double all backslashes and backslash all quotes to turn
1950 # gcc_config_arguments into a C string.
1951 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1952 $gcc_config_arguments
1954 gcc_config_arguments_str=`cat conftest.out`
1957 cat > configargs.h <<EOF
1958 /* Generated automatically. */
1959 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1960 static const char thread_model[] = "$thread_file";
1962 static const struct {
1963 const char *name, *value;
1964 } configure_default_options[] = $configure_default_options;
1969 gcc_BASEVER=`cat $srcdir/BASE-VER`
1970 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1971 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1972 if test -f $srcdir/REVISION ; then
1973 gcc_REVISION=`cat $srcdir/REVISION`
1977 cat > plugin-version.h <<EOF
1978 #include "configargs.h"
1980 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1981 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1982 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1983 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1985 static char basever[] = "$gcc_BASEVER";
1986 static char datestamp[] = "$gcc_DATESTAMP";
1987 static char devphase[] = "$gcc_DEVPHASE";
1988 static char revision[] = "$gcc_REVISION";
1990 /* FIXME plugins: We should make the version information more precise.
1991 One way to do is to add a checksum. */
1993 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1995 configuration_arguments};
1999 # Determine what GCC version number to use in filesystem paths.
2002 # Internationalization
2003 ZW_GNU_GETTEXT_SISTER_DIR
2005 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
2006 # -liconv on the link line twice.
2007 case "$LIBINTL" in *$LIBICONV*)
2011 AC_ARG_ENABLE(secureplt,
2012 [AS_HELP_STRING([--enable-secureplt],
2013 [enable -msecure-plt by default for PowerPC])],
2016 AC_ARG_ENABLE(mingw-wildcard,
2017 [AS_HELP_STRING([--enable-mingw-wildcard],
2018 [Set whether to expand wildcard on command-line.
2019 Default to platform configuration])],
2020 [],[enable_mingw_wildcard=platform])
2021 AS_IF([test x"$enable_mingw_wildcard" != xplatform ],
2022 [AC_DEFINE_UNQUOTED(MINGW_DOWILDCARD,
2023 $(test x"$enable_mingw_wildcard" = xno; echo $?),
2024 [Value to set mingw's _dowildcard to.])])
2026 AC_ARG_ENABLE(large-address-aware,
2027 [AS_HELP_STRING([--enable-large-address-aware],
2028 [Link mingw executables with --large-address-aware])])
2029 AS_IF([test x"$enable_large_address_aware" = xyes],
2030 [AC_DEFINE([MINGW_DEFAULT_LARGE_ADDR_AWARE], 1,
2031 [Define if we should link mingw executables with --large-address-aware])])
2033 AC_ARG_ENABLE(leading-mingw64-underscores,
2034 AS_HELP_STRING([--enable-leading-mingw64-underscores],
2035 [enable leading underscores on 64 bit mingw targets]),
2037 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
2038 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
2039 [Define if we should use leading underscore on 64 bit mingw targets])])
2042 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
2045 AC_ARG_ENABLE(frame-pointer,
2046 [AS_HELP_STRING([--enable-frame-pointer],
2047 [enable -fno-omit-frame-pointer by default for x86])], [],
2050 linux* | gnu* | darwin[[8912]]* | cygwin* | mingw*)
2051 # Enable -fomit-frame-pointer by default for these systems with DWARF2.
2052 enable_frame_pointer=no
2055 enable_frame_pointer=yes
2061 i[[34567]]86-*-* | x86_64-*-*)
2062 if test "x$enable_cld" = xyes; then
2063 tm_defines="${tm_defines} USE_IX86_CLD=1"
2065 if test "x$enable_frame_pointer" = xyes; then
2066 tm_defines="${tm_defines} USE_IX86_FRAME_POINTER=1"
2071 # Windows32 Registry support for specifying GCC installation paths.
2072 AC_ARG_ENABLE(win32-registry,
2073 [AS_HELP_STRING([--disable-win32-registry],
2074 [disable lookup of installation paths in the
2075 Registry on Windows hosts])
2076 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
2077 AS_HELP_STRING([--enable-win32-registry=KEY],
2078 [use KEY instead of GCC version as the last portion
2079 of the registry key])],,)
2082 win32 | pe | cygwin* | mingw32*)
2083 if test "x$enable_win32_registry" != xno; then
2084 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
2087 if test "x$enable_win32_registry" != xno; then
2088 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
2089 [Define to 1 if installation paths should be looked up in the Windows
2090 Registry. Ignored on non-Windows hosts.])
2092 if test "x$enable_win32_registry" != xyes \
2093 && test "x$enable_win32_registry" != x; then
2094 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
2095 [Define to be the last component of the Windows registry key under which
2096 to look for installation paths. The full key used will be
2097 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
2098 The default is the GCC version number.])
2104 # Get an absolute path to the GCC top-level source directory
2105 holddir=`${PWDCMD-pwd}`
2107 topdir=`${PWDCMD-pwd}`
2110 # Conditionalize the makefile for this host machine.
2112 for f in ${host_xmake_file}
2114 if test -f ${srcdir}/config/$f
2116 xmake_file="${xmake_file} \$(srcdir)/config/$f"
2120 # Conditionalize the makefile for this target machine.
2122 for f in ${tmake_file}
2124 if test -f ${srcdir}/config/$f
2126 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
2129 tmake_file="${tmake_file_}${omp_device_property_tmake_file}"
2131 out_object_file=`basename $out_file .c`.o
2132 common_out_object_file=`basename $common_out_file .c`.o
2134 tm_file_list="options.h"
2135 tm_include_list="options.h insn-constants.h"
2136 for f in $tm_file; do
2139 f=`echo $f | sed 's/^..//'`
2140 tm_file_list="${tm_file_list} $f"
2141 tm_include_list="${tm_include_list} $f"
2144 tm_file_list="${tm_file_list} \$(srcdir)/$f"
2145 tm_include_list="${tm_include_list} $f"
2148 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
2149 tm_include_list="${tm_include_list} config/$f"
2156 for f in $tm_p_file; do
2159 tm_p_file_list="${tm_p_file_list} $f"
2160 tm_p_include_list="${tm_p_include_list} $f"
2163 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
2164 tm_p_include_list="${tm_p_include_list} config/$f"
2169 tm_d_include_list="options.h insn-constants.h"
2170 for f in $tm_d_file; do
2173 tm_d_file_list="${tm_d_file_list} \$(srcdir)/$f"
2174 tm_d_include_list="${tm_d_include_list} $f"
2177 tm_d_file_list="${tm_d_file_list} \$(srcdir)/config/$f"
2178 tm_d_include_list="${tm_d_include_list} config/$f"
2185 for f in $xm_file; do
2188 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
2189 xm_include_list="${xm_include_list} $f"
2192 xm_file_list="${xm_file_list} $f"
2193 xm_include_list="${xm_include_list} $f"
2196 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
2197 xm_include_list="${xm_include_list} config/$f"
2203 host_xm_include_list=
2204 for f in $host_xm_file; do
2207 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
2208 host_xm_include_list="${host_xm_include_list} $f"
2211 host_xm_file_list="${host_xm_file_list} $f"
2212 host_xm_include_list="${host_xm_include_list} $f"
2215 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
2216 host_xm_include_list="${host_xm_include_list} config/$f"
2222 for f in $build_xm_file; do
2225 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
2226 build_xm_include_list="${build_xm_include_list} $f"
2228 auto-build.h | auto-host.h )
2229 build_xm_file_list="${build_xm_file_list} $f"
2230 build_xm_include_list="${build_xm_include_list} $f"
2233 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
2234 build_xm_include_list="${build_xm_include_list} config/$f"
2239 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
2240 # cross-compiler which does not use the native headers and libraries.
2241 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
2242 CROSS= AC_SUBST(CROSS)
2243 ALL=all.internal AC_SUBST(ALL)
2244 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
2245 BUILD_SYSTEM_HEADER_DIR=$SYSTEM_HEADER_DIR AC_SUBST(BUILD_SYSTEM_HEADER_DIR)
2247 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x ||
2248 test x$build != x$host || test "x$with_build_sysroot" != x; then
2249 if test "x$with_build_sysroot" != x; then
2250 BUILD_SYSTEM_HEADER_DIR=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
2252 BUILD_SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2255 if test x$host != x$target
2257 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
2259 SYSTEM_HEADER_DIR=$BUILD_SYSTEM_HEADER_DIR
2260 elif test "x$TARGET_SYSTEM_ROOT" != x; then
2261 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
2264 if test "x$with_build_sysroot" != "x"; then
2265 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
2266 elif test "x$with_sysroot" = x; then
2267 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
2268 elif test "x$with_sysroot" = xyes; then
2269 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
2271 target_header_dir="${with_sysroot}${native_system_header_dir}"
2274 target_header_dir=${native_system_header_dir}
2277 # If this is a cross-compiler that does not
2278 # have its own set of headers then define
2281 # If this is using newlib, without having the headers available now,
2282 # then define inhibit_libc in LIBGCC2_CFLAGS.
2283 # This prevents libgcc2 from containing any code which requires libc
2285 : ${inhibit_libc=false}
2286 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2287 test x$with_newlib = xyes ; } &&
2288 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
2291 AC_SUBST(inhibit_libc)
2293 # When building gcc with a cross-compiler, we need to adjust things so
2294 # that the generator programs are still built with the native compiler.
2295 # Also, we cannot run fixincludes.
2297 # These are the normal (build=host) settings:
2298 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2299 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2300 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2301 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2302 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2303 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2305 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS)' AC_SUBST(BUILD_NO_PIE_CFLAGS)
2306 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG)' AC_SUBST(BUILD_NO_PIE_FLAG)
2308 # And these apply if build != host, or we are generating coverage data
2309 if test x$build != x$host || test "x$coverage_flags" != x
2311 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2312 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2313 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2315 NO_PIE_CFLAGS_FOR_BUILD=${NO_PIE_CFLAGS_FOR_BUILD-${NO_PIE_CFLAGS}}
2316 NO_PIE_FLAG_FOR_BUILD=${NO_PIE_FLAG_FOR_BUILD-${NO_PIE_FLAG}}
2317 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS_FOR_BUILD)'
2318 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG_FOR_BUILD)'
2320 AC_SUBST(NO_PIE_CFLAGS_FOR_BUILD)
2321 AC_SUBST(NO_PIE_FLAG_FOR_BUILD)
2323 # Expand extra_headers to include complete path.
2324 # This substitutes for lots of t-* files.
2326 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2327 for file in ${extra_headers} ; do
2328 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2331 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2332 if test x"$use_gcc_tgmath" = xyes
2333 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2336 # Define collect2 in Makefile.
2337 case $host_can_use_collect2 in
2339 *) collect2='collect2$(exeext)' ;;
2341 AC_SUBST([collect2])
2343 # Add a definition of USE_COLLECT2 if system wants one.
2344 case $use_collect2 in
2345 no) use_collect2= ;;
2348 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2349 xm_defines="${xm_defines} USE_COLLECT2"
2350 case $host_can_use_collect2 in
2352 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2358 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2359 [Define to the name of the LTO plugin DSO that must be
2360 passed to the linker's -plugin=LIB option.])
2362 # ---------------------------
2363 # Assembler & linker features
2364 # ---------------------------
2366 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2367 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2368 # However when ld-new is first executed from the build tree, libtool will
2369 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2370 # to the build tree. While doing this we need to use the previous-stage
2371 # linker, or we have an infinite loop. The presence of a shell script as
2372 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2373 # the gcc/collect-ld script. So we need to know how libtool works, or
2374 # exec-tool will fail.
2376 m4_defun([_LT_CONFIG_COMMANDS], [])
2379 AC_SUBST(enable_fast_install)
2381 # Identify the assembler which will work hand-in-glove with the newly
2382 # built GCC, so that we can examine its features. This is the assembler
2383 # which will be driven by the driver program.
2385 # If build != host, and we aren't building gas in-tree, we identify a
2386 # build->target assembler and hope that it will have the same features
2387 # as the host->target assembler we'll be using.
2388 gcc_cv_gas_major_version=
2389 gcc_cv_gas_minor_version=
2390 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2392 m4_pattern_allow([AS_FOR_TARGET])dnl
2393 AS_VAR_SET_IF(gcc_cv_as,, [
2394 if test -x "$DEFAULT_ASSEMBLER"; then
2395 gcc_cv_as="$DEFAULT_ASSEMBLER"
2396 elif test -f $gcc_cv_as_gas_srcdir/configure.ac \
2397 && test -f ../gas/Makefile \
2398 && test x$build = x$host; then
2399 gcc_cv_as=../gas/as-new$build_exeext
2400 elif test -x as$build_exeext; then
2401 # Build using assembler in the current directory.
2402 gcc_cv_as=./as$build_exeext
2403 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2404 gcc_cv_as="$AS_FOR_TARGET"
2406 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2409 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2410 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2411 case "$ORIGINAL_AS_FOR_TARGET" in
2412 ./as | ./as$build_exeext) ;;
2413 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2416 AC_MSG_CHECKING(what assembler to use)
2417 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2418 # Single tree build which includes gas. We want to prefer it
2419 # over whatever linker top-level may have detected, since
2420 # we'll use what we're building after installation anyway.
2421 AC_MSG_RESULT(newly built gas)
2423 _gcc_COMPUTE_GAS_VERSION
2424 in_tree_gas_is_elf=no
2425 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2426 || (grep 'obj_format = multi' ../gas/Makefile \
2427 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2429 in_tree_gas_is_elf=yes
2432 AC_MSG_RESULT($gcc_cv_as)
2438 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2439 [case "${enableval}" in
2445 install_gold_as_default=no
2447 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2448 [case "${enableval}" in
2450 install_gold_as_default=yes
2453 if test x${default_ld} != x; then
2454 install_gold_as_default=yes
2460 AC_MSG_ERROR([invalid --enable-gold argument])
2464 # Identify the linker which will work hand-in-glove with the newly
2465 # built GCC, so that we can examine its features. This is the linker
2466 # which will be driven by the driver program.
2468 # If build != host, and we aren't building gas in-tree, we identify a
2469 # build->target linker and hope that it will have the same features
2470 # as the host->target linker we'll be using.
2471 gcc_cv_gld_major_version=
2472 gcc_cv_gld_minor_version=
2473 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2474 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2475 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2477 AS_VAR_SET_IF(gcc_cv_ld,, [
2478 if test -x "$DEFAULT_LINKER"; then
2479 gcc_cv_ld="$DEFAULT_LINKER"
2480 elif test $install_gold_as_default = yes \
2481 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2482 && test -f ../gold/Makefile \
2483 && test x$build = x$host; then
2484 gcc_cv_ld=../gold/ld-new$build_exeext
2485 elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \
2486 && test -f ../ld/Makefile \
2487 && test x$build = x$host; then
2488 gcc_cv_ld=../ld/ld-new$build_exeext
2489 elif test -x collect-ld$build_exeext; then
2490 # Build using linker in the current directory.
2491 gcc_cv_ld=./collect-ld$build_exeext
2492 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2493 gcc_cv_ld="$LD_FOR_TARGET"
2495 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2498 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2499 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2500 # if the PLUGIN_LD is set ld-new, just have it as ld
2501 # as that is the installed named.
2502 if test x$PLUGIN_LD_SUFFIX = xld-new \
2503 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2506 AC_ARG_WITH(plugin-ld,
2507 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2508 [if test x"$withval" != x; then
2509 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2510 PLUGIN_LD_SUFFIX="$withval"
2512 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2513 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2515 # Check to see if we are using gold instead of ld
2516 AC_MSG_CHECKING(whether we are using gold)
2518 if test x$gcc_cv_ld != x; then
2519 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2520 | grep "GNU gold" > /dev/null; then
2524 AC_MSG_RESULT($ld_is_gold)
2526 AC_MSG_CHECKING(gold linker with split stack support as non default)
2527 # Check to see if default ld is not gold, but gold is
2528 # available and has support for split stack. If gcc was configured
2529 # with gold then no checking is done.
2531 if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then
2533 # For platforms other than powerpc64*, enable as appropriate.
2536 ld_gold=`which ${gcc_cv_ld}.gold`
2537 # Make sure this gold has minimal split stack support
2538 if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then
2539 ld_vers=`$ld_gold --version | sed 1q`
2540 gold_vers=`echo $ld_vers | sed -n \
2541 -e 's,^[[^)]]*[[ ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'`
2543 # check that the gold version contains the complete split stack support
2544 # on powerpc64 big and little endian
2546 case "$gold_vers" in
2547 2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes
2549 *) gold_non_default=no
2555 if test $gold_non_default = yes; then
2556 AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1,
2557 [Define if the gold linker supports split stack and is available as a non-default])
2560 AC_MSG_RESULT($gold_non_default)
2562 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2563 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2564 case "$ORIGINAL_LD_FOR_TARGET" in
2565 ./collect-ld | ./collect-ld$build_exeext) ;;
2566 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2569 AC_MSG_CHECKING(what linker to use)
2570 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2571 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2572 # Single tree build which includes ld. We want to prefer it
2573 # over whatever linker top-level may have detected, since
2574 # we'll use what we're building after installation anyway.
2575 AC_MSG_RESULT(newly built ld)
2577 in_tree_ld_is_elf=no
2578 if (grep 'EMUL = .*elf' ../ld/Makefile \
2579 || grep 'EMUL = .*linux' ../ld/Makefile \
2580 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2581 in_tree_ld_is_elf=yes
2582 elif test "$ld_is_gold" = yes; then
2583 in_tree_ld_is_elf=yes
2585 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
2588 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2589 if test x$gcc_cv_gld_version != x; then
2593 case $gcc_cv_gld_version in
2596 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2599 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2600 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2602 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2603 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2605 AC_MSG_RESULT($gcc_cv_ld)
2607 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2608 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2609 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2612 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2613 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2615 # Figure out what nm we will be using.
2616 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2617 AS_VAR_SET_IF(gcc_cv_nm,, [
2618 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2619 && test -f ../binutils/Makefile \
2620 && test x$build = x$host; then
2621 gcc_cv_nm=../binutils/nm-new$build_exeext
2622 elif test -x nm$build_exeext; then
2623 gcc_cv_nm=./nm$build_exeext
2624 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2625 gcc_cv_nm="$NM_FOR_TARGET"
2627 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2630 AC_MSG_CHECKING(what nm to use)
2631 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2632 # Single tree build which includes binutils.
2633 AC_MSG_RESULT(newly built nm)
2636 AC_MSG_RESULT($gcc_cv_nm)
2640 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2641 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2642 case "$ORIGINAL_NM_FOR_TARGET" in
2643 ./nm | ./nm$build_exeext) ;;
2644 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2648 # Figure out what objdump we will be using.
2649 AS_VAR_SET_IF(gcc_cv_objdump,, [
2650 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2651 && test -f ../binutils/Makefile \
2652 && test x$build = x$host; then
2653 # Single tree build which includes binutils.
2654 gcc_cv_objdump=../binutils/objdump$build_exeext
2655 elif test -x objdump$build_exeext; then
2656 gcc_cv_objdump=./objdump$build_exeext
2657 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2658 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2660 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2663 AC_MSG_CHECKING(what objdump to use)
2664 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2665 # Single tree build which includes binutils.
2666 AC_MSG_RESULT(newly built objdump)
2667 elif test x$gcc_cv_objdump = x; then
2668 AC_MSG_RESULT(not found)
2670 AC_MSG_RESULT($gcc_cv_objdump)
2673 # Figure out what readelf we will be using.
2674 AS_VAR_SET_IF(gcc_cv_readelf,, [
2675 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2676 && test -f ../binutils/Makefile \
2677 && test x$build = x$host; then
2678 # Single tree build which includes binutils.
2679 gcc_cv_readelf=../binutils/readelf$build_exeext
2680 elif test -x readelf$build_exeext; then
2681 gcc_cv_readelf=./readelf$build_exeext
2682 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2683 gcc_cv_readelf="$READELF_FOR_TARGET"
2685 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2688 AC_MSG_CHECKING(what readelf to use)
2689 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2690 # Single tree build which includes binutils.
2691 AC_MSG_RESULT(newly built readelf)
2692 elif test x$gcc_cv_readelf = x; then
2693 AC_MSG_RESULT(not found)
2695 AC_MSG_RESULT($gcc_cv_readelf)
2698 # Figure out what otool we will be using.
2699 AS_VAR_SET_IF(gcc_cv_otool,, [
2700 if test -x otool$build_exeext; then
2701 gcc_cv_otool=./otool$build_exeext
2702 elif ( set dummy $OTOOL_FOR_TARGET; test -x $[2] ); then
2703 gcc_cv_otool="$OTOOL_FOR_TARGET"
2705 AC_PATH_PROG(gcc_cv_otool, $OTOOL_FOR_TARGET)
2708 AC_MSG_CHECKING(what otool to use)
2709 if test x$gcc_cv_otool = x; then
2710 AC_MSG_RESULT(not found)
2712 AC_MSG_RESULT($gcc_cv_otool)
2715 # Figure out what assembler alignment features are present.
2716 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2720 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2721 [Define if your assembler supports .balign and .p2align.])])
2723 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2726 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2727 [Define if your assembler supports specifying the maximum number
2728 of bytes to skip when using the GAS .p2align command.])])
2730 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2733 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2734 [Define if your assembler supports .literal16.])])
2736 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2738 [conftest_label1: .word 0
2740 conftest_label2: .word 0
2742 [if test x$gcc_cv_nm != x; then
2743 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2744 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2745 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2747 else gcc_cv_as_subsection_m1=yes
2749 rm -f conftest.nm1 conftest.nm2
2751 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2752 [Define if your assembler supports .subsection and .subsection -1 starts
2753 emitting at the beginning of your section.])])
2755 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2758 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2760 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2762 [ .weakref foobar, barfnot],,
2763 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2765 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2768 .NSUBSPA $CODE$,COMDAT],,
2769 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2771 # .hidden needs to be supported in both the assembler and the linker,
2772 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2773 # This is irritatingly difficult to feature test for; we have to check the
2774 # date string after the version number. If we've got an in-tree
2775 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2777 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2780 conftest_s=' .globl foobar,hidden'
2783 conftest_s=' .hidden foobar
2787 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2788 [elf,2,13,0],, [$conftest_s])
2791 # Darwin as has some visibility support, though with a different syntax.
2792 gcc_cv_as_hidden=yes
2796 # gnu_indirect_function type is an extension proposed at
2797 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2798 # selection of function implementation
2799 AC_ARG_ENABLE(gnu-indirect-function,
2800 [AS_HELP_STRING([--enable-gnu-indirect-function],
2801 [enable the use of the @gnu_indirect_function to glibc systems])],
2802 [case $enable_gnu_indirect_function in
2804 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2805 Valid choices are 'yes' and 'no'.]) ;;
2807 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2809 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2810 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2811 [Define if your system supports gnu indirect functions.])
2815 if test $in_tree_ld != yes ; then
2816 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2817 if echo "$ld_ver" | grep GNU > /dev/null; then
2818 if test x"$ld_is_gold" = xyes; then
2819 # GNU gold --version looks like this:
2821 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2823 # We extract the binutils version which is more familiar and specific
2824 # than the gold version.
2825 ld_vers=`echo $ld_ver | sed -n \
2826 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2828 # GNU ld --version looks like this:
2830 # GNU ld (GNU Binutils) 2.21.51.20110225
2831 ld_vers=`echo $ld_ver | sed -n \
2832 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2834 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'`
2835 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2836 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2837 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2841 # Solaris 2 ld -V output looks like this for a regular version:
2843 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2845 # but test versions add stuff at the end:
2847 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2849 # ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version
2850 # numbers can be used in ld.so.1 feature checks even if a different
2851 # linker is configured.
2852 ld_ver=`$gcc_cv_ld -V 2>&1`
2853 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2854 ld_vers=`echo $ld_ver | sed -n \
2855 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2856 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2857 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2865 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2866 [[if test $in_tree_ld = yes ; then
2868 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 \
2869 && test $in_tree_ld_is_elf = yes; then
2870 gcc_cv_ld_hidden=yes
2873 gcc_cv_ld_hidden=yes
2874 if test x"$ld_is_gold" = xyes; then
2876 elif echo "$ld_ver" | grep GNU > /dev/null; then
2878 mmix-knuth-mmixware)
2879 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2883 if test 0"$ld_date" -lt 20020404; then
2884 if test -n "$ld_date"; then
2885 # If there was date string, but was earlier than 2002-04-04, fail
2887 elif test -z "$ld_vers"; then
2888 # If there was no date string nor ld version number, something is wrong
2891 test -z "$ld_vers_patch" && ld_vers_patch=0
2892 if test "$ld_vers_major" -lt 2; then
2894 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2895 gcc_cv_ld_hidden="no"
2896 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2904 gcc_cv_ld_hidden=yes
2907 # Darwin ld has some visibility support.
2908 gcc_cv_ld_hidden=yes
2910 hppa64*-*-hpux* | ia64*-*-hpux*)
2911 gcc_cv_ld_hidden=yes
2914 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2915 # .symbolic was only added in Solaris 9 12/02.
2916 gcc_cv_ld_hidden=yes
2924 libgcc_visibility=no
2925 AC_SUBST(libgcc_visibility)
2926 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2927 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2928 libgcc_visibility=yes
2929 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2930 [Define if your assembler and linker support .hidden.])
2933 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2934 gcc_cv_ld_ro_rw_mix=unknown
2935 if test $in_tree_ld = yes ; then
2936 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 \
2937 && test $in_tree_ld_is_elf = yes; then
2938 gcc_cv_ld_ro_rw_mix=read-write
2940 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2941 echo '.section myfoosect, "a"' > conftest1.s
2942 echo '.section myfoosect, "aw"' > conftest2.s
2943 echo '.byte 1' >> conftest2.s
2944 echo '.section myfoosect, "a"' > conftest3.s
2945 echo '.byte 0' >> conftest3.s
2946 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2947 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2948 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2949 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2950 conftest2.o conftest3.o > /dev/null 2>&1; then
2951 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2952 | sed -e '/myfoosect/!d' -e N`
2953 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2954 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2955 gcc_cv_ld_ro_rw_mix=read-only
2957 gcc_cv_ld_ro_rw_mix=read-write
2962 rm -f conftest.* conftest[123].*
2965 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2966 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2967 [Define if your linker links a mix of read-only
2968 and read-write sections into a read-write section.])
2970 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2972 gcc_AC_INITFINI_ARRAY
2974 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2975 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2983 [[# GAS versions before 2.11 do not support uleb128,
2984 # despite appearing to.
2985 # ??? There exists an elf-specific test that will crash
2986 # the assembler. Perhaps it's better to figure out whether
2987 # arbitrary sections are supported and try the test.
2988 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2989 if echo "$as_ver" | grep GNU > /dev/null; then
2990 as_vers=`echo $as_ver | sed -n \
2991 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2992 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2993 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2994 if test $as_major -eq 2 && test $as_minor -lt 11
2996 else gcc_cv_as_leb128=yes
2999 [AC_DEFINE(HAVE_AS_LEB128, 1,
3000 [Define if your assembler supports .sleb128 and .uleb128.])],
3001 [AC_DEFINE(HAVE_AS_LEB128, 0,
3002 [Define if your assembler supports .sleb128 and .uleb128.])])
3004 # Determine if an .eh_frame section is read-only.
3005 gcc_fn_eh_frame_ro () {
3006 $gcc_cv_as $1 -o conftest.o conftest.s > /dev/null 2>&1 && \
3007 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
3008 sed -e '/.eh_frame/!d' -e N | grep READONLY > /dev/null
3011 # Check if we have assembler support for unwind directives.
3012 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
3019 .cfi_escape 1, 2, 3, 4, 5
3023 # If the linker used on Solaris (like Sun ld) isn't capable of merging
3024 # read-only and read-write sections, we need to make sure that the
3025 # assembler used emits read-write .eh_frame sections.
3026 if test "x$gcc_cv_ld_ro_rw_mix" = xread-write; then
3027 gcc_cv_as_cfi_directive=yes
3028 elif test "x$gcc_cv_objdump" = x; then
3029 # No objdump, err on the side of caution.
3030 gcc_cv_as_cfi_directive=no
3032 if test x$gas = xyes; then
3040 sparc*-*-solaris2.*)
3041 # On Solaris/SPARC, .eh_frame sections should always be read-write.
3042 if gcc_fn_eh_frame_ro $as_32_opt \
3043 || gcc_fn_eh_frame_ro $as_64_opt; then
3044 gcc_cv_as_cfi_directive=no
3046 gcc_cv_as_cfi_directive=yes
3049 i?86-*-solaris2.* | x86_64-*-solaris2.*)
3050 # On Solaris/x86, make sure that GCC and assembler agree on using
3051 # read-only .eh_frame sections for 64-bit.
3052 if gcc_fn_eh_frame_ro $as_32_opt; then
3053 gcc_cv_as_cfi_directive=no
3054 elif gcc_fn_eh_frame_ro $as_64_opt; then
3055 gcc_cv_as_cfi_directive=yes
3057 gcc_cv_as_cfi_directive=no
3064 gcc_cv_as_cfi_directive=yes
3067 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
3068 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
3072 .cfi_adjust_cfa_offset 64
3074 .cfi_adjust_cfa_offset 128
3077 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
3078 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
3079 gcc_cv_as_cfi_advance_working=yes
3083 # no objdump, err on the side of caution
3084 gcc_cv_as_cfi_advance_working=no
3086 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
3087 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
3088 [`if test $gcc_cv_as_cfi_directive = yes \
3089 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
3090 [Define 0/1 if your assembler supports CFI directives.])
3092 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
3093 gcc_GAS_CHECK_FEATURE([cfi personality directive],
3094 gcc_cv_as_cfi_personality_directive, ,,
3097 .cfi_personality 0, symbol
3099 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
3100 [`if test $gcc_cv_as_cfi_personality_directive = yes; then echo 1; else echo 0; fi`],
3101 [Define 0/1 if your assembler supports .cfi_personality.])
3103 gcc_GAS_CHECK_FEATURE([cfi sections directive],
3104 gcc_cv_as_cfi_sections_directive, ,,
3106 .cfi_sections .debug_frame, .eh_frame
3110 win32 | pe | cygwin* | mingw32*)
3111 # Need to check that we generated the correct relocation for the
3112 # .debug_frame section. This was fixed for binutils 2.21.
3113 gcc_cv_as_cfi_sections_directive=no
3114 if test "x$gcc_cv_objdump" != x; then
3115 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
3116 grep secrel > /dev/null; then
3117 gcc_cv_as_cfi_sections_directive=yes
3122 gcc_cv_as_cfi_sections_directive=yes
3125 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
3126 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
3127 [`if test $gcc_cv_as_cfi_sections_directive = yes; then echo 1; else echo 0; fi`],
3128 [Define 0/1 if your assembler supports .cfi_sections.])
3130 # GAS versions up to and including 2.11.0 may mis-optimize
3132 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
3140 .section .eh_frame,"aw",@progbits
3142 .4byte .LECIE1-.LSCIE1
3156 .4byte .LEFDE1-.LASFDE1
3158 .4byte .LASFDE1-__FRAME_BEGIN__
3166 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
3167 cat > conftest.lit <<EOF
3168 0000 10000000 00000000 017a0001 781a0004 .........z..x...
3169 0010 01000000 12000000 18000000 00000000 ................
3170 0020 08000000 04080000 0044 .........D @&t@
3172 cat > conftest.big <<EOF
3173 0000 00000010 00000000 017a0001 781a0004 .........z..x...
3174 0010 00000001 00000012 00000018 00000000 ................
3175 0020 00000008 04000000 0844 .........D @&t@
3177 # If the assembler didn't choke, and we can objdump,
3178 # and we got the correct data, then succeed.
3179 # The text in the here-document typically retains its unix-style line
3180 # endings, while the output of objdump will use host line endings.
3181 # Therefore, use diff -b for the comparisons.
3182 if test x$gcc_cv_objdump != x \
3183 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
3184 | tail -3 > conftest.got \
3185 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
3186 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
3188 gcc_cv_as_eh_frame=yes
3189 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
3190 gcc_cv_as_eh_frame=buggy
3192 # Uh oh, what do we do now?
3193 gcc_cv_as_eh_frame=no
3196 if test $gcc_cv_as_eh_frame = buggy; then
3197 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
3198 [Define if your assembler mis-optimizes .eh_frame data.])
3201 # Test if the assembler supports the section flag 'e' or #exclude for
3202 # specifying an excluded section.
3203 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_e,
3204 [2,22,51], [--fatal-warnings],
3207 if test $gcc_cv_as_section_exclude_e = no; then
3209 # Solaris as uses #exclude instead.
3213 conftest_s='.section "foo1", #exclude'
3215 i?86-*-solaris2* | x86_64-*-solaris2*)
3216 conftest_s='.section foo1, #exclude'
3221 gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_hash,,,
3225 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3226 [`if test $gcc_cv_as_section_exclude_e = yes || test $gcc_cv_as_section_exclude_hash = yes; then echo 1; else echo 0; fi`],
3227 [Define if your assembler supports specifying the exclude section flag.])
3229 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3230 [elf,2,12,0], [--fatal-warnings],
3231 [.section .rodata.str, "aMS", @progbits, 1])
3232 if test $gcc_cv_as_shf_merge = no; then
3233 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
3234 [elf,2,12,0], [--fatal-warnings],
3235 [.section .rodata.str, "aMS", %progbits, 1])
3237 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
3238 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
3239 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
3241 gcc_cv_ld_aligned_shf_merge=yes
3243 # SHF_MERGE support is broken in Solaris ld up to Solaris 11.3/SPARC for
3245 sparc*-*-solaris2.11*)
3246 if test x"$gnu_ld" = xno \
3247 && test "$ld_vers_major" -lt 2 && test "$ld_vers_minor" -lt 3159; then
3248 gcc_cv_ld_aligned_shf_merge=no
3252 AC_DEFINE_UNQUOTED(HAVE_LD_ALIGNED_SHF_MERGE,
3253 [`if test $gcc_cv_ld_aligned_shf_merge = yes; then echo 1; else echo 0; fi`],
3254 [Define 0/1 if your linker supports the SHF_MERGE flag with section alignment > 1.])
3256 gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,,
3257 [.stabs "gcc2_compiled.",60,0,0,0],,
3258 [AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1,
3259 [Define if your assembler supports .stabs.])])
3261 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
3262 gcc_cv_as_comdat_group,
3263 [elf,2,16,0], [--fatal-warnings],
3264 [.section .text,"axG",@progbits,.foo,comdat])
3265 if test $gcc_cv_as_comdat_group = yes; then
3266 gcc_cv_as_comdat_group_percent=no
3267 gcc_cv_as_comdat_group_group=no
3269 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
3270 gcc_cv_as_comdat_group_percent,
3271 [elf,2,16,0], [--fatal-warnings],
3272 [.section .text,"axG",%progbits,.foo,comdat])
3273 if test $gcc_cv_as_comdat_group_percent = yes; then
3274 gcc_cv_as_comdat_group_group=no
3277 # Sun as uses a completely different syntax.
3282 .group foo,".text%foo",#comdat
3283 .section ".text%foo", #alloc,#execinstr,#progbits
3288 i?86-*-solaris2* | x86_64-*-solaris2*)
3290 .group foo,.text%foo,#comdat
3291 .section .text%foo, "ax", @progbits
3297 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
3298 gcc_cv_as_comdat_group_group,
3302 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
3303 gcc_cv_as_comdat_group_group=no
3307 if test x"$ld_is_gold" = xyes; then
3309 elif test $in_tree_ld = yes ; then
3311 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 \
3312 && test $in_tree_ld_is_elf = yes; then
3315 elif echo "$ld_ver" | grep GNU > /dev/null; then
3317 if test 0"$ld_date" -lt 20050308; then
3318 if test -n "$ld_date"; then
3319 # If there was date string, but was earlier than 2005-03-08, fail
3321 elif test "$ld_vers_major" -lt 2; then
3323 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
3330 *-*-solaris2.1[1-9]*)
3332 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
3333 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
3336 # If using Sun as for COMDAT group as emitted by GCC, one needs at
3337 # least ld version 1.2267.
3338 if test "$ld_vers_major" -gt 1; then
3340 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
3342 elif test "$ld_vers_minor" -ge 2267; then
3347 # Assume linkers other than GNU ld don't support COMDAT group.
3353 # Allow overriding the automatic COMDAT group tests above.
3354 AC_ARG_ENABLE(comdat,
3355 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
3356 [comdat_group="$enable_comdat"])
3357 if test $comdat_group = no; then
3358 gcc_cv_as_comdat_group=no
3359 gcc_cv_as_comdat_group_percent=no
3360 gcc_cv_as_comdat_group_group=no
3362 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
3363 [`if test $gcc_cv_as_comdat_group = yes \
3364 || test $gcc_cv_as_comdat_group_percent = yes \
3365 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
3366 [Define 0/1 if your assembler and linker support COMDAT groups.])
3368 # Restrict this test to Solaris/x86: other targets define this statically.
3370 i?86-*-solaris2* | x86_64-*-solaris2*)
3371 AC_MSG_CHECKING(support for hidden thunks in linkonce sections)
3372 if test $in_tree_ld = yes || echo "$ld_ver" | grep GNU > /dev/null; then
3376 # Full support for hidden thunks in linkonce sections only appeared in
3377 # Solaris 11/OpenSolaris.
3378 *-*-solaris2.1[[1-9]]*)
3386 AC_MSG_RESULT($hidden_linkonce)
3387 AC_DEFINE_UNQUOTED(USE_HIDDEN_LINKONCE,
3388 [`if test $hidden_linkonce = yes; then echo 1; else echo 0; fi`],
3389 [Define 0/1 if your linker supports hidden thunks in linkonce sections.])
3393 gcc_GAS_CHECK_FEATURE([line table is_stmt support],
3398 .loc 1 1 0 is_stmt 1],,
3399 [AC_DEFINE(HAVE_GAS_LOC_STMT, 1,
3400 [Define if your assembler supports the .loc is_stmt sub-directive.])])
3402 gcc_GAS_CHECK_FEATURE([line table discriminator support],
3403 gcc_cv_as_discriminator,
3407 .loc 1 1 0 discriminator 1],,
3408 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
3409 [Define if your assembler supports the .loc discriminator sub-directive.])])
3411 # Catch the newlib flag of the same name so we can gate GCC features on it.
3412 AC_ARG_ENABLE(newlib-nano-formatted-io,
3413 [AS_HELP_STRING([--enable-newlib-nano-formatted-io], [Use nano version
3415 [case "${enableval}" in
3419 AC_MSG_ERROR([unknown newlib-nano-formatted-io setting $enableval])
3423 # Thread-local storage - the check is heavily parameterized.
3432 .section ".tdata","awT",@progbits
3435 ldq $27,__tls_get_addr($29) !literal!1
3436 lda $16,foo($29) !tlsgd!1
3437 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3438 ldq $27,__tls_get_addr($29) !literal!2
3439 lda $16,foo($29) !tlsldm!2
3440 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
3441 ldq $1,foo($29) !gotdtprel
3442 ldah $2,foo($29) !dtprelhi
3443 lda $3,foo($2) !dtprello
3444 lda $4,foo($29) !dtprel
3445 ldq $1,foo($29) !gottprel
3446 ldah $2,foo($29) !tprelhi
3447 lda $3,foo($2) !tprello
3448 lda $4,foo($29) !tprel'
3451 tls_as_opt=--fatal-warnings
3455 add_s r0,r0, @foo@tpoff'
3459 cris-*-*|crisv32-*-*)
3461 .section ".tdata","awT",@progbits
3468 tls_as_opt=--fatal-warnings
3472 .section ".tdata","awT",@progbits
3484 .section ".tdata","awT",@progbits
3488 addil LT%foo-$tls_gdidx$,gp
3489 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3492 addil LT%foo-$tls_ldidx$,gp
3494 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3495 addil LR%foo-$tls_dtpoff$,%ret0
3496 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3498 addil LT%foo-$tls_ieoff$,gp
3499 ldw RT%foo-$tls_ieoff$(%r1),%t2
3502 addil LR%foo-$tls_leoff$,%t1
3503 ldo RR%foo-$tls_leoff$(%r1),%t2'
3506 tls_as_opt=--fatal-warnings
3510 .section ".tdata","awT",%progbits
3521 i[34567]86-*-* | x86_64-*-*)
3523 i[34567]86-*-solaris2.* | x86_64-*-solaris2.*)
3530 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3532 .section .tdata,"awt",@progbits'
3537 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3538 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3542 .section ".tdata","awT",@progbits'
3546 tls_as_opt="--fatal-warnings"
3550 if test x$on_solaris = xyes; then
3552 yes) tls_as_opt="$tls_as_opt --32" ;;
3555 conftest_s="$conftest_s
3559 leal foo@tlsgd(,%ebx,1), %eax
3560 leal foo@tlsldm(%ebx), %eax
3561 leal foo@dtpoff(%eax), %edx
3562 movl foo@gottpoff(%ebx), %eax
3563 subl foo@gottpoff(%ebx), %eax
3564 addl foo@gotntpoff(%ebx), %eax
3565 movl foo@indntpoff, %eax
3566 movl \$foo@tpoff, %eax
3567 subl \$foo@tpoff, %eax
3568 leal foo@ntpoff(%ecx), %eax"
3571 if test x$on_solaris = xyes; then
3573 yes) tls_as_opt="$tls_as_opt --64" ;;
3574 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3577 conftest_s="$conftest_s
3581 leaq foo@tlsgd(%rip), %rdi
3582 leaq foo@tlsld(%rip), %rdi
3583 leaq foo@dtpoff(%rax), %rdx
3584 movq foo@gottpoff(%rip), %rax
3585 movq \$foo@tpoff, %rax"
3591 .section ".tdata","awT",@progbits
3594 addl r16 = @ltoff(@dtpmod(foo#)), gp
3595 addl r17 = @ltoff(@dtprel(foo#)), gp
3596 addl r18 = @ltoff(@tprel(foo#)), gp
3597 addl r19 = @dtprel(foo#), gp
3598 adds r21 = @dtprel(foo#), r13
3599 movl r23 = @dtprel(foo#)
3600 addl r20 = @tprel(foo#), gp
3601 adds r22 = @tprel(foo#), r13
3602 movl r24 = @tprel(foo#)'
3605 tls_as_opt=--fatal-warnings
3609 .section .tdata,"awT",@progbits
3613 addik r5,r20,x@TLSGD
3614 addik r5,r20,x@TLSLDM'
3617 tls_as_opt='--fatal-warnings'
3621 .section .tdata,"awT",@progbits
3625 addiu $4, $28, %tlsgd(x)
3626 addiu $4, $28, %tlsldm(x)
3627 lui $4, %dtprel_hi(x)
3628 addiu $4, $4, %dtprel_lo(x)
3629 lw $4, %gottprel(x)($28)
3630 lui $4, %tprel_hi(x)
3631 addiu $4, $4, %tprel_lo(x)'
3634 tls_as_opt='-32 --fatal-warnings'
3638 .section .tdata,"awT",@progbits
3643 move.l x@TLSGD(%a5),%a0
3644 move.l x@TLSLDM(%a5),%a0
3645 move.l x@TLSLDO(%a5),%a0
3646 move.l x@TLSIE(%a5),%a0
3647 move.l x@TLSLE(%a5),%a0'
3650 tls_as_opt='--fatal-warnings'
3654 .section ".tdata","awT",@progbits'
3657 tls_as_opt="--fatal-warnings"
3661 .section ".tdata","awT",%progbits
3665 add x0, x0, #:tlsgd_lo12:x
3670 tls_as_opt='--fatal-warnings'
3674 .section ".tdata","awT",@progbits
3677 l.movhi r3, tpoffha(foo)
3679 l.lwz r4, tpofflo(foo)(r3)'
3682 tls_as_opt=--fatal-warnings
3686 .extern __get_tpointer
3704 .section ".tdata","awT",@progbits
3712 addi 3,2,ld0@got@tlsgd
3718 addi 3,2,x1@got@tlsld
3724 addis 9,3,x2@dtprel@ha
3725 addi 9,9,x2@dtprel@l
3728 ld 9,x3@got@dtprel(2)
3734 tls_as_opt="-a64 --fatal-warnings"
3738 .section ".tdata","awT",@progbits
3746 addi 3,31,ld0@got@tlsgd
3748 addi 3,31,x1@got@tlsld
3751 addis 9,3,x2@dtprel@ha
3752 addi 9,9,x2@dtprel@l
3753 lwz 9,x3@got@tprel(31)
3756 addis 9,2,x2@tprel@ha
3757 addi 9,9,x2@tprel@l'
3760 tls_as_opt="-a32 --fatal-warnings"
3764 .section .tdata,"awT",@progbits
3768 call __tls_get_addr'
3771 tls_as_opt='--fatal-warnings'
3775 .section ".tdata","awT",@progbits
3784 l %r1,foo@GOTNTPOFF(%r12)
3785 l %r1,0(%r1):tls_load:foo
3786 bas %r14,0(%r1,%r13):tls_gdcall:foo
3787 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3790 tls_as_opt="-m31 --fatal-warnings"
3794 .section ".tdata","awT",@progbits
3802 lg %r1,foo@GOTNTPOFF(%r12)
3803 larl %r1,foo@INDNTPOFF
3804 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3805 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3808 tls_as_opt="-m64 -Aesame --fatal-warnings"
3810 sh-*-* | sh[123456789lbe]*-*-*)
3812 .section ".tdata","awT",@progbits
3822 tls_as_opt=--fatal-warnings
3826 sparc*-sun-solaris2.*)
3833 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3835 .section ".tdata",#alloc,#write,#tls'
3840 .section ".tdata","awT",@progbits'
3843 tls_as_opt="-32 --fatal-warnings"
3845 conftest_s="$conftest_s
3848 sethi %tgd_hi22(foo), %o0
3849 add %o0, %tgd_lo10(foo), %o1
3850 add %l7, %o1, %o0, %tgd_add(foo)
3851 call __tls_get_addr, %tgd_call(foo)
3852 sethi %tldm_hi22(foo), %l1
3853 add %l1, %tldm_lo10(foo), %l2
3854 add %l7, %l2, %o0, %tldm_add(foo)
3855 call __tls_get_addr, %tldm_call(foo)
3856 sethi %tldo_hix22(foo), %l3
3857 xor %l3, %tldo_lox10(foo), %l4
3858 add %o0, %l4, %l5, %tldo_add(foo)
3859 sethi %tie_hi22(foo), %o3
3860 add %o3, %tie_lo10(foo), %o3
3861 ld [%l7 + %o3], %o2, %tie_ld(foo)
3862 add %g7, %o2, %o4, %tie_add(foo)
3863 sethi %tle_hix22(foo), %l1
3864 xor %l1, %tle_lox10(foo), %o5
3865 ld [%g7 + %o5], %o1"
3869 .section ".tdata","awT",@progbits
3872 addli r0, zero, tls_gd(foo)
3873 auli r0, zero, tls_gd_ha16(foo)
3874 addli r0, r0, tls_gd_lo16(foo)
3876 addli r0, zero, tls_ie(foo)
3877 auli r0, r0, tls_ie_ha16(foo)
3878 addli r0, r0, tls_ie_lo16(foo)'
3881 tls_as_opt="--fatal-warnings"
3885 .section ".tdata","awT",@progbits
3888 shl16insli r0, zero, hw0_last_tls_gd(foo)
3889 shl16insli r0, zero, hw1_last_tls_gd(foo)
3890 shl16insli r0, r0, hw0_tls_gd(foo)
3892 shl16insli r0, zero, hw1_last_tls_ie(foo)
3893 shl16insli r0, r0, hw0_tls_ie(foo)'
3896 tls_as_opt="--fatal-warnings"
3900 .section ".tdata","awT",@progbits
3903 movi a8, foo@TLSFUNC
3904 movi a10, foo@TLSARG
3905 callx8.tls a8, foo@TLSCALL'
3912 if test "x$enable_tls" = xno ; then
3913 : # TLS explicitly disabled.
3914 elif test "x$enable_tls" = xyes ; then
3915 set_have_as_tls=yes # TLS explicitly enabled.
3916 elif test -z "$tls_first_major"; then
3917 : # If we don't have a check, assume no support.
3919 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3920 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3921 [set_have_as_tls=yes])
3923 if test $set_have_as_tls = yes ; then
3924 AC_DEFINE(HAVE_AS_TLS, 1,
3925 [Define if your assembler and linker support thread-local storage.])
3928 # Target-specific assembler checks.
3930 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3931 gcc_cv_ld_static_dynamic=no
3932 gcc_cv_ld_static_option='-Bstatic'
3933 gcc_cv_ld_dynamic_option='-Bdynamic'
3934 if test $in_tree_ld = yes ; then
3935 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
3936 gcc_cv_ld_static_dynamic=yes
3938 elif test x$gcc_cv_ld != x; then
3939 # Check if linker supports -Bstatic/-Bdynamic option
3940 if $gcc_cv_ld --help 2>&1 | grep -- -Bstatic > /dev/null \
3941 && $gcc_cv_ld --help 2>&1 | grep -- -Bdynamic > /dev/null; then
3942 gcc_cv_ld_static_dynamic=yes
3945 # AIX ld uses -b flags
3946 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3947 gcc_cv_ld_static_dynamic=yes
3948 gcc_cv_ld_static_option="-bstatic"
3949 gcc_cv_ld_dynamic_option="-bdynamic"
3951 # HP-UX ld uses -a flags to select between shared and archive.
3953 if test x"$gnu_ld" = xno; then
3954 gcc_cv_ld_static_dynamic=yes
3955 gcc_cv_ld_static_option="-aarchive_shared"
3956 gcc_cv_ld_dynamic_option="-adefault"
3959 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3961 gcc_cv_ld_static_dynamic=yes
3966 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3967 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3968 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3969 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3970 [Define to the linker option to disable use of shared objects.])
3971 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3972 [Define to the linker option to enable use of shared objects.])
3974 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3976 AC_MSG_CHECKING(linker --version-script option)
3977 gcc_cv_ld_version_script=no
3978 ld_version_script_option=''
3979 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
3980 gcc_cv_ld_version_script=yes
3981 ld_version_script_option='--version-script'
3982 elif test x$gcc_cv_ld != x; then
3984 # Solaris 2 ld always supports -M. It also supports a subset of
3985 # --version-script since Solaris 11.4, but requires
3986 # -z gnu-version-script-compat to activate.
3988 gcc_cv_ld_version_script=yes
3989 ld_version_script_option='-M'
3993 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
3994 AC_MSG_RESULT($gcc_cv_ld_version_script)
3995 AC_SUBST(ld_version_script_option)
3997 AC_MSG_CHECKING(linker soname option)
3999 if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then
4000 gcc_cv_ld_soname=yes
4001 ld_soname_option='-soname'
4002 elif test x$gcc_cv_ld != x; then
4005 gcc_cv_ld_soname=yes
4006 ld_soname_option='-install_name'
4008 # Solaris 2 ld always supports -h. It also supports --soname for GNU
4009 # ld compatiblity since some Solaris 10 update.
4011 gcc_cv_ld_soname=yes
4012 ld_soname_option='-h'
4016 # Don't AC_DEFINE result, only used in jit/Make-lang.in so far.
4017 AC_MSG_RESULT($gcc_cv_ld_soname)
4018 AC_SUBST(ld_soname_option)
4020 if test x"$demangler_in_ld" = xyes; then
4021 AC_MSG_CHECKING(linker --demangle support)
4022 gcc_cv_ld_demangle=no
4023 if test $in_tree_ld = yes; then
4024 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 \
4025 gcc_cv_ld_demangle=yes
4027 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
4028 # Check if the GNU linker supports --demangle option
4029 if $gcc_cv_ld --help 2>&1 | grep no-demangle > /dev/null; then
4030 gcc_cv_ld_demangle=yes
4033 if test x"$gcc_cv_ld_demangle" = xyes; then
4034 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
4035 [Define if your linker supports --demangle option.])
4037 AC_MSG_RESULT($gcc_cv_ld_demangle)
4040 AC_MSG_CHECKING(linker plugin support)
4042 if test -f liblto_plugin.la; then
4043 save_ld_ver="$ld_ver"
4044 save_ld_vers_major="$ld_vers_major"
4045 save_ld_vers_minor="$ld_vers_minor"
4046 save_ld_is_gold="$ld_is_gold"
4050 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
4052 # FIXME: ld_is_gold?
4053 ld_vers_major="$gcc_cv_gld_major_version"
4054 ld_vers_minor="$gcc_cv_gld_minor_version"
4056 # Determine plugin linker version.
4057 # FIXME: Partial duplicate from above, generalize.
4059 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
4060 if echo "$ld_ver" | grep GNU > /dev/null; then
4061 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
4063 ld_vers=`echo $ld_ver | sed -n \
4064 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
4066 ld_vers=`echo $ld_ver | sed -n \
4067 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
4069 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
4070 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
4075 # Determine plugin support.
4076 if echo "$ld_ver" | grep GNU > /dev/null; then
4077 # Require GNU ld or gold 2.21+ for plugin support by default.
4078 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
4080 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
4081 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
4086 ld_ver="$save_ld_ver"
4087 ld_vers_major="$save_ld_vers_major"
4088 ld_vers_minor="$save_ld_vers_minor"
4089 ld_is_gold="$save_ld_is_gold"
4091 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
4092 [Define to the level of your linker's plugin support.])
4093 AC_MSG_RESULT($gcc_cv_lto_plugin)
4095 # Target OS-specific assembler checks.
4097 case "$target_os" in
4099 gcc_GAS_CHECK_FEATURE([-mmacosx-version-min option],
4100 gcc_cv_as_mmacosx_version_min,,
4101 [-mmacosx-version-min=10.1], [.text],,
4102 [AC_DEFINE(HAVE_AS_MMACOSX_VERSION_MIN_OPTION, 1,
4103 [Define if your Mac OS X assembler supports the -mmacos-version-min option.])])
4107 # Target CPU-specific assembler checks.
4111 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
4112 [-mabi=lp64], [.text],,,)
4113 if test x$gcc_cv_as_aarch64_mabi = xyes; then
4114 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
4115 [Define if your assembler supports the -mabi option.])
4117 if test x$with_abi = xilp32; then
4118 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4119 Upgrade the Assembler.])
4121 if test x"$with_multilib_list" = xdefault; then
4122 TM_MULTILIB_CONFIG=lp64
4124 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
4125 for aarch64_multilib in ${aarch64_multilibs}; do
4126 case ${aarch64_multilib} in
4128 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
4129 Upgrade the Assembler.])
4137 # Check if we have binutils support for relocations types needed by -fpic
4138 gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,,
4141 ldr x0, [[x2, #:gotpage_lo15:globalsym]]
4142 ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1,
4143 [Define if your assembler supports relocs needed by -fpic.])])
4144 # Enable Branch Target Identification Mechanism and Return Address
4145 # Signing by default.
4146 AC_ARG_ENABLE(standard-branch-protection,
4148 AS_HELP_STRING([--enable-standard-branch-protection],
4149 [enable Branch Target Identification Mechanism and Return Address Signing by default for AArch64])
4150 AS_HELP_STRING([--disable-standard-branch-protection],
4151 [disable Branch Target Identification Mechanism and Return Address Signing by default for AArch64])
4156 tm_defines="${tm_defines} TARGET_ENABLE_BTI=1 TARGET_ENABLE_PAC_RET=1"
4161 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-standard-branch-protection.\
4162 Valid choices are 'yes' and 'no'.])
4167 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
4168 AC_ARG_ENABLE(fix-cortex-a53-835769,
4170 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
4171 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4172 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
4173 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
4178 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
4183 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
4184 Valid choices are 'yes' and 'no'.])
4190 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
4191 AC_ARG_ENABLE(fix-cortex-a53-843419,
4193 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
4194 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4195 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
4196 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
4201 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
4206 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
4207 Valid choices are 'yes' and 'no'.])
4215 # All TARGET_ABI_OSF targets.
4216 alpha*-*-linux* | alpha*-*-*bsd*)
4217 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4218 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
4221 extbl $3, $2, $3 !lituse_bytoff!1
4222 ldq $2, a($29) !literal!1
4223 ldq $4, b($29) !literal!2
4224 ldq_u $3, 0($2) !lituse_base!1
4225 ldq $27, f($29) !literal!5
4226 jsr $26, ($27), f !lituse_jsr!5
4227 ldah $29, 0($26) !gpdisp!3
4228 lda $0, c($29) !gprel
4229 ldah $1, d($29) !gprelhigh
4230 lda $1, d($1) !gprellow
4231 lda $29, 0($29) !gpdisp!3],,
4232 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
4233 [Define if your assembler supports explicit relocations.])])
4234 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
4235 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
4238 ldq $27, a($29) !literal!1
4239 jsr $26, ($27), a !lituse_jsrdirect!1],,
4240 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
4241 [Define if your assembler supports the lituse_jsrdirect relocation.])])
4245 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,,
4246 [--mlink-relax], [.text],,
4247 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
4248 [Define if your avr assembler supports --mlink-relax option.])])
4250 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,,
4252 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
4253 [Define if your avr assembler supports -mrmw option.])])
4255 gcc_GAS_CHECK_FEATURE([__gcc_isr pseudo instruction],
4256 gcc_cv_as_avr_mgccisr,,
4262 [AC_DEFINE(HAVE_AS_AVR_MGCCISR_OPTION, 1,
4263 [Define if your avr assembler supports -mgcc-isr option.])])
4265 # Check how default linker description file implements .rodata for
4266 # avrxmega3 (PR21472). avr-gcc assumes .rodata is *not* loaded to
4267 # RAM so avr-gcc skips __do_copy_data for .rodata objects.
4268 AC_MSG_CHECKING(binutils for avrxmega3 .rodata support)
4269 cat > conftest.s <<EOF
4270 .section .rodata,"a",@progbits
4272 ;; avr-nm should print "... R xxvaryy", not "... D xxvaryy".
4277 AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega3 conftest.s -o conftest.o])
4278 AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega3 conftest.o -o conftest.elf])
4279 AC_TRY_COMMAND([$gcc_cv_nm conftest.elf > conftest.nm])
4280 if test -s conftest.nm
4282 if grep ' R xxvaryy' conftest.nm > /dev/null; then
4284 AC_DEFINE(HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH, 1,
4285 [Define if your default avr linker script for avrxmega3 leaves .rodata in flash.])
4287 AC_MSG_RESULT(no: avrxmega3 .rodata located in RAM)
4288 echo "$as_me: nm output was" >&AS_MESSAGE_LOG_FD
4289 cat conftest.nm >&AS_MESSAGE_LOG_FD
4290 avr_ld_ver="`$gcc_cv_ld -v | sed -e 's:^.* ::'`"
4291 AC_MSG_WARN([[support for avrxmega3 .rodata in flash needs Binutils 2.29 or higher (have $avr_ld_ver)]])
4294 AC_MSG_RESULT(test failed)
4295 echo "$as_me: failed program was" >&AS_MESSAGE_LOG_FD
4296 cat conftest.s >&AS_MESSAGE_LOG_FD
4297 AC_MSG_WARN([[see `config.log' for details]])
4299 rm -f conftest.s conftest.o conftest.elf conftest.nm
4303 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
4304 gcc_cv_as_cris_no_mul_bug,[2,15,91],
4305 [-no-mul-bug-abort], [.text],,
4306 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
4307 [Define if your assembler supports the -no-mul-bug-abort option.])])
4311 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
4313 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
4314 [Define if your assembler supports -relax option.])])
4316 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
4317 gcc_cv_as_sparc_gotdata_op,,
4324 sethi %gdop_hix22(foo), %g1
4325 xor %g1, %gdop_lox10(foo), %g1
4326 ld [[%l7 + %g1]], %g2, %gdop(foo)],
4327 [if test x$gcc_cv_ld != x \
4328 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4329 if test x$gcc_cv_objdump != x; then
4330 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
4331 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
4332 gcc_cv_as_sparc_gotdata_op=no
4334 gcc_cv_as_sparc_gotdata_op=yes
4339 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
4340 [Define if your assembler and linker support GOTDATA_OP relocs.])])
4342 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
4343 gcc_cv_as_sparc_ua_pcrel,,
4351 .uaword %r_disp32(foo)],
4352 [if test x$gcc_cv_ld != x \
4353 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4354 gcc_cv_as_sparc_ua_pcrel=yes
4357 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
4358 [Define if your assembler and linker support unaligned PC relative relocs.])
4360 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
4361 gcc_cv_as_sparc_ua_pcrel_hidden,,
4366 .uaword %r_disp32(foo)
4367 .byte 0x32, 0x33, 0x34
4372 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4373 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
4374 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
4375 | grep ' 31000000 07323334' > /dev/null 2>&1; then
4376 if $gcc_cv_objdump -R conftest 2> /dev/null \
4377 | grep 'DISP32' > /dev/null 2>&1; then
4380 gcc_cv_as_sparc_ua_pcrel_hidden=yes
4384 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
4385 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
4386 ]) # unaligned pcrel relocs
4388 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
4389 gcc_cv_as_sparc_offsetable_lo10,,
4392 or %g1, %lo(ab) + 12, %g1
4393 or %g1, %lo(ab + 12), %g1],
4394 [if test x$gcc_cv_objdump != x \
4395 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
4396 | grep ' 82106000 82106000' > /dev/null 2>&1; then
4397 gcc_cv_as_sparc_offsetable_lo10=yes
4399 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
4400 [Define if your assembler supports offsetable %lo().])])
4402 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
4403 gcc_cv_as_sparc_fmaf,,
4406 .register %g2, #scratch
4407 .register %g3, #scratch
4409 fmaddd %f0, %f2, %f4, %f6
4410 addxccc %g1, %g2, %g3
4411 fsrl32 %f2, %f4, %f8
4412 fnaddd %f10, %f12, %f14],,
4413 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
4414 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
4416 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
4417 gcc_cv_as_sparc_sparc4,,
4420 .register %g2, #scratch
4421 .register %g3, #scratch
4424 1: cwbneg %g2, %g3, 1f
4427 aes_kexpand0 %f4, %f6, %f8
4428 des_round %f38, %f40, %f42, %f44
4429 camellia_f %f54, %f56, %f58, %f60
4430 kasumi_fi_xor %f46, %f48, %f50, %f52],,
4431 [AC_DEFINE(HAVE_AS_SPARC4, 1,
4432 [Define if your assembler supports SPARC4 instructions.])])
4434 gcc_GAS_CHECK_FEATURE([SPARC5 and VIS 4.0 instructions],
4435 gcc_cv_as_sparc_sparc5,,
4438 .register %g2, #scratch
4439 .register %g3, #scratch
4442 fpadd8 %f0, %f2, %f4],,
4443 [AC_DEFINE(HAVE_AS_SPARC5_VIS4, 1,
4444 [Define if your assembler supports SPARC5 and VIS 4.0 instructions.])])
4446 gcc_GAS_CHECK_FEATURE([SPARC6 instructions],
4447 gcc_cv_as_sparc_sparc6,,
4450 .register %g2, #scratch
4451 .register %g3, #scratch
4454 fpsll64x %f0, %f2, %f4],,
4455 [AC_DEFINE(HAVE_AS_SPARC6, 1,
4456 [Define if your assembler supports SPARC6 instructions.])])
4458 gcc_GAS_CHECK_FEATURE([LEON instructions],
4459 gcc_cv_as_sparc_leon,,
4462 .register %g2, #scratch
4463 .register %g3, #scratch
4467 casa [[%g2]] 0xb, %g3, %g1],,
4468 [AC_DEFINE(HAVE_AS_LEON, 1,
4469 [Define if your assembler supports LEON instructions.])])
4473 i[34567]86-*-* | x86_64-*-*)
4477 # Full C++ conformance when using a shared libstdc++-v3 requires some
4478 # support from the Cygwin DLL, which in more recent versions exports
4479 # wrappers to aid in interposing and redirecting operators new, delete,
4480 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
4481 # are configuring for a version of Cygwin that exports the wrappers.
4482 if test x$host = x$target && test x$host_cpu = xi686; then
4483 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
4485 # Can't check presence of libc functions during cross-compile, so
4486 # we just have to assume we're building for an up-to-date target.
4487 gcc_ac_cygwin_dll_wrappers=yes
4489 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
4490 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
4491 [Define if you want to generate code by default that assumes that the
4492 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
4495 cygwin* | pe | mingw32*)
4496 # Recent binutils allows the three-operand form of ".comm" on PE. This
4497 # definition is used unconditionally to initialise the default state of
4498 # the target option variable that governs usage of the feature.
4499 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
4500 [2,19,52],,[.comm foo,1,32])
4501 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
4502 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
4503 [Define if your assembler supports specifying the alignment
4504 of objects allocated using the GAS .comm command.])
4505 # Used for DWARF 2 in PE
4506 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
4507 gcc_cv_as_ix86_pe_secrel32,
4513 [if test x$gcc_cv_ld != x \
4514 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
4515 gcc_cv_as_ix86_pe_secrel32=yes
4518 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
4519 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
4520 # Test if the assembler supports the extended form of the .section
4521 # directive that specifies section alignment. LTO support uses this,
4522 # but normally only after installation, so we warn but don't fail the
4523 # configure if LTO is enabled but the assembler does not support it.
4524 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
4525 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
4526 if test x$gcc_cv_as_section_has_align != xyes; then
4527 case ",$enable_languages," in
4529 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
4536 gcc_GAS_CHECK_FEATURE([-xbrace_comment], gcc_cv_as_ix86_xbrace_comment,,
4537 [-xbrace_comment=no], [.text],,
4538 [AC_DEFINE(HAVE_AS_XBRACE_COMMENT_OPTION, 1,
4539 [Define if your assembler supports -xbrace_comment option.])])
4541 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
4542 gcc_cv_as_ix86_filds,,,
4543 [filds (%ebp); fists (%ebp)],,
4544 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
4545 [Define if your assembler uses filds and fists mnemonics.])])
4547 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
4548 gcc_cv_as_ix86_fildq,,,
4549 [fildq (%ebp); fistpq (%ebp)],,
4550 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
4551 [Define if your assembler uses fildq and fistq mnemonics.])])
4553 gcc_GAS_CHECK_FEATURE([cmov syntax],
4554 gcc_cv_as_ix86_cmov_sun_syntax,,,
4555 [cmovl.l %edx, %eax],,
4556 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
4557 [Define if your assembler supports the Sun syntax for cmov.])])
4559 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
4560 gcc_cv_as_ix86_ffreep,,,
4562 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
4563 [Define if your assembler supports the ffreep mnemonic.])])
4565 gcc_GAS_CHECK_FEATURE([.quad directive],
4566 gcc_cv_as_ix86_quad,,,
4568 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
4569 [Define if your assembler supports the .quad directive.])])
4571 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
4572 gcc_cv_as_ix86_sahf,,,
4575 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
4576 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
4578 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
4579 gcc_cv_as_ix86_interunit_movq,,,
4583 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
4584 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
4585 [Define if your assembler supports interunit movq mnemonic.])
4587 gcc_GAS_CHECK_FEATURE([hle prefixes],
4588 gcc_cv_as_ix86_hle,,,
4589 [lock xacquire cmpxchg %esi, (%ecx)],,
4590 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
4591 [Define if your assembler supports HLE prefixes.])])
4593 gcc_GAS_CHECK_FEATURE([swap suffix],
4594 gcc_cv_as_ix86_swap,,,
4595 [movl.s %esp, %ebp],,
4596 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
4597 [Define if your assembler supports the swap suffix.])])
4599 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
4600 gcc_cv_as_ix86_diff_sect_delta,,,
4608 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4609 [Define if your assembler supports the subtraction of symbols in different sections.])])
4611 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4612 gcc_cv_as_ix86_rep_lock_prefix,,,
4618 lock addl %edi, (%eax,%esi)
4619 lock orl $0, (%esp)],,
4620 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4621 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4623 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4624 gcc_cv_as_ix86_ud2,,,
4626 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4627 [Define if your assembler supports the 'ud2' mnemonic.])])
4629 # Enforce 32-bit output with gas and gld.
4630 if test x$gas = xyes; then
4631 as_ix86_gas_32_opt="--32"
4633 if echo "$ld_ver" | grep GNU > /dev/null; then
4634 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4635 ld_ix86_gld_32_opt="-melf_i386_sol2"
4637 ld_ix86_gld_32_opt="-melf_i386"
4641 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4642 gcc_cv_as_ix86_tlsgdplt,,
4643 [$as_ix86_gas_32_opt],
4644 [call tls_gd@tlsgdplt],
4645 [if test x$gcc_cv_ld != x \
4646 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4647 gcc_cv_as_ix86_tlsgdplt=yes
4650 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4651 [Define if your assembler and linker support @tlsgdplt.])])
4654 .section .tdata,"aw'$tls_section_flag'",@progbits
4656 .section .text,"ax",@progbits
4657 call tls_ld@tlsldmplt'
4659 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4660 gcc_cv_as_ix86_tlsldmplt,,
4661 [$as_ix86_gas_32_opt],
4663 [if test x$gcc_cv_ld != x \
4664 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then
4665 gcc_cv_as_ix86_tlsldmplt=yes
4668 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4669 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4670 [Define to 1 if your assembler and linker support @tlsldmplt.])
4673 .section .text,"ax",@progbits
4675 .type _start, @function
4677 leal value@tlsldm(%ebx), %eax
4678 call ___tls_get_addr@plt
4680 .section .tdata,"aw'$tls_section_flag'",@progbits
4681 .type value, @object
4683 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4684 gcc_cv_as_ix86_tlsldm,,
4685 [$as_ix86_gas_32_opt],
4687 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4688 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4689 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4690 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4691 gcc_cv_as_ix86_tlsldm=yes
4695 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4696 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4697 [Define to 1 if your assembler and linker support @tlsldm.])
4708 gcc_GAS_CHECK_FEATURE([R_386_GOT32X reloc],
4709 gcc_cv_as_ix86_got32x,,
4710 [$as_ix86_gas_32_opt],
4712 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4713 && test x$gcc_cv_readelf != x \
4714 && $gcc_cv_readelf --relocs --wide conftest.o 2>&1 \
4715 | grep R_386_GOT32X > /dev/null 2>&1 \
4716 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
4717 if $gcc_cv_objdump -dw conftest 2>&1 \
4718 | grep 0xffffff > /dev/null 2>&1; then
4719 gcc_cv_as_ix86_got32x=no
4721 gcc_cv_as_ix86_got32x=yes
4725 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_GOT32X,
4726 [`if test x"$gcc_cv_as_ix86_got32x" = xyes; then echo 1; else echo 0; fi`],
4727 [Define 0/1 if your assembler and linker support @GOT.])
4729 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
4730 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
4731 [$as_ix86_gas_32_opt],
4737 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
4738 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
4739 [Define true if the assembler supports '.long foo@GOTOFF'.])
4742 .section .text,"ax",@progbits
4744 .type _start, @function
4746 leal ld@tlsldm(%ecx), %eax
4747 call *___tls_get_addr@GOT(%ecx)
4748 leal gd@tlsgd(%ecx), %eax
4749 call *___tls_get_addr@GOT(%ecx)
4751 .section .tdata,"aw'$tls_section_flag'",@progbits
4759 gcc_GAS_CHECK_FEATURE([calling ___tls_get_addr via GOT],
4760 gcc_cv_as_ix86_tls_get_addr_via_got,,
4761 [$as_ix86_gas_32_opt],
4763 [if test x$gcc_cv_ld != x \
4764 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then
4765 gcc_cv_as_ix86_tls_get_addr_via_got=yes
4768 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLS_GET_ADDR_GOT,
4769 [`if test x"$gcc_cv_as_ix86_tls_get_addr_via_got" = xyes; then echo 1; else echo 0; fi`],
4770 [Define 0/1 if your assembler and linker support calling ___tls_get_addr via GOT.])
4774 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4775 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4777 addl r15 = @ltoffx(x#), gp
4779 ld8.mov r16 = [[r15]], x#
4781 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4782 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4790 gcc_GAS_CHECK_FEATURE([.machine directive support],
4791 gcc_cv_as_machine_directive,,,
4792 [ .machine ppc7400])
4793 if test x$gcc_cv_as_machine_directive != xyes; then
4794 echo "*** This target requires an assembler supporting \".machine\"" >&2
4795 echo you can get it from: https://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4796 test x$build = x$target && exit 1
4802 *-*-aix*) conftest_s=' .machine "pwr5"
4805 *-*-darwin*) conftest_s=' .text
4807 *) conftest_s=' .machine power4
4812 gcc_GAS_CHECK_FEATURE([mfcr field support],
4813 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4815 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4816 [Define if your assembler supports mfcr field.])])
4819 *-*-aix*) conftest_s=' .csect .text[[PR]]
4821 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4825 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4826 *) conftest_s=' .text
4828 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4831 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4832 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4834 [AC_DEFINE(HAVE_AS_REL16, 1,
4835 [Define if your assembler supports R_PPC_REL16 relocs.])])
4838 *-*-aix*) conftest_s=' .machine "pwr7"
4841 *) conftest_s=' .machine power7
4846 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4847 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4849 [AC_DEFINE(HAVE_AS_VSX, 1,
4850 [Define if your assembler supports VSX instructions.])])
4852 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4853 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4854 [.gnu_attribute 4,1],,
4855 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4856 [Define if your assembler supports .gnu_attribute.])])
4858 gcc_GAS_CHECK_FEATURE([prologue entry point marker support],
4859 gcc_cv_as_powerpc_entry_markers, [2,26,0],-a64 --fatal-warnings,
4860 [ .reloc .,R_PPC64_ENTRY; nop],,
4861 [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1,
4862 [Define if your assembler supports the R_PPC64_ENTRY relocation.])])
4864 gcc_GAS_CHECK_FEATURE([plt sequence marker support],
4865 gcc_cv_as_powerpc_pltseq_markers, [2,31,0],-a32 --fatal-warnings,
4866 [ .reloc .,R_PPC_PLTSEQ; nop],,
4867 [AC_DEFINE(HAVE_AS_PLTSEQ, 1,
4868 [Define if your assembler supports R_PPC*_PLTSEQ relocations.])])
4872 gcc_GAS_CHECK_FEATURE([AIX .ref support],
4873 gcc_cv_as_aix_ref, [2,21,0],,
4874 [ .csect stuff[[rw]]
4880 [AC_DEFINE(HAVE_AS_REF, 1,
4881 [Define if your assembler supports .ref])])
4883 gcc_GAS_CHECK_FEATURE([AIX DWARF location lists section support],
4884 gcc_cv_as_aix_dwloc, [2,21,0],,
4889 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
4890 [Define if your assembler supports AIX debug frame section label reference.])])
4896 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4897 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4898 [ lw $4,%gp_rel(foo)($4)],,
4899 [if test x$target_cpu_default = x
4900 then target_cpu_default=MASK_EXPLICIT_RELOCS
4901 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4904 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4905 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4906 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4907 [Define if the assembler understands -mno-shared.])])
4909 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4910 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4911 [.gnu_attribute 4,1],,
4912 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4913 [Define if your assembler supports .gnu_attribute.])])
4915 gcc_GAS_CHECK_FEATURE([.module support],
4916 gcc_cv_as_mips_dot_module,,[-32],
4919 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4920 [Define if your assembler supports .module.])])
4921 if test x$gcc_cv_as_mips_dot_module = xno \
4922 && test x$with_fp_32 != x; then
4924 [Requesting --with-fp-32= requires assembler support for .module.])
4927 gcc_GAS_CHECK_FEATURE([.micromips support],
4928 gcc_cv_as_micromips_support,,[--fatal-warnings],
4930 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4931 [Define if your assembler supports the .set micromips directive])])
4933 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4934 gcc_cv_as_mips_dtprelword, [2,18,0],,
4935 [.section .tdata,"awT",@progbits
4939 .dtprelword x+0x8000],,
4940 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4941 [Define if your assembler supports .dtprelword.])])
4943 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4944 gcc_cv_as_mips_dspr1_mult,,,
4954 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4955 [Define if your assembler supports DSPR1 mult.])])
4957 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4958 gcc_cv_as_ld_jalr_reloc=no
4959 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4960 if test $in_tree_ld = yes ; then
4961 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 \
4962 && test $in_tree_ld_is_elf = yes; then
4963 gcc_cv_as_ld_jalr_reloc=yes
4965 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4966 echo ' .ent x' > conftest.s
4967 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4968 echo ' lw $25,%call16(y)($28)' >> conftest.s
4969 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4970 echo '1: jalr $25' >> conftest.s
4971 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4972 echo '1: jalr $25' >> conftest.s
4973 echo ' .end x' >> conftest.s
4974 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4975 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4976 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4977 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4978 gcc_cv_as_ld_jalr_reloc=yes
4984 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4985 if test x$target_cpu_default = x; then
4986 target_cpu_default=MASK_RELAX_PIC_CALLS
4988 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4991 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4993 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4994 [gcc_cv_ld_mips_personality_relaxation],
4995 [gcc_cv_ld_mips_personality_relaxation=no
4996 if test $in_tree_ld = yes ; then
4997 if test "$gcc_cv_gld_major_version" -eq 2 \
4998 -a "$gcc_cv_gld_minor_version" -ge 21 \
4999 -o "$gcc_cv_gld_major_version" -gt 2; then
5000 gcc_cv_ld_mips_personality_relaxation=yes
5002 elif test x$gcc_cv_as != x \
5003 -a x$gcc_cv_ld != x \
5004 -a x$gcc_cv_readelf != x ; then
5005 cat > conftest.s <<EOF
5007 .cfi_personality 0x80,indirect_ptr
5014 .section .data,"aw",@progbits
5018 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
5019 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
5020 if $gcc_cv_readelf -d conftest 2>&1 \
5021 | grep TEXTREL > /dev/null 2>&1; then
5023 elif $gcc_cv_readelf --relocs conftest 2>&1 \
5024 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
5027 gcc_cv_ld_mips_personality_relaxation=yes
5031 rm -f conftest.s conftest.o conftest])
5032 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
5033 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
5034 [Define if your linker can relax absolute .eh_frame personality
5035 pointers into PC-relative form.])
5038 gcc_GAS_CHECK_FEATURE([-mnan= support],
5039 gcc_cv_as_mips_nan,,
5041 [AC_DEFINE(HAVE_AS_NAN, 1,
5042 [Define if the assembler understands -mnan=.])])
5043 if test x$gcc_cv_as_mips_nan = xno \
5044 && test x$with_nan != x; then
5046 [Requesting --with-nan= requires assembler support for -mnan=])
5050 # Earlier GAS versions generically support .gnu_attribute, but the
5051 # msp430 assembler will not do anything with it.
5052 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5053 gcc_cv_as_msp430_gnu_attribute, [2,33,50],,
5054 [.gnu_attribute 4,1],,
5055 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5056 [Define if your assembler supports .gnu_attribute.])])
5057 gcc_GAS_CHECK_FEATURE([.mspabi_attribute support],
5058 gcc_cv_as_msp430_mspabi_attribute, [2,33,50],,
5059 [.mspabi_attribute 4,1],,
5060 [AC_DEFINE(HAVE_AS_MSPABI_ATTRIBUTE, 1,
5061 [Define if your assembler supports .mspabi_attribute.])])
5062 if test x$enable_newlib_nano_formatted_io = xyes; then
5063 AC_DEFINE(HAVE_NEWLIB_NANO_FORMATTED_IO, 1, [Define if GCC has been
5064 configured with --enable-newlib-nano-formatted-io.])
5068 # Versions 2.33 and earlier lacked support for the %gotoff relocation
5069 # syntax that is documented in the ABI specification.
5070 gcc_GAS_CHECK_FEATURE([support for %gotoff relocations in constant data],
5071 gcc_cv_as_nios2_gotoff_relocation,,,
5074 .long %gotoff(foo)],,
5075 [AC_DEFINE(HAVE_AS_NIOS2_GOTOFF_RELOCATION, 1,
5076 [Define if your assembler supports %gotoff relocation syntax.])])
5079 gcc_GAS_CHECK_FEATURE([.attribute support],
5080 gcc_cv_as_riscv_attribute, [2,32,0],,
5081 [.attribute stack_align,4],,
5082 [AC_DEFINE(HAVE_AS_RISCV_ATTRIBUTE, 1,
5083 [Define if your assembler supports .attribute.])])
5086 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
5087 gcc_cv_as_s390_gnu_attribute, [2,18,0],,
5088 [.gnu_attribute 8,1],,
5089 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
5090 [Define if your assembler supports .gnu_attribute.])])
5091 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
5092 gcc_cv_as_s390_machine_machinemode, [2,24,0],,
5097 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
5098 [Define if your assembler supports .machine and .machinemode.])])
5099 gcc_GAS_CHECK_FEATURE([architecture modifiers support],
5100 gcc_cv_as_s390_architecture_modifiers, [2,26,0],,
5101 [ .machine z13+vx ],,
5102 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
5103 [Define if your assembler supports architecture modifiers.])])
5104 gcc_GAS_CHECK_FEATURE([vector load/store alignment hints],
5105 gcc_cv_as_s390_vector_loadstore_alignment_hints, [2,31,0],,
5106 [ vl %v24,0(%r15),3 ],,
5107 [AC_DEFINE(HAVE_AS_VECTOR_LOADSTORE_ALIGNMENT_HINTS, 1,
5108 [Define if your assembler supports vl/vst/vlm/vstm with an optional alignment hint argument.])])
5113 # Mips and HP-UX need the GNU assembler.
5114 # Linux on IA64 might be able to use the Intel assembler.
5117 mips*-*-* | *-*-hpux* )
5118 if test x$gas_flag = xyes \
5119 || test x"$host" != x"$build" \
5120 || test ! -x "$gcc_cv_as" \
5121 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
5124 echo "*** This configuration requires the GNU assembler" >&2
5130 # ??? Not all targets support dwarf2 debug_line, even within a version
5131 # of gas. Moreover, we need to emit a valid instruction to trigger any
5132 # info to the output file. So, as supported targets are added to gas 2.11,
5133 # add some instruction here to (also) show we expect this might work.
5134 # ??? Once 2.11 is released, probably need to add first known working
5135 # version to the per-target configury.
5137 aarch64 | alpha | arc | arm | avr | bfin | cris | csky | i386 | m32c | m68k \
5138 | microblaze | mips | nds32 | nios2 | pa | riscv | rs6000 | score | sparc \
5139 | tilegx | tilepro | visium | xstormy16 | xtensa)
5149 if test x"$insn" != x; then
5151 .file 1 \"conftest.s\"
5154 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
5155 gcc_cv_as_dwarf2_debug_line,
5156 [elf,2,11,0],, [$conftest_s],
5157 [if test x$gcc_cv_objdump != x \
5158 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
5159 | grep debug_line > /dev/null 2>&1; then
5160 gcc_cv_as_dwarf2_debug_line=yes
5161 elif test x$gcc_cv_otool != x \
5162 && $gcc_cv_otool -l conftest.o 2> /dev/null \
5163 | grep debug_line > /dev/null 2>&1; then
5164 gcc_cv_as_dwarf2_debug_line=yes
5167 # The .debug_line file table must be in the exact order that
5168 # we specified the files, since these indices are also used
5169 # by DW_AT_decl_file. Approximate this test by testing if
5170 # the assembler bitches if the same index is assigned twice.
5171 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
5172 gcc_cv_as_dwarf2_file_buggy,,,
5176 if test $gcc_cv_as_dwarf2_debug_line = yes \
5177 && test $gcc_cv_as_dwarf2_file_buggy = no; then
5178 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
5179 [Define if your assembler supports dwarf2 .file/.loc directives,
5180 and preserves file table indices exactly as given.])
5182 if test $gcc_cv_as_leb128 = yes; then
5184 .file 1 \"conftest.s\"
5185 .loc 1 3 0 view .LVU1
5191 gcc_GAS_CHECK_FEATURE([dwarf2 debug_view support],
5192 gcc_cv_as_dwarf2_debug_view,
5193 [elf,2,27,0],,[$conftest_s],,
5194 [AC_DEFINE(HAVE_AS_DWARF2_DEBUG_VIEW, 1,
5195 [Define if your assembler supports views in dwarf2 .loc directives.])])
5199 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
5200 gcc_cv_as_gdwarf2_flag,
5201 [elf,2,11,0], [--gdwarf2], [$insn],,
5202 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
5203 [Define if your assembler supports the --gdwarf2 option.])])
5205 gcc_GAS_CHECK_FEATURE([--gstabs option],
5206 gcc_cv_as_gstabs_flag,
5207 [elf,2,11,0], [--gstabs], [$insn],,
5208 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
5209 [Define if your assembler supports the --gstabs option.])])
5211 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
5212 gcc_cv_as_debug_prefix_map_flag,
5213 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
5214 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
5215 [Define if your assembler supports the --debug-prefix-map option.])])
5218 gcc_GAS_CHECK_FEATURE([compressed debug sections],
5219 gcc_cv_as_compress_debug,,,,
5220 [# gas compiled without zlib cannot compress debug sections and warns
5221 # about it, but still exits successfully. So check for this, too.
5222 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
5224 gcc_cv_as_compress_debug=0
5225 # Since binutils 2.26, gas supports --compress-debug-sections=type,
5226 # defaulting to the ELF gABI format.
5227 elif $gcc_cv_as --compress-debug-sections=zlib-gnu -o conftest.o conftest.s > /dev/null 2>&1
5229 gcc_cv_as_compress_debug=2
5230 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5231 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5232 # Before binutils 2.26, gas only supported --compress-debug-options and
5233 # emitted the traditional GNU format.
5234 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
5236 gcc_cv_as_compress_debug=1
5237 gcc_cv_as_compress_debug_option="--compress-debug-sections"
5238 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
5240 gcc_cv_as_compress_debug=0
5242 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
5243 [Define to the level of your assembler's compressed debug section support.])
5244 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
5245 [Define to the assembler option to enable compressed debug sections.])
5246 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
5247 [Define to the assembler option to disable compressed debug sections.])
5249 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
5252 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
5253 [Define if your assembler supports .lcomm with an alignment field.])])
5255 if test x$with_sysroot = x && test x$host = x$target \
5256 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
5257 && test "$prefix" != "NONE"; then
5258 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
5259 [Define to PREFIX/include if cpp should also search that directory.])
5262 # Determine the version of glibc, if any, used on the target.
5263 AC_MSG_CHECKING([for target glibc version])
5264 AC_ARG_WITH([glibc-version],
5265 [AS_HELP_STRING([--with-glibc-version=M.N],
5266 [assume GCC used with glibc version M.N or later])], [
5267 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
5268 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
5269 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
5271 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
5273 glibc_version_major=0
5274 glibc_version_minor=0
5275 [if test -f $target_header_dir/features.h \
5276 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
5277 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
5278 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
5279 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
5281 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
5282 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
5283 [GNU C Library major version number used on the target, or 0.])
5284 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
5285 [GNU C Library minor version number used on the target, or 0.])
5287 AC_ARG_ENABLE(gnu-unique-object,
5288 [AS_HELP_STRING([--enable-gnu-unique-object],
5289 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
5290 [case $enable_gnu_unique_object in
5292 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
5293 Valid choices are 'yes' and 'no'.]) ;;
5295 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
5297 [.type foo, '$target_type_format_char'gnu_unique_object],,
5298 # We need to unquote above to to use the definition from config.gcc.
5299 # Also check for ld.so support, i.e. glibc 2.11 or higher.
5300 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
5302 if test x$enable_gnu_unique_object = xyes; then
5303 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
5304 [Define if your assembler supports @gnu_unique_object.])
5307 AC_CACHE_CHECK([assembler for tolerance to line number 0],
5308 [gcc_cv_as_line_zero],
5309 [gcc_cv_as_line_zero=no
5310 if test $in_tree_gas = yes; then
5311 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
5312 elif test "x$gcc_cv_as" != x; then
5313 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
5314 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
5315 test "x`cat conftest.out`" = x
5317 gcc_cv_as_line_zero=yes
5319 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
5320 cat conftest.s >&AS_MESSAGE_LOG_FD
5321 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
5322 cat conftest.out >&AS_MESSAGE_LOG_FD
5324 rm -f conftest.o conftest.s conftest.out
5326 if test "x$gcc_cv_as_line_zero" = xyes; then
5327 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
5328 [Define if the assembler won't complain about a line such as # 0 "" 2.])
5331 AC_MSG_CHECKING(support for thin archives)
5332 thin_archive_support=no
5333 echo 'int main (void) { return 0; }' > conftest.c
5334 if ($AR --version | sed 1q | grep "GNU ar" \
5335 && $CC $CFLAGS -c conftest.c \
5336 && $AR rcT conftest.a conftest.o \
5337 && $CC $CFLAGS $LDFLAGS -o conftest conftest.a) >/dev/null 2>&1; then
5338 thin_archive_support=yes
5340 rm -f conftest.c conftest.o conftest.a conftest
5341 AC_MSG_RESULT($thin_archive_support)
5342 AC_SUBST(thin_archive_support)
5344 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
5345 gcc_cv_ld_eh_frame_hdr=no
5346 if test $in_tree_ld = yes ; then
5347 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 \
5348 && test $in_tree_ld_is_elf = yes; then
5349 gcc_cv_ld_eh_frame_hdr=yes
5351 elif test x$gcc_cv_ld != x; then
5352 if echo "$ld_ver" | grep GNU > /dev/null; then
5353 # Check if linker supports --eh-frame-hdr option
5354 if $gcc_cv_ld --help 2>&1 | grep eh-frame-hdr > /dev/null; then
5355 gcc_cv_ld_eh_frame_hdr=yes
5360 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
5361 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
5362 gcc_cv_ld_eh_frame_hdr=yes
5368 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
5369 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
5370 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
5371 [Define if your linker supports .eh_frame_hdr.])
5373 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
5375 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
5376 gcc_cv_ld_eh_frame_ciev3=no
5377 if test $in_tree_ld = yes ; then
5378 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 \
5379 && test $in_tree_ld_is_elf = yes; then
5380 gcc_cv_ld_eh_frame_ciev3=yes
5382 elif test x$gcc_cv_ld != x; then
5383 if echo "$ld_ver" | grep GNU > /dev/null; then
5384 gcc_cv_ld_eh_frame_ciev3=yes
5385 if test 0"$ld_date" -lt 20040513; then
5386 if test -n "$ld_date"; then
5387 # If there was date string, but was earlier than 2004-05-13, fail
5388 gcc_cv_ld_eh_frame_ciev3=no
5389 elif test "$ld_vers_major" -lt 2; then
5390 gcc_cv_ld_eh_frame_ciev3=no
5391 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
5392 gcc_cv_ld_eh_frame_ciev3=no
5398 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
5399 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
5400 gcc_cv_ld_eh_frame_ciev3=yes
5406 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
5407 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
5408 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
5409 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
5411 AC_MSG_CHECKING(linker position independent executable support)
5413 if test $in_tree_ld = yes ; then
5415 # Full PIE support on Solaris was only introduced in gld 2.26.
5416 *-*-solaris2*) gcc_gld_pie_min_version=26 ;;
5417 *) gcc_gld_pie_min_version=15 ;;
5419 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 \
5420 && test $in_tree_ld_is_elf = yes; then
5423 elif test x$gcc_cv_ld != x; then
5424 # Check if linker supports -pie option
5425 if $gcc_cv_ld --help 2>&1 | grep -- -pie > /dev/null; then
5429 if echo "$ld_ver" | grep GNU > /dev/null \
5430 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
5437 *-*-solaris2.1[[1-9]]*)
5438 # Solaris 11.3 added PIE support.
5439 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
5446 if test x"$gcc_cv_ld_pie" = xyes; then
5447 AC_DEFINE(HAVE_LD_PIE, 1,
5448 [Define if your linker supports PIE option.])
5450 AC_MSG_RESULT($gcc_cv_ld_pie)
5452 AC_MSG_CHECKING(linker PIE support with copy reloc)
5453 gcc_cv_ld_pie_copyreloc=no
5454 if test $gcc_cv_ld_pie = yes ; then
5455 if test $in_tree_ld = yes ; then
5456 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
5457 gcc_cv_ld_pie_copyreloc=yes
5459 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5460 # Check if linker supports -pie option with copy reloc
5462 i?86-*-linux* | x86_64-*-linux*)
5463 cat > conftest1.s <<EOF
5466 .type a_glob, @object
5471 cat > conftest2.s <<EOF
5474 .type main, @function
5476 movl %eax, a_glob(%rip)
5479 .section .data.rel,"aw",@progbits
5484 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5485 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
5486 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5487 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
5488 gcc_cv_ld_pie_copyreloc=yes
5490 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
5495 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
5496 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
5497 [Define 0/1 if your linker supports -pie option with copy reloc.])
5498 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
5500 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
5501 gcc_cv_ld_eh_gc_sections=no
5502 if test $in_tree_ld = yes ; then
5503 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 \
5504 && test $in_tree_ld_is_elf = yes; then
5505 gcc_cv_ld_eh_gc_sections=yes
5507 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
5508 cat > conftest.s <<EOF
5511 .type _start, @function
5514 .size _start, .-_start
5515 .section .text.foo,"ax",@progbits
5516 .type foo, @function
5520 .section .gcc_except_table.foo,"a",@progbits
5523 .section .eh_frame,"a",@progbits
5526 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5527 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5528 | grep "gc-sections option ignored" > /dev/null; then
5529 gcc_cv_ld_eh_gc_sections=no
5530 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5531 | grep gcc_except_table > /dev/null; then
5532 gcc_cv_ld_eh_gc_sections=yes
5533 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
5534 if test x$gcc_cv_as_comdat_group != xyes; then
5535 gcc_cv_ld_eh_gc_sections=no
5536 cat > conftest.s <<EOF
5539 .type _start, @function
5542 .size _start, .-_start
5543 .section .gnu.linkonce.t.foo,"ax",@progbits
5544 .type foo, @function
5548 .section .gcc_except_table.foo,"a",@progbits
5551 .section .eh_frame,"a",@progbits
5554 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5555 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5556 | grep "gc-sections option ignored" > /dev/null; then
5557 gcc_cv_ld_eh_gc_sections=no
5558 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5559 | grep gcc_except_table > /dev/null; then
5560 gcc_cv_ld_eh_gc_sections=yes
5566 rm -f conftest.s conftest.o conftest
5570 # ??? This apparently exposes a binutils bug with PC-relative relocations.
5571 gcc_cv_ld_eh_gc_sections=no
5574 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
5575 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
5576 [Define if your linker supports garbage collection of
5577 sections in presence of EH frames.])
5579 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
5581 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
5582 gcc_cv_ld_eh_gc_sections_bug=no
5583 if test $in_tree_ld = yes ; then
5584 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 \
5585 && test $in_tree_ld_is_elf = yes; then
5586 gcc_cv_ld_eh_gc_sections_bug=yes
5588 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
5589 gcc_cv_ld_eh_gc_sections_bug=yes
5590 cat > conftest.s <<EOF
5593 .type _start, @function
5596 .size _start, .-_start
5597 .section .text.startup.foo,"ax",@progbits
5598 .type foo, @function
5602 .section .gcc_except_table.foo,"a",@progbits
5605 .section .eh_frame,"a",@progbits
5608 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5609 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5610 | grep "gc-sections option ignored" > /dev/null; then
5612 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5613 | grep gcc_except_table > /dev/null; then
5614 gcc_cv_ld_eh_gc_sections_bug=no
5617 rm -f conftest.s conftest.o conftest
5619 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
5620 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
5621 [Define if your linker has buggy garbage collection of
5622 sections support when .text.startup.foo like sections are used.])
5624 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
5626 AC_MSG_CHECKING(linker for compressed debug sections)
5627 # gold/gld support compressed debug sections since binutils 2.19/2.21
5628 # In binutils 2.26, gld gained support for the ELF gABI format.
5629 if test $in_tree_ld = yes ; then
5630 gcc_cv_ld_compress_debug=0
5631 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 \
5632 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
5633 gcc_cv_ld_compress_debug=2
5634 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5635 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 \
5636 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = no; then
5637 gcc_cv_ld_compress_debug=3
5638 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5639 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 \
5640 && test $in_tree_ld_is_elf = yes; then
5641 gcc_cv_ld_compress_debug=1
5643 elif echo "$ld_ver" | grep GNU > /dev/null; then
5644 if test "$ld_vers_major" -lt 2 \
5645 || test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
5646 gcc_cv_ld_compress_debug=0
5647 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
5648 gcc_cv_ld_compress_debug=1
5650 gcc_cv_ld_compress_debug=3
5651 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5653 if test $ld_is_gold = yes; then
5654 gcc_cv_ld_compress_debug=2
5655 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5661 # Introduced in Solaris 11.2.
5662 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
5663 gcc_cv_ld_compress_debug=3
5664 gcc_cv_ld_compress_debug_option="-z compress-sections"
5666 gcc_cv_ld_compress_debug=0
5670 # Assume linkers other than GNU ld don't support compessed debug
5672 gcc_cv_ld_compress_debug=0
5677 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
5678 [Define to the level of your linker's compressed debug section support.])
5679 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
5680 [Define to the linker option to enable compressed debug sections.])
5681 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
5683 if test x"$ld64_flag" = x"yes"; then
5685 # Set defaults for possibly untestable items.
5686 gcc_cv_ld64_export_dynamic=0
5688 if test "$build" = "$host"; then
5694 # On Darwin, because of FAT library support, it is often possible to execute
5695 # exes from compatible archs even when the host differs from the build system.
5696 case "$build","$host" in
5697 x86_64-*-darwin*,i?86-*-darwin* | powerpc64*-*-darwin*,powerpc*-*-darwin*)
5702 # If the configurer specified a minimum ld64 version to be supported, then use
5703 # that to determine feature support.
5704 if test x"${gcc_cv_ld64_version}" != x; then
5705 AC_MSG_CHECKING(ld64 specified version)
5706 gcc_cv_ld64_major=`echo "$gcc_cv_ld64_version" | sed -e 's/\..*//'`
5707 AC_MSG_RESULT($gcc_cv_ld64_major)
5708 if test "$gcc_cv_ld64_major" -ge 236; then
5709 gcc_cv_ld64_export_dynamic=1
5711 elif test -x "$gcc_cv_ld" -a "$darwin_try_test" -eq 1; then
5712 # If the version was not specified, try to find it.
5713 AC_MSG_CHECKING(linker version)
5714 if test x"${gcc_cv_ld64_version}" = x; then
5715 gcc_cv_ld64_version=`$gcc_cv_ld -v 2>&1 | grep ld64 | sed s/.*ld64-// | awk '{print $1}'`
5717 AC_MSG_RESULT($gcc_cv_ld64_version)
5719 AC_MSG_CHECKING(linker for -export_dynamic support)
5720 gcc_cv_ld64_export_dynamic=1
5721 if $gcc_cv_ld -export_dynamic < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then
5722 gcc_cv_ld64_export_dynamic=0
5724 AC_MSG_RESULT($gcc_cv_ld64_export_dynamic)
5727 if test x"${gcc_cv_ld64_version}" != x; then
5728 AC_DEFINE_UNQUOTED(LD64_VERSION, "${gcc_cv_ld64_version}",
5729 [Define to ld64 version.])
5732 AC_DEFINE_UNQUOTED(LD64_HAS_EXPORT_DYNAMIC, $gcc_cv_ld64_export_dynamic,
5733 [Define to 1 if ld64 supports '-export_dynamic'.])
5740 AC_CACHE_CHECK(linker --as-needed support,
5741 gcc_cv_ld_as_needed,
5742 [gcc_cv_ld_as_needed=no
5743 gcc_cv_ld_as_needed_option='--as-needed'
5744 gcc_cv_ld_no_as_needed_option='--no-as-needed'
5745 if test $in_tree_ld = yes ; then
5746 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 \
5747 && test $in_tree_ld_is_elf = yes; then
5748 gcc_cv_ld_as_needed=yes
5749 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 28; then
5750 gcc_cv_ld_as_needed_option='--push-state --as-needed'
5751 gcc_cv_ld_no_as_needed_option='--pop-state'
5754 elif test x$gcc_cv_ld != x; then
5755 # Check if linker supports --as-needed and --no-as-needed options
5756 if $gcc_cv_ld --help 2>&1 | grep as-needed > /dev/null; then
5757 gcc_cv_ld_as_needed=yes
5758 if $gcc_cv_ld --help 2>&1 | grep push-state > /dev/null \
5759 && $gcc_cv_ld --help 2>&1 | grep pop-state > /dev/null \
5760 && echo "$ld_ver" | grep GNU > /dev/null \
5761 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 28; then
5762 # Use these options only when both ld.bfd and ld.gold support
5763 # --push-state/--pop-state, which unfortunately wasn't added
5765 gcc_cv_ld_as_needed_option='--push-state --as-needed'
5766 gcc_cv_ld_no_as_needed_option='--pop-state'
5769 case "$target:$gnu_ld" in
5771 # Solaris 2 ld always supports -z ignore/-z record. Prefer the native
5773 gcc_cv_ld_as_needed=yes
5774 gcc_cv_ld_as_needed_option="-z ignore"
5775 gcc_cv_ld_no_as_needed_option="-z record"
5779 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
5780 # dl_iterate_phdr, i.e. since Solaris 11.
5782 *-*-solaris2.1[[1-9]]*)
5784 i?86-*-* | x86_64-*-*)
5785 if echo "$ld_ver" | grep GNU > /dev/null; then
5786 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
5787 gcc_cv_ld_as_needed=no
5793 gcc_cv_ld_as_needed=no
5797 if test x"$gcc_cv_ld_as_needed" = xyes; then
5798 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
5799 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
5800 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
5801 [Define to the linker option to ignore unused dependencies.])
5802 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
5803 [Define to the linker option to keep unused dependencies.])
5806 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
5807 saved_LDFLAGS="$LDFLAGS"
5808 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
5809 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
5810 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
5811 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
5813 LDFLAGS="$saved_LDFLAGS"
5814 if test "x$gcc_cv_ld_clearcap" = xyes; then
5815 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
5816 [Define if the linker supports clearing hardware capabilities via mapfile.])
5817 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
5819 AC_MSG_RESULT($gcc_cv_ld_clearcap)
5825 emul_name="-melf32lppc"
5828 emul_name="-melf32ppc"
5831 AC_CACHE_CHECK(linker .gnu.attributes long double support,
5833 [gcc_cv_ld_ppc_attr=no
5834 if test x"$ld_is_gold" = xyes; then
5835 gcc_cv_ld_ppc_attr=yes
5836 elif test $in_tree_ld = yes ; then
5837 if test "$gcc_cv_gld_major_version" -eq 2 \
5838 -a "$gcc_cv_gld_minor_version" -ge 28 \
5839 -o "$gcc_cv_gld_major_version" -gt 2; then
5840 gcc_cv_ld_ppc_attr=yes
5842 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5843 # check that merging the long double .gnu_attribute doesn't warn
5844 cat > conftest1.s <<EOF
5847 cat > conftest2.s <<EOF
5850 if $gcc_cv_as -a32 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5851 && $gcc_cv_as -a32 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5852 && $gcc_cv_ld $emul_name -r -o conftest.o conftest1.o conftest2.o > /dev/null 2> conftest.err \
5853 && test ! -s conftest.err; then
5854 gcc_cv_ld_ppc_attr=yes
5856 rm -f conftest.err conftest.o conftest1.o conftest2.o conftest1.s conftest2.s
5859 if test x$gcc_cv_ld_ppc_attr = xyes; then
5860 AC_DEFINE(HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE, 1,
5861 [Define if your PowerPC linker has .gnu.attributes long double support.])
5866 case "$target:$tm_file" in
5867 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
5870 emul_name="-melf64lppc"
5873 emul_name="-melf64ppc"
5876 emul_name="-melf64ppc_fbsd"
5879 AC_CACHE_CHECK(linker support for omitting dot symbols,
5880 gcc_cv_ld_no_dot_syms,
5881 [gcc_cv_ld_no_dot_syms=no
5882 if test x"$ld_is_gold" = xyes; then
5883 gcc_cv_ld_no_dot_syms=yes
5884 elif test $in_tree_ld = yes ; then
5885 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
5886 gcc_cv_ld_no_dot_syms=yes
5888 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5889 cat > conftest1.s <<EOF
5893 cat > conftest2.s <<EOF
5894 .section ".opd","aw"
5899 .quad .LEfoo,.TOC.@tocbase,0
5905 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5906 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5907 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
5908 gcc_cv_ld_no_dot_syms=yes
5910 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
5913 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
5914 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
5915 [Define if your PowerPC64 linker only needs function descriptor syms.])
5918 AC_CACHE_CHECK(linker large toc support,
5919 gcc_cv_ld_large_toc,
5920 [gcc_cv_ld_large_toc=no
5921 if test x"$ld_is_gold" = xyes; then
5922 gcc_cv_ld_large_toc=yes
5923 elif test $in_tree_ld = yes ; then
5924 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
5925 gcc_cv_ld_large_toc=yes
5927 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5928 cat > conftest.s <<EOF
5929 .section ".tbss","awT",@nobits
5935 addis 9,13,ie0@got@tprel@ha
5936 ld 9,ie0@got@tprel@l(9)
5938 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5939 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5940 gcc_cv_ld_large_toc=yes
5942 rm -f conftest conftest.o conftest.s
5945 if test x"$gcc_cv_ld_large_toc" = xyes; then
5946 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5947 [Define if your PowerPC64 linker supports a large TOC.])
5950 AC_CACHE_CHECK(linker toc pointer alignment,
5951 gcc_cv_ld_toc_align,
5952 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
5953 cat > conftest.s <<EOF
5958 .section .data.rel.ro,"aw",@progbits
5963 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5964 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
5965 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)) }'`
5967 rm -f conftest conftest.o conftest.s
5970 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
5971 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
5972 [Define to .TOC. alignment forced by your linker.])
5979 AC_CACHE_CHECK(linker large toc support,
5980 gcc_cv_ld_large_toc,
5981 [gcc_cv_ld_large_toc=no
5982 if test x$gcc_cv_as != x ; then
5983 cat > conftest.s <<EOF
5993 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5994 gcc_cv_ld_large_toc=yes
5996 rm -f conftest conftest.o conftest.s
5999 if test x"$gcc_cv_ld_large_toc" = xyes; then
6000 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
6001 [Define if your PowerPC64 linker supports a large TOC.])
6006 AC_CACHE_CHECK(linker --build-id support,
6008 [gcc_cv_ld_buildid=no
6009 if test $in_tree_ld = yes ; then
6010 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6011 "$gcc_cv_gld_minor_version" -ge 18 -o \
6012 "$gcc_cv_gld_major_version" -gt 2 \
6013 && test $in_tree_ld_is_elf = yes; then
6014 gcc_cv_ld_buildid=yes
6016 elif test x$gcc_cv_ld != x; then
6017 if $gcc_cv_ld --help 2>&1 | grep build-id > /dev/null; then
6018 gcc_cv_ld_buildid=yes
6021 if test x"$gcc_cv_ld_buildid" = xyes; then
6022 AC_DEFINE(HAVE_LD_BUILDID, 1,
6023 [Define if your linker supports --build-id.])
6026 AC_ARG_ENABLE(linker-build-id,
6027 [AS_HELP_STRING([--enable-linker-build-id],
6028 [compiler will always pass --build-id to linker])],
6030 enable_linker_build_id=no)
6032 if test x"$enable_linker_build_id" = xyes; then
6033 if test x"$gcc_cv_ld_buildid" = xyes; then
6034 AC_DEFINE(ENABLE_LD_BUILDID, 1,
6035 [Define if gcc should always pass --build-id to linker.])
6037 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
6041 # In binutils 2.21, GNU ld gained support for new emulations fully
6042 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
6043 AC_CACHE_CHECK(linker *_sol2 emulation support,
6044 gcc_cv_ld_sol2_emulation,
6045 [gcc_cv_ld_sol2_emulation=no
6046 if test $in_tree_ld = yes ; then
6047 if test "$gcc_cv_gld_major_version" -eq 2 -a \
6048 "$gcc_cv_gld_minor_version" -ge 21 -o \
6049 "$gcc_cv_gld_major_version" -gt 2 \
6050 && test $in_tree_ld_is_elf = yes; then
6051 gcc_cv_ld_sol2_emulation=yes
6053 elif test x$gcc_cv_ld != x; then
6054 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
6055 grep _sol2 > /dev/null; then
6056 gcc_cv_ld_sol2_emulation=yes
6059 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
6060 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
6061 [Define if your linker supports the *_sol2 emulations.])
6064 AC_CACHE_CHECK(linker --sysroot support,
6066 [gcc_cv_ld_sysroot=no
6067 if test $in_tree_ld = yes ; then
6068 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
6069 gcc_cv_ld_sysroot=yes
6071 elif test x$gcc_cv_ld != x; then
6072 if $gcc_cv_ld --help 2>&1 | grep sysroot > /dev/null; then
6073 gcc_cv_ld_sysroot=yes
6076 if test x"$gcc_cv_ld_sysroot" = xyes; then
6077 AC_DEFINE(HAVE_LD_SYSROOT, 1,
6078 [Define if your linker supports --sysroot.])
6083 # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
6084 AC_CACHE_CHECK([system-provided CRTs on Solaris],
6085 gcc_cv_solaris_crts,
6086 [gcc_cv_solaris_crts=no
6087 if test x$host != x$target; then
6088 if test "x$with_sysroot" = xyes; then
6089 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
6091 target_sysroot="${with_sysroot}"
6094 target_libdir="$target_sysroot/usr/lib"
6095 # At the time they were added, gcrt1.o became a symlink for backwards
6096 # compatibility on x86, while crt1.o was added on sparc, so check for that.
6098 i?86-*-solaris2* | x86_64-*-solaris2*)
6099 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
6102 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
6107 if test x$gcc_cv_solaris_crts = xyes; then
6108 AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
6109 [Define if the system-provided CRTs are present on Solaris.])
6112 AC_ARG_ENABLE(libssp,
6113 [AS_HELP_STRING([--enable-libssp], [enable linking against libssp])],
6114 [case "${enableval}" in
6118 AC_MSG_ERROR([unknown libssp setting $enableval])
6122 # Test for stack protector support in target C library.
6123 AC_CACHE_CHECK(__stack_chk_fail in target C library,
6124 gcc_cv_libc_provides_ssp,
6125 [gcc_cv_libc_provides_ssp=no
6126 if test "x$enable_libssp" = "xno"; then
6127 gcc_cv_libc_provides_ssp=yes
6128 elif test "x$enable_libssp" = "xyes"; then
6129 gcc_cv_libc_provides_ssp=no
6133 # All versions of musl provide stack protector
6134 gcc_cv_libc_provides_ssp=yes;;
6135 *-*-linux* | *-*-kfreebsd*-gnu)
6136 # glibc 2.4 and later provides __stack_chk_fail and
6137 # either __stack_chk_guard, or TLS access to stack guard canary.
6138 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
6139 [if test -f $target_header_dir/features.h \
6140 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
6141 $target_header_dir/features.h > /dev/null; then
6142 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
6143 $target_header_dir/features.h > /dev/null && \
6144 test -f $target_header_dir/bits/uClibc_config.h && \
6145 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
6146 $target_header_dir/bits/uClibc_config.h > /dev/null; then
6147 gcc_cv_libc_provides_ssp=yes
6149 # all versions of Bionic support stack protector
6150 elif test -f $target_header_dir/sys/cdefs.h \
6151 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
6152 $target_header_dir/sys/cdefs.h > /dev/null; then
6153 gcc_cv_libc_provides_ssp=yes
6157 # Avoid complicated tests (see
6158 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
6159 # simply assert that glibc does provide this, which is true for all
6160 # realistically usable GNU/Hurd configurations.
6161 # All supported versions of musl provide it as well
6162 gcc_cv_libc_provides_ssp=yes;;
6163 *-*-darwin* | *-*-freebsd* | *-*-netbsd*)
6164 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
6165 [echo "no __stack_chk_fail on this target"])
6167 *) gcc_cv_libc_provides_ssp=no ;;
6171 if test x$gcc_cv_libc_provides_ssp = xyes; then
6172 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
6173 [Define if your target C library provides stack protector support])
6176 # Check whether --enable-default-ssp was given.
6177 AC_ARG_ENABLE(default-ssp,
6178 [AS_HELP_STRING([--enable-default-ssp],
6179 [enable Stack Smashing Protection as default])],[
6180 if test x$gcc_cv_libc_provides_ssp = xyes; then
6182 ia64*-*-*) enable_default_ssp=no ;;
6183 *) enable_default_ssp=$enableval ;;
6186 enable_default_ssp=no
6188 enable_default_ssp=no)
6189 if test x$enable_default_ssp = xyes ; then
6190 AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
6191 [Define if your target supports default stack protector and it is enabled.])
6193 AC_SUBST([enable_default_ssp])
6195 # Test for <sys/sdt.h> on the target.
6196 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
6197 AC_MSG_CHECKING(sys/sdt.h in the target C library)
6199 if test -f $target_header_dir/sys/sdt.h; then
6201 AC_DEFINE(HAVE_SYS_SDT_H, 1,
6202 [Define if your target C library provides sys/sdt.h])
6204 AC_MSG_RESULT($have_sys_sdt_h)
6206 # Check if TFmode long double should be used by default or not.
6207 # Some glibc targets used DFmode long double, but with glibc 2.4
6208 # and later they can use TFmode.
6210 powerpc*-*-linux* | \
6214 AC_ARG_WITH(long-double-128,
6215 [AS_HELP_STRING([--with-long-double-128],
6216 [use 128-bit long double by default])],
6217 gcc_cv_target_ldbl128="$with_long_double_128", [
6219 s390*-*-linux-musl*)
6220 gcc_cv_target_ldbl128=yes
6222 powerpc*-*-linux-musl*)
6223 gcc_cv_target_ldbl128=no
6226 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
6227 [gcc_cv_target_ldbl128=no
6228 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
6229 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
6230 && gcc_cv_target_ldbl128=yes
6238 if test x$gcc_cv_target_ldbl128 = xyes; then
6239 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
6240 [Define if TFmode long double should be the default])
6243 # Check if TFmode long double target should use the IBM extended double or IEEE
6244 # 128-bit floating point formats if long doubles are 128-bits long. The long
6245 # double type can only be switched on powerpc64 bit Linux systems where VSX is
6246 # supported. Other PowerPC systems do not build the IEEE 128-bit emulator in
6248 AC_ARG_WITH([long-double-format],
6249 [AS_HELP_STRING([--with-long-double-format={ieee,ibm}]
6250 [Specify whether PowerPC long double uses IEEE or IBM format])],[
6251 case "$target:$with_long_double_format" in
6252 powerpc64le-*-linux*:ieee | powerpc64le-*-linux*:ibm)
6255 powerpc64-*-linux*:ieee | powerpc64-*-linux*:ibm)
6256 # IEEE 128-bit emulation is only built on 64-bit VSX Linux systems
6258 power7 | power8 | power9 | power1*)
6262 AC_MSG_ERROR([Configuration option --with-long-double-format is only \
6263 supported if the default cpu is power7 or newer])
6264 with_long_double_format=""
6268 xpowerpc64*-*-linux*:*)
6269 AC_MSG_ERROR([--with-long-double-format argument should be ibm or ieee])
6270 with_long_double_format=""
6273 AC_MSG_ERROR([Configure option --with-long-double-format is only supported \
6274 on 64-bit PowerPC VSX Linux systems])
6275 with_long_double_format=""
6280 # Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP
6281 # values in the TCB. Currently, only GLIBC 2.23 and later support this.
6282 gcc_cv_libc_provides_hwcap_in_tcb=no
6285 GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], )
6288 if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then
6289 AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1,
6290 [Define if your target C Library provides the AT_HWCAP value in the TCB])
6293 # Check if the target LIBC handles PT_GNU_STACK.
6294 gcc_cv_libc_gnustack=unknown
6297 GCC_GLIBC_VERSION_GTE_IFELSE([2], [31], [gcc_cv_libc_gnustack=yes], )
6300 if test x$gcc_cv_libc_gnustack = xyes; then
6301 AC_DEFINE(TARGET_LIBC_GNUSTACK, 1,
6302 [Define if your target C Library properly handles PT_GNU_STACK])
6305 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
6306 gcc_cv_target_dl_iterate_phdr=unknown
6309 # <link.h> needs both a dl_iterate_phdr declaration and support for
6310 # compilation with largefile support.
6311 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
6312 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
6313 gcc_cv_target_dl_iterate_phdr=yes
6315 gcc_cv_target_dl_iterate_phdr=no
6318 *-*-dragonfly* | *-*-freebsd*)
6319 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
6320 gcc_cv_target_dl_iterate_phdr=yes
6322 gcc_cv_target_dl_iterate_phdr=no
6326 gcc_cv_target_dl_iterate_phdr=yes
6329 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
6330 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
6331 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
6332 [Define if your target C library provides the `dl_iterate_phdr' function.])
6334 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
6336 # We no longer support different GC mechanisms. Emit an error if
6337 # the user configures with --with-gc.
6339 [AS_HELP_STRING([--with-gc={page,zone}],
6340 [this option is not supported anymore. It used to choose
6341 the garbage collection mechanism to use with the compiler])],
6342 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
6345 # Libraries to use on the host. This will normally be set by the top
6346 # level Makefile. Here we simply capture the value for our Makefile.
6347 if test -z "${HOST_LIBS+set}"; then
6352 # Use the system's zlib library.
6355 dnl Very limited version of automake's enable-maintainer-mode
6357 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
6358 dnl maintainer-mode is disabled by default
6359 AC_ARG_ENABLE(maintainer-mode,
6360 [AS_HELP_STRING([--enable-maintainer-mode],
6361 [enable make rules and dependencies not useful
6362 (and sometimes confusing) to the casual installer])],
6363 maintainer_mode=$enableval,
6366 AC_MSG_RESULT($maintainer_mode)
6368 if test "$maintainer_mode" = "yes"; then
6375 dnl Whether to prevent multiple front-ends from linking at the same time
6377 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
6378 AC_ARG_ENABLE(link-mutex,
6379 [AS_HELP_STRING([--enable-link-mutex],
6380 [avoid linking multiple front-ends at once to avoid thrashing
6381 on the build machine])],
6382 do_link_mutex=$enableval,
6384 AC_MSG_RESULT($do_link_mutex)
6386 if test "$do_link_mutex" = "yes"; then
6391 AC_SUBST(DO_LINK_MUTEX)
6397 # Make empty files to contain the specs and options for each language.
6398 # Then add #include lines to for a compiler that has specs and/or options.
6404 # These (without "all_") are set in each config-lang.in.
6405 # `language' must be a single word so is spelled singularly.
6408 all_outputs='Makefile'
6409 # List of language configure and makefile fragments.
6410 all_lang_configurefrags=
6412 # Additional files for gengtype
6413 all_gtfiles="$target_gtfiles"
6415 # These are the languages that are set in --enable-languages,
6416 # and are available in the GCC tree.
6417 all_selected_languages=
6419 # Add the language fragments.
6420 # Languages are added via two mechanisms. Some information must be
6421 # recorded in makefile variables, these are defined in config-lang.in.
6422 # We accumulate them and plug them into the main Makefile.
6423 # The other mechanism is a set of hooks for each of the main targets
6424 # like `clean', `install', etc.
6426 language_hooks="Make-hooks"
6428 for lang in ${srcdir}/*/config-lang.in
6431 test "$lang" = "${srcdir}/*/config-lang.in" && continue
6433 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
6434 if test "x$lang_alias" = x
6436 echo "$lang doesn't set \$language." 1>&2
6439 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
6440 subdirs="$subdirs $subdir"
6442 # $gcc_subdir is where the gcc integration files are to be found
6443 # for a language, both for internal compiler purposes (compiler
6444 # sources implementing front-end to GCC tree converters), and for
6445 # build infrastructure purposes (Make-lang.in, etc.)
6447 # This will be <subdir> (relative to $srcdir) if a line like
6448 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
6449 # is found in <langdir>/config-lang.in, and will remain <langdir>
6452 # Except for the language alias (fetched above), the regular
6453 # "config-lang.in" contents are always retrieved from $gcc_subdir,
6454 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
6455 # only this and the language alias.
6457 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
6458 if [ "$gcc_subdir" = "" ]; then
6459 gcc_subdir="$subdir"
6462 case ",$enable_languages," in
6464 all_selected_languages="$all_selected_languages $lang_alias"
6465 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
6466 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
6478 . ${srcdir}/$gcc_subdir/config-lang.in
6479 if test "x$language" = x
6481 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
6486 case ",$enable_languages," in
6489 for i in $subdir_requires; do
6490 test -f "${srcdir}/$i/config-lang.in" && continue
6498 all_lang_configurefrags="$all_lang_configurefrags \$(srcdir)/$gcc_subdir/config-lang.in"
6499 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
6500 if test -f $srcdir/$gcc_subdir/lang.opt; then
6501 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
6502 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
6504 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
6505 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
6507 all_languages="$all_languages $language"
6508 all_compilers="$all_compilers $compilers"
6509 all_outputs="$all_outputs $outputs"
6510 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
6511 case ",$enable_languages," in
6513 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
6515 AC_SUBST(enable_lto)
6522 for language in $all_selected_languages
6524 check_languages="$check_languages check-$language"
6528 for language in $all_selected_languages
6530 selftest_languages="$selftest_languages selftest-$language"
6533 # We link each language in with a set of hooks, reached indirectly via
6534 # lang.${target}. Only do so for selected languages.
6538 target_list="all.cross start.encap rest.encap tags \
6539 install-common install-man install-info install-pdf install-html dvi \
6540 pdf html uninstall info man srcextra srcman srcinfo \
6541 mostlyclean clean distclean maintainer-clean install-plugin"
6543 for t in $target_list
6546 for lang in $all_selected_languages
6550 echo "lang.$t: $x" >> Make-hooks
6554 # Option include files
6557 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
6558 option_includes="option-includes.mk"
6559 AC_SUBST_FILE(option_includes)
6567 echo "dir ." > .gdbinit
6568 echo "dir ${srcdir}" >> .gdbinit
6569 if test x$gdb_needs_out_file_path = xyes
6571 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
6573 if test "x$subdirs" != x; then
6576 echo "dir ${srcdir}/$s" >> .gdbinit
6579 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
6580 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
6582 # Put a breakpoint on __asan_report_error to help with debugging buffer
6585 *-fsanitize=address*)
6586 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
6590 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
6591 AC_SUBST(gcc_tooldir)
6594 # Find a directory in which to install a shared libgcc.
6596 AC_ARG_ENABLE(version-specific-runtime-libs,
6597 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
6598 [specify that runtime libraries should be
6599 installed in a compiler-specific directory])])
6601 # Substitute configuration variables
6604 AC_SUBST(all_compilers)
6605 AC_SUBST(all_gtfiles)
6606 AC_SUBST(all_lang_configurefrags)
6607 AC_SUBST(all_lang_makefrags)
6608 AC_SUBST(all_languages)
6609 AC_SUBST(all_selected_languages)
6610 AC_SUBST(build_exeext)
6611 AC_SUBST(build_install_headers_dir)
6612 AC_SUBST(build_xm_file_list)
6613 AC_SUBST(build_xm_include_list)
6614 AC_SUBST(build_xm_defines)
6615 AC_SUBST(build_file_translate)
6616 AC_SUBST(check_languages)
6617 AC_SUBST(selftest_languages)
6618 AC_SUBST(cpp_install_dir)
6619 AC_SUBST(xmake_file)
6620 AC_SUBST(tmake_file)
6621 AC_SUBST(TM_ENDIAN_CONFIG)
6622 AC_SUBST(TM_MULTILIB_CONFIG)
6623 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
6624 AC_SUBST(extra_gcc_objs)
6625 AC_SUBST(user_headers_inc_next_pre)
6626 AC_SUBST(user_headers_inc_next_post)
6627 AC_SUBST(extra_headers_list)
6628 AC_SUBST(extra_objs)
6629 AC_SUBST(extra_programs)
6630 AC_SUBST(float_h_file)
6631 AC_SUBST(gcc_config_arguments)
6632 AC_SUBST(gcc_gxx_include_dir)
6633 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
6634 AC_SUBST(host_exeext)
6635 AC_SUBST(host_xm_file_list)
6636 AC_SUBST(host_xm_include_list)
6637 AC_SUBST(host_xm_defines)
6638 AC_SUBST(out_host_hook_obj)
6640 AC_SUBST(lang_opt_files)
6641 AC_SUBST(lang_specs_files)
6642 AC_SUBST(lang_tree_files)
6643 AC_SUBST(local_prefix)
6645 AC_SUBST(objc_boehm_gc)
6647 AC_SUBST(out_object_file)
6648 AC_SUBST(common_out_file)
6649 AC_SUBST(common_out_object_file)
6650 AC_SUBST(tm_file_list)
6651 AC_SUBST(tm_include_list)
6652 AC_SUBST(tm_defines)
6653 AC_SUBST(tm_p_file_list)
6654 AC_SUBST(tm_p_include_list)
6655 AC_SUBST(tm_d_file_list)
6656 AC_SUBST(tm_d_include_list)
6657 AC_SUBST(xm_file_list)
6658 AC_SUBST(xm_include_list)
6659 AC_SUBST(xm_defines)
6660 AC_SUBST(use_gcc_stdint)
6661 AC_SUBST(c_target_objs)
6662 AC_SUBST(cxx_target_objs)
6663 AC_SUBST(fortran_target_objs)
6664 AC_SUBST(d_target_objs)
6665 AC_SUBST(target_cpu_default)
6667 AC_SUBST_FILE(language_hooks)
6670 if test x${build} = x${host} ; then
6671 if test x${host} = x${target} ; then
6672 echo "Links are now set up to build a native compiler for ${target}." 1>&2
6674 echo "Links are now set up to build a cross-compiler" 1>&2
6675 echo " from ${host} to ${target}." 1>&2
6678 if test x${host} = x${target} ; then
6679 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
6680 echo " for ${target}." 1>&2
6682 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
6683 echo " from ${host} to ${target}." 1>&2
6687 AC_ARG_VAR(GMPLIBS,[How to link GMP])
6688 AC_ARG_VAR(GMPINC,[How to find GMP include files])
6690 AC_ARG_VAR(ISLLIBS,[How to link isl])
6691 AC_ARG_VAR(ISLINC,[How to find isl include files])
6692 if test "x${ISLLIBS}" != "x" ; then
6693 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
6697 AC_SUBST(pluginlibs)
6698 AC_SUBST(enable_plugin)
6699 if test x"$enable_plugin" = x"yes"; then
6700 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
6704 # Enable --enable-host-shared
6705 AC_ARG_ENABLE(host-shared,
6706 [AS_HELP_STRING([--enable-host-shared],
6707 [build host code as shared libraries])],
6708 [PICFLAG=-fPIC], [PICFLAG=])
6709 AC_SUBST(enable_host_shared)
6713 AC_ARG_ENABLE(libquadmath-support,
6714 [AS_HELP_STRING([--disable-libquadmath-support],
6715 [disable libquadmath support for Fortran])],
6716 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
6717 ENABLE_LIBQUADMATH_SUPPORT=yes)
6718 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
6719 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
6720 [Define to 1 to enable libquadmath support])
6724 # Specify what hash style to use by default.
6725 AC_ARG_WITH([linker-hash-style],
6726 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
6727 [specify the linker hash style])],
6728 [case x"$withval" in
6730 LINKER_HASH_STYLE=sysv
6733 LINKER_HASH_STYLE=gnu
6736 LINKER_HASH_STYLE=both
6739 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
6742 [LINKER_HASH_STYLE=''])
6743 if test x"${LINKER_HASH_STYLE}" != x; then
6744 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
6745 [The linker hash style])
6748 # Specify what should be the default of -fdiagnostics-color option.
6749 AC_ARG_WITH([diagnostics-color],
6750 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
6751 [specify the default of -fdiagnostics-color option
6752 auto-if-env stands for -fdiagnostics-color=auto if
6753 GCC_COLOR environment variable is present and
6754 -fdiagnostics-color=never otherwise])],
6755 [case x"$withval" in
6757 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
6760 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
6763 DIAGNOSTICS_COLOR_DEFAULT=-1
6766 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
6769 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
6772 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
6773 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
6774 [The default for -fdiagnostics-color option])
6776 # Specify what should be the default of -fdiagnostics-urls option.
6777 AC_ARG_WITH([diagnostics-urls],
6778 [AC_HELP_STRING([--with-diagnostics-urls={never,auto,auto-if-env,always}],
6779 [specify the default of -fdiagnostics-urls option
6780 auto-if-env stands for -fdiagnostics-urls=auto if
6781 GCC_URLS or TERM_URLS environment variable is present and
6782 -fdiagnostics-urls=never otherwise])],
6783 [case x"$withval" in
6785 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_NO
6788 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO
6791 DIAGNOSTICS_URLS_DEFAULT=-1
6794 DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_YES
6797 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-urls])
6800 [DIAGNOSTICS_URLS_DEFAULT=DIAGNOSTICS_URL_AUTO])
6801 AC_DEFINE_UNQUOTED(DIAGNOSTICS_URLS_DEFAULT, $DIAGNOSTICS_URLS_DEFAULT,
6802 [The default for -fdiagnostics-urls option])
6804 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
6805 # of jit/jit-playback.c.
6806 gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"`
6807 echo "gcc_driver_version: ${gcc_driver_version}"
6808 cat > gcc-driver-name.h <<EOF
6809 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_driver_version}${exeext}"
6812 # Check whether --enable-default-pie was given.
6813 AC_ARG_ENABLE(default-pie,
6814 [AS_HELP_STRING([--enable-default-pie],
6815 [enable Position Independent Executable as default])],
6816 enable_default_pie=$enableval,
6817 enable_default_pie=no)
6818 if test x$enable_default_pie = xyes ; then
6819 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
6820 [Define if your target supports default PIE and it is enabled.])
6822 AC_SUBST([enable_default_pie])
6824 # Check if -fno-PIE works.
6825 AC_CACHE_CHECK([for -fno-PIE option],
6827 [saved_CXXFLAGS="$CXXFLAGS"
6828 CXXFLAGS="$CXXFLAGS -fno-PIE"
6829 AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
6830 [gcc_cv_c_no_fpie=yes],
6831 [gcc_cv_c_no_fpie=no])
6832 CXXFLAGS="$saved_CXXFLAGS"])
6833 if test "$gcc_cv_c_no_fpie" = "yes"; then
6834 NO_PIE_CFLAGS="-fno-PIE"
6836 AC_SUBST([NO_PIE_CFLAGS])
6838 # Check if -no-pie works.
6839 AC_CACHE_CHECK([for -no-pie option],
6841 [saved_LDFLAGS="$LDFLAGS"
6842 LDFLAGS="$LDFLAGS -no-pie"
6843 AC_LINK_IFELSE([AC_LANG_SOURCE([int main(void) {return 0;}])],
6844 [gcc_cv_no_pie=yes],
6846 LDFLAGS="$saved_LDFLAGS"])
6847 if test "$gcc_cv_no_pie" = "yes"; then
6848 NO_PIE_FLAG="-no-pie"
6850 AC_SUBST([NO_PIE_FLAG])
6852 # Enable Intel CET on Intel CET enabled host if jit is enabled.
6853 GCC_CET_HOST_FLAGS(CET_HOST_FLAGS)
6854 case x$enable_languages in
6861 AC_SUBST(CET_HOST_FLAGS)
6863 # Check linker supports '-z bndplt'
6864 ld_bndplt_support=no
6865 AC_MSG_CHECKING(linker -z bndplt option)
6866 if test x"$ld_is_gold" = xno; then
6867 if test $in_tree_ld = yes ; then
6868 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
6869 ld_bndplt_support=yes
6871 elif test x$gcc_cv_ld != x; then
6872 # Check if linker supports -a bndplt option
6873 if $gcc_cv_ld --help 2>&1 | grep -- '-z bndplt' > /dev/null; then
6874 ld_bndplt_support=yes
6878 if test x"$ld_bndplt_support" = xyes; then
6879 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
6880 [Define if your linker supports -z bndplt])
6882 AC_MSG_RESULT($ld_bndplt_support)
6884 # Check linker supports '--push-state'/'--pop-state'
6885 ld_pushpopstate_support=no
6886 AC_MSG_CHECKING(linker --push-state/--pop-state options)
6887 if test x"$ld_is_gold" = xno; then
6888 if test $in_tree_ld = yes ; then
6889 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
6890 ld_pushpopstate_support=yes
6892 elif test x$gcc_cv_ld != x; then
6893 # Check if linker supports --push-state/--pop-state options
6894 if $gcc_cv_ld --help 2>&1 | grep -- '--push-state' > /dev/null; then
6895 ld_pushpopstate_support=yes
6899 if test x"$ld_pushpopstate_support" = xyes; then
6900 AC_DEFINE(HAVE_LD_PUSHPOPSTATE_SUPPORT, 1,
6901 [Define if your linker supports --push-state/--pop-state])
6903 AC_MSG_RESULT($ld_pushpopstate_support)
6905 # Configure the subdirectories
6906 # AC_CONFIG_SUBDIRS($subdirs)
6908 # Create the Makefile
6909 # and configure language subdirectories
6910 AC_CONFIG_FILES($all_outputs)
6912 AC_CONFIG_COMMANDS([default],
6914 case ${CONFIG_HEADERS} in
6915 *auto-host.h:config.in*)
6918 # Make sure all the subdirs exist.
6919 for d in $subdirs doc build common c-family
6921 test -d $d || mkdir $d
6924 [subdirs='$subdirs'])