2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2014 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 # Determine the target- and build-specific subdirectories
44 # Set program_transform_name
47 # Check for bogus environment variables.
48 # Test if LIBRARY_PATH contains the notation for the current directory
49 # since this would lead to problems installing/building glibc.
50 # LIBRARY_PATH contains the current directory if one of the following
52 # - one of the terminals (":" and ";") is the first or last sign
53 # - two terminals occur directly after each other
54 # - the path contains an element with a dot in it
55 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 case ${LIBRARY_PATH} in
58 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
59 library_path_setting="contains current directory"
62 library_path_setting="ok"
66 AC_MSG_RESULT($library_path_setting)
67 if test "$library_path_setting" != "ok"; then
69 *** LIBRARY_PATH shouldn't contain the current directory when
70 *** building gcc. Please change the environment variable
71 *** and run configure again.])
74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
75 # since this would lead to problems installing/building glibc.
76 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # - one of the terminals (":" and ";") is the first or last sign
79 # - two terminals occur directly after each other
80 # - the path contains an element with a dot in it
81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 case ${GCC_EXEC_PREFIX} in
84 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
85 gcc_exec_prefix_setting="contains current directory"
88 gcc_exec_prefix_setting="ok"
92 AC_MSG_RESULT($gcc_exec_prefix_setting)
93 if test "$gcc_exec_prefix_setting" != "ok"; then
95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
96 *** building gcc. Please change the environment variable
97 *** and run configure again.])
104 # Specify the local prefix
106 AC_ARG_WITH(local-prefix,
107 [AS_HELP_STRING([--with-local-prefix=DIR],
108 [specifies directory to put local include])],
109 [case "${withval}" in
110 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
112 *) local_prefix=$with_local_prefix ;;
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117 local_prefix=/usr/local
120 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
121 # passed in by the toplevel make and thus we'd get different behavior
122 # depending on where we built the sources.
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
127 [specifies directory to put g++ header files])],
128 [case "${withval}" in
129 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
131 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
134 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
135 if test x${gcc_gxx_include_dir} = x; then
136 if test x${enable_version_specific_runtime_libs} = xyes; then
137 gcc_gxx_include_dir='${libsubdir}/include/c++'
139 libstdcxx_incdir='include/c++/$(version)'
140 if test x$host != x$target; then
141 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
143 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
147 gcc_gxx_include_dir_add_sysroot=0
148 if test "${with_sysroot+set}" = set; then
149 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
150 if test "${gcc_gxx_without_sysroot}"; then
151 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
152 gcc_gxx_include_dir_add_sysroot=1
156 AC_ARG_WITH(cpp_install_dir,
157 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
158 [install the user visible C preprocessor in DIR
159 (relative to PREFIX) as well as PREFIX/bin])],
160 [if test x$withval = xyes; then
161 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
162 elif test x$withval != xno; then
163 cpp_install_dir=$withval
166 # We would like to our source tree to be readonly. However when releases or
167 # pre-releases are generated, the flex/bison generated files as well as the
168 # various formats of manuals need to be included along with the rest of the
169 # sources. Therefore we have --enable-generated-files-in-srcdir to do
172 AC_MSG_CHECKING([whether to place generated files in the source directory])
173 dnl generated-files-in-srcdir is disabled by default
174 AC_ARG_ENABLE(generated-files-in-srcdir,
175 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
176 [put copies of generated files in source dir
177 intended for creating source tarballs for users
178 without texinfo bison or flex])],
179 generated_files_in_srcdir=$enableval,
180 generated_files_in_srcdir=no)
182 AC_MSG_RESULT($generated_files_in_srcdir)
184 if test "$generated_files_in_srcdir" = "yes"; then
191 # -------------------
192 # Find default linker
193 # -------------------
197 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
198 gnu_ld_flag="$with_gnu_ld",
201 # With pre-defined ld
203 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
204 DEFAULT_LINKER="$with_ld")
205 if test x"${DEFAULT_LINKER+set}" = x"set"; then
206 if test ! -x "$DEFAULT_LINKER"; then
207 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
208 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
211 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
212 [Define to enable the use of a default linker.])
215 AC_MSG_CHECKING([whether a default linker was specified])
216 if test x"${DEFAULT_LINKER+set}" = x"set"; then
217 if test x"$gnu_ld_flag" = x"no"; then
218 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
220 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
226 # With demangler in GNU ld
227 AC_ARG_WITH(demangler-in-ld,
228 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
229 demangler_in_ld="$with_demangler_in_ld",
232 # ----------------------
233 # Find default assembler
234 # ----------------------
238 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
239 gas_flag="$with_gnu_as",
243 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
244 DEFAULT_ASSEMBLER="$with_as")
245 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
246 if test ! -x "$DEFAULT_ASSEMBLER"; then
247 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
248 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
251 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
252 [Define to enable the use of a default assembler.])
255 AC_MSG_CHECKING([whether a default assembler was specified])
256 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
257 if test x"$gas_flag" = x"no"; then
258 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
260 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
270 # If a non-executable a.out is present (e.g. created by GNU as above even if
271 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
272 # file, even when creating an executable, so an execution test fails.
273 # Remove possible default executable files to avoid this.
275 # FIXME: This really belongs into AC_PROG_CC and can be removed once
276 # Autoconf includes it.
277 rm -f a.out a.exe b.out
279 # Find the native compiler
282 ACX_PROG_GNAT([-I"$srcdir"/ada])
284 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
285 # optimizations to be activated explicitly by the toplevel.
288 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
289 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
294 # Determine PICFLAG for target gnatlib.
295 GCC_PICFLAG_FOR_TARGET
296 AC_SUBST(PICFLAG_FOR_TARGET)
298 # -------------------------
299 # Check C compiler features
300 # -------------------------
302 AC_USE_SYSTEM_EXTENSIONS
308 # sizeof(char) is 1 by definition.
309 AC_CHECK_SIZEOF(void *)
310 AC_CHECK_SIZEOF(short)
312 AC_CHECK_SIZEOF(long)
313 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
315 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
316 AC_MSG_ERROR([uint64_t or int64_t not found])
319 # check what underlying integer type int64_t uses
321 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
322 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
326 template <typename T> struct X { };
328 struct X<long> { typedef long t; };
329 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
330 if test "$ac_cv_int64_t_type" = "long"; then
331 AC_DEFINE(INT64_T_IS_LONG, 1,
332 [Define if int64_t uses long as underlying type.])
334 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
338 template <typename T> struct X { };
340 struct X<long long> { typedef long long t; };
341 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
348 # ---------------------
349 # Warnings and checking
350 # ---------------------
352 # Check $CC warning features (if it's GCC).
353 # We want to use -pedantic, but we don't want warnings about
357 # * C++11 narrowing conversions in { }
358 # So, we only use -pedantic if we can disable those warnings.
360 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
361 AC_ARG_ENABLE(build-format-warnings,
362 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
363 [],[enable_build_format_warnings=yes])
364 AS_IF([test $enable_build_format_warnings = no],
365 [wf_opt=-Wno-format],[wf_opt=])
366 ACX_PROG_CC_WARNING_OPTS(
367 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
368 ACX_PROG_CC_WARNING_OPTS(
369 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
371 ACX_PROG_CC_WARNING_OPTS(
372 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
373 ACX_PROG_CC_WARNING_OPTS(
374 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
375 ACX_PROG_CC_WARNING_OPTS(
376 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
377 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
378 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
379 [-Wno-overlength-strings])), [strict_warn])
380 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
382 # The above macros do nothing if the compiler is not GCC. However, the
383 # Makefile has more goo to add other flags, so these variables are used
384 # to enable warnings only for GCC.
387 if test "x$GCC" = "xyes"; then
388 warn_cflags='$(GCC_WARN_CFLAGS)'
389 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
391 AC_SUBST(warn_cflags)
392 AC_SUBST(warn_cxxflags)
394 # Disable exceptions and RTTI if building with g++
395 ACX_PROG_CC_WARNING_OPTS(
396 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
399 # Enable expensive internal checks
401 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
405 AC_ARG_ENABLE(checking,
406 [AS_HELP_STRING([[--enable-checking[=LIST]]],
407 [enable expensive run-time checks. With LIST,
408 enable only specific categories of checks.
409 Categories are: yes,no,all,none,release.
410 Flags are: assert,df,fold,gc,gcac,gimple,misc,
411 rtlflag,rtl,runtime,tree,valgrind,types])],
412 [ac_checking_flags="${enableval}"],[
413 # Determine the default checks.
414 if test x$is_release = x ; then
415 ac_checking_flags=yes
417 ac_checking_flags=release
419 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
420 for check in release $ac_checking_flags
423 # these set all the flags to specific states
424 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
425 ac_fold_checking= ; ac_gc_checking=1 ;
426 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
427 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
428 ac_tree_checking=1 ; ac_valgrind_checking= ;
429 ac_types_checking=1 ;;
430 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
431 ac_fold_checking= ; ac_gc_checking= ;
432 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
433 ac_rtlflag_checking= ; ac_runtime_checking= ;
434 ac_tree_checking= ; ac_valgrind_checking= ;
435 ac_types_checking= ;;
436 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
437 ac_fold_checking=1 ; ac_gc_checking=1 ;
438 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
439 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
440 ac_tree_checking=1 ; ac_valgrind_checking= ;
441 ac_types_checking=1 ;;
442 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
443 ac_fold_checking= ; ac_gc_checking= ;
444 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
445 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
446 ac_tree_checking= ; ac_valgrind_checking= ;
447 ac_types_checking= ;;
448 # these enable particular checks
449 assert) ac_assert_checking=1 ;;
450 df) ac_df_checking=1 ;;
451 fold) ac_fold_checking=1 ;;
452 gc) ac_gc_checking=1 ;;
453 gcac) ac_gc_always_collect=1 ;;
454 gimple) ac_gimple_checking=1 ;;
455 misc) ac_checking=1 ;;
456 rtl) ac_rtl_checking=1 ;;
457 rtlflag) ac_rtlflag_checking=1 ;;
458 runtime) ac_runtime_checking=1 ;;
459 tree) ac_tree_checking=1 ;;
460 types) ac_types_checking=1 ;;
461 valgrind) ac_valgrind_checking=1 ;;
462 *) AC_MSG_ERROR(unknown check category $check) ;;
468 if test x$ac_checking != x ; then
469 AC_DEFINE(ENABLE_CHECKING, 1,
470 [Define if you want more run-time sanity checks. This one gets a grab
471 bag of miscellaneous but relatively cheap checks.])
472 nocommon_flag=-fno-common
474 AC_SUBST(nocommon_flag)
475 if test x$ac_df_checking != x ; then
476 AC_DEFINE(ENABLE_DF_CHECKING, 1,
477 [Define if you want more run-time sanity checks for dataflow.])
479 if test x$ac_assert_checking != x ; then
480 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
481 [Define if you want assertions enabled. This is a cheap check.])
483 if test x$ac_gimple_checking != x ; then
484 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
485 [Define if you want operations on GIMPLE (the basic data structure of
486 the high-level optimizers) to be checked for dynamic type safety at
487 runtime. This is moderately expensive.])
489 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
490 if test x$ac_runtime_checking != x ; then
491 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
492 [Define if you want runtime assertions enabled. This is a cheap check.])
494 if test x$ac_tree_checking != x ; then
495 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
496 [Define if you want all operations on trees (the basic data
497 structure of the front ends) to be checked for dynamic type safety
498 at runtime. This is moderately expensive. The tree browser debugging
499 routines will also be enabled by this option.
501 TREEBROWSER=tree-browser.o
504 if test x$ac_types_checking != x ; then
505 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
506 [Define if you want all gimple types to be verified after gimplifiation.
510 AC_SUBST(TREEBROWSER)
511 AC_SUBST(TREECHECKING)
512 if test x$ac_rtl_checking != x ; then
513 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
514 [Define if you want all operations on RTL (the basic data structure
515 of the optimizer and back end) to be checked for dynamic type safety
516 at runtime. This is quite expensive.])
518 if test x$ac_rtlflag_checking != x ; then
519 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
520 [Define if you want RTL flag accesses to be checked against the RTL
521 codes that are supported for each access macro. This is relatively
524 if test x$ac_gc_checking != x ; then
525 AC_DEFINE(ENABLE_GC_CHECKING, 1,
526 [Define if you want the garbage collector to do object poisoning and
527 other memory allocation checks. This is quite expensive.])
529 if test x$ac_gc_always_collect != x ; then
530 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
531 [Define if you want the garbage collector to operate in maximally
532 paranoid mode, validating the entire heap and collecting garbage at
533 every opportunity. This is extremely expensive.])
535 if test x$ac_fold_checking != x ; then
536 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
537 [Define if you want fold checked that it never destructs its argument.
538 This is quite expensive.])
540 valgrind_path_defines=
543 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
544 dnl # an if statement. This was the source of very frustrating bugs
545 dnl # in converting to autoconf 2.5x!
546 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
548 # It is certainly possible that there's valgrind but no valgrind.h.
549 # GCC relies on making annotations so we must have both.
550 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
551 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
552 [[#include <valgrind/memcheck.h>
553 #ifndef VALGRIND_DISCARD
554 #error VALGRIND_DISCARD not defined
556 [gcc_cv_header_valgrind_memcheck_h=yes],
557 [gcc_cv_header_valgrind_memcheck_h=no])
558 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
559 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
560 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
561 [[#include <memcheck.h>
562 #ifndef VALGRIND_DISCARD
563 #error VALGRIND_DISCARD not defined
565 [gcc_cv_header_memcheck_h=yes],
566 [gcc_cv_header_memcheck_h=no])
567 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
568 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
569 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
570 [Define if valgrind's valgrind/memcheck.h header is installed.])
572 if test $gcc_cv_header_memcheck_h = yes; then
573 AC_DEFINE(HAVE_MEMCHECK_H, 1,
574 [Define if valgrind's memcheck.h header is installed.])
577 if test x$ac_valgrind_checking != x ; then
578 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
579 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
580 if test "x$valgrind_path" = "x" \
581 || (test $have_valgrind_h = no \
582 && test $gcc_cv_header_memcheck_h = no \
583 && test $gcc_cv_header_valgrind_memcheck_h = no); then
584 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
586 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
587 valgrind_command="$valgrind_path -q"
588 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
589 [Define if you want to run subprograms and generated programs
590 through valgrind (a memory checker). This is extremely expensive.])
592 AC_SUBST(valgrind_path_defines)
593 AC_SUBST(valgrind_command)
595 # Enable code coverage collection
596 AC_ARG_ENABLE(coverage,
597 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
598 [enable compiler's code coverage collection.
599 Use to measure compiler performance and locate
600 unused parts of the compiler. With LEVEL, specify
601 optimization. Values are opt, noopt,
603 [case "${enableval}" in
605 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
608 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
611 # a.k.a. --disable-coverage
615 AC_MSG_ERROR(unknown coverage setting $enableval)
619 AC_SUBST(coverage_flags)
621 AC_ARG_ENABLE(gather-detailed-mem-stats,
622 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
623 [enable detailed memory allocation stats gathering])], [],
624 [enable_gather_detailed_mem_stats=no])
625 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
626 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
627 [Define to enable detailed memory allocation stats gathering.])
629 AC_ARG_ENABLE(valgrind-annotations,
630 [AS_HELP_STRING([--enable-valgrind-annotations],
631 [enable valgrind runtime interaction])], [],
632 [enable_valgrind_annotations=no])
633 if test x$enable_valgrind_annotations != xno \
634 || test x$ac_valgrind_checking != x; then
635 if (test $have_valgrind_h = no \
636 && test $gcc_cv_header_memcheck_h = no \
637 && test $gcc_cv_header_valgrind_memcheck_h = no); then
638 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
640 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
641 [Define to get calls to the valgrind runtime enabled.])
644 # -------------------------------
645 # Miscenalleous configure options
646 # -------------------------------
650 [AS_HELP_STRING([--with-stabs],
651 [arrange to use stabs instead of host debug format])],
655 # Determine whether or not multilibs are enabled.
656 AC_ARG_ENABLE(multilib,
657 [AS_HELP_STRING([--enable-multilib],
658 [enable library support for multiple ABIs])],
659 [], [enable_multilib=yes])
660 AC_SUBST(enable_multilib)
662 # Determine whether or not multiarch is enabled.
663 AC_ARG_ENABLE(multiarch,
664 [AS_HELP_STRING([--enable-multiarch],
665 [enable support for multiarch paths])],
666 [case "${enableval}" in
667 yes|no|auto) enable_multiarch=$enableval;;
668 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
669 esac], [enable_multiarch=auto])
670 if test x${enable_multiarch} = xauto; then
671 if test x${with_native_system_header_dir} != x; then
672 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
675 if test x$host != x$target && test "x$with_sysroot" = x; then
676 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
680 AC_MSG_CHECKING(for multiarch configuration)
681 AC_SUBST(enable_multiarch)
682 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
684 # needed for setting the multiarch name for soft-float/hard-float ABIs
688 # Enable __cxa_atexit for C++.
689 AC_ARG_ENABLE(__cxa_atexit,
690 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
693 # Enable C extension for decimal float if target supports it.
694 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
696 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
697 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
698 [Define to 1 to enable decimal float extension to C.])
700 # Use default_decimal_float for dependency.
701 enable_decimal_float=$default_decimal_float
703 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
704 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
705 [Define to 1 to specify that we are using the BID decimal floating
706 point format instead of DPD])
708 # Enable C extension for fixed-point arithmetic.
709 AC_ARG_ENABLE(fixed-point,
710 [AS_HELP_STRING([--enable-fixed-point],
711 [enable fixed-point arithmetic extension to C])],
716 enable_fixed_point=yes
720 enable_fixed_point=yes
723 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
724 enable_fixed_point=no
728 AC_SUBST(enable_fixed_point)
730 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
731 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
732 [Define to 1 to enable fixed-point arithmetic extension to C.])
735 # Pass with no value to take the default
736 # Pass with a value to specify a thread package
737 AC_ARG_ENABLE(threads,
738 [AS_HELP_STRING([[--enable-threads[=LIB]]],
739 [enable thread usage for target GCC,
740 using LIB thread package])],,
744 [AS_HELP_STRING([--enable-tls],
745 [enable or disable generation of tls code
746 overriding the assembler check for tls support])],
750 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
751 Valid choices are 'yes' and 'no'.]) ;;
755 AC_ARG_ENABLE(objc-gc,
756 [AS_HELP_STRING([--enable-objc-gc],
757 [enable the use of Boehm's garbage collector with
758 the GNU Objective-C runtime])],
759 if test x$enable_objc_gc = xno; then
767 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
768 dwarf2="$with_dwarf2",
771 AC_ARG_ENABLE(shared,
772 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
774 case $enable_shared in
778 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
779 for pkg in $enableval; do
780 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
787 ], [enable_shared=yes])
788 AC_SUBST(enable_shared)
790 AC_ARG_WITH([native-system-header-dir],
791 [ --with-native-system-header-dir=dir
792 use dir as the directory to look for standard
793 system header files in. Defaults to /usr/include.],
795 case ${with_native_system_header_dir} in
796 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
797 /* | [[A-Za-z]]:[[\\/]]*) ;;
798 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
800 configured_native_system_header_dir="${withval}"
801 ], [configured_native_system_header_dir=])
803 AC_ARG_WITH(build-sysroot,
804 [AS_HELP_STRING([--with-build-sysroot=sysroot],
805 [use sysroot as the system root during the build])],
806 [if test x"$withval" != x ; then
807 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
809 [SYSROOT_CFLAGS_FOR_TARGET=])
810 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
812 if test "x$prefix" = xNONE; then
813 test_prefix=/usr/local
817 if test "x$exec_prefix" = xNONE; then
818 test_exec_prefix=$test_prefix
820 test_exec_prefix=$exec_prefix
824 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
825 [search for usr/lib, usr/include, et al, within DIR])],
827 case ${with_sysroot} in
828 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
829 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
832 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
833 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
835 case ${TARGET_SYSTEM_ROOT} in
836 "${test_prefix}"|"${test_prefix}/"*|\
837 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
838 '${prefix}'|'${prefix}/'*|\
839 '${exec_prefix}'|'${exec_prefix}/'*)
840 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
841 TARGET_SYSTEM_ROOT_DEFINE="$t"
846 TARGET_SYSTEM_ROOT_DEFINE=
847 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
849 AC_SUBST(TARGET_SYSTEM_ROOT)
850 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
851 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
854 [AS_HELP_STRING([--with-specs=SPECS],
855 [add SPECS to driver command-line processing])],
856 [CONFIGURE_SPECS=$withval],
859 AC_SUBST(CONFIGURE_SPECS)
861 ACX_PKGVERSION([GCC])
862 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
864 # Sanity check enable_languages in case someone does not run the toplevel
865 # configure # script.
866 AC_ARG_ENABLE(languages,
867 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
868 [case ,${enable_languages}, in
870 # go safe -- we cannot be much sure without the toplevel
872 # analysis of which target libs are present and usable
876 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
881 enable_languages=c,${enable_languages}
884 [enable_languages=c])
886 AC_ARG_WITH(multilib-list,
887 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
889 with_multilib_list=default)
891 # -------------------------
892 # Checks for other programs
893 # -------------------------
897 # Find some useful tools
899 # We need awk to create options.c and options.h.
900 # Bail out if it's missing.
902 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
909 AC_SUBST(ranlib_flags)
913 # See if cmp has --ignore-initial.
914 gcc_AC_PROG_CMP_IGNORE_INITIAL
916 # See if we have the mktemp command.
917 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
919 # See if makeinfo has been installed and is modern enough
920 # that we can use it.
921 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
922 [GNU texinfo.* \([0-9][0-9.]*\)],
923 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
924 if test $gcc_cv_prog_makeinfo_modern = no; then
926 *** Makeinfo is missing or too old.
927 *** Info documentation will not be built.])
934 # Is pod2man recent enough to regenerate manpages?
935 AC_MSG_CHECKING([for recent Pod::Man])
936 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
938 GENERATED_MANPAGES=generated-manpages
943 AC_SUBST(GENERATED_MANPAGES)
945 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
948 dnl Don't use AC_PROG_LEX; we insist on flex.
949 dnl LEXLIB is not useful in gcc.
950 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
953 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
955 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
956 # check for build == host before using them.
959 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
960 && test -d ../binutils ; then
961 NM='${objdir}/../binutils/nm-new'
963 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
967 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
968 && test -d ../binutils ; then
969 AR='${objdir}/../binutils/ar'
971 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
975 # --------------------
976 # Checks for C headers
977 # --------------------
979 # Need to reject headers which give warnings, so that the -Werror bootstrap
980 # works later. *sigh* This needs to come before all header checks.
988 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
989 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
990 sys/resource.h sys/param.h sys/times.h sys/stat.h \
991 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
993 # Check for thread headers.
994 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
995 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
997 # These tests can't be done till we know if we have limits.h.
1001 # ----------------------
1002 # Checks for C++ headers
1003 # ----------------------
1005 dnl Autoconf will give an error in the configure script if there is no
1006 dnl C++ preprocessor. Hack to prevent that.
1007 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1009 m4_popdef([AC_MSG_ERROR])[]dnl
1013 AC_CHECK_HEADERS(unordered_map)
1014 AC_CHECK_HEADERS(tr1/unordered_map)
1015 AC_CHECK_HEADERS(ext/hash_map)
1020 # Dependency checking.
1025 AC_CONFIG_COMMANDS([gccdepdir],[
1026 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1027 for lang in $subdirs c-family common
1029 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1030 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1032 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1040 # These libraries may be used by collect2.
1041 # We may need a special search path to get them linked.
1042 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1044 for libs in '' -lld -lmld \
1045 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1046 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1049 AC_TRY_LINK_FUNC(ldopen,
1050 [gcc_cv_collect2_libs="$libs"; break])
1053 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1054 case $gcc_cv_collect2_libs in
1056 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1058 AC_SUBST(COLLECT2_LIBS)
1060 # When building Ada code on Alpha, we need exc_resume which is usually in
1061 # -lexc. So test for it.
1064 AC_SEARCH_LIBS(exc_resume, exc)
1067 AC_SUBST(GNAT_LIBEXC)
1069 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1072 AC_SEARCH_LIBS(kstat_open, kstat)
1073 EXTRA_GCC_LIBS="$LIBS"
1075 AC_SUBST(EXTRA_GCC_LIBS)
1077 # Some systems put ldexp and frexp in libm instead of libc; assume
1078 # they're both in the same place. jcf-dump needs them.
1081 AC_SEARCH_LIBS(ldexp, m)
1086 # Use <inttypes.h> only if it exists,
1087 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1089 AC_MSG_CHECKING(for inttypes.h)
1090 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1091 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1092 [[#define __STDC_FORMAT_MACROS
1093 #include <sys/types.h>
1094 #include <inttypes.h>]],
1099 [gcc_cv_header_inttypes_h=yes],
1100 [gcc_cv_header_inttypes_h=no])])
1101 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1102 if test $gcc_cv_header_inttypes_h = yes; then
1103 AC_DEFINE(HAVE_INTTYPES_H, 1,
1104 [Define if you have a working <inttypes.h> header file.])
1107 dnl Disabled until we have a complete test for buggy enum bitfields.
1108 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1110 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1111 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1112 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1113 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1114 putchar_unlocked putc_unlocked)
1115 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1116 popen sysconf strsignal getrusage nl_langinfo \
1117 gettimeofday mbstowcs wcswidth mmap setlocale \
1118 gcc_UNLOCKED_FUNCS madvise)
1120 if test x$ac_cv_func_mbstowcs = xyes; then
1121 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1122 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1128 [gcc_cv_func_mbstowcs_works=yes],
1129 [gcc_cv_func_mbstowcs_works=no],
1130 [gcc_cv_func_mbstowcs_works=yes])])
1131 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1132 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1133 [Define this macro if mbstowcs does not crash when its
1134 first argument is NULL.])
1138 AC_CHECK_TYPE(ssize_t, int)
1139 AC_CHECK_TYPE(caddr_t, char *)
1141 GCC_AC_FUNC_MMAP_BLACKLIST
1145 # Under VMS, vfork works very differently than on Unix. The standard test
1146 # won't work, and it isn't easily adaptable. It makes more sense to
1148 ac_cv_func_vfork_works=yes
1153 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1154 # iconv() prototype.
1159 # Until we have in-tree GNU iconv:
1161 AC_SUBST(LIBICONV_DEP)
1167 # We will need to find libiberty.h and ansidecl.h
1168 saved_CFLAGS="$CFLAGS"
1169 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1170 saved_CXXFLAGS="$CXXFLAGS"
1171 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1172 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1173 stpcpy strnlen strsignal strstr strverscmp \
1174 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1175 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1176 #include "ansidecl.h"
1177 #include "system.h"])
1179 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1180 #include "ansidecl.h"
1182 #ifdef HAVE_SYS_RESOURCE_H
1183 #include <sys/resource.h>
1187 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1188 #include "ansidecl.h"
1190 #ifdef HAVE_SYS_RESOURCE_H
1191 #include <sys/resource.h>
1193 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1194 [Define to `long' if <sys/resource.h> doesn't define.])])
1196 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1197 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1198 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1199 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1200 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1201 #include "ansidecl.h"
1210 gcc_AC_CHECK_DECLS(times, , ,[
1211 #include "ansidecl.h"
1213 #ifdef HAVE_SYS_TIMES_H
1214 #include <sys/times.h>
1218 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1219 #include "ansidecl.h"
1224 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1227 gcc_AC_CHECK_DECLS(madvise, , ,[
1228 #include "ansidecl.h"
1233 # More time-related stuff.
1234 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1235 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1236 #include "ansidecl.h"
1238 #ifdef HAVE_SYS_TIMES_H
1239 #include <sys/times.h>
1241 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1242 if test $ac_cv_struct_tms = yes; then
1243 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1244 [Define if <sys/times.h> defines struct tms.])
1247 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1248 # revisit after autoconf 2.50.
1249 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1250 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1251 #include "ansidecl.h"
1253 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1254 if test $gcc_cv_type_clock_t = yes; then
1255 AC_DEFINE(HAVE_CLOCK_T, 1,
1256 [Define if <time.h> defines clock_t.])
1259 # Check if F_SETLKW is supported by fcntl.
1260 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1261 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1262 #include <fcntl.h>]], [[
1268 return fcntl (1, F_SETLKW, &fl);]])],
1269 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1270 if test $ac_cv_f_setlkw = yes; then
1271 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1272 [Define if F_SETLKW supported by fcntl.])
1275 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1276 CFLAGS="$saved_CFLAGS"
1277 CXXFLAGS="$saved_CXXFLAGS"
1279 # mkdir takes a single argument on some systems.
1280 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1288 # With Setjmp/Longjmp based exception handling.
1289 AC_ARG_ENABLE(sjlj-exceptions,
1290 [AS_HELP_STRING([--enable-sjlj-exceptions],
1291 [arrange to use setjmp/longjmp exception handling])],
1294 if test $enableval != yes; then
1295 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1300 force_sjlj_exceptions=yes],
1303 force_sjlj_exceptions=yes
1307 force_sjlj_exceptions=yes
1311 force_sjlj_exceptions=no
1314 if test $force_sjlj_exceptions = yes; then
1315 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1316 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1317 [Define 0/1 to force the choice for exception handling model.])
1320 # --------------------------------------------------------
1321 # Build, host, and target specific configuration fragments
1322 # --------------------------------------------------------
1324 # Collect build-machine-specific information.
1325 . ${srcdir}/config.build
1327 # Collect host-machine-specific information.
1328 . ${srcdir}/config.host
1332 # Collect target-machine-specific information.
1333 . ${srcdir}/config.gcc
1335 extra_objs="${host_extra_objs} ${extra_objs}"
1336 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1338 # Default the target-machine variables that were not explicitly set.
1339 if test x"$tm_file" = x
1340 then tm_file=$cpu_type/$cpu_type.h; fi
1342 if test x"$extra_headers" = x
1343 then extra_headers=; fi
1345 if test x$md_file = x
1346 then md_file=$cpu_type/$cpu_type.md; fi
1348 if test x$out_file = x
1349 then out_file=$cpu_type/$cpu_type.c; fi
1351 if test x"$tmake_file" = x
1352 then tmake_file=$cpu_type/t-$cpu_type
1355 # Support --enable-initfini-array.
1356 if test x$enable_initfini_array != xno; then
1357 tm_file="${tm_file} initfini-array.h"
1360 if test x"$dwarf2" = xyes
1361 then tm_file="$tm_file tm-dwarf2.h"
1364 # Say what files are being used for the output code and MD file.
1365 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1366 echo "Using \`$srcdir/config/$md_file' as machine description file."
1368 # If any of the xm_file variables contain nonexistent files, warn
1369 # about them and drop them.
1372 for x in $build_xm_file; do
1373 if test -f $srcdir/config/$x
1375 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1381 for x in $host_xm_file; do
1382 if test -f $srcdir/config/$x
1384 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1390 for x in $xm_file; do
1391 if test -f $srcdir/config/$x
1393 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1399 for f in $tm_file; do
1402 if test $count = ax; then
1403 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1405 echo "Using the following target machine macro files:"
1406 for f in $tm_file; do
1407 echo " $srcdir/config/$f"
1411 if test x$use_long_long_for_widest_fast_int = xyes; then
1412 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1413 [Define to 1 if the 'long long' type is wider than 'long' but still
1414 efficiently supported by the host hardware.])
1417 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1418 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1420 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1421 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1424 for f in $host_xm_file; do
1427 if test $count = a; then
1429 elif test $count = ax; then
1430 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1432 echo "Using the following host machine macro files:"
1433 for f in $host_xm_file; do
1434 echo " $srcdir/config/$f"
1437 echo "Using ${out_host_hook_obj} for host machine hooks."
1439 if test "$host_xm_file" != "$build_xm_file"; then
1441 for f in $build_xm_file; do
1444 if test $count = a; then
1446 elif test $count = ax; then
1447 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1449 echo "Using the following build machine macro files:"
1450 for f in $build_xm_file; do
1451 echo " $srcdir/config/$f"
1456 if test -n "$configured_native_system_header_dir"; then
1457 native_system_header_dir=$configured_native_system_header_dir
1459 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1460 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1464 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1465 gcc_cv_mcontext_underscores,
1467 #include <sys/cdefs.h>
1468 #include <sys/signal.h>
1469 #include <ucontext.h>
1470 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1472 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1473 if test $gcc_cv_mcontext_underscores = yes; then
1474 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1475 [mcontext_t fields start with __])
1484 # Check if a valid thread package
1485 case ${enable_threads} in
1488 target_thread_file='single'
1492 target_thread_file='single'
1494 aix | dce | lynx | mipssde | posix | rtems | \
1495 single | tpf | vxworks | win32)
1496 target_thread_file=${enable_threads}
1499 echo "${enable_threads} is an unknown thread package" 1>&2
1504 if test x${thread_file} = x; then
1505 # No thread file set by target-specific clauses in config.gcc,
1506 # so use file chosen by default logic above
1507 thread_file=${target_thread_file}
1515 if test x$enable___cxa_atexit = xyes || \
1516 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1517 if test x$host = x$target; then
1519 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1520 # keyed to flag_use_cxa_atexit
1528 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1529 [echo "__cxa_atexit can't be enabled on this target"])
1533 # We can't check for __cxa_atexit when building a cross, so assume
1537 if test x$use_cxa_atexit = xyes; then
1538 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1539 [Define if you want to use __cxa_atexit, rather than atexit, to
1540 register C++ destructors for local statics and global objects.
1541 This is essential for fully standards-compliant handling of
1542 destructors, but requires __cxa_atexit in libc.])
1546 # Look for a file containing extra machine modes.
1547 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1548 extra_modes_file='$(srcdir)'/config/${extra_modes}
1549 AC_SUBST(extra_modes_file)
1550 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1551 [Define to the name of a file containing a list of extra machine modes
1552 for this architecture.])
1555 # Convert extra_options into a form suitable for Makefile use.
1558 for f in $extra_options; do
1559 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1560 all_opt_files="$all_opt_files $srcdir/config/$f"
1562 AC_SUBST(extra_opt_files)
1564 # auto-host.h is the file containing items generated by autoconf and is
1565 # the first file included by config.h.
1566 # If host=build, it is correct to have bconfig include auto-host.h
1567 # as well. If host!=build, we are in error and need to do more
1568 # work to find out the build config parameters.
1569 if test x$host = x$build
1571 build_auto=auto-host.h
1573 # We create a subdir, then run autoconf in the subdir.
1574 # To prevent recursion we set host and build for the new
1575 # invocation of configure to the build for this invocation
1582 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1583 *) realsrcdir=../${srcdir};;
1585 # Clearing GMPINC is necessary to prevent host headers being
1586 # used by the build compiler. Defining GENERATOR_FILE stops
1587 # system.h from including gmp.h.
1588 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1589 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1590 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1591 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1592 ${realsrcdir}/configure \
1593 --enable-languages=${enable_languages-all} \
1594 --target=$target_alias --host=$build_alias --build=$build_alias
1596 # We just finished tests for the build machine, so rename
1597 # the file auto-build.h in the gcc directory.
1598 mv auto-host.h ../auto-build.h
1601 build_auto=auto-build.h
1603 AC_SUBST(build_subdir)
1605 tm_file="${tm_file} defaults.h"
1606 tm_p_file="${tm_p_file} tm-preds.h"
1607 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1608 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1609 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1610 # put this back in temporarily.
1611 xm_file="auto-host.h ansidecl.h ${xm_file}"
1618 # Compile in configure arguments.
1619 if test -f configargs.h ; then
1620 # Being re-configured.
1621 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1622 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1624 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1627 # Double all backslashes and backslash all quotes to turn
1628 # gcc_config_arguments into a C string.
1629 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1630 $gcc_config_arguments
1632 gcc_config_arguments_str=`cat conftest.out`
1635 cat > configargs.h <<EOF
1636 /* Generated automatically. */
1637 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1638 static const char thread_model[] = "$thread_file";
1640 static const struct {
1641 const char *name, *value;
1642 } configure_default_options[] = $configure_default_options;
1647 gcc_BASEVER=`cat $srcdir/BASE-VER`
1648 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1649 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1650 if test -f $srcdir/REVISION ; then
1651 gcc_REVISION=`cat $srcdir/REVISION`
1655 cat > plugin-version.h <<EOF
1656 #include "configargs.h"
1658 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1659 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1660 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1661 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1663 static char basever[] = "$gcc_BASEVER";
1664 static char datestamp[] = "$gcc_DATESTAMP";
1665 static char devphase[] = "$gcc_DEVPHASE";
1666 static char revision[] = "$gcc_REVISION";
1668 /* FIXME plugins: We should make the version information more precise.
1669 One way to do is to add a checksum. */
1671 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1673 configuration_arguments};
1677 # Internationalization
1678 ZW_GNU_GETTEXT_SISTER_DIR
1680 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1681 # -liconv on the link line twice.
1682 case "$LIBINTL" in *$LIBICONV*)
1686 AC_ARG_ENABLE(secureplt,
1687 [AS_HELP_STRING([--enable-secureplt],
1688 [enable -msecure-plt by default for PowerPC])],
1691 AC_ARG_ENABLE(leading-mingw64-underscores,
1692 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1693 [enable leading underscores on 64 bit mingw targets]),
1695 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1696 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1697 [Define if we should use leading underscore on 64 bit mingw targets])])
1700 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1703 AC_ARG_ENABLE(frame-pointer,
1704 [AS_HELP_STRING([--enable-frame-pointer],
1705 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1708 linux* | darwin[[8912]]*)
1709 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1711 enable_frame_pointer=no
1714 enable_frame_pointer=yes
1719 # Windows32 Registry support for specifying GCC installation paths.
1720 AC_ARG_ENABLE(win32-registry,
1721 [AS_HELP_STRING([--disable-win32-registry],
1722 [disable lookup of installation paths in the
1723 Registry on Windows hosts])
1724 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1725 AS_HELP_STRING([--enable-win32-registry=KEY],
1726 [use KEY instead of GCC version as the last portion
1727 of the registry key])],,)
1730 win32 | pe | cygwin* | mingw32* | uwin*)
1731 if test "x$enable_win32_registry" != xno; then
1732 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1735 if test "x$enable_win32_registry" != xno; then
1736 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1737 [Define to 1 if installation paths should be looked up in the Windows
1738 Registry. Ignored on non-Windows hosts.])
1740 if test "x$enable_win32_registry" != xyes \
1741 && test "x$enable_win32_registry" != x; then
1742 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1743 [Define to be the last component of the Windows registry key under which
1744 to look for installation paths. The full key used will be
1745 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1746 The default is the GCC version number.])
1752 # Get an absolute path to the GCC top-level source directory
1753 holddir=`${PWDCMD-pwd}`
1755 topdir=`${PWDCMD-pwd}`
1758 # Conditionalize the makefile for this host machine.
1760 for f in ${host_xmake_file}
1762 if test -f ${srcdir}/config/$f
1764 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1768 # Conditionalize the makefile for this target machine.
1770 for f in ${tmake_file}
1772 if test -f ${srcdir}/config/$f
1774 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1777 tmake_file="${tmake_file_}"
1779 out_object_file=`basename $out_file .c`.o
1780 common_out_object_file=`basename $common_out_file .c`.o
1782 tm_file_list="options.h"
1783 tm_include_list="options.h insn-constants.h"
1784 for f in $tm_file; do
1787 f=`echo $f | sed 's/^..//'`
1788 tm_file_list="${tm_file_list} $f"
1789 tm_include_list="${tm_include_list} $f"
1792 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1793 tm_include_list="${tm_include_list} $f"
1796 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1797 tm_include_list="${tm_include_list} config/$f"
1804 for f in $tm_p_file; do
1807 tm_p_file_list="${tm_p_file_list} $f"
1808 tm_p_include_list="${tm_p_include_list} $f"
1811 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1812 tm_p_include_list="${tm_p_include_list} config/$f"
1818 for f in $xm_file; do
1821 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1822 xm_include_list="${xm_include_list} $f"
1825 xm_file_list="${xm_file_list} $f"
1826 xm_include_list="${xm_include_list} $f"
1829 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1830 xm_include_list="${xm_include_list} config/$f"
1836 host_xm_include_list=
1837 for f in $host_xm_file; do
1840 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1841 host_xm_include_list="${host_xm_include_list} $f"
1844 host_xm_file_list="${host_xm_file_list} $f"
1845 host_xm_include_list="${host_xm_include_list} $f"
1848 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1849 host_xm_include_list="${host_xm_include_list} config/$f"
1855 for f in $build_xm_file; do
1858 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1859 build_xm_include_list="${build_xm_include_list} $f"
1861 auto-build.h | auto-host.h )
1862 build_xm_file_list="${build_xm_file_list} $f"
1863 build_xm_include_list="${build_xm_include_list} $f"
1866 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1867 build_xm_include_list="${build_xm_include_list} config/$f"
1872 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1873 # cross-compiler which does not use the native headers and libraries.
1874 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1875 CROSS= AC_SUBST(CROSS)
1876 ALL=all.internal AC_SUBST(ALL)
1877 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1879 if test "x$with_build_sysroot" != x; then
1880 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1882 # This value is used, even on a native system, because
1883 # CROSS_SYSTEM_HEADER_DIR is just
1884 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1885 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1888 if test x$host != x$target
1890 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1892 SYSTEM_HEADER_DIR=$build_system_header_dir
1893 case "$host","$target" in
1894 # Darwin crosses can use the host system's libraries and headers,
1895 # because of the fat library support. Of course, it must be the
1896 # same version of Darwin on both sides. Allow the user to
1897 # just say --target=foo-darwin without a version number to mean
1898 # "the version on this system".
1899 *-*-darwin*,*-*-darwin*)
1900 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1901 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1902 if test $hostos = $targetos -o $targetos = darwin ; then
1904 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1909 i?86-*-*,x86_64-*-* \
1910 | powerpc*-*-*,powerpc64*-*-*)
1911 CROSS="$CROSS -DNATIVE_CROSS" ;;
1916 if test "x$with_headers" = x; then
1923 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1924 SYSTEM_HEADER_DIR=$build_system_header_dir
1927 # If this is a cross-compiler that does not
1928 # have its own set of headers then define
1931 # If this is using newlib, without having the headers available now,
1932 # then define inhibit_libc in LIBGCC2_CFLAGS.
1933 # This prevents libgcc2 from containing any code which requires libc
1935 : ${inhibit_libc=false}
1936 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1937 test x$with_newlib = xyes ; } &&
1938 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1941 AC_SUBST(inhibit_libc)
1943 # When building gcc with a cross-compiler, we need to adjust things so
1944 # that the generator programs are still built with the native compiler.
1945 # Also, we cannot run fixincludes.
1947 # These are the normal (build=host) settings:
1948 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1949 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1950 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1951 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1952 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1953 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1955 # And these apply if build != host, or we are generating coverage data
1956 if test x$build != x$host || test "x$coverage_flags" != x
1958 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1959 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1960 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1963 # Expand extra_headers to include complete path.
1964 # This substitutes for lots of t-* files.
1966 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1967 for file in ${extra_headers} ; do
1968 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1971 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1972 if test x"$use_gcc_tgmath" = xyes
1973 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1976 # Define collect2 in Makefile.
1977 case $host_can_use_collect2 in
1979 *) collect2='collect2$(exeext)' ;;
1981 AC_SUBST([collect2])
1983 # Add a definition of USE_COLLECT2 if system wants one.
1984 case $use_collect2 in
1985 no) use_collect2= ;;
1988 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1989 xm_defines="${xm_defines} USE_COLLECT2"
1990 case $host_can_use_collect2 in
1992 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1998 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1999 [Define to the name of the LTO plugin DSO that must be
2000 passed to the linker's -plugin=LIB option.])
2002 # ---------------------------
2003 # Assembler & linker features
2004 # ---------------------------
2006 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2007 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2008 # However when ld-new is first executed from the build tree, libtool will
2009 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2010 # to the build tree. While doing this we need to use the previous-stage
2011 # linker, or we have an infinite loop. The presence of a shell script as
2012 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2013 # the gcc/collect-ld script. So we need to know how libtool works, or
2014 # exec-tool will fail.
2016 m4_defun([_LT_CONFIG_COMMANDS], [])
2019 AC_SUBST(enable_fast_install)
2021 # Identify the assembler which will work hand-in-glove with the newly
2022 # built GCC, so that we can examine its features. This is the assembler
2023 # which will be driven by the driver program.
2025 # If build != host, and we aren't building gas in-tree, we identify a
2026 # build->target assembler and hope that it will have the same features
2027 # as the host->target assembler we'll be using.
2028 gcc_cv_gas_major_version=
2029 gcc_cv_gas_minor_version=
2030 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2032 m4_pattern_allow([AS_FOR_TARGET])dnl
2033 AS_VAR_SET_IF(gcc_cv_as,, [
2034 if test -x "$DEFAULT_ASSEMBLER"; then
2035 gcc_cv_as="$DEFAULT_ASSEMBLER"
2036 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2037 && test -f ../gas/Makefile \
2038 && test x$build = x$host; then
2039 gcc_cv_as=../gas/as-new$build_exeext
2040 elif test -x as$build_exeext; then
2041 # Build using assembler in the current directory.
2042 gcc_cv_as=./as$build_exeext
2043 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2044 gcc_cv_as="$AS_FOR_TARGET"
2046 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2049 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2050 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2051 case "$ORIGINAL_AS_FOR_TARGET" in
2052 ./as | ./as$build_exeext) ;;
2053 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2056 AC_MSG_CHECKING(what assembler to use)
2057 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2058 # Single tree build which includes gas. We want to prefer it
2059 # over whatever linker top-level may have detected, since
2060 # we'll use what we're building after installation anyway.
2061 AC_MSG_RESULT(newly built gas)
2063 _gcc_COMPUTE_GAS_VERSION
2064 in_tree_gas_is_elf=no
2065 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2066 || (grep 'obj_format = multi' ../gas/Makefile \
2067 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2069 in_tree_gas_is_elf=yes
2072 AC_MSG_RESULT($gcc_cv_as)
2078 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2079 [case "${enableval}" in
2086 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2087 [case "${enableval}" in
2089 install_gold_as_default=yes
2092 if test x${default_ld} != x; then
2093 install_gold_as_default=yes
2097 install_gold_as_default=no
2100 AC_MSG_ERROR([invalid --enable-gold argument])
2103 [install_gold_as_default=no])
2105 # Identify the linker which will work hand-in-glove with the newly
2106 # built GCC, so that we can examine its features. This is the linker
2107 # which will be driven by the driver program.
2109 # If build != host, and we aren't building gas in-tree, we identify a
2110 # build->target linker and hope that it will have the same features
2111 # as the host->target linker we'll be using.
2112 gcc_cv_gld_major_version=
2113 gcc_cv_gld_minor_version=
2114 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2115 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2116 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2118 AS_VAR_SET_IF(gcc_cv_ld,, [
2119 if test -x "$DEFAULT_LINKER"; then
2120 gcc_cv_ld="$DEFAULT_LINKER"
2121 elif test $install_gold_as_default = yes \
2122 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2123 && test -f ../gold/Makefile \
2124 && test x$build = x$host; then
2125 gcc_cv_ld=../gold/ld-new$build_exeext
2126 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2127 && test -f ../ld/Makefile \
2128 && test x$build = x$host; then
2129 gcc_cv_ld=../ld/ld-new$build_exeext
2130 elif test -x collect-ld$build_exeext; then
2131 # Build using linker in the current directory.
2132 gcc_cv_ld=./collect-ld$build_exeext
2133 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2134 gcc_cv_ld="$LD_FOR_TARGET"
2136 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2139 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2140 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2141 # if the PLUGIN_LD is set ld-new, just have it as ld
2142 # as that is the installed named.
2143 if test x$PLUGIN_LD_SUFFIX = xld-new \
2144 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2147 AC_ARG_WITH(plugin-ld,
2148 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2149 [if test x"$withval" != x; then
2150 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2151 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2153 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2154 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2156 # Check to see if we are using gold instead of ld
2157 AC_MSG_CHECKING(whether we are using gold)
2159 if test x$gcc_cv_ld != x; then
2160 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2161 | grep "GNU gold" > /dev/null; then
2165 AC_MSG_RESULT($ld_is_gold)
2167 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2168 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2169 case "$ORIGINAL_LD_FOR_TARGET" in
2170 ./collect-ld | ./collect-ld$build_exeext) ;;
2171 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2174 AC_MSG_CHECKING(what linker to use)
2175 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2176 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2177 # Single tree build which includes ld. We want to prefer it
2178 # over whatever linker top-level may have detected, since
2179 # we'll use what we're building after installation anyway.
2180 AC_MSG_RESULT(newly built ld)
2182 in_tree_ld_is_elf=no
2183 if (grep 'EMUL = .*elf' ../ld/Makefile \
2184 || grep 'EMUL = .*linux' ../ld/Makefile \
2185 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2186 in_tree_ld_is_elf=yes
2187 elif test "$ld_is_gold" = yes; then
2188 in_tree_ld_is_elf=yes
2190 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
2193 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2194 if test x$gcc_cv_gld_version != x; then
2198 case $gcc_cv_gld_version in
2201 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2204 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2205 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2207 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2208 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2210 AC_MSG_RESULT($gcc_cv_ld)
2212 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2213 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2214 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2217 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2218 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2220 # Figure out what nm we will be using.
2221 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2222 AS_VAR_SET_IF(gcc_cv_nm,, [
2223 if test -f $gcc_cv_binutils_srcdir/configure.in \
2224 && test -f ../binutils/Makefile \
2225 && test x$build = x$host; then
2226 gcc_cv_nm=../binutils/nm-new$build_exeext
2227 elif test -x nm$build_exeext; then
2228 gcc_cv_nm=./nm$build_exeext
2229 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2230 gcc_cv_nm="$NM_FOR_TARGET"
2232 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2235 AC_MSG_CHECKING(what nm to use)
2236 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2237 # Single tree build which includes binutils.
2238 AC_MSG_RESULT(newly built nm)
2241 AC_MSG_RESULT($gcc_cv_nm)
2245 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2246 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2247 case "$ORIGINAL_NM_FOR_TARGET" in
2248 ./nm | ./nm$build_exeext) ;;
2249 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2253 # Figure out what objdump we will be using.
2254 AS_VAR_SET_IF(gcc_cv_objdump,, [
2255 if test -f $gcc_cv_binutils_srcdir/configure.in \
2256 && test -f ../binutils/Makefile \
2257 && test x$build = x$host; then
2258 # Single tree build which includes binutils.
2259 gcc_cv_objdump=../binutils/objdump$build_exeext
2260 elif test -x objdump$build_exeext; then
2261 gcc_cv_objdump=./objdump$build_exeext
2262 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2263 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2265 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2268 AC_MSG_CHECKING(what objdump to use)
2269 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2270 # Single tree build which includes binutils.
2271 AC_MSG_RESULT(newly built objdump)
2272 elif test x$gcc_cv_objdump = x; then
2273 AC_MSG_RESULT(not found)
2275 AC_MSG_RESULT($gcc_cv_objdump)
2278 # Figure out what readelf we will be using.
2279 AS_VAR_SET_IF(gcc_cv_readelf,, [
2280 if test -f $gcc_cv_binutils_srcdir/configure.in \
2281 && test -f ../binutils/Makefile \
2282 && test x$build = x$host; then
2283 # Single tree build which includes binutils.
2284 gcc_cv_readelf=../binutils/readelf$build_exeext
2285 elif test -x readelf$build_exeext; then
2286 gcc_cv_readelf=./readelf$build_exeext
2288 AC_PATH_PROG(gcc_cv_readelf, readelf)
2291 AC_MSG_CHECKING(what readelf to use)
2292 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2293 # Single tree build which includes binutils.
2294 AC_MSG_RESULT(newly built readelf)
2295 elif test x$gcc_cv_readelf = x; then
2296 AC_MSG_RESULT(not found)
2298 AC_MSG_RESULT($gcc_cv_readelf)
2301 # Figure out what assembler alignment features are present.
2302 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2306 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2307 [Define if your assembler supports .balign and .p2align.])])
2309 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2312 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2313 [Define if your assembler supports specifying the maximum number
2314 of bytes to skip when using the GAS .p2align command.])])
2316 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2319 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2320 [Define if your assembler supports .literal16.])])
2322 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2324 [conftest_label1: .word 0
2326 conftest_label2: .word 0
2328 [if test x$gcc_cv_nm != x; then
2329 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2330 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2331 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2333 else gcc_cv_as_subsection_m1=yes
2335 rm -f conftest.nm1 conftest.nm2
2337 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2338 [Define if your assembler supports .subsection and .subsection -1 starts
2339 emitting at the beginning of your section.])])
2341 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2344 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2346 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2348 [ .weakref foobar, barfnot],,
2349 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2351 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2354 .NSUBSPA $CODE$,COMDAT],,
2355 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2357 # .hidden needs to be supported in both the assembler and the linker,
2358 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2359 # This is irritatingly difficult to feature test for; we have to check the
2360 # date string after the version number. If we've got an in-tree
2361 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2363 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2364 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2370 # Darwin as has some visibility support, though with a different syntax.
2371 gcc_cv_as_hidden=yes
2375 # gnu_indirect_function type is an extension proposed at
2376 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2377 # selection of function implementation
2378 AC_ARG_ENABLE(gnu-indirect-function,
2379 [AS_HELP_STRING([--enable-gnu-indirect-function],
2380 [enable the use of the @gnu_indirect_function to glibc systems])],
2381 [case $enable_gnu_indirect_function in
2383 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2384 Valid choices are 'yes' and 'no'.]) ;;
2386 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2388 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2389 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2390 [Define if your system supports gnu indirect functions.])
2394 if test $in_tree_ld != yes ; then
2395 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2396 if echo "$ld_ver" | grep GNU > /dev/null; then
2397 if test x"$ld_is_gold" = xyes; then
2398 # GNU gold --version looks like this:
2400 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2402 # We extract the binutils version which is more familiar and specific
2403 # than the gold version.
2404 ld_vers=`echo $ld_ver | sed -n \
2405 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2407 # GNU ld --version looks like this:
2409 # GNU ld (GNU Binutils) 2.21.51.20110225
2410 ld_vers=`echo $ld_ver | sed -n \
2411 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2413 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'`
2414 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2415 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2416 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2420 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2423 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2424 # /usr/ccs/bin/ld has been configured.
2425 ld_ver=`$gcc_cv_ld -V 2>&1`
2426 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2427 ld_vers=`echo $ld_ver | sed -n \
2428 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2429 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2430 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2438 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2439 [[if test $in_tree_ld = yes ; then
2441 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 \
2442 && test $in_tree_ld_is_elf = yes; then
2443 gcc_cv_ld_hidden=yes
2446 gcc_cv_ld_hidden=yes
2447 if test x"$ld_is_gold" = xyes; then
2449 elif echo "$ld_ver" | grep GNU > /dev/null; then
2451 mmix-knuth-mmixware)
2452 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2456 if test 0"$ld_date" -lt 20020404; then
2457 if test -n "$ld_date"; then
2458 # If there was date string, but was earlier than 2002-04-04, fail
2460 elif test -z "$ld_vers"; then
2461 # If there was no date string nor ld version number, something is wrong
2464 test -z "$ld_vers_patch" && ld_vers_patch=0
2465 if test "$ld_vers_major" -lt 2; then
2467 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2468 gcc_cv_ld_hidden="no"
2469 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2477 # Darwin ld has some visibility support.
2478 gcc_cv_ld_hidden=yes
2480 hppa64*-*-hpux* | ia64*-*-hpux*)
2481 gcc_cv_ld_hidden=yes
2483 *-*-solaris2.1[0-9]*)
2484 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2485 # .symbolic was only added in Solaris 9 12/02.
2486 gcc_cv_ld_hidden=yes
2494 libgcc_visibility=no
2495 AC_SUBST(libgcc_visibility)
2496 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2497 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2498 libgcc_visibility=yes
2499 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2500 [Define if your assembler and linker support .hidden.])
2503 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2504 gcc_cv_ld_ro_rw_mix=unknown
2505 if test $in_tree_ld = yes ; then
2506 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 \
2507 && test $in_tree_ld_is_elf = yes; then
2508 gcc_cv_ld_ro_rw_mix=read-write
2510 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2511 echo '.section myfoosect, "a"' > conftest1.s
2512 echo '.section myfoosect, "aw"' > conftest2.s
2513 echo '.byte 1' >> conftest2.s
2514 echo '.section myfoosect, "a"' > conftest3.s
2515 echo '.byte 0' >> conftest3.s
2516 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2517 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2518 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2519 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2520 conftest2.o conftest3.o > /dev/null 2>&1; then
2521 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2522 | sed -e '/myfoosect/!d' -e N`
2523 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2524 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2525 gcc_cv_ld_ro_rw_mix=read-only
2527 gcc_cv_ld_ro_rw_mix=read-write
2532 rm -f conftest.* conftest[123].*
2535 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2536 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2537 [Define if your linker links a mix of read-only
2538 and read-write sections into a read-write section.])
2540 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2542 gcc_AC_INITFINI_ARRAY
2544 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2545 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2553 [[# GAS versions before 2.11 do not support uleb128,
2554 # despite appearing to.
2555 # ??? There exists an elf-specific test that will crash
2556 # the assembler. Perhaps it's better to figure out whether
2557 # arbitrary sections are supported and try the test.
2558 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2559 if echo "$as_ver" | grep GNU > /dev/null; then
2560 as_vers=`echo $as_ver | sed -n \
2561 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2562 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2563 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2564 if test $as_major -eq 2 && test $as_minor -lt 11
2566 else gcc_cv_as_leb128=yes
2569 [AC_DEFINE(HAVE_AS_LEB128, 1,
2570 [Define if your assembler supports .sleb128 and .uleb128.])])
2572 # Check if we have assembler support for unwind directives.
2573 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2580 .cfi_escape 1, 2, 3, 4, 5
2584 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2585 # read-only and read-write sections, we need to make sure that the
2586 # assembler used emits read-write .eh_frame sections.
2587 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2588 if test "x$gcc_cv_objdump" != x; then
2589 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2590 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2591 gcc_cv_as_cfi_directive=no
2594 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2595 # On Solaris/x86, make sure that GCC and assembler agree on using
2596 # read-only .eh_frame sections for 64-bit.
2597 if test x$gas = xyes; then
2598 as_ix86_64_opt="--64"
2600 as_ix86_64_opt="-xarch=amd64"
2602 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2603 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2604 sed -e /.eh_frame/!d -e N | \
2605 grep READONLY > /dev/null; then
2606 gcc_cv_as_cfi_directive=yes
2608 gcc_cv_as_cfi_directive=no
2612 gcc_cv_as_cfi_directive=yes
2617 # no objdump, err on the side of caution
2618 gcc_cv_as_cfi_directive=no
2621 gcc_cv_as_cfi_directive=yes
2625 gcc_cv_as_cfi_directive=yes
2628 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2629 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2633 .cfi_adjust_cfa_offset 64
2635 .cfi_adjust_cfa_offset 128
2638 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2639 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2640 gcc_cv_as_cfi_advance_working=yes
2644 # no objdump, err on the side of caution
2645 gcc_cv_as_cfi_advance_working=no
2647 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2648 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2649 [`if test $gcc_cv_as_cfi_directive = yes \
2650 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2651 [Define 0/1 if your assembler supports CFI directives.])
2653 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2654 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2655 gcc_cv_as_cfi_personality_directive, ,,
2658 .cfi_personality 0, symbol
2660 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2661 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2662 then echo 1; else echo 0; fi`],
2663 [Define 0/1 if your assembler supports .cfi_personality.])
2665 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2666 gcc_cv_as_cfi_sections_directive, ,,
2668 .cfi_sections .debug_frame, .eh_frame
2672 win32 | pe | cygwin* | mingw32* | uwin*)
2673 # Need to check that we generated the correct relocation for the
2674 # .debug_frame section. This was fixed for binutils 2.21.
2675 gcc_cv_as_cfi_sections_directive=no
2676 if test "x$gcc_cv_objdump" != x; then
2677 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2678 grep secrel > /dev/null; then
2679 gcc_cv_as_cfi_sections_directive=yes
2684 gcc_cv_as_cfi_sections_directive=yes
2687 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2688 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2689 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2690 then echo 1; else echo 0; fi`],
2691 [Define 0/1 if your assembler supports .cfi_sections.])
2693 # GAS versions up to and including 2.11.0 may mis-optimize
2695 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2703 .section .eh_frame,"aw",@progbits
2705 .4byte .LECIE1-.LSCIE1
2719 .4byte .LEFDE1-.LASFDE1
2721 .4byte .LASFDE1-__FRAME_BEGIN__
2729 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2730 cat > conftest.lit <<EOF
2731 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2732 0010 01000000 12000000 18000000 00000000 ................
2733 0020 08000000 04080000 0044 .........D @&t@
2735 cat > conftest.big <<EOF
2736 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2737 0010 00000001 00000012 00000018 00000000 ................
2738 0020 00000008 04000000 0844 .........D @&t@
2740 # If the assembler didn't choke, and we can objdump,
2741 # and we got the correct data, then succeed.
2742 # The text in the here-document typically retains its unix-style line
2743 # endings, while the output of objdump will use host line endings.
2744 # Therefore, use diff -b for the comparisons.
2745 if test x$gcc_cv_objdump != x \
2746 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2747 | tail -3 > conftest.got \
2748 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2749 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2751 gcc_cv_as_eh_frame=yes
2752 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2753 gcc_cv_as_eh_frame=buggy
2755 # Uh oh, what do we do now?
2756 gcc_cv_as_eh_frame=no
2759 if test $gcc_cv_as_eh_frame = buggy; then
2760 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2761 [Define if your assembler mis-optimizes .eh_frame data.])
2764 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2765 [elf,2,12,0], [--fatal-warnings],
2766 [.section .rodata.str, "aMS", @progbits, 1])
2767 if test $gcc_cv_as_shf_merge = no; then
2768 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2769 [elf,2,12,0], [--fatal-warnings],
2770 [.section .rodata.str, "aMS", %progbits, 1])
2772 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2773 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2774 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2776 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2777 gcc_cv_as_comdat_group,
2778 [elf,2,16,0], [--fatal-warnings],
2779 [.section .text,"axG",@progbits,.foo,comdat])
2780 if test $gcc_cv_as_comdat_group = yes; then
2781 gcc_cv_as_comdat_group_percent=no
2782 gcc_cv_as_comdat_group_group=no
2784 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2785 gcc_cv_as_comdat_group_percent,
2786 [elf,2,16,0], [--fatal-warnings],
2787 [.section .text,"axG",%progbits,.foo,comdat])
2788 if test $gcc_cv_as_comdat_group_percent = yes; then
2789 gcc_cv_as_comdat_group_group=no
2791 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2792 gcc_cv_as_comdat_group_group=no
2795 # Sun as uses a completely different syntax.
2800 .group foo,".text%foo",#comdat
2801 .section ".text%foo", #alloc,#execinstr,#progbits
2806 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2808 .group foo,.text%foo,#comdat
2809 .section .text%foo, "ax", @progbits
2815 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2816 gcc_cv_as_comdat_group_group,
2822 if test x"$ld_is_gold" = xyes; then
2824 elif test $in_tree_ld = yes ; then
2826 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 \
2827 && test $in_tree_ld_is_elf = yes; then
2830 elif echo "$ld_ver" | grep GNU > /dev/null; then
2832 if test 0"$ld_date" -lt 20050308; then
2833 if test -n "$ld_date"; then
2834 # If there was date string, but was earlier than 2005-03-08, fail
2836 elif test "$ld_vers_major" -lt 2; then
2838 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2845 *-*-solaris2.1[1-9]*)
2847 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2848 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2851 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2852 # least ld version 1.2267.
2853 if test "$ld_vers_major" -gt 1; then
2855 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2857 elif test "$ld_vers_minor" -ge 2267; then
2862 # Assume linkers other than GNU ld don't support COMDAT group.
2868 # Allow overriding the automatic COMDAT group tests above.
2869 AC_ARG_ENABLE(comdat,
2870 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2871 [comdat_group="$enable_comdat"])
2872 if test $comdat_group = no; then
2873 gcc_cv_as_comdat_group=no
2874 gcc_cv_as_comdat_group_percent=no
2875 gcc_cv_as_comdat_group_group=no
2877 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2878 [`if test $gcc_cv_as_comdat_group = yes \
2879 || test $gcc_cv_as_comdat_group_percent = yes \
2880 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2881 [Define 0/1 if your assembler and linker support COMDAT groups.])
2883 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2884 gcc_cv_as_discriminator,
2888 .loc 1 1 0 discriminator 1],,
2889 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2890 [Define if your assembler supports the .loc discriminator sub-directive.])])
2892 # Thread-local storage - the check is heavily parameterized.
2901 .section ".tdata","awT",@progbits
2904 ldq $27,__tls_get_addr($29) !literal!1
2905 lda $16,foo($29) !tlsgd!1
2906 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2907 ldq $27,__tls_get_addr($29) !literal!2
2908 lda $16,foo($29) !tlsldm!2
2909 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2910 ldq $1,foo($29) !gotdtprel
2911 ldah $2,foo($29) !dtprelhi
2912 lda $3,foo($2) !dtprello
2913 lda $4,foo($29) !dtprel
2914 ldq $1,foo($29) !gottprel
2915 ldah $2,foo($29) !tprelhi
2916 lda $3,foo($2) !tprello
2917 lda $4,foo($29) !tprel'
2920 tls_as_opt=--fatal-warnings
2922 cris-*-*|crisv32-*-*)
2924 .section ".tdata","awT",@progbits
2931 tls_as_opt=--fatal-warnings
2935 .section ".tdata","awT",@progbits
2947 .section ".tdata","awT",@progbits
2951 addil LT%foo-$tls_gdidx$,gp
2952 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2955 addil LT%foo-$tls_ldidx$,gp
2957 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2958 addil LR%foo-$tls_dtpoff$,%ret0
2959 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2961 addil LT%foo-$tls_ieoff$,gp
2962 ldw RT%foo-$tls_ieoff$(%r1),%t2
2965 addil LR%foo-$tls_leoff$,%t1
2966 ldo RR%foo-$tls_leoff$(%r1),%t2'
2969 tls_as_opt=--fatal-warnings
2973 .section ".tdata","awT",%progbits
2984 i[34567]86-*-* | x86_64-*-*)
2986 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
2993 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2995 .section .tdata,"awt",@progbits'
3000 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3001 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3005 .section ".tdata","awT",@progbits'
3009 tls_as_opt="--fatal-warnings"
3013 conftest_s="$conftest_s
3017 leal foo@tlsgd(,%ebx,1), %eax
3018 leal foo@tlsldm(%ebx), %eax
3019 leal foo@dtpoff(%eax), %edx
3020 movl foo@gottpoff(%ebx), %eax
3021 subl foo@gottpoff(%ebx), %eax
3022 addl foo@gotntpoff(%ebx), %eax
3023 movl foo@indntpoff, %eax
3024 movl \$foo@tpoff, %eax
3025 subl \$foo@tpoff, %eax
3026 leal foo@ntpoff(%ecx), %eax"
3029 if test x$on_solaris = xyes; then
3031 yes) tls_as_opt="$tls_as_opt --64" ;;
3032 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3035 conftest_s="$conftest_s
3039 leaq foo@tlsgd(%rip), %rdi
3040 leaq foo@tlsld(%rip), %rdi
3041 leaq foo@dtpoff(%rax), %rdx
3042 movq foo@gottpoff(%rip), %rax
3043 movq \$foo@tpoff, %rax"
3049 .section ".tdata","awT",@progbits
3052 addl r16 = @ltoff(@dtpmod(foo#)), gp
3053 addl r17 = @ltoff(@dtprel(foo#)), gp
3054 addl r18 = @ltoff(@tprel(foo#)), gp
3055 addl r19 = @dtprel(foo#), gp
3056 adds r21 = @dtprel(foo#), r13
3057 movl r23 = @dtprel(foo#)
3058 addl r20 = @tprel(foo#), gp
3059 adds r22 = @tprel(foo#), r13
3060 movl r24 = @tprel(foo#)'
3063 tls_as_opt=--fatal-warnings
3067 .section .tdata,"awT",@progbits
3071 addik r5,r20,x@TLSGD
3072 addik r5,r20,x@TLSLDM'
3075 tls_as_opt='--fatal-warnings'
3079 .section .tdata,"awT",@progbits
3083 addiu $4, $28, %tlsgd(x)
3084 addiu $4, $28, %tlsldm(x)
3085 lui $4, %dtprel_hi(x)
3086 addiu $4, $4, %dtprel_lo(x)
3087 lw $4, %gottprel(x)($28)
3088 lui $4, %tprel_hi(x)
3089 addiu $4, $4, %tprel_lo(x)'
3092 tls_as_opt='-32 --fatal-warnings'
3096 .section .tdata,"awT",@progbits
3101 move.l x@TLSGD(%a5),%a0
3102 move.l x@TLSLDM(%a5),%a0
3103 move.l x@TLSLDO(%a5),%a0
3104 move.l x@TLSIE(%a5),%a0
3105 move.l x@TLSLE(%a5),%a0'
3108 tls_as_opt='--fatal-warnings'
3112 .section ".tdata","awT",@progbits'
3115 tls_as_opt="--fatal-warnings"
3119 .section ".tdata","awT",%progbits
3123 add x0, x0, #:tlsgd_lo12:x
3128 tls_as_opt='--fatal-warnings'
3132 .extern __get_tpointer
3150 .section ".tdata","awT",@progbits
3158 addi 3,2,ld0@got@tlsgd
3164 addi 3,2,x1@got@tlsld
3170 addis 9,3,x2@dtprel@ha
3171 addi 9,9,x2@dtprel@l
3174 ld 9,x3@got@dtprel(2)
3180 tls_as_opt="-a64 --fatal-warnings"
3184 .section ".tdata","awT",@progbits
3192 addi 3,31,ld0@got@tlsgd
3194 addi 3,31,x1@got@tlsld
3197 addis 9,3,x2@dtprel@ha
3198 addi 9,9,x2@dtprel@l
3199 lwz 9,x3@got@tprel(31)
3202 addis 9,2,x2@tprel@ha
3203 addi 9,9,x2@tprel@l'
3206 tls_as_opt="-a32 --fatal-warnings"
3210 .section ".tdata","awT",@progbits
3219 l %r1,foo@GOTNTPOFF(%r12)
3220 l %r1,0(%r1):tls_load:foo
3221 bas %r14,0(%r1,%r13):tls_gdcall:foo
3222 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3225 tls_as_opt="-m31 --fatal-warnings"
3229 .section ".tdata","awT",@progbits
3237 lg %r1,foo@GOTNTPOFF(%r12)
3238 larl %r1,foo@INDNTPOFF
3239 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3240 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3243 tls_as_opt="-m64 -Aesame --fatal-warnings"
3245 sh-*-* | sh[34]-*-*)
3247 .section ".tdata","awT",@progbits
3257 tls_as_opt=--fatal-warnings
3261 sparc*-sun-solaris2.*)
3268 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3270 .section ".tdata",#alloc,#write,#tls'
3275 .section ".tdata","awT",@progbits'
3278 tls_as_opt="-32 --fatal-warnings"
3280 conftest_s="$conftest_s
3283 sethi %tgd_hi22(foo), %o0
3284 add %o0, %tgd_lo10(foo), %o1
3285 add %l7, %o1, %o0, %tgd_add(foo)
3286 call __tls_get_addr, %tgd_call(foo)
3287 sethi %tldm_hi22(foo), %l1
3288 add %l1, %tldm_lo10(foo), %l2
3289 add %l7, %l2, %o0, %tldm_add(foo)
3290 call __tls_get_addr, %tldm_call(foo)
3291 sethi %tldo_hix22(foo), %l3
3292 xor %l3, %tldo_lox10(foo), %l4
3293 add %o0, %l4, %l5, %tldo_add(foo)
3294 sethi %tie_hi22(foo), %o3
3295 add %o3, %tie_lo10(foo), %o3
3296 ld [%l7 + %o3], %o2, %tie_ld(foo)
3297 add %g7, %o2, %o4, %tie_add(foo)
3298 sethi %tle_hix22(foo), %l1
3299 xor %l1, %tle_lox10(foo), %o5
3300 ld [%g7 + %o5], %o1"
3304 .section ".tdata","awT",@progbits
3307 addli r0, zero, tls_gd(foo)
3308 auli r0, zero, tls_gd_ha16(foo)
3309 addli r0, r0, tls_gd_lo16(foo)
3311 addli r0, zero, tls_ie(foo)
3312 auli r0, r0, tls_ie_ha16(foo)
3313 addli r0, r0, tls_ie_lo16(foo)'
3316 tls_as_opt="--fatal-warnings"
3320 .section ".tdata","awT",@progbits
3323 shl16insli r0, zero, hw0_last_tls_gd(foo)
3324 shl16insli r0, zero, hw1_last_tls_gd(foo)
3325 shl16insli r0, r0, hw0_tls_gd(foo)
3327 shl16insli r0, zero, hw1_last_tls_ie(foo)
3328 shl16insli r0, r0, hw0_tls_ie(foo)'
3331 tls_as_opt="--fatal-warnings"
3335 .section ".tdata","awT",@progbits
3338 movi a8, foo@TLSFUNC
3339 movi a10, foo@TLSARG
3340 callx8.tls a8, foo@TLSCALL'
3347 if test "x$enable_tls" = xno ; then
3348 : # TLS explicitly disabled.
3349 elif test "x$enable_tls" = xyes ; then
3350 set_have_as_tls=yes # TLS explicitly enabled.
3351 elif test -z "$tls_first_major"; then
3352 : # If we don't have a check, assume no support.
3354 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3355 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3356 [set_have_as_tls=yes])
3358 if test $set_have_as_tls = yes ; then
3359 AC_DEFINE(HAVE_AS_TLS, 1,
3360 [Define if your assembler and linker support thread-local storage.])
3363 # Target-specific assembler checks.
3365 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3366 gcc_cv_ld_static_dynamic=no
3367 gcc_cv_ld_static_option='-Bstatic'
3368 gcc_cv_ld_dynamic_option='-Bdynamic'
3369 if test $in_tree_ld = yes ; then
3370 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
3371 gcc_cv_ld_static_dynamic=yes
3373 elif test x$gcc_cv_ld != x; then
3374 # Check if linker supports -Bstatic/-Bdynamic option
3375 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3376 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3377 gcc_cv_ld_static_dynamic=yes
3380 # AIX ld uses -b flags
3381 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3382 gcc_cv_ld_static_dynamic=yes
3383 gcc_cv_ld_static_option="-bstatic"
3384 gcc_cv_ld_dynamic_option="-bdynamic"
3386 # HP-UX ld uses -a flags to select between shared and archive.
3388 if test x"$gnu_ld" = xno; then
3389 gcc_cv_ld_static_dynamic=yes
3390 gcc_cv_ld_static_option="-aarchive_shared"
3391 gcc_cv_ld_dynamic_option="-adefault"
3394 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3396 gcc_cv_ld_static_dynamic=yes
3401 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3402 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3403 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3404 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3405 [Define to the linker option to disable use of shared objects.])
3406 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3407 [Define to the linker option to enable use of shared objects.])
3409 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3411 if test x"$demangler_in_ld" = xyes; then
3412 AC_MSG_CHECKING(linker --demangle support)
3413 gcc_cv_ld_demangle=no
3414 if test $in_tree_ld = yes; then
3415 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 \
3416 gcc_cv_ld_demangle=yes
3418 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3419 # Check if the GNU linker supports --demangle option
3420 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3421 gcc_cv_ld_demangle=yes
3424 if test x"$gcc_cv_ld_demangle" = xyes; then
3425 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3426 [Define if your linker supports --demangle option.])
3428 AC_MSG_RESULT($gcc_cv_ld_demangle)
3431 AC_MSG_CHECKING(linker plugin support)
3433 if test -f liblto_plugin.la; then
3434 save_ld_ver="$ld_ver"
3435 save_ld_vers_major="$ld_vers_major"
3436 save_ld_vers_minor="$ld_vers_minor"
3437 save_ld_is_gold="$ld_is_gold"
3441 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3443 # FIXME: ld_is_gold?
3444 ld_vers_major="$gcc_cv_gld_major_version"
3445 ld_vers_minor="$gcc_cv_gld_minor_version"
3447 # Determine plugin linker version.
3448 # FIXME: Partial duplicate from above, generalize.
3450 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3451 if echo "$ld_ver" | grep GNU > /dev/null; then
3452 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3454 ld_vers=`echo $ld_ver | sed -n \
3455 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3457 ld_vers=`echo $ld_ver | sed -n \
3458 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3460 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3461 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3466 # Determine plugin support.
3467 if echo "$ld_ver" | grep GNU > /dev/null; then
3468 # Require GNU ld or gold 2.21+ for plugin support by default.
3469 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3471 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3472 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3477 ld_ver="$save_ld_ver"
3478 ld_vers_major="$save_ld_vers_major"
3479 ld_vers_minor="$save_ld_vers_minor"
3480 ld_is_gold="$save_ld_is_gold"
3482 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3483 [Define to the level of your linker's plugin support.])
3484 AC_MSG_RESULT($gcc_cv_lto_plugin)
3488 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3489 [-mabi=lp64], [.text],,,)
3490 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3491 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3492 [Define if your assembler supports the -mabi option.])
3494 if test x$with_abi = xilp32; then
3495 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3496 Upgrade the Assembler.])
3498 if test x"$with_multilib_list" = xdefault; then
3499 TM_MULTILIB_CONFIG=lp64
3501 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3502 for aarch64_multilib in ${aarch64_multilibs}; do
3503 case ${aarch64_multilib} in
3505 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3506 Upgrade the Assembler.])
3516 # All TARGET_ABI_OSF targets.
3517 alpha*-*-linux* | alpha*-*-*bsd*)
3518 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3519 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3522 extbl $3, $2, $3 !lituse_bytoff!1
3523 ldq $2, a($29) !literal!1
3524 ldq $4, b($29) !literal!2
3525 ldq_u $3, 0($2) !lituse_base!1
3526 ldq $27, f($29) !literal!5
3527 jsr $26, ($27), f !lituse_jsr!5
3528 ldah $29, 0($26) !gpdisp!3
3529 lda $0, c($29) !gprel
3530 ldah $1, d($29) !gprelhigh
3531 lda $1, d($1) !gprellow
3532 lda $29, 0($29) !gpdisp!3],,
3533 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3534 [Define if your assembler supports explicit relocations.])])
3535 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3536 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3539 ldq $27, a($29) !literal!1
3540 jsr $26, ($27), a !lituse_jsrdirect!1],,
3541 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3542 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3546 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3547 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3548 [-no-mul-bug-abort], [.text],,
3549 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3550 [Define if your assembler supports the -no-mul-bug-abort option.])])
3554 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3555 [.register %g2, #scratch],,
3556 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3557 [Define if your assembler supports .register.])])
3559 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3560 [.section "nobits",#alloc,#write,#nobits
3561 .section "progbits",#alloc,#write,#progbits])
3562 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3563 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3564 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3566 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3568 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3569 [Define if your assembler supports -relax option.])])
3571 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3572 gcc_cv_as_sparc_gotdata_op,,
3579 sethi %gdop_hix22(foo), %g1
3580 xor %g1, %gdop_lox10(foo), %g1
3581 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3582 [if test x$gcc_cv_ld != x \
3583 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3584 if test x$gcc_cv_objdump != x; then
3585 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3586 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3587 gcc_cv_as_sparc_gotdata_op=no
3589 gcc_cv_as_sparc_gotdata_op=yes
3594 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3595 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3597 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3598 gcc_cv_as_sparc_ua_pcrel,,
3606 .uaword %r_disp32(foo)],
3607 [if test x$gcc_cv_ld != x \
3608 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3609 gcc_cv_as_sparc_ua_pcrel=yes
3612 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3613 [Define if your assembler and linker support unaligned PC relative relocs.])
3615 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3616 gcc_cv_as_sparc_ua_pcrel_hidden,,
3621 .uaword %r_disp32(foo)
3622 .byte 0x32, 0x33, 0x34
3627 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3628 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3629 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3630 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3631 if $gcc_cv_objdump -R conftest 2> /dev/null \
3632 | grep 'DISP32' > /dev/null 2>&1; then
3635 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3639 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3640 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3641 ]) # unaligned pcrel relocs
3643 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3644 gcc_cv_as_sparc_offsetable_lo10,,
3647 or %g1, %lo(ab) + 12, %g1
3648 or %g1, %lo(ab + 12), %g1],
3649 [if test x$gcc_cv_objdump != x \
3650 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3651 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3652 gcc_cv_as_sparc_offsetable_lo10=yes
3654 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3655 [Define if your assembler supports offsetable %lo().])])
3657 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3658 gcc_cv_as_sparc_fmaf,,
3661 .register %g2, #scratch
3662 .register %g3, #scratch
3664 fmaddd %f0, %f2, %f4, %f6
3665 addxccc %g1, %g2, %g3
3666 fsrl32 %f2, %f4, %f8
3667 fnaddd %f10, %f12, %f14],,
3668 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3669 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3671 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3672 gcc_cv_as_sparc_sparc4,,
3675 .register %g2, #scratch
3676 .register %g3, #scratch
3679 1: cwbneg %g2, %g3, 1f
3682 aes_kexpand0 %f4, %f6, %f8
3683 des_round %f38, %f40, %f42, %f44
3684 camellia_f %f54, %f56, %f58, %f60
3685 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3686 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3687 [Define if your assembler supports SPARC4 instructions.])])
3689 gcc_GAS_CHECK_FEATURE([LEON instructions],
3690 gcc_cv_as_sparc_leon,,
3693 .register %g2, #scratch
3694 .register %g3, #scratch
3698 casa [[%g2]] 0xb, %g3, %g1],,
3699 [AC_DEFINE(HAVE_AS_LEON, 1,
3700 [Define if your assembler supports LEON instructions.])])
3704 i[34567]86-*-* | x86_64-*-*)
3708 # Full C++ conformance when using a shared libstdc++-v3 requires some
3709 # support from the Cygwin DLL, which in more recent versions exports
3710 # wrappers to aid in interposing and redirecting operators new, delete,
3711 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3712 # are configuring for a version of Cygwin that exports the wrappers.
3713 if test x$host = x$target && test x$host_cpu = xi686; then
3714 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3716 # Can't check presence of libc functions during cross-compile, so
3717 # we just have to assume we're building for an up-to-date target.
3718 gcc_ac_cygwin_dll_wrappers=yes
3720 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3721 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3722 [Define if you want to generate code by default that assumes that the
3723 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3726 cygwin* | pe | mingw32* | interix*)
3727 # Recent binutils allows the three-operand form of ".comm" on PE. This
3728 # definition is used unconditionally to initialise the default state of
3729 # the target option variable that governs usage of the feature.
3730 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3731 [2,19,52],,[.comm foo,1,32])
3732 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3733 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3734 [Define if your assembler supports specifying the alignment
3735 of objects allocated using the GAS .comm command.])
3736 # Used for DWARF 2 in PE
3737 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3738 gcc_cv_as_ix86_pe_secrel32,
3744 [if test x$gcc_cv_ld != x \
3745 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3746 gcc_cv_as_ix86_pe_secrel32=yes
3749 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3750 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3751 # Test if the assembler supports the extended form of the .section
3752 # directive that specifies section alignment. LTO support uses this,
3753 # but normally only after installation, so we warn but don't fail the
3754 # configure if LTO is enabled but the assembler does not support it.
3755 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3756 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3757 if test x$gcc_cv_as_section_has_align != xyes; then
3758 case ",$enable_languages," in
3760 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3764 # Test if the assembler supports the section flag 'e' for specifying
3765 # an excluded section.
3766 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3770 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3771 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3772 [Define if your assembler supports specifying the section flag e.])
3776 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3777 gcc_cv_as_ix86_filds,,,
3778 [filds mem; fists mem],,
3779 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3780 [Define if your assembler uses filds and fists mnemonics.])])
3782 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3783 gcc_cv_as_ix86_fildq,,,
3784 [fildq mem; fistpq mem],,
3785 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3786 [Define if your assembler uses fildq and fistq mnemonics.])])
3788 gcc_GAS_CHECK_FEATURE([cmov syntax],
3789 gcc_cv_as_ix86_cmov_sun_syntax,,,
3790 [cmovl.l %edx, %eax],,
3791 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3792 [Define if your assembler supports the Sun syntax for cmov.])])
3794 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3795 gcc_cv_as_ix86_ffreep,,,
3797 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3798 [Define if your assembler supports the ffreep mnemonic.])])
3800 gcc_GAS_CHECK_FEATURE([.quad directive],
3801 gcc_cv_as_ix86_quad,,,
3803 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3804 [Define if your assembler supports the .quad directive.])])
3806 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3807 gcc_cv_as_ix86_sahf,,,
3810 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3811 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3813 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3814 gcc_cv_as_ix86_interunit_movq,,,
3818 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3819 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3820 [Define if your assembler supports interunit movq mnemonic.])
3822 gcc_GAS_CHECK_FEATURE([hle prefixes],
3823 gcc_cv_as_ix86_hle,,,
3824 [lock xacquire cmpxchg %esi, (%ecx)],,
3825 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3826 [Define if your assembler supports HLE prefixes.])])
3828 gcc_GAS_CHECK_FEATURE([swap suffix],
3829 gcc_cv_as_ix86_swap,,,
3830 [movl.s %esp, %ebp],,
3831 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3832 [Define if your assembler supports the swap suffix.])])
3834 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3835 gcc_cv_as_ix86_diff_sect_delta,,,
3843 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3844 [Define if your assembler supports the subtraction of symbols in different sections.])])
3846 # These two are used unconditionally by i386.[ch]; it is to be defined
3847 # to 1 if the feature is present, 0 otherwise.
3848 as_ix86_gotoff_in_data_opt=
3849 if test x$gas = xyes; then
3850 as_ix86_gotoff_in_data_opt="--32"
3852 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3853 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3854 [$as_ix86_gotoff_in_data_opt],
3860 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3861 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3862 [Define true if the assembler supports '.long foo@GOTOFF'.])
3864 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3865 gcc_cv_as_ix86_rep_lock_prefix,,,
3871 lock addl %edi, (%eax,%esi)
3872 lock orl $0, (%esp)],,
3873 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3874 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3876 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3877 gcc_cv_as_ix86_ud2,,,
3879 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3880 [Define if your assembler supports the 'ud2' mnemonic.])])
3882 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3883 gcc_cv_as_ix86_tlsgdplt,,,
3884 [call tls_gd@tlsgdplt],
3885 [if test x$gcc_cv_ld != x \
3886 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3887 gcc_cv_as_ix86_tlsgdplt=yes
3890 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3891 [Define if your assembler and linker support @tlsgdplt.])])
3894 .section .tdata,"aw'$tls_section_flag'",@progbits
3896 .section .text,"ax",@progbits
3897 call tls_ld@tlsldmplt'
3898 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3899 gcc_cv_as_ix86_tlsldmplt,,,
3901 [if test x$gcc_cv_ld != x \
3902 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3903 gcc_cv_as_ix86_tlsldmplt=yes
3906 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3907 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3908 [Define to 1 if your assembler and linker support @tlsldmplt.])
3910 # Enforce 32-bit output with gas and gld.
3911 if test x$gas = xyes; then
3912 as_ix86_tls_ldm_opt="--32"
3914 if echo "$ld_ver" | grep GNU > /dev/null; then
3915 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3916 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3918 ld_ix86_tls_ldm_opt="-melf_i386"
3922 .section .text,"ax",@progbits
3924 .type _start, @function
3926 leal value@tlsldm(%ebx), %eax
3927 call ___tls_get_addr@plt
3929 .section .tdata,"aw'$tls_section_flag'",@progbits
3930 .type value, @object
3932 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3933 gcc_cv_as_ix86_tlsldm,,
3934 [$as_ix86_tls_ldm_opt],
3936 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3937 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3938 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3939 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3940 gcc_cv_as_ix86_tlsldm=yes
3944 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3945 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3946 [Define to 1 if your assembler and linker support @tlsldm.])
3951 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3952 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3954 addl r15 = @ltoffx(x#), gp
3956 ld8.mov r16 = [[r15]], x#],,
3957 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3958 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3964 *-*-aix*) conftest_s=' .machine "pwr5"
3968 gcc_GAS_CHECK_FEATURE([.machine directive support],
3969 gcc_cv_as_machine_directive,,,
3970 [ .machine ppc7400])
3971 if test x$gcc_cv_as_machine_directive != xyes; then
3972 echo "*** This target requires an assembler supporting \".machine\"" >&2
3973 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3974 test x$build = x$target && exit 1
3978 *) conftest_s=' .machine power4
3983 gcc_GAS_CHECK_FEATURE([mfcr field support],
3984 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3986 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3987 [Define if your assembler supports mfcr field.])])
3990 *-*-aix*) conftest_s=' .machine "pwr5"
3993 *) conftest_s=' .machine power5
3998 gcc_GAS_CHECK_FEATURE([popcntb support],
3999 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4001 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4002 [Define if your assembler supports popcntb field.])])
4005 *-*-aix*) conftest_s=' .machine "pwr5x"
4008 *) conftest_s=' .machine power5
4013 gcc_GAS_CHECK_FEATURE([fp round support],
4014 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4016 [AC_DEFINE(HAVE_AS_FPRND, 1,
4017 [Define if your assembler supports fprnd.])])
4020 *-*-aix*) conftest_s=' .machine "pwr6"
4023 *) conftest_s=' .machine power6
4028 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4029 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4031 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4032 [Define if your assembler supports mffgpr and mftgpr.])])
4035 *-*-aix*) conftest_s=' .csect .text[[PR]]
4037 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4041 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4042 *) conftest_s=' .text
4044 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4047 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4048 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4050 [AC_DEFINE(HAVE_AS_REL16, 1,
4051 [Define if your assembler supports R_PPC_REL16 relocs.])])
4054 *-*-aix*) conftest_s=' .machine "pwr6"
4057 *) conftest_s=' .machine power6
4062 gcc_GAS_CHECK_FEATURE([compare bytes support],
4063 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4065 [AC_DEFINE(HAVE_AS_CMPB, 1,
4066 [Define if your assembler supports cmpb.])])
4069 *-*-aix*) conftest_s=' .machine "pwr6"
4072 *) conftest_s=' .machine power6
4077 gcc_GAS_CHECK_FEATURE([decimal float support],
4078 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4080 [AC_DEFINE(HAVE_AS_DFP, 1,
4081 [Define if your assembler supports DFP instructions.])])
4084 *-*-aix*) conftest_s=' .machine "pwr7"
4087 *) conftest_s=' .machine power7
4092 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4093 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4095 [AC_DEFINE(HAVE_AS_VSX, 1,
4096 [Define if your assembler supports VSX instructions.])])
4099 *-*-aix*) conftest_s=' .machine "pwr7"
4102 *) conftest_s=' .machine power7
4107 gcc_GAS_CHECK_FEATURE([popcntd support],
4108 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4110 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4111 [Define if your assembler supports POPCNTD instructions.])])
4114 *-*-aix*) conftest_s=' .machine "pwr8"
4115 .csect .text[[PR]]';;
4116 *) conftest_s=' .machine power8
4120 gcc_GAS_CHECK_FEATURE([power8 support],
4121 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4123 [AC_DEFINE(HAVE_AS_POWER8, 1,
4124 [Define if your assembler supports POWER8 instructions.])])
4127 *-*-aix*) conftest_s=' .csect .text[[PR]]
4129 *) conftest_s=' .text
4133 gcc_GAS_CHECK_FEATURE([lwsync support],
4134 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4136 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4137 [Define if your assembler supports LWSYNC instructions.])])
4140 *-*-aix*) conftest_s=' .machine "476"
4143 *) conftest_s=' .machine "476"
4148 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4149 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4151 [AC_DEFINE(HAVE_AS_DCI, 1,
4152 [Define if your assembler supports the DCI/ICI instructions.])])
4154 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4155 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4156 [.gnu_attribute 4,1],,
4157 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4158 [Define if your assembler supports .gnu_attribute.])])
4160 gcc_GAS_CHECK_FEATURE([tls marker support],
4161 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4162 [ bl __tls_get_addr(x@tlsgd)],,
4163 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4164 [Define if your assembler supports arg info for __tls_get_addr.])])
4168 gcc_GAS_CHECK_FEATURE([.ref support],
4169 gcc_cv_as_aix_ref, [2,21,0],,
4170 [ .csect stuff[[rw]]
4176 [AC_DEFINE(HAVE_AS_REF, 1,
4177 [Define if your assembler supports .ref])])
4183 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4184 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4185 [ lw $4,%gp_rel(foo)($4)],,
4186 [if test x$target_cpu_default = x
4187 then target_cpu_default=MASK_EXPLICIT_RELOCS
4188 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4190 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4191 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4192 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4193 [Define if the assembler understands -mno-shared.])])
4195 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4196 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4197 [.gnu_attribute 4,1],,
4198 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4199 [Define if your assembler supports .gnu_attribute.])])
4201 gcc_GAS_CHECK_FEATURE([.micromips support],
4202 gcc_cv_as_micromips_support,,[--fatal-warnings],
4204 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4205 [Define if your assembler supports the .set micromips directive])])
4207 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4208 gcc_cv_as_mips_dtprelword, [2,18,0],,
4209 [.section .tdata,"awT",@progbits
4213 .dtprelword x+0x8000],,
4214 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4215 [Define if your assembler supports .dtprelword.])])
4217 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4218 gcc_cv_as_mips_dspr1_mult,,,
4228 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4229 [Define if your assembler supports DSPR1 mult.])])
4231 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4232 gcc_cv_as_ld_jalr_reloc=no
4233 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4234 if test $in_tree_ld = yes ; then
4235 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 \
4236 && test $in_tree_ld_is_elf = yes; then
4237 gcc_cv_as_ld_jalr_reloc=yes
4239 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4240 echo ' .ent x' > conftest.s
4241 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4242 echo ' lw $25,%call16(y)($28)' >> conftest.s
4243 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4244 echo '1: jalr $25' >> conftest.s
4245 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4246 echo '1: jalr $25' >> conftest.s
4247 echo ' .end x' >> conftest.s
4248 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4249 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4250 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4251 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4252 gcc_cv_as_ld_jalr_reloc=yes
4258 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4259 if test x$target_cpu_default = x; then
4260 target_cpu_default=MASK_RELAX_PIC_CALLS
4262 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4265 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4267 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4268 [gcc_cv_ld_mips_personality_relaxation],
4269 [gcc_cv_ld_mips_personality_relaxation=no
4270 if test $in_tree_ld = yes ; then
4271 if test "$gcc_cv_gld_major_version" -eq 2 \
4272 -a "$gcc_cv_gld_minor_version" -ge 21 \
4273 -o "$gcc_cv_gld_major_version" -gt 2; then
4274 gcc_cv_ld_mips_personality_relaxation=yes
4276 elif test x$gcc_cv_as != x \
4277 -a x$gcc_cv_ld != x \
4278 -a x$gcc_cv_readelf != x ; then
4279 cat > conftest.s <<EOF
4281 .cfi_personality 0x80,indirect_ptr
4288 .section .data,"aw",@progbits
4292 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4293 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4294 if $gcc_cv_readelf -d conftest 2>&1 \
4295 | grep TEXTREL > /dev/null 2>&1; then
4297 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4298 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4301 gcc_cv_ld_mips_personality_relaxation=yes
4305 rm -f conftest.s conftest.o conftest])
4306 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4307 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4308 [Define if your linker can relax absolute .eh_frame personality
4309 pointers into PC-relative form.])
4312 gcc_GAS_CHECK_FEATURE([-mnan= support],
4313 gcc_cv_as_mips_nan,,
4315 [AC_DEFINE(HAVE_AS_NAN, 1,
4316 [Define if the assembler understands -mnan=.])])
4317 if test x$gcc_cv_as_mips_nan = xno \
4318 && test x$with_nan != x; then
4320 [Requesting --with-nan= requires assembler support for -mnan=])
4325 # Mips and HP-UX need the GNU assembler.
4326 # Linux on IA64 might be able to use the Intel assembler.
4329 mips*-*-* | *-*-hpux* )
4330 if test x$gas_flag = xyes \
4331 || test x"$host" != x"$build" \
4332 || test ! -x "$gcc_cv_as" \
4333 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4336 echo "*** This configuration requires the GNU assembler" >&2
4342 # ??? Not all targets support dwarf2 debug_line, even within a version
4343 # of gas. Moreover, we need to emit a valid instruction to trigger any
4344 # info to the output file. So, as supported targets are added to gas 2.11,
4345 # add some instruction here to (also) show we expect this might work.
4346 # ??? Once 2.11 is released, probably need to add first known working
4347 # version to the per-target configury.
4349 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4350 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4351 | xstormy16 | xtensa)
4361 if test x"$insn" != x; then
4363 .file 1 \"conftest.s\"
4366 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4367 gcc_cv_as_dwarf2_debug_line,
4368 [elf,2,11,0],, [$conftest_s],
4369 [if test x$gcc_cv_objdump != x \
4370 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4371 | grep debug_line > /dev/null 2>&1; then
4372 gcc_cv_as_dwarf2_debug_line=yes
4375 # The .debug_line file table must be in the exact order that
4376 # we specified the files, since these indices are also used
4377 # by DW_AT_decl_file. Approximate this test by testing if
4378 # the assembler bitches if the same index is assigned twice.
4379 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4380 gcc_cv_as_dwarf2_file_buggy,,,
4384 if test $gcc_cv_as_dwarf2_debug_line = yes \
4385 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4386 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4387 [Define if your assembler supports dwarf2 .file/.loc directives,
4388 and preserves file table indices exactly as given.])
4391 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4392 gcc_cv_as_gdwarf2_flag,
4393 [elf,2,11,0], [--gdwarf2], [$insn],,
4394 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4395 [Define if your assembler supports the --gdwarf2 option.])])
4397 gcc_GAS_CHECK_FEATURE([--gstabs option],
4398 gcc_cv_as_gstabs_flag,
4399 [elf,2,11,0], [--gstabs], [$insn],,
4400 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4401 [Define if your assembler supports the --gstabs option.])])
4403 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4404 gcc_cv_as_debug_prefix_map_flag,
4405 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4406 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4407 [Define if your assembler supports the --debug-prefix-map option.])])
4410 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4411 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4412 [# gas compiled without zlib cannot compress debug sections and warns
4413 # about it, but still exits successfully. So check for this, too.
4414 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4416 gcc_cv_as_compress_debug=0
4417 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4419 gcc_cv_as_compress_debug=1
4420 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4421 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4423 gcc_cv_as_compress_debug=0
4424 # FIXME: Future gas versions will support ELF gABI style via
4425 # --compress-debug-sections[=type].
4427 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4428 [Define to the level of your assembler's compressed debug section support.])
4429 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4430 [Define to the assembler option to enable compressed debug sections.])
4431 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4432 [Define to the assembler option to disable compressed debug sections.])
4434 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4437 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4438 [Define if your assembler supports .lcomm with an alignment field.])])
4440 if test x$with_sysroot = x && test x$host = x$target \
4441 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4442 && test "$prefix" != "NONE"; then
4443 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4444 [Define to PREFIX/include if cpp should also search that directory.])
4447 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4448 if test "x$with_headers" != x; then
4449 target_header_dir=$with_headers
4450 elif test "x$with_sysroot" = x; then
4451 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4452 elif test "x$with_build_sysroot" != "x"; then
4453 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4454 elif test "x$with_sysroot" = xyes; then
4455 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4457 target_header_dir="${with_sysroot}${native_system_header_dir}"
4460 target_header_dir=${native_system_header_dir}
4463 # Determine the version of glibc, if any, used on the target.
4464 AC_MSG_CHECKING([for target glibc version])
4465 AC_ARG_WITH([glibc-version],
4466 [AS_HELP_STRING([--with-glibc-version=M.N],
4467 [assume GCC used with glibc version M.N or later])], [
4468 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4469 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4470 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4472 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4474 glibc_version_major=0
4475 glibc_version_minor=0
4476 [if test -f $target_header_dir/features.h \
4477 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4478 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4479 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4480 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4482 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4484 AC_ARG_ENABLE(gnu-unique-object,
4485 [AS_HELP_STRING([--enable-gnu-unique-object],
4486 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4487 [case $enable_gnu_unique_object in
4489 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4490 Valid choices are 'yes' and 'no'.]) ;;
4492 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4494 [.type foo, '$target_type_format_char'gnu_unique_object],,
4495 # We need to unquote above to to use the definition from config.gcc.
4496 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4497 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4499 if test x$enable_gnu_unique_object = xyes; then
4500 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4501 [Define if your assembler supports @gnu_unique_object.])
4504 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4505 [gcc_cv_as_line_zero],
4506 [gcc_cv_as_line_zero=no
4507 if test $in_tree_gas = yes; then
4508 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4509 elif test "x$gcc_cv_as" != x; then
4510 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4511 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4512 test "x`cat conftest.out`" = x
4514 gcc_cv_as_line_zero=yes
4516 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4517 cat conftest.s >&AS_MESSAGE_LOG_FD
4518 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4519 cat conftest.out >&AS_MESSAGE_LOG_FD
4521 rm -f conftest.o conftest.s conftest.out
4523 if test "x$gcc_cv_as_line_zero" = xyes; then
4524 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4525 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4528 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4529 gcc_cv_ld_eh_frame_hdr=no
4530 if test $in_tree_ld = yes ; then
4531 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 \
4532 && test $in_tree_ld_is_elf = yes; then
4533 gcc_cv_ld_eh_frame_hdr=yes
4535 elif test x$gcc_cv_ld != x; then
4536 if echo "$ld_ver" | grep GNU > /dev/null; then
4537 # Check if linker supports --eh-frame-hdr option
4538 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4539 gcc_cv_ld_eh_frame_hdr=yes
4544 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4545 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4546 gcc_cv_ld_eh_frame_hdr=yes
4552 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4553 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4554 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4555 [Define if your linker supports .eh_frame_hdr.])
4557 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4559 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4560 gcc_cv_ld_eh_frame_ciev3=no
4561 if test $in_tree_ld = yes ; then
4562 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 \
4563 && test $in_tree_ld_is_elf = yes; then
4564 gcc_cv_ld_eh_frame_ciev3=yes
4566 elif test x$gcc_cv_ld != x; then
4567 if echo "$ld_ver" | grep GNU > /dev/null; then
4568 gcc_cv_ld_eh_frame_ciev3=yes
4569 if test 0"$ld_date" -lt 20040513; then
4570 if test -n "$ld_date"; then
4571 # If there was date string, but was earlier than 2004-05-13, fail
4572 gcc_cv_ld_eh_frame_ciev3=no
4573 elif test "$ld_vers_major" -lt 2; then
4574 gcc_cv_ld_eh_frame_ciev3=no
4575 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4576 gcc_cv_ld_eh_frame_ciev3=no
4582 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4583 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4584 gcc_cv_ld_eh_frame_ciev3=yes
4590 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4591 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4592 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4593 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4595 AC_MSG_CHECKING(linker position independent executable support)
4597 if test $in_tree_ld = yes ; then
4598 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 \
4599 && test $in_tree_ld_is_elf = yes; then
4602 elif test x$gcc_cv_ld != x; then
4603 # Check if linker supports -pie option
4604 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4608 if test x"$gcc_cv_ld_pie" = xyes; then
4609 AC_DEFINE(HAVE_LD_PIE, 1,
4610 [Define if your linker supports -pie option.])
4612 AC_MSG_RESULT($gcc_cv_ld_pie)
4614 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4615 gcc_cv_ld_eh_gc_sections=no
4616 if test $in_tree_ld = yes ; then
4617 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 \
4618 && test $in_tree_ld_is_elf = yes; then
4619 gcc_cv_ld_eh_gc_sections=yes
4621 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4622 cat > conftest.s <<EOF
4625 .type _start, @function
4628 .size _start, .-_start
4629 .section .text.foo,"ax",@progbits
4630 .type foo, @function
4634 .section .gcc_except_table.foo,"a",@progbits
4637 .section .eh_frame,"a",@progbits
4640 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4641 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4642 | grep "gc-sections option ignored" > /dev/null; then
4643 gcc_cv_ld_eh_gc_sections=no
4644 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4645 | grep gcc_except_table > /dev/null; then
4646 gcc_cv_ld_eh_gc_sections=yes
4647 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4648 if test x$gcc_cv_as_comdat_group != xyes; then
4649 gcc_cv_ld_eh_gc_sections=no
4650 cat > conftest.s <<EOF
4653 .type _start, @function
4656 .size _start, .-_start
4657 .section .gnu.linkonce.t.foo,"ax",@progbits
4658 .type foo, @function
4662 .section .gcc_except_table.foo,"a",@progbits
4665 .section .eh_frame,"a",@progbits
4668 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4669 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4670 | grep "gc-sections option ignored" > /dev/null; then
4671 gcc_cv_ld_eh_gc_sections=no
4672 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4673 | grep gcc_except_table > /dev/null; then
4674 gcc_cv_ld_eh_gc_sections=yes
4680 rm -f conftest.s conftest.o conftest
4684 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4685 gcc_cv_ld_eh_gc_sections=no
4688 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4689 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4690 [Define if your linker supports garbage collection of
4691 sections in presence of EH frames.])
4693 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4695 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4696 gcc_cv_ld_eh_gc_sections_bug=no
4697 if test $in_tree_ld = yes ; then
4698 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 \
4699 && test $in_tree_ld_is_elf = yes; then
4700 gcc_cv_ld_eh_gc_sections_bug=yes
4702 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
4703 gcc_cv_ld_eh_gc_sections_bug=yes
4704 cat > conftest.s <<EOF
4707 .type _start, @function
4710 .size _start, .-_start
4711 .section .text.startup.foo,"ax",@progbits
4712 .type foo, @function
4716 .section .gcc_except_table.foo,"a",@progbits
4719 .section .eh_frame,"a",@progbits
4722 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4723 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4724 | grep "gc-sections option ignored" > /dev/null; then
4726 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4727 | grep gcc_except_table > /dev/null; then
4728 gcc_cv_ld_eh_gc_sections_bug=no
4731 rm -f conftest.s conftest.o conftest
4733 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4734 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4735 [Define if your linker has buggy garbage collection of
4736 sections support when .text.startup.foo like sections are used.])
4738 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4740 AC_MSG_CHECKING(linker for compressed debug sections)
4741 # gold/gld support compressed debug sections since binutils 2.19/2.21
4742 if test $in_tree_ld = yes ; then
4743 gcc_cv_ld_compress_debug=0
4744 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 \
4745 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
4746 gcc_cv_ld_compress_debug=2
4747 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4748 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 \
4749 && test $in_tree_ld_is_elf = yes; then
4750 gcc_cv_ld_compress_debug=1
4752 elif echo "$ld_ver" | grep GNU > /dev/null; then
4753 gcc_cv_ld_compress_debug=1
4754 if test 0"$ld_date" -lt 20050308; then
4755 if test -n "$ld_date"; then
4756 # If there was date string, but was earlier than 2005-03-08, fail
4757 gcc_cv_ld_compress_debug=0
4758 elif test "$ld_vers_major" -lt 2; then
4759 gcc_cv_ld_compress_debug=0
4760 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
4761 gcc_cv_ld_compress_debug=0
4764 if test $ld_is_gold = yes; then
4765 gcc_cv_ld_compress_debug=2
4766 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4772 # Introduced in Solaris 11.2.
4773 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
4774 gcc_cv_ld_compress_debug=3
4775 gcc_cv_ld_compress_debug_option="-z compress-sections"
4777 gcc_cv_ld_compress_debug=0
4781 # Assume linkers other than GNU ld don't support compessed debug
4783 gcc_cv_ld_compress_debug=0
4788 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
4789 [Define to the level of your linker's compressed debug section support.])
4790 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
4791 [Define to the linker option to enable compressed debug sections.])
4792 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
4798 AC_CACHE_CHECK(linker --as-needed support,
4799 gcc_cv_ld_as_needed,
4800 [gcc_cv_ld_as_needed=no
4801 gcc_cv_ld_as_needed_option='--as-needed'
4802 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4803 if test $in_tree_ld = yes ; then
4804 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 \
4805 && test $in_tree_ld_is_elf = yes; then
4806 gcc_cv_ld_as_needed=yes
4808 elif test x$gcc_cv_ld != x; then
4809 # Check if linker supports --as-needed and --no-as-needed options
4810 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4811 gcc_cv_ld_as_needed=yes
4814 # Solaris 2 ld always supports -z ignore/-z record.
4816 gcc_cv_ld_as_needed=yes
4817 gcc_cv_ld_as_needed_option="-z ignore"
4818 gcc_cv_ld_no_as_needed_option="-z record"
4823 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4824 # dl_iterate_phdr, i.e. since Solaris 11.
4826 *-*-solaris2.1[[1-9]]*)
4828 i?86-*-* | x86_64-*-*)
4829 if echo "$ld_ver" | grep GNU > /dev/null; then
4830 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4831 gcc_cv_ld_as_needed=no
4837 gcc_cv_ld_as_needed=no
4841 if test x"$gcc_cv_ld_as_needed" = xyes; then
4842 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4843 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4844 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4845 [Define to the linker option to ignore unused dependencies.])
4846 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4847 [Define to the linker option to keep unused dependencies.])
4850 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4851 saved_LDFLAGS="$LDFLAGS"
4852 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4853 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4854 AC_LINK_IFELSE([int main(void) {return 0;}],
4855 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4857 LDFLAGS="$saved_LDFLAGS"
4858 if test "x$gcc_cv_ld_clearcap" = xyes; then
4859 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4860 [Define if the linker supports clearing hardware capabilities via mapfile.])
4861 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4863 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4865 case "$target:$tm_file" in
4866 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4869 emul_name="-melf64lppc"
4872 emul_name="-melf64ppc"
4875 emul_name="-melf64ppc_fbsd"
4878 AC_CACHE_CHECK(linker support for omitting dot symbols,
4879 gcc_cv_ld_no_dot_syms,
4880 [gcc_cv_ld_no_dot_syms=no
4881 if test x"$ld_is_gold" = xyes; then
4882 gcc_cv_ld_no_dot_syms=yes
4883 elif test $in_tree_ld = yes ; then
4884 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
4885 gcc_cv_ld_no_dot_syms=yes
4887 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4888 cat > conftest1.s <<EOF
4892 cat > conftest2.s <<EOF
4893 .section ".opd","aw"
4898 .quad .LEfoo,.TOC.@tocbase,0
4904 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4905 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4906 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4907 gcc_cv_ld_no_dot_syms=yes
4909 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4912 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4913 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4914 [Define if your PowerPC64 linker only needs function descriptor syms.])
4917 AC_CACHE_CHECK(linker large toc support,
4918 gcc_cv_ld_large_toc,
4919 [gcc_cv_ld_large_toc=no
4920 if test x"$ld_is_gold" = xyes; then
4921 gcc_cv_ld_large_toc=yes
4922 elif test $in_tree_ld = yes ; then
4923 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
4924 gcc_cv_ld_large_toc=yes
4926 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4927 cat > conftest.s <<EOF
4928 .section ".tbss","awT",@nobits
4934 addis 9,13,ie0@got@tprel@ha
4935 ld 9,ie0@got@tprel@l(9)
4937 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4938 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4939 gcc_cv_ld_large_toc=yes
4941 rm -f conftest conftest.o conftest.s
4944 if test x"$gcc_cv_ld_large_toc" = xyes; then
4945 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4946 [Define if your PowerPC64 linker supports a large TOC.])
4953 AC_CACHE_CHECK(linker large toc support,
4954 gcc_cv_ld_large_toc,
4955 [gcc_cv_ld_large_toc=no
4956 if test x$gcc_cv_as != x ; then
4957 cat > conftest.s <<EOF
4967 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4968 gcc_cv_ld_large_toc=yes
4970 rm -f conftest conftest.o conftest.s
4973 if test x"$gcc_cv_ld_large_toc" = xyes; then
4974 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4975 [Define if your PowerPC64 linker supports a large TOC.])
4980 AC_CACHE_CHECK(linker --build-id support,
4982 [gcc_cv_ld_buildid=no
4983 if test $in_tree_ld = yes ; then
4984 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4985 "$gcc_cv_gld_minor_version" -ge 18 -o \
4986 "$gcc_cv_gld_major_version" -gt 2 \
4987 && test $in_tree_ld_is_elf = yes; then
4988 gcc_cv_ld_buildid=yes
4990 elif test x$gcc_cv_ld != x; then
4991 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4992 gcc_cv_ld_buildid=yes
4995 if test x"$gcc_cv_ld_buildid" = xyes; then
4996 AC_DEFINE(HAVE_LD_BUILDID, 1,
4997 [Define if your linker supports --build-id.])
5000 AC_ARG_ENABLE(linker-build-id,
5001 [AS_HELP_STRING([--enable-linker-build-id],
5002 [compiler will always pass --build-id to linker])],
5004 enable_linker_build_id=no)
5006 if test x"$enable_linker_build_id" = xyes; then
5007 if test x"$gcc_cv_ld_buildid" = xyes; then
5008 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5009 [Define if gcc should always pass --build-id to linker.])
5011 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5015 # In binutils 2.21, GNU ld gained support for new emulations fully
5016 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5017 AC_CACHE_CHECK(linker *_sol2 emulation support,
5018 gcc_cv_ld_sol2_emulation,
5019 [gcc_cv_ld_sol2_emulation=no
5020 if test $in_tree_ld = yes ; then
5021 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5022 "$gcc_cv_gld_minor_version" -ge 21 -o \
5023 "$gcc_cv_gld_major_version" -gt 2 \
5024 && test $in_tree_ld_is_elf = yes; then
5025 gcc_cv_ld_sol2_emulation=yes
5027 elif test x$gcc_cv_ld != x; then
5028 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5029 grep _sol2 > /dev/null; then
5030 gcc_cv_ld_sol2_emulation=yes
5033 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5034 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5035 [Define if your linker supports the *_sol2 emulations.])
5038 AC_CACHE_CHECK(linker --sysroot support,
5040 [gcc_cv_ld_sysroot=no
5041 if 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_sysroot=yes
5045 elif test x$gcc_cv_ld != x; then
5046 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5047 gcc_cv_ld_sysroot=yes
5050 if test x"$gcc_cv_ld_sysroot" = xyes; then
5051 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5052 [Define if your linker supports --sysroot.])
5055 # Test for stack protector support in target C library.
5056 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5057 gcc_cv_libc_provides_ssp,
5058 [gcc_cv_libc_provides_ssp=no
5060 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5061 # glibc 2.4 and later provides __stack_chk_fail and
5062 # either __stack_chk_guard, or TLS access to stack guard canary.
5063 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5064 [if test -f $target_header_dir/features.h \
5065 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5066 $target_header_dir/features.h > /dev/null; then
5067 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5068 $target_header_dir/features.h > /dev/null && \
5069 test -f $target_header_dir/bits/uClibc_config.h && \
5070 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5071 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5072 gcc_cv_libc_provides_ssp=yes
5074 # all versions of Bionic support stack protector
5075 elif test -f $target_header_dir/sys/cdefs.h \
5076 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5077 $target_header_dir/sys/cdefs.h > /dev/null; then
5078 gcc_cv_libc_provides_ssp=yes
5082 # Avoid complicated tests (see
5083 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5084 # simply assert that glibc does provide this, which is true for all
5085 # realistically usable GNU/Hurd configurations.
5086 gcc_cv_libc_provides_ssp=yes;;
5087 *-*-darwin* | *-*-freebsd*)
5088 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5089 [echo "no __stack_chk_fail on this target"])
5091 *) gcc_cv_libc_provides_ssp=no ;;
5094 if test x$gcc_cv_libc_provides_ssp = xyes; then
5095 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5096 [Define if your target C library provides stack protector support])
5099 # Test for <sys/sdt.h> on the target.
5100 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5101 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5103 if test -f $target_header_dir/sys/sdt.h; then
5105 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5106 [Define if your target C library provides sys/sdt.h])
5108 AC_MSG_RESULT($have_sys_sdt_h)
5110 # Check if TFmode long double should be used by default or not.
5111 # Some glibc targets used DFmode long double, but with glibc 2.4
5112 # and later they can use TFmode.
5114 powerpc*-*-linux* | \
5118 AC_ARG_WITH(long-double-128,
5119 [AS_HELP_STRING([--with-long-double-128],
5120 [use 128-bit long double by default])],
5121 gcc_cv_target_ldbl128="$with_long_double_128",
5122 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5123 [gcc_cv_target_ldbl128=no
5124 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5125 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5126 && gcc_cv_target_ldbl128=yes
5130 if test x$gcc_cv_target_ldbl128 = xyes; then
5131 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5132 [Define if TFmode long double should be the default])
5135 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5136 gcc_cv_target_dl_iterate_phdr=unknown
5138 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5139 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5140 # libdl there, both complicating its use and breaking compatibility
5141 # between Solaris 10 updates.
5142 *-*-solaris2.1[[1-9]]*)
5143 # <link.h> needs both a dl_iterate_phdr declaration and support for
5144 # compilation with largefile support.
5145 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5146 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5147 gcc_cv_target_dl_iterate_phdr=yes
5149 gcc_cv_target_dl_iterate_phdr=no
5152 *-*-dragonfly* | *-*-freebsd*)
5153 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5154 gcc_cv_target_dl_iterate_phdr=yes
5156 gcc_cv_target_dl_iterate_phdr=no
5160 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5161 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5162 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5163 [Define if your target C library provides the `dl_iterate_phdr' function.])
5165 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5167 # We no longer support different GC mechanisms. Emit an error if
5168 # the user configures with --with-gc.
5170 [AS_HELP_STRING([--with-gc={page,zone}],
5171 [this option is not supported anymore. It used to choose
5172 the garbage collection mechanism to use with the compiler])],
5173 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5176 # Libraries to use on the host. This will normally be set by the top
5177 # level Makefile. Here we simply capture the value for our Makefile.
5178 if test -z "${HOST_LIBS+set}"; then
5183 # Use the system's zlib library.
5185 zlibinc="-I\$(srcdir)/../zlib"
5186 AC_ARG_WITH(system-zlib,
5187 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5194 dnl Very limited version of automake's enable-maintainer-mode
5196 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5197 dnl maintainer-mode is disabled by default
5198 AC_ARG_ENABLE(maintainer-mode,
5199 [AS_HELP_STRING([--enable-maintainer-mode],
5200 [enable make rules and dependencies not useful
5201 (and sometimes confusing) to the casual installer])],
5202 maintainer_mode=$enableval,
5205 AC_MSG_RESULT($maintainer_mode)
5207 if test "$maintainer_mode" = "yes"; then
5214 dnl Whether to prevent multiple front-ends from linking at the same time
5216 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5217 AC_ARG_ENABLE(link-mutex,
5218 [AS_HELP_STRING([--enable-link-mutex],
5219 [avoid linking multiple front-ends at once to avoid thrashing
5220 on the build machine])],
5221 do_link_mutex=$enableval,
5223 AC_MSG_RESULT($do_link_mutex)
5225 if test "$do_link_mutex" = "yes"; then
5230 AC_SUBST(DO_LINK_MUTEX)
5236 # Make empty files to contain the specs and options for each language.
5237 # Then add #include lines to for a compiler that has specs and/or options.
5243 # These (without "all_") are set in each config-lang.in.
5244 # `language' must be a single word so is spelled singularly.
5247 all_outputs='Makefile'
5248 # List of language makefile fragments.
5250 # Additional files for gengtype
5251 all_gtfiles="$target_gtfiles"
5253 # These are the languages that are set in --enable-languages,
5254 # and are available in the GCC tree.
5255 all_selected_languages=
5257 # Add the language fragments.
5258 # Languages are added via two mechanisms. Some information must be
5259 # recorded in makefile variables, these are defined in config-lang.in.
5260 # We accumulate them and plug them into the main Makefile.
5261 # The other mechanism is a set of hooks for each of the main targets
5262 # like `clean', `install', etc.
5264 language_hooks="Make-hooks"
5266 for lang in ${srcdir}/*/config-lang.in
5269 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5271 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5272 if test "x$lang_alias" = x
5274 echo "$lang doesn't set \$language." 1>&2
5277 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5278 subdirs="$subdirs $subdir"
5280 # $gcc_subdir is where the gcc integration files are to be found
5281 # for a language, both for internal compiler purposes (compiler
5282 # sources implementing front-end to GCC tree converters), and for
5283 # build infrastructure purposes (Make-lang.in, etc.)
5285 # This will be <subdir> (relative to $srcdir) if a line like
5286 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5287 # is found in <langdir>/config-lang.in, and will remain <langdir>
5290 # Except for the language alias (fetched above), the regular
5291 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5292 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5293 # only this and the language alias.
5295 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5296 if [ "$gcc_subdir" = "" ]; then
5297 gcc_subdir="$subdir"
5300 case ",$enable_languages," in
5302 all_selected_languages="$all_selected_languages $lang_alias"
5303 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5304 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5316 . ${srcdir}/$gcc_subdir/config-lang.in
5317 if test "x$language" = x
5319 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5324 case ",$enable_languages," in
5327 for i in $subdir_requires; do
5328 test -f "${srcdir}/$i/config-lang.in" && continue
5336 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5337 if test -f $srcdir/$gcc_subdir/lang.opt; then
5338 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5339 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5341 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5342 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5344 all_languages="$all_languages $language"
5345 all_compilers="$all_compilers $compilers"
5346 all_outputs="$all_outputs $outputs"
5347 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5348 case ",$enable_languages," in
5350 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5352 AC_SUBST(enable_lto)
5359 for language in $all_selected_languages
5361 check_languages="$check_languages check-$language"
5364 # We link each language in with a set of hooks, reached indirectly via
5365 # lang.${target}. Only do so for selected languages.
5369 target_list="all.cross start.encap rest.encap tags \
5370 install-common install-man install-info install-pdf install-html dvi \
5371 pdf html uninstall info man srcextra srcman srcinfo \
5372 mostlyclean clean distclean maintainer-clean install-plugin"
5374 for t in $target_list
5377 for lang in $all_selected_languages
5381 echo "lang.$t: $x" >> Make-hooks
5385 # Option include files
5388 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5389 option_includes="option-includes.mk"
5390 AC_SUBST_FILE(option_includes)
5398 echo "dir ." > .gdbinit
5399 echo "dir ${srcdir}" >> .gdbinit
5400 if test x$gdb_needs_out_file_path = xyes
5402 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5404 if test "x$subdirs" != x; then
5407 echo "dir ${srcdir}/$s" >> .gdbinit
5410 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5411 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5413 # Put a breakpoint on __asan_report_error to help with debugging buffer
5416 *-fsanitize=address*)
5417 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5421 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5422 AC_SUBST(gcc_tooldir)
5425 # Find a directory in which to install a shared libgcc.
5427 AC_ARG_ENABLE(version-specific-runtime-libs,
5428 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5429 [specify that runtime libraries should be
5430 installed in a compiler-specific directory])])
5432 # Substitute configuration variables
5435 AC_SUBST(all_compilers)
5436 AC_SUBST(all_gtfiles)
5437 AC_SUBST(all_lang_makefrags)
5438 AC_SUBST(all_languages)
5439 AC_SUBST(all_selected_languages)
5440 AC_SUBST(build_exeext)
5441 AC_SUBST(build_install_headers_dir)
5442 AC_SUBST(build_xm_file_list)
5443 AC_SUBST(build_xm_include_list)
5444 AC_SUBST(build_xm_defines)
5445 AC_SUBST(build_file_translate)
5446 AC_SUBST(check_languages)
5447 AC_SUBST(cpp_install_dir)
5448 AC_SUBST(xmake_file)
5449 AC_SUBST(tmake_file)
5450 AC_SUBST(TM_ENDIAN_CONFIG)
5451 AC_SUBST(TM_MULTILIB_CONFIG)
5452 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5453 AC_SUBST(extra_gcc_objs)
5454 AC_SUBST(user_headers_inc_next_pre)
5455 AC_SUBST(user_headers_inc_next_post)
5456 AC_SUBST(extra_headers_list)
5457 AC_SUBST(extra_objs)
5458 AC_SUBST(extra_programs)
5459 AC_SUBST(float_h_file)
5460 AC_SUBST(gcc_config_arguments)
5461 AC_SUBST(gcc_gxx_include_dir)
5462 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5463 AC_SUBST(host_exeext)
5464 AC_SUBST(host_xm_file_list)
5465 AC_SUBST(host_xm_include_list)
5466 AC_SUBST(host_xm_defines)
5467 AC_SUBST(out_host_hook_obj)
5469 AC_SUBST(lang_opt_files)
5470 AC_SUBST(lang_specs_files)
5471 AC_SUBST(lang_tree_files)
5472 AC_SUBST(local_prefix)
5474 AC_SUBST(objc_boehm_gc)
5476 AC_SUBST(out_object_file)
5477 AC_SUBST(common_out_file)
5478 AC_SUBST(common_out_object_file)
5479 AC_SUBST(tm_file_list)
5480 AC_SUBST(tm_include_list)
5481 AC_SUBST(tm_defines)
5482 AC_SUBST(tm_p_file_list)
5483 AC_SUBST(tm_p_include_list)
5484 AC_SUBST(xm_file_list)
5485 AC_SUBST(xm_include_list)
5486 AC_SUBST(xm_defines)
5487 AC_SUBST(use_gcc_stdint)
5488 AC_SUBST(c_target_objs)
5489 AC_SUBST(cxx_target_objs)
5490 AC_SUBST(fortran_target_objs)
5491 AC_SUBST(target_cpu_default)
5493 AC_SUBST_FILE(language_hooks)
5496 if test x${build} = x${host} ; then
5497 if test x${host} = x${target} ; then
5498 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5500 echo "Links are now set up to build a cross-compiler" 1>&2
5501 echo " from ${host} to ${target}." 1>&2
5504 if test x${host} = x${target} ; then
5505 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5506 echo " for ${target}." 1>&2
5508 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5509 echo " from ${host} to ${target}." 1>&2
5513 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5514 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5516 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5517 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5518 if test "x${ISLLIBS}" != "x" ; then
5519 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5522 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5523 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5524 if test "x${CLOOGLIBS}" != "x" ; then
5525 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5528 # Check for plugin support
5529 AC_ARG_ENABLE(plugin,
5530 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5531 enable_plugin=$enableval,
5532 enable_plugin=yes; default_plugin=yes)
5538 if test x$build = x$host; then
5539 export_sym_check="nm${exeext} -g"
5540 elif test x$host = x$target; then
5541 export_sym_check="$gcc_cv_nm -g"
5547 if test x$build = x$host; then
5548 export_sym_check="objdump${exeext} -T"
5549 elif test x$host = x$target; then
5550 export_sym_check="$gcc_cv_objdump -T"
5557 if test x"$enable_plugin" = x"yes"; then
5559 AC_MSG_CHECKING([for exported symbols])
5560 if test "x$export_sym_check" != x; then
5561 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5562 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5563 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5564 : # No need to use a flag
5565 AC_MSG_RESULT([yes])
5567 AC_MSG_RESULT([yes])
5568 AC_MSG_CHECKING([for -rdynamic])
5569 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5570 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5572 pluginlibs="-rdynamic"
5577 AC_MSG_RESULT([$plugin_rdynamic])
5580 AC_MSG_RESULT([unable to check])
5585 AC_SEARCH_LIBS([dlopen], [dl])
5586 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5587 pluginlibs="$pluginlibs -ldl"
5591 # Check that we can build shared objects with -fPIC -shared
5592 saved_LDFLAGS="$LDFLAGS"
5593 saved_CFLAGS="$CFLAGS"
5596 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5597 CFLAGS="$CFLAGS -fPIC"
5598 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5601 CFLAGS="$CFLAGS -fPIC"
5602 LDFLAGS="$LDFLAGS -fPIC -shared"
5605 AC_MSG_CHECKING([for -fPIC -shared])
5607 [extern int X;],[return X == 0;],
5608 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5609 [AC_MSG_RESULT([no]); have_pic_shared=no])
5610 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5614 LDFLAGS="$saved_LDFLAGS"
5615 CFLAGS="$saved_CFLAGS"
5617 # If plugin support had been requested but not available, fail.
5618 if test x"$enable_plugin" = x"no" ; then
5619 if test x"$default_plugin" != x"yes"; then
5621 Building GCC with plugin support requires a host that supports
5622 -fPIC, -shared, -ldl and -rdynamic.])
5627 AC_SUBST(pluginlibs)
5628 AC_SUBST(enable_plugin)
5629 if test x"$enable_plugin" = x"yes"; then
5630 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5634 # Enable --enable-host-shared
5635 AC_ARG_ENABLE(host-shared,
5636 [AS_HELP_STRING([--enable-host-shared],
5637 [build host code as shared libraries])],
5638 [PICFLAG=-fPIC], [PICFLAG=])
5639 AC_SUBST(enable_host_shared)
5643 AC_ARG_ENABLE(libquadmath-support,
5644 [AS_HELP_STRING([--disable-libquadmath-support],
5645 [disable libquadmath support for Fortran])],
5646 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5647 ENABLE_LIBQUADMATH_SUPPORT=yes)
5648 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5649 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5650 [Define to 1 to enable libquadmath support])
5654 # Specify what hash style to use by default.
5655 AC_ARG_WITH([linker-hash-style],
5656 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5657 [specify the linker hash style])],
5658 [case x"$withval" in
5660 LINKER_HASH_STYLE=sysv
5663 LINKER_HASH_STYLE=gnu
5666 LINKER_HASH_STYLE=both
5669 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5672 [LINKER_HASH_STYLE=''])
5673 if test x"${LINKER_HASH_STYLE}" != x; then
5674 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5675 [The linker hash style])
5678 # Configure the subdirectories
5679 # AC_CONFIG_SUBDIRS($subdirs)
5681 # Create the Makefile
5682 # and configure language subdirectories
5683 AC_CONFIG_FILES($all_outputs)
5685 AC_CONFIG_COMMANDS([default],
5687 case ${CONFIG_HEADERS} in
5688 *auto-host.h:config.in*)
5691 # Make sure all the subdirs exist.
5692 for d in $subdirs doc build common c-family
5694 test -d $d || mkdir $d
5697 [subdirs='$subdirs'])