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
2099 AC_MSG_ERROR([invalid --enable-gold argument])
2102 [install_gold_as_default=no])
2104 # Identify the linker which will work hand-in-glove with the newly
2105 # built GCC, so that we can examine its features. This is the linker
2106 # which will be driven by the driver program.
2108 # If build != host, and we aren't building gas in-tree, we identify a
2109 # build->target linker and hope that it will have the same features
2110 # as the host->target linker we'll be using.
2111 gcc_cv_gld_major_version=
2112 gcc_cv_gld_minor_version=
2113 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2114 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2115 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2117 AS_VAR_SET_IF(gcc_cv_ld,, [
2118 if test -x "$DEFAULT_LINKER"; then
2119 gcc_cv_ld="$DEFAULT_LINKER"
2120 elif test $install_gold_as_default = yes \
2121 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2122 && test -f ../gold/Makefile \
2123 && test x$build = x$host; then
2124 gcc_cv_ld=../gold/ld-new$build_exeext
2125 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2126 && test -f ../ld/Makefile \
2127 && test x$build = x$host; then
2128 gcc_cv_ld=../ld/ld-new$build_exeext
2129 elif test -x collect-ld$build_exeext; then
2130 # Build using linker in the current directory.
2131 gcc_cv_ld=./collect-ld$build_exeext
2132 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2133 gcc_cv_ld="$LD_FOR_TARGET"
2135 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2138 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2139 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2140 # if the PLUGIN_LD is set ld-new, just have it as ld
2141 # as that is the installed named.
2142 if test x$PLUGIN_LD_SUFFIX = xld-new \
2143 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2146 AC_ARG_WITH(plugin-ld,
2147 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2148 [if test x"$withval" != x; then
2149 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2150 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2152 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2153 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2155 # Check to see if we are using gold instead of ld
2156 AC_MSG_CHECKING(whether we are using gold)
2158 if test x$gcc_cv_ld != x; then
2159 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2160 | grep "GNU gold" > /dev/null; then
2164 AC_MSG_RESULT($ld_is_gold)
2166 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2167 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2168 case "$ORIGINAL_LD_FOR_TARGET" in
2169 ./collect-ld | ./collect-ld$build_exeext) ;;
2170 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2173 AC_MSG_CHECKING(what linker to use)
2174 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2175 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2176 # Single tree build which includes ld. We want to prefer it
2177 # over whatever linker top-level may have detected, since
2178 # we'll use what we're building after installation anyway.
2179 AC_MSG_RESULT(newly built ld)
2181 in_tree_ld_is_elf=no
2182 if (grep 'EMUL = .*elf' ../ld/Makefile \
2183 || grep 'EMUL = .*linux' ../ld/Makefile \
2184 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2185 in_tree_ld_is_elf=yes
2186 elif test "$ld_is_gold" = yes; then
2187 in_tree_ld_is_elf=yes
2189 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
2192 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2193 if test x$gcc_cv_gld_version != x; then
2197 case $gcc_cv_gld_version in
2200 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2203 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2204 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2206 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2207 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2209 AC_MSG_RESULT($gcc_cv_ld)
2211 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2212 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2213 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2216 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2217 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2219 # Figure out what nm we will be using.
2220 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2221 AS_VAR_SET_IF(gcc_cv_nm,, [
2222 if test -f $gcc_cv_binutils_srcdir/configure.in \
2223 && test -f ../binutils/Makefile \
2224 && test x$build = x$host; then
2225 gcc_cv_nm=../binutils/nm-new$build_exeext
2226 elif test -x nm$build_exeext; then
2227 gcc_cv_nm=./nm$build_exeext
2228 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2229 gcc_cv_nm="$NM_FOR_TARGET"
2231 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2234 AC_MSG_CHECKING(what nm to use)
2235 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2236 # Single tree build which includes binutils.
2237 AC_MSG_RESULT(newly built nm)
2240 AC_MSG_RESULT($gcc_cv_nm)
2244 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2245 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2246 case "$ORIGINAL_NM_FOR_TARGET" in
2247 ./nm | ./nm$build_exeext) ;;
2248 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2252 # Figure out what objdump we will be using.
2253 AS_VAR_SET_IF(gcc_cv_objdump,, [
2254 if test -f $gcc_cv_binutils_srcdir/configure.in \
2255 && test -f ../binutils/Makefile \
2256 && test x$build = x$host; then
2257 # Single tree build which includes binutils.
2258 gcc_cv_objdump=../binutils/objdump$build_exeext
2259 elif test -x objdump$build_exeext; then
2260 gcc_cv_objdump=./objdump$build_exeext
2261 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2262 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2264 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2267 AC_MSG_CHECKING(what objdump to use)
2268 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2269 # Single tree build which includes binutils.
2270 AC_MSG_RESULT(newly built objdump)
2271 elif test x$gcc_cv_objdump = x; then
2272 AC_MSG_RESULT(not found)
2274 AC_MSG_RESULT($gcc_cv_objdump)
2277 # Figure out what readelf we will be using.
2278 AS_VAR_SET_IF(gcc_cv_readelf,, [
2279 if test -f $gcc_cv_binutils_srcdir/configure.in \
2280 && test -f ../binutils/Makefile \
2281 && test x$build = x$host; then
2282 # Single tree build which includes binutils.
2283 gcc_cv_readelf=../binutils/readelf$build_exeext
2284 elif test -x readelf$build_exeext; then
2285 gcc_cv_readelf=./readelf$build_exeext
2287 AC_PATH_PROG(gcc_cv_readelf, readelf)
2290 AC_MSG_CHECKING(what readelf to use)
2291 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2292 # Single tree build which includes binutils.
2293 AC_MSG_RESULT(newly built readelf)
2294 elif test x$gcc_cv_readelf = x; then
2295 AC_MSG_RESULT(not found)
2297 AC_MSG_RESULT($gcc_cv_readelf)
2300 # Figure out what assembler alignment features are present.
2301 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2305 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2306 [Define if your assembler supports .balign and .p2align.])])
2308 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2311 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2312 [Define if your assembler supports specifying the maximum number
2313 of bytes to skip when using the GAS .p2align command.])])
2315 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2318 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2319 [Define if your assembler supports .literal16.])])
2321 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2323 [conftest_label1: .word 0
2325 conftest_label2: .word 0
2327 [if test x$gcc_cv_nm != x; then
2328 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2329 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2330 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2332 else gcc_cv_as_subsection_m1=yes
2334 rm -f conftest.nm1 conftest.nm2
2336 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2337 [Define if your assembler supports .subsection and .subsection -1 starts
2338 emitting at the beginning of your section.])])
2340 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2343 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2345 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2347 [ .weakref foobar, barfnot],,
2348 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2350 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2353 .NSUBSPA $CODE$,COMDAT],,
2354 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2356 # .hidden needs to be supported in both the assembler and the linker,
2357 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2358 # This is irritatingly difficult to feature test for; we have to check the
2359 # date string after the version number. If we've got an in-tree
2360 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2362 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2363 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2369 # Darwin as has some visibility support, though with a different syntax.
2370 gcc_cv_as_hidden=yes
2374 # gnu_indirect_function type is an extension proposed at
2375 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2376 # selection of function implementation
2377 AC_ARG_ENABLE(gnu-indirect-function,
2378 [AS_HELP_STRING([--enable-gnu-indirect-function],
2379 [enable the use of the @gnu_indirect_function to glibc systems])],
2380 [case $enable_gnu_indirect_function in
2382 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2383 Valid choices are 'yes' and 'no'.]) ;;
2385 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2387 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2388 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2389 [Define if your system supports gnu indirect functions.])
2393 if test $in_tree_ld != yes ; then
2394 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2395 if echo "$ld_ver" | grep GNU > /dev/null; then
2396 if test x"$ld_is_gold" = xyes; then
2397 # GNU gold --version looks like this:
2399 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2401 # We extract the binutils version which is more familiar and specific
2402 # than the gold version.
2403 ld_vers=`echo $ld_ver | sed -n \
2404 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2406 # GNU ld --version looks like this:
2408 # GNU ld (GNU Binutils) 2.21.51.20110225
2409 ld_vers=`echo $ld_ver | sed -n \
2410 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2412 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'`
2413 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2414 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2415 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2419 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2422 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2423 # /usr/ccs/bin/ld has been configured.
2424 ld_ver=`$gcc_cv_ld -V 2>&1`
2425 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2426 ld_vers=`echo $ld_ver | sed -n \
2427 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2428 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2429 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2437 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2438 [[if test $in_tree_ld = yes ; then
2440 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 \
2441 && test $in_tree_ld_is_elf = yes; then
2442 gcc_cv_ld_hidden=yes
2445 gcc_cv_ld_hidden=yes
2446 if test x"$ld_is_gold" = xyes; then
2448 elif echo "$ld_ver" | grep GNU > /dev/null; then
2450 mmix-knuth-mmixware)
2451 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2455 if test 0"$ld_date" -lt 20020404; then
2456 if test -n "$ld_date"; then
2457 # If there was date string, but was earlier than 2002-04-04, fail
2459 elif test -z "$ld_vers"; then
2460 # If there was no date string nor ld version number, something is wrong
2463 test -z "$ld_vers_patch" && ld_vers_patch=0
2464 if test "$ld_vers_major" -lt 2; then
2466 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2467 gcc_cv_ld_hidden="no"
2468 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2476 # Darwin ld has some visibility support.
2477 gcc_cv_ld_hidden=yes
2479 hppa64*-*-hpux* | ia64*-*-hpux*)
2480 gcc_cv_ld_hidden=yes
2482 *-*-solaris2.1[0-9]*)
2483 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2484 # .symbolic was only added in Solaris 9 12/02.
2485 gcc_cv_ld_hidden=yes
2493 libgcc_visibility=no
2494 AC_SUBST(libgcc_visibility)
2495 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2496 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2497 libgcc_visibility=yes
2498 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2499 [Define if your assembler and linker support .hidden.])
2502 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2503 gcc_cv_ld_ro_rw_mix=unknown
2504 if test $in_tree_ld = yes ; then
2505 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 \
2506 && test $in_tree_ld_is_elf = yes; then
2507 gcc_cv_ld_ro_rw_mix=read-write
2509 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2510 echo '.section myfoosect, "a"' > conftest1.s
2511 echo '.section myfoosect, "aw"' > conftest2.s
2512 echo '.byte 1' >> conftest2.s
2513 echo '.section myfoosect, "a"' > conftest3.s
2514 echo '.byte 0' >> conftest3.s
2515 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2516 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2517 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2518 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2519 conftest2.o conftest3.o > /dev/null 2>&1; then
2520 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2521 | sed -e '/myfoosect/!d' -e N`
2522 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2523 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2524 gcc_cv_ld_ro_rw_mix=read-only
2526 gcc_cv_ld_ro_rw_mix=read-write
2531 rm -f conftest.* conftest[123].*
2534 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2535 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2536 [Define if your linker links a mix of read-only
2537 and read-write sections into a read-write section.])
2539 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2541 gcc_AC_INITFINI_ARRAY
2543 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2544 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2552 [[# GAS versions before 2.11 do not support uleb128,
2553 # despite appearing to.
2554 # ??? There exists an elf-specific test that will crash
2555 # the assembler. Perhaps it's better to figure out whether
2556 # arbitrary sections are supported and try the test.
2557 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2558 if echo "$as_ver" | grep GNU > /dev/null; then
2559 as_vers=`echo $as_ver | sed -n \
2560 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2561 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2562 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2563 if test $as_major -eq 2 && test $as_minor -lt 11
2565 else gcc_cv_as_leb128=yes
2568 [AC_DEFINE(HAVE_AS_LEB128, 1,
2569 [Define if your assembler supports .sleb128 and .uleb128.])])
2571 # Check if we have assembler support for unwind directives.
2572 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2579 .cfi_escape 1, 2, 3, 4, 5
2583 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2584 # read-only and read-write sections, we need to make sure that the
2585 # assembler used emits read-write .eh_frame sections.
2586 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2587 if test "x$gcc_cv_objdump" != x; then
2588 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2589 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2590 gcc_cv_as_cfi_directive=no
2593 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2594 # On Solaris/x86, make sure that GCC and assembler agree on using
2595 # read-only .eh_frame sections for 64-bit.
2596 if test x$gas = xyes; then
2597 as_ix86_64_opt="--64"
2599 as_ix86_64_opt="-xarch=amd64"
2601 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2602 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2603 sed -e /.eh_frame/!d -e N | \
2604 grep READONLY > /dev/null; then
2605 gcc_cv_as_cfi_directive=yes
2607 gcc_cv_as_cfi_directive=no
2611 gcc_cv_as_cfi_directive=yes
2616 # no objdump, err on the side of caution
2617 gcc_cv_as_cfi_directive=no
2620 gcc_cv_as_cfi_directive=yes
2624 gcc_cv_as_cfi_directive=yes
2627 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2628 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2632 .cfi_adjust_cfa_offset 64
2634 .cfi_adjust_cfa_offset 128
2637 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2638 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2639 gcc_cv_as_cfi_advance_working=yes
2643 # no objdump, err on the side of caution
2644 gcc_cv_as_cfi_advance_working=no
2646 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2647 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2648 [`if test $gcc_cv_as_cfi_directive = yes \
2649 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2650 [Define 0/1 if your assembler supports CFI directives.])
2652 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2653 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2654 gcc_cv_as_cfi_personality_directive, ,,
2657 .cfi_personality 0, symbol
2659 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2660 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2661 then echo 1; else echo 0; fi`],
2662 [Define 0/1 if your assembler supports .cfi_personality.])
2664 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2665 gcc_cv_as_cfi_sections_directive, ,,
2667 .cfi_sections .debug_frame, .eh_frame
2671 win32 | pe | cygwin* | mingw32* | uwin*)
2672 # Need to check that we generated the correct relocation for the
2673 # .debug_frame section. This was fixed for binutils 2.21.
2674 gcc_cv_as_cfi_sections_directive=no
2675 if test "x$gcc_cv_objdump" != x; then
2676 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2677 grep secrel > /dev/null; then
2678 gcc_cv_as_cfi_sections_directive=yes
2683 gcc_cv_as_cfi_sections_directive=yes
2686 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2687 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2688 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2689 then echo 1; else echo 0; fi`],
2690 [Define 0/1 if your assembler supports .cfi_sections.])
2692 # GAS versions up to and including 2.11.0 may mis-optimize
2694 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2702 .section .eh_frame,"aw",@progbits
2704 .4byte .LECIE1-.LSCIE1
2718 .4byte .LEFDE1-.LASFDE1
2720 .4byte .LASFDE1-__FRAME_BEGIN__
2728 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2729 cat > conftest.lit <<EOF
2730 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2731 0010 01000000 12000000 18000000 00000000 ................
2732 0020 08000000 04080000 0044 .........D @&t@
2734 cat > conftest.big <<EOF
2735 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2736 0010 00000001 00000012 00000018 00000000 ................
2737 0020 00000008 04000000 0844 .........D @&t@
2739 # If the assembler didn't choke, and we can objdump,
2740 # and we got the correct data, then succeed.
2741 # The text in the here-document typically retains its unix-style line
2742 # endings, while the output of objdump will use host line endings.
2743 # Therefore, use diff -b for the comparisons.
2744 if test x$gcc_cv_objdump != x \
2745 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2746 | tail -3 > conftest.got \
2747 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2748 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2750 gcc_cv_as_eh_frame=yes
2751 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2752 gcc_cv_as_eh_frame=buggy
2754 # Uh oh, what do we do now?
2755 gcc_cv_as_eh_frame=no
2758 if test $gcc_cv_as_eh_frame = buggy; then
2759 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2760 [Define if your assembler mis-optimizes .eh_frame data.])
2763 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2764 [elf,2,12,0], [--fatal-warnings],
2765 [.section .rodata.str, "aMS", @progbits, 1])
2766 if test $gcc_cv_as_shf_merge = no; then
2767 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2768 [elf,2,12,0], [--fatal-warnings],
2769 [.section .rodata.str, "aMS", %progbits, 1])
2771 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2772 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2773 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2775 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2776 gcc_cv_as_comdat_group,
2777 [elf,2,16,0], [--fatal-warnings],
2778 [.section .text,"axG",@progbits,.foo,comdat])
2779 if test $gcc_cv_as_comdat_group = yes; then
2780 gcc_cv_as_comdat_group_percent=no
2781 gcc_cv_as_comdat_group_group=no
2783 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2784 gcc_cv_as_comdat_group_percent,
2785 [elf,2,16,0], [--fatal-warnings],
2786 [.section .text,"axG",%progbits,.foo,comdat])
2787 if test $gcc_cv_as_comdat_group_percent = yes; then
2788 gcc_cv_as_comdat_group_group=no
2790 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2791 gcc_cv_as_comdat_group_group=no
2794 # Sun as uses a completely different syntax.
2799 .group foo,".text%foo",#comdat
2800 .section ".text%foo", #alloc,#execinstr,#progbits
2805 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2807 .group foo,.text%foo,#comdat
2808 .section .text%foo, "ax", @progbits
2814 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2815 gcc_cv_as_comdat_group_group,
2821 if test x"$ld_is_gold" = xyes; then
2823 elif test $in_tree_ld = yes ; then
2825 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 \
2826 && test $in_tree_ld_is_elf = yes; then
2829 elif echo "$ld_ver" | grep GNU > /dev/null; then
2831 if test 0"$ld_date" -lt 20050308; then
2832 if test -n "$ld_date"; then
2833 # If there was date string, but was earlier than 2005-03-08, fail
2835 elif test "$ld_vers_major" -lt 2; then
2837 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2844 *-*-solaris2.1[1-9]*)
2846 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2847 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2850 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2851 # least ld version 1.2267.
2852 if test "$ld_vers_major" -gt 1; then
2854 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2856 elif test "$ld_vers_minor" -ge 2267; then
2861 # Assume linkers other than GNU ld don't support COMDAT group.
2867 # Allow overriding the automatic COMDAT group tests above.
2868 AC_ARG_ENABLE(comdat,
2869 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2870 [comdat_group="$enable_comdat"])
2871 if test $comdat_group = no; then
2872 gcc_cv_as_comdat_group=no
2873 gcc_cv_as_comdat_group_percent=no
2874 gcc_cv_as_comdat_group_group=no
2876 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2877 [`if test $gcc_cv_as_comdat_group = yes \
2878 || test $gcc_cv_as_comdat_group_percent = yes \
2879 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2880 [Define 0/1 if your assembler and linker support COMDAT groups.])
2882 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2883 gcc_cv_as_discriminator,
2887 .loc 1 1 0 discriminator 1],,
2888 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2889 [Define if your assembler supports the .loc discriminator sub-directive.])])
2891 # Thread-local storage - the check is heavily parameterized.
2900 .section ".tdata","awT",@progbits
2903 ldq $27,__tls_get_addr($29) !literal!1
2904 lda $16,foo($29) !tlsgd!1
2905 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2906 ldq $27,__tls_get_addr($29) !literal!2
2907 lda $16,foo($29) !tlsldm!2
2908 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2909 ldq $1,foo($29) !gotdtprel
2910 ldah $2,foo($29) !dtprelhi
2911 lda $3,foo($2) !dtprello
2912 lda $4,foo($29) !dtprel
2913 ldq $1,foo($29) !gottprel
2914 ldah $2,foo($29) !tprelhi
2915 lda $3,foo($2) !tprello
2916 lda $4,foo($29) !tprel'
2919 tls_as_opt=--fatal-warnings
2921 cris-*-*|crisv32-*-*)
2923 .section ".tdata","awT",@progbits
2930 tls_as_opt=--fatal-warnings
2934 .section ".tdata","awT",@progbits
2946 .section ".tdata","awT",@progbits
2950 addil LT%foo-$tls_gdidx$,gp
2951 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2954 addil LT%foo-$tls_ldidx$,gp
2956 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2957 addil LR%foo-$tls_dtpoff$,%ret0
2958 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2960 addil LT%foo-$tls_ieoff$,gp
2961 ldw RT%foo-$tls_ieoff$(%r1),%t2
2964 addil LR%foo-$tls_leoff$,%t1
2965 ldo RR%foo-$tls_leoff$(%r1),%t2'
2968 tls_as_opt=--fatal-warnings
2972 .section ".tdata","awT",%progbits
2983 i[34567]86-*-* | x86_64-*-*)
2985 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
2992 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2994 .section .tdata,"awt",@progbits'
2999 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3000 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3004 .section ".tdata","awT",@progbits'
3008 tls_as_opt="--fatal-warnings"
3012 conftest_s="$conftest_s
3016 leal foo@tlsgd(,%ebx,1), %eax
3017 leal foo@tlsldm(%ebx), %eax
3018 leal foo@dtpoff(%eax), %edx
3019 movl foo@gottpoff(%ebx), %eax
3020 subl foo@gottpoff(%ebx), %eax
3021 addl foo@gotntpoff(%ebx), %eax
3022 movl foo@indntpoff, %eax
3023 movl \$foo@tpoff, %eax
3024 subl \$foo@tpoff, %eax
3025 leal foo@ntpoff(%ecx), %eax"
3028 if test x$on_solaris = xyes; then
3030 yes) tls_as_opt="$tls_as_opt --64" ;;
3031 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3034 conftest_s="$conftest_s
3038 leaq foo@tlsgd(%rip), %rdi
3039 leaq foo@tlsld(%rip), %rdi
3040 leaq foo@dtpoff(%rax), %rdx
3041 movq foo@gottpoff(%rip), %rax
3042 movq \$foo@tpoff, %rax"
3048 .section ".tdata","awT",@progbits
3051 addl r16 = @ltoff(@dtpmod(foo#)), gp
3052 addl r17 = @ltoff(@dtprel(foo#)), gp
3053 addl r18 = @ltoff(@tprel(foo#)), gp
3054 addl r19 = @dtprel(foo#), gp
3055 adds r21 = @dtprel(foo#), r13
3056 movl r23 = @dtprel(foo#)
3057 addl r20 = @tprel(foo#), gp
3058 adds r22 = @tprel(foo#), r13
3059 movl r24 = @tprel(foo#)'
3062 tls_as_opt=--fatal-warnings
3066 .section .tdata,"awT",@progbits
3070 addik r5,r20,x@TLSGD
3071 addik r5,r20,x@TLSLDM'
3074 tls_as_opt='--fatal-warnings'
3078 .section .tdata,"awT",@progbits
3082 addiu $4, $28, %tlsgd(x)
3083 addiu $4, $28, %tlsldm(x)
3084 lui $4, %dtprel_hi(x)
3085 addiu $4, $4, %dtprel_lo(x)
3086 lw $4, %gottprel(x)($28)
3087 lui $4, %tprel_hi(x)
3088 addiu $4, $4, %tprel_lo(x)'
3091 tls_as_opt='-32 --fatal-warnings'
3095 .section .tdata,"awT",@progbits
3100 move.l x@TLSGD(%a5),%a0
3101 move.l x@TLSLDM(%a5),%a0
3102 move.l x@TLSLDO(%a5),%a0
3103 move.l x@TLSIE(%a5),%a0
3104 move.l x@TLSLE(%a5),%a0'
3107 tls_as_opt='--fatal-warnings'
3111 .section ".tdata","awT",@progbits'
3114 tls_as_opt="--fatal-warnings"
3118 .section ".tdata","awT",%progbits
3122 add x0, x0, #:tlsgd_lo12:x
3127 tls_as_opt='--fatal-warnings'
3131 .extern __get_tpointer
3149 .section ".tdata","awT",@progbits
3157 addi 3,2,ld0@got@tlsgd
3163 addi 3,2,x1@got@tlsld
3169 addis 9,3,x2@dtprel@ha
3170 addi 9,9,x2@dtprel@l
3173 ld 9,x3@got@dtprel(2)
3179 tls_as_opt="-a64 --fatal-warnings"
3183 .section ".tdata","awT",@progbits
3191 addi 3,31,ld0@got@tlsgd
3193 addi 3,31,x1@got@tlsld
3196 addis 9,3,x2@dtprel@ha
3197 addi 9,9,x2@dtprel@l
3198 lwz 9,x3@got@tprel(31)
3201 addis 9,2,x2@tprel@ha
3202 addi 9,9,x2@tprel@l'
3205 tls_as_opt="-a32 --fatal-warnings"
3209 .section ".tdata","awT",@progbits
3218 l %r1,foo@GOTNTPOFF(%r12)
3219 l %r1,0(%r1):tls_load:foo
3220 bas %r14,0(%r1,%r13):tls_gdcall:foo
3221 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3224 tls_as_opt="-m31 --fatal-warnings"
3228 .section ".tdata","awT",@progbits
3236 lg %r1,foo@GOTNTPOFF(%r12)
3237 larl %r1,foo@INDNTPOFF
3238 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3239 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3242 tls_as_opt="-m64 -Aesame --fatal-warnings"
3244 sh-*-* | sh[34]-*-*)
3246 .section ".tdata","awT",@progbits
3256 tls_as_opt=--fatal-warnings
3260 sparc*-sun-solaris2.*)
3267 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3269 .section ".tdata",#alloc,#write,#tls'
3274 .section ".tdata","awT",@progbits'
3277 tls_as_opt="-32 --fatal-warnings"
3279 conftest_s="$conftest_s
3282 sethi %tgd_hi22(foo), %o0
3283 add %o0, %tgd_lo10(foo), %o1
3284 add %l7, %o1, %o0, %tgd_add(foo)
3285 call __tls_get_addr, %tgd_call(foo)
3286 sethi %tldm_hi22(foo), %l1
3287 add %l1, %tldm_lo10(foo), %l2
3288 add %l7, %l2, %o0, %tldm_add(foo)
3289 call __tls_get_addr, %tldm_call(foo)
3290 sethi %tldo_hix22(foo), %l3
3291 xor %l3, %tldo_lox10(foo), %l4
3292 add %o0, %l4, %l5, %tldo_add(foo)
3293 sethi %tie_hi22(foo), %o3
3294 add %o3, %tie_lo10(foo), %o3
3295 ld [%l7 + %o3], %o2, %tie_ld(foo)
3296 add %g7, %o2, %o4, %tie_add(foo)
3297 sethi %tle_hix22(foo), %l1
3298 xor %l1, %tle_lox10(foo), %o5
3299 ld [%g7 + %o5], %o1"
3303 .section ".tdata","awT",@progbits
3306 addli r0, zero, tls_gd(foo)
3307 auli r0, zero, tls_gd_ha16(foo)
3308 addli r0, r0, tls_gd_lo16(foo)
3310 addli r0, zero, tls_ie(foo)
3311 auli r0, r0, tls_ie_ha16(foo)
3312 addli r0, r0, tls_ie_lo16(foo)'
3315 tls_as_opt="--fatal-warnings"
3319 .section ".tdata","awT",@progbits
3322 shl16insli r0, zero, hw0_last_tls_gd(foo)
3323 shl16insli r0, zero, hw1_last_tls_gd(foo)
3324 shl16insli r0, r0, hw0_tls_gd(foo)
3326 shl16insli r0, zero, hw1_last_tls_ie(foo)
3327 shl16insli r0, r0, hw0_tls_ie(foo)'
3330 tls_as_opt="--fatal-warnings"
3334 .section ".tdata","awT",@progbits
3337 movi a8, foo@TLSFUNC
3338 movi a10, foo@TLSARG
3339 callx8.tls a8, foo@TLSCALL'
3346 if test "x$enable_tls" = xno ; then
3347 : # TLS explicitly disabled.
3348 elif test "x$enable_tls" = xyes ; then
3349 set_have_as_tls=yes # TLS explicitly enabled.
3350 elif test -z "$tls_first_major"; then
3351 : # If we don't have a check, assume no support.
3353 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3354 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3355 [set_have_as_tls=yes])
3357 if test $set_have_as_tls = yes ; then
3358 AC_DEFINE(HAVE_AS_TLS, 1,
3359 [Define if your assembler and linker support thread-local storage.])
3362 # Target-specific assembler checks.
3364 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3365 gcc_cv_ld_static_dynamic=no
3366 gcc_cv_ld_static_option='-Bstatic'
3367 gcc_cv_ld_dynamic_option='-Bdynamic'
3368 if test $in_tree_ld = yes ; then
3369 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
3370 gcc_cv_ld_static_dynamic=yes
3372 elif test x$gcc_cv_ld != x; then
3373 # Check if linker supports -Bstatic/-Bdynamic option
3374 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3375 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3376 gcc_cv_ld_static_dynamic=yes
3379 # AIX ld uses -b flags
3380 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3381 gcc_cv_ld_static_dynamic=yes
3382 gcc_cv_ld_static_option="-bstatic"
3383 gcc_cv_ld_dynamic_option="-bdynamic"
3385 # HP-UX ld uses -a flags to select between shared and archive.
3387 if test x"$gnu_ld" = xno; then
3388 gcc_cv_ld_static_dynamic=yes
3389 gcc_cv_ld_static_option="-aarchive_shared"
3390 gcc_cv_ld_dynamic_option="-adefault"
3393 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3395 gcc_cv_ld_static_dynamic=yes
3400 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3401 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3402 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3403 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3404 [Define to the linker option to disable use of shared objects.])
3405 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3406 [Define to the linker option to enable use of shared objects.])
3408 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3410 if test x"$demangler_in_ld" = xyes; then
3411 AC_MSG_CHECKING(linker --demangle support)
3412 gcc_cv_ld_demangle=no
3413 if test $in_tree_ld = yes; then
3414 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 \
3415 gcc_cv_ld_demangle=yes
3417 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3418 # Check if the GNU linker supports --demangle option
3419 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3420 gcc_cv_ld_demangle=yes
3423 if test x"$gcc_cv_ld_demangle" = xyes; then
3424 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3425 [Define if your linker supports --demangle option.])
3427 AC_MSG_RESULT($gcc_cv_ld_demangle)
3430 AC_MSG_CHECKING(linker plugin support)
3432 if test -f liblto_plugin.la; then
3433 save_ld_ver="$ld_ver"
3434 save_ld_vers_major="$ld_vers_major"
3435 save_ld_vers_minor="$ld_vers_minor"
3436 save_ld_is_gold="$ld_is_gold"
3440 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3442 # FIXME: ld_is_gold?
3443 ld_vers_major="$gcc_cv_gld_major_version"
3444 ld_vers_minor="$gcc_cv_gld_minor_version"
3446 # Determine plugin linker version.
3447 # FIXME: Partial duplicate from above, generalize.
3449 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3450 if echo "$ld_ver" | grep GNU > /dev/null; then
3451 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3453 ld_vers=`echo $ld_ver | sed -n \
3454 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3456 ld_vers=`echo $ld_ver | sed -n \
3457 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3459 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3460 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3465 # Determine plugin support.
3466 if echo "$ld_ver" | grep GNU > /dev/null; then
3467 # Require GNU ld or gold 2.21+ for plugin support by default.
3468 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3470 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3471 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3476 ld_ver="$save_ld_ver"
3477 ld_vers_major="$save_ld_vers_major"
3478 ld_vers_minor="$save_ld_vers_minor"
3479 ld_is_gold="$save_ld_is_gold"
3481 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3482 [Define to the level of your linker's plugin support.])
3483 AC_MSG_RESULT($gcc_cv_lto_plugin)
3487 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3488 [-mabi=lp64], [.text],,,)
3489 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3490 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3491 [Define if your assembler supports the -mabi option.])
3493 if test x$with_abi = xilp32; then
3494 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3495 Upgrade the Assembler.])
3497 if test x"$with_multilib_list" = xdefault; then
3498 TM_MULTILIB_CONFIG=lp64
3500 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3501 for aarch64_multilib in ${aarch64_multilibs}; do
3502 case ${aarch64_multilib} in
3504 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3505 Upgrade the Assembler.])
3515 # All TARGET_ABI_OSF targets.
3516 alpha*-*-linux* | alpha*-*-*bsd*)
3517 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3518 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3521 extbl $3, $2, $3 !lituse_bytoff!1
3522 ldq $2, a($29) !literal!1
3523 ldq $4, b($29) !literal!2
3524 ldq_u $3, 0($2) !lituse_base!1
3525 ldq $27, f($29) !literal!5
3526 jsr $26, ($27), f !lituse_jsr!5
3527 ldah $29, 0($26) !gpdisp!3
3528 lda $0, c($29) !gprel
3529 ldah $1, d($29) !gprelhigh
3530 lda $1, d($1) !gprellow
3531 lda $29, 0($29) !gpdisp!3],,
3532 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3533 [Define if your assembler supports explicit relocations.])])
3534 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3535 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3538 ldq $27, a($29) !literal!1
3539 jsr $26, ($27), a !lituse_jsrdirect!1],,
3540 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3541 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3545 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3546 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3547 [-no-mul-bug-abort], [.text],,
3548 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3549 [Define if your assembler supports the -no-mul-bug-abort option.])])
3553 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3554 [.register %g2, #scratch],,
3555 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3556 [Define if your assembler supports .register.])])
3558 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3559 [.section "nobits",#alloc,#write,#nobits
3560 .section "progbits",#alloc,#write,#progbits])
3561 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3562 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3563 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3565 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3567 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3568 [Define if your assembler supports -relax option.])])
3570 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3571 gcc_cv_as_sparc_gotdata_op,,
3578 sethi %gdop_hix22(foo), %g1
3579 xor %g1, %gdop_lox10(foo), %g1
3580 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3581 [if test x$gcc_cv_ld != x \
3582 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3583 if test x$gcc_cv_objdump != x; then
3584 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3585 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3586 gcc_cv_as_sparc_gotdata_op=no
3588 gcc_cv_as_sparc_gotdata_op=yes
3593 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3594 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3596 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3597 gcc_cv_as_sparc_ua_pcrel,,
3605 .uaword %r_disp32(foo)],
3606 [if test x$gcc_cv_ld != x \
3607 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3608 gcc_cv_as_sparc_ua_pcrel=yes
3611 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3612 [Define if your assembler and linker support unaligned PC relative relocs.])
3614 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3615 gcc_cv_as_sparc_ua_pcrel_hidden,,
3620 .uaword %r_disp32(foo)
3621 .byte 0x32, 0x33, 0x34
3626 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3627 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3628 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3629 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3630 if $gcc_cv_objdump -R conftest 2> /dev/null \
3631 | grep 'DISP32' > /dev/null 2>&1; then
3634 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3638 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3639 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3640 ]) # unaligned pcrel relocs
3642 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3643 gcc_cv_as_sparc_offsetable_lo10,,
3646 or %g1, %lo(ab) + 12, %g1
3647 or %g1, %lo(ab + 12), %g1],
3648 [if test x$gcc_cv_objdump != x \
3649 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3650 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3651 gcc_cv_as_sparc_offsetable_lo10=yes
3653 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3654 [Define if your assembler supports offsetable %lo().])])
3656 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3657 gcc_cv_as_sparc_fmaf,,
3660 .register %g2, #scratch
3661 .register %g3, #scratch
3663 fmaddd %f0, %f2, %f4, %f6
3664 addxccc %g1, %g2, %g3
3665 fsrl32 %f2, %f4, %f8
3666 fnaddd %f10, %f12, %f14],,
3667 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3668 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3670 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3671 gcc_cv_as_sparc_sparc4,,
3674 .register %g2, #scratch
3675 .register %g3, #scratch
3678 1: cwbneg %g2, %g3, 1f
3681 aes_kexpand0 %f4, %f6, %f8
3682 des_round %f38, %f40, %f42, %f44
3683 camellia_f %f54, %f56, %f58, %f60
3684 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3685 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3686 [Define if your assembler supports SPARC4 instructions.])])
3688 gcc_GAS_CHECK_FEATURE([LEON instructions],
3689 gcc_cv_as_sparc_leon,,
3692 .register %g2, #scratch
3693 .register %g3, #scratch
3697 casa [[%g2]] 0xb, %g3, %g1],,
3698 [AC_DEFINE(HAVE_AS_LEON, 1,
3699 [Define if your assembler supports LEON instructions.])])
3703 i[34567]86-*-* | x86_64-*-*)
3707 # Full C++ conformance when using a shared libstdc++-v3 requires some
3708 # support from the Cygwin DLL, which in more recent versions exports
3709 # wrappers to aid in interposing and redirecting operators new, delete,
3710 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3711 # are configuring for a version of Cygwin that exports the wrappers.
3712 if test x$host = x$target && test x$host_cpu = xi686; then
3713 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3715 # Can't check presence of libc functions during cross-compile, so
3716 # we just have to assume we're building for an up-to-date target.
3717 gcc_ac_cygwin_dll_wrappers=yes
3719 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3720 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3721 [Define if you want to generate code by default that assumes that the
3722 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3725 cygwin* | pe | mingw32* | interix*)
3726 # Recent binutils allows the three-operand form of ".comm" on PE. This
3727 # definition is used unconditionally to initialise the default state of
3728 # the target option variable that governs usage of the feature.
3729 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3730 [2,19,52],,[.comm foo,1,32])
3731 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3732 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3733 [Define if your assembler supports specifying the alignment
3734 of objects allocated using the GAS .comm command.])
3735 # Used for DWARF 2 in PE
3736 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3737 gcc_cv_as_ix86_pe_secrel32,
3743 [if test x$gcc_cv_ld != x \
3744 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3745 gcc_cv_as_ix86_pe_secrel32=yes
3748 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3749 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3750 # Test if the assembler supports the extended form of the .section
3751 # directive that specifies section alignment. LTO support uses this,
3752 # but normally only after installation, so we warn but don't fail the
3753 # configure if LTO is enabled but the assembler does not support it.
3754 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3755 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3756 if test x$gcc_cv_as_section_has_align != xyes; then
3757 case ",$enable_languages," in
3759 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3763 # Test if the assembler supports the section flag 'e' for specifying
3764 # an excluded section.
3765 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3769 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3770 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3771 [Define if your assembler supports specifying the section flag e.])
3775 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3776 gcc_cv_as_ix86_filds,,,
3777 [filds mem; fists mem],,
3778 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3779 [Define if your assembler uses filds and fists mnemonics.])])
3781 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3782 gcc_cv_as_ix86_fildq,,,
3783 [fildq mem; fistpq mem],,
3784 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3785 [Define if your assembler uses fildq and fistq mnemonics.])])
3787 gcc_GAS_CHECK_FEATURE([cmov syntax],
3788 gcc_cv_as_ix86_cmov_sun_syntax,,,
3789 [cmovl.l %edx, %eax],,
3790 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3791 [Define if your assembler supports the Sun syntax for cmov.])])
3793 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3794 gcc_cv_as_ix86_ffreep,,,
3796 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3797 [Define if your assembler supports the ffreep mnemonic.])])
3799 gcc_GAS_CHECK_FEATURE([.quad directive],
3800 gcc_cv_as_ix86_quad,,,
3802 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3803 [Define if your assembler supports the .quad directive.])])
3805 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3806 gcc_cv_as_ix86_sahf,,,
3809 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3810 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3812 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3813 gcc_cv_as_ix86_interunit_movq,,,
3817 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3818 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3819 [Define if your assembler supports interunit movq mnemonic.])
3821 gcc_GAS_CHECK_FEATURE([hle prefixes],
3822 gcc_cv_as_ix86_hle,,,
3823 [lock xacquire cmpxchg %esi, (%ecx)],,
3824 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3825 [Define if your assembler supports HLE prefixes.])])
3827 gcc_GAS_CHECK_FEATURE([swap suffix],
3828 gcc_cv_as_ix86_swap,,,
3829 [movl.s %esp, %ebp],,
3830 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3831 [Define if your assembler supports the swap suffix.])])
3833 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3834 gcc_cv_as_ix86_diff_sect_delta,,,
3842 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3843 [Define if your assembler supports the subtraction of symbols in different sections.])])
3845 # These two are used unconditionally by i386.[ch]; it is to be defined
3846 # to 1 if the feature is present, 0 otherwise.
3847 as_ix86_gotoff_in_data_opt=
3848 if test x$gas = xyes; then
3849 as_ix86_gotoff_in_data_opt="--32"
3851 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3852 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3853 [$as_ix86_gotoff_in_data_opt],
3859 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3860 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3861 [Define true if the assembler supports '.long foo@GOTOFF'.])
3863 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3864 gcc_cv_as_ix86_rep_lock_prefix,,,
3870 lock addl %edi, (%eax,%esi)
3871 lock orl $0, (%esp)],,
3872 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3873 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3875 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3876 gcc_cv_as_ix86_ud2,,,
3878 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3879 [Define if your assembler supports the 'ud2' mnemonic.])])
3881 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3882 gcc_cv_as_ix86_tlsgdplt,,,
3883 [call tls_gd@tlsgdplt],
3884 [if test x$gcc_cv_ld != x \
3885 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3886 gcc_cv_as_ix86_tlsgdplt=yes
3889 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3890 [Define if your assembler and linker support @tlsgdplt.])])
3893 .section .tdata,"aw'$tls_section_flag'",@progbits
3895 .section .text,"ax",@progbits
3896 call tls_ld@tlsldmplt'
3897 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3898 gcc_cv_as_ix86_tlsldmplt,,,
3900 [if test x$gcc_cv_ld != x \
3901 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3902 gcc_cv_as_ix86_tlsldmplt=yes
3905 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3906 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3907 [Define to 1 if your assembler and linker support @tlsldmplt.])
3909 # Enforce 32-bit output with gas and gld.
3910 if test x$gas = xyes; then
3911 as_ix86_tls_ldm_opt="--32"
3913 if echo "$ld_ver" | grep GNU > /dev/null; then
3914 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3915 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3917 ld_ix86_tls_ldm_opt="-melf_i386"
3921 .section .text,"ax",@progbits
3923 .type _start, @function
3925 leal value@tlsldm(%ebx), %eax
3926 call ___tls_get_addr@plt
3928 .section .tdata,"aw'$tls_section_flag'",@progbits
3929 .type value, @object
3931 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3932 gcc_cv_as_ix86_tlsldm,,
3933 [$as_ix86_tls_ldm_opt],
3935 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3936 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3937 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3938 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3939 gcc_cv_as_ix86_tlsldm=yes
3943 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3944 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3945 [Define to 1 if your assembler and linker support @tlsldm.])
3950 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3951 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3953 addl r15 = @ltoffx(x#), gp
3955 ld8.mov r16 = [[r15]], x#],,
3956 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3957 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3963 *-*-aix*) conftest_s=' .machine "pwr5"
3967 gcc_GAS_CHECK_FEATURE([.machine directive support],
3968 gcc_cv_as_machine_directive,,,
3969 [ .machine ppc7400])
3970 if test x$gcc_cv_as_machine_directive != xyes; then
3971 echo "*** This target requires an assembler supporting \".machine\"" >&2
3972 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3973 test x$build = x$target && exit 1
3977 *) conftest_s=' .machine power4
3982 gcc_GAS_CHECK_FEATURE([mfcr field support],
3983 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3985 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3986 [Define if your assembler supports mfcr field.])])
3989 *-*-aix*) conftest_s=' .machine "pwr5"
3992 *) conftest_s=' .machine power5
3997 gcc_GAS_CHECK_FEATURE([popcntb support],
3998 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4000 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4001 [Define if your assembler supports popcntb field.])])
4004 *-*-aix*) conftest_s=' .machine "pwr5x"
4007 *) conftest_s=' .machine power5
4012 gcc_GAS_CHECK_FEATURE([fp round support],
4013 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4015 [AC_DEFINE(HAVE_AS_FPRND, 1,
4016 [Define if your assembler supports fprnd.])])
4019 *-*-aix*) conftest_s=' .machine "pwr6"
4022 *) conftest_s=' .machine power6
4027 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4028 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4030 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4031 [Define if your assembler supports mffgpr and mftgpr.])])
4034 *-*-aix*) conftest_s=' .csect .text[[PR]]
4036 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4040 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4041 *) conftest_s=' .text
4043 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4046 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4047 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4049 [AC_DEFINE(HAVE_AS_REL16, 1,
4050 [Define if your assembler supports R_PPC_REL16 relocs.])])
4053 *-*-aix*) conftest_s=' .machine "pwr6"
4056 *) conftest_s=' .machine power6
4061 gcc_GAS_CHECK_FEATURE([compare bytes support],
4062 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4064 [AC_DEFINE(HAVE_AS_CMPB, 1,
4065 [Define if your assembler supports cmpb.])])
4068 *-*-aix*) conftest_s=' .machine "pwr6"
4071 *) conftest_s=' .machine power6
4076 gcc_GAS_CHECK_FEATURE([decimal float support],
4077 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4079 [AC_DEFINE(HAVE_AS_DFP, 1,
4080 [Define if your assembler supports DFP instructions.])])
4083 *-*-aix*) conftest_s=' .machine "pwr7"
4086 *) conftest_s=' .machine power7
4091 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4092 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4094 [AC_DEFINE(HAVE_AS_VSX, 1,
4095 [Define if your assembler supports VSX instructions.])])
4098 *-*-aix*) conftest_s=' .machine "pwr7"
4101 *) conftest_s=' .machine power7
4106 gcc_GAS_CHECK_FEATURE([popcntd support],
4107 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4109 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4110 [Define if your assembler supports POPCNTD instructions.])])
4113 *-*-aix*) conftest_s=' .machine "pwr8"
4114 .csect .text[[PR]]';;
4115 *) conftest_s=' .machine power8
4119 gcc_GAS_CHECK_FEATURE([power8 support],
4120 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4122 [AC_DEFINE(HAVE_AS_POWER8, 1,
4123 [Define if your assembler supports POWER8 instructions.])])
4126 *-*-aix*) conftest_s=' .csect .text[[PR]]
4128 *) conftest_s=' .text
4132 gcc_GAS_CHECK_FEATURE([lwsync support],
4133 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4135 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4136 [Define if your assembler supports LWSYNC instructions.])])
4139 *-*-aix*) conftest_s=' .machine "476"
4142 *) conftest_s=' .machine "476"
4147 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4148 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4150 [AC_DEFINE(HAVE_AS_DCI, 1,
4151 [Define if your assembler supports the DCI/ICI instructions.])])
4153 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4154 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4155 [.gnu_attribute 4,1],,
4156 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4157 [Define if your assembler supports .gnu_attribute.])])
4159 gcc_GAS_CHECK_FEATURE([tls marker support],
4160 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4161 [ bl __tls_get_addr(x@tlsgd)],,
4162 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4163 [Define if your assembler supports arg info for __tls_get_addr.])])
4167 gcc_GAS_CHECK_FEATURE([.ref support],
4168 gcc_cv_as_aix_ref, [2,21,0],,
4169 [ .csect stuff[[rw]]
4175 [AC_DEFINE(HAVE_AS_REF, 1,
4176 [Define if your assembler supports .ref])])
4182 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4183 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4184 [ lw $4,%gp_rel(foo)($4)],,
4185 [if test x$target_cpu_default = x
4186 then target_cpu_default=MASK_EXPLICIT_RELOCS
4187 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4189 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4190 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4191 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4192 [Define if the assembler understands -mno-shared.])])
4194 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4195 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4196 [.gnu_attribute 4,1],,
4197 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4198 [Define if your assembler supports .gnu_attribute.])])
4200 gcc_GAS_CHECK_FEATURE([.micromips support],
4201 gcc_cv_as_micromips_support,,[--fatal-warnings],
4203 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4204 [Define if your assembler supports the .set micromips directive])])
4206 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4207 gcc_cv_as_mips_dtprelword, [2,18,0],,
4208 [.section .tdata,"awT",@progbits
4212 .dtprelword x+0x8000],,
4213 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4214 [Define if your assembler supports .dtprelword.])])
4216 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4217 gcc_cv_as_mips_dspr1_mult,,,
4227 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4228 [Define if your assembler supports DSPR1 mult.])])
4230 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4231 gcc_cv_as_ld_jalr_reloc=no
4232 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4233 if test $in_tree_ld = yes ; then
4234 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 \
4235 && test $in_tree_ld_is_elf = yes; then
4236 gcc_cv_as_ld_jalr_reloc=yes
4238 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4239 echo ' .ent x' > conftest.s
4240 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4241 echo ' lw $25,%call16(y)($28)' >> conftest.s
4242 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4243 echo '1: jalr $25' >> conftest.s
4244 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4245 echo '1: jalr $25' >> conftest.s
4246 echo ' .end x' >> conftest.s
4247 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4248 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4249 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4250 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4251 gcc_cv_as_ld_jalr_reloc=yes
4257 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4258 if test x$target_cpu_default = x; then
4259 target_cpu_default=MASK_RELAX_PIC_CALLS
4261 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4264 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4266 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4267 [gcc_cv_ld_mips_personality_relaxation],
4268 [gcc_cv_ld_mips_personality_relaxation=no
4269 if test $in_tree_ld = yes ; then
4270 if test "$gcc_cv_gld_major_version" -eq 2 \
4271 -a "$gcc_cv_gld_minor_version" -ge 21 \
4272 -o "$gcc_cv_gld_major_version" -gt 2; then
4273 gcc_cv_ld_mips_personality_relaxation=yes
4275 elif test x$gcc_cv_as != x \
4276 -a x$gcc_cv_ld != x \
4277 -a x$gcc_cv_readelf != x ; then
4278 cat > conftest.s <<EOF
4280 .cfi_personality 0x80,indirect_ptr
4287 .section .data,"aw",@progbits
4291 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4292 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4293 if $gcc_cv_readelf -d conftest 2>&1 \
4294 | grep TEXTREL > /dev/null 2>&1; then
4296 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4297 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4300 gcc_cv_ld_mips_personality_relaxation=yes
4304 rm -f conftest.s conftest.o conftest])
4305 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4306 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4307 [Define if your linker can relax absolute .eh_frame personality
4308 pointers into PC-relative form.])
4311 gcc_GAS_CHECK_FEATURE([-mnan= support],
4312 gcc_cv_as_mips_nan,,
4314 [AC_DEFINE(HAVE_AS_NAN, 1,
4315 [Define if the assembler understands -mnan=.])])
4316 if test x$gcc_cv_as_mips_nan = xno \
4317 && test x$with_nan != x; then
4319 [Requesting --with-nan= requires assembler support for -mnan=])
4324 # Mips and HP-UX need the GNU assembler.
4325 # Linux on IA64 might be able to use the Intel assembler.
4328 mips*-*-* | *-*-hpux* )
4329 if test x$gas_flag = xyes \
4330 || test x"$host" != x"$build" \
4331 || test ! -x "$gcc_cv_as" \
4332 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4335 echo "*** This configuration requires the GNU assembler" >&2
4341 # ??? Not all targets support dwarf2 debug_line, even within a version
4342 # of gas. Moreover, we need to emit a valid instruction to trigger any
4343 # info to the output file. So, as supported targets are added to gas 2.11,
4344 # add some instruction here to (also) show we expect this might work.
4345 # ??? Once 2.11 is released, probably need to add first known working
4346 # version to the per-target configury.
4348 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4349 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4350 | xstormy16 | xtensa)
4360 if test x"$insn" != x; then
4362 .file 1 \"conftest.s\"
4365 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4366 gcc_cv_as_dwarf2_debug_line,
4367 [elf,2,11,0],, [$conftest_s],
4368 [if test x$gcc_cv_objdump != x \
4369 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4370 | grep debug_line > /dev/null 2>&1; then
4371 gcc_cv_as_dwarf2_debug_line=yes
4374 # The .debug_line file table must be in the exact order that
4375 # we specified the files, since these indices are also used
4376 # by DW_AT_decl_file. Approximate this test by testing if
4377 # the assembler bitches if the same index is assigned twice.
4378 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4379 gcc_cv_as_dwarf2_file_buggy,,,
4383 if test $gcc_cv_as_dwarf2_debug_line = yes \
4384 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4385 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4386 [Define if your assembler supports dwarf2 .file/.loc directives,
4387 and preserves file table indices exactly as given.])
4390 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4391 gcc_cv_as_gdwarf2_flag,
4392 [elf,2,11,0], [--gdwarf2], [$insn],,
4393 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4394 [Define if your assembler supports the --gdwarf2 option.])])
4396 gcc_GAS_CHECK_FEATURE([--gstabs option],
4397 gcc_cv_as_gstabs_flag,
4398 [elf,2,11,0], [--gstabs], [$insn],,
4399 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4400 [Define if your assembler supports the --gstabs option.])])
4402 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4403 gcc_cv_as_debug_prefix_map_flag,
4404 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4405 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4406 [Define if your assembler supports the --debug-prefix-map option.])])
4409 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4410 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4411 [# gas compiled without zlib cannot compress debug sections and warns
4412 # about it, but still exits successfully. So check for this, too.
4413 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4415 gcc_cv_as_compress_debug=0
4416 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4418 gcc_cv_as_compress_debug=1
4419 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4420 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4422 gcc_cv_as_compress_debug=0
4423 # FIXME: Future gas versions will support ELF gABI style via
4424 # --compress-debug-sections[=type].
4426 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4427 [Define to the level of your assembler's compressed debug section support.])
4428 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4429 [Define to the assembler option to enable compressed debug sections.])
4430 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4431 [Define to the assembler option to disable compressed debug sections.])
4433 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4436 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4437 [Define if your assembler supports .lcomm with an alignment field.])])
4439 if test x$with_sysroot = x && test x$host = x$target \
4440 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4441 && test "$prefix" != "NONE"; then
4442 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4443 [Define to PREFIX/include if cpp should also search that directory.])
4446 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4447 if test "x$with_headers" != x; then
4448 target_header_dir=$with_headers
4449 elif test "x$with_sysroot" = x; then
4450 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4451 elif test "x$with_build_sysroot" != "x"; then
4452 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4453 elif test "x$with_sysroot" = xyes; then
4454 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4456 target_header_dir="${with_sysroot}${native_system_header_dir}"
4459 target_header_dir=${native_system_header_dir}
4462 # Determine the version of glibc, if any, used on the target.
4463 AC_MSG_CHECKING([for target glibc version])
4464 AC_ARG_WITH([glibc-version],
4465 [AS_HELP_STRING([--with-glibc-version=M.N],
4466 [assume GCC used with glibc version M.N or later])], [
4467 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4468 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4469 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4471 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4473 glibc_version_major=0
4474 glibc_version_minor=0
4475 [if test -f $target_header_dir/features.h \
4476 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4477 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4478 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4479 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4481 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4483 AC_ARG_ENABLE(gnu-unique-object,
4484 [AS_HELP_STRING([--enable-gnu-unique-object],
4485 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4486 [case $enable_gnu_unique_object in
4488 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4489 Valid choices are 'yes' and 'no'.]) ;;
4491 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4493 [.type foo, '$target_type_format_char'gnu_unique_object],,
4494 # We need to unquote above to to use the definition from config.gcc.
4495 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4496 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4498 if test x$enable_gnu_unique_object = xyes; then
4499 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4500 [Define if your assembler supports @gnu_unique_object.])
4503 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4504 [gcc_cv_as_line_zero],
4505 [gcc_cv_as_line_zero=no
4506 if test $in_tree_gas = yes; then
4507 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4508 elif test "x$gcc_cv_as" != x; then
4509 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4510 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4511 test "x`cat conftest.out`" = x
4513 gcc_cv_as_line_zero=yes
4515 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4516 cat conftest.s >&AS_MESSAGE_LOG_FD
4517 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4518 cat conftest.out >&AS_MESSAGE_LOG_FD
4520 rm -f conftest.o conftest.s conftest.out
4522 if test "x$gcc_cv_as_line_zero" = xyes; then
4523 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4524 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4527 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4528 gcc_cv_ld_eh_frame_hdr=no
4529 if test $in_tree_ld = yes ; then
4530 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 \
4531 && test $in_tree_ld_is_elf = yes; then
4532 gcc_cv_ld_eh_frame_hdr=yes
4534 elif test x$gcc_cv_ld != x; then
4535 if echo "$ld_ver" | grep GNU > /dev/null; then
4536 # Check if linker supports --eh-frame-hdr option
4537 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4538 gcc_cv_ld_eh_frame_hdr=yes
4543 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4544 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4545 gcc_cv_ld_eh_frame_hdr=yes
4551 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4552 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4553 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4554 [Define if your linker supports .eh_frame_hdr.])
4556 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4558 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4559 gcc_cv_ld_eh_frame_ciev3=no
4560 if test $in_tree_ld = yes ; then
4561 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 \
4562 && test $in_tree_ld_is_elf = yes; then
4563 gcc_cv_ld_eh_frame_ciev3=yes
4565 elif test x$gcc_cv_ld != x; then
4566 if echo "$ld_ver" | grep GNU > /dev/null; then
4567 gcc_cv_ld_eh_frame_ciev3=yes
4568 if test 0"$ld_date" -lt 20040513; then
4569 if test -n "$ld_date"; then
4570 # If there was date string, but was earlier than 2004-05-13, fail
4571 gcc_cv_ld_eh_frame_ciev3=no
4572 elif test "$ld_vers_major" -lt 2; then
4573 gcc_cv_ld_eh_frame_ciev3=no
4574 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4575 gcc_cv_ld_eh_frame_ciev3=no
4581 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4582 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4583 gcc_cv_ld_eh_frame_ciev3=yes
4589 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4590 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4591 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4592 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4594 AC_MSG_CHECKING(linker position independent executable support)
4596 if test $in_tree_ld = yes ; then
4597 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 \
4598 && test $in_tree_ld_is_elf = yes; then
4601 elif test x$gcc_cv_ld != x; then
4602 # Check if linker supports -pie option
4603 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4607 if test x"$gcc_cv_ld_pie" = xyes; then
4608 AC_DEFINE(HAVE_LD_PIE, 1,
4609 [Define if your linker supports -pie option.])
4611 AC_MSG_RESULT($gcc_cv_ld_pie)
4613 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4614 gcc_cv_ld_eh_gc_sections=no
4615 if test $in_tree_ld = yes ; then
4616 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 \
4617 && test $in_tree_ld_is_elf = yes; then
4618 gcc_cv_ld_eh_gc_sections=yes
4620 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4621 cat > conftest.s <<EOF
4624 .type _start, @function
4627 .size _start, .-_start
4628 .section .text.foo,"ax",@progbits
4629 .type foo, @function
4633 .section .gcc_except_table.foo,"a",@progbits
4636 .section .eh_frame,"a",@progbits
4639 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4640 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4641 | grep "gc-sections option ignored" > /dev/null; then
4642 gcc_cv_ld_eh_gc_sections=no
4643 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4644 | grep gcc_except_table > /dev/null; then
4645 gcc_cv_ld_eh_gc_sections=yes
4646 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4647 if test x$gcc_cv_as_comdat_group != xyes; then
4648 gcc_cv_ld_eh_gc_sections=no
4649 cat > conftest.s <<EOF
4652 .type _start, @function
4655 .size _start, .-_start
4656 .section .gnu.linkonce.t.foo,"ax",@progbits
4657 .type foo, @function
4661 .section .gcc_except_table.foo,"a",@progbits
4664 .section .eh_frame,"a",@progbits
4667 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4668 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4669 | grep "gc-sections option ignored" > /dev/null; then
4670 gcc_cv_ld_eh_gc_sections=no
4671 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4672 | grep gcc_except_table > /dev/null; then
4673 gcc_cv_ld_eh_gc_sections=yes
4679 rm -f conftest.s conftest.o conftest
4683 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4684 gcc_cv_ld_eh_gc_sections=no
4687 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4688 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4689 [Define if your linker supports garbage collection of
4690 sections in presence of EH frames.])
4692 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4694 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4695 gcc_cv_ld_eh_gc_sections_bug=no
4696 if test $in_tree_ld = yes ; then
4697 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 \
4698 && test $in_tree_ld_is_elf = yes; then
4699 gcc_cv_ld_eh_gc_sections_bug=yes
4701 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
4702 gcc_cv_ld_eh_gc_sections_bug=yes
4703 cat > conftest.s <<EOF
4706 .type _start, @function
4709 .size _start, .-_start
4710 .section .text.startup.foo,"ax",@progbits
4711 .type foo, @function
4715 .section .gcc_except_table.foo,"a",@progbits
4718 .section .eh_frame,"a",@progbits
4721 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4722 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4723 | grep "gc-sections option ignored" > /dev/null; then
4725 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4726 | grep gcc_except_table > /dev/null; then
4727 gcc_cv_ld_eh_gc_sections_bug=no
4730 rm -f conftest.s conftest.o conftest
4732 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4733 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4734 [Define if your linker has buggy garbage collection of
4735 sections support when .text.startup.foo like sections are used.])
4737 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4739 AC_MSG_CHECKING(linker for compressed debug sections)
4740 # gold/gld support compressed debug sections since binutils 2.19/2.21
4741 if test $in_tree_ld = yes ; then
4742 gcc_cv_ld_compress_debug=0
4743 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 \
4744 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
4745 gcc_cv_ld_compress_debug=2
4746 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4747 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 \
4748 && test $in_tree_ld_is_elf = yes; then
4749 gcc_cv_ld_compress_debug=1
4751 elif echo "$ld_ver" | grep GNU > /dev/null; then
4752 gcc_cv_ld_compress_debug=1
4753 if test 0"$ld_date" -lt 20050308; then
4754 if test -n "$ld_date"; then
4755 # If there was date string, but was earlier than 2005-03-08, fail
4756 gcc_cv_ld_compress_debug=0
4757 elif test "$ld_vers_major" -lt 2; then
4758 gcc_cv_ld_compress_debug=0
4759 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
4760 gcc_cv_ld_compress_debug=0
4763 if test $ld_is_gold = yes; then
4764 gcc_cv_ld_compress_debug=2
4765 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4771 # Introduced in Solaris 11.2.
4772 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
4773 gcc_cv_ld_compress_debug=3
4774 gcc_cv_ld_compress_debug_option="-z compress-sections"
4776 gcc_cv_ld_compress_debug=0
4780 # Assume linkers other than GNU ld don't support compessed debug
4782 gcc_cv_ld_compress_debug=0
4787 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
4788 [Define to the level of your linker's compressed debug section support.])
4789 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
4790 [Define to the linker option to enable compressed debug sections.])
4791 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
4797 AC_CACHE_CHECK(linker --as-needed support,
4798 gcc_cv_ld_as_needed,
4799 [gcc_cv_ld_as_needed=no
4800 gcc_cv_ld_as_needed_option='--as-needed'
4801 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4802 if test $in_tree_ld = yes ; then
4803 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 \
4804 && test $in_tree_ld_is_elf = yes; then
4805 gcc_cv_ld_as_needed=yes
4807 elif test x$gcc_cv_ld != x; then
4808 # Check if linker supports --as-needed and --no-as-needed options
4809 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4810 gcc_cv_ld_as_needed=yes
4813 # Solaris 2 ld always supports -z ignore/-z record.
4815 gcc_cv_ld_as_needed=yes
4816 gcc_cv_ld_as_needed_option="-z ignore"
4817 gcc_cv_ld_no_as_needed_option="-z record"
4822 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4823 # dl_iterate_phdr, i.e. since Solaris 11.
4825 *-*-solaris2.1[[1-9]]*)
4827 i?86-*-* | x86_64-*-*)
4828 if echo "$ld_ver" | grep GNU > /dev/null; then
4829 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4830 gcc_cv_ld_as_needed=no
4836 gcc_cv_ld_as_needed=no
4840 if test x"$gcc_cv_ld_as_needed" = xyes; then
4841 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4842 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4843 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4844 [Define to the linker option to ignore unused dependencies.])
4845 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4846 [Define to the linker option to keep unused dependencies.])
4849 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4850 saved_LDFLAGS="$LDFLAGS"
4851 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4852 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4853 AC_LINK_IFELSE([int main(void) {return 0;}],
4854 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4856 LDFLAGS="$saved_LDFLAGS"
4857 if test "x$gcc_cv_ld_clearcap" = xyes; then
4858 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4859 [Define if the linker supports clearing hardware capabilities via mapfile.])
4860 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4862 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4864 case "$target:$tm_file" in
4865 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4868 emul_name="-melf64lppc"
4871 emul_name="-melf64ppc"
4874 emul_name="-melf64ppc_fbsd"
4877 AC_CACHE_CHECK(linker support for omitting dot symbols,
4878 gcc_cv_ld_no_dot_syms,
4879 [gcc_cv_ld_no_dot_syms=no
4880 if test x"$ld_is_gold" = xyes; then
4881 gcc_cv_ld_no_dot_syms=yes
4882 elif test $in_tree_ld = yes ; then
4883 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
4884 gcc_cv_ld_no_dot_syms=yes
4886 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4887 cat > conftest1.s <<EOF
4891 cat > conftest2.s <<EOF
4892 .section ".opd","aw"
4897 .quad .LEfoo,.TOC.@tocbase,0
4903 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4904 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4905 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4906 gcc_cv_ld_no_dot_syms=yes
4908 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4911 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4912 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4913 [Define if your PowerPC64 linker only needs function descriptor syms.])
4916 AC_CACHE_CHECK(linker large toc support,
4917 gcc_cv_ld_large_toc,
4918 [gcc_cv_ld_large_toc=no
4919 if test x"$ld_is_gold" = xyes; then
4920 gcc_cv_ld_large_toc=yes
4921 elif test $in_tree_ld = yes ; then
4922 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
4923 gcc_cv_ld_large_toc=yes
4925 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4926 cat > conftest.s <<EOF
4927 .section ".tbss","awT",@nobits
4933 addis 9,13,ie0@got@tprel@ha
4934 ld 9,ie0@got@tprel@l(9)
4936 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4937 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4938 gcc_cv_ld_large_toc=yes
4940 rm -f conftest conftest.o conftest.s
4943 if test x"$gcc_cv_ld_large_toc" = xyes; then
4944 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4945 [Define if your PowerPC64 linker supports a large TOC.])
4952 AC_CACHE_CHECK(linker large toc support,
4953 gcc_cv_ld_large_toc,
4954 [gcc_cv_ld_large_toc=no
4955 if test x$gcc_cv_as != x ; then
4956 cat > conftest.s <<EOF
4966 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4967 gcc_cv_ld_large_toc=yes
4969 rm -f conftest conftest.o conftest.s
4972 if test x"$gcc_cv_ld_large_toc" = xyes; then
4973 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4974 [Define if your PowerPC64 linker supports a large TOC.])
4979 AC_CACHE_CHECK(linker --build-id support,
4981 [gcc_cv_ld_buildid=no
4982 if test $in_tree_ld = yes ; then
4983 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4984 "$gcc_cv_gld_minor_version" -ge 18 -o \
4985 "$gcc_cv_gld_major_version" -gt 2 \
4986 && test $in_tree_ld_is_elf = yes; then
4987 gcc_cv_ld_buildid=yes
4989 elif test x$gcc_cv_ld != x; then
4990 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4991 gcc_cv_ld_buildid=yes
4994 if test x"$gcc_cv_ld_buildid" = xyes; then
4995 AC_DEFINE(HAVE_LD_BUILDID, 1,
4996 [Define if your linker supports --build-id.])
4999 AC_ARG_ENABLE(linker-build-id,
5000 [AS_HELP_STRING([--enable-linker-build-id],
5001 [compiler will always pass --build-id to linker])],
5003 enable_linker_build_id=no)
5005 if test x"$enable_linker_build_id" = xyes; then
5006 if test x"$gcc_cv_ld_buildid" = xyes; then
5007 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5008 [Define if gcc should always pass --build-id to linker.])
5010 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5014 # In binutils 2.21, GNU ld gained support for new emulations fully
5015 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5016 AC_CACHE_CHECK(linker *_sol2 emulation support,
5017 gcc_cv_ld_sol2_emulation,
5018 [gcc_cv_ld_sol2_emulation=no
5019 if test $in_tree_ld = yes ; then
5020 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5021 "$gcc_cv_gld_minor_version" -ge 21 -o \
5022 "$gcc_cv_gld_major_version" -gt 2 \
5023 && test $in_tree_ld_is_elf = yes; then
5024 gcc_cv_ld_sol2_emulation=yes
5026 elif test x$gcc_cv_ld != x; then
5027 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5028 grep _sol2 > /dev/null; then
5029 gcc_cv_ld_sol2_emulation=yes
5032 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5033 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5034 [Define if your linker supports the *_sol2 emulations.])
5037 AC_CACHE_CHECK(linker --sysroot support,
5039 [gcc_cv_ld_sysroot=no
5040 if test $in_tree_ld = yes ; then
5041 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
5042 gcc_cv_ld_sysroot=yes
5044 elif test x$gcc_cv_ld != x; then
5045 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5046 gcc_cv_ld_sysroot=yes
5049 if test x"$gcc_cv_ld_sysroot" = xyes; then
5050 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5051 [Define if your linker supports --sysroot.])
5054 # Test for stack protector support in target C library.
5055 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5056 gcc_cv_libc_provides_ssp,
5057 [gcc_cv_libc_provides_ssp=no
5059 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5060 # glibc 2.4 and later provides __stack_chk_fail and
5061 # either __stack_chk_guard, or TLS access to stack guard canary.
5062 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5063 [if test -f $target_header_dir/features.h \
5064 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5065 $target_header_dir/features.h > /dev/null; then
5066 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5067 $target_header_dir/features.h > /dev/null && \
5068 test -f $target_header_dir/bits/uClibc_config.h && \
5069 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5070 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5071 gcc_cv_libc_provides_ssp=yes
5073 # all versions of Bionic support stack protector
5074 elif test -f $target_header_dir/sys/cdefs.h \
5075 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5076 $target_header_dir/sys/cdefs.h > /dev/null; then
5077 gcc_cv_libc_provides_ssp=yes
5081 # Avoid complicated tests (see
5082 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5083 # simply assert that glibc does provide this, which is true for all
5084 # realistically usable GNU/Hurd configurations.
5085 gcc_cv_libc_provides_ssp=yes;;
5086 *-*-darwin* | *-*-freebsd*)
5087 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5088 [echo "no __stack_chk_fail on this target"])
5090 *) gcc_cv_libc_provides_ssp=no ;;
5093 if test x$gcc_cv_libc_provides_ssp = xyes; then
5094 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5095 [Define if your target C library provides stack protector support])
5098 # Test for <sys/sdt.h> on the target.
5099 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5100 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5102 if test -f $target_header_dir/sys/sdt.h; then
5104 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5105 [Define if your target C library provides sys/sdt.h])
5107 AC_MSG_RESULT($have_sys_sdt_h)
5109 # Check if TFmode long double should be used by default or not.
5110 # Some glibc targets used DFmode long double, but with glibc 2.4
5111 # and later they can use TFmode.
5113 powerpc*-*-linux* | \
5117 AC_ARG_WITH(long-double-128,
5118 [AS_HELP_STRING([--with-long-double-128],
5119 [use 128-bit long double by default])],
5120 gcc_cv_target_ldbl128="$with_long_double_128",
5121 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5122 [gcc_cv_target_ldbl128=no
5123 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5124 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5125 && gcc_cv_target_ldbl128=yes
5129 if test x$gcc_cv_target_ldbl128 = xyes; then
5130 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5131 [Define if TFmode long double should be the default])
5134 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5135 gcc_cv_target_dl_iterate_phdr=unknown
5137 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5138 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5139 # libdl there, both complicating its use and breaking compatibility
5140 # between Solaris 10 updates.
5141 *-*-solaris2.1[[1-9]]*)
5142 # <link.h> needs both a dl_iterate_phdr declaration and support for
5143 # compilation with largefile support.
5144 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5145 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5146 gcc_cv_target_dl_iterate_phdr=yes
5148 gcc_cv_target_dl_iterate_phdr=no
5151 *-*-dragonfly* | *-*-freebsd*)
5152 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5153 gcc_cv_target_dl_iterate_phdr=yes
5155 gcc_cv_target_dl_iterate_phdr=no
5159 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5160 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5161 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5162 [Define if your target C library provides the `dl_iterate_phdr' function.])
5164 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5166 # We no longer support different GC mechanisms. Emit an error if
5167 # the user configures with --with-gc.
5169 [AS_HELP_STRING([--with-gc={page,zone}],
5170 [this option is not supported anymore. It used to choose
5171 the garbage collection mechanism to use with the compiler])],
5172 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5175 # Libraries to use on the host. This will normally be set by the top
5176 # level Makefile. Here we simply capture the value for our Makefile.
5177 if test -z "${HOST_LIBS+set}"; then
5182 # Use the system's zlib library.
5184 zlibinc="-I\$(srcdir)/../zlib"
5185 AC_ARG_WITH(system-zlib,
5186 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5193 dnl Very limited version of automake's enable-maintainer-mode
5195 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5196 dnl maintainer-mode is disabled by default
5197 AC_ARG_ENABLE(maintainer-mode,
5198 [AS_HELP_STRING([--enable-maintainer-mode],
5199 [enable make rules and dependencies not useful
5200 (and sometimes confusing) to the casual installer])],
5201 maintainer_mode=$enableval,
5204 AC_MSG_RESULT($maintainer_mode)
5206 if test "$maintainer_mode" = "yes"; then
5213 dnl Whether to prevent multiple front-ends from linking at the same time
5215 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5216 AC_ARG_ENABLE(link-mutex,
5217 [AS_HELP_STRING([--enable-link-mutex],
5218 [avoid linking multiple front-ends at once to avoid thrashing
5219 on the build machine])],
5220 do_link_mutex=$enableval,
5222 AC_MSG_RESULT($do_link_mutex)
5224 if test "$do_link_mutex" = "yes"; then
5229 AC_SUBST(DO_LINK_MUTEX)
5235 # Make empty files to contain the specs and options for each language.
5236 # Then add #include lines to for a compiler that has specs and/or options.
5242 # These (without "all_") are set in each config-lang.in.
5243 # `language' must be a single word so is spelled singularly.
5246 all_outputs='Makefile'
5247 # List of language makefile fragments.
5249 # Additional files for gengtype
5250 all_gtfiles="$target_gtfiles"
5252 # These are the languages that are set in --enable-languages,
5253 # and are available in the GCC tree.
5254 all_selected_languages=
5256 # Add the language fragments.
5257 # Languages are added via two mechanisms. Some information must be
5258 # recorded in makefile variables, these are defined in config-lang.in.
5259 # We accumulate them and plug them into the main Makefile.
5260 # The other mechanism is a set of hooks for each of the main targets
5261 # like `clean', `install', etc.
5263 language_hooks="Make-hooks"
5265 for lang in ${srcdir}/*/config-lang.in
5268 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5270 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5271 if test "x$lang_alias" = x
5273 echo "$lang doesn't set \$language." 1>&2
5276 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5277 subdirs="$subdirs $subdir"
5279 # $gcc_subdir is where the gcc integration files are to be found
5280 # for a language, both for internal compiler purposes (compiler
5281 # sources implementing front-end to GCC tree converters), and for
5282 # build infrastructure purposes (Make-lang.in, etc.)
5284 # This will be <subdir> (relative to $srcdir) if a line like
5285 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5286 # is found in <langdir>/config-lang.in, and will remain <langdir>
5289 # Except for the language alias (fetched above), the regular
5290 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5291 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5292 # only this and the language alias.
5294 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5295 if [ "$gcc_subdir" = "" ]; then
5296 gcc_subdir="$subdir"
5299 case ",$enable_languages," in
5301 all_selected_languages="$all_selected_languages $lang_alias"
5302 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5303 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5315 . ${srcdir}/$gcc_subdir/config-lang.in
5316 if test "x$language" = x
5318 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5323 case ",$enable_languages," in
5326 for i in $subdir_requires; do
5327 test -f "${srcdir}/$i/config-lang.in" && continue
5335 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5336 if test -f $srcdir/$gcc_subdir/lang.opt; then
5337 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5338 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5340 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5341 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5343 all_languages="$all_languages $language"
5344 all_compilers="$all_compilers $compilers"
5345 all_outputs="$all_outputs $outputs"
5346 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5347 case ",$enable_languages," in
5349 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5351 AC_SUBST(enable_lto)
5358 for language in $all_selected_languages
5360 check_languages="$check_languages check-$language"
5363 # We link each language in with a set of hooks, reached indirectly via
5364 # lang.${target}. Only do so for selected languages.
5368 target_list="all.cross start.encap rest.encap tags \
5369 install-common install-man install-info install-pdf install-html dvi \
5370 pdf html uninstall info man srcextra srcman srcinfo \
5371 mostlyclean clean distclean maintainer-clean install-plugin"
5373 for t in $target_list
5376 for lang in $all_selected_languages
5380 echo "lang.$t: $x" >> Make-hooks
5384 # Option include files
5387 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5388 option_includes="option-includes.mk"
5389 AC_SUBST_FILE(option_includes)
5397 echo "dir ." > .gdbinit
5398 echo "dir ${srcdir}" >> .gdbinit
5399 if test x$gdb_needs_out_file_path = xyes
5401 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5403 if test "x$subdirs" != x; then
5406 echo "dir ${srcdir}/$s" >> .gdbinit
5409 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5410 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5412 # Put a breakpoint on __asan_report_error to help with debugging buffer
5415 *-fsanitize=address*)
5416 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5420 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5421 AC_SUBST(gcc_tooldir)
5424 # Find a directory in which to install a shared libgcc.
5426 AC_ARG_ENABLE(version-specific-runtime-libs,
5427 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5428 [specify that runtime libraries should be
5429 installed in a compiler-specific directory])])
5431 # Substitute configuration variables
5434 AC_SUBST(all_compilers)
5435 AC_SUBST(all_gtfiles)
5436 AC_SUBST(all_lang_makefrags)
5437 AC_SUBST(all_languages)
5438 AC_SUBST(all_selected_languages)
5439 AC_SUBST(build_exeext)
5440 AC_SUBST(build_install_headers_dir)
5441 AC_SUBST(build_xm_file_list)
5442 AC_SUBST(build_xm_include_list)
5443 AC_SUBST(build_xm_defines)
5444 AC_SUBST(build_file_translate)
5445 AC_SUBST(check_languages)
5446 AC_SUBST(cpp_install_dir)
5447 AC_SUBST(xmake_file)
5448 AC_SUBST(tmake_file)
5449 AC_SUBST(TM_ENDIAN_CONFIG)
5450 AC_SUBST(TM_MULTILIB_CONFIG)
5451 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5452 AC_SUBST(extra_gcc_objs)
5453 AC_SUBST(user_headers_inc_next_pre)
5454 AC_SUBST(user_headers_inc_next_post)
5455 AC_SUBST(extra_headers_list)
5456 AC_SUBST(extra_objs)
5457 AC_SUBST(extra_programs)
5458 AC_SUBST(float_h_file)
5459 AC_SUBST(gcc_config_arguments)
5460 AC_SUBST(gcc_gxx_include_dir)
5461 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5462 AC_SUBST(host_exeext)
5463 AC_SUBST(host_xm_file_list)
5464 AC_SUBST(host_xm_include_list)
5465 AC_SUBST(host_xm_defines)
5466 AC_SUBST(out_host_hook_obj)
5468 AC_SUBST(lang_opt_files)
5469 AC_SUBST(lang_specs_files)
5470 AC_SUBST(lang_tree_files)
5471 AC_SUBST(local_prefix)
5473 AC_SUBST(objc_boehm_gc)
5475 AC_SUBST(out_object_file)
5476 AC_SUBST(common_out_file)
5477 AC_SUBST(common_out_object_file)
5478 AC_SUBST(tm_file_list)
5479 AC_SUBST(tm_include_list)
5480 AC_SUBST(tm_defines)
5481 AC_SUBST(tm_p_file_list)
5482 AC_SUBST(tm_p_include_list)
5483 AC_SUBST(xm_file_list)
5484 AC_SUBST(xm_include_list)
5485 AC_SUBST(xm_defines)
5486 AC_SUBST(use_gcc_stdint)
5487 AC_SUBST(c_target_objs)
5488 AC_SUBST(cxx_target_objs)
5489 AC_SUBST(fortran_target_objs)
5490 AC_SUBST(target_cpu_default)
5492 AC_SUBST_FILE(language_hooks)
5495 if test x${build} = x${host} ; then
5496 if test x${host} = x${target} ; then
5497 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5499 echo "Links are now set up to build a cross-compiler" 1>&2
5500 echo " from ${host} to ${target}." 1>&2
5503 if test x${host} = x${target} ; then
5504 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5505 echo " for ${target}." 1>&2
5507 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5508 echo " from ${host} to ${target}." 1>&2
5512 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5513 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5515 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5516 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5517 if test "x${ISLLIBS}" != "x" ; then
5518 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5521 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5522 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5523 if test "x${CLOOGLIBS}" != "x" ; then
5524 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5527 # Check for plugin support
5528 AC_ARG_ENABLE(plugin,
5529 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5530 enable_plugin=$enableval,
5531 enable_plugin=yes; default_plugin=yes)
5537 if test x$build = x$host; then
5538 export_sym_check="nm${exeext} -g"
5539 elif test x$host = x$target; then
5540 export_sym_check="$gcc_cv_nm -g"
5546 if test x$build = x$host; then
5547 export_sym_check="objdump${exeext} -T"
5548 elif test x$host = x$target; then
5549 export_sym_check="$gcc_cv_objdump -T"
5556 if test x"$enable_plugin" = x"yes"; then
5558 AC_MSG_CHECKING([for exported symbols])
5559 if test "x$export_sym_check" != x; then
5560 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5561 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5562 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5563 : # No need to use a flag
5564 AC_MSG_RESULT([yes])
5566 AC_MSG_RESULT([yes])
5567 AC_MSG_CHECKING([for -rdynamic])
5568 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5569 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5571 pluginlibs="-rdynamic"
5576 AC_MSG_RESULT([$plugin_rdynamic])
5579 AC_MSG_RESULT([unable to check])
5584 AC_SEARCH_LIBS([dlopen], [dl])
5585 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5586 pluginlibs="$pluginlibs -ldl"
5590 # Check that we can build shared objects with -fPIC -shared
5591 saved_LDFLAGS="$LDFLAGS"
5592 saved_CFLAGS="$CFLAGS"
5595 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5596 CFLAGS="$CFLAGS -fPIC"
5597 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5600 CFLAGS="$CFLAGS -fPIC"
5601 LDFLAGS="$LDFLAGS -fPIC -shared"
5604 AC_MSG_CHECKING([for -fPIC -shared])
5606 [extern int X;],[return X == 0;],
5607 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5608 [AC_MSG_RESULT([no]); have_pic_shared=no])
5609 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5613 LDFLAGS="$saved_LDFLAGS"
5614 CFLAGS="$saved_CFLAGS"
5616 # If plugin support had been requested but not available, fail.
5617 if test x"$enable_plugin" = x"no" ; then
5618 if test x"$default_plugin" != x"yes"; then
5620 Building GCC with plugin support requires a host that supports
5621 -fPIC, -shared, -ldl and -rdynamic.])
5626 AC_SUBST(pluginlibs)
5627 AC_SUBST(enable_plugin)
5628 if test x"$enable_plugin" = x"yes"; then
5629 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5633 # Enable --enable-host-shared
5634 AC_ARG_ENABLE(host-shared,
5635 [AS_HELP_STRING([--enable-host-shared],
5636 [build host code as shared libraries])],
5637 [PICFLAG=-fPIC], [PICFLAG=])
5638 AC_SUBST(enable_host_shared)
5642 AC_ARG_ENABLE(libquadmath-support,
5643 [AS_HELP_STRING([--disable-libquadmath-support],
5644 [disable libquadmath support for Fortran])],
5645 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5646 ENABLE_LIBQUADMATH_SUPPORT=yes)
5647 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5648 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5649 [Define to 1 to enable libquadmath support])
5653 # Specify what hash style to use by default.
5654 AC_ARG_WITH([linker-hash-style],
5655 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5656 [specify the linker hash style])],
5657 [case x"$withval" in
5659 LINKER_HASH_STYLE=sysv
5662 LINKER_HASH_STYLE=gnu
5665 LINKER_HASH_STYLE=both
5668 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5671 [LINKER_HASH_STYLE=''])
5672 if test x"${LINKER_HASH_STYLE}" != x; then
5673 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5674 [The linker hash style])
5677 # Configure the subdirectories
5678 # AC_CONFIG_SUBDIRS($subdirs)
5680 # Create the Makefile
5681 # and configure language subdirectories
5682 AC_CONFIG_FILES($all_outputs)
5684 AC_CONFIG_COMMANDS([default],
5686 case ${CONFIG_HEADERS} in
5687 *auto-host.h:config.in*)
5690 # Make sure all the subdirs exist.
5691 for d in $subdirs doc build common c-family
5693 test -d $d || mkdir $d
5696 [subdirs='$subdirs'])