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 AC_ARG_WITH([runtime-root-prefix],
813 [ --with-runtime-root-prefix=prefix
814 prepend prefix to paths used by the compiler to
815 name the dynamic linker and other files used at
816 runtime. Defaults to empty (no prefix).],
818 case ${with_runtime_root_prefix} in
819 yes|no) AC_MSG_ERROR([bad value ${withval} given for runtime root prefix]) ;;
821 *) AC_MSG_ERROR([${withval} should be an absolute directory]) ;;
823 RUNTIME_ROOT_PREFIX_DEFINE="-DRUNTIME_ROOT_PREFIX=\\\"${withval}\\\""
824 ], [RUNTIME_ROOT_PREFIX_DEFINE=""])
825 AC_SUBST(RUNTIME_ROOT_PREFIX_DEFINE)
827 if test "x$prefix" = xNONE; then
828 test_prefix=/usr/local
832 if test "x$exec_prefix" = xNONE; then
833 test_exec_prefix=$test_prefix
835 test_exec_prefix=$exec_prefix
839 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
840 [search for usr/lib, usr/include, et al, within DIR])],
842 case ${with_sysroot} in
843 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
844 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
847 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
848 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
850 case ${TARGET_SYSTEM_ROOT} in
851 "${test_prefix}"|"${test_prefix}/"*|\
852 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
853 '${prefix}'|'${prefix}/'*|\
854 '${exec_prefix}'|'${exec_prefix}/'*)
855 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
856 TARGET_SYSTEM_ROOT_DEFINE="$t"
861 TARGET_SYSTEM_ROOT_DEFINE=
862 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
864 AC_SUBST(TARGET_SYSTEM_ROOT)
865 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
866 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
869 [AS_HELP_STRING([--with-specs=SPECS],
870 [add SPECS to driver command-line processing])],
871 [CONFIGURE_SPECS=$withval],
874 AC_SUBST(CONFIGURE_SPECS)
876 ACX_PKGVERSION([GCC])
877 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
879 # Sanity check enable_languages in case someone does not run the toplevel
880 # configure # script.
881 AC_ARG_ENABLE(languages,
882 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
883 [case ,${enable_languages}, in
885 # go safe -- we cannot be much sure without the toplevel
887 # analysis of which target libs are present and usable
891 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
896 enable_languages=c,${enable_languages}
899 [enable_languages=c])
901 AC_ARG_WITH(multilib-list,
902 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
904 with_multilib_list=default)
906 # -------------------------
907 # Checks for other programs
908 # -------------------------
912 # Find some useful tools
914 # We need awk to create options.c and options.h.
915 # Bail out if it's missing.
917 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
924 AC_SUBST(ranlib_flags)
928 # See if cmp has --ignore-initial.
929 gcc_AC_PROG_CMP_IGNORE_INITIAL
931 # See if we have the mktemp command.
932 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
934 # See if makeinfo has been installed and is modern enough
935 # that we can use it.
936 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
937 [GNU texinfo.* \([0-9][0-9.]*\)],
938 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
939 if test $gcc_cv_prog_makeinfo_modern = no; then
941 *** Makeinfo is missing or too old.
942 *** Info documentation will not be built.])
949 # Is pod2man recent enough to regenerate manpages?
950 AC_MSG_CHECKING([for recent Pod::Man])
951 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
953 GENERATED_MANPAGES=generated-manpages
958 AC_SUBST(GENERATED_MANPAGES)
960 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
963 dnl Don't use AC_PROG_LEX; we insist on flex.
964 dnl LEXLIB is not useful in gcc.
965 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
968 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
970 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
971 # check for build == host before using them.
974 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
975 && test -d ../binutils ; then
976 NM='${objdir}/../binutils/nm-new'
978 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
982 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
983 && test -d ../binutils ; then
984 AR='${objdir}/../binutils/ar'
986 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
990 # --------------------
991 # Checks for C headers
992 # --------------------
994 # Need to reject headers which give warnings, so that the -Werror bootstrap
995 # works later. *sigh* This needs to come before all header checks.
1002 AC_HEADER_TIOCGWINSZ
1003 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1004 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
1005 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1006 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1008 # Check for thread headers.
1009 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1010 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1012 # These tests can't be done till we know if we have limits.h.
1016 # ----------------------
1017 # Checks for C++ headers
1018 # ----------------------
1020 dnl Autoconf will give an error in the configure script if there is no
1021 dnl C++ preprocessor. Hack to prevent that.
1022 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1024 m4_popdef([AC_MSG_ERROR])[]dnl
1028 AC_CHECK_HEADERS(unordered_map)
1029 AC_CHECK_HEADERS(tr1/unordered_map)
1030 AC_CHECK_HEADERS(ext/hash_map)
1035 # Dependency checking.
1040 AC_CONFIG_COMMANDS([gccdepdir],[
1041 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1042 for lang in $subdirs c-family common
1044 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1045 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1047 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1055 # These libraries may be used by collect2.
1056 # We may need a special search path to get them linked.
1057 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1059 for libs in '' -lld -lmld \
1060 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1061 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1064 AC_TRY_LINK_FUNC(ldopen,
1065 [gcc_cv_collect2_libs="$libs"; break])
1068 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1069 case $gcc_cv_collect2_libs in
1071 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1073 AC_SUBST(COLLECT2_LIBS)
1075 # When building Ada code on Alpha, we need exc_resume which is usually in
1076 # -lexc. So test for it.
1079 AC_SEARCH_LIBS(exc_resume, exc)
1082 AC_SUBST(GNAT_LIBEXC)
1084 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1087 AC_SEARCH_LIBS(kstat_open, kstat)
1088 EXTRA_GCC_LIBS="$LIBS"
1090 AC_SUBST(EXTRA_GCC_LIBS)
1092 # Some systems put ldexp and frexp in libm instead of libc; assume
1093 # they're both in the same place. jcf-dump needs them.
1096 AC_SEARCH_LIBS(ldexp, m)
1101 # Use <inttypes.h> only if it exists,
1102 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1104 AC_MSG_CHECKING(for inttypes.h)
1105 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1106 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1107 [[#define __STDC_FORMAT_MACROS
1108 #include <sys/types.h>
1109 #include <inttypes.h>]],
1114 [gcc_cv_header_inttypes_h=yes],
1115 [gcc_cv_header_inttypes_h=no])])
1116 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1117 if test $gcc_cv_header_inttypes_h = yes; then
1118 AC_DEFINE(HAVE_INTTYPES_H, 1,
1119 [Define if you have a working <inttypes.h> header file.])
1122 dnl Disabled until we have a complete test for buggy enum bitfields.
1123 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1125 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1126 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1127 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1128 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1129 putchar_unlocked putc_unlocked)
1130 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1131 popen sysconf strsignal getrusage nl_langinfo \
1132 gettimeofday mbstowcs wcswidth mmap setlocale \
1133 gcc_UNLOCKED_FUNCS madvise)
1135 if test x$ac_cv_func_mbstowcs = xyes; then
1136 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1137 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1143 [gcc_cv_func_mbstowcs_works=yes],
1144 [gcc_cv_func_mbstowcs_works=no],
1145 [gcc_cv_func_mbstowcs_works=yes])])
1146 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1147 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1148 [Define this macro if mbstowcs does not crash when its
1149 first argument is NULL.])
1153 AC_CHECK_TYPE(ssize_t, int)
1154 AC_CHECK_TYPE(caddr_t, char *)
1156 GCC_AC_FUNC_MMAP_BLACKLIST
1160 # Under VMS, vfork works very differently than on Unix. The standard test
1161 # won't work, and it isn't easily adaptable. It makes more sense to
1163 ac_cv_func_vfork_works=yes
1168 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1169 # iconv() prototype.
1174 # Until we have in-tree GNU iconv:
1176 AC_SUBST(LIBICONV_DEP)
1182 # We will need to find libiberty.h and ansidecl.h
1183 saved_CFLAGS="$CFLAGS"
1184 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1185 saved_CXXFLAGS="$CXXFLAGS"
1186 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1187 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1188 stpcpy strnlen strsignal strstr strverscmp \
1189 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1190 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1191 #include "ansidecl.h"
1192 #include "system.h"])
1194 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1195 #include "ansidecl.h"
1197 #ifdef HAVE_SYS_RESOURCE_H
1198 #include <sys/resource.h>
1202 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1203 #include "ansidecl.h"
1205 #ifdef HAVE_SYS_RESOURCE_H
1206 #include <sys/resource.h>
1208 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1209 [Define to `long' if <sys/resource.h> doesn't define.])])
1211 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1212 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1213 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1214 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1215 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1216 #include "ansidecl.h"
1225 gcc_AC_CHECK_DECLS(times, , ,[
1226 #include "ansidecl.h"
1228 #ifdef HAVE_SYS_TIMES_H
1229 #include <sys/times.h>
1233 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1234 #include "ansidecl.h"
1239 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1242 gcc_AC_CHECK_DECLS(madvise, , ,[
1243 #include "ansidecl.h"
1248 # More time-related stuff.
1249 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1250 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1251 #include "ansidecl.h"
1253 #ifdef HAVE_SYS_TIMES_H
1254 #include <sys/times.h>
1256 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1257 if test $ac_cv_struct_tms = yes; then
1258 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1259 [Define if <sys/times.h> defines struct tms.])
1262 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1263 # revisit after autoconf 2.50.
1264 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1265 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1266 #include "ansidecl.h"
1268 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1269 if test $gcc_cv_type_clock_t = yes; then
1270 AC_DEFINE(HAVE_CLOCK_T, 1,
1271 [Define if <time.h> defines clock_t.])
1274 # Check if F_SETLKW is supported by fcntl.
1275 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1276 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1277 #include <fcntl.h>]], [[
1283 return fcntl (1, F_SETLKW, &fl);]])],
1284 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1285 if test $ac_cv_f_setlkw = yes; then
1286 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1287 [Define if F_SETLKW supported by fcntl.])
1290 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1291 CFLAGS="$saved_CFLAGS"
1292 CXXFLAGS="$saved_CXXFLAGS"
1294 # mkdir takes a single argument on some systems.
1295 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1303 # With Setjmp/Longjmp based exception handling.
1304 AC_ARG_ENABLE(sjlj-exceptions,
1305 [AS_HELP_STRING([--enable-sjlj-exceptions],
1306 [arrange to use setjmp/longjmp exception handling])],
1309 if test $enableval != yes; then
1310 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1315 force_sjlj_exceptions=yes],
1318 force_sjlj_exceptions=yes
1322 force_sjlj_exceptions=yes
1326 force_sjlj_exceptions=no
1329 if test $force_sjlj_exceptions = yes; then
1330 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1331 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1332 [Define 0/1 to force the choice for exception handling model.])
1335 # --------------------------------------------------------
1336 # Build, host, and target specific configuration fragments
1337 # --------------------------------------------------------
1339 # Collect build-machine-specific information.
1340 . ${srcdir}/config.build
1342 # Collect host-machine-specific information.
1343 . ${srcdir}/config.host
1347 # Collect target-machine-specific information.
1348 . ${srcdir}/config.gcc
1350 extra_objs="${host_extra_objs} ${extra_objs}"
1351 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1353 # Default the target-machine variables that were not explicitly set.
1354 if test x"$tm_file" = x
1355 then tm_file=$cpu_type/$cpu_type.h; fi
1357 if test x"$extra_headers" = x
1358 then extra_headers=; fi
1360 if test x$md_file = x
1361 then md_file=$cpu_type/$cpu_type.md; fi
1363 if test x$out_file = x
1364 then out_file=$cpu_type/$cpu_type.c; fi
1366 if test x"$tmake_file" = x
1367 then tmake_file=$cpu_type/t-$cpu_type
1370 # Support --enable-initfini-array.
1371 if test x$enable_initfini_array != xno; then
1372 tm_file="${tm_file} initfini-array.h"
1375 if test x"$dwarf2" = xyes
1376 then tm_file="$tm_file tm-dwarf2.h"
1379 # Say what files are being used for the output code and MD file.
1380 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1381 echo "Using \`$srcdir/config/$md_file' as machine description file."
1383 # If any of the xm_file variables contain nonexistent files, warn
1384 # about them and drop them.
1387 for x in $build_xm_file; do
1388 if test -f $srcdir/config/$x
1390 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1396 for x in $host_xm_file; do
1397 if test -f $srcdir/config/$x
1399 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1405 for x in $xm_file; do
1406 if test -f $srcdir/config/$x
1408 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1414 for f in $tm_file; do
1417 if test $count = ax; then
1418 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1420 echo "Using the following target machine macro files:"
1421 for f in $tm_file; do
1422 echo " $srcdir/config/$f"
1426 if test x$use_long_long_for_widest_fast_int = xyes; then
1427 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1428 [Define to 1 if the 'long long' type is wider than 'long' but still
1429 efficiently supported by the host hardware.])
1432 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1433 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1435 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1436 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1439 for f in $host_xm_file; do
1442 if test $count = a; then
1444 elif test $count = ax; then
1445 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1447 echo "Using the following host machine macro files:"
1448 for f in $host_xm_file; do
1449 echo " $srcdir/config/$f"
1452 echo "Using ${out_host_hook_obj} for host machine hooks."
1454 if test "$host_xm_file" != "$build_xm_file"; then
1456 for f in $build_xm_file; do
1459 if test $count = a; then
1461 elif test $count = ax; then
1462 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1464 echo "Using the following build machine macro files:"
1465 for f in $build_xm_file; do
1466 echo " $srcdir/config/$f"
1471 if test -n "$configured_native_system_header_dir"; then
1472 native_system_header_dir=$configured_native_system_header_dir
1474 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1475 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1479 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1480 gcc_cv_mcontext_underscores,
1482 #include <sys/cdefs.h>
1483 #include <sys/signal.h>
1484 #include <ucontext.h>
1485 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1487 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1488 if test $gcc_cv_mcontext_underscores = yes; then
1489 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1490 [mcontext_t fields start with __])
1499 # Check if a valid thread package
1500 case ${enable_threads} in
1503 target_thread_file='single'
1507 target_thread_file='single'
1509 aix | dce | lynx | mipssde | posix | rtems | \
1510 single | tpf | vxworks | win32)
1511 target_thread_file=${enable_threads}
1514 echo "${enable_threads} is an unknown thread package" 1>&2
1519 if test x${thread_file} = x; then
1520 # No thread file set by target-specific clauses in config.gcc,
1521 # so use file chosen by default logic above
1522 thread_file=${target_thread_file}
1530 if test x$enable___cxa_atexit = xyes || \
1531 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1532 if test x$host = x$target; then
1534 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1535 # keyed to flag_use_cxa_atexit
1543 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1544 [echo "__cxa_atexit can't be enabled on this target"])
1548 # We can't check for __cxa_atexit when building a cross, so assume
1552 if test x$use_cxa_atexit = xyes; then
1553 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1554 [Define if you want to use __cxa_atexit, rather than atexit, to
1555 register C++ destructors for local statics and global objects.
1556 This is essential for fully standards-compliant handling of
1557 destructors, but requires __cxa_atexit in libc.])
1561 # Look for a file containing extra machine modes.
1562 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1563 extra_modes_file='$(srcdir)'/config/${extra_modes}
1564 AC_SUBST(extra_modes_file)
1565 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1566 [Define to the name of a file containing a list of extra machine modes
1567 for this architecture.])
1570 # Convert extra_options into a form suitable for Makefile use.
1573 for f in $extra_options; do
1574 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1575 all_opt_files="$all_opt_files $srcdir/config/$f"
1577 AC_SUBST(extra_opt_files)
1579 # auto-host.h is the file containing items generated by autoconf and is
1580 # the first file included by config.h.
1581 # If host=build, it is correct to have bconfig include auto-host.h
1582 # as well. If host!=build, we are in error and need to do more
1583 # work to find out the build config parameters.
1584 if test x$host = x$build
1586 build_auto=auto-host.h
1588 # We create a subdir, then run autoconf in the subdir.
1589 # To prevent recursion we set host and build for the new
1590 # invocation of configure to the build for this invocation
1597 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1598 *) realsrcdir=../${srcdir};;
1600 # Clearing GMPINC is necessary to prevent host headers being
1601 # used by the build compiler. Defining GENERATOR_FILE stops
1602 # system.h from including gmp.h.
1603 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1604 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1605 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1606 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1607 ${realsrcdir}/configure \
1608 --enable-languages=${enable_languages-all} \
1609 --target=$target_alias --host=$build_alias --build=$build_alias
1611 # We just finished tests for the build machine, so rename
1612 # the file auto-build.h in the gcc directory.
1613 mv auto-host.h ../auto-build.h
1616 build_auto=auto-build.h
1618 AC_SUBST(build_subdir)
1620 tm_file="${tm_file} defaults.h"
1621 tm_p_file="${tm_p_file} tm-preds.h"
1622 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1623 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1624 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1625 # put this back in temporarily.
1626 xm_file="auto-host.h ansidecl.h ${xm_file}"
1633 # Compile in configure arguments.
1634 if test -f configargs.h ; then
1635 # Being re-configured.
1636 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1637 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1639 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1642 # Double all backslashes and backslash all quotes to turn
1643 # gcc_config_arguments into a C string.
1644 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1645 $gcc_config_arguments
1647 gcc_config_arguments_str=`cat conftest.out`
1650 cat > configargs.h <<EOF
1651 /* Generated automatically. */
1652 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1653 static const char thread_model[] = "$thread_file";
1655 static const struct {
1656 const char *name, *value;
1657 } configure_default_options[] = $configure_default_options;
1662 gcc_BASEVER=`cat $srcdir/BASE-VER`
1663 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1664 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1665 if test -f $srcdir/REVISION ; then
1666 gcc_REVISION=`cat $srcdir/REVISION`
1670 cat > plugin-version.h <<EOF
1671 #include "configargs.h"
1673 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1674 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1675 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1676 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1678 static char basever[] = "$gcc_BASEVER";
1679 static char datestamp[] = "$gcc_DATESTAMP";
1680 static char devphase[] = "$gcc_DEVPHASE";
1681 static char revision[] = "$gcc_REVISION";
1683 /* FIXME plugins: We should make the version information more precise.
1684 One way to do is to add a checksum. */
1686 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1688 configuration_arguments};
1692 # Internationalization
1693 ZW_GNU_GETTEXT_SISTER_DIR
1695 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1696 # -liconv on the link line twice.
1697 case "$LIBINTL" in *$LIBICONV*)
1701 AC_ARG_ENABLE(secureplt,
1702 [AS_HELP_STRING([--enable-secureplt],
1703 [enable -msecure-plt by default for PowerPC])],
1706 AC_ARG_ENABLE(leading-mingw64-underscores,
1707 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1708 [enable leading underscores on 64 bit mingw targets]),
1710 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1711 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1712 [Define if we should use leading underscore on 64 bit mingw targets])])
1715 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1718 AC_ARG_ENABLE(frame-pointer,
1719 [AS_HELP_STRING([--enable-frame-pointer],
1720 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1723 linux* | darwin[[8912]]*)
1724 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1726 enable_frame_pointer=no
1729 enable_frame_pointer=yes
1734 # Windows32 Registry support for specifying GCC installation paths.
1735 AC_ARG_ENABLE(win32-registry,
1736 [AS_HELP_STRING([--disable-win32-registry],
1737 [disable lookup of installation paths in the
1738 Registry on Windows hosts])
1739 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1740 AS_HELP_STRING([--enable-win32-registry=KEY],
1741 [use KEY instead of GCC version as the last portion
1742 of the registry key])],,)
1745 win32 | pe | cygwin* | mingw32* | uwin*)
1746 if test "x$enable_win32_registry" != xno; then
1747 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1750 if test "x$enable_win32_registry" != xno; then
1751 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1752 [Define to 1 if installation paths should be looked up in the Windows
1753 Registry. Ignored on non-Windows hosts.])
1755 if test "x$enable_win32_registry" != xyes \
1756 && test "x$enable_win32_registry" != x; then
1757 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1758 [Define to be the last component of the Windows registry key under which
1759 to look for installation paths. The full key used will be
1760 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1761 The default is the GCC version number.])
1767 # Get an absolute path to the GCC top-level source directory
1768 holddir=`${PWDCMD-pwd}`
1770 topdir=`${PWDCMD-pwd}`
1773 # Conditionalize the makefile for this host machine.
1775 for f in ${host_xmake_file}
1777 if test -f ${srcdir}/config/$f
1779 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1783 # Conditionalize the makefile for this target machine.
1785 for f in ${tmake_file}
1787 if test -f ${srcdir}/config/$f
1789 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1792 tmake_file="${tmake_file_}"
1794 out_object_file=`basename $out_file .c`.o
1795 common_out_object_file=`basename $common_out_file .c`.o
1797 tm_file_list="options.h"
1798 tm_include_list="options.h insn-constants.h"
1799 for f in $tm_file; do
1802 f=`echo $f | sed 's/^..//'`
1803 tm_file_list="${tm_file_list} $f"
1804 tm_include_list="${tm_include_list} $f"
1807 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1808 tm_include_list="${tm_include_list} $f"
1811 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1812 tm_include_list="${tm_include_list} config/$f"
1819 for f in $tm_p_file; do
1822 tm_p_file_list="${tm_p_file_list} $f"
1823 tm_p_include_list="${tm_p_include_list} $f"
1826 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1827 tm_p_include_list="${tm_p_include_list} config/$f"
1833 for f in $xm_file; do
1836 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1837 xm_include_list="${xm_include_list} $f"
1840 xm_file_list="${xm_file_list} $f"
1841 xm_include_list="${xm_include_list} $f"
1844 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1845 xm_include_list="${xm_include_list} config/$f"
1851 host_xm_include_list=
1852 for f in $host_xm_file; do
1855 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1856 host_xm_include_list="${host_xm_include_list} $f"
1859 host_xm_file_list="${host_xm_file_list} $f"
1860 host_xm_include_list="${host_xm_include_list} $f"
1863 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1864 host_xm_include_list="${host_xm_include_list} config/$f"
1870 for f in $build_xm_file; do
1873 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1874 build_xm_include_list="${build_xm_include_list} $f"
1876 auto-build.h | auto-host.h )
1877 build_xm_file_list="${build_xm_file_list} $f"
1878 build_xm_include_list="${build_xm_include_list} $f"
1881 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1882 build_xm_include_list="${build_xm_include_list} config/$f"
1887 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1888 # cross-compiler which does not use the native headers and libraries.
1889 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1890 CROSS= AC_SUBST(CROSS)
1891 ALL=all.internal AC_SUBST(ALL)
1892 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1894 if test "x$with_build_sysroot" != x; then
1895 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1897 # This value is used, even on a native system, because
1898 # CROSS_SYSTEM_HEADER_DIR is just
1899 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1900 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1903 if test x$host != x$target
1905 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1907 SYSTEM_HEADER_DIR=$build_system_header_dir
1908 case "$host","$target" in
1909 # Darwin crosses can use the host system's libraries and headers,
1910 # because of the fat library support. Of course, it must be the
1911 # same version of Darwin on both sides. Allow the user to
1912 # just say --target=foo-darwin without a version number to mean
1913 # "the version on this system".
1914 *-*-darwin*,*-*-darwin*)
1915 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1916 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1917 if test $hostos = $targetos -o $targetos = darwin ; then
1919 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1924 i?86-*-*,x86_64-*-* \
1925 | powerpc*-*-*,powerpc64*-*-*)
1926 CROSS="$CROSS -DNATIVE_CROSS" ;;
1931 if test "x$with_headers" = x; then
1938 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1939 SYSTEM_HEADER_DIR=$build_system_header_dir
1942 # If this is a cross-compiler that does not
1943 # have its own set of headers then define
1946 # If this is using newlib, without having the headers available now,
1947 # then define inhibit_libc in LIBGCC2_CFLAGS.
1948 # This prevents libgcc2 from containing any code which requires libc
1950 : ${inhibit_libc=false}
1951 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1952 test x$with_newlib = xyes ; } &&
1953 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1956 AC_SUBST(inhibit_libc)
1958 # When building gcc with a cross-compiler, we need to adjust things so
1959 # that the generator programs are still built with the native compiler.
1960 # Also, we cannot run fixincludes.
1962 # These are the normal (build=host) settings:
1963 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1964 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1965 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1966 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1967 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1968 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1970 # And these apply if build != host, or we are generating coverage data
1971 if test x$build != x$host || test "x$coverage_flags" != x
1973 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1974 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1975 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1978 # Expand extra_headers to include complete path.
1979 # This substitutes for lots of t-* files.
1981 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1982 for file in ${extra_headers} ; do
1983 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1986 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1987 if test x"$use_gcc_tgmath" = xyes
1988 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1991 # Define collect2 in Makefile.
1992 case $host_can_use_collect2 in
1994 *) collect2='collect2$(exeext)' ;;
1996 AC_SUBST([collect2])
1998 # Add a definition of USE_COLLECT2 if system wants one.
1999 case $use_collect2 in
2000 no) use_collect2= ;;
2003 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2004 xm_defines="${xm_defines} USE_COLLECT2"
2005 case $host_can_use_collect2 in
2007 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2013 AC_DEFINE_UNQUOTED(FRPLUGINSONAME,"${host_function_reordering_plugin_soname}",
2014 [Define to the name of the function reordering plugin DSO that must be
2015 passed to the linker's -plugin=LIB option.])
2017 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2018 [Define to the name of the LTO plugin DSO that must be
2019 passed to the linker's -plugin=LIB option.])
2021 # ---------------------------
2022 # Assembler & linker features
2023 # ---------------------------
2025 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2026 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2027 # However when ld-new is first executed from the build tree, libtool will
2028 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2029 # to the build tree. While doing this we need to use the previous-stage
2030 # linker, or we have an infinite loop. The presence of a shell script as
2031 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2032 # the gcc/collect-ld script. So we need to know how libtool works, or
2033 # exec-tool will fail.
2035 m4_defun([_LT_CONFIG_COMMANDS], [])
2038 AC_SUBST(enable_fast_install)
2040 # Identify the assembler which will work hand-in-glove with the newly
2041 # built GCC, so that we can examine its features. This is the assembler
2042 # which will be driven by the driver program.
2044 # If build != host, and we aren't building gas in-tree, we identify a
2045 # build->target assembler and hope that it will have the same features
2046 # as the host->target assembler we'll be using.
2047 gcc_cv_gas_major_version=
2048 gcc_cv_gas_minor_version=
2049 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2051 m4_pattern_allow([AS_FOR_TARGET])dnl
2052 AS_VAR_SET_IF(gcc_cv_as,, [
2053 if test -x "$DEFAULT_ASSEMBLER"; then
2054 gcc_cv_as="$DEFAULT_ASSEMBLER"
2055 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2056 && test -f ../gas/Makefile \
2057 && test x$build = x$host; then
2058 gcc_cv_as=../gas/as-new$build_exeext
2059 elif test -x as$build_exeext; then
2060 # Build using assembler in the current directory.
2061 gcc_cv_as=./as$build_exeext
2062 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2063 gcc_cv_as="$AS_FOR_TARGET"
2065 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2068 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2069 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2070 case "$ORIGINAL_AS_FOR_TARGET" in
2071 ./as | ./as$build_exeext) ;;
2072 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2075 AC_MSG_CHECKING(what assembler to use)
2076 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2077 # Single tree build which includes gas. We want to prefer it
2078 # over whatever linker top-level may have detected, since
2079 # we'll use what we're building after installation anyway.
2080 AC_MSG_RESULT(newly built gas)
2082 _gcc_COMPUTE_GAS_VERSION
2083 in_tree_gas_is_elf=no
2084 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2085 || (grep 'obj_format = multi' ../gas/Makefile \
2086 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2088 in_tree_gas_is_elf=yes
2091 AC_MSG_RESULT($gcc_cv_as)
2097 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2098 [case "${enableval}" in
2105 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2106 [case "${enableval}" in
2108 install_gold_as_default=yes
2111 if test x${default_ld} != x; then
2112 install_gold_as_default=yes
2118 AC_MSG_ERROR([invalid --enable-gold argument])
2121 [install_gold_as_default=no])
2123 # Identify the linker which will work hand-in-glove with the newly
2124 # built GCC, so that we can examine its features. This is the linker
2125 # which will be driven by the driver program.
2127 # If build != host, and we aren't building gas in-tree, we identify a
2128 # build->target linker and hope that it will have the same features
2129 # as the host->target linker we'll be using.
2130 gcc_cv_gld_major_version=
2131 gcc_cv_gld_minor_version=
2132 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2133 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2134 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2136 AS_VAR_SET_IF(gcc_cv_ld,, [
2137 if test -x "$DEFAULT_LINKER"; then
2138 gcc_cv_ld="$DEFAULT_LINKER"
2139 elif test $install_gold_as_default = yes \
2140 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2141 && test -f ../gold/Makefile \
2142 && test x$build = x$host; then
2143 gcc_cv_ld=../gold/ld-new$build_exeext
2144 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2145 && test -f ../ld/Makefile \
2146 && test x$build = x$host; then
2147 gcc_cv_ld=../ld/ld-new$build_exeext
2148 elif test -x collect-ld$build_exeext; then
2149 # Build using linker in the current directory.
2150 gcc_cv_ld=./collect-ld$build_exeext
2151 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2152 gcc_cv_ld="$LD_FOR_TARGET"
2154 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2157 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2158 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2159 # if the PLUGIN_LD is set ld-new, just have it as ld
2160 # as that is the installed named.
2161 if test x$PLUGIN_LD_SUFFIX = xld-new \
2162 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2165 AC_ARG_WITH(plugin-ld,
2166 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2167 [if test x"$withval" != x; then
2168 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2169 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2171 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2172 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2174 # Check to see if we are using gold instead of ld
2175 AC_MSG_CHECKING(whether we are using gold)
2177 if test x$gcc_cv_ld != x; then
2178 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2179 | grep "GNU gold" > /dev/null; then
2183 AC_MSG_RESULT($ld_is_gold)
2185 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2186 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2187 case "$ORIGINAL_LD_FOR_TARGET" in
2188 ./collect-ld | ./collect-ld$build_exeext) ;;
2189 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2192 AC_MSG_CHECKING(what linker to use)
2193 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2194 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2195 # Single tree build which includes ld. We want to prefer it
2196 # over whatever linker top-level may have detected, since
2197 # we'll use what we're building after installation anyway.
2198 AC_MSG_RESULT(newly built ld)
2200 in_tree_ld_is_elf=no
2201 if (grep 'EMUL = .*elf' ../ld/Makefile \
2202 || grep 'EMUL = .*linux' ../ld/Makefile \
2203 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2204 in_tree_ld_is_elf=yes
2205 elif test "$ld_is_gold" = yes; then
2206 in_tree_ld_is_elf=yes
2208 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
2211 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2212 if test x$gcc_cv_gld_version != x; then
2216 case $gcc_cv_gld_version in
2219 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2222 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2223 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2225 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2226 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2228 AC_MSG_RESULT($gcc_cv_ld)
2230 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2231 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2232 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2235 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2236 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2238 # Figure out what nm we will be using.
2239 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2240 AS_VAR_SET_IF(gcc_cv_nm,, [
2241 if test -f $gcc_cv_binutils_srcdir/configure.in \
2242 && test -f ../binutils/Makefile \
2243 && test x$build = x$host; then
2244 gcc_cv_nm=../binutils/nm-new$build_exeext
2245 elif test -x nm$build_exeext; then
2246 gcc_cv_nm=./nm$build_exeext
2247 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2248 gcc_cv_nm="$NM_FOR_TARGET"
2250 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2253 AC_MSG_CHECKING(what nm to use)
2254 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2255 # Single tree build which includes binutils.
2256 AC_MSG_RESULT(newly built nm)
2259 AC_MSG_RESULT($gcc_cv_nm)
2263 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2264 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2265 case "$ORIGINAL_NM_FOR_TARGET" in
2266 ./nm | ./nm$build_exeext) ;;
2267 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2271 # Figure out what objdump we will be using.
2272 AS_VAR_SET_IF(gcc_cv_objdump,, [
2273 if test -f $gcc_cv_binutils_srcdir/configure.in \
2274 && test -f ../binutils/Makefile \
2275 && test x$build = x$host; then
2276 # Single tree build which includes binutils.
2277 gcc_cv_objdump=../binutils/objdump$build_exeext
2278 elif test -x objdump$build_exeext; then
2279 gcc_cv_objdump=./objdump$build_exeext
2280 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2281 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2283 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2286 AC_MSG_CHECKING(what objdump to use)
2287 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2288 # Single tree build which includes binutils.
2289 AC_MSG_RESULT(newly built objdump)
2290 elif test x$gcc_cv_objdump = x; then
2291 AC_MSG_RESULT(not found)
2293 AC_MSG_RESULT($gcc_cv_objdump)
2296 # Figure out what readelf we will be using.
2297 AS_VAR_SET_IF(gcc_cv_readelf,, [
2298 if test -f $gcc_cv_binutils_srcdir/configure.in \
2299 && test -f ../binutils/Makefile \
2300 && test x$build = x$host; then
2301 # Single tree build which includes binutils.
2302 gcc_cv_readelf=../binutils/readelf$build_exeext
2303 elif test -x readelf$build_exeext; then
2304 gcc_cv_readelf=./readelf$build_exeext
2306 AC_PATH_PROG(gcc_cv_readelf, readelf)
2309 AC_MSG_CHECKING(what readelf to use)
2310 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2311 # Single tree build which includes binutils.
2312 AC_MSG_RESULT(newly built readelf)
2313 elif test x$gcc_cv_readelf = x; then
2314 AC_MSG_RESULT(not found)
2316 AC_MSG_RESULT($gcc_cv_readelf)
2319 # Figure out what assembler alignment features are present.
2320 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2324 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2325 [Define if your assembler supports .balign and .p2align.])])
2327 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2330 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2331 [Define if your assembler supports specifying the maximum number
2332 of bytes to skip when using the GAS .p2align command.])])
2334 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2337 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2338 [Define if your assembler supports .literal16.])])
2340 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2342 [conftest_label1: .word 0
2344 conftest_label2: .word 0
2346 [if test x$gcc_cv_nm != x; then
2347 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2348 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2349 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2351 else gcc_cv_as_subsection_m1=yes
2353 rm -f conftest.nm1 conftest.nm2
2355 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2356 [Define if your assembler supports .subsection and .subsection -1 starts
2357 emitting at the beginning of your section.])])
2359 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2362 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2364 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2366 [ .weakref foobar, barfnot],,
2367 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2369 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2372 .NSUBSPA $CODE$,COMDAT],,
2373 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2375 # .hidden needs to be supported in both the assembler and the linker,
2376 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2377 # This is irritatingly difficult to feature test for; we have to check the
2378 # date string after the version number. If we've got an in-tree
2379 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2381 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2382 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2388 # Darwin as has some visibility support, though with a different syntax.
2389 gcc_cv_as_hidden=yes
2393 # gnu_indirect_function type is an extension proposed at
2394 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2395 # selection of function implementation
2396 AC_ARG_ENABLE(gnu-indirect-function,
2397 [AS_HELP_STRING([--enable-gnu-indirect-function],
2398 [enable the use of the @gnu_indirect_function to glibc systems])],
2399 [case $enable_gnu_indirect_function in
2401 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2402 Valid choices are 'yes' and 'no'.]) ;;
2404 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2406 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2407 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2408 [Define if your system supports gnu indirect functions.])
2412 if test $in_tree_ld != yes ; then
2413 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2414 if echo "$ld_ver" | grep GNU > /dev/null; then
2415 if test x"$ld_is_gold" = xyes; then
2416 # GNU gold --version looks like this:
2418 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2420 # We extract the binutils version which is more familiar and specific
2421 # than the gold version.
2422 ld_vers=`echo $ld_ver | sed -n \
2423 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2425 # GNU ld --version looks like this:
2427 # GNU ld (GNU Binutils) 2.21.51.20110225
2428 ld_vers=`echo $ld_ver | sed -n \
2429 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2431 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'`
2432 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2433 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2434 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2438 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2441 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2442 # /usr/ccs/bin/ld has been configured.
2443 ld_ver=`$gcc_cv_ld -V 2>&1`
2444 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2445 ld_vers=`echo $ld_ver | sed -n \
2446 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2447 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2448 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2456 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2457 [[if test $in_tree_ld = yes ; then
2459 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 \
2460 && test $in_tree_ld_is_elf = yes; then
2461 gcc_cv_ld_hidden=yes
2464 gcc_cv_ld_hidden=yes
2465 if test x"$ld_is_gold" = xyes; then
2467 elif echo "$ld_ver" | grep GNU > /dev/null; then
2469 mmix-knuth-mmixware)
2470 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2474 if test 0"$ld_date" -lt 20020404; then
2475 if test -n "$ld_date"; then
2476 # If there was date string, but was earlier than 2002-04-04, fail
2478 elif test -z "$ld_vers"; then
2479 # If there was no date string nor ld version number, something is wrong
2482 test -z "$ld_vers_patch" && ld_vers_patch=0
2483 if test "$ld_vers_major" -lt 2; then
2485 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2486 gcc_cv_ld_hidden="no"
2487 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2495 # Darwin ld has some visibility support.
2496 gcc_cv_ld_hidden=yes
2498 hppa64*-*-hpux* | ia64*-*-hpux*)
2499 gcc_cv_ld_hidden=yes
2501 *-*-solaris2.1[0-9]*)
2502 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2503 # .symbolic was only added in Solaris 9 12/02.
2504 gcc_cv_ld_hidden=yes
2512 libgcc_visibility=no
2513 AC_SUBST(libgcc_visibility)
2514 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2515 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2516 libgcc_visibility=yes
2517 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2518 [Define if your assembler and linker support .hidden.])
2521 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2522 gcc_cv_ld_ro_rw_mix=unknown
2523 if test $in_tree_ld = yes ; then
2524 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 \
2525 && test $in_tree_ld_is_elf = yes; then
2526 gcc_cv_ld_ro_rw_mix=read-write
2528 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2529 echo '.section myfoosect, "a"' > conftest1.s
2530 echo '.section myfoosect, "aw"' > conftest2.s
2531 echo '.byte 1' >> conftest2.s
2532 echo '.section myfoosect, "a"' > conftest3.s
2533 echo '.byte 0' >> conftest3.s
2534 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2535 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2536 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2537 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2538 conftest2.o conftest3.o > /dev/null 2>&1; then
2539 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2540 | sed -e '/myfoosect/!d' -e N`
2541 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2542 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2543 gcc_cv_ld_ro_rw_mix=read-only
2545 gcc_cv_ld_ro_rw_mix=read-write
2550 rm -f conftest.* conftest[123].*
2553 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2554 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2555 [Define if your linker links a mix of read-only
2556 and read-write sections into a read-write section.])
2558 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2560 gcc_AC_INITFINI_ARRAY
2562 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2563 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2571 [[# GAS versions before 2.11 do not support uleb128,
2572 # despite appearing to.
2573 # ??? There exists an elf-specific test that will crash
2574 # the assembler. Perhaps it's better to figure out whether
2575 # arbitrary sections are supported and try the test.
2576 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2577 if echo "$as_ver" | grep GNU > /dev/null; then
2578 as_vers=`echo $as_ver | sed -n \
2579 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2580 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2581 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2582 if test $as_major -eq 2 && test $as_minor -lt 11
2584 else gcc_cv_as_leb128=yes
2587 [AC_DEFINE(HAVE_AS_LEB128, 1,
2588 [Define if your assembler supports .sleb128 and .uleb128.])])
2590 # Check if we have assembler support for unwind directives.
2591 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2598 .cfi_escape 1, 2, 3, 4, 5
2602 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2603 # read-only and read-write sections, we need to make sure that the
2604 # assembler used emits read-write .eh_frame sections.
2605 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2606 if test "x$gcc_cv_objdump" != x; then
2607 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2608 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2609 gcc_cv_as_cfi_directive=no
2612 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2613 # On Solaris/x86, make sure that GCC and assembler agree on using
2614 # read-only .eh_frame sections for 64-bit.
2615 if test x$gas = xyes; then
2616 as_ix86_64_opt="--64"
2618 as_ix86_64_opt="-xarch=amd64"
2620 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2621 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2622 sed -e /.eh_frame/!d -e N | \
2623 grep READONLY > /dev/null; then
2624 gcc_cv_as_cfi_directive=yes
2626 gcc_cv_as_cfi_directive=no
2630 gcc_cv_as_cfi_directive=yes
2635 # no objdump, err on the side of caution
2636 gcc_cv_as_cfi_directive=no
2639 gcc_cv_as_cfi_directive=yes
2643 gcc_cv_as_cfi_directive=yes
2646 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2647 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2651 .cfi_adjust_cfa_offset 64
2653 .cfi_adjust_cfa_offset 128
2656 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2657 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2658 gcc_cv_as_cfi_advance_working=yes
2662 # no objdump, err on the side of caution
2663 gcc_cv_as_cfi_advance_working=no
2665 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2666 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2667 [`if test $gcc_cv_as_cfi_directive = yes \
2668 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2669 [Define 0/1 if your assembler supports CFI directives.])
2671 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2672 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2673 gcc_cv_as_cfi_personality_directive, ,,
2676 .cfi_personality 0, symbol
2678 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2679 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2680 then echo 1; else echo 0; fi`],
2681 [Define 0/1 if your assembler supports .cfi_personality.])
2683 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2684 gcc_cv_as_cfi_sections_directive, ,,
2686 .cfi_sections .debug_frame, .eh_frame
2690 win32 | pe | cygwin* | mingw32* | uwin*)
2691 # Need to check that we generated the correct relocation for the
2692 # .debug_frame section. This was fixed for binutils 2.21.
2693 gcc_cv_as_cfi_sections_directive=no
2694 if test "x$gcc_cv_objdump" != x; then
2695 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2696 grep secrel > /dev/null; then
2697 gcc_cv_as_cfi_sections_directive=yes
2702 gcc_cv_as_cfi_sections_directive=yes
2705 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2706 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2707 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2708 then echo 1; else echo 0; fi`],
2709 [Define 0/1 if your assembler supports .cfi_sections.])
2711 # GAS versions up to and including 2.11.0 may mis-optimize
2713 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2721 .section .eh_frame,"aw",@progbits
2723 .4byte .LECIE1-.LSCIE1
2737 .4byte .LEFDE1-.LASFDE1
2739 .4byte .LASFDE1-__FRAME_BEGIN__
2747 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2748 cat > conftest.lit <<EOF
2749 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2750 0010 01000000 12000000 18000000 00000000 ................
2751 0020 08000000 04080000 0044 .........D @&t@
2753 cat > conftest.big <<EOF
2754 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2755 0010 00000001 00000012 00000018 00000000 ................
2756 0020 00000008 04000000 0844 .........D @&t@
2758 # If the assembler didn't choke, and we can objdump,
2759 # and we got the correct data, then succeed.
2760 # The text in the here-document typically retains its unix-style line
2761 # endings, while the output of objdump will use host line endings.
2762 # Therefore, use diff -b for the comparisons.
2763 if test x$gcc_cv_objdump != x \
2764 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2765 | tail -3 > conftest.got \
2766 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2767 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2769 gcc_cv_as_eh_frame=yes
2770 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2771 gcc_cv_as_eh_frame=buggy
2773 # Uh oh, what do we do now?
2774 gcc_cv_as_eh_frame=no
2777 if test $gcc_cv_as_eh_frame = buggy; then
2778 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2779 [Define if your assembler mis-optimizes .eh_frame data.])
2782 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2783 [elf,2,12,0], [--fatal-warnings],
2784 [.section .rodata.str, "aMS", @progbits, 1])
2785 if test $gcc_cv_as_shf_merge = no; then
2786 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2787 [elf,2,12,0], [--fatal-warnings],
2788 [.section .rodata.str, "aMS", %progbits, 1])
2790 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2791 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2792 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2794 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2795 gcc_cv_as_comdat_group,
2796 [elf,2,16,0], [--fatal-warnings],
2797 [.section .text,"axG",@progbits,.foo,comdat])
2798 if test $gcc_cv_as_comdat_group = yes; then
2799 gcc_cv_as_comdat_group_percent=no
2800 gcc_cv_as_comdat_group_group=no
2802 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2803 gcc_cv_as_comdat_group_percent,
2804 [elf,2,16,0], [--fatal-warnings],
2805 [.section .text,"axG",%progbits,.foo,comdat])
2806 if test $gcc_cv_as_comdat_group_percent = yes; then
2807 gcc_cv_as_comdat_group_group=no
2809 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2810 gcc_cv_as_comdat_group_group=no
2813 # Sun as uses a completely different syntax.
2818 .group foo,".text%foo",#comdat
2819 .section ".text%foo", #alloc,#execinstr,#progbits
2824 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2826 .group foo,.text%foo,#comdat
2827 .section .text%foo, "ax", @progbits
2833 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2834 gcc_cv_as_comdat_group_group,
2840 if test x"$ld_is_gold" = xyes; then
2842 elif test $in_tree_ld = yes ; then
2844 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 \
2845 && test $in_tree_ld_is_elf = yes; then
2848 elif echo "$ld_ver" | grep GNU > /dev/null; then
2850 if test 0"$ld_date" -lt 20050308; then
2851 if test -n "$ld_date"; then
2852 # If there was date string, but was earlier than 2005-03-08, fail
2854 elif test "$ld_vers_major" -lt 2; then
2856 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2863 *-*-solaris2.1[1-9]*)
2865 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2866 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2869 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2870 # least ld version 1.2267.
2871 if test "$ld_vers_major" -gt 1; then
2873 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2875 elif test "$ld_vers_minor" -ge 2267; then
2880 # Assume linkers other than GNU ld don't support COMDAT group.
2886 # Allow overriding the automatic COMDAT group tests above.
2887 AC_ARG_ENABLE(comdat,
2888 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2889 [comdat_group="$enable_comdat"])
2890 if test $comdat_group = no; then
2891 gcc_cv_as_comdat_group=no
2892 gcc_cv_as_comdat_group_percent=no
2893 gcc_cv_as_comdat_group_group=no
2895 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2896 [`if test $gcc_cv_as_comdat_group = yes \
2897 || test $gcc_cv_as_comdat_group_percent = yes \
2898 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2899 [Define 0/1 if your assembler and linker support COMDAT groups.])
2901 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2902 gcc_cv_as_discriminator,
2906 .loc 1 1 0 discriminator 1],,
2907 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2908 [Define if your assembler supports the .loc discriminator sub-directive.])])
2910 # Thread-local storage - the check is heavily parameterized.
2919 .section ".tdata","awT",@progbits
2922 ldq $27,__tls_get_addr($29) !literal!1
2923 lda $16,foo($29) !tlsgd!1
2924 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2925 ldq $27,__tls_get_addr($29) !literal!2
2926 lda $16,foo($29) !tlsldm!2
2927 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2928 ldq $1,foo($29) !gotdtprel
2929 ldah $2,foo($29) !dtprelhi
2930 lda $3,foo($2) !dtprello
2931 lda $4,foo($29) !dtprel
2932 ldq $1,foo($29) !gottprel
2933 ldah $2,foo($29) !tprelhi
2934 lda $3,foo($2) !tprello
2935 lda $4,foo($29) !tprel'
2938 tls_as_opt=--fatal-warnings
2940 cris-*-*|crisv32-*-*)
2942 .section ".tdata","awT",@progbits
2949 tls_as_opt=--fatal-warnings
2953 .section ".tdata","awT",@progbits
2965 .section ".tdata","awT",@progbits
2969 addil LT%foo-$tls_gdidx$,gp
2970 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2973 addil LT%foo-$tls_ldidx$,gp
2975 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2976 addil LR%foo-$tls_dtpoff$,%ret0
2977 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2979 addil LT%foo-$tls_ieoff$,gp
2980 ldw RT%foo-$tls_ieoff$(%r1),%t2
2983 addil LR%foo-$tls_leoff$,%t1
2984 ldo RR%foo-$tls_leoff$(%r1),%t2'
2987 tls_as_opt=--fatal-warnings
2991 .section ".tdata","awT",%progbits
3002 i[34567]86-*-* | x86_64-*-*)
3004 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
3011 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3013 .section .tdata,"awt",@progbits'
3018 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3019 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3023 .section ".tdata","awT",@progbits'
3027 tls_as_opt="--fatal-warnings"
3031 conftest_s="$conftest_s
3035 leal foo@tlsgd(,%ebx,1), %eax
3036 leal foo@tlsldm(%ebx), %eax
3037 leal foo@dtpoff(%eax), %edx
3038 movl foo@gottpoff(%ebx), %eax
3039 subl foo@gottpoff(%ebx), %eax
3040 addl foo@gotntpoff(%ebx), %eax
3041 movl foo@indntpoff, %eax
3042 movl \$foo@tpoff, %eax
3043 subl \$foo@tpoff, %eax
3044 leal foo@ntpoff(%ecx), %eax"
3047 if test x$on_solaris = xyes; then
3049 yes) tls_as_opt="$tls_as_opt --64" ;;
3050 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3053 conftest_s="$conftest_s
3057 leaq foo@tlsgd(%rip), %rdi
3058 leaq foo@tlsld(%rip), %rdi
3059 leaq foo@dtpoff(%rax), %rdx
3060 movq foo@gottpoff(%rip), %rax
3061 movq \$foo@tpoff, %rax"
3067 .section ".tdata","awT",@progbits
3070 addl r16 = @ltoff(@dtpmod(foo#)), gp
3071 addl r17 = @ltoff(@dtprel(foo#)), gp
3072 addl r18 = @ltoff(@tprel(foo#)), gp
3073 addl r19 = @dtprel(foo#), gp
3074 adds r21 = @dtprel(foo#), r13
3075 movl r23 = @dtprel(foo#)
3076 addl r20 = @tprel(foo#), gp
3077 adds r22 = @tprel(foo#), r13
3078 movl r24 = @tprel(foo#)'
3081 tls_as_opt=--fatal-warnings
3085 .section .tdata,"awT",@progbits
3089 addik r5,r20,x@TLSGD
3090 addik r5,r20,x@TLSLDM'
3093 tls_as_opt='--fatal-warnings'
3097 .section .tdata,"awT",@progbits
3101 addiu $4, $28, %tlsgd(x)
3102 addiu $4, $28, %tlsldm(x)
3103 lui $4, %dtprel_hi(x)
3104 addiu $4, $4, %dtprel_lo(x)
3105 lw $4, %gottprel(x)($28)
3106 lui $4, %tprel_hi(x)
3107 addiu $4, $4, %tprel_lo(x)'
3110 tls_as_opt='-32 --fatal-warnings'
3114 .section .tdata,"awT",@progbits
3119 move.l x@TLSGD(%a5),%a0
3120 move.l x@TLSLDM(%a5),%a0
3121 move.l x@TLSLDO(%a5),%a0
3122 move.l x@TLSIE(%a5),%a0
3123 move.l x@TLSLE(%a5),%a0'
3126 tls_as_opt='--fatal-warnings'
3130 .section ".tdata","awT",@progbits'
3133 tls_as_opt="--fatal-warnings"
3137 .section ".tdata","awT",%progbits
3141 add x0, x0, #:tlsgd_lo12:x
3146 tls_as_opt='--fatal-warnings'
3150 .extern __get_tpointer
3168 .section ".tdata","awT",@progbits
3176 addi 3,2,ld0@got@tlsgd
3182 addi 3,2,x1@got@tlsld
3188 addis 9,3,x2@dtprel@ha
3189 addi 9,9,x2@dtprel@l
3192 ld 9,x3@got@dtprel(2)
3198 tls_as_opt="-a64 --fatal-warnings"
3202 .section ".tdata","awT",@progbits
3210 addi 3,31,ld0@got@tlsgd
3212 addi 3,31,x1@got@tlsld
3215 addis 9,3,x2@dtprel@ha
3216 addi 9,9,x2@dtprel@l
3217 lwz 9,x3@got@tprel(31)
3220 addis 9,2,x2@tprel@ha
3221 addi 9,9,x2@tprel@l'
3224 tls_as_opt="-a32 --fatal-warnings"
3228 .section ".tdata","awT",@progbits
3237 l %r1,foo@GOTNTPOFF(%r12)
3238 l %r1,0(%r1):tls_load:foo
3239 bas %r14,0(%r1,%r13):tls_gdcall:foo
3240 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3243 tls_as_opt="-m31 --fatal-warnings"
3247 .section ".tdata","awT",@progbits
3255 lg %r1,foo@GOTNTPOFF(%r12)
3256 larl %r1,foo@INDNTPOFF
3257 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3258 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3261 tls_as_opt="-m64 -Aesame --fatal-warnings"
3263 sh-*-* | sh[34]-*-*)
3265 .section ".tdata","awT",@progbits
3275 tls_as_opt=--fatal-warnings
3279 sparc*-sun-solaris2.*)
3286 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3288 .section ".tdata",#alloc,#write,#tls'
3293 .section ".tdata","awT",@progbits'
3296 tls_as_opt="-32 --fatal-warnings"
3298 conftest_s="$conftest_s
3301 sethi %tgd_hi22(foo), %o0
3302 add %o0, %tgd_lo10(foo), %o1
3303 add %l7, %o1, %o0, %tgd_add(foo)
3304 call __tls_get_addr, %tgd_call(foo)
3305 sethi %tldm_hi22(foo), %l1
3306 add %l1, %tldm_lo10(foo), %l2
3307 add %l7, %l2, %o0, %tldm_add(foo)
3308 call __tls_get_addr, %tldm_call(foo)
3309 sethi %tldo_hix22(foo), %l3
3310 xor %l3, %tldo_lox10(foo), %l4
3311 add %o0, %l4, %l5, %tldo_add(foo)
3312 sethi %tie_hi22(foo), %o3
3313 add %o3, %tie_lo10(foo), %o3
3314 ld [%l7 + %o3], %o2, %tie_ld(foo)
3315 add %g7, %o2, %o4, %tie_add(foo)
3316 sethi %tle_hix22(foo), %l1
3317 xor %l1, %tle_lox10(foo), %o5
3318 ld [%g7 + %o5], %o1"
3322 .section ".tdata","awT",@progbits
3325 addli r0, zero, tls_gd(foo)
3326 auli r0, zero, tls_gd_ha16(foo)
3327 addli r0, r0, tls_gd_lo16(foo)
3329 addli r0, zero, tls_ie(foo)
3330 auli r0, r0, tls_ie_ha16(foo)
3331 addli r0, r0, tls_ie_lo16(foo)'
3334 tls_as_opt="--fatal-warnings"
3338 .section ".tdata","awT",@progbits
3341 shl16insli r0, zero, hw0_last_tls_gd(foo)
3342 shl16insli r0, zero, hw1_last_tls_gd(foo)
3343 shl16insli r0, r0, hw0_tls_gd(foo)
3345 shl16insli r0, zero, hw1_last_tls_ie(foo)
3346 shl16insli r0, r0, hw0_tls_ie(foo)'
3349 tls_as_opt="--fatal-warnings"
3353 .section ".tdata","awT",@progbits
3356 movi a8, foo@TLSFUNC
3357 movi a10, foo@TLSARG
3358 callx8.tls a8, foo@TLSCALL'
3365 if test "x$enable_tls" = xno ; then
3366 : # TLS explicitly disabled.
3367 elif test "x$enable_tls" = xyes ; then
3368 set_have_as_tls=yes # TLS explicitly enabled.
3369 elif test -z "$tls_first_major"; then
3370 : # If we don't have a check, assume no support.
3372 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3373 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3374 [set_have_as_tls=yes])
3376 if test $set_have_as_tls = yes ; then
3377 AC_DEFINE(HAVE_AS_TLS, 1,
3378 [Define if your assembler and linker support thread-local storage.])
3381 # Target-specific assembler checks.
3383 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3384 gcc_cv_ld_static_dynamic=no
3385 gcc_cv_ld_static_option='-Bstatic'
3386 gcc_cv_ld_dynamic_option='-Bdynamic'
3387 if test $in_tree_ld = yes ; then
3388 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
3389 gcc_cv_ld_static_dynamic=yes
3391 elif test x$gcc_cv_ld != x; then
3392 # Check if linker supports -Bstatic/-Bdynamic option
3393 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3394 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3395 gcc_cv_ld_static_dynamic=yes
3398 # AIX ld uses -b flags
3399 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3400 gcc_cv_ld_static_dynamic=yes
3401 gcc_cv_ld_static_option="-bstatic"
3402 gcc_cv_ld_dynamic_option="-bdynamic"
3404 # HP-UX ld uses -a flags to select between shared and archive.
3406 if test x"$gnu_ld" = xno; then
3407 gcc_cv_ld_static_dynamic=yes
3408 gcc_cv_ld_static_option="-aarchive_shared"
3409 gcc_cv_ld_dynamic_option="-adefault"
3412 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3414 gcc_cv_ld_static_dynamic=yes
3419 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3420 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3421 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3422 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3423 [Define to the linker option to disable use of shared objects.])
3424 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3425 [Define to the linker option to enable use of shared objects.])
3427 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3429 if test x"$demangler_in_ld" = xyes; then
3430 AC_MSG_CHECKING(linker --demangle support)
3431 gcc_cv_ld_demangle=no
3432 if test $in_tree_ld = yes; then
3433 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 \
3434 gcc_cv_ld_demangle=yes
3436 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3437 # Check if the GNU linker supports --demangle option
3438 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3439 gcc_cv_ld_demangle=yes
3442 if test x"$gcc_cv_ld_demangle" = xyes; then
3443 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3444 [Define if your linker supports --demangle option.])
3446 AC_MSG_RESULT($gcc_cv_ld_demangle)
3449 AC_MSG_CHECKING(linker plugin support)
3451 if test -f liblto_plugin.la; then
3452 save_ld_ver="$ld_ver"
3453 save_ld_vers_major="$ld_vers_major"
3454 save_ld_vers_minor="$ld_vers_minor"
3455 save_ld_is_gold="$ld_is_gold"
3459 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3461 # FIXME: ld_is_gold?
3462 ld_vers_major="$gcc_cv_gld_major_version"
3463 ld_vers_minor="$gcc_cv_gld_minor_version"
3465 # Determine plugin linker version.
3466 # FIXME: Partial duplicate from above, generalize.
3468 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3469 if echo "$ld_ver" | grep GNU > /dev/null; then
3470 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3472 ld_vers=`echo $ld_ver | sed -n \
3473 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3475 ld_vers=`echo $ld_ver | sed -n \
3476 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3478 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3479 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3484 # Determine plugin support.
3485 if echo "$ld_ver" | grep GNU > /dev/null; then
3486 # Require GNU ld or gold 2.21+ for plugin support by default.
3487 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3489 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3490 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3495 ld_ver="$save_ld_ver"
3496 ld_vers_major="$save_ld_vers_major"
3497 ld_vers_minor="$save_ld_vers_minor"
3498 ld_is_gold="$save_ld_is_gold"
3500 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3501 [Define to the level of your linker's plugin support.])
3502 AC_MSG_RESULT($gcc_cv_lto_plugin)
3506 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3507 [-mabi=lp64], [.text],,,)
3508 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3509 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3510 [Define if your assembler supports the -mabi option.])
3512 if test x$with_abi = xilp32; then
3513 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3514 Upgrade the Assembler.])
3516 if test x"$with_multilib_list" = xdefault; then
3517 TM_MULTILIB_CONFIG=lp64
3519 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3520 for aarch64_multilib in ${aarch64_multilibs}; do
3521 case ${aarch64_multilib} in
3523 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3524 Upgrade the Assembler.])
3534 # All TARGET_ABI_OSF targets.
3535 alpha*-*-linux* | alpha*-*-*bsd*)
3536 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3537 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3540 extbl $3, $2, $3 !lituse_bytoff!1
3541 ldq $2, a($29) !literal!1
3542 ldq $4, b($29) !literal!2
3543 ldq_u $3, 0($2) !lituse_base!1
3544 ldq $27, f($29) !literal!5
3545 jsr $26, ($27), f !lituse_jsr!5
3546 ldah $29, 0($26) !gpdisp!3
3547 lda $0, c($29) !gprel
3548 ldah $1, d($29) !gprelhigh
3549 lda $1, d($1) !gprellow
3550 lda $29, 0($29) !gpdisp!3],,
3551 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3552 [Define if your assembler supports explicit relocations.])])
3553 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3554 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3557 ldq $27, a($29) !literal!1
3558 jsr $26, ($27), a !lituse_jsrdirect!1],,
3559 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3560 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3564 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3565 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3566 [-no-mul-bug-abort], [.text],,
3567 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3568 [Define if your assembler supports the -no-mul-bug-abort option.])])
3572 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3573 [.register %g2, #scratch],,
3574 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3575 [Define if your assembler supports .register.])])
3577 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3578 [.section "nobits",#alloc,#write,#nobits
3579 .section "progbits",#alloc,#write,#progbits])
3580 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3581 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3582 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3584 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3586 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3587 [Define if your assembler supports -relax option.])])
3589 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3590 gcc_cv_as_sparc_gotdata_op,,
3597 sethi %gdop_hix22(foo), %g1
3598 xor %g1, %gdop_lox10(foo), %g1
3599 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3600 [if test x$gcc_cv_ld != x \
3601 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3602 if test x$gcc_cv_objdump != x; then
3603 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3604 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3605 gcc_cv_as_sparc_gotdata_op=no
3607 gcc_cv_as_sparc_gotdata_op=yes
3612 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3613 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3615 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3616 gcc_cv_as_sparc_ua_pcrel,,
3624 .uaword %r_disp32(foo)],
3625 [if test x$gcc_cv_ld != x \
3626 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3627 gcc_cv_as_sparc_ua_pcrel=yes
3630 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3631 [Define if your assembler and linker support unaligned PC relative relocs.])
3633 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3634 gcc_cv_as_sparc_ua_pcrel_hidden,,
3639 .uaword %r_disp32(foo)
3640 .byte 0x32, 0x33, 0x34
3645 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3646 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3647 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3648 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3649 if $gcc_cv_objdump -R conftest 2> /dev/null \
3650 | grep 'DISP32' > /dev/null 2>&1; then
3653 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3657 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3658 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3659 ]) # unaligned pcrel relocs
3661 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3662 gcc_cv_as_sparc_offsetable_lo10,,
3665 or %g1, %lo(ab) + 12, %g1
3666 or %g1, %lo(ab + 12), %g1],
3667 [if test x$gcc_cv_objdump != x \
3668 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3669 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3670 gcc_cv_as_sparc_offsetable_lo10=yes
3672 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3673 [Define if your assembler supports offsetable %lo().])])
3675 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3676 gcc_cv_as_sparc_fmaf,,
3679 .register %g2, #scratch
3680 .register %g3, #scratch
3682 fmaddd %f0, %f2, %f4, %f6
3683 addxccc %g1, %g2, %g3
3684 fsrl32 %f2, %f4, %f8
3685 fnaddd %f10, %f12, %f14],,
3686 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3687 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3689 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3690 gcc_cv_as_sparc_sparc4,,
3693 .register %g2, #scratch
3694 .register %g3, #scratch
3697 1: cwbneg %g2, %g3, 1f
3700 aes_kexpand0 %f4, %f6, %f8
3701 des_round %f38, %f40, %f42, %f44
3702 camellia_f %f54, %f56, %f58, %f60
3703 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3704 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3705 [Define if your assembler supports SPARC4 instructions.])])
3707 gcc_GAS_CHECK_FEATURE([LEON instructions],
3708 gcc_cv_as_sparc_leon,,
3711 .register %g2, #scratch
3712 .register %g3, #scratch
3716 casa [[%g2]] 0xb, %g3, %g1],,
3717 [AC_DEFINE(HAVE_AS_LEON, 1,
3718 [Define if your assembler supports LEON instructions.])])
3722 i[34567]86-*-* | x86_64-*-*)
3726 # Full C++ conformance when using a shared libstdc++-v3 requires some
3727 # support from the Cygwin DLL, which in more recent versions exports
3728 # wrappers to aid in interposing and redirecting operators new, delete,
3729 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3730 # are configuring for a version of Cygwin that exports the wrappers.
3731 if test x$host = x$target && test x$host_cpu = xi686; then
3732 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3734 # Can't check presence of libc functions during cross-compile, so
3735 # we just have to assume we're building for an up-to-date target.
3736 gcc_ac_cygwin_dll_wrappers=yes
3738 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3739 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3740 [Define if you want to generate code by default that assumes that the
3741 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3744 cygwin* | pe | mingw32* | interix*)
3745 # Recent binutils allows the three-operand form of ".comm" on PE. This
3746 # definition is used unconditionally to initialise the default state of
3747 # the target option variable that governs usage of the feature.
3748 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3749 [2,19,52],,[.comm foo,1,32])
3750 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3751 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3752 [Define if your assembler supports specifying the alignment
3753 of objects allocated using the GAS .comm command.])
3754 # Used for DWARF 2 in PE
3755 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3756 gcc_cv_as_ix86_pe_secrel32,
3762 [if test x$gcc_cv_ld != x \
3763 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3764 gcc_cv_as_ix86_pe_secrel32=yes
3767 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3768 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3769 # Test if the assembler supports the extended form of the .section
3770 # directive that specifies section alignment. LTO support uses this,
3771 # but normally only after installation, so we warn but don't fail the
3772 # configure if LTO is enabled but the assembler does not support it.
3773 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3774 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3775 if test x$gcc_cv_as_section_has_align != xyes; then
3776 case ",$enable_languages," in
3778 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3782 # Test if the assembler supports the section flag 'e' for specifying
3783 # an excluded section.
3784 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3788 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3789 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3790 [Define if your assembler supports specifying the section flag e.])
3794 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3795 gcc_cv_as_ix86_filds,,,
3796 [filds mem; fists mem],,
3797 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3798 [Define if your assembler uses filds and fists mnemonics.])])
3800 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3801 gcc_cv_as_ix86_fildq,,,
3802 [fildq mem; fistpq mem],,
3803 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3804 [Define if your assembler uses fildq and fistq mnemonics.])])
3806 gcc_GAS_CHECK_FEATURE([cmov syntax],
3807 gcc_cv_as_ix86_cmov_sun_syntax,,,
3808 [cmovl.l %edx, %eax],,
3809 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3810 [Define if your assembler supports the Sun syntax for cmov.])])
3812 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3813 gcc_cv_as_ix86_ffreep,,,
3815 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3816 [Define if your assembler supports the ffreep mnemonic.])])
3818 gcc_GAS_CHECK_FEATURE([.quad directive],
3819 gcc_cv_as_ix86_quad,,,
3821 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3822 [Define if your assembler supports the .quad directive.])])
3824 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3825 gcc_cv_as_ix86_sahf,,,
3828 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3829 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3831 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3832 gcc_cv_as_ix86_interunit_movq,,,
3836 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3837 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3838 [Define if your assembler supports interunit movq mnemonic.])
3840 gcc_GAS_CHECK_FEATURE([hle prefixes],
3841 gcc_cv_as_ix86_hle,,,
3842 [lock xacquire cmpxchg %esi, (%ecx)],,
3843 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3844 [Define if your assembler supports HLE prefixes.])])
3846 gcc_GAS_CHECK_FEATURE([swap suffix],
3847 gcc_cv_as_ix86_swap,,,
3848 [movl.s %esp, %ebp],,
3849 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3850 [Define if your assembler supports the swap suffix.])])
3852 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3853 gcc_cv_as_ix86_diff_sect_delta,,,
3861 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3862 [Define if your assembler supports the subtraction of symbols in different sections.])])
3864 # These two are used unconditionally by i386.[ch]; it is to be defined
3865 # to 1 if the feature is present, 0 otherwise.
3866 as_ix86_gotoff_in_data_opt=
3867 if test x$gas = xyes; then
3868 as_ix86_gotoff_in_data_opt="--32"
3870 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3871 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3872 [$as_ix86_gotoff_in_data_opt],
3878 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3879 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3880 [Define true if the assembler supports '.long foo@GOTOFF'.])
3882 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3883 gcc_cv_as_ix86_rep_lock_prefix,,,
3889 lock addl %edi, (%eax,%esi)
3890 lock orl $0, (%esp)],,
3891 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3892 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3894 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3895 gcc_cv_as_ix86_ud2,,,
3897 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3898 [Define if your assembler supports the 'ud2' mnemonic.])])
3900 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3901 gcc_cv_as_ix86_tlsgdplt,,,
3902 [call tls_gd@tlsgdplt],
3903 [if test x$gcc_cv_ld != x \
3904 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3905 gcc_cv_as_ix86_tlsgdplt=yes
3908 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3909 [Define if your assembler and linker support @tlsgdplt.])])
3912 .section .tdata,"aw'$tls_section_flag'",@progbits
3914 .section .text,"ax",@progbits
3915 call tls_ld@tlsldmplt'
3916 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3917 gcc_cv_as_ix86_tlsldmplt,,,
3919 [if test x$gcc_cv_ld != x \
3920 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3921 gcc_cv_as_ix86_tlsldmplt=yes
3924 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3925 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3926 [Define to 1 if your assembler and linker support @tlsldmplt.])
3928 # Enforce 32-bit output with gas and gld.
3929 if test x$gas = xyes; then
3930 as_ix86_tls_ldm_opt="--32"
3932 if echo "$ld_ver" | grep GNU > /dev/null; then
3933 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3934 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3936 ld_ix86_tls_ldm_opt="-melf_i386"
3940 .section .text,"ax",@progbits
3942 .type _start, @function
3944 leal value@tlsldm(%ebx), %eax
3945 call ___tls_get_addr@plt
3947 .section .tdata,"aw'$tls_section_flag'",@progbits
3948 .type value, @object
3950 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3951 gcc_cv_as_ix86_tlsldm,,
3952 [$as_ix86_tls_ldm_opt],
3954 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3955 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3956 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3957 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3958 gcc_cv_as_ix86_tlsldm=yes
3962 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3963 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3964 [Define to 1 if your assembler and linker support @tlsldm.])
3969 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3970 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3972 addl r15 = @ltoffx(x#), gp
3974 ld8.mov r16 = [[r15]], x#],,
3975 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3976 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3982 *-*-aix*) conftest_s=' .machine "pwr5"
3986 gcc_GAS_CHECK_FEATURE([.machine directive support],
3987 gcc_cv_as_machine_directive,,,
3988 [ .machine ppc7400])
3989 if test x$gcc_cv_as_machine_directive != xyes; then
3990 echo "*** This target requires an assembler supporting \".machine\"" >&2
3991 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3992 test x$build = x$target && exit 1
3996 *) conftest_s=' .machine power4
4001 gcc_GAS_CHECK_FEATURE([mfcr field support],
4002 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4004 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4005 [Define if your assembler supports mfcr field.])])
4008 *-*-aix*) conftest_s=' .machine "pwr5"
4011 *) conftest_s=' .machine power5
4016 gcc_GAS_CHECK_FEATURE([popcntb support],
4017 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4019 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4020 [Define if your assembler supports popcntb field.])])
4023 *-*-aix*) conftest_s=' .machine "pwr5x"
4026 *) conftest_s=' .machine power5
4031 gcc_GAS_CHECK_FEATURE([fp round support],
4032 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4034 [AC_DEFINE(HAVE_AS_FPRND, 1,
4035 [Define if your assembler supports fprnd.])])
4038 *-*-aix*) conftest_s=' .machine "pwr6"
4041 *) conftest_s=' .machine power6
4046 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4047 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4049 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4050 [Define if your assembler supports mffgpr and mftgpr.])])
4053 *-*-aix*) conftest_s=' .csect .text[[PR]]
4055 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4059 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4060 *) conftest_s=' .text
4062 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4065 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4066 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4068 [AC_DEFINE(HAVE_AS_REL16, 1,
4069 [Define if your assembler supports R_PPC_REL16 relocs.])])
4072 *-*-aix*) conftest_s=' .machine "pwr6"
4075 *) conftest_s=' .machine power6
4080 gcc_GAS_CHECK_FEATURE([compare bytes support],
4081 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4083 [AC_DEFINE(HAVE_AS_CMPB, 1,
4084 [Define if your assembler supports cmpb.])])
4087 *-*-aix*) conftest_s=' .machine "pwr6"
4090 *) conftest_s=' .machine power6
4095 gcc_GAS_CHECK_FEATURE([decimal float support],
4096 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4098 [AC_DEFINE(HAVE_AS_DFP, 1,
4099 [Define if your assembler supports DFP instructions.])])
4102 *-*-aix*) conftest_s=' .machine "pwr7"
4105 *) conftest_s=' .machine power7
4110 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4111 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4113 [AC_DEFINE(HAVE_AS_VSX, 1,
4114 [Define if your assembler supports VSX instructions.])])
4117 *-*-aix*) conftest_s=' .machine "pwr7"
4120 *) conftest_s=' .machine power7
4125 gcc_GAS_CHECK_FEATURE([popcntd support],
4126 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4128 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4129 [Define if your assembler supports POPCNTD instructions.])])
4132 *-*-aix*) conftest_s=' .machine "pwr8"
4133 .csect .text[[PR]]';;
4134 *) conftest_s=' .machine power8
4138 gcc_GAS_CHECK_FEATURE([power8 support],
4139 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4141 [AC_DEFINE(HAVE_AS_POWER8, 1,
4142 [Define if your assembler supports POWER8 instructions.])])
4145 *-*-aix*) conftest_s=' .csect .text[[PR]]
4147 *) conftest_s=' .text
4151 gcc_GAS_CHECK_FEATURE([lwsync support],
4152 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4154 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4155 [Define if your assembler supports LWSYNC instructions.])])
4158 *-*-aix*) conftest_s=' .machine "476"
4161 *) conftest_s=' .machine "476"
4166 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4167 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4169 [AC_DEFINE(HAVE_AS_DCI, 1,
4170 [Define if your assembler supports the DCI/ICI instructions.])])
4172 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4173 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4174 [.gnu_attribute 4,1],,
4175 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4176 [Define if your assembler supports .gnu_attribute.])])
4178 gcc_GAS_CHECK_FEATURE([tls marker support],
4179 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4180 [ bl __tls_get_addr(x@tlsgd)],,
4181 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4182 [Define if your assembler supports arg info for __tls_get_addr.])])
4186 gcc_GAS_CHECK_FEATURE([.ref support],
4187 gcc_cv_as_aix_ref, [2,21,0],,
4188 [ .csect stuff[[rw]]
4194 [AC_DEFINE(HAVE_AS_REF, 1,
4195 [Define if your assembler supports .ref])])
4201 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4202 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4203 [ lw $4,%gp_rel(foo)($4)],,
4204 [if test x$target_cpu_default = x
4205 then target_cpu_default=MASK_EXPLICIT_RELOCS
4206 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4208 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4209 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4210 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4211 [Define if the assembler understands -mno-shared.])])
4213 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4214 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4215 [.gnu_attribute 4,1],,
4216 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4217 [Define if your assembler supports .gnu_attribute.])])
4219 gcc_GAS_CHECK_FEATURE([.micromips support],
4220 gcc_cv_as_micromips_support,,[--fatal-warnings],
4222 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4223 [Define if your assembler supports the .set micromips directive])])
4225 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4226 gcc_cv_as_mips_dtprelword, [2,18,0],,
4227 [.section .tdata,"awT",@progbits
4231 .dtprelword x+0x8000],,
4232 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4233 [Define if your assembler supports .dtprelword.])])
4235 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4236 gcc_cv_as_mips_dspr1_mult,,,
4246 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4247 [Define if your assembler supports DSPR1 mult.])])
4249 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4250 gcc_cv_as_ld_jalr_reloc=no
4251 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4252 if test $in_tree_ld = yes ; then
4253 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 \
4254 && test $in_tree_ld_is_elf = yes; then
4255 gcc_cv_as_ld_jalr_reloc=yes
4257 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4258 echo ' .ent x' > conftest.s
4259 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4260 echo ' lw $25,%call16(y)($28)' >> conftest.s
4261 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4262 echo '1: jalr $25' >> conftest.s
4263 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4264 echo '1: jalr $25' >> conftest.s
4265 echo ' .end x' >> conftest.s
4266 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4267 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4268 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4269 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4270 gcc_cv_as_ld_jalr_reloc=yes
4276 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4277 if test x$target_cpu_default = x; then
4278 target_cpu_default=MASK_RELAX_PIC_CALLS
4280 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4283 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4285 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4286 [gcc_cv_ld_mips_personality_relaxation],
4287 [gcc_cv_ld_mips_personality_relaxation=no
4288 if test $in_tree_ld = yes ; then
4289 if test "$gcc_cv_gld_major_version" -eq 2 \
4290 -a "$gcc_cv_gld_minor_version" -ge 21 \
4291 -o "$gcc_cv_gld_major_version" -gt 2; then
4292 gcc_cv_ld_mips_personality_relaxation=yes
4294 elif test x$gcc_cv_as != x \
4295 -a x$gcc_cv_ld != x \
4296 -a x$gcc_cv_readelf != x ; then
4297 cat > conftest.s <<EOF
4299 .cfi_personality 0x80,indirect_ptr
4306 .section .data,"aw",@progbits
4310 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4311 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4312 if $gcc_cv_readelf -d conftest 2>&1 \
4313 | grep TEXTREL > /dev/null 2>&1; then
4315 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4316 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4319 gcc_cv_ld_mips_personality_relaxation=yes
4323 rm -f conftest.s conftest.o conftest])
4324 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4325 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4326 [Define if your linker can relax absolute .eh_frame personality
4327 pointers into PC-relative form.])
4330 gcc_GAS_CHECK_FEATURE([-mnan= support],
4331 gcc_cv_as_mips_nan,,
4333 [AC_DEFINE(HAVE_AS_NAN, 1,
4334 [Define if the assembler understands -mnan=.])])
4335 if test x$gcc_cv_as_mips_nan = xno \
4336 && test x$with_nan != x; then
4338 [Requesting --with-nan= requires assembler support for -mnan=])
4343 # Mips and HP-UX need the GNU assembler.
4344 # Linux on IA64 might be able to use the Intel assembler.
4347 mips*-*-* | *-*-hpux* )
4348 if test x$gas_flag = xyes \
4349 || test x"$host" != x"$build" \
4350 || test ! -x "$gcc_cv_as" \
4351 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4354 echo "*** This configuration requires the GNU assembler" >&2
4360 # ??? Not all targets support dwarf2 debug_line, even within a version
4361 # of gas. Moreover, we need to emit a valid instruction to trigger any
4362 # info to the output file. So, as supported targets are added to gas 2.11,
4363 # add some instruction here to (also) show we expect this might work.
4364 # ??? Once 2.11 is released, probably need to add first known working
4365 # version to the per-target configury.
4367 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4368 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4369 | xstormy16 | xtensa)
4379 if test x"$insn" != x; then
4381 .file 1 \"conftest.s\"
4384 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4385 gcc_cv_as_dwarf2_debug_line,
4386 [elf,2,11,0],, [$conftest_s],
4387 [if test x$gcc_cv_objdump != x \
4388 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4389 | grep debug_line > /dev/null 2>&1; then
4390 gcc_cv_as_dwarf2_debug_line=yes
4393 # The .debug_line file table must be in the exact order that
4394 # we specified the files, since these indices are also used
4395 # by DW_AT_decl_file. Approximate this test by testing if
4396 # the assembler bitches if the same index is assigned twice.
4397 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4398 gcc_cv_as_dwarf2_file_buggy,,,
4402 if test $gcc_cv_as_dwarf2_debug_line = yes \
4403 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4404 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4405 [Define if your assembler supports dwarf2 .file/.loc directives,
4406 and preserves file table indices exactly as given.])
4409 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4410 gcc_cv_as_gdwarf2_flag,
4411 [elf,2,11,0], [--gdwarf2], [$insn],,
4412 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4413 [Define if your assembler supports the --gdwarf2 option.])])
4415 gcc_GAS_CHECK_FEATURE([--gstabs option],
4416 gcc_cv_as_gstabs_flag,
4417 [elf,2,11,0], [--gstabs], [$insn],,
4418 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4419 [Define if your assembler supports the --gstabs option.])])
4421 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4422 gcc_cv_as_debug_prefix_map_flag,
4423 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4424 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4425 [Define if your assembler supports the --debug-prefix-map option.])])
4428 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4429 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4430 [# gas compiled without zlib cannot compress debug sections and warns
4431 # about it, but still exits successfully. So check for this, too.
4432 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4434 gcc_cv_as_compress_debug=0
4435 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4437 gcc_cv_as_compress_debug=1
4438 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4439 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4441 gcc_cv_as_compress_debug=0
4442 # FIXME: Future gas versions will support ELF gABI style via
4443 # --compress-debug-sections[=type].
4445 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4446 [Define to the level of your assembler's compressed debug section support.])
4447 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4448 [Define to the assembler option to enable compressed debug sections.])
4449 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4450 [Define to the assembler option to disable compressed debug sections.])
4452 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4455 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4456 [Define if your assembler supports .lcomm with an alignment field.])])
4458 if test x$with_sysroot = x && test x$host = x$target \
4459 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4460 && test "$prefix" != "NONE"; then
4461 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4462 [Define to PREFIX/include if cpp should also search that directory.])
4465 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4466 if test "x$with_headers" != x; then
4467 target_header_dir=$with_headers
4468 elif test "x$with_sysroot" = x; then
4469 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4470 elif test "x$with_build_sysroot" != "x"; then
4471 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4472 elif test "x$with_sysroot" = xyes; then
4473 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4475 target_header_dir="${with_sysroot}${native_system_header_dir}"
4478 target_header_dir=${native_system_header_dir}
4481 # Determine the version of glibc, if any, used on the target.
4482 AC_MSG_CHECKING([for target glibc version])
4483 AC_ARG_WITH([glibc-version],
4484 [AS_HELP_STRING([--with-glibc-version=M.N],
4485 [assume GCC used with glibc version M.N or later])], [
4486 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4487 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4488 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4490 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4492 glibc_version_major=0
4493 glibc_version_minor=0
4494 [if test -f $target_header_dir/features.h \
4495 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4496 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4497 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4498 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4500 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4502 AC_ARG_ENABLE(gnu-unique-object,
4503 [AS_HELP_STRING([--enable-gnu-unique-object],
4504 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4505 [case $enable_gnu_unique_object in
4507 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4508 Valid choices are 'yes' and 'no'.]) ;;
4510 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4512 [.type foo, '$target_type_format_char'gnu_unique_object],,
4513 # We need to unquote above to to use the definition from config.gcc.
4514 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4515 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4517 if test x$enable_gnu_unique_object = xyes; then
4518 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4519 [Define if your assembler supports @gnu_unique_object.])
4522 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4523 [gcc_cv_as_line_zero],
4524 [gcc_cv_as_line_zero=no
4525 if test $in_tree_gas = yes; then
4526 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4527 elif test "x$gcc_cv_as" != x; then
4528 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4529 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4530 test "x`cat conftest.out`" = x
4532 gcc_cv_as_line_zero=yes
4534 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4535 cat conftest.s >&AS_MESSAGE_LOG_FD
4536 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4537 cat conftest.out >&AS_MESSAGE_LOG_FD
4539 rm -f conftest.o conftest.s conftest.out
4541 if test "x$gcc_cv_as_line_zero" = xyes; then
4542 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4543 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4546 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4547 gcc_cv_ld_eh_frame_hdr=no
4548 if test $in_tree_ld = yes ; then
4549 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 \
4550 && test $in_tree_ld_is_elf = yes; then
4551 gcc_cv_ld_eh_frame_hdr=yes
4553 elif test x$gcc_cv_ld != x; then
4554 if echo "$ld_ver" | grep GNU > /dev/null; then
4555 # Check if linker supports --eh-frame-hdr option
4556 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4557 gcc_cv_ld_eh_frame_hdr=yes
4562 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4563 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4564 gcc_cv_ld_eh_frame_hdr=yes
4570 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4571 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4572 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4573 [Define if your linker supports .eh_frame_hdr.])
4575 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4577 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4578 gcc_cv_ld_eh_frame_ciev3=no
4579 if test $in_tree_ld = yes ; then
4580 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 \
4581 && test $in_tree_ld_is_elf = yes; then
4582 gcc_cv_ld_eh_frame_ciev3=yes
4584 elif test x$gcc_cv_ld != x; then
4585 if echo "$ld_ver" | grep GNU > /dev/null; then
4586 gcc_cv_ld_eh_frame_ciev3=yes
4587 if test 0"$ld_date" -lt 20040513; then
4588 if test -n "$ld_date"; then
4589 # If there was date string, but was earlier than 2004-05-13, fail
4590 gcc_cv_ld_eh_frame_ciev3=no
4591 elif test "$ld_vers_major" -lt 2; then
4592 gcc_cv_ld_eh_frame_ciev3=no
4593 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4594 gcc_cv_ld_eh_frame_ciev3=no
4600 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4601 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4602 gcc_cv_ld_eh_frame_ciev3=yes
4608 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4609 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4610 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4611 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4613 AC_MSG_CHECKING(linker position independent executable support)
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 15 -o "$gcc_cv_gld_major_version" -gt 2 \
4617 && test $in_tree_ld_is_elf = yes; then
4620 elif test x$gcc_cv_ld != x; then
4621 # Check if linker supports -pie option
4622 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4626 if test x"$gcc_cv_ld_pie" = xyes; then
4627 AC_DEFINE(HAVE_LD_PIE, 1,
4628 [Define if your linker supports -pie option.])
4630 AC_MSG_RESULT($gcc_cv_ld_pie)
4632 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4633 gcc_cv_ld_eh_gc_sections=no
4634 if test $in_tree_ld = yes ; then
4635 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 \
4636 && test $in_tree_ld_is_elf = yes; then
4637 gcc_cv_ld_eh_gc_sections=yes
4639 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4640 cat > conftest.s <<EOF
4643 .type _start, @function
4646 .size _start, .-_start
4647 .section .text.foo,"ax",@progbits
4648 .type foo, @function
4652 .section .gcc_except_table.foo,"a",@progbits
4655 .section .eh_frame,"a",@progbits
4658 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4659 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4660 | grep "gc-sections option ignored" > /dev/null; then
4661 gcc_cv_ld_eh_gc_sections=no
4662 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4663 | grep gcc_except_table > /dev/null; then
4664 gcc_cv_ld_eh_gc_sections=yes
4665 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4666 if test x$gcc_cv_as_comdat_group != xyes; then
4667 gcc_cv_ld_eh_gc_sections=no
4668 cat > conftest.s <<EOF
4671 .type _start, @function
4674 .size _start, .-_start
4675 .section .gnu.linkonce.t.foo,"ax",@progbits
4676 .type foo, @function
4680 .section .gcc_except_table.foo,"a",@progbits
4683 .section .eh_frame,"a",@progbits
4686 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4687 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4688 | grep "gc-sections option ignored" > /dev/null; then
4689 gcc_cv_ld_eh_gc_sections=no
4690 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4691 | grep gcc_except_table > /dev/null; then
4692 gcc_cv_ld_eh_gc_sections=yes
4698 rm -f conftest.s conftest.o conftest
4702 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4703 gcc_cv_ld_eh_gc_sections=no
4706 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4707 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4708 [Define if your linker supports garbage collection of
4709 sections in presence of EH frames.])
4711 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4713 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4714 gcc_cv_ld_eh_gc_sections_bug=no
4715 if test $in_tree_ld = yes ; then
4716 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 \
4717 && test $in_tree_ld_is_elf = yes; then
4718 gcc_cv_ld_eh_gc_sections_bug=yes
4720 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
4721 gcc_cv_ld_eh_gc_sections_bug=yes
4722 cat > conftest.s <<EOF
4725 .type _start, @function
4728 .size _start, .-_start
4729 .section .text.startup.foo,"ax",@progbits
4730 .type foo, @function
4734 .section .gcc_except_table.foo,"a",@progbits
4737 .section .eh_frame,"a",@progbits
4740 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4741 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4742 | grep "gc-sections option ignored" > /dev/null; then
4744 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4745 | grep gcc_except_table > /dev/null; then
4746 gcc_cv_ld_eh_gc_sections_bug=no
4749 rm -f conftest.s conftest.o conftest
4751 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4752 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4753 [Define if your linker has buggy garbage collection of
4754 sections support when .text.startup.foo like sections are used.])
4756 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4758 AC_MSG_CHECKING(linker for compressed debug sections)
4759 # gold/gld support compressed debug sections since binutils 2.19/2.21
4760 if test $in_tree_ld = yes ; then
4761 gcc_cv_ld_compress_debug=0
4762 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 \
4763 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
4764 gcc_cv_ld_compress_debug=2
4765 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4766 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 \
4767 && test $in_tree_ld_is_elf = yes; then
4768 gcc_cv_ld_compress_debug=1
4770 elif echo "$ld_ver" | grep GNU > /dev/null; then
4771 gcc_cv_ld_compress_debug=1
4772 if test 0"$ld_date" -lt 20050308; then
4773 if test -n "$ld_date"; then
4774 # If there was date string, but was earlier than 2005-03-08, fail
4775 gcc_cv_ld_compress_debug=0
4776 elif test "$ld_vers_major" -lt 2; then
4777 gcc_cv_ld_compress_debug=0
4778 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
4779 gcc_cv_ld_compress_debug=0
4782 if test $ld_is_gold = yes; then
4783 gcc_cv_ld_compress_debug=2
4784 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4790 # Introduced in Solaris 11.2.
4791 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
4792 gcc_cv_ld_compress_debug=3
4793 gcc_cv_ld_compress_debug_option="-z compress-sections"
4795 gcc_cv_ld_compress_debug=0
4799 # Assume linkers other than GNU ld don't support compessed debug
4801 gcc_cv_ld_compress_debug=0
4806 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
4807 [Define to the level of your linker's compressed debug section support.])
4808 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
4809 [Define to the linker option to enable compressed debug sections.])
4810 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
4816 AC_CACHE_CHECK(linker --as-needed support,
4817 gcc_cv_ld_as_needed,
4818 [gcc_cv_ld_as_needed=no
4819 gcc_cv_ld_as_needed_option='--as-needed'
4820 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4821 if test $in_tree_ld = yes ; then
4822 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 \
4823 && test $in_tree_ld_is_elf = yes; then
4824 gcc_cv_ld_as_needed=yes
4826 elif test x$gcc_cv_ld != x; then
4827 # Check if linker supports --as-needed and --no-as-needed options
4828 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4829 gcc_cv_ld_as_needed=yes
4832 # Solaris 2 ld always supports -z ignore/-z record.
4834 gcc_cv_ld_as_needed=yes
4835 gcc_cv_ld_as_needed_option="-z ignore"
4836 gcc_cv_ld_no_as_needed_option="-z record"
4841 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4842 # dl_iterate_phdr, i.e. since Solaris 11.
4844 *-*-solaris2.1[[1-9]]*)
4846 i?86-*-* | x86_64-*-*)
4847 if echo "$ld_ver" | grep GNU > /dev/null; then
4848 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4849 gcc_cv_ld_as_needed=no
4855 gcc_cv_ld_as_needed=no
4859 if test x"$gcc_cv_ld_as_needed" = xyes; then
4860 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4861 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4862 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4863 [Define to the linker option to ignore unused dependencies.])
4864 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4865 [Define to the linker option to keep unused dependencies.])
4868 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4869 saved_LDFLAGS="$LDFLAGS"
4870 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4871 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4872 AC_LINK_IFELSE([int main(void) {return 0;}],
4873 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4875 LDFLAGS="$saved_LDFLAGS"
4876 if test "x$gcc_cv_ld_clearcap" = xyes; then
4877 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4878 [Define if the linker supports clearing hardware capabilities via mapfile.])
4879 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4881 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4883 case "$target:$tm_file" in
4884 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4887 emul_name="-melf64lppc"
4890 emul_name="-melf64ppc"
4893 emul_name="-melf64ppc_fbsd"
4896 AC_CACHE_CHECK(linker support for omitting dot symbols,
4897 gcc_cv_ld_no_dot_syms,
4898 [gcc_cv_ld_no_dot_syms=no
4899 if test x"$ld_is_gold" = xyes; then
4900 gcc_cv_ld_no_dot_syms=yes
4901 elif test $in_tree_ld = yes ; then
4902 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
4903 gcc_cv_ld_no_dot_syms=yes
4905 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4906 cat > conftest1.s <<EOF
4910 cat > conftest2.s <<EOF
4911 .section ".opd","aw"
4916 .quad .LEfoo,.TOC.@tocbase,0
4922 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4923 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4924 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4925 gcc_cv_ld_no_dot_syms=yes
4927 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4930 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4931 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4932 [Define if your PowerPC64 linker only needs function descriptor syms.])
4935 AC_CACHE_CHECK(linker large toc support,
4936 gcc_cv_ld_large_toc,
4937 [gcc_cv_ld_large_toc=no
4938 if test x"$ld_is_gold" = xyes; then
4939 gcc_cv_ld_large_toc=yes
4940 elif test $in_tree_ld = yes ; then
4941 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
4942 gcc_cv_ld_large_toc=yes
4944 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4945 cat > conftest.s <<EOF
4946 .section ".tbss","awT",@nobits
4952 addis 9,13,ie0@got@tprel@ha
4953 ld 9,ie0@got@tprel@l(9)
4955 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4956 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4957 gcc_cv_ld_large_toc=yes
4959 rm -f conftest conftest.o conftest.s
4962 if test x"$gcc_cv_ld_large_toc" = xyes; then
4963 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4964 [Define if your PowerPC64 linker supports a large TOC.])
4971 AC_CACHE_CHECK(linker large toc support,
4972 gcc_cv_ld_large_toc,
4973 [gcc_cv_ld_large_toc=no
4974 if test x$gcc_cv_as != x ; then
4975 cat > conftest.s <<EOF
4985 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4986 gcc_cv_ld_large_toc=yes
4988 rm -f conftest conftest.o conftest.s
4991 if test x"$gcc_cv_ld_large_toc" = xyes; then
4992 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4993 [Define if your PowerPC64 linker supports a large TOC.])
4998 AC_CACHE_CHECK(linker --build-id support,
5000 [gcc_cv_ld_buildid=no
5001 if test $in_tree_ld = yes ; then
5002 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5003 "$gcc_cv_gld_minor_version" -ge 18 -o \
5004 "$gcc_cv_gld_major_version" -gt 2 \
5005 && test $in_tree_ld_is_elf = yes; then
5006 gcc_cv_ld_buildid=yes
5008 elif test x$gcc_cv_ld != x; then
5009 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5010 gcc_cv_ld_buildid=yes
5013 if test x"$gcc_cv_ld_buildid" = xyes; then
5014 AC_DEFINE(HAVE_LD_BUILDID, 1,
5015 [Define if your linker supports --build-id.])
5018 AC_ARG_ENABLE(linker-build-id,
5019 [AS_HELP_STRING([--enable-linker-build-id],
5020 [compiler will always pass --build-id to linker])],
5022 enable_linker_build_id=no)
5024 if test x"$enable_linker_build_id" = xyes; then
5025 if test x"$gcc_cv_ld_buildid" = xyes; then
5026 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5027 [Define if gcc should always pass --build-id to linker.])
5029 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5033 # In binutils 2.21, GNU ld gained support for new emulations fully
5034 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5035 AC_CACHE_CHECK(linker *_sol2 emulation support,
5036 gcc_cv_ld_sol2_emulation,
5037 [gcc_cv_ld_sol2_emulation=no
5038 if test $in_tree_ld = yes ; then
5039 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5040 "$gcc_cv_gld_minor_version" -ge 21 -o \
5041 "$gcc_cv_gld_major_version" -gt 2 \
5042 && test $in_tree_ld_is_elf = yes; then
5043 gcc_cv_ld_sol2_emulation=yes
5045 elif test x$gcc_cv_ld != x; then
5046 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5047 grep _sol2 > /dev/null; then
5048 gcc_cv_ld_sol2_emulation=yes
5051 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5052 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5053 [Define if your linker supports the *_sol2 emulations.])
5056 AC_CACHE_CHECK(linker --sysroot support,
5058 [gcc_cv_ld_sysroot=no
5059 if test $in_tree_ld = yes ; then
5060 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
5061 gcc_cv_ld_sysroot=yes
5063 elif test x$gcc_cv_ld != x; then
5064 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5065 gcc_cv_ld_sysroot=yes
5068 if test x"$gcc_cv_ld_sysroot" = xyes; then
5069 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5070 [Define if your linker supports --sysroot.])
5073 # Test for stack protector support in target C library.
5074 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5075 gcc_cv_libc_provides_ssp,
5076 [gcc_cv_libc_provides_ssp=no
5078 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5079 # glibc 2.4 and later provides __stack_chk_fail and
5080 # either __stack_chk_guard, or TLS access to stack guard canary.
5081 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5082 [if test -f $target_header_dir/features.h \
5083 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5084 $target_header_dir/features.h > /dev/null; then
5085 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5086 $target_header_dir/features.h > /dev/null && \
5087 test -f $target_header_dir/bits/uClibc_config.h && \
5088 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5089 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5090 gcc_cv_libc_provides_ssp=yes
5092 # all versions of Bionic support stack protector
5093 elif test -f $target_header_dir/sys/cdefs.h \
5094 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5095 $target_header_dir/sys/cdefs.h > /dev/null; then
5096 gcc_cv_libc_provides_ssp=yes
5100 # Avoid complicated tests (see
5101 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5102 # simply assert that glibc does provide this, which is true for all
5103 # realistically usable GNU/Hurd configurations.
5104 gcc_cv_libc_provides_ssp=yes;;
5105 *-*-darwin* | *-*-freebsd*)
5106 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5107 [echo "no __stack_chk_fail on this target"])
5109 *) gcc_cv_libc_provides_ssp=no ;;
5112 if test x$gcc_cv_libc_provides_ssp = xyes; then
5113 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5114 [Define if your target C library provides stack protector support])
5117 # Test for <sys/sdt.h> on the target.
5118 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5119 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5121 if test -f $target_header_dir/sys/sdt.h; then
5123 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5124 [Define if your target C library provides sys/sdt.h])
5126 AC_MSG_RESULT($have_sys_sdt_h)
5128 # Check if TFmode long double should be used by default or not.
5129 # Some glibc targets used DFmode long double, but with glibc 2.4
5130 # and later they can use TFmode.
5132 powerpc*-*-linux* | \
5136 AC_ARG_WITH(long-double-128,
5137 [AS_HELP_STRING([--with-long-double-128],
5138 [use 128-bit long double by default])],
5139 gcc_cv_target_ldbl128="$with_long_double_128",
5140 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5141 [gcc_cv_target_ldbl128=no
5142 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5143 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5144 && gcc_cv_target_ldbl128=yes
5148 if test x$gcc_cv_target_ldbl128 = xyes; then
5149 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5150 [Define if TFmode long double should be the default])
5153 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5154 gcc_cv_target_dl_iterate_phdr=unknown
5156 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5157 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5158 # libdl there, both complicating its use and breaking compatibility
5159 # between Solaris 10 updates.
5160 *-*-solaris2.1[[1-9]]*)
5161 # <link.h> needs both a dl_iterate_phdr declaration and support for
5162 # compilation with largefile support.
5163 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5164 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5165 gcc_cv_target_dl_iterate_phdr=yes
5167 gcc_cv_target_dl_iterate_phdr=no
5170 *-*-dragonfly* | *-*-freebsd*)
5171 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5172 gcc_cv_target_dl_iterate_phdr=yes
5174 gcc_cv_target_dl_iterate_phdr=no
5178 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5179 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5180 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5181 [Define if your target C library provides the `dl_iterate_phdr' function.])
5183 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5185 # We no longer support different GC mechanisms. Emit an error if
5186 # the user configures with --with-gc.
5188 [AS_HELP_STRING([--with-gc={page,zone}],
5189 [this option is not supported anymore. It used to choose
5190 the garbage collection mechanism to use with the compiler])],
5191 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5194 # Libraries to use on the host. This will normally be set by the top
5195 # level Makefile. Here we simply capture the value for our Makefile.
5196 if test -z "${HOST_LIBS+set}"; then
5201 # Use the system's zlib library.
5203 zlibinc="-I\$(srcdir)/../zlib"
5204 AC_ARG_WITH(system-zlib,
5205 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5212 dnl Very limited version of automake's enable-maintainer-mode
5214 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5215 dnl maintainer-mode is disabled by default
5216 AC_ARG_ENABLE(maintainer-mode,
5217 [AS_HELP_STRING([--enable-maintainer-mode],
5218 [enable make rules and dependencies not useful
5219 (and sometimes confusing) to the casual installer])],
5220 maintainer_mode=$enableval,
5223 AC_MSG_RESULT($maintainer_mode)
5225 if test "$maintainer_mode" = "yes"; then
5232 dnl Whether to prevent multiple front-ends from linking at the same time
5234 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5235 AC_ARG_ENABLE(link-mutex,
5236 [AS_HELP_STRING([--enable-link-mutex],
5237 [avoid linking multiple front-ends at once to avoid thrashing
5238 on the build machine])],
5239 do_link_mutex=$enableval,
5241 AC_MSG_RESULT($do_link_mutex)
5243 if test "$do_link_mutex" = "yes"; then
5248 AC_SUBST(DO_LINK_MUTEX)
5254 # Make empty files to contain the specs and options for each language.
5255 # Then add #include lines to for a compiler that has specs and/or options.
5261 # These (without "all_") are set in each config-lang.in.
5262 # `language' must be a single word so is spelled singularly.
5265 all_outputs='Makefile'
5266 # List of language makefile fragments.
5268 # Additional files for gengtype
5269 all_gtfiles="$target_gtfiles"
5271 # These are the languages that are set in --enable-languages,
5272 # and are available in the GCC tree.
5273 all_selected_languages=
5275 # Add the language fragments.
5276 # Languages are added via two mechanisms. Some information must be
5277 # recorded in makefile variables, these are defined in config-lang.in.
5278 # We accumulate them and plug them into the main Makefile.
5279 # The other mechanism is a set of hooks for each of the main targets
5280 # like `clean', `install', etc.
5282 language_hooks="Make-hooks"
5284 for lang in ${srcdir}/*/config-lang.in
5287 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5289 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5290 if test "x$lang_alias" = x
5292 echo "$lang doesn't set \$language." 1>&2
5295 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5296 subdirs="$subdirs $subdir"
5298 # $gcc_subdir is where the gcc integration files are to be found
5299 # for a language, both for internal compiler purposes (compiler
5300 # sources implementing front-end to GCC tree converters), and for
5301 # build infrastructure purposes (Make-lang.in, etc.)
5303 # This will be <subdir> (relative to $srcdir) if a line like
5304 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5305 # is found in <langdir>/config-lang.in, and will remain <langdir>
5308 # Except for the language alias (fetched above), the regular
5309 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5310 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5311 # only this and the language alias.
5313 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5314 if [ "$gcc_subdir" = "" ]; then
5315 gcc_subdir="$subdir"
5318 case ",$enable_languages," in
5320 all_selected_languages="$all_selected_languages $lang_alias"
5321 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5322 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5334 . ${srcdir}/$gcc_subdir/config-lang.in
5335 if test "x$language" = x
5337 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5342 case ",$enable_languages," in
5345 for i in $subdir_requires; do
5346 test -f "${srcdir}/$i/config-lang.in" && continue
5354 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5355 if test -f $srcdir/$gcc_subdir/lang.opt; then
5356 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5357 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5359 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5360 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5362 all_languages="$all_languages $language"
5363 all_compilers="$all_compilers $compilers"
5364 all_outputs="$all_outputs $outputs"
5365 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5366 case ",$enable_languages," in
5368 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5370 AC_SUBST(enable_lto)
5377 for language in $all_selected_languages
5379 check_languages="$check_languages check-$language"
5382 # We link each language in with a set of hooks, reached indirectly via
5383 # lang.${target}. Only do so for selected languages.
5387 target_list="all.cross start.encap rest.encap tags \
5388 install-common install-man install-info install-pdf install-html dvi \
5389 pdf html uninstall info man srcextra srcman srcinfo \
5390 mostlyclean clean distclean maintainer-clean install-plugin"
5392 for t in $target_list
5395 for lang in $all_selected_languages
5399 echo "lang.$t: $x" >> Make-hooks
5403 # Option include files
5406 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5407 option_includes="option-includes.mk"
5408 AC_SUBST_FILE(option_includes)
5416 echo "dir ." > .gdbinit
5417 echo "dir ${srcdir}" >> .gdbinit
5418 if test x$gdb_needs_out_file_path = xyes
5420 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5422 if test "x$subdirs" != x; then
5425 echo "dir ${srcdir}/$s" >> .gdbinit
5428 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5429 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5431 # Put a breakpoint on __asan_report_error to help with debugging buffer
5434 *-fsanitize=address*)
5435 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5439 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5440 AC_SUBST(gcc_tooldir)
5443 # Find a directory in which to install a shared libgcc.
5445 AC_ARG_ENABLE(version-specific-runtime-libs,
5446 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5447 [specify that runtime libraries should be
5448 installed in a compiler-specific directory])])
5450 # Set default prefix canonicalization.
5452 AC_ARG_ENABLE(canonical-prefixes,
5453 [ --enable-canonical-prefixes
5454 enable or disable prefix canonicalization],
5456 enable_canonical_prefixes=yes)
5457 if test x"$enable_canonical_prefixes" = xyes; then
5458 AC_DEFINE(ENABLE_CANONICAL_PREFIXES,
5459 1, [Define to enable prefix canonicalization.])
5462 # Substitute configuration variables
5465 AC_SUBST(all_compilers)
5466 AC_SUBST(all_gtfiles)
5467 AC_SUBST(all_lang_makefrags)
5468 AC_SUBST(all_languages)
5469 AC_SUBST(all_selected_languages)
5470 AC_SUBST(build_exeext)
5471 AC_SUBST(build_install_headers_dir)
5472 AC_SUBST(build_xm_file_list)
5473 AC_SUBST(build_xm_include_list)
5474 AC_SUBST(build_xm_defines)
5475 AC_SUBST(build_file_translate)
5476 AC_SUBST(check_languages)
5477 AC_SUBST(cpp_install_dir)
5478 AC_SUBST(xmake_file)
5479 AC_SUBST(tmake_file)
5480 AC_SUBST(TM_ENDIAN_CONFIG)
5481 AC_SUBST(TM_MULTILIB_CONFIG)
5482 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5483 AC_SUBST(extra_gcc_objs)
5484 AC_SUBST(user_headers_inc_next_pre)
5485 AC_SUBST(user_headers_inc_next_post)
5486 AC_SUBST(extra_headers_list)
5487 AC_SUBST(extra_objs)
5488 AC_SUBST(extra_programs)
5489 AC_SUBST(float_h_file)
5490 AC_SUBST(gcc_config_arguments)
5491 AC_SUBST(gcc_gxx_include_dir)
5492 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5493 AC_SUBST(host_exeext)
5494 AC_SUBST(host_xm_file_list)
5495 AC_SUBST(host_xm_include_list)
5496 AC_SUBST(host_xm_defines)
5497 AC_SUBST(out_host_hook_obj)
5499 AC_SUBST(lang_opt_files)
5500 AC_SUBST(lang_specs_files)
5501 AC_SUBST(lang_tree_files)
5502 AC_SUBST(local_prefix)
5504 AC_SUBST(objc_boehm_gc)
5506 AC_SUBST(out_object_file)
5507 AC_SUBST(common_out_file)
5508 AC_SUBST(common_out_object_file)
5509 AC_SUBST(tm_file_list)
5510 AC_SUBST(tm_include_list)
5511 AC_SUBST(tm_defines)
5512 AC_SUBST(tm_p_file_list)
5513 AC_SUBST(tm_p_include_list)
5514 AC_SUBST(xm_file_list)
5515 AC_SUBST(xm_include_list)
5516 AC_SUBST(xm_defines)
5517 AC_SUBST(use_gcc_stdint)
5518 AC_SUBST(c_target_objs)
5519 AC_SUBST(cxx_target_objs)
5520 AC_SUBST(fortran_target_objs)
5521 AC_SUBST(target_cpu_default)
5523 AC_SUBST_FILE(language_hooks)
5526 if test x${build} = x${host} ; then
5527 if test x${host} = x${target} ; then
5528 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5530 echo "Links are now set up to build a cross-compiler" 1>&2
5531 echo " from ${host} to ${target}." 1>&2
5534 if test x${host} = x${target} ; then
5535 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5536 echo " for ${target}." 1>&2
5538 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5539 echo " from ${host} to ${target}." 1>&2
5543 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5544 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5546 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5547 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5549 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5550 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5551 if test "x${CLOOGLIBS}" != "x" ; then
5552 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5555 # Check for plugin support
5556 AC_ARG_ENABLE(plugin,
5557 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5558 enable_plugin=$enableval,
5559 enable_plugin=yes; default_plugin=yes)
5565 if test x$build = x$host; then
5566 export_sym_check="nm${exeext} -g"
5567 elif test x$host = x$target; then
5568 export_sym_check="$gcc_cv_nm -g"
5574 if test x$build = x$host; then
5575 export_sym_check="objdump${exeext} -T"
5576 elif test x$host = x$target; then
5577 export_sym_check="$gcc_cv_objdump -T"
5584 if test x"$enable_plugin" = x"yes"; then
5586 AC_MSG_CHECKING([for exported symbols])
5587 if test "x$export_sym_check" != x; then
5588 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5589 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5590 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5591 : # No need to use a flag
5592 AC_MSG_RESULT([yes])
5594 AC_MSG_RESULT([yes])
5595 AC_MSG_CHECKING([for -rdynamic])
5596 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5597 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5599 pluginlibs="-rdynamic"
5604 AC_MSG_RESULT([$plugin_rdynamic])
5607 AC_MSG_RESULT([unable to check])
5612 AC_SEARCH_LIBS([dlopen], [dl])
5613 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5614 pluginlibs="$pluginlibs -ldl"
5618 # Check that we can build shared objects with -fPIC -shared
5619 saved_LDFLAGS="$LDFLAGS"
5620 saved_CFLAGS="$CFLAGS"
5623 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5624 CFLAGS="$CFLAGS -fPIC"
5625 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5628 CFLAGS="$CFLAGS -fPIC"
5629 LDFLAGS="$LDFLAGS -fPIC -shared"
5632 AC_MSG_CHECKING([for -fPIC -shared])
5634 [extern int X;],[return X == 0;],
5635 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5636 [AC_MSG_RESULT([no]); have_pic_shared=no])
5637 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5641 LDFLAGS="$saved_LDFLAGS"
5642 CFLAGS="$saved_CFLAGS"
5644 # If plugin support had been requested but not available, fail.
5645 if test x"$enable_plugin" = x"no" ; then
5646 if test x"$default_plugin" != x"yes"; then
5648 Building GCC with plugin support requires a host that supports
5649 -fPIC, -shared, -ldl and -rdynamic.])
5654 AC_SUBST(pluginlibs)
5655 AC_SUBST(enable_plugin)
5656 if test x"$enable_plugin" = x"yes"; then
5657 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5661 # Enable --enable-host-shared
5662 AC_ARG_ENABLE(host-shared,
5663 [AS_HELP_STRING([--enable-host-shared],
5664 [build host code as shared libraries])],
5665 [PICFLAG=-fPIC], [PICFLAG=])
5666 AC_SUBST(enable_host_shared)
5670 AC_ARG_ENABLE(libquadmath-support,
5671 [AS_HELP_STRING([--disable-libquadmath-support],
5672 [disable libquadmath support for Fortran])],
5673 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5674 ENABLE_LIBQUADMATH_SUPPORT=yes)
5675 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5676 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5677 [Define to 1 to enable libquadmath support])
5681 warn_frame_larger_than_extra_text=
5682 AC_ARG_WITH(warn-frame-larger-than-extra-text,
5683 [ --with-warn-frame-larger-than-extra-text=TEXT
5684 specifies extra text for frame size warnings],
5685 [case "${withval}" in
5686 yes) AC_MSG_ERROR(bad value ${withval} given for frame size warning text) ;;
5688 *) warn_frame_larger_than_extra_text="$withval" ;;
5690 AC_DEFINE_UNQUOTED(WARN_FRAME_LARGER_THAN_EXTRA_TEXT,
5691 "$warn_frame_larger_than_extra_text",
5692 [Define to be extra text for frame size warnings.])
5695 # Specify what hash style to use by default.
5696 AC_ARG_WITH([linker-hash-style],
5697 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5698 [specify the linker hash style])],
5699 [case x"$withval" in
5701 LINKER_HASH_STYLE=sysv
5704 LINKER_HASH_STYLE=gnu
5707 LINKER_HASH_STYLE=both
5710 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5713 [LINKER_HASH_STYLE=''])
5714 if test x"${LINKER_HASH_STYLE}" != x; then
5715 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5716 [The linker hash style])
5719 # Configure the subdirectories
5720 # AC_CONFIG_SUBDIRS($subdirs)
5722 # Create the Makefile
5723 # and configure language subdirectories
5724 AC_CONFIG_FILES($all_outputs)
5726 AC_CONFIG_COMMANDS([default],
5728 case ${CONFIG_HEADERS} in
5729 *auto-host.h:config.in*)
5732 # Make sure all the subdirs exist.
5733 for d in $subdirs doc build common c-family
5735 test -d $d || mkdir $d
5738 [subdirs='$subdirs'])