2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2014 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3. If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
28 AC_CONFIG_SRCDIR(tree.c)
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 ACX_NONCANONICAL_TARGET
41 # Determine the target- and build-specific subdirectories
44 # Set program_transform_name
47 # Check for bogus environment variables.
48 # Test if LIBRARY_PATH contains the notation for the current directory
49 # since this would lead to problems installing/building glibc.
50 # LIBRARY_PATH contains the current directory if one of the following
52 # - one of the terminals (":" and ";") is the first or last sign
53 # - two terminals occur directly after each other
54 # - the path contains an element with a dot in it
55 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 case ${LIBRARY_PATH} in
58 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
59 library_path_setting="contains current directory"
62 library_path_setting="ok"
66 AC_MSG_RESULT($library_path_setting)
67 if test "$library_path_setting" != "ok"; then
69 *** LIBRARY_PATH shouldn't contain the current directory when
70 *** building gcc. Please change the environment variable
71 *** and run configure again.])
74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
75 # since this would lead to problems installing/building glibc.
76 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # - one of the terminals (":" and ";") is the first or last sign
79 # - two terminals occur directly after each other
80 # - the path contains an element with a dot in it
81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 case ${GCC_EXEC_PREFIX} in
84 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
85 gcc_exec_prefix_setting="contains current directory"
88 gcc_exec_prefix_setting="ok"
92 AC_MSG_RESULT($gcc_exec_prefix_setting)
93 if test "$gcc_exec_prefix_setting" != "ok"; then
95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
96 *** building gcc. Please change the environment variable
97 *** and run configure again.])
104 # Specify the local prefix
106 AC_ARG_WITH(local-prefix,
107 [AS_HELP_STRING([--with-local-prefix=DIR],
108 [specifies directory to put local include])],
109 [case "${withval}" in
110 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
112 *) local_prefix=$with_local_prefix ;;
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117 local_prefix=/usr/local
120 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
121 # passed in by the toplevel make and thus we'd get different behavior
122 # depending on where we built the sources.
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
127 [specifies directory to put g++ header files])],
128 [case "${withval}" in
129 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
131 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
134 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
135 if test x${gcc_gxx_include_dir} = x; then
136 if test x${enable_version_specific_runtime_libs} = xyes; then
137 gcc_gxx_include_dir='${libsubdir}/include/c++'
139 libstdcxx_incdir='include/c++/$(version)'
140 if test x$host != x$target; then
141 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
143 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
147 gcc_gxx_include_dir_add_sysroot=0
148 if test "${with_sysroot+set}" = set; then
149 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
150 if test "${gcc_gxx_without_sysroot}"; then
151 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
152 gcc_gxx_include_dir_add_sysroot=1
156 AC_ARG_WITH(cpp_install_dir,
157 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
158 [install the user visible C preprocessor in DIR
159 (relative to PREFIX) as well as PREFIX/bin])],
160 [if test x$withval = xyes; then
161 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
162 elif test x$withval != xno; then
163 cpp_install_dir=$withval
166 # We would like to our source tree to be readonly. However when releases or
167 # pre-releases are generated, the flex/bison generated files as well as the
168 # various formats of manuals need to be included along with the rest of the
169 # sources. Therefore we have --enable-generated-files-in-srcdir to do
172 AC_MSG_CHECKING([whether to place generated files in the source directory])
173 dnl generated-files-in-srcdir is disabled by default
174 AC_ARG_ENABLE(generated-files-in-srcdir,
175 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
176 [put copies of generated files in source dir
177 intended for creating source tarballs for users
178 without texinfo bison or flex])],
179 generated_files_in_srcdir=$enableval,
180 generated_files_in_srcdir=no)
182 AC_MSG_RESULT($generated_files_in_srcdir)
184 if test "$generated_files_in_srcdir" = "yes"; then
191 # -------------------
192 # Find default linker
193 # -------------------
197 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
198 gnu_ld_flag="$with_gnu_ld",
201 # With pre-defined ld
203 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
204 DEFAULT_LINKER="$with_ld")
205 if test x"${DEFAULT_LINKER+set}" = x"set"; then
206 if test ! -x "$DEFAULT_LINKER"; then
207 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
208 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
211 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
212 [Define to enable the use of a default linker.])
215 AC_MSG_CHECKING([whether a default linker was specified])
216 if test x"${DEFAULT_LINKER+set}" = x"set"; then
217 if test x"$gnu_ld_flag" = x"no"; then
218 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
220 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
226 # With demangler in GNU ld
227 AC_ARG_WITH(demangler-in-ld,
228 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
229 demangler_in_ld="$with_demangler_in_ld",
232 # ----------------------
233 # Find default assembler
234 # ----------------------
238 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
239 gas_flag="$with_gnu_as",
243 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
244 DEFAULT_ASSEMBLER="$with_as")
245 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
246 if test ! -x "$DEFAULT_ASSEMBLER"; then
247 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
248 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
251 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
252 [Define to enable the use of a default assembler.])
255 AC_MSG_CHECKING([whether a default assembler was specified])
256 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
257 if test x"$gas_flag" = x"no"; then
258 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
260 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
270 # If a non-executable a.out is present (e.g. created by GNU as above even if
271 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
272 # file, even when creating an executable, so an execution test fails.
273 # Remove possible default executable files to avoid this.
275 # FIXME: This really belongs into AC_PROG_CC and can be removed once
276 # Autoconf includes it.
277 rm -f a.out a.exe b.out
279 # Find the native compiler
282 ACX_PROG_GNAT([-I"$srcdir"/ada])
284 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
285 # optimizations to be activated explicitly by the toplevel.
288 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
289 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
294 # Determine PICFLAG for target gnatlib.
295 GCC_PICFLAG_FOR_TARGET
296 AC_SUBST(PICFLAG_FOR_TARGET)
298 # -------------------------
299 # Check C compiler features
300 # -------------------------
302 AC_USE_SYSTEM_EXTENSIONS
308 # sizeof(char) is 1 by definition.
309 AC_CHECK_SIZEOF(void *)
310 AC_CHECK_SIZEOF(short)
312 AC_CHECK_SIZEOF(long)
313 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
315 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
316 AC_MSG_ERROR([uint64_t or int64_t not found])
319 # check what underlying integer type int64_t uses
321 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
322 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
326 template <typename T> struct X { };
328 struct X<long> { typedef long t; };
329 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
330 if test "$ac_cv_int64_t_type" = "long"; then
331 AC_DEFINE(INT64_T_IS_LONG, 1,
332 [Define if int64_t uses long as underlying type.])
334 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
338 template <typename T> struct X { };
340 struct X<long long> { typedef long long t; };
341 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
348 # ---------------------
349 # Warnings and checking
350 # ---------------------
352 # Check $CC warning features (if it's GCC).
353 # We want to use -pedantic, but we don't want warnings about
357 # * C++11 narrowing conversions in { }
358 # So, we only use -pedantic if we can disable those warnings.
360 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
361 AC_ARG_ENABLE(build-format-warnings,
362 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
363 [],[enable_build_format_warnings=yes])
364 AS_IF([test $enable_build_format_warnings = no],
365 [wf_opt=-Wno-format],[wf_opt=])
366 ACX_PROG_CC_WARNING_OPTS(
367 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
368 ACX_PROG_CC_WARNING_OPTS(
369 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
371 ACX_PROG_CC_WARNING_OPTS(
372 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
373 ACX_PROG_CC_WARNING_OPTS(
374 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
375 ACX_PROG_CC_WARNING_OPTS(
376 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
377 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
378 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
379 [-Wno-overlength-strings])), [strict_warn])
380 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
382 # The above macros do nothing if the compiler is not GCC. However, the
383 # Makefile has more goo to add other flags, so these variables are used
384 # to enable warnings only for GCC.
387 if test "x$GCC" = "xyes"; then
388 warn_cflags='$(GCC_WARN_CFLAGS)'
389 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
391 AC_SUBST(warn_cflags)
392 AC_SUBST(warn_cxxflags)
394 # Disable exceptions and RTTI if building with g++
395 ACX_PROG_CC_WARNING_OPTS(
396 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
399 # Enable expensive internal checks
401 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
405 AC_ARG_ENABLE(checking,
406 [AS_HELP_STRING([[--enable-checking[=LIST]]],
407 [enable expensive run-time checks. With LIST,
408 enable only specific categories of checks.
409 Categories are: yes,no,all,none,release.
410 Flags are: assert,df,fold,gc,gcac,gimple,misc,
411 rtlflag,rtl,runtime,tree,valgrind,types])],
412 [ac_checking_flags="${enableval}"],[
413 # Determine the default checks.
414 if test x$is_release = x ; then
415 ac_checking_flags=yes
417 ac_checking_flags=release
419 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
420 for check in release $ac_checking_flags
423 # these set all the flags to specific states
424 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
425 ac_fold_checking= ; ac_gc_checking=1 ;
426 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
427 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
428 ac_tree_checking=1 ; ac_valgrind_checking= ;
429 ac_types_checking=1 ;;
430 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
431 ac_fold_checking= ; ac_gc_checking= ;
432 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
433 ac_rtlflag_checking= ; ac_runtime_checking= ;
434 ac_tree_checking= ; ac_valgrind_checking= ;
435 ac_types_checking= ;;
436 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
437 ac_fold_checking=1 ; ac_gc_checking=1 ;
438 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
439 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
440 ac_tree_checking=1 ; ac_valgrind_checking= ;
441 ac_types_checking=1 ;;
442 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
443 ac_fold_checking= ; ac_gc_checking= ;
444 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
445 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
446 ac_tree_checking= ; ac_valgrind_checking= ;
447 ac_types_checking= ;;
448 # these enable particular checks
449 assert) ac_assert_checking=1 ;;
450 df) ac_df_checking=1 ;;
451 fold) ac_fold_checking=1 ;;
452 gc) ac_gc_checking=1 ;;
453 gcac) ac_gc_always_collect=1 ;;
454 gimple) ac_gimple_checking=1 ;;
455 misc) ac_checking=1 ;;
456 rtl) ac_rtl_checking=1 ;;
457 rtlflag) ac_rtlflag_checking=1 ;;
458 runtime) ac_runtime_checking=1 ;;
459 tree) ac_tree_checking=1 ;;
460 types) ac_types_checking=1 ;;
461 valgrind) ac_valgrind_checking=1 ;;
462 *) AC_MSG_ERROR(unknown check category $check) ;;
468 if test x$ac_checking != x ; then
469 AC_DEFINE(ENABLE_CHECKING, 1,
470 [Define if you want more run-time sanity checks. This one gets a grab
471 bag of miscellaneous but relatively cheap checks.])
472 nocommon_flag=-fno-common
474 AC_SUBST(nocommon_flag)
475 if test x$ac_df_checking != x ; then
476 AC_DEFINE(ENABLE_DF_CHECKING, 1,
477 [Define if you want more run-time sanity checks for dataflow.])
479 if test x$ac_assert_checking != x ; then
480 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
481 [Define if you want assertions enabled. This is a cheap check.])
483 if test x$ac_gimple_checking != x ; then
484 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
485 [Define if you want operations on GIMPLE (the basic data structure of
486 the high-level optimizers) to be checked for dynamic type safety at
487 runtime. This is moderately expensive.])
489 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
490 if test x$ac_runtime_checking != x ; then
491 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
492 [Define if you want runtime assertions enabled. This is a cheap check.])
494 if test x$ac_tree_checking != x ; then
495 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
496 [Define if you want all operations on trees (the basic data
497 structure of the front ends) to be checked for dynamic type safety
498 at runtime. This is moderately expensive. The tree browser debugging
499 routines will also be enabled by this option.
501 TREEBROWSER=tree-browser.o
504 if test x$ac_types_checking != x ; then
505 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
506 [Define if you want all gimple types to be verified after gimplifiation.
510 AC_SUBST(TREEBROWSER)
511 AC_SUBST(TREECHECKING)
512 if test x$ac_rtl_checking != x ; then
513 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
514 [Define if you want all operations on RTL (the basic data structure
515 of the optimizer and back end) to be checked for dynamic type safety
516 at runtime. This is quite expensive.])
518 if test x$ac_rtlflag_checking != x ; then
519 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
520 [Define if you want RTL flag accesses to be checked against the RTL
521 codes that are supported for each access macro. This is relatively
524 if test x$ac_gc_checking != x ; then
525 AC_DEFINE(ENABLE_GC_CHECKING, 1,
526 [Define if you want the garbage collector to do object poisoning and
527 other memory allocation checks. This is quite expensive.])
529 if test x$ac_gc_always_collect != x ; then
530 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
531 [Define if you want the garbage collector to operate in maximally
532 paranoid mode, validating the entire heap and collecting garbage at
533 every opportunity. This is extremely expensive.])
535 if test x$ac_fold_checking != x ; then
536 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
537 [Define if you want fold checked that it never destructs its argument.
538 This is quite expensive.])
540 valgrind_path_defines=
543 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
544 dnl # an if statement. This was the source of very frustrating bugs
545 dnl # in converting to autoconf 2.5x!
546 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
548 # It is certainly possible that there's valgrind but no valgrind.h.
549 # GCC relies on making annotations so we must have both.
550 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
551 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
552 [[#include <valgrind/memcheck.h>
553 #ifndef VALGRIND_DISCARD
554 #error VALGRIND_DISCARD not defined
556 [gcc_cv_header_valgrind_memcheck_h=yes],
557 [gcc_cv_header_valgrind_memcheck_h=no])
558 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
559 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
560 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
561 [[#include <memcheck.h>
562 #ifndef VALGRIND_DISCARD
563 #error VALGRIND_DISCARD not defined
565 [gcc_cv_header_memcheck_h=yes],
566 [gcc_cv_header_memcheck_h=no])
567 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
568 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
569 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
570 [Define if valgrind's valgrind/memcheck.h header is installed.])
572 if test $gcc_cv_header_memcheck_h = yes; then
573 AC_DEFINE(HAVE_MEMCHECK_H, 1,
574 [Define if valgrind's memcheck.h header is installed.])
577 if test x$ac_valgrind_checking != x ; then
578 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
579 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
580 if test "x$valgrind_path" = "x" \
581 || (test $have_valgrind_h = no \
582 && test $gcc_cv_header_memcheck_h = no \
583 && test $gcc_cv_header_valgrind_memcheck_h = no); then
584 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
586 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
587 valgrind_command="$valgrind_path -q"
588 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
589 [Define if you want to run subprograms and generated programs
590 through valgrind (a memory checker). This is extremely expensive.])
592 AC_SUBST(valgrind_path_defines)
593 AC_SUBST(valgrind_command)
595 # Enable code coverage collection
596 AC_ARG_ENABLE(coverage,
597 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
598 [enable compiler's code coverage collection.
599 Use to measure compiler performance and locate
600 unused parts of the compiler. With LEVEL, specify
601 optimization. Values are opt, noopt,
603 [case "${enableval}" in
605 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
608 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
611 # a.k.a. --disable-coverage
615 AC_MSG_ERROR(unknown coverage setting $enableval)
619 AC_SUBST(coverage_flags)
621 AC_ARG_ENABLE(gather-detailed-mem-stats,
622 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
623 [enable detailed memory allocation stats gathering])], [],
624 [enable_gather_detailed_mem_stats=no])
625 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
626 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
627 [Define to enable detailed memory allocation stats gathering.])
629 AC_ARG_ENABLE(valgrind-annotations,
630 [AS_HELP_STRING([--enable-valgrind-annotations],
631 [enable valgrind runtime interaction])], [],
632 [enable_valgrind_annotations=no])
633 if test x$enable_valgrind_annotations != xno \
634 || test x$ac_valgrind_checking != x; then
635 if (test $have_valgrind_h = no \
636 && test $gcc_cv_header_memcheck_h = no \
637 && test $gcc_cv_header_valgrind_memcheck_h = no); then
638 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
640 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
641 [Define to get calls to the valgrind runtime enabled.])
644 # -------------------------------
645 # Miscenalleous configure options
646 # -------------------------------
650 [AS_HELP_STRING([--with-stabs],
651 [arrange to use stabs instead of host debug format])],
655 # Determine whether or not multilibs are enabled.
656 AC_ARG_ENABLE(multilib,
657 [AS_HELP_STRING([--enable-multilib],
658 [enable library support for multiple ABIs])],
659 [], [enable_multilib=yes])
660 AC_SUBST(enable_multilib)
662 # Determine whether or not multiarch is enabled.
663 AC_ARG_ENABLE(multiarch,
664 [AS_HELP_STRING([--enable-multiarch],
665 [enable support for multiarch paths])],
666 [case "${enableval}" in
667 yes|no|auto) enable_multiarch=$enableval;;
668 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
669 esac], [enable_multiarch=auto])
670 if test x${enable_multiarch} = xauto; then
671 if test x${with_native_system_header_dir} != x; then
672 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
675 if test x$host != x$target && test "x$with_sysroot" = x; then
676 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
680 AC_MSG_CHECKING(for multiarch configuration)
681 AC_SUBST(enable_multiarch)
682 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
684 # needed for setting the multiarch name for soft-float/hard-float ABIs
688 # Enable __cxa_atexit for C++.
689 AC_ARG_ENABLE(__cxa_atexit,
690 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
693 # Enable C extension for decimal float if target supports it.
694 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
696 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
697 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
698 [Define to 1 to enable decimal float extension to C.])
700 # Use default_decimal_float for dependency.
701 enable_decimal_float=$default_decimal_float
703 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
704 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
705 [Define to 1 to specify that we are using the BID decimal floating
706 point format instead of DPD])
708 # Enable C extension for fixed-point arithmetic.
709 AC_ARG_ENABLE(fixed-point,
710 [AS_HELP_STRING([--enable-fixed-point],
711 [enable fixed-point arithmetic extension to C])],
716 enable_fixed_point=yes
720 enable_fixed_point=yes
723 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
724 enable_fixed_point=no
728 AC_SUBST(enable_fixed_point)
730 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
731 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
732 [Define to 1 to enable fixed-point arithmetic extension to C.])
735 # Pass with no value to take the default
736 # Pass with a value to specify a thread package
737 AC_ARG_ENABLE(threads,
738 [AS_HELP_STRING([[--enable-threads[=LIB]]],
739 [enable thread usage for target GCC,
740 using LIB thread package])],,
744 [AS_HELP_STRING([--enable-tls],
745 [enable or disable generation of tls code
746 overriding the assembler check for tls support])],
750 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
751 Valid choices are 'yes' and 'no'.]) ;;
755 AC_ARG_ENABLE(objc-gc,
756 [AS_HELP_STRING([--enable-objc-gc],
757 [enable the use of Boehm's garbage collector with
758 the GNU Objective-C runtime])],
759 if test x$enable_objc_gc = xno; then
767 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
768 dwarf2="$with_dwarf2",
771 AC_ARG_ENABLE(shared,
772 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
774 case $enable_shared in
778 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
779 for pkg in $enableval; do
780 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
787 ], [enable_shared=yes])
788 AC_SUBST(enable_shared)
790 AC_ARG_WITH([native-system-header-dir],
791 [ --with-native-system-header-dir=dir
792 use dir as the directory to look for standard
793 system header files in. Defaults to /usr/include.],
795 case ${with_native_system_header_dir} in
796 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
797 /* | [[A-Za-z]]:[[\\/]]*) ;;
798 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
800 configured_native_system_header_dir="${withval}"
801 ], [configured_native_system_header_dir=])
803 AC_ARG_WITH(build-sysroot,
804 [AS_HELP_STRING([--with-build-sysroot=sysroot],
805 [use sysroot as the system root during the build])],
806 [if test x"$withval" != x ; then
807 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
809 [SYSROOT_CFLAGS_FOR_TARGET=])
810 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
812 if test "x$prefix" = xNONE; then
813 test_prefix=/usr/local
817 if test "x$exec_prefix" = xNONE; then
818 test_exec_prefix=$test_prefix
820 test_exec_prefix=$exec_prefix
824 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
825 [search for usr/lib, usr/include, et al, within DIR])],
827 case ${with_sysroot} in
828 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
829 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
832 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
833 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
835 case ${TARGET_SYSTEM_ROOT} in
836 "${test_prefix}"|"${test_prefix}/"*|\
837 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
838 '${prefix}'|'${prefix}/'*|\
839 '${exec_prefix}'|'${exec_prefix}/'*)
840 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
841 TARGET_SYSTEM_ROOT_DEFINE="$t"
846 TARGET_SYSTEM_ROOT_DEFINE=
847 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
849 AC_SUBST(TARGET_SYSTEM_ROOT)
850 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
851 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
854 [AS_HELP_STRING([--with-specs=SPECS],
855 [add SPECS to driver command-line processing])],
856 [CONFIGURE_SPECS=$withval],
859 AC_SUBST(CONFIGURE_SPECS)
861 ACX_PKGVERSION([GCC])
862 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
864 # Sanity check enable_languages in case someone does not run the toplevel
865 # configure # script.
866 AC_ARG_ENABLE(languages,
867 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
868 [case ,${enable_languages}, in
870 # go safe -- we cannot be much sure without the toplevel
872 # analysis of which target libs are present and usable
876 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
881 enable_languages=c,${enable_languages}
884 [enable_languages=c])
886 AC_ARG_WITH(multilib-list,
887 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
889 with_multilib_list=default)
891 # -------------------------
892 # Checks for other programs
893 # -------------------------
897 # Find some useful tools
899 # We need awk to create options.c and options.h.
900 # Bail out if it's missing.
902 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
909 AC_SUBST(ranlib_flags)
913 # See if cmp has --ignore-initial.
914 gcc_AC_PROG_CMP_IGNORE_INITIAL
916 # See if we have the mktemp command.
917 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
919 # See if makeinfo has been installed and is modern enough
920 # that we can use it.
921 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
922 [GNU texinfo.* \([0-9][0-9.]*\)],
923 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
924 if test $gcc_cv_prog_makeinfo_modern = no; then
926 *** Makeinfo is missing or too old.
927 *** Info documentation will not be built.])
934 # Is pod2man recent enough to regenerate manpages?
935 AC_MSG_CHECKING([for recent Pod::Man])
936 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
938 GENERATED_MANPAGES=generated-manpages
943 AC_SUBST(GENERATED_MANPAGES)
945 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
948 dnl Don't use AC_PROG_LEX; we insist on flex.
949 dnl LEXLIB is not useful in gcc.
950 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
953 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
955 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
956 # check for build == host before using them.
959 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
960 && test -d ../binutils ; then
961 NM='${objdir}/../binutils/nm-new'
963 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
967 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
968 && test -d ../binutils ; then
969 AR='${objdir}/../binutils/ar'
971 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
975 # --------------------
976 # Checks for C headers
977 # --------------------
979 # Need to reject headers which give warnings, so that the -Werror bootstrap
980 # works later. *sigh* This needs to come before all header checks.
988 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
989 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
990 sys/resource.h sys/param.h sys/times.h sys/stat.h \
991 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
993 # Check for thread headers.
994 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
995 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
997 # These tests can't be done till we know if we have limits.h.
1001 # ----------------------
1002 # Checks for C++ headers
1003 # ----------------------
1005 dnl Autoconf will give an error in the configure script if there is no
1006 dnl C++ preprocessor. Hack to prevent that.
1007 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1009 m4_popdef([AC_MSG_ERROR])[]dnl
1013 AC_CHECK_HEADERS(unordered_map)
1014 AC_CHECK_HEADERS(tr1/unordered_map)
1015 AC_CHECK_HEADERS(ext/hash_map)
1020 # Dependency checking.
1025 AC_CONFIG_COMMANDS([gccdepdir],[
1026 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1027 for lang in $subdirs c-family common
1029 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1030 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1032 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1040 # These libraries may be used by collect2.
1041 # We may need a special search path to get them linked.
1042 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1044 for libs in '' -lld -lmld \
1045 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1046 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1049 AC_TRY_LINK_FUNC(ldopen,
1050 [gcc_cv_collect2_libs="$libs"; break])
1053 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1054 case $gcc_cv_collect2_libs in
1056 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1058 AC_SUBST(COLLECT2_LIBS)
1060 # When building Ada code on Alpha, we need exc_resume which is usually in
1061 # -lexc. So test for it.
1064 AC_SEARCH_LIBS(exc_resume, exc)
1067 AC_SUBST(GNAT_LIBEXC)
1069 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1072 AC_SEARCH_LIBS(kstat_open, kstat)
1073 EXTRA_GCC_LIBS="$LIBS"
1075 AC_SUBST(EXTRA_GCC_LIBS)
1077 # Some systems put ldexp and frexp in libm instead of libc; assume
1078 # they're both in the same place. jcf-dump needs them.
1081 AC_SEARCH_LIBS(ldexp, m)
1086 # Use <inttypes.h> only if it exists,
1087 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1089 AC_MSG_CHECKING(for inttypes.h)
1090 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1091 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1092 [[#define __STDC_FORMAT_MACROS
1093 #include <sys/types.h>
1094 #include <inttypes.h>]],
1099 [gcc_cv_header_inttypes_h=yes],
1100 [gcc_cv_header_inttypes_h=no])])
1101 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1102 if test $gcc_cv_header_inttypes_h = yes; then
1103 AC_DEFINE(HAVE_INTTYPES_H, 1,
1104 [Define if you have a working <inttypes.h> header file.])
1107 dnl Disabled until we have a complete test for buggy enum bitfields.
1108 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1110 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1111 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1112 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1113 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1114 putchar_unlocked putc_unlocked)
1115 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1116 sysconf strsignal getrusage nl_langinfo \
1117 gettimeofday mbstowcs wcswidth mmap setlocale \
1118 gcc_UNLOCKED_FUNCS madvise)
1120 if test x$ac_cv_func_mbstowcs = xyes; then
1121 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1122 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1128 [gcc_cv_func_mbstowcs_works=yes],
1129 [gcc_cv_func_mbstowcs_works=no],
1130 [gcc_cv_func_mbstowcs_works=yes])])
1131 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1132 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1133 [Define this macro if mbstowcs does not crash when its
1134 first argument is NULL.])
1138 AC_CHECK_TYPE(ssize_t, int)
1139 AC_CHECK_TYPE(caddr_t, char *)
1141 GCC_AC_FUNC_MMAP_BLACKLIST
1145 # Under VMS, vfork works very differently than on Unix. The standard test
1146 # won't work, and it isn't easily adaptable. It makes more sense to
1148 ac_cv_func_vfork_works=yes
1153 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1154 # iconv() prototype.
1159 # Until we have in-tree GNU iconv:
1161 AC_SUBST(LIBICONV_DEP)
1167 # We will need to find libiberty.h and ansidecl.h
1168 saved_CFLAGS="$CFLAGS"
1169 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1170 saved_CXXFLAGS="$CXXFLAGS"
1171 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1172 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1173 strsignal strstr stpcpy strverscmp \
1174 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1175 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1176 #include "ansidecl.h"
1177 #include "system.h"])
1179 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1180 #include "ansidecl.h"
1182 #ifdef HAVE_SYS_RESOURCE_H
1183 #include <sys/resource.h>
1187 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1188 #include "ansidecl.h"
1190 #ifdef HAVE_SYS_RESOURCE_H
1191 #include <sys/resource.h>
1193 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1194 [Define to `long' if <sys/resource.h> doesn't define.])])
1196 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1197 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1198 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1199 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1200 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1201 #include "ansidecl.h"
1210 gcc_AC_CHECK_DECLS(times, , ,[
1211 #include "ansidecl.h"
1213 #ifdef HAVE_SYS_TIMES_H
1214 #include <sys/times.h>
1218 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1219 #include "ansidecl.h"
1224 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1227 gcc_AC_CHECK_DECLS(madvise, , ,[
1228 #include "ansidecl.h"
1233 # More time-related stuff.
1234 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1235 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1236 #include "ansidecl.h"
1238 #ifdef HAVE_SYS_TIMES_H
1239 #include <sys/times.h>
1241 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1242 if test $ac_cv_struct_tms = yes; then
1243 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1244 [Define if <sys/times.h> defines struct tms.])
1247 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1248 # revisit after autoconf 2.50.
1249 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1250 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1251 #include "ansidecl.h"
1253 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1254 if test $gcc_cv_type_clock_t = yes; then
1255 AC_DEFINE(HAVE_CLOCK_T, 1,
1256 [Define if <time.h> defines clock_t.])
1259 # Check if F_SETLKW is supported by fcntl.
1260 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1261 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1262 #include <fcntl.h>]], [[
1268 return fcntl (1, F_SETLKW, &fl);]])],
1269 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1270 if test $ac_cv_f_setlkw = yes; then
1271 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1272 [Define if F_SETLKW supported by fcntl.])
1275 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1276 CFLAGS="$saved_CFLAGS"
1277 CXXFLAGS="$saved_CXXFLAGS"
1279 # mkdir takes a single argument on some systems.
1280 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1288 # With Setjmp/Longjmp based exception handling.
1289 AC_ARG_ENABLE(sjlj-exceptions,
1290 [AS_HELP_STRING([--enable-sjlj-exceptions],
1291 [arrange to use setjmp/longjmp exception handling])],
1294 if test $enableval != yes; then
1295 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1300 force_sjlj_exceptions=yes],
1303 force_sjlj_exceptions=yes
1307 force_sjlj_exceptions=yes
1311 force_sjlj_exceptions=no
1314 if test $force_sjlj_exceptions = yes; then
1315 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1316 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1317 [Define 0/1 to force the choice for exception handling model.])
1320 # --------------------------------------------------------
1321 # Build, host, and target specific configuration fragments
1322 # --------------------------------------------------------
1324 # Collect build-machine-specific information.
1325 . ${srcdir}/config.build
1327 # Collect host-machine-specific information.
1328 . ${srcdir}/config.host
1332 # Collect target-machine-specific information.
1333 . ${srcdir}/config.gcc
1335 extra_objs="${host_extra_objs} ${extra_objs}"
1336 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1338 # Default the target-machine variables that were not explicitly set.
1339 if test x"$tm_file" = x
1340 then tm_file=$cpu_type/$cpu_type.h; fi
1342 if test x"$extra_headers" = x
1343 then extra_headers=; fi
1345 if test x$md_file = x
1346 then md_file=$cpu_type/$cpu_type.md; fi
1348 if test x$out_file = x
1349 then out_file=$cpu_type/$cpu_type.c; fi
1351 if test x"$tmake_file" = x
1352 then tmake_file=$cpu_type/t-$cpu_type
1355 # Support --enable-initfini-array.
1356 if test x$enable_initfini_array != xno; then
1357 tm_file="${tm_file} initfini-array.h"
1360 if test x"$dwarf2" = xyes
1361 then tm_file="$tm_file tm-dwarf2.h"
1364 # Say what files are being used for the output code and MD file.
1365 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1366 echo "Using \`$srcdir/config/$md_file' as machine description file."
1368 # If any of the xm_file variables contain nonexistent files, warn
1369 # about them and drop them.
1372 for x in $build_xm_file; do
1373 if test -f $srcdir/config/$x
1375 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1381 for x in $host_xm_file; do
1382 if test -f $srcdir/config/$x
1384 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1390 for x in $xm_file; do
1391 if test -f $srcdir/config/$x
1393 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1399 for f in $tm_file; do
1402 if test $count = ax; then
1403 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1405 echo "Using the following target machine macro files:"
1406 for f in $tm_file; do
1407 echo " $srcdir/config/$f"
1411 if test x$use_long_long_for_widest_fast_int = xyes; then
1412 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1413 [Define to 1 if the 'long long' type is wider than 'long' but still
1414 efficiently supported by the host hardware.])
1417 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1418 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1420 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1421 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1424 for f in $host_xm_file; do
1427 if test $count = a; then
1429 elif test $count = ax; then
1430 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1432 echo "Using the following host machine macro files:"
1433 for f in $host_xm_file; do
1434 echo " $srcdir/config/$f"
1437 echo "Using ${out_host_hook_obj} for host machine hooks."
1439 if test "$host_xm_file" != "$build_xm_file"; then
1441 for f in $build_xm_file; do
1444 if test $count = a; then
1446 elif test $count = ax; then
1447 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1449 echo "Using the following build machine macro files:"
1450 for f in $build_xm_file; do
1451 echo " $srcdir/config/$f"
1456 if test -n "$configured_native_system_header_dir"; then
1457 native_system_header_dir=$configured_native_system_header_dir
1459 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1460 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1464 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1465 gcc_cv_mcontext_underscores,
1467 #include <sys/cdefs.h>
1468 #include <sys/signal.h>
1469 #include <ucontext.h>
1470 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1472 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1473 if test $gcc_cv_mcontext_underscores = yes; then
1474 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1475 [mcontext_t fields start with __])
1484 # Check if a valid thread package
1485 case ${enable_threads} in
1488 target_thread_file='single'
1492 target_thread_file='single'
1494 aix | dce | lynx | mipssde | posix | rtems | \
1495 single | tpf | vxworks | win32)
1496 target_thread_file=${enable_threads}
1499 echo "${enable_threads} is an unknown thread package" 1>&2
1504 if test x${thread_file} = x; then
1505 # No thread file set by target-specific clauses in config.gcc,
1506 # so use file chosen by default logic above
1507 thread_file=${target_thread_file}
1515 if test x$enable___cxa_atexit = xyes || \
1516 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1517 if test x$host = x$target; then
1519 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1520 # keyed to flag_use_cxa_atexit
1528 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1529 [echo "__cxa_atexit can't be enabled on this target"])
1533 # We can't check for __cxa_atexit when building a cross, so assume
1537 if test x$use_cxa_atexit = xyes; then
1538 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1539 [Define if you want to use __cxa_atexit, rather than atexit, to
1540 register C++ destructors for local statics and global objects.
1541 This is essential for fully standards-compliant handling of
1542 destructors, but requires __cxa_atexit in libc.])
1546 # Look for a file containing extra machine modes.
1547 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1548 extra_modes_file='$(srcdir)'/config/${extra_modes}
1549 AC_SUBST(extra_modes_file)
1550 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1551 [Define to the name of a file containing a list of extra machine modes
1552 for this architecture.])
1555 # Convert extra_options into a form suitable for Makefile use.
1558 for f in $extra_options; do
1559 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1560 all_opt_files="$all_opt_files $srcdir/config/$f"
1562 AC_SUBST(extra_opt_files)
1564 # auto-host.h is the file containing items generated by autoconf and is
1565 # the first file included by config.h.
1566 # If host=build, it is correct to have bconfig include auto-host.h
1567 # as well. If host!=build, we are in error and need to do more
1568 # work to find out the build config parameters.
1569 if test x$host = x$build
1571 build_auto=auto-host.h
1573 # We create a subdir, then run autoconf in the subdir.
1574 # To prevent recursion we set host and build for the new
1575 # invocation of configure to the build for this invocation
1582 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1583 *) realsrcdir=../${srcdir};;
1585 # Clearing GMPINC is necessary to prevent host headers being
1586 # used by the build compiler. Defining GENERATOR_FILE stops
1587 # system.h from including gmp.h.
1588 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1589 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1590 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1591 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1592 ${realsrcdir}/configure \
1593 --enable-languages=${enable_languages-all} \
1594 --target=$target_alias --host=$build_alias --build=$build_alias
1596 # We just finished tests for the build machine, so rename
1597 # the file auto-build.h in the gcc directory.
1598 mv auto-host.h ../auto-build.h
1601 build_auto=auto-build.h
1603 AC_SUBST(build_subdir)
1605 tm_file="${tm_file} defaults.h"
1606 tm_p_file="${tm_p_file} tm-preds.h"
1607 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1608 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1609 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1610 # put this back in temporarily.
1611 xm_file="auto-host.h ansidecl.h ${xm_file}"
1618 # Compile in configure arguments.
1619 if test -f configargs.h ; then
1620 # Being re-configured.
1621 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1622 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1624 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1627 # Double all backslashes and backslash all quotes to turn
1628 # gcc_config_arguments into a C string.
1629 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1630 $gcc_config_arguments
1632 gcc_config_arguments_str=`cat conftest.out`
1635 cat > configargs.h <<EOF
1636 /* Generated automatically. */
1637 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1638 static const char thread_model[] = "$thread_file";
1640 static const struct {
1641 const char *name, *value;
1642 } configure_default_options[] = $configure_default_options;
1647 gcc_BASEVER=`cat $srcdir/BASE-VER`
1648 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1649 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1650 if test -f $srcdir/REVISION ; then
1651 gcc_REVISION=`cat $srcdir/REVISION`
1655 cat > plugin-version.h <<EOF
1656 #include "configargs.h"
1658 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1659 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1660 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1661 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1663 static char basever[] = "$gcc_BASEVER";
1664 static char datestamp[] = "$gcc_DATESTAMP";
1665 static char devphase[] = "$gcc_DEVPHASE";
1666 static char revision[] = "$gcc_REVISION";
1668 /* FIXME plugins: We should make the version information more precise.
1669 One way to do is to add a checksum. */
1671 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1673 configuration_arguments};
1677 # Internationalization
1678 ZW_GNU_GETTEXT_SISTER_DIR
1680 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1681 # -liconv on the link line twice.
1682 case "$LIBINTL" in *$LIBICONV*)
1686 AC_ARG_ENABLE(secureplt,
1687 [AS_HELP_STRING([--enable-secureplt],
1688 [enable -msecure-plt by default for PowerPC])],
1691 AC_ARG_ENABLE(leading-mingw64-underscores,
1692 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1693 [enable leading underscores on 64 bit mingw targets]),
1695 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1696 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1697 [Define if we should use leading underscore on 64 bit mingw targets])])
1700 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1703 AC_ARG_ENABLE(frame-pointer,
1704 [AS_HELP_STRING([--enable-frame-pointer],
1705 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1708 linux* | darwin[[8912]]*)
1709 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1711 enable_frame_pointer=no
1714 enable_frame_pointer=yes
1719 # Windows32 Registry support for specifying GCC installation paths.
1720 AC_ARG_ENABLE(win32-registry,
1721 [AS_HELP_STRING([--disable-win32-registry],
1722 [disable lookup of installation paths in the
1723 Registry on Windows hosts])
1724 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1725 AS_HELP_STRING([--enable-win32-registry=KEY],
1726 [use KEY instead of GCC version as the last portion
1727 of the registry key])],,)
1730 win32 | pe | cygwin* | mingw32* | uwin*)
1731 if test "x$enable_win32_registry" != xno; then
1732 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1735 if test "x$enable_win32_registry" != xno; then
1736 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1737 [Define to 1 if installation paths should be looked up in the Windows
1738 Registry. Ignored on non-Windows hosts.])
1740 if test "x$enable_win32_registry" != xyes \
1741 && test "x$enable_win32_registry" != x; then
1742 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1743 [Define to be the last component of the Windows registry key under which
1744 to look for installation paths. The full key used will be
1745 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1746 The default is the GCC version number.])
1752 # Get an absolute path to the GCC top-level source directory
1753 holddir=`${PWDCMD-pwd}`
1755 topdir=`${PWDCMD-pwd}`
1758 # Conditionalize the makefile for this host machine.
1760 for f in ${host_xmake_file}
1762 if test -f ${srcdir}/config/$f
1764 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1768 # Conditionalize the makefile for this target machine.
1770 for f in ${tmake_file}
1772 if test -f ${srcdir}/config/$f
1774 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1777 tmake_file="${tmake_file_}"
1779 out_object_file=`basename $out_file .c`.o
1780 common_out_object_file=`basename $common_out_file .c`.o
1782 tm_file_list="options.h"
1783 tm_include_list="options.h insn-constants.h"
1784 for f in $tm_file; do
1787 f=`echo $f | sed 's/^..//'`
1788 tm_file_list="${tm_file_list} $f"
1789 tm_include_list="${tm_include_list} $f"
1792 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1793 tm_include_list="${tm_include_list} $f"
1796 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1797 tm_include_list="${tm_include_list} config/$f"
1804 for f in $tm_p_file; do
1807 tm_p_file_list="${tm_p_file_list} $f"
1808 tm_p_include_list="${tm_p_include_list} $f"
1811 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1812 tm_p_include_list="${tm_p_include_list} config/$f"
1818 for f in $xm_file; do
1821 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1822 xm_include_list="${xm_include_list} $f"
1825 xm_file_list="${xm_file_list} $f"
1826 xm_include_list="${xm_include_list} $f"
1829 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1830 xm_include_list="${xm_include_list} config/$f"
1836 host_xm_include_list=
1837 for f in $host_xm_file; do
1840 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1841 host_xm_include_list="${host_xm_include_list} $f"
1844 host_xm_file_list="${host_xm_file_list} $f"
1845 host_xm_include_list="${host_xm_include_list} $f"
1848 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1849 host_xm_include_list="${host_xm_include_list} config/$f"
1855 for f in $build_xm_file; do
1858 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1859 build_xm_include_list="${build_xm_include_list} $f"
1861 auto-build.h | auto-host.h )
1862 build_xm_file_list="${build_xm_file_list} $f"
1863 build_xm_include_list="${build_xm_include_list} $f"
1866 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1867 build_xm_include_list="${build_xm_include_list} config/$f"
1872 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1873 # cross-compiler which does not use the native headers and libraries.
1874 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1875 CROSS= AC_SUBST(CROSS)
1876 ALL=all.internal AC_SUBST(ALL)
1877 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1879 if test "x$with_build_sysroot" != x; then
1880 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1882 # This value is used, even on a native system, because
1883 # CROSS_SYSTEM_HEADER_DIR is just
1884 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1885 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1888 if test x$host != x$target
1890 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1892 SYSTEM_HEADER_DIR=$build_system_header_dir
1893 case "$host","$target" in
1894 # Darwin crosses can use the host system's libraries and headers,
1895 # because of the fat library support. Of course, it must be the
1896 # same version of Darwin on both sides. Allow the user to
1897 # just say --target=foo-darwin without a version number to mean
1898 # "the version on this system".
1899 *-*-darwin*,*-*-darwin*)
1900 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1901 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1902 if test $hostos = $targetos -o $targetos = darwin ; then
1904 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1909 i?86-*-*,x86_64-*-* \
1910 | powerpc*-*-*,powerpc64*-*-*)
1911 CROSS="$CROSS -DNATIVE_CROSS" ;;
1916 if test "x$with_headers" = x; then
1923 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1924 SYSTEM_HEADER_DIR=$build_system_header_dir
1927 # If this is a cross-compiler that does not
1928 # have its own set of headers then define
1931 # If this is using newlib, without having the headers available now,
1932 # then define inhibit_libc in LIBGCC2_CFLAGS.
1933 # This prevents libgcc2 from containing any code which requires libc
1935 : ${inhibit_libc=false}
1936 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1937 test x$with_newlib = xyes ; } &&
1938 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1941 AC_SUBST(inhibit_libc)
1943 # When building gcc with a cross-compiler, we need to adjust things so
1944 # that the generator programs are still built with the native compiler.
1945 # Also, we cannot run fixincludes.
1947 # These are the normal (build=host) settings:
1948 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1949 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1950 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1951 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1952 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1953 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1955 # And these apply if build != host, or we are generating coverage data
1956 if test x$build != x$host || test "x$coverage_flags" != x
1958 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1959 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1960 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1963 # Expand extra_headers to include complete path.
1964 # This substitutes for lots of t-* files.
1966 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1967 for file in ${extra_headers} ; do
1968 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1971 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1972 if test x"$use_gcc_tgmath" = xyes
1973 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1976 # Define collect2 in Makefile.
1977 case $host_can_use_collect2 in
1979 *) collect2='collect2$(exeext)' ;;
1981 AC_SUBST([collect2])
1983 # Add a definition of USE_COLLECT2 if system wants one.
1984 case $use_collect2 in
1985 no) use_collect2= ;;
1988 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1989 xm_defines="${xm_defines} USE_COLLECT2"
1990 case $host_can_use_collect2 in
1992 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1998 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1999 [Define to the name of the LTO plugin DSO that must be
2000 passed to the linker's -plugin=LIB option.])
2002 # ---------------------------
2003 # Assembler & linker features
2004 # ---------------------------
2006 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2007 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2008 # However when ld-new is first executed from the build tree, libtool will
2009 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2010 # to the build tree. While doing this we need to use the previous-stage
2011 # linker, or we have an infinite loop. The presence of a shell script as
2012 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2013 # the gcc/collect-ld script. So we need to know how libtool works, or
2014 # exec-tool will fail.
2016 m4_defun([_LT_CONFIG_COMMANDS], [])
2019 AC_SUBST(enable_fast_install)
2021 # Identify the assembler which will work hand-in-glove with the newly
2022 # built GCC, so that we can examine its features. This is the assembler
2023 # which will be driven by the driver program.
2025 # If build != host, and we aren't building gas in-tree, we identify a
2026 # build->target assembler and hope that it will have the same features
2027 # as the host->target assembler we'll be using.
2028 gcc_cv_gas_major_version=
2029 gcc_cv_gas_minor_version=
2030 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2032 m4_pattern_allow([AS_FOR_TARGET])dnl
2033 AS_VAR_SET_IF(gcc_cv_as,, [
2034 if test -x "$DEFAULT_ASSEMBLER"; then
2035 gcc_cv_as="$DEFAULT_ASSEMBLER"
2036 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2037 && test -f ../gas/Makefile \
2038 && test x$build = x$host; then
2039 gcc_cv_as=../gas/as-new$build_exeext
2040 elif test -x as$build_exeext; then
2041 # Build using assembler in the current directory.
2042 gcc_cv_as=./as$build_exeext
2043 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2044 gcc_cv_as="$AS_FOR_TARGET"
2046 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2049 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2050 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2051 case "$ORIGINAL_AS_FOR_TARGET" in
2052 ./as | ./as$build_exeext) ;;
2053 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2056 AC_MSG_CHECKING(what assembler to use)
2057 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2058 # Single tree build which includes gas. We want to prefer it
2059 # over whatever linker top-level may have detected, since
2060 # we'll use what we're building after installation anyway.
2061 AC_MSG_RESULT(newly built gas)
2063 _gcc_COMPUTE_GAS_VERSION
2064 in_tree_gas_is_elf=no
2065 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2066 || (grep 'obj_format = multi' ../gas/Makefile \
2067 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2069 in_tree_gas_is_elf=yes
2072 AC_MSG_RESULT($gcc_cv_as)
2078 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2079 [case "${enableval}" in
2086 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2087 [case "${enableval}" in
2089 install_gold_as_default=yes
2092 if test x${default_ld} != x; then
2093 install_gold_as_default=yes
2099 AC_MSG_ERROR([invalid --enable-gold argument])
2102 [install_gold_as_default=no])
2104 # Identify the linker which will work hand-in-glove with the newly
2105 # built GCC, so that we can examine its features. This is the linker
2106 # which will be driven by the driver program.
2108 # If build != host, and we aren't building gas in-tree, we identify a
2109 # build->target linker and hope that it will have the same features
2110 # as the host->target linker we'll be using.
2111 gcc_cv_gld_major_version=
2112 gcc_cv_gld_minor_version=
2113 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2114 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2115 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2117 AS_VAR_SET_IF(gcc_cv_ld,, [
2118 if test -x "$DEFAULT_LINKER"; then
2119 gcc_cv_ld="$DEFAULT_LINKER"
2120 elif test $install_gold_as_default = yes \
2121 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2122 && test -f ../gold/Makefile \
2123 && test x$build = x$host; then
2124 gcc_cv_ld=../gold/ld-new$build_exeext
2125 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2126 && test -f ../ld/Makefile \
2127 && test x$build = x$host; then
2128 gcc_cv_ld=../ld/ld-new$build_exeext
2129 elif test -x collect-ld$build_exeext; then
2130 # Build using linker in the current directory.
2131 gcc_cv_ld=./collect-ld$build_exeext
2132 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2133 gcc_cv_ld="$LD_FOR_TARGET"
2135 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2138 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2139 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2140 # if the PLUGIN_LD is set ld-new, just have it as ld
2141 # as that is the installed named.
2142 if test x$PLUGIN_LD_SUFFIX = xld-new \
2143 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2146 AC_ARG_WITH(plugin-ld,
2147 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2148 [if test x"$withval" != x; then
2149 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2150 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2152 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2153 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2155 # Check to see if we are using gold instead of ld
2156 AC_MSG_CHECKING(whether we are using gold)
2158 if test x$gcc_cv_ld != x; then
2159 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2160 | grep "GNU gold" > /dev/null; then
2164 AC_MSG_RESULT($ld_is_gold)
2166 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2167 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2168 case "$ORIGINAL_LD_FOR_TARGET" in
2169 ./collect-ld | ./collect-ld$build_exeext) ;;
2170 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2173 AC_MSG_CHECKING(what linker to use)
2174 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2175 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2176 # Single tree build which includes ld. We want to prefer it
2177 # over whatever linker top-level may have detected, since
2178 # we'll use what we're building after installation anyway.
2179 AC_MSG_RESULT(newly built ld)
2181 in_tree_ld_is_elf=no
2182 if (grep 'EMUL = .*elf' ../ld/Makefile \
2183 || grep 'EMUL = .*linux' ../ld/Makefile \
2184 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2185 in_tree_ld_is_elf=yes
2186 elif test "$ld_is_gold" = yes; then
2187 in_tree_ld_is_elf=yes
2189 for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in
2192 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2193 if test x$gcc_cv_gld_version != x; then
2197 case $gcc_cv_gld_version in
2200 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2203 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2204 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2206 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2207 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2209 AC_MSG_RESULT($gcc_cv_ld)
2211 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2212 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2213 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2216 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2217 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2219 # Figure out what nm we will be using.
2220 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2221 AS_VAR_SET_IF(gcc_cv_nm,, [
2222 if test -f $gcc_cv_binutils_srcdir/configure.in \
2223 && test -f ../binutils/Makefile \
2224 && test x$build = x$host; then
2225 gcc_cv_nm=../binutils/nm-new$build_exeext
2226 elif test -x nm$build_exeext; then
2227 gcc_cv_nm=./nm$build_exeext
2228 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2229 gcc_cv_nm="$NM_FOR_TARGET"
2231 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2234 AC_MSG_CHECKING(what nm to use)
2235 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2236 # Single tree build which includes binutils.
2237 AC_MSG_RESULT(newly built nm)
2240 AC_MSG_RESULT($gcc_cv_nm)
2244 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2245 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2246 case "$ORIGINAL_NM_FOR_TARGET" in
2247 ./nm | ./nm$build_exeext) ;;
2248 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2252 # Figure out what objdump we will be using.
2253 AS_VAR_SET_IF(gcc_cv_objdump,, [
2254 if test -f $gcc_cv_binutils_srcdir/configure.in \
2255 && test -f ../binutils/Makefile \
2256 && test x$build = x$host; then
2257 # Single tree build which includes binutils.
2258 gcc_cv_objdump=../binutils/objdump$build_exeext
2259 elif test -x objdump$build_exeext; then
2260 gcc_cv_objdump=./objdump$build_exeext
2261 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2262 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2264 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2267 AC_MSG_CHECKING(what objdump to use)
2268 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2269 # Single tree build which includes binutils.
2270 AC_MSG_RESULT(newly built objdump)
2271 elif test x$gcc_cv_objdump = x; then
2272 AC_MSG_RESULT(not found)
2274 AC_MSG_RESULT($gcc_cv_objdump)
2277 # Figure out what readelf we will be using.
2278 AS_VAR_SET_IF(gcc_cv_readelf,, [
2279 if test -f $gcc_cv_binutils_srcdir/configure.in \
2280 && test -f ../binutils/Makefile \
2281 && test x$build = x$host; then
2282 # Single tree build which includes binutils.
2283 gcc_cv_readelf=../binutils/readelf$build_exeext
2284 elif test -x readelf$build_exeext; then
2285 gcc_cv_readelf=./readelf$build_exeext
2287 AC_PATH_PROG(gcc_cv_readelf, readelf)
2290 AC_MSG_CHECKING(what readelf to use)
2291 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2292 # Single tree build which includes binutils.
2293 AC_MSG_RESULT(newly built readelf)
2294 elif test x$gcc_cv_readelf = x; then
2295 AC_MSG_RESULT(not found)
2297 AC_MSG_RESULT($gcc_cv_readelf)
2300 # Figure out what assembler alignment features are present.
2301 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2305 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2306 [Define if your assembler supports .balign and .p2align.])])
2308 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2311 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2312 [Define if your assembler supports specifying the maximum number
2313 of bytes to skip when using the GAS .p2align command.])])
2315 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2318 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2319 [Define if your assembler supports .literal16.])])
2321 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2323 [conftest_label1: .word 0
2325 conftest_label2: .word 0
2327 [if test x$gcc_cv_nm != x; then
2328 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2329 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2330 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2332 else gcc_cv_as_subsection_m1=yes
2334 rm -f conftest.nm1 conftest.nm2
2336 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2337 [Define if your assembler supports .subsection and .subsection -1 starts
2338 emitting at the beginning of your section.])])
2340 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2343 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2345 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2347 [ .weakref foobar, barfnot],,
2348 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2350 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2353 .NSUBSPA $CODE$,COMDAT],,
2354 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2356 # .hidden needs to be supported in both the assembler and the linker,
2357 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2358 # This is irritatingly difficult to feature test for; we have to check the
2359 # date string after the version number. If we've got an in-tree
2360 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2362 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2363 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2369 # Darwin as has some visibility support, though with a different syntax.
2370 gcc_cv_as_hidden=yes
2374 # gnu_indirect_function type is an extension proposed at
2375 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2376 # selection of function implementation
2377 AC_ARG_ENABLE(gnu-indirect-function,
2378 [AS_HELP_STRING([--enable-gnu-indirect-function],
2379 [enable the use of the @gnu_indirect_function to glibc systems])],
2380 [case $enable_gnu_indirect_function in
2382 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2383 Valid choices are 'yes' and 'no'.]) ;;
2385 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2387 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2388 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2389 [Define if your system supports gnu indirect functions.])
2393 if test $in_tree_ld != yes ; then
2394 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2395 if echo "$ld_ver" | grep GNU > /dev/null; then
2396 if test x"$ld_is_gold" = xyes; then
2397 # GNU gold --version looks like this:
2399 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2401 # We extract the binutils version which is more familiar and specific
2402 # than the gold version.
2403 ld_vers=`echo $ld_ver | sed -n \
2404 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2406 # GNU ld --version looks like this:
2408 # GNU ld (GNU Binutils) 2.21.51.20110225
2409 ld_vers=`echo $ld_ver | sed -n \
2410 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2412 ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)[-]*\([01][0-9]\)[-]*\([0-3][0-9]\).*$,\1\2\3,p'`
2413 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2414 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2415 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2419 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2422 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2423 # /usr/ccs/bin/ld has been configured.
2424 ld_ver=`$gcc_cv_ld -V 2>&1`
2425 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2426 ld_vers=`echo $ld_ver | sed -n \
2427 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2428 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2429 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2437 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2438 [[if test $in_tree_ld = yes ; then
2440 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 13 -o "$gcc_cv_gld_major_version" -gt 2 \
2441 && test $in_tree_ld_is_elf = yes; then
2442 gcc_cv_ld_hidden=yes
2445 gcc_cv_ld_hidden=yes
2446 if test x"$ld_is_gold" = xyes; then
2448 elif echo "$ld_ver" | grep GNU > /dev/null; then
2450 mmix-knuth-mmixware)
2451 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2455 if test 0"$ld_date" -lt 20020404; then
2456 if test -n "$ld_date"; then
2457 # If there was date string, but was earlier than 2002-04-04, fail
2459 elif test -z "$ld_vers"; then
2460 # If there was no date string nor ld version number, something is wrong
2463 test -z "$ld_vers_patch" && ld_vers_patch=0
2464 if test "$ld_vers_major" -lt 2; then
2466 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2467 gcc_cv_ld_hidden="no"
2468 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2476 # Darwin ld has some visibility support.
2477 gcc_cv_ld_hidden=yes
2479 hppa64*-*-hpux* | ia64*-*-hpux*)
2480 gcc_cv_ld_hidden=yes
2482 *-*-solaris2.1[0-9]*)
2483 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2484 # .symbolic was only added in Solaris 9 12/02.
2485 gcc_cv_ld_hidden=yes
2493 libgcc_visibility=no
2494 AC_SUBST(libgcc_visibility)
2495 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2496 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2497 libgcc_visibility=yes
2498 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2499 [Define if your assembler and linker support .hidden.])
2502 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2503 gcc_cv_ld_ro_rw_mix=unknown
2504 if test $in_tree_ld = yes ; then
2505 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 \
2506 && test $in_tree_ld_is_elf = yes; then
2507 gcc_cv_ld_ro_rw_mix=read-write
2509 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2510 echo '.section myfoosect, "a"' > conftest1.s
2511 echo '.section myfoosect, "aw"' > conftest2.s
2512 echo '.byte 1' >> conftest2.s
2513 echo '.section myfoosect, "a"' > conftest3.s
2514 echo '.byte 0' >> conftest3.s
2515 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2516 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2517 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2518 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2519 conftest2.o conftest3.o > /dev/null 2>&1; then
2520 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2521 | sed -e '/myfoosect/!d' -e N`
2522 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2523 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2524 gcc_cv_ld_ro_rw_mix=read-only
2526 gcc_cv_ld_ro_rw_mix=read-write
2531 rm -f conftest.* conftest[123].*
2534 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2535 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2536 [Define if your linker links a mix of read-only
2537 and read-write sections into a read-write section.])
2539 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2541 gcc_AC_INITFINI_ARRAY
2543 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2544 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2552 [[# GAS versions before 2.11 do not support uleb128,
2553 # despite appearing to.
2554 # ??? There exists an elf-specific test that will crash
2555 # the assembler. Perhaps it's better to figure out whether
2556 # arbitrary sections are supported and try the test.
2557 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2558 if echo "$as_ver" | grep GNU > /dev/null; then
2559 as_vers=`echo $as_ver | sed -n \
2560 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2561 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2562 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2563 if test $as_major -eq 2 && test $as_minor -lt 11
2565 else gcc_cv_as_leb128=yes
2568 [AC_DEFINE(HAVE_AS_LEB128, 1,
2569 [Define if your assembler supports .sleb128 and .uleb128.])])
2571 # Check if we have assembler support for unwind directives.
2572 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2579 .cfi_escape 1, 2, 3, 4, 5
2583 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2584 # read-only and read-write sections, we need to make sure that the
2585 # assembler used emits read-write .eh_frame sections.
2586 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2587 if test "x$gcc_cv_objdump" != x; then
2588 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2589 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2590 gcc_cv_as_cfi_directive=no
2593 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2594 # On Solaris/x86, make sure that GCC and assembler agree on using
2595 # read-only .eh_frame sections for 64-bit.
2596 if test x$gas = xyes; then
2597 as_ix86_64_opt="--64"
2599 as_ix86_64_opt="-xarch=amd64"
2601 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2602 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2603 sed -e /.eh_frame/!d -e N | \
2604 grep READONLY > /dev/null; then
2605 gcc_cv_as_cfi_directive=yes
2607 gcc_cv_as_cfi_directive=no
2611 gcc_cv_as_cfi_directive=yes
2616 # no objdump, err on the side of caution
2617 gcc_cv_as_cfi_directive=no
2620 gcc_cv_as_cfi_directive=yes
2624 gcc_cv_as_cfi_directive=yes
2627 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2628 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2632 .cfi_adjust_cfa_offset 64
2634 .cfi_adjust_cfa_offset 128
2637 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2638 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2639 gcc_cv_as_cfi_advance_working=yes
2643 # no objdump, err on the side of caution
2644 gcc_cv_as_cfi_advance_working=no
2646 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2647 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2648 [`if test $gcc_cv_as_cfi_directive = yes \
2649 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2650 [Define 0/1 if your assembler supports CFI directives.])
2652 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2653 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2654 gcc_cv_as_cfi_personality_directive, ,,
2657 .cfi_personality 0, symbol
2659 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2660 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2661 then echo 1; else echo 0; fi`],
2662 [Define 0/1 if your assembler supports .cfi_personality.])
2664 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2665 gcc_cv_as_cfi_sections_directive, ,,
2667 .cfi_sections .debug_frame, .eh_frame
2671 win32 | pe | cygwin* | mingw32* | uwin*)
2672 # Need to check that we generated the correct relocation for the
2673 # .debug_frame section. This was fixed for binutils 2.21.
2674 gcc_cv_as_cfi_sections_directive=no
2675 if test "x$gcc_cv_objdump" != x; then
2676 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2677 grep secrel > /dev/null; then
2678 gcc_cv_as_cfi_sections_directive=yes
2683 gcc_cv_as_cfi_sections_directive=yes
2686 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2687 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2688 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2689 then echo 1; else echo 0; fi`],
2690 [Define 0/1 if your assembler supports .cfi_sections.])
2692 # GAS versions up to and including 2.11.0 may mis-optimize
2694 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2702 .section .eh_frame,"aw",@progbits
2704 .4byte .LECIE1-.LSCIE1
2718 .4byte .LEFDE1-.LASFDE1
2720 .4byte .LASFDE1-__FRAME_BEGIN__
2728 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2729 cat > conftest.lit <<EOF
2730 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2731 0010 01000000 12000000 18000000 00000000 ................
2732 0020 08000000 04080000 0044 .........D @&t@
2734 cat > conftest.big <<EOF
2735 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2736 0010 00000001 00000012 00000018 00000000 ................
2737 0020 00000008 04000000 0844 .........D @&t@
2739 # If the assembler didn't choke, and we can objdump,
2740 # and we got the correct data, then succeed.
2741 # The text in the here-document typically retains its unix-style line
2742 # endings, while the output of objdump will use host line endings.
2743 # Therefore, use diff -b for the comparisons.
2744 if test x$gcc_cv_objdump != x \
2745 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2746 | tail -3 > conftest.got \
2747 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2748 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2750 gcc_cv_as_eh_frame=yes
2751 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2752 gcc_cv_as_eh_frame=buggy
2754 # Uh oh, what do we do now?
2755 gcc_cv_as_eh_frame=no
2758 if test $gcc_cv_as_eh_frame = buggy; then
2759 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2760 [Define if your assembler mis-optimizes .eh_frame data.])
2763 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2764 [elf,2,12,0], [--fatal-warnings],
2765 [.section .rodata.str, "aMS", @progbits, 1])
2766 if test $gcc_cv_as_shf_merge = no; then
2767 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2768 [elf,2,12,0], [--fatal-warnings],
2769 [.section .rodata.str, "aMS", %progbits, 1])
2771 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2772 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2773 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2775 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2776 gcc_cv_as_comdat_group,
2777 [elf,2,16,0], [--fatal-warnings],
2778 [.section .text,"axG",@progbits,.foo,comdat])
2779 if test $gcc_cv_as_comdat_group = yes; then
2780 gcc_cv_as_comdat_group_percent=no
2781 gcc_cv_as_comdat_group_group=no
2783 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2784 gcc_cv_as_comdat_group_percent,
2785 [elf,2,16,0], [--fatal-warnings],
2786 [.section .text,"axG",%progbits,.foo,comdat])
2787 if test $gcc_cv_as_comdat_group_percent = yes; then
2788 gcc_cv_as_comdat_group_group=no
2790 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2791 gcc_cv_as_comdat_group_group=no
2794 # Sun as uses a completely different syntax.
2799 .group foo,".text%foo",#comdat
2800 .section ".text%foo", #alloc,#execinstr,#progbits
2805 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2807 .group foo,.text%foo,#comdat
2808 .section .text%foo, "ax", @progbits
2814 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2815 gcc_cv_as_comdat_group_group,
2821 if test x"$ld_is_gold" = xyes; then
2823 elif test $in_tree_ld = yes ; then
2825 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
2826 && test $in_tree_ld_is_elf = yes; then
2829 elif echo "$ld_ver" | grep GNU > /dev/null; then
2831 if test 0"$ld_date" -lt 20050308; then
2832 if test -n "$ld_date"; then
2833 # If there was date string, but was earlier than 2005-03-08, fail
2835 elif test "$ld_vers_major" -lt 2; then
2837 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2844 *-*-solaris2.1[1-9]*)
2846 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2847 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2850 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2851 # least ld version 1.2267.
2852 if test "$ld_vers_major" -gt 1; then
2854 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2856 elif test "$ld_vers_minor" -ge 2267; then
2861 # Assume linkers other than GNU ld don't support COMDAT group.
2867 # Allow overriding the automatic COMDAT group tests above.
2868 AC_ARG_ENABLE(comdat,
2869 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2870 [comdat_group="$enable_comdat"])
2871 if test $comdat_group = no; then
2872 gcc_cv_as_comdat_group=no
2873 gcc_cv_as_comdat_group_percent=no
2874 gcc_cv_as_comdat_group_group=no
2876 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2877 [`if test $gcc_cv_as_comdat_group = yes \
2878 || test $gcc_cv_as_comdat_group_percent = yes \
2879 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2880 [Define 0/1 if your assembler and linker support COMDAT groups.])
2882 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2883 gcc_cv_as_discriminator,
2887 .loc 1 1 0 discriminator 1],,
2888 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2889 [Define if your assembler supports the .loc discriminator sub-directive.])])
2891 # Thread-local storage - the check is heavily parameterized.
2900 .section ".tdata","awT",@progbits
2903 ldq $27,__tls_get_addr($29) !literal!1
2904 lda $16,foo($29) !tlsgd!1
2905 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2906 ldq $27,__tls_get_addr($29) !literal!2
2907 lda $16,foo($29) !tlsldm!2
2908 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2909 ldq $1,foo($29) !gotdtprel
2910 ldah $2,foo($29) !dtprelhi
2911 lda $3,foo($2) !dtprello
2912 lda $4,foo($29) !dtprel
2913 ldq $1,foo($29) !gottprel
2914 ldah $2,foo($29) !tprelhi
2915 lda $3,foo($2) !tprello
2916 lda $4,foo($29) !tprel'
2919 tls_as_opt=--fatal-warnings
2921 cris-*-*|crisv32-*-*)
2923 .section ".tdata","awT",@progbits
2930 tls_as_opt=--fatal-warnings
2934 .section ".tdata","awT",@progbits
2946 .section ".tdata","awT",@progbits
2950 addil LT%foo-$tls_gdidx$,gp
2951 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2954 addil LT%foo-$tls_ldidx$,gp
2956 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2957 addil LR%foo-$tls_dtpoff$,%ret0
2958 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2960 addil LT%foo-$tls_ieoff$,gp
2961 ldw RT%foo-$tls_ieoff$(%r1),%t2
2964 addil LR%foo-$tls_leoff$,%t1
2965 ldo RR%foo-$tls_leoff$(%r1),%t2'
2968 tls_as_opt=--fatal-warnings
2972 .section ".tdata","awT",%progbits
2983 i[34567]86-*-* | x86_64-*-*)
2985 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
2992 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2994 .section .tdata,"awt",@progbits'
2999 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3000 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3004 .section ".tdata","awT",@progbits'
3008 tls_as_opt="--fatal-warnings"
3012 conftest_s="$conftest_s
3016 leal foo@tlsgd(,%ebx,1), %eax
3017 leal foo@tlsldm(%ebx), %eax
3018 leal foo@dtpoff(%eax), %edx
3019 movl foo@gottpoff(%ebx), %eax
3020 subl foo@gottpoff(%ebx), %eax
3021 addl foo@gotntpoff(%ebx), %eax
3022 movl foo@indntpoff, %eax
3023 movl \$foo@tpoff, %eax
3024 subl \$foo@tpoff, %eax
3025 leal foo@ntpoff(%ecx), %eax"
3028 if test x$on_solaris = xyes; then
3030 yes) tls_as_opt="$tls_as_opt --64" ;;
3031 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3034 conftest_s="$conftest_s
3038 leaq foo@tlsgd(%rip), %rdi
3039 leaq foo@tlsld(%rip), %rdi
3040 leaq foo@dtpoff(%rax), %rdx
3041 movq foo@gottpoff(%rip), %rax
3042 movq \$foo@tpoff, %rax"
3048 .section ".tdata","awT",@progbits
3051 addl r16 = @ltoff(@dtpmod(foo#)), gp
3052 addl r17 = @ltoff(@dtprel(foo#)), gp
3053 addl r18 = @ltoff(@tprel(foo#)), gp
3054 addl r19 = @dtprel(foo#), gp
3055 adds r21 = @dtprel(foo#), r13
3056 movl r23 = @dtprel(foo#)
3057 addl r20 = @tprel(foo#), gp
3058 adds r22 = @tprel(foo#), r13
3059 movl r24 = @tprel(foo#)'
3062 tls_as_opt=--fatal-warnings
3066 .section .tdata,"awT",@progbits
3070 addik r5,r20,x@TLSGD
3071 addik r5,r20,x@TLSLDM'
3074 tls_as_opt='--fatal-warnings'
3078 .section .tdata,"awT",@progbits
3082 addiu $4, $28, %tlsgd(x)
3083 addiu $4, $28, %tlsldm(x)
3084 lui $4, %dtprel_hi(x)
3085 addiu $4, $4, %dtprel_lo(x)
3086 lw $4, %gottprel(x)($28)
3087 lui $4, %tprel_hi(x)
3088 addiu $4, $4, %tprel_lo(x)'
3091 tls_as_opt='-32 --fatal-warnings'
3095 .section .tdata,"awT",@progbits
3100 move.l x@TLSGD(%a5),%a0
3101 move.l x@TLSLDM(%a5),%a0
3102 move.l x@TLSLDO(%a5),%a0
3103 move.l x@TLSIE(%a5),%a0
3104 move.l x@TLSLE(%a5),%a0'
3107 tls_as_opt='--fatal-warnings'
3111 .section ".tdata","awT",@progbits'
3114 tls_as_opt="--fatal-warnings"
3118 .section ".tdata","awT",%progbits
3122 add x0, x0, #:tlsgd_lo12:x
3127 tls_as_opt='--fatal-warnings'
3131 .extern __get_tpointer
3149 .section ".tdata","awT",@progbits
3157 addi 3,2,ld0@got@tlsgd
3163 addi 3,2,x1@got@tlsld
3169 addis 9,3,x2@dtprel@ha
3170 addi 9,9,x2@dtprel@l
3173 ld 9,x3@got@dtprel(2)
3179 tls_as_opt="-a64 --fatal-warnings"
3183 .section ".tdata","awT",@progbits
3191 addi 3,31,ld0@got@tlsgd
3193 addi 3,31,x1@got@tlsld
3196 addis 9,3,x2@dtprel@ha
3197 addi 9,9,x2@dtprel@l
3198 lwz 9,x3@got@tprel(31)
3201 addis 9,2,x2@tprel@ha
3202 addi 9,9,x2@tprel@l'
3205 tls_as_opt="-a32 --fatal-warnings"
3209 .section ".tdata","awT",@progbits
3218 l %r1,foo@GOTNTPOFF(%r12)
3219 l %r1,0(%r1):tls_load:foo
3220 bas %r14,0(%r1,%r13):tls_gdcall:foo
3221 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3224 tls_as_opt="-m31 --fatal-warnings"
3228 .section ".tdata","awT",@progbits
3236 lg %r1,foo@GOTNTPOFF(%r12)
3237 larl %r1,foo@INDNTPOFF
3238 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3239 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3242 tls_as_opt="-m64 -Aesame --fatal-warnings"
3244 sh-*-* | sh[34]-*-*)
3246 .section ".tdata","awT",@progbits
3256 tls_as_opt=--fatal-warnings
3260 sparc*-sun-solaris2.*)
3267 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3269 .section ".tdata",#alloc,#write,#tls'
3274 .section ".tdata","awT",@progbits'
3277 tls_as_opt="-32 --fatal-warnings"
3279 conftest_s="$conftest_s
3282 sethi %tgd_hi22(foo), %o0
3283 add %o0, %tgd_lo10(foo), %o1
3284 add %l7, %o1, %o0, %tgd_add(foo)
3285 call __tls_get_addr, %tgd_call(foo)
3286 sethi %tldm_hi22(foo), %l1
3287 add %l1, %tldm_lo10(foo), %l2
3288 add %l7, %l2, %o0, %tldm_add(foo)
3289 call __tls_get_addr, %tldm_call(foo)
3290 sethi %tldo_hix22(foo), %l3
3291 xor %l3, %tldo_lox10(foo), %l4
3292 add %o0, %l4, %l5, %tldo_add(foo)
3293 sethi %tie_hi22(foo), %o3
3294 add %o3, %tie_lo10(foo), %o3
3295 ld [%l7 + %o3], %o2, %tie_ld(foo)
3296 add %g7, %o2, %o4, %tie_add(foo)
3297 sethi %tle_hix22(foo), %l1
3298 xor %l1, %tle_lox10(foo), %o5
3299 ld [%g7 + %o5], %o1"
3303 .section ".tdata","awT",@progbits
3306 addli r0, zero, tls_gd(foo)
3307 auli r0, zero, tls_gd_ha16(foo)
3308 addli r0, r0, tls_gd_lo16(foo)
3310 addli r0, zero, tls_ie(foo)
3311 auli r0, r0, tls_ie_ha16(foo)
3312 addli r0, r0, tls_ie_lo16(foo)'
3315 tls_as_opt="--fatal-warnings"
3319 .section ".tdata","awT",@progbits
3322 shl16insli r0, zero, hw0_last_tls_gd(foo)
3323 shl16insli r0, zero, hw1_last_tls_gd(foo)
3324 shl16insli r0, r0, hw0_tls_gd(foo)
3326 shl16insli r0, zero, hw1_last_tls_ie(foo)
3327 shl16insli r0, r0, hw0_tls_ie(foo)'
3330 tls_as_opt="--fatal-warnings"
3334 .section ".tdata","awT",@progbits
3337 movi a8, foo@TLSFUNC
3338 movi a10, foo@TLSARG
3339 callx8.tls a8, foo@TLSCALL'
3346 if test "x$enable_tls" = xno ; then
3347 : # TLS explicitly disabled.
3348 elif test "x$enable_tls" = xyes ; then
3349 set_have_as_tls=yes # TLS explicitly enabled.
3350 elif test -z "$tls_first_major"; then
3351 : # If we don't have a check, assume no support.
3353 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3354 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3355 [set_have_as_tls=yes])
3357 if test $set_have_as_tls = yes ; then
3358 AC_DEFINE(HAVE_AS_TLS, 1,
3359 [Define if your assembler and linker support thread-local storage.])
3362 # Target-specific assembler checks.
3364 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3365 gcc_cv_ld_static_dynamic=no
3366 gcc_cv_ld_static_option='-Bstatic'
3367 gcc_cv_ld_dynamic_option='-Bdynamic'
3368 if test $in_tree_ld = yes ; then
3369 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2; then
3370 gcc_cv_ld_static_dynamic=yes
3372 elif test x$gcc_cv_ld != x; then
3373 # Check if linker supports -Bstatic/-Bdynamic option
3374 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3375 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3376 gcc_cv_ld_static_dynamic=yes
3379 # AIX ld uses -b flags
3380 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3381 gcc_cv_ld_static_dynamic=yes
3382 gcc_cv_ld_static_option="-bstatic"
3383 gcc_cv_ld_dynamic_option="-bdynamic"
3385 # HP-UX ld uses -a flags to select between shared and archive.
3387 if test x"$gnu_ld" = xno; then
3388 gcc_cv_ld_static_dynamic=yes
3389 gcc_cv_ld_static_option="-aarchive_shared"
3390 gcc_cv_ld_dynamic_option="-adefault"
3393 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3395 gcc_cv_ld_static_dynamic=yes
3400 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3401 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3402 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3403 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3404 [Define to the linker option to disable use of shared objects.])
3405 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3406 [Define to the linker option to enable use of shared objects.])
3408 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3410 if test x"$demangler_in_ld" = xyes; then
3411 AC_MSG_CHECKING(linker --demangle support)
3412 gcc_cv_ld_demangle=no
3413 if test $in_tree_ld = yes; then
3414 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 14 -o "$gcc_cv_gld_major_version" -gt 2; then \
3415 gcc_cv_ld_demangle=yes
3417 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3418 # Check if the GNU linker supports --demangle option
3419 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3420 gcc_cv_ld_demangle=yes
3423 if test x"$gcc_cv_ld_demangle" = xyes; then
3424 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3425 [Define if your linker supports --demangle option.])
3427 AC_MSG_RESULT($gcc_cv_ld_demangle)
3430 AC_MSG_CHECKING(linker plugin support)
3432 if test -f liblto_plugin.la; then
3433 save_ld_ver="$ld_ver"
3434 save_ld_vers_major="$ld_vers_major"
3435 save_ld_vers_minor="$ld_vers_minor"
3436 save_ld_is_gold="$ld_is_gold"
3440 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3442 # FIXME: ld_is_gold?
3443 ld_vers_major="$gcc_cv_gld_major_version"
3444 ld_vers_minor="$gcc_cv_gld_minor_version"
3446 # Determine plugin linker version.
3447 # FIXME: Partial duplicate from above, generalize.
3449 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3450 if echo "$ld_ver" | grep GNU > /dev/null; then
3451 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3453 ld_vers=`echo $ld_ver | sed -n \
3454 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3456 ld_vers=`echo $ld_ver | sed -n \
3457 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3459 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3460 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3465 # Determine plugin support.
3466 if echo "$ld_ver" | grep GNU > /dev/null; then
3467 # Require GNU ld or gold 2.21+ for plugin support by default.
3468 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3470 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3471 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3476 ld_ver="$save_ld_ver"
3477 ld_vers_major="$save_ld_vers_major"
3478 ld_vers_minor="$save_ld_vers_minor"
3479 ld_is_gold="$save_ld_is_gold"
3481 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3482 [Define to the level of your linker's plugin support.])
3483 AC_MSG_RESULT($gcc_cv_lto_plugin)
3487 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3488 [-mabi=lp64], [.text],,,)
3489 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3490 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3491 [Define if your assembler supports the -mabi option.])
3493 if test x$with_abi = xilp32; then
3494 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3495 Upgrade the Assembler.])
3497 if test x"$with_multilib_list" = xdefault; then
3498 TM_MULTILIB_CONFIG=lp64
3500 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3501 for aarch64_multilib in ${aarch64_multilibs}; do
3502 case ${aarch64_multilib} in
3504 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3505 Upgrade the Assembler.])
3515 # All TARGET_ABI_OSF targets.
3516 alpha*-*-linux* | alpha*-*-*bsd*)
3517 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3518 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3521 extbl $3, $2, $3 !lituse_bytoff!1
3522 ldq $2, a($29) !literal!1
3523 ldq $4, b($29) !literal!2
3524 ldq_u $3, 0($2) !lituse_base!1
3525 ldq $27, f($29) !literal!5
3526 jsr $26, ($27), f !lituse_jsr!5
3527 ldah $29, 0($26) !gpdisp!3
3528 lda $0, c($29) !gprel
3529 ldah $1, d($29) !gprelhigh
3530 lda $1, d($1) !gprellow
3531 lda $29, 0($29) !gpdisp!3],,
3532 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3533 [Define if your assembler supports explicit relocations.])])
3534 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3535 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3538 ldq $27, a($29) !literal!1
3539 jsr $26, ($27), a !lituse_jsrdirect!1],,
3540 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3541 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3545 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3546 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3547 [-no-mul-bug-abort], [.text],,
3548 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3549 [Define if your assembler supports the -no-mul-bug-abort option.])])
3553 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3554 [.register %g2, #scratch],,
3555 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3556 [Define if your assembler supports .register.])])
3558 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3559 [.section "nobits",#alloc,#write,#nobits
3560 .section "progbits",#alloc,#write,#progbits])
3561 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3562 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3563 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3565 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3567 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3568 [Define if your assembler supports -relax option.])])
3570 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3571 gcc_cv_as_sparc_gotdata_op,,
3578 sethi %gdop_hix22(foo), %g1
3579 xor %g1, %gdop_lox10(foo), %g1
3580 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3581 [if test x$gcc_cv_ld != x \
3582 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3583 if test x$gcc_cv_objdump != x; then
3584 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3585 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3586 gcc_cv_as_sparc_gotdata_op=no
3588 gcc_cv_as_sparc_gotdata_op=yes
3593 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3594 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3596 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3597 gcc_cv_as_sparc_ua_pcrel,,
3605 .uaword %r_disp32(foo)],
3606 [if test x$gcc_cv_ld != x \
3607 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3608 gcc_cv_as_sparc_ua_pcrel=yes
3611 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3612 [Define if your assembler and linker support unaligned PC relative relocs.])
3614 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3615 gcc_cv_as_sparc_ua_pcrel_hidden,,
3620 .uaword %r_disp32(foo)
3621 .byte 0x32, 0x33, 0x34
3626 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3627 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3628 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3629 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3630 if $gcc_cv_objdump -R conftest 2> /dev/null \
3631 | grep 'DISP32' > /dev/null 2>&1; then
3634 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3638 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3639 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3640 ]) # unaligned pcrel relocs
3642 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3643 gcc_cv_as_sparc_offsetable_lo10,,
3646 or %g1, %lo(ab) + 12, %g1
3647 or %g1, %lo(ab + 12), %g1],
3648 [if test x$gcc_cv_objdump != x \
3649 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3650 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3651 gcc_cv_as_sparc_offsetable_lo10=yes
3653 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3654 [Define if your assembler supports offsetable %lo().])])
3656 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3657 gcc_cv_as_sparc_fmaf,,
3660 .register %g2, #scratch
3661 .register %g3, #scratch
3663 fmaddd %f0, %f2, %f4, %f6
3664 addxccc %g1, %g2, %g3
3665 fsrl32 %f2, %f4, %f8
3666 fnaddd %f10, %f12, %f14],,
3667 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3668 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3670 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3671 gcc_cv_as_sparc_sparc4,,
3674 .register %g2, #scratch
3675 .register %g3, #scratch
3678 1: cwbneg %g2, %g3, 1f
3681 aes_kexpand0 %f4, %f6, %f8
3682 des_round %f38, %f40, %f42, %f44
3683 camellia_f %f54, %f56, %f58, %f60
3684 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3685 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3686 [Define if your assembler supports SPARC4 instructions.])])
3688 gcc_GAS_CHECK_FEATURE([LEON instructions],
3689 gcc_cv_as_sparc_leon,,
3692 .register %g2, #scratch
3693 .register %g3, #scratch
3697 casa [[%g2]] 0xb, %g3, %g1],,
3698 [AC_DEFINE(HAVE_AS_LEON, 1,
3699 [Define if your assembler supports LEON instructions.])])
3703 i[34567]86-*-* | x86_64-*-*)
3707 # Full C++ conformance when using a shared libstdc++-v3 requires some
3708 # support from the Cygwin DLL, which in more recent versions exports
3709 # wrappers to aid in interposing and redirecting operators new, delete,
3710 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3711 # are configuring for a version of Cygwin that exports the wrappers.
3712 if test x$host = x$target && test x$host_cpu = xi686; then
3713 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3715 # Can't check presence of libc functions during cross-compile, so
3716 # we just have to assume we're building for an up-to-date target.
3717 gcc_ac_cygwin_dll_wrappers=yes
3719 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3720 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3721 [Define if you want to generate code by default that assumes that the
3722 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3725 cygwin* | pe | mingw32* | interix*)
3726 # Recent binutils allows the three-operand form of ".comm" on PE. This
3727 # definition is used unconditionally to initialise the default state of
3728 # the target option variable that governs usage of the feature.
3729 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3730 [2,19,52],,[.comm foo,1,32])
3731 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3732 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3733 [Define if your assembler supports specifying the alignment
3734 of objects allocated using the GAS .comm command.])
3735 # Used for DWARF 2 in PE
3736 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3737 gcc_cv_as_ix86_pe_secrel32,
3743 [if test x$gcc_cv_ld != x \
3744 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3745 gcc_cv_as_ix86_pe_secrel32=yes
3748 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3749 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3750 # Test if the assembler supports the extended form of the .section
3751 # directive that specifies section alignment. LTO support uses this,
3752 # but normally only after installation, so we warn but don't fail the
3753 # configure if LTO is enabled but the assembler does not support it.
3754 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3755 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3756 if test x$gcc_cv_as_section_has_align != xyes; then
3757 case ",$enable_languages," in
3759 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3763 # Test if the assembler supports the section flag 'e' for specifying
3764 # an excluded section.
3765 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3769 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3770 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3771 [Define if your assembler supports specifying the section flag e.])
3775 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3776 gcc_cv_as_ix86_filds,,,
3777 [filds mem; fists mem],,
3778 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3779 [Define if your assembler uses filds and fists mnemonics.])])
3781 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3782 gcc_cv_as_ix86_fildq,,,
3783 [fildq mem; fistpq mem],,
3784 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3785 [Define if your assembler uses fildq and fistq mnemonics.])])
3787 gcc_GAS_CHECK_FEATURE([cmov syntax],
3788 gcc_cv_as_ix86_cmov_sun_syntax,,,
3789 [cmovl.l %edx, %eax],,
3790 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3791 [Define if your assembler supports the Sun syntax for cmov.])])
3793 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3794 gcc_cv_as_ix86_ffreep,,,
3796 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3797 [Define if your assembler supports the ffreep mnemonic.])])
3799 gcc_GAS_CHECK_FEATURE([.quad directive],
3800 gcc_cv_as_ix86_quad,,,
3802 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3803 [Define if your assembler supports the .quad directive.])])
3805 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3806 gcc_cv_as_ix86_sahf,,,
3809 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3810 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3812 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3813 gcc_cv_as_ix86_interunit_movq,,,
3817 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3818 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3819 [Define if your assembler supports interunit movq mnemonic.])
3821 gcc_GAS_CHECK_FEATURE([hle prefixes],
3822 gcc_cv_as_ix86_hle,,,
3823 [lock xacquire cmpxchg %esi, (%ecx)],,
3824 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3825 [Define if your assembler supports HLE prefixes.])])
3827 gcc_GAS_CHECK_FEATURE([swap suffix],
3828 gcc_cv_as_ix86_swap,,,
3829 [movl.s %esp, %ebp],,
3830 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3831 [Define if your assembler supports the swap suffix.])])
3833 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3834 gcc_cv_as_ix86_diff_sect_delta,,,
3842 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3843 [Define if your assembler supports the subtraction of symbols in different sections.])])
3845 # These two are used unconditionally by i386.[ch]; it is to be defined
3846 # to 1 if the feature is present, 0 otherwise.
3847 as_ix86_gotoff_in_data_opt=
3848 if test x$gas = xyes; then
3849 as_ix86_gotoff_in_data_opt="--32"
3851 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3852 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3853 [$as_ix86_gotoff_in_data_opt],
3859 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3860 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3861 [Define true if the assembler supports '.long foo@GOTOFF'.])
3863 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3864 gcc_cv_as_ix86_rep_lock_prefix,,,
3870 lock addl %edi, (%eax,%esi)
3871 lock orl $0, (%esp)],,
3872 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3873 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3875 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3876 gcc_cv_as_ix86_ud2,,,
3878 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3879 [Define if your assembler supports the 'ud2' mnemonic.])])
3881 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3882 gcc_cv_as_ix86_tlsgdplt,,,
3883 [call tls_gd@tlsgdplt],
3884 [if test x$gcc_cv_ld != x \
3885 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3886 gcc_cv_as_ix86_tlsgdplt=yes
3889 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3890 [Define if your assembler and linker support @tlsgdplt.])])
3893 .section .tdata,"aw'$tls_section_flag'",@progbits
3895 .section .text,"ax",@progbits
3896 call tls_ld@tlsldmplt'
3897 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3898 gcc_cv_as_ix86_tlsldmplt,,,
3900 [if test x$gcc_cv_ld != x \
3901 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3902 gcc_cv_as_ix86_tlsldmplt=yes
3905 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3906 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3907 [Define to 1 if your assembler and linker support @tlsldmplt.])
3909 # Enforce 32-bit output with gas and gld.
3910 if test x$gas = xyes; then
3911 as_ix86_tls_ldm_opt="--32"
3913 if echo "$ld_ver" | grep GNU > /dev/null; then
3914 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3915 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3917 ld_ix86_tls_ldm_opt="-melf_i386"
3921 .section .text,"ax",@progbits
3923 .type _start, @function
3925 leal value@tlsldm(%ebx), %eax
3926 call ___tls_get_addr@plt
3928 .section .tdata,"aw'$tls_section_flag'",@progbits
3929 .type value, @object
3931 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3932 gcc_cv_as_ix86_tlsldm,,
3933 [$as_ix86_tls_ldm_opt],
3935 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3936 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3937 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3938 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3939 gcc_cv_as_ix86_tlsldm=yes
3943 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3944 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3945 [Define to 1 if your assembler and linker support @tlsldm.])
3950 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3951 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3953 addl r15 = @ltoffx(x#), gp
3955 ld8.mov r16 = [[r15]], x#],,
3956 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3957 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3963 *-*-aix*) conftest_s=' .machine "pwr5"
3967 gcc_GAS_CHECK_FEATURE([.machine directive support],
3968 gcc_cv_as_machine_directive,,,
3969 [ .machine ppc7400])
3970 if test x$gcc_cv_as_machine_directive != xyes; then
3971 echo "*** This target requires an assembler supporting \".machine\"" >&2
3972 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3973 test x$build = x$target && exit 1
3977 *) conftest_s=' .machine power4
3982 gcc_GAS_CHECK_FEATURE([mfcr field support],
3983 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3985 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3986 [Define if your assembler supports mfcr field.])])
3989 *-*-aix*) conftest_s=' .machine "pwr5"
3992 *) conftest_s=' .machine power5
3997 gcc_GAS_CHECK_FEATURE([popcntb support],
3998 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4000 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4001 [Define if your assembler supports popcntb field.])])
4004 *-*-aix*) conftest_s=' .machine "pwr5x"
4007 *) conftest_s=' .machine power5
4012 gcc_GAS_CHECK_FEATURE([fp round support],
4013 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4015 [AC_DEFINE(HAVE_AS_FPRND, 1,
4016 [Define if your assembler supports fprnd.])])
4019 *-*-aix*) conftest_s=' .machine "pwr6"
4022 *) conftest_s=' .machine power6
4027 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4028 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4030 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4031 [Define if your assembler supports mffgpr and mftgpr.])])
4034 *-*-aix*) conftest_s=' .csect .text[[PR]]
4036 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4040 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4041 *) conftest_s=' .text
4043 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4046 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4047 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4049 [AC_DEFINE(HAVE_AS_REL16, 1,
4050 [Define if your assembler supports R_PPC_REL16 relocs.])])
4053 *-*-aix*) conftest_s=' .machine "pwr6"
4056 *) conftest_s=' .machine power6
4061 gcc_GAS_CHECK_FEATURE([compare bytes support],
4062 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4064 [AC_DEFINE(HAVE_AS_CMPB, 1,
4065 [Define if your assembler supports cmpb.])])
4068 *-*-aix*) conftest_s=' .machine "pwr6"
4071 *) conftest_s=' .machine power6
4076 gcc_GAS_CHECK_FEATURE([decimal float support],
4077 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4079 [AC_DEFINE(HAVE_AS_DFP, 1,
4080 [Define if your assembler supports DFP instructions.])])
4083 *-*-aix*) conftest_s=' .machine "pwr7"
4086 *) conftest_s=' .machine power7
4091 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4092 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4094 [AC_DEFINE(HAVE_AS_VSX, 1,
4095 [Define if your assembler supports VSX instructions.])])
4098 *-*-aix*) conftest_s=' .machine "pwr7"
4101 *) conftest_s=' .machine power7
4106 gcc_GAS_CHECK_FEATURE([popcntd support],
4107 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4109 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4110 [Define if your assembler supports POPCNTD instructions.])])
4113 *-*-aix*) conftest_s=' .machine "pwr8"
4114 .csect .text[[PR]]';;
4115 *) conftest_s=' .machine power8
4119 gcc_GAS_CHECK_FEATURE([power8 support],
4120 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4122 [AC_DEFINE(HAVE_AS_POWER8, 1,
4123 [Define if your assembler supports POWER8 instructions.])])
4126 *-*-aix*) conftest_s=' .csect .text[[PR]]
4128 *) conftest_s=' .text
4132 gcc_GAS_CHECK_FEATURE([lwsync support],
4133 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4135 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4136 [Define if your assembler supports LWSYNC instructions.])])
4139 *-*-aix*) conftest_s=' .machine "476"
4142 *) conftest_s=' .machine "476"
4147 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4148 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4150 [AC_DEFINE(HAVE_AS_DCI, 1,
4151 [Define if your assembler supports the DCI/ICI instructions.])])
4153 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4154 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4155 [.gnu_attribute 4,1],,
4156 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4157 [Define if your assembler supports .gnu_attribute.])])
4159 gcc_GAS_CHECK_FEATURE([tls marker support],
4160 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4161 [ bl __tls_get_addr(x@tlsgd)],,
4162 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4163 [Define if your assembler supports arg info for __tls_get_addr.])])
4167 gcc_GAS_CHECK_FEATURE([.ref support],
4168 gcc_cv_as_aix_ref, [2,21,0],,
4169 [ .csect stuff[[rw]]
4175 [AC_DEFINE(HAVE_AS_REF, 1,
4176 [Define if your assembler supports .ref])])
4182 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4183 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4184 [ lw $4,%gp_rel(foo)($4)],,
4185 [if test x$target_cpu_default = x
4186 then target_cpu_default=MASK_EXPLICIT_RELOCS
4187 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4189 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4190 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4191 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4192 [Define if the assembler understands -mno-shared.])])
4194 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4195 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4196 [.gnu_attribute 4,1],,
4197 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4198 [Define if your assembler supports .gnu_attribute.])])
4200 gcc_GAS_CHECK_FEATURE([.micromips support],
4201 gcc_cv_as_micromips_support,,[--fatal-warnings],
4203 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4204 [Define if your assembler supports the .set micromips directive])])
4206 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4207 gcc_cv_as_mips_dtprelword, [2,18,0],,
4208 [.section .tdata,"awT",@progbits
4212 .dtprelword x+0x8000],,
4213 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4214 [Define if your assembler supports .dtprelword.])])
4216 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4217 gcc_cv_as_mips_dspr1_mult,,,
4227 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4228 [Define if your assembler supports DSPR1 mult.])])
4230 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4231 gcc_cv_as_ld_jalr_reloc=no
4232 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4233 if test $in_tree_ld = yes ; then
4234 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 20 -o "$gcc_cv_gld_major_version" -gt 2 \
4235 && test $in_tree_ld_is_elf = yes; then
4236 gcc_cv_as_ld_jalr_reloc=yes
4238 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4239 echo ' .ent x' > conftest.s
4240 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4241 echo ' lw $25,%call16(y)($28)' >> conftest.s
4242 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4243 echo '1: jalr $25' >> conftest.s
4244 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4245 echo '1: jalr $25' >> conftest.s
4246 echo ' .end x' >> conftest.s
4247 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4248 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4249 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4250 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4251 gcc_cv_as_ld_jalr_reloc=yes
4257 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4258 if test x$target_cpu_default = x; then
4259 target_cpu_default=MASK_RELAX_PIC_CALLS
4261 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4264 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4266 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4267 [gcc_cv_ld_mips_personality_relaxation],
4268 [gcc_cv_ld_mips_personality_relaxation=no
4269 if test $in_tree_ld = yes ; then
4270 if test "$gcc_cv_gld_major_version" -eq 2 \
4271 -a "$gcc_cv_gld_minor_version" -ge 21 \
4272 -o "$gcc_cv_gld_major_version" -gt 2; then
4273 gcc_cv_ld_mips_personality_relaxation=yes
4275 elif test x$gcc_cv_as != x \
4276 -a x$gcc_cv_ld != x \
4277 -a x$gcc_cv_readelf != x ; then
4278 cat > conftest.s <<EOF
4280 .cfi_personality 0x80,indirect_ptr
4287 .section .data,"aw",@progbits
4291 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4292 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4293 if $gcc_cv_readelf -d conftest 2>&1 \
4294 | grep TEXTREL > /dev/null 2>&1; then
4296 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4297 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4300 gcc_cv_ld_mips_personality_relaxation=yes
4304 rm -f conftest.s conftest.o conftest])
4305 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4306 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4307 [Define if your linker can relax absolute .eh_frame personality
4308 pointers into PC-relative form.])
4311 gcc_GAS_CHECK_FEATURE([-mnan= support],
4312 gcc_cv_as_mips_nan,,
4314 [AC_DEFINE(HAVE_AS_NAN, 1,
4315 [Define if the assembler understands -mnan=.])])
4316 if test x$gcc_cv_as_mips_nan = xno \
4317 && test x$with_nan != x; then
4319 [Requesting --with-nan= requires assembler support for -mnan=])
4324 # Mips and HP-UX need the GNU assembler.
4325 # Linux on IA64 might be able to use the Intel assembler.
4328 mips*-*-* | *-*-hpux* )
4329 if test x$gas_flag = xyes \
4330 || test x"$host" != x"$build" \
4331 || test ! -x "$gcc_cv_as" \
4332 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4335 echo "*** This configuration requires the GNU assembler" >&2
4341 # ??? Not all targets support dwarf2 debug_line, even within a version
4342 # of gas. Moreover, we need to emit a valid instruction to trigger any
4343 # info to the output file. So, as supported targets are added to gas 2.11,
4344 # add some instruction here to (also) show we expect this might work.
4345 # ??? Once 2.11 is released, probably need to add first known working
4346 # version to the per-target configury.
4348 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4349 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4350 | xstormy16 | xtensa)
4360 if test x"$insn" != x; then
4362 .file 1 \"conftest.s\"
4365 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4366 gcc_cv_as_dwarf2_debug_line,
4367 [elf,2,11,0],, [$conftest_s],
4368 [if test x$gcc_cv_objdump != x \
4369 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4370 | grep debug_line > /dev/null 2>&1; then
4371 gcc_cv_as_dwarf2_debug_line=yes
4374 # The .debug_line file table must be in the exact order that
4375 # we specified the files, since these indices are also used
4376 # by DW_AT_decl_file. Approximate this test by testing if
4377 # the assembler bitches if the same index is assigned twice.
4378 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4379 gcc_cv_as_dwarf2_file_buggy,,,
4383 if test $gcc_cv_as_dwarf2_debug_line = yes \
4384 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4385 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4386 [Define if your assembler supports dwarf2 .file/.loc directives,
4387 and preserves file table indices exactly as given.])
4390 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4391 gcc_cv_as_gdwarf2_flag,
4392 [elf,2,11,0], [--gdwarf2], [$insn],,
4393 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4394 [Define if your assembler supports the --gdwarf2 option.])])
4396 gcc_GAS_CHECK_FEATURE([--gstabs option],
4397 gcc_cv_as_gstabs_flag,
4398 [elf,2,11,0], [--gstabs], [$insn],,
4399 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4400 [Define if your assembler supports the --gstabs option.])])
4402 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4403 gcc_cv_as_debug_prefix_map_flag,
4404 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4405 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4406 [Define if your assembler supports the --debug-prefix-map option.])])
4409 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4412 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4413 [Define if your assembler supports .lcomm with an alignment field.])])
4415 if test x$with_sysroot = x && test x$host = x$target \
4416 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4417 && test "$prefix" != "NONE"; then
4418 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4419 [Define to PREFIX/include if cpp should also search that directory.])
4422 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4423 if test "x$with_headers" != x; then
4424 target_header_dir=$with_headers
4425 elif test "x$with_sysroot" = x; then
4426 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4427 elif test "x$with_build_sysroot" != "x"; then
4428 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4429 elif test "x$with_sysroot" = xyes; then
4430 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4432 target_header_dir="${with_sysroot}${native_system_header_dir}"
4435 target_header_dir=${native_system_header_dir}
4438 # Determine the version of glibc, if any, used on the target.
4439 AC_MSG_CHECKING([for target glibc version])
4440 AC_ARG_WITH([glibc-version],
4441 [AS_HELP_STRING([--with-glibc-version=M.N],
4442 [assume GCC used with glibc version M.N or later])], [
4443 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4444 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4445 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4447 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4449 glibc_version_major=0
4450 glibc_version_minor=0
4451 [if test -f $target_header_dir/features.h \
4452 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4453 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4454 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4455 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4457 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4459 AC_ARG_ENABLE(gnu-unique-object,
4460 [AS_HELP_STRING([--enable-gnu-unique-object],
4461 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4462 [case $enable_gnu_unique_object in
4464 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4465 Valid choices are 'yes' and 'no'.]) ;;
4467 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4469 [.type foo, '$target_type_format_char'gnu_unique_object],,
4470 # We need to unquote above to to use the definition from config.gcc.
4471 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4472 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4474 if test x$enable_gnu_unique_object = xyes; then
4475 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4476 [Define if your assembler supports @gnu_unique_object.])
4479 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4480 [gcc_cv_as_line_zero],
4481 [gcc_cv_as_line_zero=no
4482 if test $in_tree_gas = yes; then
4483 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4484 elif test "x$gcc_cv_as" != x; then
4485 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4486 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4487 test "x`cat conftest.out`" = x
4489 gcc_cv_as_line_zero=yes
4491 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4492 cat conftest.s >&AS_MESSAGE_LOG_FD
4493 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4494 cat conftest.out >&AS_MESSAGE_LOG_FD
4496 rm -f conftest.o conftest.s conftest.out
4498 if test "x$gcc_cv_as_line_zero" = xyes; then
4499 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4500 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4503 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4504 gcc_cv_ld_eh_frame_hdr=no
4505 if test $in_tree_ld = yes ; then
4506 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 \
4507 && test $in_tree_ld_is_elf = yes; then
4508 gcc_cv_ld_eh_frame_hdr=yes
4510 elif test x$gcc_cv_ld != x; then
4511 if echo "$ld_ver" | grep GNU > /dev/null; then
4512 # Check if linker supports --eh-frame-hdr option
4513 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4514 gcc_cv_ld_eh_frame_hdr=yes
4519 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4520 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4521 gcc_cv_ld_eh_frame_hdr=yes
4527 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4528 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4529 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4530 [Define if your linker supports .eh_frame_hdr.])
4532 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4534 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4535 gcc_cv_ld_eh_frame_ciev3=no
4536 if test $in_tree_ld = yes ; then
4537 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 \
4538 && test $in_tree_ld_is_elf = yes; then
4539 gcc_cv_ld_eh_frame_ciev3=yes
4541 elif test x$gcc_cv_ld != x; then
4542 if echo "$ld_ver" | grep GNU > /dev/null; then
4543 gcc_cv_ld_eh_frame_ciev3=yes
4544 if test 0"$ld_date" -lt 20040513; then
4545 if test -n "$ld_date"; then
4546 # If there was date string, but was earlier than 2004-05-13, fail
4547 gcc_cv_ld_eh_frame_ciev3=no
4548 elif test "$ld_vers_major" -lt 2; then
4549 gcc_cv_ld_eh_frame_ciev3=no
4550 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4551 gcc_cv_ld_eh_frame_ciev3=no
4557 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4558 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4559 gcc_cv_ld_eh_frame_ciev3=yes
4565 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4566 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4567 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4568 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4570 AC_MSG_CHECKING(linker position independent executable support)
4572 if test $in_tree_ld = yes ; then
4573 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 \
4574 && test $in_tree_ld_is_elf = yes; then
4577 elif test x$gcc_cv_ld != x; then
4578 # Check if linker supports -pie option
4579 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4583 if test x"$gcc_cv_ld_pie" = xyes; then
4584 AC_DEFINE(HAVE_LD_PIE, 1,
4585 [Define if your linker supports -pie option.])
4587 AC_MSG_RESULT($gcc_cv_ld_pie)
4589 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4590 gcc_cv_ld_eh_gc_sections=no
4591 if test $in_tree_ld = yes ; then
4592 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 \
4593 && test $in_tree_ld_is_elf = yes; then
4594 gcc_cv_ld_eh_gc_sections=yes
4596 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4597 cat > conftest.s <<EOF
4600 .type _start, @function
4603 .size _start, .-_start
4604 .section .text.foo,"ax",@progbits
4605 .type foo, @function
4609 .section .gcc_except_table.foo,"a",@progbits
4612 .section .eh_frame,"a",@progbits
4615 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4616 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4617 | grep "gc-sections option ignored" > /dev/null; then
4618 gcc_cv_ld_eh_gc_sections=no
4619 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4620 | grep gcc_except_table > /dev/null; then
4621 gcc_cv_ld_eh_gc_sections=yes
4622 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4623 if test x$gcc_cv_as_comdat_group != xyes; then
4624 gcc_cv_ld_eh_gc_sections=no
4625 cat > conftest.s <<EOF
4628 .type _start, @function
4631 .size _start, .-_start
4632 .section .gnu.linkonce.t.foo,"ax",@progbits
4633 .type foo, @function
4637 .section .gcc_except_table.foo,"a",@progbits
4640 .section .eh_frame,"a",@progbits
4643 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4644 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4645 | grep "gc-sections option ignored" > /dev/null; then
4646 gcc_cv_ld_eh_gc_sections=no
4647 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4648 | grep gcc_except_table > /dev/null; then
4649 gcc_cv_ld_eh_gc_sections=yes
4655 rm -f conftest.s conftest.o conftest
4659 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4660 gcc_cv_ld_eh_gc_sections=no
4663 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4664 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4665 [Define if your linker supports garbage collection of
4666 sections in presence of EH frames.])
4668 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4670 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4671 gcc_cv_ld_eh_gc_sections_bug=no
4672 if test $in_tree_ld = yes ; then
4673 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 \
4674 && test $in_tree_ld_is_elf = yes; then
4675 gcc_cv_ld_eh_gc_sections_bug=yes
4677 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
4678 gcc_cv_ld_eh_gc_sections_bug=yes
4679 cat > conftest.s <<EOF
4682 .type _start, @function
4685 .size _start, .-_start
4686 .section .text.startup.foo,"ax",@progbits
4687 .type foo, @function
4691 .section .gcc_except_table.foo,"a",@progbits
4694 .section .eh_frame,"a",@progbits
4697 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4698 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4699 | grep "gc-sections option ignored" > /dev/null; then
4701 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4702 | grep gcc_except_table > /dev/null; then
4703 gcc_cv_ld_eh_gc_sections_bug=no
4706 rm -f conftest.s conftest.o conftest
4708 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4709 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4710 [Define if your linker has buggy garbage collection of
4711 sections support when .text.startup.foo like sections are used.])
4713 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4719 AC_CACHE_CHECK(linker --as-needed support,
4720 gcc_cv_ld_as_needed,
4721 [gcc_cv_ld_as_needed=no
4722 gcc_cv_ld_as_needed_option='--as-needed'
4723 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4724 if test $in_tree_ld = yes ; then
4725 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 \
4726 && test $in_tree_ld_is_elf = yes; then
4727 gcc_cv_ld_as_needed=yes
4729 elif test x$gcc_cv_ld != x; then
4730 # Check if linker supports --as-needed and --no-as-needed options
4731 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4732 gcc_cv_ld_as_needed=yes
4735 # Solaris 2 ld always supports -z ignore/-z record.
4737 gcc_cv_ld_as_needed=yes
4738 gcc_cv_ld_as_needed_option="-z ignore"
4739 gcc_cv_ld_no_as_needed_option="-z record"
4744 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4745 # dl_iterate_phdr, i.e. since Solaris 11.
4747 *-*-solaris2.1[[1-9]]*)
4749 i?86-*-* | x86_64-*-*)
4750 if echo "$ld_ver" | grep GNU > /dev/null; then
4751 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4752 gcc_cv_ld_as_needed=no
4758 gcc_cv_ld_as_needed=no
4762 if test x"$gcc_cv_ld_as_needed" = xyes; then
4763 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4764 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4765 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4766 [Define to the linker option to ignore unused dependencies.])
4767 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4768 [Define to the linker option to keep unused dependencies.])
4771 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4772 saved_LDFLAGS="$LDFLAGS"
4773 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4774 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4775 AC_LINK_IFELSE([int main(void) {return 0;}],
4776 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4778 LDFLAGS="$saved_LDFLAGS"
4779 if test "x$gcc_cv_ld_clearcap" = xyes; then
4780 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4781 [Define if the linker supports clearing hardware capabilities via mapfile.])
4782 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4784 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4786 case "$target:$tm_file" in
4787 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4790 emul_name="-melf64lppc"
4793 emul_name="-melf64ppc"
4796 emul_name="-melf64ppc_fbsd"
4799 AC_CACHE_CHECK(linker support for omitting dot symbols,
4800 gcc_cv_ld_no_dot_syms,
4801 [gcc_cv_ld_no_dot_syms=no
4802 if test x"$ld_is_gold" = xyes; then
4803 gcc_cv_ld_no_dot_syms=yes
4804 elif test $in_tree_ld = yes ; then
4805 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
4806 gcc_cv_ld_no_dot_syms=yes
4808 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4809 cat > conftest1.s <<EOF
4813 cat > conftest2.s <<EOF
4814 .section ".opd","aw"
4819 .quad .LEfoo,.TOC.@tocbase,0
4825 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4826 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4827 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4828 gcc_cv_ld_no_dot_syms=yes
4830 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4833 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4834 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4835 [Define if your PowerPC64 linker only needs function descriptor syms.])
4838 AC_CACHE_CHECK(linker large toc support,
4839 gcc_cv_ld_large_toc,
4840 [gcc_cv_ld_large_toc=no
4841 if test x"$ld_is_gold" = xyes; then
4842 gcc_cv_ld_large_toc=yes
4843 elif test $in_tree_ld = yes ; then
4844 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
4845 gcc_cv_ld_large_toc=yes
4847 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4848 cat > conftest.s <<EOF
4849 .section ".tbss","awT",@nobits
4855 addis 9,13,ie0@got@tprel@ha
4856 ld 9,ie0@got@tprel@l(9)
4858 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4859 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4860 gcc_cv_ld_large_toc=yes
4862 rm -f conftest conftest.o conftest.s
4865 if test x"$gcc_cv_ld_large_toc" = xyes; then
4866 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4867 [Define if your PowerPC64 linker supports a large TOC.])
4874 AC_CACHE_CHECK(linker large toc support,
4875 gcc_cv_ld_large_toc,
4876 [gcc_cv_ld_large_toc=no
4877 if test x$gcc_cv_as != x ; then
4878 cat > conftest.s <<EOF
4888 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4889 gcc_cv_ld_large_toc=yes
4891 rm -f conftest conftest.o conftest.s
4894 if test x"$gcc_cv_ld_large_toc" = xyes; then
4895 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4896 [Define if your PowerPC64 linker supports a large TOC.])
4901 AC_CACHE_CHECK(linker --build-id support,
4903 [gcc_cv_ld_buildid=no
4904 if test $in_tree_ld = yes ; then
4905 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4906 "$gcc_cv_gld_minor_version" -ge 18 -o \
4907 "$gcc_cv_gld_major_version" -gt 2 \
4908 && test $in_tree_ld_is_elf = yes; then
4909 gcc_cv_ld_buildid=yes
4911 elif test x$gcc_cv_ld != x; then
4912 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4913 gcc_cv_ld_buildid=yes
4916 if test x"$gcc_cv_ld_buildid" = xyes; then
4917 AC_DEFINE(HAVE_LD_BUILDID, 1,
4918 [Define if your linker supports --build-id.])
4921 AC_ARG_ENABLE(linker-build-id,
4922 [AS_HELP_STRING([--enable-linker-build-id],
4923 [compiler will always pass --build-id to linker])],
4925 enable_linker_build_id=no)
4927 if test x"$enable_linker_build_id" = xyes; then
4928 if test x"$gcc_cv_ld_buildid" = xyes; then
4929 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4930 [Define if gcc should always pass --build-id to linker.])
4932 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4936 # In binutils 2.21, GNU ld gained support for new emulations fully
4937 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4938 AC_CACHE_CHECK(linker *_sol2 emulation support,
4939 gcc_cv_ld_sol2_emulation,
4940 [gcc_cv_ld_sol2_emulation=no
4941 if test $in_tree_ld = yes ; then
4942 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4943 "$gcc_cv_gld_minor_version" -ge 21 -o \
4944 "$gcc_cv_gld_major_version" -gt 2 \
4945 && test $in_tree_ld_is_elf = yes; then
4946 gcc_cv_ld_sol2_emulation=yes
4948 elif test x$gcc_cv_ld != x; then
4949 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4950 grep _sol2 > /dev/null; then
4951 gcc_cv_ld_sol2_emulation=yes
4954 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4955 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4956 [Define if your linker supports the *_sol2 emulations.])
4959 AC_CACHE_CHECK(linker --sysroot support,
4961 [gcc_cv_ld_sysroot=no
4962 if test $in_tree_ld = yes ; then
4963 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
4964 gcc_cv_ld_sysroot=yes
4966 elif test x$gcc_cv_ld != x; then
4967 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4968 gcc_cv_ld_sysroot=yes
4971 if test x"$gcc_cv_ld_sysroot" = xyes; then
4972 AC_DEFINE(HAVE_LD_SYSROOT, 1,
4973 [Define if your linker supports --sysroot.])
4976 # Test for stack protector support in target C library.
4977 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4978 gcc_cv_libc_provides_ssp,
4979 [gcc_cv_libc_provides_ssp=no
4981 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4982 # glibc 2.4 and later provides __stack_chk_fail and
4983 # either __stack_chk_guard, or TLS access to stack guard canary.
4984 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
4985 [if test -f $target_header_dir/features.h \
4986 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
4987 $target_header_dir/features.h > /dev/null; then
4988 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
4989 $target_header_dir/features.h > /dev/null && \
4990 test -f $target_header_dir/bits/uClibc_config.h && \
4991 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
4992 $target_header_dir/bits/uClibc_config.h > /dev/null; then
4993 gcc_cv_libc_provides_ssp=yes
4995 # all versions of Bionic support stack protector
4996 elif test -f $target_header_dir/sys/cdefs.h \
4997 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
4998 $target_header_dir/sys/cdefs.h > /dev/null; then
4999 gcc_cv_libc_provides_ssp=yes
5003 # Avoid complicated tests (see
5004 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5005 # simply assert that glibc does provide this, which is true for all
5006 # realistically usable GNU/Hurd configurations.
5007 gcc_cv_libc_provides_ssp=yes;;
5008 *-*-darwin* | *-*-freebsd*)
5009 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5010 [echo "no __stack_chk_fail on this target"])
5012 *) gcc_cv_libc_provides_ssp=no ;;
5015 if test x$gcc_cv_libc_provides_ssp = xyes; then
5016 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5017 [Define if your target C library provides stack protector support])
5020 # Test for <sys/sdt.h> on the target.
5021 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5022 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5024 if test -f $target_header_dir/sys/sdt.h; then
5026 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5027 [Define if your target C library provides sys/sdt.h])
5029 AC_MSG_RESULT($have_sys_sdt_h)
5031 # Check if TFmode long double should be used by default or not.
5032 # Some glibc targets used DFmode long double, but with glibc 2.4
5033 # and later they can use TFmode.
5035 powerpc*-*-linux* | \
5039 AC_ARG_WITH(long-double-128,
5040 [AS_HELP_STRING([--with-long-double-128],
5041 [use 128-bit long double by default])],
5042 gcc_cv_target_ldbl128="$with_long_double_128",
5043 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5044 [gcc_cv_target_ldbl128=no
5045 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5046 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5047 && gcc_cv_target_ldbl128=yes
5051 if test x$gcc_cv_target_ldbl128 = xyes; then
5052 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5053 [Define if TFmode long double should be the default])
5056 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5057 gcc_cv_target_dl_iterate_phdr=unknown
5059 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5060 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5061 # libdl there, both complicating its use and breaking compatibility
5062 # between Solaris 10 updates.
5063 *-*-solaris2.1[[1-9]]*)
5064 # <link.h> needs both a dl_iterate_phdr declaration and support for
5065 # compilation with largefile support.
5066 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5067 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5068 gcc_cv_target_dl_iterate_phdr=yes
5070 gcc_cv_target_dl_iterate_phdr=no
5073 *-*-dragonfly* | *-*-freebsd*)
5074 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5075 gcc_cv_target_dl_iterate_phdr=yes
5077 gcc_cv_target_dl_iterate_phdr=no
5081 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5082 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5083 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5084 [Define if your target C library provides the `dl_iterate_phdr' function.])
5086 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5088 # We no longer support different GC mechanisms. Emit an error if
5089 # the user configures with --with-gc.
5091 [AS_HELP_STRING([--with-gc={page,zone}],
5092 [this option is not supported anymore. It used to choose
5093 the garbage collection mechanism to use with the compiler])],
5094 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5097 # Libraries to use on the host. This will normally be set by the top
5098 # level Makefile. Here we simply capture the value for our Makefile.
5099 if test -z "${HOST_LIBS+set}"; then
5104 # Use the system's zlib library.
5106 zlibinc="-I\$(srcdir)/../zlib"
5107 AC_ARG_WITH(system-zlib,
5108 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5115 dnl Very limited version of automake's enable-maintainer-mode
5117 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5118 dnl maintainer-mode is disabled by default
5119 AC_ARG_ENABLE(maintainer-mode,
5120 [AS_HELP_STRING([--enable-maintainer-mode],
5121 [enable make rules and dependencies not useful
5122 (and sometimes confusing) to the casual installer])],
5123 maintainer_mode=$enableval,
5126 AC_MSG_RESULT($maintainer_mode)
5128 if test "$maintainer_mode" = "yes"; then
5135 dnl Whether to prevent multiple front-ends from linking at the same time
5137 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5138 AC_ARG_ENABLE(link-mutex,
5139 [AS_HELP_STRING([--enable-link-mutex],
5140 [avoid linking multiple front-ends at once to avoid thrashing
5141 on the build machine])],
5142 do_link_mutex=$enableval,
5144 AC_MSG_RESULT($do_link_mutex)
5146 if test "$do_link_mutex" = "yes"; then
5151 AC_SUBST(DO_LINK_MUTEX)
5157 # Make empty files to contain the specs and options for each language.
5158 # Then add #include lines to for a compiler that has specs and/or options.
5164 # These (without "all_") are set in each config-lang.in.
5165 # `language' must be a single word so is spelled singularly.
5168 all_outputs='Makefile'
5169 # List of language makefile fragments.
5171 # Additional files for gengtype
5172 all_gtfiles="$target_gtfiles"
5174 # These are the languages that are set in --enable-languages,
5175 # and are available in the GCC tree.
5176 all_selected_languages=
5178 # Add the language fragments.
5179 # Languages are added via two mechanisms. Some information must be
5180 # recorded in makefile variables, these are defined in config-lang.in.
5181 # We accumulate them and plug them into the main Makefile.
5182 # The other mechanism is a set of hooks for each of the main targets
5183 # like `clean', `install', etc.
5185 language_hooks="Make-hooks"
5187 for lang in ${srcdir}/*/config-lang.in
5190 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5192 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5193 if test "x$lang_alias" = x
5195 echo "$lang doesn't set \$language." 1>&2
5198 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5199 subdirs="$subdirs $subdir"
5201 # $gcc_subdir is where the gcc integration files are to be found
5202 # for a language, both for internal compiler purposes (compiler
5203 # sources implementing front-end to GCC tree converters), and for
5204 # build infrastructure purposes (Make-lang.in, etc.)
5206 # This will be <subdir> (relative to $srcdir) if a line like
5207 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5208 # is found in <langdir>/config-lang.in, and will remain <langdir>
5211 # Except for the language alias (fetched above), the regular
5212 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5213 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5214 # only this and the language alias.
5216 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5217 if [ "$gcc_subdir" = "" ]; then
5218 gcc_subdir="$subdir"
5221 case ",$enable_languages," in
5223 all_selected_languages="$all_selected_languages $lang_alias"
5224 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5225 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5237 . ${srcdir}/$gcc_subdir/config-lang.in
5238 if test "x$language" = x
5240 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5245 case ",$enable_languages," in
5248 for i in $subdir_requires; do
5249 test -f "${srcdir}/$i/config-lang.in" && continue
5257 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5258 if test -f $srcdir/$gcc_subdir/lang.opt; then
5259 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5260 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5262 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5263 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5265 all_languages="$all_languages $language"
5266 all_compilers="$all_compilers $compilers"
5267 all_outputs="$all_outputs $outputs"
5268 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5269 case ",$enable_languages," in
5271 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5273 AC_SUBST(enable_lto)
5280 for language in $all_selected_languages
5282 check_languages="$check_languages check-$language"
5285 # We link each language in with a set of hooks, reached indirectly via
5286 # lang.${target}. Only do so for selected languages.
5290 target_list="all.cross start.encap rest.encap tags \
5291 install-common install-man install-info install-pdf install-html dvi \
5292 pdf html uninstall info man srcextra srcman srcinfo \
5293 mostlyclean clean distclean maintainer-clean install-plugin"
5295 for t in $target_list
5298 for lang in $all_selected_languages
5302 echo "lang.$t: $x" >> Make-hooks
5306 # Option include files
5309 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5310 option_includes="option-includes.mk"
5311 AC_SUBST_FILE(option_includes)
5319 echo "dir ." > .gdbinit
5320 echo "dir ${srcdir}" >> .gdbinit
5321 if test x$gdb_needs_out_file_path = xyes
5323 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5325 if test "x$subdirs" != x; then
5328 echo "dir ${srcdir}/$s" >> .gdbinit
5331 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5332 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5334 # Put a breakpoint on __asan_report_error to help with debugging buffer
5337 *-fsanitize=address*)
5338 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5342 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5343 AC_SUBST(gcc_tooldir)
5346 # Find a directory in which to install a shared libgcc.
5348 AC_ARG_ENABLE(version-specific-runtime-libs,
5349 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5350 [specify that runtime libraries should be
5351 installed in a compiler-specific directory])])
5353 # Substitute configuration variables
5356 AC_SUBST(all_compilers)
5357 AC_SUBST(all_gtfiles)
5358 AC_SUBST(all_lang_makefrags)
5359 AC_SUBST(all_languages)
5360 AC_SUBST(all_selected_languages)
5361 AC_SUBST(build_exeext)
5362 AC_SUBST(build_install_headers_dir)
5363 AC_SUBST(build_xm_file_list)
5364 AC_SUBST(build_xm_include_list)
5365 AC_SUBST(build_xm_defines)
5366 AC_SUBST(build_file_translate)
5367 AC_SUBST(check_languages)
5368 AC_SUBST(cpp_install_dir)
5369 AC_SUBST(xmake_file)
5370 AC_SUBST(tmake_file)
5371 AC_SUBST(TM_ENDIAN_CONFIG)
5372 AC_SUBST(TM_MULTILIB_CONFIG)
5373 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5374 AC_SUBST(extra_gcc_objs)
5375 AC_SUBST(user_headers_inc_next_pre)
5376 AC_SUBST(user_headers_inc_next_post)
5377 AC_SUBST(extra_headers_list)
5378 AC_SUBST(extra_objs)
5379 AC_SUBST(extra_programs)
5380 AC_SUBST(float_h_file)
5381 AC_SUBST(gcc_config_arguments)
5382 AC_SUBST(gcc_gxx_include_dir)
5383 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5384 AC_SUBST(host_exeext)
5385 AC_SUBST(host_xm_file_list)
5386 AC_SUBST(host_xm_include_list)
5387 AC_SUBST(host_xm_defines)
5388 AC_SUBST(out_host_hook_obj)
5390 AC_SUBST(lang_opt_files)
5391 AC_SUBST(lang_specs_files)
5392 AC_SUBST(lang_tree_files)
5393 AC_SUBST(local_prefix)
5395 AC_SUBST(objc_boehm_gc)
5397 AC_SUBST(out_object_file)
5398 AC_SUBST(common_out_file)
5399 AC_SUBST(common_out_object_file)
5400 AC_SUBST(tm_file_list)
5401 AC_SUBST(tm_include_list)
5402 AC_SUBST(tm_defines)
5403 AC_SUBST(tm_p_file_list)
5404 AC_SUBST(tm_p_include_list)
5405 AC_SUBST(xm_file_list)
5406 AC_SUBST(xm_include_list)
5407 AC_SUBST(xm_defines)
5408 AC_SUBST(use_gcc_stdint)
5409 AC_SUBST(c_target_objs)
5410 AC_SUBST(cxx_target_objs)
5411 AC_SUBST(fortran_target_objs)
5412 AC_SUBST(target_cpu_default)
5414 AC_SUBST_FILE(language_hooks)
5417 if test x${build} = x${host} ; then
5418 if test x${host} = x${target} ; then
5419 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5421 echo "Links are now set up to build a cross-compiler" 1>&2
5422 echo " from ${host} to ${target}." 1>&2
5425 if test x${host} = x${target} ; then
5426 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5427 echo " for ${target}." 1>&2
5429 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5430 echo " from ${host} to ${target}." 1>&2
5434 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5435 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5437 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5438 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5440 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5441 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5442 if test "x${CLOOGLIBS}" != "x" ; then
5443 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5446 # Check for plugin support
5447 AC_ARG_ENABLE(plugin,
5448 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5449 enable_plugin=$enableval,
5450 enable_plugin=yes; default_plugin=yes)
5456 if test x$build = x$host; then
5457 export_sym_check="nm${exeext} -g"
5458 elif test x$host = x$target; then
5459 export_sym_check="$gcc_cv_nm -g"
5465 if test x$build = x$host; then
5466 export_sym_check="objdump${exeext} -T"
5467 elif test x$host = x$target; then
5468 export_sym_check="$gcc_cv_objdump -T"
5475 if test x"$enable_plugin" = x"yes"; then
5477 AC_MSG_CHECKING([for exported symbols])
5478 if test "x$export_sym_check" != x; then
5479 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5480 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5481 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5482 : # No need to use a flag
5483 AC_MSG_RESULT([yes])
5485 AC_MSG_RESULT([yes])
5486 AC_MSG_CHECKING([for -rdynamic])
5487 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5488 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5490 pluginlibs="-rdynamic"
5495 AC_MSG_RESULT([$plugin_rdynamic])
5498 AC_MSG_RESULT([unable to check])
5503 AC_SEARCH_LIBS([dlopen], [dl])
5504 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5505 pluginlibs="$pluginlibs -ldl"
5509 # Check that we can build shared objects with -fPIC -shared
5510 saved_LDFLAGS="$LDFLAGS"
5511 saved_CFLAGS="$CFLAGS"
5514 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5515 CFLAGS="$CFLAGS -fPIC"
5516 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5519 CFLAGS="$CFLAGS -fPIC"
5520 LDFLAGS="$LDFLAGS -fPIC -shared"
5523 AC_MSG_CHECKING([for -fPIC -shared])
5525 [extern int X;],[return X == 0;],
5526 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5527 [AC_MSG_RESULT([no]); have_pic_shared=no])
5528 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5532 LDFLAGS="$saved_LDFLAGS"
5533 CFLAGS="$saved_CFLAGS"
5535 # If plugin support had been requested but not available, fail.
5536 if test x"$enable_plugin" = x"no" ; then
5537 if test x"$default_plugin" != x"yes"; then
5539 Building GCC with plugin support requires a host that supports
5540 -fPIC, -shared, -ldl and -rdynamic.])
5545 AC_SUBST(pluginlibs)
5546 AC_SUBST(enable_plugin)
5547 if test x"$enable_plugin" = x"yes"; then
5548 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5552 # Enable --enable-host-shared
5553 AC_ARG_ENABLE(host-shared,
5554 [AS_HELP_STRING([--enable-host-shared],
5555 [build host code as shared libraries])],
5556 [PICFLAG=-fPIC], [PICFLAG=])
5557 AC_SUBST(enable_host_shared)
5561 AC_ARG_ENABLE(libquadmath-support,
5562 [AS_HELP_STRING([--disable-libquadmath-support],
5563 [disable libquadmath support for Fortran])],
5564 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5565 ENABLE_LIBQUADMATH_SUPPORT=yes)
5566 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5567 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5568 [Define to 1 to enable libquadmath support])
5572 # Specify what hash style to use by default.
5573 AC_ARG_WITH([linker-hash-style],
5574 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5575 [specify the linker hash style])],
5576 [case x"$withval" in
5578 LINKER_HASH_STYLE=sysv
5581 LINKER_HASH_STYLE=gnu
5584 LINKER_HASH_STYLE=both
5587 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5590 [LINKER_HASH_STYLE=''])
5591 if test x"${LINKER_HASH_STYLE}" != x; then
5592 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5593 [The linker hash style])
5596 # Configure the subdirectories
5597 # AC_CONFIG_SUBDIRS($subdirs)
5599 # Create the Makefile
5600 # and configure language subdirectories
5601 AC_CONFIG_FILES($all_outputs)
5603 AC_CONFIG_COMMANDS([default],
5605 case ${CONFIG_HEADERS} in
5606 *auto-host.h:config.in*)
5609 # Make sure all the subdirs exist.
5610 for d in $subdirs doc build common c-family
5612 test -d $d || mkdir $d
5615 [subdirs='$subdirs'])