2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2015 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 # --------------------------------
28 AC_CONFIG_SRCDIR(tree.c)
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 ACX_NONCANONICAL_TARGET
41 # Used for constructing correct paths for offload compilers.
42 real_target_noncanonical=${target_noncanonical}
45 # Determine the target- and build-specific subdirectories
48 # Set program_transform_name
51 # Check for bogus environment variables.
52 # Test if LIBRARY_PATH contains the notation for the current directory
53 # since this would lead to problems installing/building glibc.
54 # LIBRARY_PATH contains the current directory if one of the following
56 # - one of the terminals (":" and ";") is the first or last sign
57 # - two terminals occur directly after each other
58 # - the path contains an element with a dot in it
59 AC_MSG_CHECKING(LIBRARY_PATH variable)
61 case ${LIBRARY_PATH} in
62 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
63 library_path_setting="contains current directory"
66 library_path_setting="ok"
70 AC_MSG_RESULT($library_path_setting)
71 if test "$library_path_setting" != "ok"; then
73 *** LIBRARY_PATH shouldn't contain the current directory when
74 *** building gcc. Please change the environment variable
75 *** and run configure again.])
78 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
79 # since this would lead to problems installing/building glibc.
80 # GCC_EXEC_PREFIX contains the current directory if one of the following
82 # - one of the terminals (":" and ";") is the first or last sign
83 # - two terminals occur directly after each other
84 # - the path contains an element with a dot in it
85 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
87 case ${GCC_EXEC_PREFIX} in
88 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
89 gcc_exec_prefix_setting="contains current directory"
92 gcc_exec_prefix_setting="ok"
96 AC_MSG_RESULT($gcc_exec_prefix_setting)
97 if test "$gcc_exec_prefix_setting" != "ok"; then
99 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
100 *** building gcc. Please change the environment variable
101 *** and run configure again.])
108 # Specify the local prefix
110 AC_ARG_WITH(local-prefix,
111 [AS_HELP_STRING([--with-local-prefix=DIR],
112 [specifies directory to put local include])],
113 [case "${withval}" in
114 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
116 *) local_prefix=$with_local_prefix ;;
119 # Default local prefix if it is empty
120 if test x$local_prefix = x; then
121 local_prefix=/usr/local
124 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
125 # passed in by the toplevel make and thus we'd get different behavior
126 # depending on where we built the sources.
128 # Specify the g++ header file directory
129 AC_ARG_WITH(gxx-include-dir,
130 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
131 [specifies directory to put g++ header files])],
132 [case "${withval}" in
133 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
135 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
138 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
139 if test x${gcc_gxx_include_dir} = x; then
140 if test x${enable_version_specific_runtime_libs} = xyes; then
141 gcc_gxx_include_dir='${libsubdir}/include/c++'
143 libstdcxx_incdir='include/c++/$(version)'
144 if test x$host != x$target; then
145 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
147 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
151 gcc_gxx_include_dir_add_sysroot=0
152 if test "${with_sysroot+set}" = set; then
153 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
154 if test "${gcc_gxx_without_sysroot}"; then
155 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
156 gcc_gxx_include_dir_add_sysroot=1
160 AC_ARG_WITH(cpp_install_dir,
161 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
162 [install the user visible C preprocessor in DIR
163 (relative to PREFIX) as well as PREFIX/bin])],
164 [if test x$withval = xyes; then
165 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
166 elif test x$withval != xno; then
167 cpp_install_dir=$withval
170 # We would like to our source tree to be readonly. However when releases or
171 # pre-releases are generated, the flex/bison generated files as well as the
172 # various formats of manuals need to be included along with the rest of the
173 # sources. Therefore we have --enable-generated-files-in-srcdir to do
176 AC_MSG_CHECKING([whether to place generated files in the source directory])
177 dnl generated-files-in-srcdir is disabled by default
178 AC_ARG_ENABLE(generated-files-in-srcdir,
179 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
180 [put copies of generated files in source dir
181 intended for creating source tarballs for users
182 without texinfo bison or flex])],
183 generated_files_in_srcdir=$enableval,
184 generated_files_in_srcdir=no)
186 AC_MSG_RESULT($generated_files_in_srcdir)
188 if test "$generated_files_in_srcdir" = "yes"; then
195 # -------------------
196 # Find default linker
197 # -------------------
201 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
202 gnu_ld_flag="$with_gnu_ld",
205 # With pre-defined ld
207 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
208 DEFAULT_LINKER="$with_ld")
209 if test x"${DEFAULT_LINKER+set}" = x"set"; then
210 if test ! -x "$DEFAULT_LINKER"; then
211 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
212 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
215 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
216 [Define to enable the use of a default linker.])
219 AC_MSG_CHECKING([whether a default linker was specified])
220 if test x"${DEFAULT_LINKER+set}" = x"set"; then
221 if test x"$gnu_ld_flag" = x"no"; then
222 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
224 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
230 # With demangler in GNU ld
231 AC_ARG_WITH(demangler-in-ld,
232 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
233 demangler_in_ld="$with_demangler_in_ld",
236 # ----------------------
237 # Find default assembler
238 # ----------------------
242 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
243 gas_flag="$with_gnu_as",
247 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
248 DEFAULT_ASSEMBLER="$with_as")
249 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
250 if test ! -x "$DEFAULT_ASSEMBLER"; then
251 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
252 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
255 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
256 [Define to enable the use of a default assembler.])
259 AC_MSG_CHECKING([whether a default assembler was specified])
260 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
261 if test x"$gas_flag" = x"no"; then
262 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
264 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
274 # If a non-executable a.out is present (e.g. created by GNU as above even if
275 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
276 # file, even when creating an executable, so an execution test fails.
277 # Remove possible default executable files to avoid this.
279 # FIXME: This really belongs into AC_PROG_CC and can be removed once
280 # Autoconf includes it.
281 rm -f a.out a.exe b.out
283 # Find the native compiler
286 ACX_PROG_GNAT([-I"$srcdir"/ada])
288 # Do configure tests with the C++ compiler, since that's what we build with.
291 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
292 # optimizations to be activated explicitly by the toplevel.
295 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
296 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
301 # Determine PICFLAG for target gnatlib.
302 GCC_PICFLAG_FOR_TARGET
303 AC_SUBST(PICFLAG_FOR_TARGET)
305 # -------------------------
306 # Check C compiler features
307 # -------------------------
309 AC_USE_SYSTEM_EXTENSIONS
315 # sizeof(char) is 1 by definition.
316 AC_CHECK_SIZEOF(void *)
317 AC_CHECK_SIZEOF(short)
319 AC_CHECK_SIZEOF(long)
320 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
322 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
323 AC_MSG_ERROR([uint64_t or int64_t not found])
326 # check what underlying integer type int64_t uses
327 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
328 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
332 template <typename T> struct X { };
334 struct X<long> { typedef long t; };
335 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
336 if test "$ac_cv_int64_t_type" = "long"; then
337 AC_DEFINE(INT64_T_IS_LONG, 1,
338 [Define if int64_t uses long as underlying type.])
340 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
344 template <typename T> struct X { };
346 struct X<long long> { typedef long long t; };
347 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
353 # ---------------------
354 # Warnings and checking
355 # ---------------------
357 # Check $CC warning features (if it's GCC).
358 # We want to use -pedantic, but we don't want warnings about
362 # * C++11 narrowing conversions in { }
363 # So, we only use -pedantic if we can disable those warnings.
365 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
366 AC_ARG_ENABLE(build-format-warnings,
367 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
368 [],[enable_build_format_warnings=yes])
369 AS_IF([test $enable_build_format_warnings = no],
370 [wf_opt=-Wno-format],[wf_opt=])
371 ACX_PROG_CC_WARNING_OPTS(
372 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
373 ACX_PROG_CC_WARNING_OPTS(
374 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
376 ACX_PROG_CC_WARNING_OPTS(
377 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
378 ACX_PROG_CC_WARNING_OPTS(
379 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
380 ACX_PROG_CC_WARNING_OPTS(
381 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
382 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
383 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
384 [-Wno-overlength-strings])), [strict_warn])
385 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
387 # The above macros do nothing if the compiler is not GCC. However, the
388 # Makefile has more goo to add other flags, so these variables are used
389 # to enable warnings only for GCC.
392 if test "x$GCC" = "xyes"; then
393 warn_cflags='$(GCC_WARN_CFLAGS)'
394 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
396 AC_SUBST(warn_cflags)
397 AC_SUBST(warn_cxxflags)
399 # Disable exceptions and RTTI if building with g++
400 ACX_PROG_CC_WARNING_OPTS(
401 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
404 # Enable expensive internal checks
406 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
410 AC_ARG_ENABLE(checking,
411 [AS_HELP_STRING([[--enable-checking[=LIST]]],
412 [enable expensive run-time checks. With LIST,
413 enable only specific categories of checks.
414 Categories are: yes,no,all,none,release.
415 Flags are: assert,df,fold,gc,gcac,gimple,misc,
416 rtlflag,rtl,runtime,tree,valgrind,types])],
417 [ac_checking_flags="${enableval}"],[
418 # Determine the default checks.
419 if test x$is_release = x ; then
420 ac_checking_flags=yes
422 ac_checking_flags=release
424 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
425 for check in release $ac_checking_flags
428 # these set all the flags to specific states
429 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
430 ac_fold_checking= ; ac_gc_checking=1 ;
431 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
432 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
433 ac_tree_checking=1 ; ac_valgrind_checking= ;
434 ac_types_checking=1 ;;
435 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
436 ac_fold_checking= ; ac_gc_checking= ;
437 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
438 ac_rtlflag_checking= ; ac_runtime_checking= ;
439 ac_tree_checking= ; ac_valgrind_checking= ;
440 ac_types_checking= ;;
441 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
442 ac_fold_checking=1 ; ac_gc_checking=1 ;
443 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
444 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
445 ac_tree_checking=1 ; ac_valgrind_checking= ;
446 ac_types_checking=1 ;;
447 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
448 ac_fold_checking= ; ac_gc_checking= ;
449 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
450 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
451 ac_tree_checking= ; ac_valgrind_checking= ;
452 ac_types_checking= ;;
453 # these enable particular checks
454 assert) ac_assert_checking=1 ;;
455 df) ac_df_checking=1 ;;
456 fold) ac_fold_checking=1 ;;
457 gc) ac_gc_checking=1 ;;
458 gcac) ac_gc_always_collect=1 ;;
459 gimple) ac_gimple_checking=1 ;;
460 misc) ac_checking=1 ;;
461 rtl) ac_rtl_checking=1 ;;
462 rtlflag) ac_rtlflag_checking=1 ;;
463 runtime) ac_runtime_checking=1 ;;
464 tree) ac_tree_checking=1 ;;
465 types) ac_types_checking=1 ;;
466 valgrind) ac_valgrind_checking=1 ;;
467 *) AC_MSG_ERROR(unknown check category $check) ;;
473 if test x$ac_checking != x ; then
474 AC_DEFINE(ENABLE_CHECKING, 1,
475 [Define if you want more run-time sanity checks. This one gets a grab
476 bag of miscellaneous but relatively cheap checks.])
477 nocommon_flag=-fno-common
479 AC_SUBST(nocommon_flag)
480 if test x$ac_df_checking != x ; then
481 AC_DEFINE(ENABLE_DF_CHECKING, 1,
482 [Define if you want more run-time sanity checks for dataflow.])
484 if test x$ac_assert_checking != x ; then
485 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
486 [Define if you want assertions enabled. This is a cheap check.])
488 if test x$ac_gimple_checking != x ; then
489 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
490 [Define if you want operations on GIMPLE (the basic data structure of
491 the high-level optimizers) to be checked for dynamic type safety at
492 runtime. This is moderately expensive.])
494 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
495 if test x$ac_runtime_checking != x ; then
496 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
497 [Define if you want runtime assertions enabled. This is a cheap check.])
499 if test x$ac_tree_checking != x ; then
500 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
501 [Define if you want all operations on trees (the basic data
502 structure of the front ends) to be checked for dynamic type safety
503 at runtime. This is moderately expensive. The tree browser debugging
504 routines will also be enabled by this option.
506 TREEBROWSER=tree-browser.o
509 if test x$ac_types_checking != x ; then
510 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
511 [Define if you want all gimple types to be verified after gimplifiation.
515 AC_SUBST(TREEBROWSER)
516 AC_SUBST(TREECHECKING)
517 if test x$ac_rtl_checking != x ; then
518 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
519 [Define if you want all operations on RTL (the basic data structure
520 of the optimizer and back end) to be checked for dynamic type safety
521 at runtime. This is quite expensive.])
523 if test x$ac_rtlflag_checking != x ; then
524 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
525 [Define if you want RTL flag accesses to be checked against the RTL
526 codes that are supported for each access macro. This is relatively
529 if test x$ac_gc_checking != x ; then
530 AC_DEFINE(ENABLE_GC_CHECKING, 1,
531 [Define if you want the garbage collector to do object poisoning and
532 other memory allocation checks. This is quite expensive.])
534 if test x$ac_gc_always_collect != x ; then
535 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
536 [Define if you want the garbage collector to operate in maximally
537 paranoid mode, validating the entire heap and collecting garbage at
538 every opportunity. This is extremely expensive.])
540 if test x$ac_fold_checking != x ; then
541 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
542 [Define if you want fold checked that it never destructs its argument.
543 This is quite expensive.])
545 valgrind_path_defines=
548 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
549 dnl # an if statement. This was the source of very frustrating bugs
550 dnl # in converting to autoconf 2.5x!
551 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
553 # It is certainly possible that there's valgrind but no valgrind.h.
554 # GCC relies on making annotations so we must have both.
555 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
556 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
557 [[#include <valgrind/memcheck.h>
558 #ifndef VALGRIND_DISCARD
559 #error VALGRIND_DISCARD not defined
561 [gcc_cv_header_valgrind_memcheck_h=yes],
562 [gcc_cv_header_valgrind_memcheck_h=no])
563 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
564 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
565 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
566 [[#include <memcheck.h>
567 #ifndef VALGRIND_DISCARD
568 #error VALGRIND_DISCARD not defined
570 [gcc_cv_header_memcheck_h=yes],
571 [gcc_cv_header_memcheck_h=no])
572 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
573 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
574 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
575 [Define if valgrind's valgrind/memcheck.h header is installed.])
577 if test $gcc_cv_header_memcheck_h = yes; then
578 AC_DEFINE(HAVE_MEMCHECK_H, 1,
579 [Define if valgrind's memcheck.h header is installed.])
582 if test x$ac_valgrind_checking != x ; then
583 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
584 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
585 if test "x$valgrind_path" = "x" \
586 || (test $have_valgrind_h = no \
587 && test $gcc_cv_header_memcheck_h = no \
588 && test $gcc_cv_header_valgrind_memcheck_h = no); then
589 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
591 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
592 valgrind_command="$valgrind_path -q"
593 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
594 [Define if you want to run subprograms and generated programs
595 through valgrind (a memory checker). This is extremely expensive.])
597 AC_SUBST(valgrind_path_defines)
598 AC_SUBST(valgrind_command)
600 # Enable code coverage collection
601 AC_ARG_ENABLE(coverage,
602 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
603 [enable compiler's code coverage collection.
604 Use to measure compiler performance and locate
605 unused parts of the compiler. With LEVEL, specify
606 optimization. Values are opt, noopt,
608 [case "${enableval}" in
610 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
613 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
616 # a.k.a. --disable-coverage
620 AC_MSG_ERROR(unknown coverage setting $enableval)
624 AC_SUBST(coverage_flags)
626 AC_ARG_ENABLE(gather-detailed-mem-stats,
627 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
628 [enable detailed memory allocation stats gathering])], [],
629 [enable_gather_detailed_mem_stats=no])
630 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
631 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
632 [Define to enable detailed memory allocation stats gathering.])
634 AC_ARG_ENABLE(valgrind-annotations,
635 [AS_HELP_STRING([--enable-valgrind-annotations],
636 [enable valgrind runtime interaction])], [],
637 [enable_valgrind_annotations=no])
638 if test x$enable_valgrind_annotations != xno \
639 || test x$ac_valgrind_checking != x; then
640 if (test $have_valgrind_h = no \
641 && test $gcc_cv_header_memcheck_h = no \
642 && test $gcc_cv_header_valgrind_memcheck_h = no); then
643 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
645 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
646 [Define to get calls to the valgrind runtime enabled.])
649 # -------------------------------
650 # Miscenalleous configure options
651 # -------------------------------
655 [AS_HELP_STRING([--with-stabs],
656 [arrange to use stabs instead of host debug format])],
660 # Determine whether or not multilibs are enabled.
661 AC_ARG_ENABLE(multilib,
662 [AS_HELP_STRING([--enable-multilib],
663 [enable library support for multiple ABIs])],
664 [], [enable_multilib=yes])
665 AC_SUBST(enable_multilib)
667 # Determine whether or not multiarch is enabled.
668 AC_ARG_ENABLE(multiarch,
669 [AS_HELP_STRING([--enable-multiarch],
670 [enable support for multiarch paths])],
671 [case "${enableval}" in
672 yes|no|auto) enable_multiarch=$enableval;;
673 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
674 esac], [enable_multiarch=auto])
675 if test x${enable_multiarch} = xauto; then
676 if test x${with_native_system_header_dir} != x; then
677 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
680 if test x$host != x$target && test "x$with_sysroot" = x; then
681 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
685 AC_MSG_CHECKING(for multiarch configuration)
686 AC_SUBST(enable_multiarch)
687 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
689 # needed for setting the multiarch name for soft-float/hard-float ABIs
693 # Enable __cxa_atexit for C++.
694 AC_ARG_ENABLE(__cxa_atexit,
695 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
698 # Enable C extension for decimal float if target supports it.
699 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
701 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
702 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
703 [Define to 1 to enable decimal float extension to C.])
705 # Use default_decimal_float for dependency.
706 enable_decimal_float=$default_decimal_float
708 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
709 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
710 [Define to 1 to specify that we are using the BID decimal floating
711 point format instead of DPD])
713 # Enable C extension for fixed-point arithmetic.
714 AC_ARG_ENABLE(fixed-point,
715 [AS_HELP_STRING([--enable-fixed-point],
716 [enable fixed-point arithmetic extension to C])],
721 enable_fixed_point=yes
725 enable_fixed_point=yes
728 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
729 enable_fixed_point=no
733 AC_SUBST(enable_fixed_point)
735 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
736 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
737 [Define to 1 to enable fixed-point arithmetic extension to C.])
740 # Pass with no value to take the default
741 # Pass with a value to specify a thread package
742 AC_ARG_ENABLE(threads,
743 [AS_HELP_STRING([[--enable-threads[=LIB]]],
744 [enable thread usage for target GCC,
745 using LIB thread package])],,
749 [AS_HELP_STRING([--enable-tls],
750 [enable or disable generation of tls code
751 overriding the assembler check for tls support])],
755 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
756 Valid choices are 'yes' and 'no'.]) ;;
760 AC_ARG_ENABLE(objc-gc,
761 [AS_HELP_STRING([--enable-objc-gc],
762 [enable the use of Boehm's garbage collector with
763 the GNU Objective-C runtime])],
764 if test x$enable_objc_gc = xno; then
772 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
773 dwarf2="$with_dwarf2",
776 AC_ARG_ENABLE(shared,
777 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
779 case $enable_shared in
783 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
784 for pkg in $enableval; do
785 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
792 ], [enable_shared=yes])
793 AC_SUBST(enable_shared)
795 AC_ARG_WITH([native-system-header-dir],
796 [ --with-native-system-header-dir=dir
797 use dir as the directory to look for standard
798 system header files in. Defaults to /usr/include.],
800 case ${with_native_system_header_dir} in
801 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
802 /* | [[A-Za-z]]:[[\\/]]*) ;;
803 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
805 configured_native_system_header_dir="${withval}"
806 ], [configured_native_system_header_dir=])
808 AC_ARG_WITH(build-sysroot,
809 [AS_HELP_STRING([--with-build-sysroot=sysroot],
810 [use sysroot as the system root during the build])],
811 [if test x"$withval" != x ; then
812 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
814 [SYSROOT_CFLAGS_FOR_TARGET=])
815 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
817 if test "x$prefix" = xNONE; then
818 test_prefix=/usr/local
822 if test "x$exec_prefix" = xNONE; then
823 test_exec_prefix=$test_prefix
825 test_exec_prefix=$exec_prefix
829 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
830 [search for usr/lib, usr/include, et al, within DIR])],
832 case ${with_sysroot} in
833 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
834 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
837 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
838 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
840 case ${TARGET_SYSTEM_ROOT} in
841 "${test_prefix}"|"${test_prefix}/"*|\
842 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
843 '${prefix}'|'${prefix}/'*|\
844 '${exec_prefix}'|'${exec_prefix}/'*)
845 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
846 TARGET_SYSTEM_ROOT_DEFINE="$t"
851 TARGET_SYSTEM_ROOT_DEFINE=
852 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
854 AC_SUBST(TARGET_SYSTEM_ROOT)
855 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
856 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
859 [AS_HELP_STRING([--with-specs=SPECS],
860 [add SPECS to driver command-line processing])],
861 [CONFIGURE_SPECS=$withval],
864 AC_SUBST(CONFIGURE_SPECS)
866 ACX_PKGVERSION([GCC])
867 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
869 # Sanity check enable_languages in case someone does not run the toplevel
870 # configure # script.
871 AC_ARG_ENABLE(languages,
872 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
873 [case ,${enable_languages}, in
875 # go safe -- we cannot be much sure without the toplevel
877 # analysis of which target libs are present and usable
881 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
886 enable_languages=c,${enable_languages}
889 [enable_languages=c])
891 if test x"$enable_as_accelerator_for" != x; then
892 AC_DEFINE(ACCEL_COMPILER, 1,
893 [Define if this compiler should be built as the offload target compiler.])
894 enable_as_accelerator=yes
897 # In this case we expect offload compiler to be built as native, so we
898 # need to rename the driver to avoid clashes with host's drivers.
899 program_transform_name="s&^&${target}-&" ;;
901 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
902 program_transform_name=`echo $program_transform_name | sed $sedscript`
903 accel_dir_suffix=/accel/${target_noncanonical}
904 real_target_noncanonical=${enable_as_accelerator_for}
906 AC_SUBST(enable_as_accelerator)
907 AC_SUBST(real_target_noncanonical)
908 AC_SUBST(accel_dir_suffix)
910 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
911 tgt=`echo $tgt | sed 's/=.*//'`
912 if test x"$offload_targets" = x; then
915 offload_targets="$offload_targets:$tgt"
918 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
919 [Define to hold the list of target names suitable for offloading.])
920 if test x"$offload_targets" != x; then
921 AC_DEFINE(ENABLE_OFFLOADING, 1,
922 [Define this to enable support for offloading.])
925 AC_ARG_WITH(multilib-list,
926 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
928 with_multilib_list=default)
930 # -------------------------
931 # Checks for other programs
932 # -------------------------
936 # Find some useful tools
938 # We need awk to create options.c and options.h.
939 # Bail out if it's missing.
941 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
948 AC_SUBST(ranlib_flags)
952 # See if cmp has --ignore-initial.
953 gcc_AC_PROG_CMP_IGNORE_INITIAL
955 # See if we have the mktemp command.
956 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
958 # See if makeinfo has been installed and is modern enough
959 # that we can use it.
960 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
961 [GNU texinfo.* \([0-9][0-9.]*\)],
962 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
963 if test $gcc_cv_prog_makeinfo_modern = no; then
965 *** Makeinfo is missing or too old.
966 *** Info documentation will not be built.])
973 # Is pod2man recent enough to regenerate manpages?
974 AC_MSG_CHECKING([for recent Pod::Man])
975 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
977 GENERATED_MANPAGES=generated-manpages
982 AC_SUBST(GENERATED_MANPAGES)
984 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
987 dnl Don't use AC_PROG_LEX; we insist on flex.
988 dnl LEXLIB is not useful in gcc.
989 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
992 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
994 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
995 # check for build == host before using them.
998 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
999 && test -d ../binutils ; then
1000 NM='${objdir}/../binutils/nm-new'
1002 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1006 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1007 && test -d ../binutils ; then
1008 AR='${objdir}/../binutils/ar'
1010 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1013 # The jit documentation looks better if built with sphinx, but can be
1014 # built with texinfo if sphinx is not available.
1015 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1016 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1018 # --------------------
1019 # Checks for C headers
1020 # --------------------
1022 # Need to reject headers which give warnings, so that the -Werror bootstrap
1023 # works later. *sigh* This needs to come before all header checks.
1030 AC_HEADER_TIOCGWINSZ
1031 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1032 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1033 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1034 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1036 # Check for thread headers.
1037 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1038 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1040 # These tests can't be done till we know if we have limits.h.
1044 # ----------------------
1045 # Checks for C++ headers
1046 # ----------------------
1048 dnl Autoconf will give an error in the configure script if there is no
1049 dnl C++ preprocessor. Hack to prevent that.
1050 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1052 m4_popdef([AC_MSG_ERROR])[]dnl
1054 AC_CHECK_HEADERS(unordered_map)
1055 AC_CHECK_HEADERS(tr1/unordered_map)
1056 AC_CHECK_HEADERS(ext/hash_map)
1059 # Dependency checking.
1063 AC_CONFIG_COMMANDS([gccdepdir],[
1064 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1065 for lang in $subdirs c-family common
1067 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1068 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1070 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1077 # These libraries may be used by collect2.
1078 # We may need a special search path to get them linked.
1079 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1081 for libs in '' -lld -lmld \
1082 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1083 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1086 AC_TRY_LINK_FUNC(ldopen,
1087 [gcc_cv_collect2_libs="$libs"; break])
1090 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1091 case $gcc_cv_collect2_libs in
1093 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1095 AC_SUBST(COLLECT2_LIBS)
1097 # When building Ada code on Alpha, we need exc_resume which is usually in
1098 # -lexc. So test for it.
1101 AC_SEARCH_LIBS(exc_resume, exc)
1104 AC_SUBST(GNAT_LIBEXC)
1106 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1109 AC_SEARCH_LIBS(kstat_open, kstat)
1110 EXTRA_GCC_LIBS="$LIBS"
1112 AC_SUBST(EXTRA_GCC_LIBS)
1114 # Some systems put ldexp and frexp in libm instead of libc; assume
1115 # they're both in the same place. jcf-dump needs them.
1118 AC_SEARCH_LIBS(ldexp, m)
1123 # Use <inttypes.h> only if it exists,
1124 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1126 AC_MSG_CHECKING(for inttypes.h)
1127 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1128 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1129 [[#define __STDC_FORMAT_MACROS
1130 #include <sys/types.h>
1131 #include <inttypes.h>]],
1136 [gcc_cv_header_inttypes_h=yes],
1137 [gcc_cv_header_inttypes_h=no])])
1138 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1139 if test $gcc_cv_header_inttypes_h = yes; then
1140 AC_DEFINE(HAVE_INTTYPES_H, 1,
1141 [Define if you have a working <inttypes.h> header file.])
1144 dnl Disabled until we have a complete test for buggy enum bitfields.
1145 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1147 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1148 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1149 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1150 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1151 putchar_unlocked putc_unlocked)
1152 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1153 popen sysconf strsignal getrusage nl_langinfo \
1154 gettimeofday mbstowcs wcswidth mmap setlocale \
1155 gcc_UNLOCKED_FUNCS madvise)
1157 if test x$ac_cv_func_mbstowcs = xyes; then
1158 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1159 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1165 [gcc_cv_func_mbstowcs_works=yes],
1166 [gcc_cv_func_mbstowcs_works=no],
1167 [gcc_cv_func_mbstowcs_works=yes])])
1168 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1169 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1170 [Define this macro if mbstowcs does not crash when its
1171 first argument is NULL.])
1175 AC_CHECK_TYPE(ssize_t, int)
1176 AC_CHECK_TYPE(caddr_t, char *)
1178 GCC_AC_FUNC_MMAP_BLACKLIST
1182 # Under VMS, vfork works very differently than on Unix. The standard test
1183 # won't work, and it isn't easily adaptable. It makes more sense to
1185 ac_cv_func_vfork_works=yes
1192 # Until we have in-tree GNU iconv:
1194 AC_SUBST(LIBICONV_DEP)
1200 # We will need to find libiberty.h and ansidecl.h
1201 saved_CFLAGS="$CFLAGS"
1202 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1203 saved_CXXFLAGS="$CXXFLAGS"
1204 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1206 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1207 # normal autoconf function for these. But force definition of
1208 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1209 # basename handling in libiberty.h.
1210 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1211 #undef HAVE_DECL_BASENAME
1212 #define HAVE_DECL_BASENAME 1
1213 #include "ansidecl.h"
1214 #include "system.h"])
1216 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1217 madvise stpcpy strnlen strsignal strverscmp \
1218 strtol strtoul strtoll strtoull \
1219 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1220 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1221 #include "ansidecl.h"
1222 #include "system.h"])
1224 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1225 #include "ansidecl.h"
1227 #ifdef HAVE_SYS_RESOURCE_H
1228 #include <sys/resource.h>
1232 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1233 #include "ansidecl.h"
1235 #ifdef HAVE_SYS_RESOURCE_H
1236 #include <sys/resource.h>
1238 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1239 [Define to `long' if <sys/resource.h> doesn't define.])])
1241 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1242 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1243 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1244 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1245 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1246 #include "ansidecl.h"
1255 gcc_AC_CHECK_DECLS(times, , ,[
1256 #include "ansidecl.h"
1258 #ifdef HAVE_SYS_TIMES_H
1259 #include <sys/times.h>
1263 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1264 #include "ansidecl.h"
1269 # More time-related stuff.
1270 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1271 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1272 #include "ansidecl.h"
1274 #ifdef HAVE_SYS_TIMES_H
1275 #include <sys/times.h>
1277 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1278 if test $ac_cv_struct_tms = yes; then
1279 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1280 [Define if <sys/times.h> defines struct tms.])
1283 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1284 # revisit after autoconf 2.50.
1285 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1286 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1287 #include "ansidecl.h"
1289 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1290 if test $gcc_cv_type_clock_t = yes; then
1291 AC_DEFINE(HAVE_CLOCK_T, 1,
1292 [Define if <time.h> defines clock_t.])
1295 # Check if F_SETLKW is supported by fcntl.
1296 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1297 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1298 #include <fcntl.h>]], [[
1304 return fcntl (1, F_SETLKW, &fl);]])],
1305 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1306 if test $ac_cv_f_setlkw = yes; then
1307 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1308 [Define if F_SETLKW supported by fcntl.])
1311 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1312 CFLAGS="$saved_CFLAGS"
1313 CXXFLAGS="$saved_CXXFLAGS"
1315 # mkdir takes a single argument on some systems.
1316 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1324 # With Setjmp/Longjmp based exception handling.
1325 AC_ARG_ENABLE(sjlj-exceptions,
1326 [AS_HELP_STRING([--enable-sjlj-exceptions],
1327 [arrange to use setjmp/longjmp exception handling])],
1330 if test $enableval != yes; then
1331 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1336 force_sjlj_exceptions=yes],
1339 force_sjlj_exceptions=yes
1343 force_sjlj_exceptions=yes
1347 force_sjlj_exceptions=no
1350 if test $force_sjlj_exceptions = yes; then
1351 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1352 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1353 [Define 0/1 to force the choice for exception handling model.])
1356 # --------------------------------------------------------
1357 # Build, host, and target specific configuration fragments
1358 # --------------------------------------------------------
1360 # Collect build-machine-specific information.
1361 . ${srcdir}/config.build
1363 # Collect host-machine-specific information.
1364 . ${srcdir}/config.host
1368 # Collect target-machine-specific information.
1369 . ${srcdir}/config.gcc
1371 extra_objs="${host_extra_objs} ${extra_objs}"
1372 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1374 # Default the target-machine variables that were not explicitly set.
1375 if test x"$tm_file" = x
1376 then tm_file=$cpu_type/$cpu_type.h; fi
1378 if test x"$extra_headers" = x
1379 then extra_headers=; fi
1381 if test x$md_file = x
1382 then md_file=$cpu_type/$cpu_type.md; fi
1384 if test x$out_file = x
1385 then out_file=$cpu_type/$cpu_type.c; fi
1387 if test x"$tmake_file" = x
1388 then tmake_file=$cpu_type/t-$cpu_type
1391 # Support --enable-initfini-array.
1392 if test x$enable_initfini_array != xno; then
1393 tm_file="${tm_file} initfini-array.h"
1396 if test x"$dwarf2" = xyes
1397 then tm_file="$tm_file tm-dwarf2.h"
1400 # Say what files are being used for the output code and MD file.
1401 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1402 echo "Using \`$srcdir/config/$md_file' as machine description file."
1404 # If any of the xm_file variables contain nonexistent files, warn
1405 # about them and drop them.
1408 for x in $build_xm_file; do
1409 if test -f $srcdir/config/$x
1411 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1417 for x in $host_xm_file; do
1418 if test -f $srcdir/config/$x
1420 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1426 for x in $xm_file; do
1427 if test -f $srcdir/config/$x
1429 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1435 for f in $tm_file; do
1438 if test $count = ax; then
1439 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1441 echo "Using the following target machine macro files:"
1442 for f in $tm_file; do
1443 echo " $srcdir/config/$f"
1447 if test x$use_long_long_for_widest_fast_int = xyes; then
1448 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1449 [Define to 1 if the 'long long' type is wider than 'long' but still
1450 efficiently supported by the host hardware.])
1453 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1454 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1456 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1457 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1460 for f in $host_xm_file; do
1463 if test $count = a; then
1465 elif test $count = ax; then
1466 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1468 echo "Using the following host machine macro files:"
1469 for f in $host_xm_file; do
1470 echo " $srcdir/config/$f"
1473 echo "Using ${out_host_hook_obj} for host machine hooks."
1475 if test "$host_xm_file" != "$build_xm_file"; then
1477 for f in $build_xm_file; do
1480 if test $count = a; then
1482 elif test $count = ax; then
1483 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1485 echo "Using the following build machine macro files:"
1486 for f in $build_xm_file; do
1487 echo " $srcdir/config/$f"
1492 if test -n "$configured_native_system_header_dir"; then
1493 native_system_header_dir=$configured_native_system_header_dir
1495 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1496 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1500 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1501 gcc_cv_mcontext_underscores,
1503 #include <sys/cdefs.h>
1504 #include <sys/signal.h>
1505 #include <ucontext.h>
1506 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1508 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1509 if test $gcc_cv_mcontext_underscores = yes; then
1510 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1511 [mcontext_t fields start with __])
1520 # Check if a valid thread package
1521 case ${enable_threads} in
1524 target_thread_file='single'
1528 target_thread_file='single'
1530 aix | dce | lynx | mipssde | posix | rtems | \
1531 single | tpf | vxworks | win32)
1532 target_thread_file=${enable_threads}
1535 echo "${enable_threads} is an unknown thread package" 1>&2
1540 if test x${thread_file} = x; then
1541 # No thread file set by target-specific clauses in config.gcc,
1542 # so use file chosen by default logic above
1543 thread_file=${target_thread_file}
1551 if test x$enable___cxa_atexit = xyes || \
1552 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1553 if test x$host = x$target; then
1555 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1556 # keyed to flag_use_cxa_atexit
1564 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1565 [echo "__cxa_atexit can't be enabled on this target"])
1569 # We can't check for __cxa_atexit when building a cross, so assume
1573 if test x$use_cxa_atexit = xyes; then
1574 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1575 [Define if you want to use __cxa_atexit, rather than atexit, to
1576 register C++ destructors for local statics and global objects.
1577 This is essential for fully standards-compliant handling of
1578 destructors, but requires __cxa_atexit in libc.])
1582 # Look for a file containing extra machine modes.
1583 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1584 extra_modes_file='$(srcdir)'/config/${extra_modes}
1585 AC_SUBST(extra_modes_file)
1586 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1587 [Define to the name of a file containing a list of extra machine modes
1588 for this architecture.])
1591 # Convert extra_options into a form suitable for Makefile use.
1594 for f in $extra_options; do
1595 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1596 all_opt_files="$all_opt_files $srcdir/config/$f"
1598 AC_SUBST(extra_opt_files)
1600 # auto-host.h is the file containing items generated by autoconf and is
1601 # the first file included by config.h.
1602 # If host=build, it is correct to have bconfig include auto-host.h
1603 # as well. If host!=build, we are in error and need to do more
1604 # work to find out the build config parameters.
1605 if test x$host = x$build
1607 build_auto=auto-host.h
1609 # We create a subdir, then run autoconf in the subdir.
1610 # To prevent recursion we set host and build for the new
1611 # invocation of configure to the build for this invocation
1618 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1619 *) realsrcdir=../${srcdir};;
1621 # Clearing GMPINC is necessary to prevent host headers being
1622 # used by the build compiler. Defining GENERATOR_FILE stops
1623 # system.h from including gmp.h.
1624 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1625 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1626 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1627 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1628 ${realsrcdir}/configure \
1629 --enable-languages=${enable_languages-all} \
1630 --target=$target_alias --host=$build_alias --build=$build_alias
1632 # We just finished tests for the build machine, so rename
1633 # the file auto-build.h in the gcc directory.
1634 mv auto-host.h ../auto-build.h
1637 build_auto=auto-build.h
1639 AC_SUBST(build_subdir)
1641 tm_file="${tm_file} defaults.h"
1642 tm_p_file="${tm_p_file} tm-preds.h"
1643 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1644 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1645 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1646 # put this back in temporarily.
1647 xm_file="auto-host.h ansidecl.h ${xm_file}"
1654 # Compile in configure arguments.
1655 if test -f configargs.h ; then
1656 # Being re-configured.
1657 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1658 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1660 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1663 # Double all backslashes and backslash all quotes to turn
1664 # gcc_config_arguments into a C string.
1665 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1666 $gcc_config_arguments
1668 gcc_config_arguments_str=`cat conftest.out`
1671 cat > configargs.h <<EOF
1672 /* Generated automatically. */
1673 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1674 static const char thread_model[] = "$thread_file";
1676 static const struct {
1677 const char *name, *value;
1678 } configure_default_options[] = $configure_default_options;
1683 gcc_BASEVER=`cat $srcdir/BASE-VER`
1684 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1685 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1686 if test -f $srcdir/REVISION ; then
1687 gcc_REVISION=`cat $srcdir/REVISION`
1691 cat > plugin-version.h <<EOF
1692 #include "configargs.h"
1694 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1695 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1696 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1697 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1699 static char basever[] = "$gcc_BASEVER";
1700 static char datestamp[] = "$gcc_DATESTAMP";
1701 static char devphase[] = "$gcc_DEVPHASE";
1702 static char revision[] = "$gcc_REVISION";
1704 /* FIXME plugins: We should make the version information more precise.
1705 One way to do is to add a checksum. */
1707 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1709 configuration_arguments};
1713 # Internationalization
1714 ZW_GNU_GETTEXT_SISTER_DIR
1716 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1717 # -liconv on the link line twice.
1718 case "$LIBINTL" in *$LIBICONV*)
1722 AC_ARG_ENABLE(secureplt,
1723 [AS_HELP_STRING([--enable-secureplt],
1724 [enable -msecure-plt by default for PowerPC])],
1727 AC_ARG_ENABLE(leading-mingw64-underscores,
1728 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1729 [enable leading underscores on 64 bit mingw targets]),
1731 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1732 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1733 [Define if we should use leading underscore on 64 bit mingw targets])])
1736 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1739 AC_ARG_ENABLE(frame-pointer,
1740 [AS_HELP_STRING([--enable-frame-pointer],
1741 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1744 linux* | darwin[[8912]]*)
1745 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1747 enable_frame_pointer=no
1750 enable_frame_pointer=yes
1755 # Windows32 Registry support for specifying GCC installation paths.
1756 AC_ARG_ENABLE(win32-registry,
1757 [AS_HELP_STRING([--disable-win32-registry],
1758 [disable lookup of installation paths in the
1759 Registry on Windows hosts])
1760 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1761 AS_HELP_STRING([--enable-win32-registry=KEY],
1762 [use KEY instead of GCC version as the last portion
1763 of the registry key])],,)
1766 win32 | pe | cygwin* | mingw32* | uwin*)
1767 if test "x$enable_win32_registry" != xno; then
1768 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1771 if test "x$enable_win32_registry" != xno; then
1772 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1773 [Define to 1 if installation paths should be looked up in the Windows
1774 Registry. Ignored on non-Windows hosts.])
1776 if test "x$enable_win32_registry" != xyes \
1777 && test "x$enable_win32_registry" != x; then
1778 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1779 [Define to be the last component of the Windows registry key under which
1780 to look for installation paths. The full key used will be
1781 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1782 The default is the GCC version number.])
1788 # Get an absolute path to the GCC top-level source directory
1789 holddir=`${PWDCMD-pwd}`
1791 topdir=`${PWDCMD-pwd}`
1794 # Conditionalize the makefile for this host machine.
1796 for f in ${host_xmake_file}
1798 if test -f ${srcdir}/config/$f
1800 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1804 # Conditionalize the makefile for this target machine.
1806 for f in ${tmake_file}
1808 if test -f ${srcdir}/config/$f
1810 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1813 tmake_file="${tmake_file_}"
1815 out_object_file=`basename $out_file .c`.o
1816 common_out_object_file=`basename $common_out_file .c`.o
1818 tm_file_list="options.h"
1819 tm_include_list="options.h insn-constants.h"
1820 for f in $tm_file; do
1823 f=`echo $f | sed 's/^..//'`
1824 tm_file_list="${tm_file_list} $f"
1825 tm_include_list="${tm_include_list} $f"
1828 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1829 tm_include_list="${tm_include_list} $f"
1832 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1833 tm_include_list="${tm_include_list} config/$f"
1840 for f in $tm_p_file; do
1843 tm_p_file_list="${tm_p_file_list} $f"
1844 tm_p_include_list="${tm_p_include_list} $f"
1847 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1848 tm_p_include_list="${tm_p_include_list} config/$f"
1854 for f in $xm_file; do
1857 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1858 xm_include_list="${xm_include_list} $f"
1861 xm_file_list="${xm_file_list} $f"
1862 xm_include_list="${xm_include_list} $f"
1865 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1866 xm_include_list="${xm_include_list} config/$f"
1872 host_xm_include_list=
1873 for f in $host_xm_file; do
1876 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1877 host_xm_include_list="${host_xm_include_list} $f"
1880 host_xm_file_list="${host_xm_file_list} $f"
1881 host_xm_include_list="${host_xm_include_list} $f"
1884 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1885 host_xm_include_list="${host_xm_include_list} config/$f"
1891 for f in $build_xm_file; do
1894 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1895 build_xm_include_list="${build_xm_include_list} $f"
1897 auto-build.h | auto-host.h )
1898 build_xm_file_list="${build_xm_file_list} $f"
1899 build_xm_include_list="${build_xm_include_list} $f"
1902 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1903 build_xm_include_list="${build_xm_include_list} config/$f"
1908 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1909 # cross-compiler which does not use the native headers and libraries.
1910 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1911 CROSS= AC_SUBST(CROSS)
1912 ALL=all.internal AC_SUBST(ALL)
1913 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1915 if test "x$with_build_sysroot" != x; then
1916 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1918 # This value is used, even on a native system, because
1919 # CROSS_SYSTEM_HEADER_DIR is just
1920 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1921 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1924 if test x$host != x$target
1926 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1928 SYSTEM_HEADER_DIR=$build_system_header_dir
1929 case "$host","$target" in
1930 # Darwin crosses can use the host system's libraries and headers,
1931 # because of the fat library support. Of course, it must be the
1932 # same version of Darwin on both sides. Allow the user to
1933 # just say --target=foo-darwin without a version number to mean
1934 # "the version on this system".
1935 *-*-darwin*,*-*-darwin*)
1936 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1937 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1938 if test $hostos = $targetos -o $targetos = darwin ; then
1940 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1945 i?86-*-*,x86_64-*-* \
1946 | powerpc*-*-*,powerpc64*-*-*)
1947 CROSS="$CROSS -DNATIVE_CROSS" ;;
1952 if test "x$with_headers" = x; then
1959 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1960 SYSTEM_HEADER_DIR=$build_system_header_dir
1963 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
1964 if test "x$with_headers" != x; then
1965 target_header_dir=$with_headers
1966 elif test "x$with_sysroot" = x; then
1967 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
1968 elif test "x$with_build_sysroot" != "x"; then
1969 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
1970 elif test "x$with_sysroot" = xyes; then
1971 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
1973 target_header_dir="${with_sysroot}${native_system_header_dir}"
1976 target_header_dir=${native_system_header_dir}
1979 # If this is a cross-compiler that does not
1980 # have its own set of headers then define
1983 # If this is using newlib, without having the headers available now,
1984 # then define inhibit_libc in LIBGCC2_CFLAGS.
1985 # This prevents libgcc2 from containing any code which requires libc
1987 : ${inhibit_libc=false}
1988 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1989 test x$with_newlib = xyes ; } &&
1990 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
1993 AC_SUBST(inhibit_libc)
1995 # When building gcc with a cross-compiler, we need to adjust things so
1996 # that the generator programs are still built with the native compiler.
1997 # Also, we cannot run fixincludes.
1999 # These are the normal (build=host) settings:
2000 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2001 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2002 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2003 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2004 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2005 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2007 # And these apply if build != host, or we are generating coverage data
2008 if test x$build != x$host || test "x$coverage_flags" != x
2010 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2011 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2012 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2015 # Expand extra_headers to include complete path.
2016 # This substitutes for lots of t-* files.
2018 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2019 for file in ${extra_headers} ; do
2020 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2023 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2024 if test x"$use_gcc_tgmath" = xyes
2025 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2028 # Define collect2 in Makefile.
2029 case $host_can_use_collect2 in
2031 *) collect2='collect2$(exeext)' ;;
2033 AC_SUBST([collect2])
2035 # Add a definition of USE_COLLECT2 if system wants one.
2036 case $use_collect2 in
2037 no) use_collect2= ;;
2040 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2041 xm_defines="${xm_defines} USE_COLLECT2"
2042 case $host_can_use_collect2 in
2044 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2050 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2051 [Define to the name of the LTO plugin DSO that must be
2052 passed to the linker's -plugin=LIB option.])
2054 # ---------------------------
2055 # Assembler & linker features
2056 # ---------------------------
2058 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2059 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2060 # However when ld-new is first executed from the build tree, libtool will
2061 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2062 # to the build tree. While doing this we need to use the previous-stage
2063 # linker, or we have an infinite loop. The presence of a shell script as
2064 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2065 # the gcc/collect-ld script. So we need to know how libtool works, or
2066 # exec-tool will fail.
2068 m4_defun([_LT_CONFIG_COMMANDS], [])
2071 AC_SUBST(enable_fast_install)
2073 # Identify the assembler which will work hand-in-glove with the newly
2074 # built GCC, so that we can examine its features. This is the assembler
2075 # which will be driven by the driver program.
2077 # If build != host, and we aren't building gas in-tree, we identify a
2078 # build->target assembler and hope that it will have the same features
2079 # as the host->target assembler we'll be using.
2080 gcc_cv_gas_major_version=
2081 gcc_cv_gas_minor_version=
2082 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2084 m4_pattern_allow([AS_FOR_TARGET])dnl
2085 AS_VAR_SET_IF(gcc_cv_as,, [
2086 if test -x "$DEFAULT_ASSEMBLER"; then
2087 gcc_cv_as="$DEFAULT_ASSEMBLER"
2088 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2089 && test -f ../gas/Makefile \
2090 && test x$build = x$host; then
2091 gcc_cv_as=../gas/as-new$build_exeext
2092 elif test -x as$build_exeext; then
2093 # Build using assembler in the current directory.
2094 gcc_cv_as=./as$build_exeext
2095 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2096 gcc_cv_as="$AS_FOR_TARGET"
2098 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2101 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2102 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2103 case "$ORIGINAL_AS_FOR_TARGET" in
2104 ./as | ./as$build_exeext) ;;
2105 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2108 AC_MSG_CHECKING(what assembler to use)
2109 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2110 # Single tree build which includes gas. We want to prefer it
2111 # over whatever linker top-level may have detected, since
2112 # we'll use what we're building after installation anyway.
2113 AC_MSG_RESULT(newly built gas)
2115 _gcc_COMPUTE_GAS_VERSION
2116 in_tree_gas_is_elf=no
2117 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2118 || (grep 'obj_format = multi' ../gas/Makefile \
2119 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2121 in_tree_gas_is_elf=yes
2124 AC_MSG_RESULT($gcc_cv_as)
2130 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2131 [case "${enableval}" in
2137 install_gold_as_default=no
2139 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2140 [case "${enableval}" in
2142 install_gold_as_default=yes
2145 if test x${default_ld} != x; then
2146 install_gold_as_default=yes
2152 AC_MSG_ERROR([invalid --enable-gold argument])
2156 # Identify the linker which will work hand-in-glove with the newly
2157 # built GCC, so that we can examine its features. This is the linker
2158 # which will be driven by the driver program.
2160 # If build != host, and we aren't building gas in-tree, we identify a
2161 # build->target linker and hope that it will have the same features
2162 # as the host->target linker we'll be using.
2163 gcc_cv_gld_major_version=
2164 gcc_cv_gld_minor_version=
2165 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2166 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2167 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2169 AS_VAR_SET_IF(gcc_cv_ld,, [
2170 if test -x "$DEFAULT_LINKER"; then
2171 gcc_cv_ld="$DEFAULT_LINKER"
2172 elif test $install_gold_as_default = yes \
2173 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2174 && test -f ../gold/Makefile \
2175 && test x$build = x$host; then
2176 gcc_cv_ld=../gold/ld-new$build_exeext
2177 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2178 && test -f ../ld/Makefile \
2179 && test x$build = x$host; then
2180 gcc_cv_ld=../ld/ld-new$build_exeext
2181 elif test -x collect-ld$build_exeext; then
2182 # Build using linker in the current directory.
2183 gcc_cv_ld=./collect-ld$build_exeext
2184 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2185 gcc_cv_ld="$LD_FOR_TARGET"
2187 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2190 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2191 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2192 # if the PLUGIN_LD is set ld-new, just have it as ld
2193 # as that is the installed named.
2194 if test x$PLUGIN_LD_SUFFIX = xld-new \
2195 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2198 AC_ARG_WITH(plugin-ld,
2199 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2200 [if test x"$withval" != x; then
2201 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2202 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2204 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2205 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2207 # Check to see if we are using gold instead of ld
2208 AC_MSG_CHECKING(whether we are using gold)
2210 if test x$gcc_cv_ld != x; then
2211 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2212 | grep "GNU gold" > /dev/null; then
2216 AC_MSG_RESULT($ld_is_gold)
2218 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2219 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2220 case "$ORIGINAL_LD_FOR_TARGET" in
2221 ./collect-ld | ./collect-ld$build_exeext) ;;
2222 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2225 AC_MSG_CHECKING(what linker to use)
2226 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2227 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2228 # Single tree build which includes ld. We want to prefer it
2229 # over whatever linker top-level may have detected, since
2230 # we'll use what we're building after installation anyway.
2231 AC_MSG_RESULT(newly built ld)
2233 in_tree_ld_is_elf=no
2234 if (grep 'EMUL = .*elf' ../ld/Makefile \
2235 || grep 'EMUL = .*linux' ../ld/Makefile \
2236 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2237 in_tree_ld_is_elf=yes
2238 elif test "$ld_is_gold" = yes; then
2239 in_tree_ld_is_elf=yes
2241 for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in
2244 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2245 if test x$gcc_cv_gld_version != x; then
2249 case $gcc_cv_gld_version in
2252 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2255 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2256 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2258 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2259 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2261 AC_MSG_RESULT($gcc_cv_ld)
2263 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2264 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2265 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2268 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2269 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2271 # Figure out what nm we will be using.
2272 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2273 AS_VAR_SET_IF(gcc_cv_nm,, [
2274 if test -f $gcc_cv_binutils_srcdir/configure.in \
2275 && test -f ../binutils/Makefile \
2276 && test x$build = x$host; then
2277 gcc_cv_nm=../binutils/nm-new$build_exeext
2278 elif test -x nm$build_exeext; then
2279 gcc_cv_nm=./nm$build_exeext
2280 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2281 gcc_cv_nm="$NM_FOR_TARGET"
2283 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2286 AC_MSG_CHECKING(what nm to use)
2287 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2288 # Single tree build which includes binutils.
2289 AC_MSG_RESULT(newly built nm)
2292 AC_MSG_RESULT($gcc_cv_nm)
2296 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2297 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2298 case "$ORIGINAL_NM_FOR_TARGET" in
2299 ./nm | ./nm$build_exeext) ;;
2300 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2304 # Figure out what objdump we will be using.
2305 AS_VAR_SET_IF(gcc_cv_objdump,, [
2306 if test -f $gcc_cv_binutils_srcdir/configure.in \
2307 && test -f ../binutils/Makefile \
2308 && test x$build = x$host; then
2309 # Single tree build which includes binutils.
2310 gcc_cv_objdump=../binutils/objdump$build_exeext
2311 elif test -x objdump$build_exeext; then
2312 gcc_cv_objdump=./objdump$build_exeext
2313 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2314 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2316 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2319 AC_MSG_CHECKING(what objdump to use)
2320 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2321 # Single tree build which includes binutils.
2322 AC_MSG_RESULT(newly built objdump)
2323 elif test x$gcc_cv_objdump = x; then
2324 AC_MSG_RESULT(not found)
2326 AC_MSG_RESULT($gcc_cv_objdump)
2329 # Figure out what readelf we will be using.
2330 AS_VAR_SET_IF(gcc_cv_readelf,, [
2331 if test -f $gcc_cv_binutils_srcdir/configure.in \
2332 && test -f ../binutils/Makefile \
2333 && test x$build = x$host; then
2334 # Single tree build which includes binutils.
2335 gcc_cv_readelf=../binutils/readelf$build_exeext
2336 elif test -x readelf$build_exeext; then
2337 gcc_cv_readelf=./readelf$build_exeext
2339 AC_PATH_PROG(gcc_cv_readelf, readelf)
2342 AC_MSG_CHECKING(what readelf to use)
2343 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2344 # Single tree build which includes binutils.
2345 AC_MSG_RESULT(newly built readelf)
2346 elif test x$gcc_cv_readelf = x; then
2347 AC_MSG_RESULT(not found)
2349 AC_MSG_RESULT($gcc_cv_readelf)
2352 # Figure out what assembler alignment features are present.
2353 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2357 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2358 [Define if your assembler supports .balign and .p2align.])])
2360 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2363 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2364 [Define if your assembler supports specifying the maximum number
2365 of bytes to skip when using the GAS .p2align command.])])
2367 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2370 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2371 [Define if your assembler supports .literal16.])])
2373 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2375 [conftest_label1: .word 0
2377 conftest_label2: .word 0
2379 [if test x$gcc_cv_nm != x; then
2380 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2381 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2382 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2384 else gcc_cv_as_subsection_m1=yes
2386 rm -f conftest.nm1 conftest.nm2
2388 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2389 [Define if your assembler supports .subsection and .subsection -1 starts
2390 emitting at the beginning of your section.])])
2392 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2395 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2397 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2399 [ .weakref foobar, barfnot],,
2400 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2402 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2405 .NSUBSPA $CODE$,COMDAT],,
2406 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2408 # .hidden needs to be supported in both the assembler and the linker,
2409 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2410 # This is irritatingly difficult to feature test for; we have to check the
2411 # date string after the version number. If we've got an in-tree
2412 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2414 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2415 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2421 # Darwin as has some visibility support, though with a different syntax.
2422 gcc_cv_as_hidden=yes
2426 # gnu_indirect_function type is an extension proposed at
2427 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2428 # selection of function implementation
2429 AC_ARG_ENABLE(gnu-indirect-function,
2430 [AS_HELP_STRING([--enable-gnu-indirect-function],
2431 [enable the use of the @gnu_indirect_function to glibc systems])],
2432 [case $enable_gnu_indirect_function in
2434 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2435 Valid choices are 'yes' and 'no'.]) ;;
2437 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2439 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2440 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2441 [Define if your system supports gnu indirect functions.])
2445 if test $in_tree_ld != yes ; then
2446 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2447 if echo "$ld_ver" | grep GNU > /dev/null; then
2448 if test x"$ld_is_gold" = xyes; then
2449 # GNU gold --version looks like this:
2451 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2453 # We extract the binutils version which is more familiar and specific
2454 # than the gold version.
2455 ld_vers=`echo $ld_ver | sed -n \
2456 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2458 # GNU ld --version looks like this:
2460 # GNU ld (GNU Binutils) 2.21.51.20110225
2461 ld_vers=`echo $ld_ver | sed -n \
2462 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2464 ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)[-]*\([01][0-9]\)[-]*\([0-3][0-9]\).*$,\1\2\3,p'`
2465 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2466 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2467 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2471 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2474 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2475 # /usr/ccs/bin/ld has been configured.
2476 ld_ver=`$gcc_cv_ld -V 2>&1`
2477 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2478 ld_vers=`echo $ld_ver | sed -n \
2479 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2480 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2481 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2489 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2490 [[if test $in_tree_ld = yes ; then
2492 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 \
2493 && test $in_tree_ld_is_elf = yes; then
2494 gcc_cv_ld_hidden=yes
2497 gcc_cv_ld_hidden=yes
2498 if test x"$ld_is_gold" = xyes; then
2500 elif echo "$ld_ver" | grep GNU > /dev/null; then
2502 mmix-knuth-mmixware)
2503 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2507 if test 0"$ld_date" -lt 20020404; then
2508 if test -n "$ld_date"; then
2509 # If there was date string, but was earlier than 2002-04-04, fail
2511 elif test -z "$ld_vers"; then
2512 # If there was no date string nor ld version number, something is wrong
2515 test -z "$ld_vers_patch" && ld_vers_patch=0
2516 if test "$ld_vers_major" -lt 2; then
2518 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2519 gcc_cv_ld_hidden="no"
2520 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2528 # Darwin ld has some visibility support.
2529 gcc_cv_ld_hidden=yes
2531 hppa64*-*-hpux* | ia64*-*-hpux*)
2532 gcc_cv_ld_hidden=yes
2534 *-*-solaris2.1[0-9]*)
2535 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2536 # .symbolic was only added in Solaris 9 12/02.
2537 gcc_cv_ld_hidden=yes
2545 libgcc_visibility=no
2546 AC_SUBST(libgcc_visibility)
2547 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2548 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2549 libgcc_visibility=yes
2550 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2551 [Define if your assembler and linker support .hidden.])
2554 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2555 gcc_cv_ld_ro_rw_mix=unknown
2556 if test $in_tree_ld = yes ; then
2557 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 \
2558 && test $in_tree_ld_is_elf = yes; then
2559 gcc_cv_ld_ro_rw_mix=read-write
2561 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2562 echo '.section myfoosect, "a"' > conftest1.s
2563 echo '.section myfoosect, "aw"' > conftest2.s
2564 echo '.byte 1' >> conftest2.s
2565 echo '.section myfoosect, "a"' > conftest3.s
2566 echo '.byte 0' >> conftest3.s
2567 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2568 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2569 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2570 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2571 conftest2.o conftest3.o > /dev/null 2>&1; then
2572 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2573 | sed -e '/myfoosect/!d' -e N`
2574 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2575 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2576 gcc_cv_ld_ro_rw_mix=read-only
2578 gcc_cv_ld_ro_rw_mix=read-write
2583 rm -f conftest.* conftest[123].*
2586 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2587 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2588 [Define if your linker links a mix of read-only
2589 and read-write sections into a read-write section.])
2591 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2593 gcc_AC_INITFINI_ARRAY
2595 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2596 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2604 [[# GAS versions before 2.11 do not support uleb128,
2605 # despite appearing to.
2606 # ??? There exists an elf-specific test that will crash
2607 # the assembler. Perhaps it's better to figure out whether
2608 # arbitrary sections are supported and try the test.
2609 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2610 if echo "$as_ver" | grep GNU > /dev/null; then
2611 as_vers=`echo $as_ver | sed -n \
2612 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2613 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2614 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2615 if test $as_major -eq 2 && test $as_minor -lt 11
2617 else gcc_cv_as_leb128=yes
2620 [AC_DEFINE(HAVE_AS_LEB128, 1,
2621 [Define if your assembler supports .sleb128 and .uleb128.])])
2623 # Check if we have assembler support for unwind directives.
2624 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2631 .cfi_escape 1, 2, 3, 4, 5
2635 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2636 # read-only and read-write sections, we need to make sure that the
2637 # assembler used emits read-write .eh_frame sections.
2638 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2639 if test "x$gcc_cv_objdump" != x; then
2640 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2641 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2642 gcc_cv_as_cfi_directive=no
2645 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2646 # On Solaris/x86, make sure that GCC and assembler agree on using
2647 # read-only .eh_frame sections for 64-bit.
2648 if test x$gas = xyes; then
2649 as_ix86_64_opt="--64"
2651 as_ix86_64_opt="-xarch=amd64"
2653 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2654 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2655 sed -e /.eh_frame/!d -e N | \
2656 grep READONLY > /dev/null; then
2657 gcc_cv_as_cfi_directive=yes
2659 gcc_cv_as_cfi_directive=no
2663 gcc_cv_as_cfi_directive=yes
2668 # no objdump, err on the side of caution
2669 gcc_cv_as_cfi_directive=no
2672 gcc_cv_as_cfi_directive=yes
2676 gcc_cv_as_cfi_directive=yes
2679 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2680 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2684 .cfi_adjust_cfa_offset 64
2686 .cfi_adjust_cfa_offset 128
2689 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2690 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2691 gcc_cv_as_cfi_advance_working=yes
2695 # no objdump, err on the side of caution
2696 gcc_cv_as_cfi_advance_working=no
2698 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2699 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2700 [`if test $gcc_cv_as_cfi_directive = yes \
2701 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2702 [Define 0/1 if your assembler supports CFI directives.])
2704 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2705 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2706 gcc_cv_as_cfi_personality_directive, ,,
2709 .cfi_personality 0, symbol
2711 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2712 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2713 then echo 1; else echo 0; fi`],
2714 [Define 0/1 if your assembler supports .cfi_personality.])
2716 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2717 gcc_cv_as_cfi_sections_directive, ,,
2719 .cfi_sections .debug_frame, .eh_frame
2723 win32 | pe | cygwin* | mingw32* | uwin*)
2724 # Need to check that we generated the correct relocation for the
2725 # .debug_frame section. This was fixed for binutils 2.21.
2726 gcc_cv_as_cfi_sections_directive=no
2727 if test "x$gcc_cv_objdump" != x; then
2728 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2729 grep secrel > /dev/null; then
2730 gcc_cv_as_cfi_sections_directive=yes
2735 gcc_cv_as_cfi_sections_directive=yes
2738 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2739 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2740 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2741 then echo 1; else echo 0; fi`],
2742 [Define 0/1 if your assembler supports .cfi_sections.])
2744 # GAS versions up to and including 2.11.0 may mis-optimize
2746 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2754 .section .eh_frame,"aw",@progbits
2756 .4byte .LECIE1-.LSCIE1
2770 .4byte .LEFDE1-.LASFDE1
2772 .4byte .LASFDE1-__FRAME_BEGIN__
2780 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2781 cat > conftest.lit <<EOF
2782 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2783 0010 01000000 12000000 18000000 00000000 ................
2784 0020 08000000 04080000 0044 .........D @&t@
2786 cat > conftest.big <<EOF
2787 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2788 0010 00000001 00000012 00000018 00000000 ................
2789 0020 00000008 04000000 0844 .........D @&t@
2791 # If the assembler didn't choke, and we can objdump,
2792 # and we got the correct data, then succeed.
2793 # The text in the here-document typically retains its unix-style line
2794 # endings, while the output of objdump will use host line endings.
2795 # Therefore, use diff -b for the comparisons.
2796 if test x$gcc_cv_objdump != x \
2797 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2798 | tail -3 > conftest.got \
2799 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2800 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2802 gcc_cv_as_eh_frame=yes
2803 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2804 gcc_cv_as_eh_frame=buggy
2806 # Uh oh, what do we do now?
2807 gcc_cv_as_eh_frame=no
2810 if test $gcc_cv_as_eh_frame = buggy; then
2811 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2812 [Define if your assembler mis-optimizes .eh_frame data.])
2815 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2816 [elf,2,12,0], [--fatal-warnings],
2817 [.section .rodata.str, "aMS", @progbits, 1])
2818 if test $gcc_cv_as_shf_merge = no; then
2819 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2820 [elf,2,12,0], [--fatal-warnings],
2821 [.section .rodata.str, "aMS", %progbits, 1])
2823 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2824 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2825 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2827 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2828 gcc_cv_as_comdat_group,
2829 [elf,2,16,0], [--fatal-warnings],
2830 [.section .text,"axG",@progbits,.foo,comdat])
2831 if test $gcc_cv_as_comdat_group = yes; then
2832 gcc_cv_as_comdat_group_percent=no
2833 gcc_cv_as_comdat_group_group=no
2835 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2836 gcc_cv_as_comdat_group_percent,
2837 [elf,2,16,0], [--fatal-warnings],
2838 [.section .text,"axG",%progbits,.foo,comdat])
2839 if test $gcc_cv_as_comdat_group_percent = yes; then
2840 gcc_cv_as_comdat_group_group=no
2843 # Sun as uses a completely different syntax.
2848 .group foo,".text%foo",#comdat
2849 .section ".text%foo", #alloc,#execinstr,#progbits
2854 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2856 .group foo,.text%foo,#comdat
2857 .section .text%foo, "ax", @progbits
2863 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2864 gcc_cv_as_comdat_group_group,
2868 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2869 gcc_cv_as_comdat_group_group=no
2873 if test x"$ld_is_gold" = xyes; then
2875 elif test $in_tree_ld = yes ; then
2877 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 \
2878 && test $in_tree_ld_is_elf = yes; then
2881 elif echo "$ld_ver" | grep GNU > /dev/null; then
2883 if test 0"$ld_date" -lt 20050308; then
2884 if test -n "$ld_date"; then
2885 # If there was date string, but was earlier than 2005-03-08, fail
2887 elif test "$ld_vers_major" -lt 2; then
2889 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2896 *-*-solaris2.1[1-9]*)
2898 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2899 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2902 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2903 # least ld version 1.2267.
2904 if test "$ld_vers_major" -gt 1; then
2906 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2908 elif test "$ld_vers_minor" -ge 2267; then
2913 # Assume linkers other than GNU ld don't support COMDAT group.
2919 # Allow overriding the automatic COMDAT group tests above.
2920 AC_ARG_ENABLE(comdat,
2921 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2922 [comdat_group="$enable_comdat"])
2923 if test $comdat_group = no; then
2924 gcc_cv_as_comdat_group=no
2925 gcc_cv_as_comdat_group_percent=no
2926 gcc_cv_as_comdat_group_group=no
2928 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2929 [`if test $gcc_cv_as_comdat_group = yes \
2930 || test $gcc_cv_as_comdat_group_percent = yes \
2931 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2932 [Define 0/1 if your assembler and linker support COMDAT groups.])
2934 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2935 gcc_cv_as_discriminator,
2939 .loc 1 1 0 discriminator 1],,
2940 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2941 [Define if your assembler supports the .loc discriminator sub-directive.])])
2943 # Thread-local storage - the check is heavily parameterized.
2952 .section ".tdata","awT",@progbits
2955 ldq $27,__tls_get_addr($29) !literal!1
2956 lda $16,foo($29) !tlsgd!1
2957 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2958 ldq $27,__tls_get_addr($29) !literal!2
2959 lda $16,foo($29) !tlsldm!2
2960 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2961 ldq $1,foo($29) !gotdtprel
2962 ldah $2,foo($29) !dtprelhi
2963 lda $3,foo($2) !dtprello
2964 lda $4,foo($29) !dtprel
2965 ldq $1,foo($29) !gottprel
2966 ldah $2,foo($29) !tprelhi
2967 lda $3,foo($2) !tprello
2968 lda $4,foo($29) !tprel'
2971 tls_as_opt=--fatal-warnings
2973 cris-*-*|crisv32-*-*)
2975 .section ".tdata","awT",@progbits
2982 tls_as_opt=--fatal-warnings
2986 .section ".tdata","awT",@progbits
2998 .section ".tdata","awT",@progbits
3002 addil LT%foo-$tls_gdidx$,gp
3003 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3006 addil LT%foo-$tls_ldidx$,gp
3008 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3009 addil LR%foo-$tls_dtpoff$,%ret0
3010 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3012 addil LT%foo-$tls_ieoff$,gp
3013 ldw RT%foo-$tls_ieoff$(%r1),%t2
3016 addil LR%foo-$tls_leoff$,%t1
3017 ldo RR%foo-$tls_leoff$(%r1),%t2'
3020 tls_as_opt=--fatal-warnings
3024 .section ".tdata","awT",%progbits
3035 i[34567]86-*-* | x86_64-*-*)
3037 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
3044 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3046 .section .tdata,"awt",@progbits'
3051 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3052 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3056 .section ".tdata","awT",@progbits'
3060 tls_as_opt="--fatal-warnings"
3064 conftest_s="$conftest_s
3068 leal foo@tlsgd(,%ebx,1), %eax
3069 leal foo@tlsldm(%ebx), %eax
3070 leal foo@dtpoff(%eax), %edx
3071 movl foo@gottpoff(%ebx), %eax
3072 subl foo@gottpoff(%ebx), %eax
3073 addl foo@gotntpoff(%ebx), %eax
3074 movl foo@indntpoff, %eax
3075 movl \$foo@tpoff, %eax
3076 subl \$foo@tpoff, %eax
3077 leal foo@ntpoff(%ecx), %eax"
3080 if test x$on_solaris = xyes; then
3082 yes) tls_as_opt="$tls_as_opt --64" ;;
3083 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3086 conftest_s="$conftest_s
3090 leaq foo@tlsgd(%rip), %rdi
3091 leaq foo@tlsld(%rip), %rdi
3092 leaq foo@dtpoff(%rax), %rdx
3093 movq foo@gottpoff(%rip), %rax
3094 movq \$foo@tpoff, %rax"
3100 .section ".tdata","awT",@progbits
3103 addl r16 = @ltoff(@dtpmod(foo#)), gp
3104 addl r17 = @ltoff(@dtprel(foo#)), gp
3105 addl r18 = @ltoff(@tprel(foo#)), gp
3106 addl r19 = @dtprel(foo#), gp
3107 adds r21 = @dtprel(foo#), r13
3108 movl r23 = @dtprel(foo#)
3109 addl r20 = @tprel(foo#), gp
3110 adds r22 = @tprel(foo#), r13
3111 movl r24 = @tprel(foo#)'
3114 tls_as_opt=--fatal-warnings
3118 .section .tdata,"awT",@progbits
3122 addik r5,r20,x@TLSGD
3123 addik r5,r20,x@TLSLDM'
3126 tls_as_opt='--fatal-warnings'
3130 .section .tdata,"awT",@progbits
3134 addiu $4, $28, %tlsgd(x)
3135 addiu $4, $28, %tlsldm(x)
3136 lui $4, %dtprel_hi(x)
3137 addiu $4, $4, %dtprel_lo(x)
3138 lw $4, %gottprel(x)($28)
3139 lui $4, %tprel_hi(x)
3140 addiu $4, $4, %tprel_lo(x)'
3143 tls_as_opt='-32 --fatal-warnings'
3147 .section .tdata,"awT",@progbits
3152 move.l x@TLSGD(%a5),%a0
3153 move.l x@TLSLDM(%a5),%a0
3154 move.l x@TLSLDO(%a5),%a0
3155 move.l x@TLSIE(%a5),%a0
3156 move.l x@TLSLE(%a5),%a0'
3159 tls_as_opt='--fatal-warnings'
3163 .section ".tdata","awT",@progbits'
3166 tls_as_opt="--fatal-warnings"
3170 .section ".tdata","awT",%progbits
3174 add x0, x0, #:tlsgd_lo12:x
3179 tls_as_opt='--fatal-warnings'
3183 .extern __get_tpointer
3201 .section ".tdata","awT",@progbits
3209 addi 3,2,ld0@got@tlsgd
3215 addi 3,2,x1@got@tlsld
3221 addis 9,3,x2@dtprel@ha
3222 addi 9,9,x2@dtprel@l
3225 ld 9,x3@got@dtprel(2)
3231 tls_as_opt="-a64 --fatal-warnings"
3235 .section ".tdata","awT",@progbits
3243 addi 3,31,ld0@got@tlsgd
3245 addi 3,31,x1@got@tlsld
3248 addis 9,3,x2@dtprel@ha
3249 addi 9,9,x2@dtprel@l
3250 lwz 9,x3@got@tprel(31)
3253 addis 9,2,x2@tprel@ha
3254 addi 9,9,x2@tprel@l'
3257 tls_as_opt="-a32 --fatal-warnings"
3261 .section ".tdata","awT",@progbits
3270 l %r1,foo@GOTNTPOFF(%r12)
3271 l %r1,0(%r1):tls_load:foo
3272 bas %r14,0(%r1,%r13):tls_gdcall:foo
3273 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3276 tls_as_opt="-m31 --fatal-warnings"
3280 .section ".tdata","awT",@progbits
3288 lg %r1,foo@GOTNTPOFF(%r12)
3289 larl %r1,foo@INDNTPOFF
3290 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3291 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3294 tls_as_opt="-m64 -Aesame --fatal-warnings"
3296 sh-*-* | sh[34]-*-*)
3298 .section ".tdata","awT",@progbits
3308 tls_as_opt=--fatal-warnings
3312 sparc*-sun-solaris2.*)
3319 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3321 .section ".tdata",#alloc,#write,#tls'
3326 .section ".tdata","awT",@progbits'
3329 tls_as_opt="-32 --fatal-warnings"
3331 conftest_s="$conftest_s
3334 sethi %tgd_hi22(foo), %o0
3335 add %o0, %tgd_lo10(foo), %o1
3336 add %l7, %o1, %o0, %tgd_add(foo)
3337 call __tls_get_addr, %tgd_call(foo)
3338 sethi %tldm_hi22(foo), %l1
3339 add %l1, %tldm_lo10(foo), %l2
3340 add %l7, %l2, %o0, %tldm_add(foo)
3341 call __tls_get_addr, %tldm_call(foo)
3342 sethi %tldo_hix22(foo), %l3
3343 xor %l3, %tldo_lox10(foo), %l4
3344 add %o0, %l4, %l5, %tldo_add(foo)
3345 sethi %tie_hi22(foo), %o3
3346 add %o3, %tie_lo10(foo), %o3
3347 ld [%l7 + %o3], %o2, %tie_ld(foo)
3348 add %g7, %o2, %o4, %tie_add(foo)
3349 sethi %tle_hix22(foo), %l1
3350 xor %l1, %tle_lox10(foo), %o5
3351 ld [%g7 + %o5], %o1"
3355 .section ".tdata","awT",@progbits
3358 addli r0, zero, tls_gd(foo)
3359 auli r0, zero, tls_gd_ha16(foo)
3360 addli r0, r0, tls_gd_lo16(foo)
3362 addli r0, zero, tls_ie(foo)
3363 auli r0, r0, tls_ie_ha16(foo)
3364 addli r0, r0, tls_ie_lo16(foo)'
3367 tls_as_opt="--fatal-warnings"
3371 .section ".tdata","awT",@progbits
3374 shl16insli r0, zero, hw0_last_tls_gd(foo)
3375 shl16insli r0, zero, hw1_last_tls_gd(foo)
3376 shl16insli r0, r0, hw0_tls_gd(foo)
3378 shl16insli r0, zero, hw1_last_tls_ie(foo)
3379 shl16insli r0, r0, hw0_tls_ie(foo)'
3382 tls_as_opt="--fatal-warnings"
3386 .section ".tdata","awT",@progbits
3389 movi a8, foo@TLSFUNC
3390 movi a10, foo@TLSARG
3391 callx8.tls a8, foo@TLSCALL'
3398 if test "x$enable_tls" = xno ; then
3399 : # TLS explicitly disabled.
3400 elif test "x$enable_tls" = xyes ; then
3401 set_have_as_tls=yes # TLS explicitly enabled.
3402 elif test -z "$tls_first_major"; then
3403 : # If we don't have a check, assume no support.
3405 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3406 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3407 [set_have_as_tls=yes])
3409 if test $set_have_as_tls = yes ; then
3410 AC_DEFINE(HAVE_AS_TLS, 1,
3411 [Define if your assembler and linker support thread-local storage.])
3414 # Target-specific assembler checks.
3416 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3417 gcc_cv_ld_static_dynamic=no
3418 gcc_cv_ld_static_option='-Bstatic'
3419 gcc_cv_ld_dynamic_option='-Bdynamic'
3420 if test $in_tree_ld = yes ; then
3421 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
3422 gcc_cv_ld_static_dynamic=yes
3424 elif test x$gcc_cv_ld != x; then
3425 # Check if linker supports -Bstatic/-Bdynamic option
3426 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3427 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3428 gcc_cv_ld_static_dynamic=yes
3431 # AIX ld uses -b flags
3432 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3433 gcc_cv_ld_static_dynamic=yes
3434 gcc_cv_ld_static_option="-bstatic"
3435 gcc_cv_ld_dynamic_option="-bdynamic"
3437 # HP-UX ld uses -a flags to select between shared and archive.
3439 if test x"$gnu_ld" = xno; then
3440 gcc_cv_ld_static_dynamic=yes
3441 gcc_cv_ld_static_option="-aarchive_shared"
3442 gcc_cv_ld_dynamic_option="-adefault"
3445 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3447 gcc_cv_ld_static_dynamic=yes
3452 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3453 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3454 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3455 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3456 [Define to the linker option to disable use of shared objects.])
3457 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3458 [Define to the linker option to enable use of shared objects.])
3460 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3462 if test x"$demangler_in_ld" = xyes; then
3463 AC_MSG_CHECKING(linker --demangle support)
3464 gcc_cv_ld_demangle=no
3465 if test $in_tree_ld = yes; then
3466 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 \
3467 gcc_cv_ld_demangle=yes
3469 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3470 # Check if the GNU linker supports --demangle option
3471 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3472 gcc_cv_ld_demangle=yes
3475 if test x"$gcc_cv_ld_demangle" = xyes; then
3476 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3477 [Define if your linker supports --demangle option.])
3479 AC_MSG_RESULT($gcc_cv_ld_demangle)
3482 AC_MSG_CHECKING(linker plugin support)
3484 if test -f liblto_plugin.la; then
3485 save_ld_ver="$ld_ver"
3486 save_ld_vers_major="$ld_vers_major"
3487 save_ld_vers_minor="$ld_vers_minor"
3488 save_ld_is_gold="$ld_is_gold"
3492 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3494 # FIXME: ld_is_gold?
3495 ld_vers_major="$gcc_cv_gld_major_version"
3496 ld_vers_minor="$gcc_cv_gld_minor_version"
3498 # Determine plugin linker version.
3499 # FIXME: Partial duplicate from above, generalize.
3501 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3502 if echo "$ld_ver" | grep GNU > /dev/null; then
3503 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3505 ld_vers=`echo $ld_ver | sed -n \
3506 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3508 ld_vers=`echo $ld_ver | sed -n \
3509 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3511 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3512 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3517 # Determine plugin support.
3518 if echo "$ld_ver" | grep GNU > /dev/null; then
3519 # Require GNU ld or gold 2.21+ for plugin support by default.
3520 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3522 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3523 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3528 ld_ver="$save_ld_ver"
3529 ld_vers_major="$save_ld_vers_major"
3530 ld_vers_minor="$save_ld_vers_minor"
3531 ld_is_gold="$save_ld_is_gold"
3533 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3534 [Define to the level of your linker's plugin support.])
3535 AC_MSG_RESULT($gcc_cv_lto_plugin)
3539 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3540 [-mabi=lp64], [.text],,,)
3541 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3542 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3543 [Define if your assembler supports the -mabi option.])
3545 if test x$with_abi = xilp32; then
3546 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3547 Upgrade the Assembler.])
3549 if test x"$with_multilib_list" = xdefault; then
3550 TM_MULTILIB_CONFIG=lp64
3552 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3553 for aarch64_multilib in ${aarch64_multilibs}; do
3554 case ${aarch64_multilib} in
3556 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3557 Upgrade the Assembler.])
3565 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
3566 AC_ARG_ENABLE(fix-cortex-a53-835769,
3568 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
3569 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3570 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
3571 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3576 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
3581 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
3582 Valid choices are 'yes' and 'no'.])
3588 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
3589 AC_ARG_ENABLE(fix-cortex-a53-843419,
3591 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
3592 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3593 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
3594 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3599 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
3604 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
3605 Valid choices are 'yes' and 'no'.])
3613 # All TARGET_ABI_OSF targets.
3614 alpha*-*-linux* | alpha*-*-*bsd*)
3615 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3616 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3619 extbl $3, $2, $3 !lituse_bytoff!1
3620 ldq $2, a($29) !literal!1
3621 ldq $4, b($29) !literal!2
3622 ldq_u $3, 0($2) !lituse_base!1
3623 ldq $27, f($29) !literal!5
3624 jsr $26, ($27), f !lituse_jsr!5
3625 ldah $29, 0($26) !gpdisp!3
3626 lda $0, c($29) !gprel
3627 ldah $1, d($29) !gprelhigh
3628 lda $1, d($1) !gprellow
3629 lda $29, 0($29) !gpdisp!3],,
3630 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3631 [Define if your assembler supports explicit relocations.])])
3632 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3633 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3636 ldq $27, a($29) !literal!1
3637 jsr $26, ($27), a !lituse_jsrdirect!1],,
3638 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3639 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3643 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,,
3644 [--mlink-relax], [.text],,
3645 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
3646 [Define if your avr assembler supports --mlink-relax option.])])
3648 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,,
3650 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
3651 [Define if your avr assembler supports -mrmw option.])])
3655 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3656 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3657 [-no-mul-bug-abort], [.text],,
3658 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3659 [Define if your assembler supports the -no-mul-bug-abort option.])])
3663 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3664 [.register %g2, #scratch],,
3665 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3666 [Define if your assembler supports .register.])])
3668 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3669 [.section "nobits",#alloc,#write,#nobits
3670 .section "progbits",#alloc,#write,#progbits])
3671 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3672 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3673 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3675 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3677 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3678 [Define if your assembler supports -relax option.])])
3680 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3681 gcc_cv_as_sparc_gotdata_op,,
3688 sethi %gdop_hix22(foo), %g1
3689 xor %g1, %gdop_lox10(foo), %g1
3690 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3691 [if test x$gcc_cv_ld != x \
3692 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3693 if test x$gcc_cv_objdump != x; then
3694 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3695 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3696 gcc_cv_as_sparc_gotdata_op=no
3698 gcc_cv_as_sparc_gotdata_op=yes
3703 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3704 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3706 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3707 gcc_cv_as_sparc_ua_pcrel,,
3715 .uaword %r_disp32(foo)],
3716 [if test x$gcc_cv_ld != x \
3717 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3718 gcc_cv_as_sparc_ua_pcrel=yes
3721 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3722 [Define if your assembler and linker support unaligned PC relative relocs.])
3724 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3725 gcc_cv_as_sparc_ua_pcrel_hidden,,
3730 .uaword %r_disp32(foo)
3731 .byte 0x32, 0x33, 0x34
3736 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3737 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3738 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3739 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3740 if $gcc_cv_objdump -R conftest 2> /dev/null \
3741 | grep 'DISP32' > /dev/null 2>&1; then
3744 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3748 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3749 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3750 ]) # unaligned pcrel relocs
3752 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3753 gcc_cv_as_sparc_offsetable_lo10,,
3756 or %g1, %lo(ab) + 12, %g1
3757 or %g1, %lo(ab + 12), %g1],
3758 [if test x$gcc_cv_objdump != x \
3759 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3760 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3761 gcc_cv_as_sparc_offsetable_lo10=yes
3763 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3764 [Define if your assembler supports offsetable %lo().])])
3766 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3767 gcc_cv_as_sparc_fmaf,,
3770 .register %g2, #scratch
3771 .register %g3, #scratch
3773 fmaddd %f0, %f2, %f4, %f6
3774 addxccc %g1, %g2, %g3
3775 fsrl32 %f2, %f4, %f8
3776 fnaddd %f10, %f12, %f14],,
3777 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3778 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3780 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3781 gcc_cv_as_sparc_sparc4,,
3784 .register %g2, #scratch
3785 .register %g3, #scratch
3788 1: cwbneg %g2, %g3, 1f
3791 aes_kexpand0 %f4, %f6, %f8
3792 des_round %f38, %f40, %f42, %f44
3793 camellia_f %f54, %f56, %f58, %f60
3794 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3795 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3796 [Define if your assembler supports SPARC4 instructions.])])
3798 gcc_GAS_CHECK_FEATURE([LEON instructions],
3799 gcc_cv_as_sparc_leon,,
3802 .register %g2, #scratch
3803 .register %g3, #scratch
3807 casa [[%g2]] 0xb, %g3, %g1],,
3808 [AC_DEFINE(HAVE_AS_LEON, 1,
3809 [Define if your assembler supports LEON instructions.])])
3813 i[34567]86-*-* | x86_64-*-*)
3817 # Full C++ conformance when using a shared libstdc++-v3 requires some
3818 # support from the Cygwin DLL, which in more recent versions exports
3819 # wrappers to aid in interposing and redirecting operators new, delete,
3820 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3821 # are configuring for a version of Cygwin that exports the wrappers.
3822 if test x$host = x$target && test x$host_cpu = xi686; then
3823 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3825 # Can't check presence of libc functions during cross-compile, so
3826 # we just have to assume we're building for an up-to-date target.
3827 gcc_ac_cygwin_dll_wrappers=yes
3829 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3830 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3831 [Define if you want to generate code by default that assumes that the
3832 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3835 cygwin* | pe | mingw32* | interix*)
3836 # Recent binutils allows the three-operand form of ".comm" on PE. This
3837 # definition is used unconditionally to initialise the default state of
3838 # the target option variable that governs usage of the feature.
3839 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3840 [2,19,52],,[.comm foo,1,32])
3841 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3842 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3843 [Define if your assembler supports specifying the alignment
3844 of objects allocated using the GAS .comm command.])
3845 # Used for DWARF 2 in PE
3846 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3847 gcc_cv_as_ix86_pe_secrel32,
3853 [if test x$gcc_cv_ld != x \
3854 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3855 gcc_cv_as_ix86_pe_secrel32=yes
3858 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3859 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3860 # Test if the assembler supports the extended form of the .section
3861 # directive that specifies section alignment. LTO support uses this,
3862 # but normally only after installation, so we warn but don't fail the
3863 # configure if LTO is enabled but the assembler does not support it.
3864 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3865 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3866 if test x$gcc_cv_as_section_has_align != xyes; then
3867 case ",$enable_languages," in
3869 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3876 # Test if the assembler supports the section flag 'e' for specifying
3877 # an excluded section.
3878 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3879 [2,22,51], [--fatal-warnings],
3882 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3883 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3884 [Define if your assembler supports specifying the section flag e.])
3886 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3887 gcc_cv_as_ix86_filds,,,
3888 [filds mem; fists mem],,
3889 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3890 [Define if your assembler uses filds and fists mnemonics.])])
3892 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3893 gcc_cv_as_ix86_fildq,,,
3894 [fildq mem; fistpq mem],,
3895 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3896 [Define if your assembler uses fildq and fistq mnemonics.])])
3898 gcc_GAS_CHECK_FEATURE([cmov syntax],
3899 gcc_cv_as_ix86_cmov_sun_syntax,,,
3900 [cmovl.l %edx, %eax],,
3901 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3902 [Define if your assembler supports the Sun syntax for cmov.])])
3904 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3905 gcc_cv_as_ix86_ffreep,,,
3907 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3908 [Define if your assembler supports the ffreep mnemonic.])])
3910 gcc_GAS_CHECK_FEATURE([.quad directive],
3911 gcc_cv_as_ix86_quad,,,
3913 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3914 [Define if your assembler supports the .quad directive.])])
3916 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3917 gcc_cv_as_ix86_sahf,,,
3920 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3921 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3923 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3924 gcc_cv_as_ix86_interunit_movq,,,
3928 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3929 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3930 [Define if your assembler supports interunit movq mnemonic.])
3932 gcc_GAS_CHECK_FEATURE([hle prefixes],
3933 gcc_cv_as_ix86_hle,,,
3934 [lock xacquire cmpxchg %esi, (%ecx)],,
3935 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3936 [Define if your assembler supports HLE prefixes.])])
3938 gcc_GAS_CHECK_FEATURE([swap suffix],
3939 gcc_cv_as_ix86_swap,,,
3940 [movl.s %esp, %ebp],,
3941 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3942 [Define if your assembler supports the swap suffix.])])
3944 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3945 gcc_cv_as_ix86_diff_sect_delta,,,
3953 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3954 [Define if your assembler supports the subtraction of symbols in different sections.])])
3956 # These two are used unconditionally by i386.[ch]; it is to be defined
3957 # to 1 if the feature is present, 0 otherwise.
3958 as_ix86_gotoff_in_data_opt=
3959 if test x$gas = xyes; then
3960 as_ix86_gotoff_in_data_opt="--32"
3962 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3963 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3964 [$as_ix86_gotoff_in_data_opt],
3970 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3971 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3972 [Define true if the assembler supports '.long foo@GOTOFF'.])
3974 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3975 gcc_cv_as_ix86_rep_lock_prefix,,,
3981 lock addl %edi, (%eax,%esi)
3982 lock orl $0, (%esp)],,
3983 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3984 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3986 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3987 gcc_cv_as_ix86_ud2,,,
3989 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3990 [Define if your assembler supports the 'ud2' mnemonic.])])
3992 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3993 gcc_cv_as_ix86_tlsgdplt,,,
3994 [call tls_gd@tlsgdplt],
3995 [if test x$gcc_cv_ld != x \
3996 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3997 gcc_cv_as_ix86_tlsgdplt=yes
4000 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4001 [Define if your assembler and linker support @tlsgdplt.])])
4004 .section .tdata,"aw'$tls_section_flag'",@progbits
4006 .section .text,"ax",@progbits
4007 call tls_ld@tlsldmplt'
4008 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4009 gcc_cv_as_ix86_tlsldmplt,,,
4011 [if test x$gcc_cv_ld != x \
4012 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4013 gcc_cv_as_ix86_tlsldmplt=yes
4016 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4017 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4018 [Define to 1 if your assembler and linker support @tlsldmplt.])
4020 # Enforce 32-bit output with gas and gld.
4021 if test x$gas = xyes; then
4022 as_ix86_tls_ldm_opt="--32"
4024 if echo "$ld_ver" | grep GNU > /dev/null; then
4025 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4026 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
4028 ld_ix86_tls_ldm_opt="-melf_i386"
4032 .section .text,"ax",@progbits
4034 .type _start, @function
4036 leal value@tlsldm(%ebx), %eax
4037 call ___tls_get_addr@plt
4039 .section .tdata,"aw'$tls_section_flag'",@progbits
4040 .type value, @object
4042 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4043 gcc_cv_as_ix86_tlsldm,,
4044 [$as_ix86_tls_ldm_opt],
4046 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4047 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4048 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4049 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4050 gcc_cv_as_ix86_tlsldm=yes
4054 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4055 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4056 [Define to 1 if your assembler and linker support @tlsldm.])
4061 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4062 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4064 addl r15 = @ltoffx(x#), gp
4066 ld8.mov r16 = [[r15]], x#],,
4067 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4068 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4074 *-*-aix*) conftest_s=' .machine "pwr5"
4078 gcc_GAS_CHECK_FEATURE([.machine directive support],
4079 gcc_cv_as_machine_directive,,,
4080 [ .machine ppc7400])
4081 if test x$gcc_cv_as_machine_directive != xyes; then
4082 echo "*** This target requires an assembler supporting \".machine\"" >&2
4083 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4084 test x$build = x$target && exit 1
4088 *) conftest_s=' .machine power4
4093 gcc_GAS_CHECK_FEATURE([mfcr field support],
4094 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4096 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4097 [Define if your assembler supports mfcr field.])])
4100 *-*-aix*) conftest_s=' .machine "pwr5"
4103 *) conftest_s=' .machine power5
4108 gcc_GAS_CHECK_FEATURE([popcntb support],
4109 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4111 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4112 [Define if your assembler supports popcntb field.])])
4115 *-*-aix*) conftest_s=' .machine "pwr5x"
4118 *) conftest_s=' .machine power5
4123 gcc_GAS_CHECK_FEATURE([fp round support],
4124 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4126 [AC_DEFINE(HAVE_AS_FPRND, 1,
4127 [Define if your assembler supports fprnd.])])
4130 *-*-aix*) conftest_s=' .machine "pwr6"
4133 *) conftest_s=' .machine power6
4138 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4139 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4141 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4142 [Define if your assembler supports mffgpr and mftgpr.])])
4145 *-*-aix*) conftest_s=' .csect .text[[PR]]
4147 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4151 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4152 *) conftest_s=' .text
4154 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4157 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4158 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4160 [AC_DEFINE(HAVE_AS_REL16, 1,
4161 [Define if your assembler supports R_PPC_REL16 relocs.])])
4164 *-*-aix*) conftest_s=' .machine "pwr6"
4167 *) conftest_s=' .machine power6
4172 gcc_GAS_CHECK_FEATURE([compare bytes support],
4173 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4175 [AC_DEFINE(HAVE_AS_CMPB, 1,
4176 [Define if your assembler supports cmpb.])])
4179 *-*-aix*) conftest_s=' .machine "pwr6"
4182 *) conftest_s=' .machine power6
4187 gcc_GAS_CHECK_FEATURE([decimal float support],
4188 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4190 [AC_DEFINE(HAVE_AS_DFP, 1,
4191 [Define if your assembler supports DFP instructions.])])
4194 *-*-aix*) conftest_s=' .machine "pwr7"
4197 *) conftest_s=' .machine power7
4202 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4203 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4205 [AC_DEFINE(HAVE_AS_VSX, 1,
4206 [Define if your assembler supports VSX instructions.])])
4209 *-*-aix*) conftest_s=' .machine "pwr7"
4212 *) conftest_s=' .machine power7
4217 gcc_GAS_CHECK_FEATURE([popcntd support],
4218 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4220 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4221 [Define if your assembler supports POPCNTD instructions.])])
4224 *-*-aix*) conftest_s=' .machine "pwr8"
4225 .csect .text[[PR]]';;
4226 *) conftest_s=' .machine power8
4230 gcc_GAS_CHECK_FEATURE([power8 support],
4231 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4233 [AC_DEFINE(HAVE_AS_POWER8, 1,
4234 [Define if your assembler supports POWER8 instructions.])])
4237 *-*-aix*) conftest_s=' .csect .text[[PR]]
4239 *) conftest_s=' .text
4243 gcc_GAS_CHECK_FEATURE([lwsync support],
4244 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4246 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4247 [Define if your assembler supports LWSYNC instructions.])])
4250 *-*-aix*) conftest_s=' .machine "476"
4253 *) conftest_s=' .machine "476"
4258 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4259 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4261 [AC_DEFINE(HAVE_AS_DCI, 1,
4262 [Define if your assembler supports the DCI/ICI instructions.])])
4264 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4265 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4266 [.gnu_attribute 4,1],,
4267 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4268 [Define if your assembler supports .gnu_attribute.])])
4270 gcc_GAS_CHECK_FEATURE([tls marker support],
4271 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4272 [ bl __tls_get_addr(x@tlsgd)],,
4273 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4274 [Define if your assembler supports arg info for __tls_get_addr.])])
4278 gcc_GAS_CHECK_FEATURE([.ref support],
4279 gcc_cv_as_aix_ref, [2,21,0],,
4280 [ .csect stuff[[rw]]
4286 [AC_DEFINE(HAVE_AS_REF, 1,
4287 [Define if your assembler supports .ref])])
4293 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4294 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4295 [ lw $4,%gp_rel(foo)($4)],,
4296 [if test x$target_cpu_default = x
4297 then target_cpu_default=MASK_EXPLICIT_RELOCS
4298 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4300 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4301 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4302 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4303 [Define if the assembler understands -mno-shared.])])
4305 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4306 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4307 [.gnu_attribute 4,1],,
4308 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4309 [Define if your assembler supports .gnu_attribute.])])
4311 gcc_GAS_CHECK_FEATURE([.module support],
4312 gcc_cv_as_mips_dot_module,,[-32],
4315 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4316 [Define if your assembler supports .module.])])
4317 if test x$gcc_cv_as_mips_dot_module = xno \
4318 && test x$with_fp_32 != x; then
4320 [Requesting --with-fp-32= requires assembler support for .module.])
4323 gcc_GAS_CHECK_FEATURE([.micromips support],
4324 gcc_cv_as_micromips_support,,[--fatal-warnings],
4326 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4327 [Define if your assembler supports the .set micromips directive])])
4329 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4330 gcc_cv_as_mips_dtprelword, [2,18,0],,
4331 [.section .tdata,"awT",@progbits
4335 .dtprelword x+0x8000],,
4336 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4337 [Define if your assembler supports .dtprelword.])])
4339 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4340 gcc_cv_as_mips_dspr1_mult,,,
4350 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4351 [Define if your assembler supports DSPR1 mult.])])
4353 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4354 gcc_cv_as_ld_jalr_reloc=no
4355 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4356 if test $in_tree_ld = yes ; then
4357 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 \
4358 && test $in_tree_ld_is_elf = yes; then
4359 gcc_cv_as_ld_jalr_reloc=yes
4361 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4362 echo ' .ent x' > conftest.s
4363 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4364 echo ' lw $25,%call16(y)($28)' >> conftest.s
4365 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4366 echo '1: jalr $25' >> conftest.s
4367 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4368 echo '1: jalr $25' >> conftest.s
4369 echo ' .end x' >> conftest.s
4370 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4371 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4372 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4373 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4374 gcc_cv_as_ld_jalr_reloc=yes
4380 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4381 if test x$target_cpu_default = x; then
4382 target_cpu_default=MASK_RELAX_PIC_CALLS
4384 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4387 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4389 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4390 [gcc_cv_ld_mips_personality_relaxation],
4391 [gcc_cv_ld_mips_personality_relaxation=no
4392 if test $in_tree_ld = yes ; then
4393 if test "$gcc_cv_gld_major_version" -eq 2 \
4394 -a "$gcc_cv_gld_minor_version" -ge 21 \
4395 -o "$gcc_cv_gld_major_version" -gt 2; then
4396 gcc_cv_ld_mips_personality_relaxation=yes
4398 elif test x$gcc_cv_as != x \
4399 -a x$gcc_cv_ld != x \
4400 -a x$gcc_cv_readelf != x ; then
4401 cat > conftest.s <<EOF
4403 .cfi_personality 0x80,indirect_ptr
4410 .section .data,"aw",@progbits
4414 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4415 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4416 if $gcc_cv_readelf -d conftest 2>&1 \
4417 | grep TEXTREL > /dev/null 2>&1; then
4419 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4420 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4423 gcc_cv_ld_mips_personality_relaxation=yes
4427 rm -f conftest.s conftest.o conftest])
4428 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4429 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4430 [Define if your linker can relax absolute .eh_frame personality
4431 pointers into PC-relative form.])
4434 gcc_GAS_CHECK_FEATURE([-mnan= support],
4435 gcc_cv_as_mips_nan,,
4437 [AC_DEFINE(HAVE_AS_NAN, 1,
4438 [Define if the assembler understands -mnan=.])])
4439 if test x$gcc_cv_as_mips_nan = xno \
4440 && test x$with_nan != x; then
4442 [Requesting --with-nan= requires assembler support for -mnan=])
4447 # Mips and HP-UX need the GNU assembler.
4448 # Linux on IA64 might be able to use the Intel assembler.
4451 mips*-*-* | *-*-hpux* )
4452 if test x$gas_flag = xyes \
4453 || test x"$host" != x"$build" \
4454 || test ! -x "$gcc_cv_as" \
4455 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4458 echo "*** This configuration requires the GNU assembler" >&2
4464 # ??? Not all targets support dwarf2 debug_line, even within a version
4465 # of gas. Moreover, we need to emit a valid instruction to trigger any
4466 # info to the output file. So, as supported targets are added to gas 2.11,
4467 # add some instruction here to (also) show we expect this might work.
4468 # ??? Once 2.11 is released, probably need to add first known working
4469 # version to the per-target configury.
4471 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4472 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4473 | visium | xstormy16 | xtensa)
4483 if test x"$insn" != x; then
4485 .file 1 \"conftest.s\"
4488 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4489 gcc_cv_as_dwarf2_debug_line,
4490 [elf,2,11,0],, [$conftest_s],
4491 [if test x$gcc_cv_objdump != x \
4492 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4493 | grep debug_line > /dev/null 2>&1; then
4494 gcc_cv_as_dwarf2_debug_line=yes
4497 # The .debug_line file table must be in the exact order that
4498 # we specified the files, since these indices are also used
4499 # by DW_AT_decl_file. Approximate this test by testing if
4500 # the assembler bitches if the same index is assigned twice.
4501 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4502 gcc_cv_as_dwarf2_file_buggy,,,
4506 if test $gcc_cv_as_dwarf2_debug_line = yes \
4507 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4508 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4509 [Define if your assembler supports dwarf2 .file/.loc directives,
4510 and preserves file table indices exactly as given.])
4513 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4514 gcc_cv_as_gdwarf2_flag,
4515 [elf,2,11,0], [--gdwarf2], [$insn],,
4516 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4517 [Define if your assembler supports the --gdwarf2 option.])])
4519 gcc_GAS_CHECK_FEATURE([--gstabs option],
4520 gcc_cv_as_gstabs_flag,
4521 [elf,2,11,0], [--gstabs], [$insn],,
4522 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4523 [Define if your assembler supports the --gstabs option.])])
4525 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4526 gcc_cv_as_debug_prefix_map_flag,
4527 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4528 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4529 [Define if your assembler supports the --debug-prefix-map option.])])
4532 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4533 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4534 [# gas compiled without zlib cannot compress debug sections and warns
4535 # about it, but still exits successfully. So check for this, too.
4536 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4538 gcc_cv_as_compress_debug=0
4539 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4541 gcc_cv_as_compress_debug=1
4542 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4543 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4545 gcc_cv_as_compress_debug=0
4546 # FIXME: Future gas versions will support ELF gABI style via
4547 # --compress-debug-sections[=type].
4549 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4550 [Define to the level of your assembler's compressed debug section support.])
4551 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4552 [Define to the assembler option to enable compressed debug sections.])
4553 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4554 [Define to the assembler option to disable compressed debug sections.])
4556 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4559 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4560 [Define if your assembler supports .lcomm with an alignment field.])])
4562 if test x$with_sysroot = x && test x$host = x$target \
4563 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4564 && test "$prefix" != "NONE"; then
4565 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4566 [Define to PREFIX/include if cpp should also search that directory.])
4569 # Determine the version of glibc, if any, used on the target.
4570 AC_MSG_CHECKING([for target glibc version])
4571 AC_ARG_WITH([glibc-version],
4572 [AS_HELP_STRING([--with-glibc-version=M.N],
4573 [assume GCC used with glibc version M.N or later])], [
4574 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4575 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4576 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4578 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4580 glibc_version_major=0
4581 glibc_version_minor=0
4582 [if test -f $target_header_dir/features.h \
4583 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4584 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4585 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4586 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4588 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4589 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
4590 [GNU C Library major version number used on the target, or 0.])
4591 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
4592 [GNU C Library minor version number used on the target, or 0.])
4594 AC_ARG_ENABLE(gnu-unique-object,
4595 [AS_HELP_STRING([--enable-gnu-unique-object],
4596 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4597 [case $enable_gnu_unique_object in
4599 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4600 Valid choices are 'yes' and 'no'.]) ;;
4602 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4604 [.type foo, '$target_type_format_char'gnu_unique_object],,
4605 # We need to unquote above to to use the definition from config.gcc.
4606 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4607 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4609 if test x$enable_gnu_unique_object = xyes; then
4610 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4611 [Define if your assembler supports @gnu_unique_object.])
4614 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4615 [gcc_cv_as_line_zero],
4616 [gcc_cv_as_line_zero=no
4617 if test $in_tree_gas = yes; then
4618 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4619 elif test "x$gcc_cv_as" != x; then
4620 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4621 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4622 test "x`cat conftest.out`" = x
4624 gcc_cv_as_line_zero=yes
4626 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4627 cat conftest.s >&AS_MESSAGE_LOG_FD
4628 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4629 cat conftest.out >&AS_MESSAGE_LOG_FD
4631 rm -f conftest.o conftest.s conftest.out
4633 if test "x$gcc_cv_as_line_zero" = xyes; then
4634 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4635 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4638 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4639 gcc_cv_ld_eh_frame_hdr=no
4640 if test $in_tree_ld = yes ; then
4641 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 \
4642 && test $in_tree_ld_is_elf = yes; then
4643 gcc_cv_ld_eh_frame_hdr=yes
4645 elif test x$gcc_cv_ld != x; then
4646 if echo "$ld_ver" | grep GNU > /dev/null; then
4647 # Check if linker supports --eh-frame-hdr option
4648 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4649 gcc_cv_ld_eh_frame_hdr=yes
4654 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4655 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4656 gcc_cv_ld_eh_frame_hdr=yes
4662 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4663 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4664 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4665 [Define if your linker supports .eh_frame_hdr.])
4667 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4669 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4670 gcc_cv_ld_eh_frame_ciev3=no
4671 if test $in_tree_ld = yes ; then
4672 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 \
4673 && test $in_tree_ld_is_elf = yes; then
4674 gcc_cv_ld_eh_frame_ciev3=yes
4676 elif test x$gcc_cv_ld != x; then
4677 if echo "$ld_ver" | grep GNU > /dev/null; then
4678 gcc_cv_ld_eh_frame_ciev3=yes
4679 if test 0"$ld_date" -lt 20040513; then
4680 if test -n "$ld_date"; then
4681 # If there was date string, but was earlier than 2004-05-13, fail
4682 gcc_cv_ld_eh_frame_ciev3=no
4683 elif test "$ld_vers_major" -lt 2; then
4684 gcc_cv_ld_eh_frame_ciev3=no
4685 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4686 gcc_cv_ld_eh_frame_ciev3=no
4692 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4693 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4694 gcc_cv_ld_eh_frame_ciev3=yes
4700 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4701 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4702 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4703 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4705 AC_MSG_CHECKING(linker position independent executable support)
4707 if test $in_tree_ld = yes ; then
4708 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 15 -o "$gcc_cv_gld_major_version" -gt 2 \
4709 && test $in_tree_ld_is_elf = yes; then
4712 elif test x$gcc_cv_ld != x; then
4713 # Check if linker supports -pie option
4714 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4718 if test x"$gcc_cv_ld_pie" = xyes; then
4719 AC_DEFINE(HAVE_LD_PIE, 1,
4720 [Define if your linker supports -pie option.])
4722 AC_MSG_RESULT($gcc_cv_ld_pie)
4724 AC_MSG_CHECKING(linker PIE support with copy reloc)
4725 gcc_cv_ld_pie_copyreloc=no
4726 if test $gcc_cv_ld_pie = yes ; then
4727 if test $in_tree_ld = yes ; then
4728 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
4729 gcc_cv_ld_pie_copyreloc=yes
4731 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4732 # Check if linker supports -pie option with copy reloc
4734 i?86-*-linux* | x86_64-*-linux*)
4735 cat > conftest1.s <<EOF
4738 .type a_glob, @object
4743 cat > conftest2.s <<EOF
4746 .type main, @function
4748 movl %eax, a_glob(%rip)
4751 .section .data.rel,"aw",@progbits
4756 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4757 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
4758 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4759 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
4760 gcc_cv_ld_pie_copyreloc=yes
4762 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
4767 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
4768 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
4769 [Define 0/1 if your linker supports -pie option with copy reloc.])
4770 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
4772 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4773 gcc_cv_ld_eh_gc_sections=no
4774 if test $in_tree_ld = yes ; then
4775 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 \
4776 && test $in_tree_ld_is_elf = yes; then
4777 gcc_cv_ld_eh_gc_sections=yes
4779 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4780 cat > conftest.s <<EOF
4783 .type _start, @function
4786 .size _start, .-_start
4787 .section .text.foo,"ax",@progbits
4788 .type foo, @function
4792 .section .gcc_except_table.foo,"a",@progbits
4795 .section .eh_frame,"a",@progbits
4798 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4799 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4800 | grep "gc-sections option ignored" > /dev/null; then
4801 gcc_cv_ld_eh_gc_sections=no
4802 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4803 | grep gcc_except_table > /dev/null; then
4804 gcc_cv_ld_eh_gc_sections=yes
4805 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4806 if test x$gcc_cv_as_comdat_group != xyes; then
4807 gcc_cv_ld_eh_gc_sections=no
4808 cat > conftest.s <<EOF
4811 .type _start, @function
4814 .size _start, .-_start
4815 .section .gnu.linkonce.t.foo,"ax",@progbits
4816 .type foo, @function
4820 .section .gcc_except_table.foo,"a",@progbits
4823 .section .eh_frame,"a",@progbits
4826 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4827 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4828 | grep "gc-sections option ignored" > /dev/null; then
4829 gcc_cv_ld_eh_gc_sections=no
4830 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4831 | grep gcc_except_table > /dev/null; then
4832 gcc_cv_ld_eh_gc_sections=yes
4838 rm -f conftest.s conftest.o conftest
4842 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4843 gcc_cv_ld_eh_gc_sections=no
4846 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4847 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4848 [Define if your linker supports garbage collection of
4849 sections in presence of EH frames.])
4851 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4853 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4854 gcc_cv_ld_eh_gc_sections_bug=no
4855 if test $in_tree_ld = yes ; then
4856 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 \
4857 && test $in_tree_ld_is_elf = yes; then
4858 gcc_cv_ld_eh_gc_sections_bug=yes
4860 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
4861 gcc_cv_ld_eh_gc_sections_bug=yes
4862 cat > conftest.s <<EOF
4865 .type _start, @function
4868 .size _start, .-_start
4869 .section .text.startup.foo,"ax",@progbits
4870 .type foo, @function
4874 .section .gcc_except_table.foo,"a",@progbits
4877 .section .eh_frame,"a",@progbits
4880 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4881 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4882 | grep "gc-sections option ignored" > /dev/null; then
4884 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4885 | grep gcc_except_table > /dev/null; then
4886 gcc_cv_ld_eh_gc_sections_bug=no
4889 rm -f conftest.s conftest.o conftest
4891 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4892 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4893 [Define if your linker has buggy garbage collection of
4894 sections support when .text.startup.foo like sections are used.])
4896 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4898 AC_MSG_CHECKING(linker for compressed debug sections)
4899 # gold/gld support compressed debug sections since binutils 2.19/2.21
4900 if test $in_tree_ld = yes ; then
4901 gcc_cv_ld_compress_debug=0
4902 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 \
4903 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
4904 gcc_cv_ld_compress_debug=2
4905 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4906 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 \
4907 && test $in_tree_ld_is_elf = yes; then
4908 gcc_cv_ld_compress_debug=1
4910 elif echo "$ld_ver" | grep GNU > /dev/null; then
4911 gcc_cv_ld_compress_debug=1
4912 if test 0"$ld_date" -lt 20050308; then
4913 if test -n "$ld_date"; then
4914 # If there was date string, but was earlier than 2005-03-08, fail
4915 gcc_cv_ld_compress_debug=0
4916 elif test "$ld_vers_major" -lt 2; then
4917 gcc_cv_ld_compress_debug=0
4918 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
4919 gcc_cv_ld_compress_debug=0
4922 if test $ld_is_gold = yes; then
4923 gcc_cv_ld_compress_debug=2
4924 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4930 # Introduced in Solaris 11.2.
4931 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
4932 gcc_cv_ld_compress_debug=3
4933 gcc_cv_ld_compress_debug_option="-z compress-sections"
4935 gcc_cv_ld_compress_debug=0
4939 # Assume linkers other than GNU ld don't support compessed debug
4941 gcc_cv_ld_compress_debug=0
4946 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
4947 [Define to the level of your linker's compressed debug section support.])
4948 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
4949 [Define to the linker option to enable compressed debug sections.])
4950 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
4956 AC_CACHE_CHECK(linker --as-needed support,
4957 gcc_cv_ld_as_needed,
4958 [gcc_cv_ld_as_needed=no
4959 gcc_cv_ld_as_needed_option='--as-needed'
4960 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4961 if test $in_tree_ld = yes ; then
4962 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 \
4963 && test $in_tree_ld_is_elf = yes; then
4964 gcc_cv_ld_as_needed=yes
4966 elif test x$gcc_cv_ld != x; then
4967 # Check if linker supports --as-needed and --no-as-needed options
4968 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4969 gcc_cv_ld_as_needed=yes
4972 # Solaris 2 ld always supports -z ignore/-z record.
4974 gcc_cv_ld_as_needed=yes
4975 gcc_cv_ld_as_needed_option="-z ignore"
4976 gcc_cv_ld_no_as_needed_option="-z record"
4981 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4982 # dl_iterate_phdr, i.e. since Solaris 11.
4984 *-*-solaris2.1[[1-9]]*)
4986 i?86-*-* | x86_64-*-*)
4987 if echo "$ld_ver" | grep GNU > /dev/null; then
4988 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4989 gcc_cv_ld_as_needed=no
4995 gcc_cv_ld_as_needed=no
4999 if test x"$gcc_cv_ld_as_needed" = xyes; then
5000 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
5001 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
5002 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
5003 [Define to the linker option to ignore unused dependencies.])
5004 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
5005 [Define to the linker option to keep unused dependencies.])
5008 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
5009 saved_LDFLAGS="$LDFLAGS"
5010 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
5011 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
5012 AC_LINK_IFELSE([int main(void) {return 0;}],
5013 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
5015 LDFLAGS="$saved_LDFLAGS"
5016 if test "x$gcc_cv_ld_clearcap" = xyes; then
5017 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
5018 [Define if the linker supports clearing hardware capabilities via mapfile.])
5019 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
5021 AC_MSG_RESULT($gcc_cv_ld_clearcap)
5023 case "$target:$tm_file" in
5024 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
5027 emul_name="-melf64lppc"
5030 emul_name="-melf64ppc"
5033 emul_name="-melf64ppc_fbsd"
5036 AC_CACHE_CHECK(linker support for omitting dot symbols,
5037 gcc_cv_ld_no_dot_syms,
5038 [gcc_cv_ld_no_dot_syms=no
5039 if test x"$ld_is_gold" = xyes; then
5040 gcc_cv_ld_no_dot_syms=yes
5041 elif test $in_tree_ld = yes ; then
5042 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
5043 gcc_cv_ld_no_dot_syms=yes
5045 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5046 cat > conftest1.s <<EOF
5050 cat > conftest2.s <<EOF
5051 .section ".opd","aw"
5056 .quad .LEfoo,.TOC.@tocbase,0
5062 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5063 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5064 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
5065 gcc_cv_ld_no_dot_syms=yes
5067 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
5070 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
5071 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
5072 [Define if your PowerPC64 linker only needs function descriptor syms.])
5075 AC_CACHE_CHECK(linker large toc support,
5076 gcc_cv_ld_large_toc,
5077 [gcc_cv_ld_large_toc=no
5078 if test x"$ld_is_gold" = xyes; then
5079 gcc_cv_ld_large_toc=yes
5080 elif test $in_tree_ld = yes ; then
5081 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
5082 gcc_cv_ld_large_toc=yes
5084 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5085 cat > conftest.s <<EOF
5086 .section ".tbss","awT",@nobits
5092 addis 9,13,ie0@got@tprel@ha
5093 ld 9,ie0@got@tprel@l(9)
5095 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5096 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5097 gcc_cv_ld_large_toc=yes
5099 rm -f conftest conftest.o conftest.s
5102 if test x"$gcc_cv_ld_large_toc" = xyes; then
5103 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5104 [Define if your PowerPC64 linker supports a large TOC.])
5107 AC_CACHE_CHECK(linker toc pointer alignment,
5108 gcc_cv_ld_toc_align,
5109 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
5110 cat > conftest.s <<EOF
5115 .section .data.rel.ro,"aw",@progbits
5120 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5121 && $gcc_cv_ld $emul_name -o conftest conftest.o > /dev/null 2>&1; then
5122 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)) }'`
5124 rm -f conftest conftest.o conftest.s
5127 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
5128 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
5129 [Define to .TOC. alignment forced by your linker.])
5136 AC_CACHE_CHECK(linker large toc support,
5137 gcc_cv_ld_large_toc,
5138 [gcc_cv_ld_large_toc=no
5139 if test x$gcc_cv_as != x ; then
5140 cat > conftest.s <<EOF
5150 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5151 gcc_cv_ld_large_toc=yes
5153 rm -f conftest conftest.o conftest.s
5156 if test x"$gcc_cv_ld_large_toc" = xyes; then
5157 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5158 [Define if your PowerPC64 linker supports a large TOC.])
5163 AC_CACHE_CHECK(linker --build-id support,
5165 [gcc_cv_ld_buildid=no
5166 if test $in_tree_ld = yes ; then
5167 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5168 "$gcc_cv_gld_minor_version" -ge 18 -o \
5169 "$gcc_cv_gld_major_version" -gt 2 \
5170 && test $in_tree_ld_is_elf = yes; then
5171 gcc_cv_ld_buildid=yes
5173 elif test x$gcc_cv_ld != x; then
5174 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5175 gcc_cv_ld_buildid=yes
5178 if test x"$gcc_cv_ld_buildid" = xyes; then
5179 AC_DEFINE(HAVE_LD_BUILDID, 1,
5180 [Define if your linker supports --build-id.])
5183 AC_ARG_ENABLE(linker-build-id,
5184 [AS_HELP_STRING([--enable-linker-build-id],
5185 [compiler will always pass --build-id to linker])],
5187 enable_linker_build_id=no)
5189 if test x"$enable_linker_build_id" = xyes; then
5190 if test x"$gcc_cv_ld_buildid" = xyes; then
5191 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5192 [Define if gcc should always pass --build-id to linker.])
5194 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5198 # In binutils 2.21, GNU ld gained support for new emulations fully
5199 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5200 AC_CACHE_CHECK(linker *_sol2 emulation support,
5201 gcc_cv_ld_sol2_emulation,
5202 [gcc_cv_ld_sol2_emulation=no
5203 if test $in_tree_ld = yes ; then
5204 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5205 "$gcc_cv_gld_minor_version" -ge 21 -o \
5206 "$gcc_cv_gld_major_version" -gt 2 \
5207 && test $in_tree_ld_is_elf = yes; then
5208 gcc_cv_ld_sol2_emulation=yes
5210 elif test x$gcc_cv_ld != x; then
5211 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5212 grep _sol2 > /dev/null; then
5213 gcc_cv_ld_sol2_emulation=yes
5216 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5217 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5218 [Define if your linker supports the *_sol2 emulations.])
5221 AC_CACHE_CHECK(linker --sysroot support,
5223 [gcc_cv_ld_sysroot=no
5224 if test $in_tree_ld = yes ; then
5225 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
5226 gcc_cv_ld_sysroot=yes
5228 elif test x$gcc_cv_ld != x; then
5229 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5230 gcc_cv_ld_sysroot=yes
5233 if test x"$gcc_cv_ld_sysroot" = xyes; then
5234 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5235 [Define if your linker supports --sysroot.])
5238 # Test for stack protector support in target C library.
5239 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5240 gcc_cv_libc_provides_ssp,
5241 [gcc_cv_libc_provides_ssp=no
5244 # All versions of musl provide stack protector
5245 gcc_cv_libc_provides_ssp=yes;;
5246 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5247 # glibc 2.4 and later provides __stack_chk_fail and
5248 # either __stack_chk_guard, or TLS access to stack guard canary.
5249 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5250 [if test -f $target_header_dir/features.h \
5251 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5252 $target_header_dir/features.h > /dev/null; then
5253 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5254 $target_header_dir/features.h > /dev/null && \
5255 test -f $target_header_dir/bits/uClibc_config.h && \
5256 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5257 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5258 gcc_cv_libc_provides_ssp=yes
5260 # all versions of Bionic support stack protector
5261 elif test -f $target_header_dir/sys/cdefs.h \
5262 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5263 $target_header_dir/sys/cdefs.h > /dev/null; then
5264 gcc_cv_libc_provides_ssp=yes
5268 # Avoid complicated tests (see
5269 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5270 # simply assert that glibc does provide this, which is true for all
5271 # realistically usable GNU/Hurd configurations.
5272 # All supported versions of musl provide it as well
5273 gcc_cv_libc_provides_ssp=yes;;
5274 *-*-darwin* | *-*-freebsd*)
5275 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5276 [echo "no __stack_chk_fail on this target"])
5278 *) gcc_cv_libc_provides_ssp=no ;;
5281 if test x$gcc_cv_libc_provides_ssp = xyes; then
5282 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5283 [Define if your target C library provides stack protector support])
5286 # Test for <sys/sdt.h> on the target.
5287 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5288 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5290 if test -f $target_header_dir/sys/sdt.h; then
5292 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5293 [Define if your target C library provides sys/sdt.h])
5295 AC_MSG_RESULT($have_sys_sdt_h)
5297 # Check if TFmode long double should be used by default or not.
5298 # Some glibc targets used DFmode long double, but with glibc 2.4
5299 # and later they can use TFmode.
5301 powerpc*-*-linux* | \
5305 AC_ARG_WITH(long-double-128,
5306 [AS_HELP_STRING([--with-long-double-128],
5307 [use 128-bit long double by default])],
5308 gcc_cv_target_ldbl128="$with_long_double_128",
5309 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5310 [gcc_cv_target_ldbl128=no
5311 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5312 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5313 && gcc_cv_target_ldbl128=yes
5317 if test x$gcc_cv_target_ldbl128 = xyes; then
5318 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5319 [Define if TFmode long double should be the default])
5322 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5323 gcc_cv_target_dl_iterate_phdr=unknown
5325 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5326 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5327 # libdl there, both complicating its use and breaking compatibility
5328 # between Solaris 10 updates.
5329 *-*-solaris2.1[[1-9]]*)
5330 # <link.h> needs both a dl_iterate_phdr declaration and support for
5331 # compilation with largefile support.
5332 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5333 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5334 gcc_cv_target_dl_iterate_phdr=yes
5336 gcc_cv_target_dl_iterate_phdr=no
5339 *-*-dragonfly* | *-*-freebsd*)
5340 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5341 gcc_cv_target_dl_iterate_phdr=yes
5343 gcc_cv_target_dl_iterate_phdr=no
5347 gcc_cv_target_dl_iterate_phdr=yes
5350 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5351 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5352 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5353 [Define if your target C library provides the `dl_iterate_phdr' function.])
5355 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5357 # We no longer support different GC mechanisms. Emit an error if
5358 # the user configures with --with-gc.
5360 [AS_HELP_STRING([--with-gc={page,zone}],
5361 [this option is not supported anymore. It used to choose
5362 the garbage collection mechanism to use with the compiler])],
5363 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5366 # Libraries to use on the host. This will normally be set by the top
5367 # level Makefile. Here we simply capture the value for our Makefile.
5368 if test -z "${HOST_LIBS+set}"; then
5373 # Use the system's zlib library.
5375 zlibinc="-I\$(srcdir)/../zlib"
5376 AC_ARG_WITH(system-zlib,
5377 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5384 dnl Very limited version of automake's enable-maintainer-mode
5386 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5387 dnl maintainer-mode is disabled by default
5388 AC_ARG_ENABLE(maintainer-mode,
5389 [AS_HELP_STRING([--enable-maintainer-mode],
5390 [enable make rules and dependencies not useful
5391 (and sometimes confusing) to the casual installer])],
5392 maintainer_mode=$enableval,
5395 AC_MSG_RESULT($maintainer_mode)
5397 if test "$maintainer_mode" = "yes"; then
5404 dnl Whether to prevent multiple front-ends from linking at the same time
5406 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5407 AC_ARG_ENABLE(link-mutex,
5408 [AS_HELP_STRING([--enable-link-mutex],
5409 [avoid linking multiple front-ends at once to avoid thrashing
5410 on the build machine])],
5411 do_link_mutex=$enableval,
5413 AC_MSG_RESULT($do_link_mutex)
5415 if test "$do_link_mutex" = "yes"; then
5420 AC_SUBST(DO_LINK_MUTEX)
5426 # Make empty files to contain the specs and options for each language.
5427 # Then add #include lines to for a compiler that has specs and/or options.
5433 # These (without "all_") are set in each config-lang.in.
5434 # `language' must be a single word so is spelled singularly.
5437 all_outputs='Makefile'
5438 # List of language makefile fragments.
5440 # Additional files for gengtype
5441 all_gtfiles="$target_gtfiles"
5443 # These are the languages that are set in --enable-languages,
5444 # and are available in the GCC tree.
5445 all_selected_languages=
5447 # Add the language fragments.
5448 # Languages are added via two mechanisms. Some information must be
5449 # recorded in makefile variables, these are defined in config-lang.in.
5450 # We accumulate them and plug them into the main Makefile.
5451 # The other mechanism is a set of hooks for each of the main targets
5452 # like `clean', `install', etc.
5454 language_hooks="Make-hooks"
5456 for lang in ${srcdir}/*/config-lang.in
5459 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5461 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5462 if test "x$lang_alias" = x
5464 echo "$lang doesn't set \$language." 1>&2
5467 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5468 subdirs="$subdirs $subdir"
5470 # $gcc_subdir is where the gcc integration files are to be found
5471 # for a language, both for internal compiler purposes (compiler
5472 # sources implementing front-end to GCC tree converters), and for
5473 # build infrastructure purposes (Make-lang.in, etc.)
5475 # This will be <subdir> (relative to $srcdir) if a line like
5476 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5477 # is found in <langdir>/config-lang.in, and will remain <langdir>
5480 # Except for the language alias (fetched above), the regular
5481 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5482 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5483 # only this and the language alias.
5485 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5486 if [ "$gcc_subdir" = "" ]; then
5487 gcc_subdir="$subdir"
5490 case ",$enable_languages," in
5492 all_selected_languages="$all_selected_languages $lang_alias"
5493 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5494 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5506 . ${srcdir}/$gcc_subdir/config-lang.in
5507 if test "x$language" = x
5509 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5514 case ",$enable_languages," in
5517 for i in $subdir_requires; do
5518 test -f "${srcdir}/$i/config-lang.in" && continue
5526 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5527 if test -f $srcdir/$gcc_subdir/lang.opt; then
5528 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5529 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5531 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5532 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5534 all_languages="$all_languages $language"
5535 all_compilers="$all_compilers $compilers"
5536 all_outputs="$all_outputs $outputs"
5537 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5538 case ",$enable_languages," in
5540 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5542 AC_SUBST(enable_lto)
5549 for language in $all_selected_languages
5551 check_languages="$check_languages check-$language"
5554 # We link each language in with a set of hooks, reached indirectly via
5555 # lang.${target}. Only do so for selected languages.
5559 target_list="all.cross start.encap rest.encap tags \
5560 install-common install-man install-info install-pdf install-html dvi \
5561 pdf html uninstall info man srcextra srcman srcinfo \
5562 mostlyclean clean distclean maintainer-clean install-plugin"
5564 for t in $target_list
5567 for lang in $all_selected_languages
5571 echo "lang.$t: $x" >> Make-hooks
5575 # Option include files
5578 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5579 option_includes="option-includes.mk"
5580 AC_SUBST_FILE(option_includes)
5588 echo "dir ." > .gdbinit
5589 echo "dir ${srcdir}" >> .gdbinit
5590 if test x$gdb_needs_out_file_path = xyes
5592 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5594 if test "x$subdirs" != x; then
5597 echo "dir ${srcdir}/$s" >> .gdbinit
5600 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5601 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5603 # Put a breakpoint on __asan_report_error to help with debugging buffer
5606 *-fsanitize=address*)
5607 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5611 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5612 AC_SUBST(gcc_tooldir)
5615 # Find a directory in which to install a shared libgcc.
5617 AC_ARG_ENABLE(version-specific-runtime-libs,
5618 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5619 [specify that runtime libraries should be
5620 installed in a compiler-specific directory])])
5622 # Substitute configuration variables
5625 AC_SUBST(all_compilers)
5626 AC_SUBST(all_gtfiles)
5627 AC_SUBST(all_lang_makefrags)
5628 AC_SUBST(all_languages)
5629 AC_SUBST(all_selected_languages)
5630 AC_SUBST(build_exeext)
5631 AC_SUBST(build_install_headers_dir)
5632 AC_SUBST(build_xm_file_list)
5633 AC_SUBST(build_xm_include_list)
5634 AC_SUBST(build_xm_defines)
5635 AC_SUBST(build_file_translate)
5636 AC_SUBST(check_languages)
5637 AC_SUBST(cpp_install_dir)
5638 AC_SUBST(xmake_file)
5639 AC_SUBST(tmake_file)
5640 AC_SUBST(TM_ENDIAN_CONFIG)
5641 AC_SUBST(TM_MULTILIB_CONFIG)
5642 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5643 AC_SUBST(extra_gcc_objs)
5644 AC_SUBST(user_headers_inc_next_pre)
5645 AC_SUBST(user_headers_inc_next_post)
5646 AC_SUBST(extra_headers_list)
5647 AC_SUBST(extra_objs)
5648 AC_SUBST(extra_programs)
5649 AC_SUBST(float_h_file)
5650 AC_SUBST(gcc_config_arguments)
5651 AC_SUBST(gcc_gxx_include_dir)
5652 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5653 AC_SUBST(host_exeext)
5654 AC_SUBST(host_xm_file_list)
5655 AC_SUBST(host_xm_include_list)
5656 AC_SUBST(host_xm_defines)
5657 AC_SUBST(out_host_hook_obj)
5659 AC_SUBST(lang_opt_files)
5660 AC_SUBST(lang_specs_files)
5661 AC_SUBST(lang_tree_files)
5662 AC_SUBST(local_prefix)
5664 AC_SUBST(objc_boehm_gc)
5666 AC_SUBST(out_object_file)
5667 AC_SUBST(common_out_file)
5668 AC_SUBST(common_out_object_file)
5669 AC_SUBST(tm_file_list)
5670 AC_SUBST(tm_include_list)
5671 AC_SUBST(tm_defines)
5672 AC_SUBST(tm_p_file_list)
5673 AC_SUBST(tm_p_include_list)
5674 AC_SUBST(xm_file_list)
5675 AC_SUBST(xm_include_list)
5676 AC_SUBST(xm_defines)
5677 AC_SUBST(use_gcc_stdint)
5678 AC_SUBST(c_target_objs)
5679 AC_SUBST(cxx_target_objs)
5680 AC_SUBST(fortran_target_objs)
5681 AC_SUBST(target_cpu_default)
5683 AC_SUBST_FILE(language_hooks)
5686 if test x${build} = x${host} ; then
5687 if test x${host} = x${target} ; then
5688 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5690 echo "Links are now set up to build a cross-compiler" 1>&2
5691 echo " from ${host} to ${target}." 1>&2
5694 if test x${host} = x${target} ; then
5695 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5696 echo " for ${target}." 1>&2
5698 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5699 echo " from ${host} to ${target}." 1>&2
5703 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5704 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5706 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5707 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5708 if test "x${ISLLIBS}" != "x" ; then
5709 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5712 # Check whether isl_schedule_constraints_compute_schedule is available;
5713 # it's new in ISL-0.13.
5714 if test "x${ISLLIBS}" != "x" ; then
5715 saved_CFLAGS="$CFLAGS"
5716 CFLAGS="$CFLAGS $ISLINC"
5718 LIBS="$LIBS $ISLLIBS $GMPLIBS"
5720 AC_MSG_CHECKING([Checking for isl_schedule_constraints_compute_schedule])
5721 AC_TRY_LINK([#include <isl/schedule.h>],
5722 [isl_schedule_constraints_compute_schedule (NULL);],
5723 [ac_has_isl_schedule_constraints_compute_schedule=yes],
5724 [ac_has_isl_schedule_constraints_compute_schedule=no])
5725 AC_MSG_RESULT($ac_has_isl_schedule_constraints_compute_schedule)
5728 CFLAGS="$saved_CFLAGS"
5730 if test x"$ac_has_isl_schedule_constraints_compute_schedule" = x"yes"; then
5731 AC_DEFINE(HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE, 1,
5732 [Define if isl_schedule_constraints_compute_schedule exists.])
5737 AC_SUBST(pluginlibs)
5738 AC_SUBST(enable_plugin)
5739 if test x"$enable_plugin" = x"yes"; then
5740 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5744 # Enable --enable-host-shared
5745 AC_ARG_ENABLE(host-shared,
5746 [AS_HELP_STRING([--enable-host-shared],
5747 [build host code as shared libraries])],
5748 [PICFLAG=-fPIC], [PICFLAG=])
5749 AC_SUBST(enable_host_shared)
5753 AC_ARG_ENABLE(libquadmath-support,
5754 [AS_HELP_STRING([--disable-libquadmath-support],
5755 [disable libquadmath support for Fortran])],
5756 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5757 ENABLE_LIBQUADMATH_SUPPORT=yes)
5758 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5759 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5760 [Define to 1 to enable libquadmath support])
5764 # Specify what hash style to use by default.
5765 AC_ARG_WITH([linker-hash-style],
5766 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5767 [specify the linker hash style])],
5768 [case x"$withval" in
5770 LINKER_HASH_STYLE=sysv
5773 LINKER_HASH_STYLE=gnu
5776 LINKER_HASH_STYLE=both
5779 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5782 [LINKER_HASH_STYLE=''])
5783 if test x"${LINKER_HASH_STYLE}" != x; then
5784 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5785 [The linker hash style])
5788 # Specify what should be the default of -fdiagnostics-color option.
5789 AC_ARG_WITH([diagnostics-color],
5790 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
5791 [specify the default of -fdiagnostics-color option
5792 auto-if-env stands for -fdiagnostics-color=auto if
5793 GCC_COLOR environment variable is present and
5794 -fdiagnostics-color=never otherwise])],
5795 [case x"$withval" in
5797 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
5800 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
5803 DIAGNOSTICS_COLOR_DEFAULT=-1
5806 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
5809 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
5812 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
5813 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
5814 [The default for -fdiagnostics-color option])
5816 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
5817 # of jit/jit-playback.c.
5818 cat > gcc-driver-name.h <<EOF
5819 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}"
5822 # Configure the subdirectories
5823 # AC_CONFIG_SUBDIRS($subdirs)
5825 # Create the Makefile
5826 # and configure language subdirectories
5827 AC_CONFIG_FILES($all_outputs)
5829 AC_CONFIG_COMMANDS([default],
5831 case ${CONFIG_HEADERS} in
5832 *auto-host.h:config.in*)
5835 # Make sure all the subdirs exist.
5836 for d in $subdirs doc build common c-family
5838 test -d $d || mkdir $d
5841 [subdirs='$subdirs'])