2 # Process this file with autoconf to generate a configuration script.
4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
5 # 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 #This file is part of GCC.
9 #GCC is free software; you can redistribute it and/or modify it under
10 #the terms of the GNU General Public License as published by the Free
11 #Software Foundation; either version 3, or (at your option) any later
14 #GCC is distributed in the hope that it will be useful, but WITHOUT
15 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 #You should have received a copy of the GNU General Public License
20 #along with GCC; see the file COPYING3. If not see
21 #<http://www.gnu.org/licenses/>.
23 # --------------------------------
24 # Initialization and sanity checks
25 # --------------------------------
29 AC_CONFIG_SRCDIR(tree.c)
30 AC_CONFIG_HEADER(auto-host.h:config.in)
32 gcc_version=`cat $srcdir/BASE-VER`
34 # Determine the host, build, and target systems
39 # Determine the noncanonical target name, for directory use.
40 ACX_NONCANONICAL_TARGET
42 # Determine the target- and build-specific subdirectories
45 # Set program_transform_name
48 # Check for bogus environment variables.
49 # Test if LIBRARY_PATH contains the notation for the current directory
50 # since this would lead to problems installing/building glibc.
51 # LIBRARY_PATH contains the current directory if one of the following
53 # - one of the terminals (":" and ";") is the first or last sign
54 # - two terminals occur directly after each other
55 # - the path contains an element with a dot in it
56 AC_MSG_CHECKING(LIBRARY_PATH variable)
58 case ${LIBRARY_PATH} in
59 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
60 library_path_setting="contains current directory"
63 library_path_setting="ok"
67 AC_MSG_RESULT($library_path_setting)
68 if test "$library_path_setting" != "ok"; then
70 *** LIBRARY_PATH shouldn't contain the current directory when
71 *** building gcc. Please change the environment variable
72 *** and run configure again.])
75 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
76 # since this would lead to problems installing/building glibc.
77 # GCC_EXEC_PREFIX contains the current directory if one of the following
79 # - one of the terminals (":" and ";") is the first or last sign
80 # - two terminals occur directly after each other
81 # - the path contains an element with a dot in it
82 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
84 case ${GCC_EXEC_PREFIX} in
85 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
86 gcc_exec_prefix_setting="contains current directory"
89 gcc_exec_prefix_setting="ok"
93 AC_MSG_RESULT($gcc_exec_prefix_setting)
94 if test "$gcc_exec_prefix_setting" != "ok"; then
96 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
97 *** building gcc. Please change the environment variable
98 *** and run configure again.])
105 # Specify the local prefix
107 AC_ARG_WITH(local-prefix,
108 [AS_HELP_STRING([--with-local-prefix=DIR],
109 [specifies directory to put local include])],
110 [case "${withval}" in
111 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
113 *) local_prefix=$with_local_prefix ;;
116 # Default local prefix if it is empty
117 if test x$local_prefix = x; then
118 local_prefix=/usr/local
121 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
122 # passed in by the toplevel make and thus we'd get different behavior
123 # depending on where we built the sources.
125 # Specify the g++ header file directory
126 AC_ARG_WITH(gxx-include-dir,
127 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
128 [specifies directory to put g++ header files])],
129 [case "${withval}" in
130 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
132 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
135 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
136 if test x${gcc_gxx_include_dir} = x; then
137 if test x${enable_version_specific_runtime_libs} = xyes; then
138 gcc_gxx_include_dir='${libsubdir}/include/c++'
140 libstdcxx_incdir='include/c++/$(version)'
141 if test x$host != x$target; then
142 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
144 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
148 AC_ARG_WITH(cpp_install_dir,
149 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
150 [install the user visible C preprocessor in DIR
151 (relative to PREFIX) as well as PREFIX/bin])],
152 [if test x$withval = xyes; then
153 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
154 elif test x$withval != xno; then
155 cpp_install_dir=$withval
158 # We would like to our source tree to be readonly. However when releases or
159 # pre-releases are generated, the flex/bison generated files as well as the
160 # various formats of manuals need to be included along with the rest of the
161 # sources. Therefore we have --enable-generated-files-in-srcdir to do
164 AC_MSG_CHECKING([whether to place generated files in the source directory])
165 dnl generated-files-in-srcdir is disabled by default
166 AC_ARG_ENABLE(generated-files-in-srcdir,
167 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
168 [put copies of generated files in source dir
169 intended for creating source tarballs for users
170 without texinfo bison or flex])],
171 generated_files_in_srcdir=$enableval,
172 generated_files_in_srcdir=no)
174 AC_MSG_RESULT($generated_files_in_srcdir)
176 if test "$generated_files_in_srcdir" = "yes"; then
183 # -------------------
184 # Find default linker
185 # -------------------
189 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
190 gnu_ld_flag="$with_gnu_ld",
193 # With pre-defined ld
195 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
196 DEFAULT_LINKER="$with_ld")
197 if test x"${DEFAULT_LINKER+set}" = x"set"; then
198 if test ! -x "$DEFAULT_LINKER"; then
199 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
200 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
203 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
204 [Define to enable the use of a default linker.])
207 gnu_ld=`if test x"$gnu_ld_flag" = x"yes"; then echo 1; else echo 0; fi`
208 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld, [Define if using GNU ld.])
210 AC_MSG_CHECKING([whether a default linker was specified])
211 if test x"${DEFAULT_LINKER+set}" = x"set"; then
212 if test x"$gnu_ld_flag" = x"no"; then
213 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
215 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
221 # With demangler in GNU ld
222 AC_ARG_WITH(demangler-in-ld,
223 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
224 demangler_in_ld="$with_demangler_in_ld",
227 # ----------------------
228 # Find default assembler
229 # ----------------------
233 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
234 gas_flag="$with_gnu_as",
238 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
239 DEFAULT_ASSEMBLER="$with_as")
240 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
241 if test ! -x "$DEFAULT_ASSEMBLER"; then
242 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
243 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
246 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
247 [Define to enable the use of a default assembler.])
250 gnu_as=`if test x"$gas_flag" = x"yes"; then echo 1; else echo 0; fi`
251 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as, [Define if using GNU as.])
253 AC_MSG_CHECKING([whether a default assembler was specified])
254 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
255 if test x"$gas_flag" = x"no"; then
256 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
258 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
268 # If a non-executable a.out is present (e.g. created by GNU as above even if
269 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
270 # file, even when creating an executable, so an execution test fails.
271 # Remove possible default executable files to avoid this.
273 # FIXME: This really belongs into AC_PROG_CC and can be removed once
274 # Autoconf includes it.
275 rm -f a.out a.exe b.out
277 # Find the native compiler
281 ACX_PROG_GNAT([-I"$srcdir"/ada])
283 # autoconf is lame and doesn't give us any substitution variable for this.
284 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
285 NO_MINUS_C_MINUS_O=yes
287 OUTPUT_OPTION='-o $@'
289 AC_SUBST(NO_MINUS_C_MINUS_O)
290 AC_SUBST(OUTPUT_OPTION)
292 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
293 # optimizations to be activated explicitly by the toplevel.
296 *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
300 # Determine PICFLAG for target gnatlib.
301 GCC_PICFLAG_FOR_TARGET
302 AC_SUBST(PICFLAG_FOR_TARGET)
304 # -------------------------
305 # Check C compiler features
306 # -------------------------
308 AC_USE_SYSTEM_EXTENSIONS
314 # sizeof(char) is 1 by definition.
315 AC_CHECK_SIZEOF(void *)
316 AC_CHECK_SIZEOF(short)
318 AC_CHECK_SIZEOF(long)
319 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
320 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
323 # ---------------------
324 # Warnings and checking
325 # ---------------------
327 # Check $CC warning features (if it's GCC).
328 # We want to use -pedantic, but we don't want warnings about
332 # * C++11 narrowing conversions in { }
333 # So, we only use -pedantic if we can disable those warnings.
335 ACX_PROG_CC_WARNING_OPTS(
336 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual])), [loose_warn])
337 ACX_PROG_CC_WARNING_OPTS(
338 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
340 ACX_PROG_CC_WARNING_OPTS(
341 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
342 ACX_PROG_CC_WARNING_OPTS(
343 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
344 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
345 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
346 [-Wno-overlength-strings])), [strict_warn])
347 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
349 # The above macros do nothing if the compiler is not GCC. However, the
350 # Makefile has more goo to add other flags, so these variables are used
351 # to enable warnings only for GCC.
354 if test "x$GCC" = "xyes"; then
355 warn_cflags='$(GCC_WARN_CFLAGS)'
356 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
358 AC_SUBST(warn_cflags)
359 AC_SUBST(warn_cxxflags)
361 # Disable exceptions and RTTI if building with g++
362 ACX_PROG_CC_WARNING_OPTS(
363 m4_quote(m4_do([-fno-exceptions -fno-rtti])), [noexception_flags])
365 # Enable expensive internal checks
367 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
371 AC_ARG_ENABLE(checking,
372 [AS_HELP_STRING([[--enable-checking[=LIST]]],
373 [enable expensive run-time checks. With LIST,
374 enable only specific categories of checks.
375 Categories are: yes,no,all,none,release.
376 Flags are: assert,df,fold,gc,gcac,gimple,misc,
377 rtlflag,rtl,runtime,tree,valgrind,types])],
378 [ac_checking_flags="${enableval}"],[
379 # Determine the default checks.
380 if test x$is_release = x ; then
381 ac_checking_flags=yes
383 ac_checking_flags=release
385 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
386 for check in release $ac_checking_flags
389 # these set all the flags to specific states
390 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
391 ac_fold_checking= ; ac_gc_checking=1 ;
392 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
393 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
394 ac_tree_checking=1 ; ac_valgrind_checking= ;
395 ac_types_checking=1 ;;
396 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
397 ac_fold_checking= ; ac_gc_checking= ;
398 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
399 ac_rtlflag_checking= ; ac_runtime_checking= ;
400 ac_tree_checking= ; ac_valgrind_checking= ;
401 ac_types_checking= ;;
402 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
403 ac_fold_checking=1 ; ac_gc_checking=1 ;
404 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
405 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
406 ac_tree_checking=1 ; ac_valgrind_checking= ;
407 ac_types_checking=1 ;;
408 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
409 ac_fold_checking= ; ac_gc_checking= ;
410 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
411 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
412 ac_tree_checking= ; ac_valgrind_checking= ;
413 ac_types_checking= ;;
414 # these enable particular checks
415 assert) ac_assert_checking=1 ;;
416 df) ac_df_checking=1 ;;
417 fold) ac_fold_checking=1 ;;
418 gc) ac_gc_checking=1 ;;
419 gcac) ac_gc_always_collect=1 ;;
420 gimple) ac_gimple_checking=1 ;;
421 misc) ac_checking=1 ;;
422 rtl) ac_rtl_checking=1 ;;
423 rtlflag) ac_rtlflag_checking=1 ;;
424 runtime) ac_runtime_checking=1 ;;
425 tree) ac_tree_checking=1 ;;
426 types) ac_types_checking=1 ;;
427 valgrind) ac_valgrind_checking=1 ;;
428 *) AC_MSG_ERROR(unknown check category $check) ;;
434 if test x$ac_checking != x ; then
435 AC_DEFINE(ENABLE_CHECKING, 1,
436 [Define if you want more run-time sanity checks. This one gets a grab
437 bag of miscellaneous but relatively cheap checks.])
438 nocommon_flag=-fno-common
440 AC_SUBST(nocommon_flag)
441 if test x$ac_df_checking != x ; then
442 AC_DEFINE(ENABLE_DF_CHECKING, 1,
443 [Define if you want more run-time sanity checks for dataflow.])
445 if test x$ac_assert_checking != x ; then
446 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
447 [Define if you want assertions enabled. This is a cheap check.])
449 if test x$ac_gimple_checking != x ; then
450 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
451 [Define if you want operations on GIMPLE (the basic data structure of
452 the high-level optimizers) to be checked for dynamic type safety at
453 runtime. This is moderately expensive.])
455 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
456 if test x$ac_runtime_checking != x ; then
457 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
458 [Define if you want runtime assertions enabled. This is a cheap check.])
460 if test x$ac_tree_checking != x ; then
461 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
462 [Define if you want all operations on trees (the basic data
463 structure of the front ends) to be checked for dynamic type safety
464 at runtime. This is moderately expensive. The tree browser debugging
465 routines will also be enabled by this option.
467 TREEBROWSER=tree-browser.o
469 if test x$ac_types_checking != x ; then
470 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
471 [Define if you want all gimple types to be verified after gimplifiation.
475 AC_SUBST(TREEBROWSER)
476 if test x$ac_rtl_checking != x ; then
477 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
478 [Define if you want all operations on RTL (the basic data structure
479 of the optimizer and back end) to be checked for dynamic type safety
480 at runtime. This is quite expensive.])
482 if test x$ac_rtlflag_checking != x ; then
483 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
484 [Define if you want RTL flag accesses to be checked against the RTL
485 codes that are supported for each access macro. This is relatively
488 if test x$ac_gc_checking != x ; then
489 AC_DEFINE(ENABLE_GC_CHECKING, 1,
490 [Define if you want the garbage collector to do object poisoning and
491 other memory allocation checks. This is quite expensive.])
493 if test x$ac_gc_always_collect != x ; then
494 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
495 [Define if you want the garbage collector to operate in maximally
496 paranoid mode, validating the entire heap and collecting garbage at
497 every opportunity. This is extremely expensive.])
499 if test x$ac_fold_checking != x ; then
500 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
501 [Define if you want fold checked that it never destructs its argument.
502 This is quite expensive.])
504 valgrind_path_defines=
507 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
508 dnl # an if statement. This was the source of very frustrating bugs
509 dnl # in converting to autoconf 2.5x!
510 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
512 if test x$ac_valgrind_checking != x ; then
513 # It is certainly possible that there's valgrind but no valgrind.h.
514 # GCC relies on making annotations so we must have both.
515 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
516 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
517 [[#include <valgrind/memcheck.h>
518 #ifndef VALGRIND_DISCARD
519 #error VALGRIND_DISCARD not defined
521 [gcc_cv_header_valgrind_memcheck_h=yes],
522 [gcc_cv_header_valgrind_memcheck_h=no])
523 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
524 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
525 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
526 [[#include <memcheck.h>
527 #ifndef VALGRIND_DISCARD
528 #error VALGRIND_DISCARD not defined
530 [gcc_cv_header_memcheck_h=yes],
531 [gcc_cv_header_memcheck_h=no])
532 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
533 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
534 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
535 if test "x$valgrind_path" = "x" \
536 || (test $have_valgrind_h = no \
537 && test $gcc_cv_header_memcheck_h = no \
538 && test $gcc_cv_header_valgrind_memcheck_h = no); then
539 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
541 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
542 valgrind_command="$valgrind_path -q"
543 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
544 [Define if you want to run subprograms and generated programs
545 through valgrind (a memory checker). This is extremely expensive.])
546 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
547 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
548 [Define if valgrind's valgrind/memcheck.h header is installed.])
550 if test $gcc_cv_header_memcheck_h = yes; then
551 AC_DEFINE(HAVE_MEMCHECK_H, 1,
552 [Define if valgrind's memcheck.h header is installed.])
555 AC_SUBST(valgrind_path_defines)
556 AC_SUBST(valgrind_command)
558 # Enable code coverage collection
559 AC_ARG_ENABLE(coverage,
560 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
561 [enable compiler's code coverage collection.
562 Use to measure compiler performance and locate
563 unused parts of the compiler. With LEVEL, specify
564 optimization. Values are opt, noopt,
566 [case "${enableval}" in
568 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
571 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
574 # a.k.a. --disable-coverage
578 AC_MSG_ERROR(unknown coverage setting $enableval)
582 AC_SUBST(coverage_flags)
584 AC_ARG_ENABLE(gather-detailed-mem-stats,
585 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
586 [enable detailed memory allocation stats gathering])], [],
587 [enable_gather_detailed_mem_stats=no])
588 if test x$enable_gather_detailed_mem_stats = xyes ; then
589 AC_DEFINE(GATHER_STATISTICS, 1,
590 [Define to enable detailed memory allocation stats gathering.])
593 # -------------------------------
594 # Miscenalleous configure options
595 # -------------------------------
597 # See if we are building gcc with C++.
598 AC_ARG_ENABLE(build-with-cxx,
599 [AS_HELP_STRING([--enable-build-with-cxx],
600 [build with C++ compiler instead of C compiler])],
601 ENABLE_BUILD_WITH_CXX=$enableval,
602 ENABLE_BUILD_WITH_CXX=no)
603 AC_SUBST(ENABLE_BUILD_WITH_CXX)
604 if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
605 AC_DEFINE(ENABLE_BUILD_WITH_CXX, 1,
606 [Define if building with C++.])
611 [AS_HELP_STRING([--with-stabs],
612 [arrange to use stabs instead of host debug format])],
616 # Determine whether or not multilibs are enabled.
617 AC_ARG_ENABLE(multilib,
618 [AS_HELP_STRING([--enable-multilib],
619 [enable library support for multiple ABIs])],
620 [], [enable_multilib=yes])
621 AC_SUBST(enable_multilib)
623 # Enable __cxa_atexit for C++.
624 AC_ARG_ENABLE(__cxa_atexit,
625 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
628 # Enable C extension for decimal float if target supports it.
629 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
631 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
632 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
633 [Define to 1 to enable decimal float extension to C.])
635 # Use default_decimal_float for dependency.
636 enable_decimal_float=$default_decimal_float
638 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
639 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
640 [Define to 1 to specify that we are using the BID decimal floating
641 point format instead of DPD])
643 # Enable C extension for fixed-point arithmetic.
644 AC_ARG_ENABLE(fixed-point,
645 [AS_HELP_STRING([--enable-fixed-point],
646 [enable fixed-point arithmetic extension to C])],
651 enable_fixed_point=yes
657 AC_MSG_WARN([fixed-point is not supported on IRIX, ignored])
658 enable_fixed_point=no
661 enable_fixed_point=yes
666 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
667 enable_fixed_point=no
671 AC_SUBST(enable_fixed_point)
673 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
674 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
675 [Define to 1 to enable fixed-point arithmetic extension to C.])
678 # Pass with no value to take the default
679 # Pass with a value to specify a thread package
680 AC_ARG_ENABLE(threads,
681 [AS_HELP_STRING([[--enable-threads[=LIB]]],
682 [enable thread usage for target GCC,
683 using LIB thread package])],,
687 [AS_HELP_STRING([--enable-tls],
688 [enable or disable generation of tls code
689 overriding the assembler check for tls support])],
693 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
694 Valid choices are 'yes' and 'no'.]) ;;
698 AC_ARG_ENABLE(objc-gc,
699 [AS_HELP_STRING([--enable-objc-gc],
700 [enable the use of Boehm's garbage collector with
701 the GNU Objective-C runtime])],
702 if test x$enable_objc_gc = xno; then
710 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
711 dwarf2="$with_dwarf2",
714 AC_ARG_ENABLE(shared,
715 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
717 case $enable_shared in
721 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
722 for pkg in $enableval; do
723 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
730 ], [enable_shared=yes])
731 AC_SUBST(enable_shared)
733 AC_ARG_WITH([native-system-header-dir],
734 [ --with-native-system-header-dir=dir
735 use dir as the directory to look for standard
736 system header files in. Defaults to /usr/include.],
738 case ${with_native_system_header_dir} in
739 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
740 /* | [[A-Za-z]]:[[\\/]]*) ;;
741 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
743 configured_native_system_header_dir="${withval}"
744 ], [configured_native_system_header_dir=])
746 AC_ARG_WITH(build-sysroot,
747 [AS_HELP_STRING([--with-build-sysroot=sysroot],
748 [use sysroot as the system root during the build])],
749 [if test x"$withval" != x ; then
750 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
752 [SYSROOT_CFLAGS_FOR_TARGET=])
753 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
756 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
757 [search for usr/lib, usr/include, et al, within DIR])],
759 case ${with_sysroot} in
760 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
761 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
764 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
765 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
767 if test "x$prefix" = xNONE; then
768 test_prefix=/usr/local
772 if test "x$exec_prefix" = xNONE; then
773 test_exec_prefix=$test_prefix
775 test_exec_prefix=$exec_prefix
777 case ${TARGET_SYSTEM_ROOT} in
778 "${test_prefix}"|"${test_prefix}/"*|\
779 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
780 '${prefix}'|'${prefix}/'*|\
781 '${exec_prefix}'|'${exec_prefix}/'*)
782 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
783 TARGET_SYSTEM_ROOT_DEFINE="$t"
788 TARGET_SYSTEM_ROOT_DEFINE=
789 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
791 AC_SUBST(TARGET_SYSTEM_ROOT)
792 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
793 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
796 [AS_HELP_STRING([--with-specs=SPECS],
797 [add SPECS to driver command-line processing])],
798 [CONFIGURE_SPECS=$withval],
801 AC_SUBST(CONFIGURE_SPECS)
803 ACX_PKGVERSION([GCC])
804 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
806 # Sanity check enable_languages in case someone does not run the toplevel
807 # configure # script.
808 AC_ARG_ENABLE(languages,
809 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
810 [case ,${enable_languages}, in
812 # go safe -- we cannot be much sure without the toplevel
814 # analysis of which target libs are present and usable
818 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
823 enable_languages=c,${enable_languages}
826 [enable_languages=c])
828 AC_ARG_WITH(multilib-list,
829 [AS_HELP_STRING([--with-multilib-list], [select multilibs (SH and x86-64 only)])],
831 with_multilib_list=default)
833 # -------------------------
834 # Checks for other programs
835 # -------------------------
839 # Find some useful tools
841 # We need awk to create options.c and options.h.
842 # Bail out if it's missing.
844 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
851 AC_SUBST(ranlib_flags)
855 # See if cmp has --ignore-initial.
856 gcc_AC_PROG_CMP_IGNORE_INITIAL
858 # See if we have the mktemp command.
859 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
861 # See if makeinfo has been installed and is modern enough
862 # that we can use it.
863 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
864 [GNU texinfo.* \([0-9][0-9.]*\)],
865 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
866 if test $gcc_cv_prog_makeinfo_modern = no; then
868 *** Makeinfo is missing or too old.
869 *** Info documentation will not be built.])
876 # Is pod2man recent enough to regenerate manpages?
877 AC_MSG_CHECKING([for recent Pod::Man])
878 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
880 GENERATED_MANPAGES=generated-manpages
885 AC_SUBST(GENERATED_MANPAGES)
887 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
890 dnl Don't use AC_PROG_LEX; we insist on flex.
891 dnl LEXLIB is not useful in gcc.
892 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
895 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
897 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
898 # check for build == host before using them.
901 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
902 && test -d ../binutils ; then
903 NM='${objdir}/../binutils/nm-new'
905 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
909 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
910 && test -d ../binutils ; then
911 AR='${objdir}/../binutils/ar'
913 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
917 # --------------------
918 # Checks for C headers
919 # --------------------
921 # Need to reject headers which give warnings, so that the -Werror bootstrap
922 # works later. *sigh* This needs to come before all header checks.
929 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
930 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
931 sys/resource.h sys/param.h sys/times.h sys/stat.h \
932 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
934 # Check for thread headers.
935 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
936 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
938 # These tests can't be done till we know if we have limits.h.
942 # ----------------------
943 # Checks for C++ headers
944 # ----------------------
946 dnl Autoconf will give an error in the configure script if there is no
947 dnl C++ preprocessor. Hack to prevent that.
948 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
950 m4_popdef([AC_MSG_ERROR])[]dnl
954 AC_CHECK_HEADERS(unordered_map)
955 AC_CHECK_HEADERS(tr1/unordered_map)
956 AC_CHECK_HEADERS(ext/hash_map)
965 # These libraries may be used by collect2.
966 # We may need a special search path to get them linked.
967 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
969 for libs in '' -lld -lmld \
970 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
971 '-L/usr/lib/cmplrs/cc3.11 -lmld'
974 AC_TRY_LINK_FUNC(ldopen,
975 [gcc_cv_collect2_libs="$libs"; break])
978 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
979 case $gcc_cv_collect2_libs in
981 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
983 AC_SUBST(COLLECT2_LIBS)
985 # When building Ada code on Alpha, we need exc_resume which is usually in
986 # -lexc. So test for it.
989 AC_SEARCH_LIBS(exc_resume, exc)
992 AC_SUBST(GNAT_LIBEXC)
994 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
997 AC_SEARCH_LIBS(kstat_open, kstat)
998 EXTRA_GCC_LIBS="$LIBS"
1000 AC_SUBST(EXTRA_GCC_LIBS)
1002 # Some systems put ldexp and frexp in libm instead of libc; assume
1003 # they're both in the same place. jcf-dump needs them.
1006 AC_SEARCH_LIBS(ldexp, m)
1011 # Use <inttypes.h> only if it exists,
1012 # doesn't clash with <sys/types.h>, and declares intmax_t.
1013 AC_MSG_CHECKING(for inttypes.h)
1014 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1015 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1016 [[#include <sys/types.h>
1017 #include <inttypes.h>]],
1018 [[intmax_t i = -1;]])],
1019 [gcc_cv_header_inttypes_h=yes],
1020 [gcc_cv_header_inttypes_h=no])])
1021 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1022 if test $gcc_cv_header_inttypes_h = yes; then
1023 AC_DEFINE(HAVE_INTTYPES_H, 1,
1024 [Define if you have a working <inttypes.h> header file.])
1027 dnl Disabled until we have a complete test for buggy enum bitfields.
1028 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1030 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1031 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1032 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1033 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1034 putchar_unlocked putc_unlocked)
1035 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1036 sysconf strsignal getrusage nl_langinfo \
1037 gettimeofday mbstowcs wcswidth mmap setlocale \
1038 gcc_UNLOCKED_FUNCS madvise)
1040 if test x$ac_cv_func_mbstowcs = xyes; then
1041 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1042 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1048 [gcc_cv_func_mbstowcs_works=yes],
1049 [gcc_cv_func_mbstowcs_works=no],
1050 [gcc_cv_func_mbstowcs_works=yes])])
1051 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1052 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1053 [Define this macro if mbstowcs does not crash when its
1054 first argument is NULL.])
1058 AC_CHECK_TYPE(ssize_t, int)
1059 AC_CHECK_TYPE(caddr_t, char *)
1061 gcc_AC_FUNC_MMAP_BLACKLIST
1065 # Under VMS, vfork works very differently than on Unix. The standard test
1066 # won't work, and it isn't easily adaptable. It makes more sense to
1068 ac_cv_func_vfork_works=yes
1073 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1074 # iconv() prototype.
1075 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1076 [AC_LANG_PUSH([C++])
1078 AC_LANG_POP([C++])],
1081 # Until we have in-tree GNU iconv:
1083 AC_SUBST(LIBICONV_DEP)
1089 # We will need to find libiberty.h and ansidecl.h
1090 saved_CFLAGS="$CFLAGS"
1091 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1092 saved_CXXFLAGS="$CXXFLAGS"
1093 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include"
1094 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1095 strsignal strstr stpcpy strverscmp \
1096 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1097 free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1098 #include "ansidecl.h"
1099 #include "system.h"])
1101 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1102 #include "ansidecl.h"
1104 #ifdef HAVE_SYS_RESOURCE_H
1105 #include <sys/resource.h>
1109 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1110 #include "ansidecl.h"
1112 #ifdef HAVE_SYS_RESOURCE_H
1113 #include <sys/resource.h>
1115 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1116 [Define to `long' if <sys/resource.h> doesn't define.])])
1118 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1119 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1120 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1121 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1122 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1123 #include "ansidecl.h"
1132 gcc_AC_CHECK_DECLS(times, , ,[
1133 #include "ansidecl.h"
1135 #ifdef HAVE_SYS_TIMES_H
1136 #include <sys/times.h>
1140 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1141 #include "ansidecl.h"
1146 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1148 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1149 [AC_LANG_PUSH([C++])
1150 gcc_AC_CHECK_DECLS(madvise, , ,[
1151 #include "ansidecl.h"
1154 AC_LANG_POP([C++])],
1155 [gcc_AC_CHECK_DECLS(madvise, , ,[
1156 #include "ansidecl.h"
1161 # More time-related stuff.
1162 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1163 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1164 #include "ansidecl.h"
1166 #ifdef HAVE_SYS_TIMES_H
1167 #include <sys/times.h>
1169 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1170 if test $ac_cv_struct_tms = yes; then
1171 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1172 [Define if <sys/times.h> defines struct tms.])
1175 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1176 # revisit after autoconf 2.50.
1177 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1178 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1179 #include "ansidecl.h"
1181 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1182 if test $gcc_cv_type_clock_t = yes; then
1183 AC_DEFINE(HAVE_CLOCK_T, 1,
1184 [Define if <time.h> defines clock_t.])
1187 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1188 CFLAGS="$saved_CFLAGS"
1189 CXXFLAGS="$saved_CXXFLAGS"
1191 gcc_AC_INITFINI_ARRAY
1193 # mkdir takes a single argument on some systems.
1194 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1202 # With Setjmp/Longjmp based exception handling.
1203 AC_ARG_ENABLE(sjlj-exceptions,
1204 [AS_HELP_STRING([--enable-sjlj-exceptions],
1205 [arrange to use setjmp/longjmp exception handling])],
1208 if test $enableval != yes; then
1209 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1214 force_sjlj_exceptions=yes],
1217 force_sjlj_exceptions=yes
1221 force_sjlj_exceptions=no
1224 if test $force_sjlj_exceptions = yes; then
1225 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1226 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1227 [Define 0/1 to force the choice for exception handling model.])
1230 # --------------------------------------------------------
1231 # Build, host, and target specific configuration fragments
1232 # --------------------------------------------------------
1234 # Collect build-machine-specific information.
1235 . ${srcdir}/config.build
1237 # Collect host-machine-specific information.
1238 . ${srcdir}/config.host
1242 # Collect target-machine-specific information.
1243 . ${srcdir}/config.gcc
1245 extra_objs="${host_extra_objs} ${extra_objs}"
1246 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1248 # Default the target-machine variables that were not explicitly set.
1249 if test x"$tm_file" = x
1250 then tm_file=$cpu_type/$cpu_type.h; fi
1252 if test x"$extra_headers" = x
1253 then extra_headers=; fi
1255 if test x$md_file = x
1256 then md_file=$cpu_type/$cpu_type.md; fi
1258 if test x$out_file = x
1259 then out_file=$cpu_type/$cpu_type.c; fi
1261 if test x"$tmake_file" = x
1262 then tmake_file=$cpu_type/t-$cpu_type
1265 if test x"$dwarf2" = xyes
1266 then tm_file="$tm_file tm-dwarf2.h"
1269 # Say what files are being used for the output code and MD file.
1270 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1271 echo "Using \`$srcdir/config/$md_file' as machine description file."
1273 # If any of the xm_file variables contain nonexistent files, warn
1274 # about them and drop them.
1277 for x in $build_xm_file; do
1278 if test -f $srcdir/config/$x
1280 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1286 for x in $host_xm_file; do
1287 if test -f $srcdir/config/$x
1289 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1295 for x in $xm_file; do
1296 if test -f $srcdir/config/$x
1298 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1304 for f in $tm_file; do
1307 if test $count = ax; then
1308 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1310 echo "Using the following target machine macro files:"
1311 for f in $tm_file; do
1312 echo " $srcdir/config/$f"
1316 if test x$need_64bit_hwint = xyes; then
1317 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1318 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1321 if test x$use_long_long_for_widest_fast_int = xyes; then
1322 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1323 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1324 efficiently supported by the host hardware.])
1328 for f in $host_xm_file; do
1331 if test $count = a; then
1333 elif test $count = ax; then
1334 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1336 echo "Using the following host machine macro files:"
1337 for f in $host_xm_file; do
1338 echo " $srcdir/config/$f"
1341 echo "Using ${out_host_hook_obj} for host machine hooks."
1343 if test "$host_xm_file" != "$build_xm_file"; then
1345 for f in $build_xm_file; do
1348 if test $count = a; then
1350 elif test $count = ax; then
1351 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1353 echo "Using the following build machine macro files:"
1354 for f in $build_xm_file; do
1355 echo " $srcdir/config/$f"
1360 if test -n "$configured_native_system_header_dir"; then
1361 native_system_header_dir=$configured_native_system_header_dir
1363 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1364 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1368 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1369 gcc_cv_mcontext_underscores,
1371 #include <sys/cdefs.h>
1372 #include <sys/signal.h>
1373 #include <ucontext.h>
1374 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1376 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1377 if test $gcc_cv_mcontext_underscores = yes; then
1378 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1379 [mcontext_t fields start with __])
1388 # Check if a valid thread package
1389 case ${enable_threads} in
1392 target_thread_file='single'
1396 target_thread_file='single'
1398 aix | dce | lynx | mipssde | posix | rtems | \
1399 single | tpf | vxworks | win32)
1400 target_thread_file=${enable_threads}
1403 echo "${enable_threads} is an unknown thread package" 1>&2
1408 if test x${thread_file} = x; then
1409 # No thread file set by target-specific clauses in config.gcc,
1410 # so use file chosen by default logic above
1411 thread_file=${target_thread_file}
1419 if test x$enable___cxa_atexit = xyes || \
1420 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1421 if test x$host = x$target; then
1423 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1424 # keyed to flag_use_cxa_atexit
1429 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1430 [echo "__cxa_atexit can't be enabled on this target"])
1434 # We can't check for __cxa_atexit when building a cross, so assume
1438 if test x$use_cxa_atexit = xyes; then
1439 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1440 [Define if you want to use __cxa_atexit, rather than atexit, to
1441 register C++ destructors for local statics and global objects.
1442 This is essential for fully standards-compliant handling of
1443 destructors, but requires __cxa_atexit in libc.])
1447 # Look for a file containing extra machine modes.
1448 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1449 extra_modes_file='$(srcdir)'/config/${extra_modes}
1450 AC_SUBST(extra_modes_file)
1451 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1452 [Define to the name of a file containing a list of extra machine modes
1453 for this architecture.])
1456 # Convert extra_options into a form suitable for Makefile use.
1459 for f in $extra_options; do
1460 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1461 all_opt_files="$all_opt_files $srcdir/config/$f"
1463 AC_SUBST(extra_opt_files)
1465 # auto-host.h is the file containing items generated by autoconf and is
1466 # the first file included by config.h.
1467 # If host=build, it is correct to have bconfig include auto-host.h
1468 # as well. If host!=build, we are in error and need to do more
1469 # work to find out the build config parameters.
1470 if test x$host = x$build
1472 build_auto=auto-host.h
1474 # We create a subdir, then run autoconf in the subdir.
1475 # To prevent recursion we set host and build for the new
1476 # invocation of configure to the build for this invocation
1483 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1484 *) realsrcdir=../${srcdir};;
1486 saved_CFLAGS="${CFLAGS}"
1487 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1488 LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1489 ${realsrcdir}/configure \
1490 --enable-languages=${enable_languages-all} \
1491 --target=$target_alias --host=$build_alias --build=$build_alias
1492 CFLAGS="${saved_CFLAGS}"
1494 # We just finished tests for the build machine, so rename
1495 # the file auto-build.h in the gcc directory.
1496 mv auto-host.h ../auto-build.h
1499 build_auto=auto-build.h
1501 AC_SUBST(build_subdir)
1503 tm_file="${tm_file} defaults.h"
1504 tm_p_file="${tm_p_file} tm-preds.h"
1505 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1506 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1507 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1508 # put this back in temporarily.
1509 xm_file="auto-host.h ansidecl.h ${xm_file}"
1516 # Compile in configure arguments.
1517 if test -f configargs.h ; then
1518 # Being re-configured.
1519 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1520 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1522 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1525 # Double all backslashes and backslash all quotes to turn
1526 # gcc_config_arguments into a C string.
1527 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1528 $gcc_config_arguments
1530 gcc_config_arguments_str=`cat conftest.out`
1533 cat > configargs.h <<EOF
1534 /* Generated automatically. */
1535 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1536 static const char thread_model[] = "$thread_file";
1538 static const struct {
1539 const char *name, *value;
1540 } configure_default_options[] = $configure_default_options;
1545 gcc_BASEVER=`cat $srcdir/BASE-VER`
1546 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1547 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1548 if test -f $srcdir/REVISION ; then
1549 gcc_REVISION=`cat $srcdir/REVISION`
1553 cat > plugin-version.h <<EOF
1554 #include "configargs.h"
1556 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1557 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1558 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1559 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1561 static char basever[] = "$gcc_BASEVER";
1562 static char datestamp[] = "$gcc_DATESTAMP";
1563 static char devphase[] = "$gcc_DEVPHASE";
1564 static char revision[] = "$gcc_REVISION";
1566 /* FIXME plugins: We should make the version information more precise.
1567 One way to do is to add a checksum. */
1569 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1571 configuration_arguments};
1575 # Internationalization
1576 ZW_GNU_GETTEXT_SISTER_DIR
1578 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1579 # -liconv on the link line twice.
1580 case "$LIBINTL" in *$LIBICONV*)
1584 AC_ARG_ENABLE(secureplt,
1585 [AS_HELP_STRING([--enable-secureplt],
1586 [enable -msecure-plt by default for PowerPC])],
1589 AC_ARG_ENABLE(leading-mingw64-underscores,
1590 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1591 [enable leading underscores on 64 bit mingw targets]),
1593 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1594 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1595 [Define if we should use leading underscore on 64 bit mingw targets])])
1598 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1601 AC_ARG_ENABLE(frame-pointer,
1602 [AS_HELP_STRING([--enable-frame-pointer],
1603 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1606 linux* | darwin[[8912]]*)
1607 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1609 enable_frame_pointer=no
1612 enable_frame_pointer=yes
1617 # Windows32 Registry support for specifying GCC installation paths.
1618 AC_ARG_ENABLE(win32-registry,
1619 [AS_HELP_STRING([--disable-win32-registry],
1620 [disable lookup of installation paths in the
1621 Registry on Windows hosts])
1622 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1623 AS_HELP_STRING([--enable-win32-registry=KEY],
1624 [use KEY instead of GCC version as the last portion
1625 of the registry key])],,)
1628 win32 | pe | cygwin* | mingw32* | uwin*)
1629 if test "x$enable_win32_registry" != xno; then
1630 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1633 if test "x$enable_win32_registry" != xno; then
1634 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1635 [Define to 1 if installation paths should be looked up in the Windows
1636 Registry. Ignored on non-Windows hosts.])
1638 if test "x$enable_win32_registry" != xyes \
1639 && test "x$enable_win32_registry" != x; then
1640 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1641 [Define to be the last component of the Windows registry key under which
1642 to look for installation paths. The full key used will be
1643 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1644 The default is the GCC version number.])
1650 # Get an absolute path to the GCC top-level source directory
1651 holddir=`${PWDCMD-pwd}`
1653 topdir=`${PWDCMD-pwd}`
1656 # Conditionalize the makefile for this host machine.
1658 for f in ${host_xmake_file}
1660 if test -f ${srcdir}/config/$f
1662 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1666 # Conditionalize the makefile for this target machine.
1668 for f in ${tmake_file}
1670 if test -f ${srcdir}/config/$f
1672 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1675 tmake_file="${tmake_file_}"
1677 out_object_file=`basename $out_file .c`.o
1678 common_out_object_file=`basename $common_out_file .c`.o
1680 tm_file_list="options.h"
1681 tm_include_list="options.h insn-constants.h"
1682 for f in $tm_file; do
1685 f=`echo $f | sed 's/^..//'`
1686 tm_file_list="${tm_file_list} $f"
1687 tm_include_list="${tm_include_list} $f"
1690 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1691 tm_include_list="${tm_include_list} $f"
1694 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1695 tm_include_list="${tm_include_list} config/$f"
1702 for f in $tm_p_file; do
1705 tm_p_file_list="${tm_p_file_list} $f"
1706 tm_p_include_list="${tm_p_include_list} $f"
1709 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1710 tm_p_include_list="${tm_p_include_list} config/$f"
1716 for f in $xm_file; do
1719 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1720 xm_include_list="${xm_include_list} $f"
1723 xm_file_list="${xm_file_list} $f"
1724 xm_include_list="${xm_include_list} $f"
1727 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1728 xm_include_list="${xm_include_list} config/$f"
1734 host_xm_include_list=
1735 for f in $host_xm_file; do
1738 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1739 host_xm_include_list="${host_xm_include_list} $f"
1742 host_xm_file_list="${host_xm_file_list} $f"
1743 host_xm_include_list="${host_xm_include_list} $f"
1746 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1747 host_xm_include_list="${host_xm_include_list} config/$f"
1753 for f in $build_xm_file; do
1756 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1757 build_xm_include_list="${build_xm_include_list} $f"
1759 auto-build.h | auto-host.h )
1760 build_xm_file_list="${build_xm_file_list} $f"
1761 build_xm_include_list="${build_xm_include_list} $f"
1764 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1765 build_xm_include_list="${build_xm_include_list} config/$f"
1770 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1771 # cross-compiler which does not use the native headers and libraries.
1772 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1773 CROSS= AC_SUBST(CROSS)
1774 ALL=all.internal AC_SUBST(ALL)
1775 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1777 if test "x$with_build_sysroot" != x; then
1778 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1780 # This value is used, even on a native system, because
1781 # CROSS_SYSTEM_HEADER_DIR is just
1782 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1783 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1786 if test x$host != x$target
1788 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1790 SYSTEM_HEADER_DIR=$build_system_header_dir
1791 case "$host","$target" in
1792 # Darwin crosses can use the host system's libraries and headers,
1793 # because of the fat library support. Of course, it must be the
1794 # same version of Darwin on both sides. Allow the user to
1795 # just say --target=foo-darwin without a version number to mean
1796 # "the version on this system".
1797 *-*-darwin*,*-*-darwin*)
1798 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1799 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1800 if test $hostos = $targetos -o $targetos = darwin ; then
1802 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1807 i?86-*-*,x86_64-*-* \
1808 | powerpc*-*-*,powerpc64*-*-*)
1809 CROSS="$CROSS -DNATIVE_CROSS" ;;
1814 if test "x$with_headers" = x; then
1821 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1822 SYSTEM_HEADER_DIR=$build_system_header_dir
1825 # If this is a cross-compiler that does not
1826 # have its own set of headers then define
1829 # If this is using newlib, without having the headers available now,
1830 # then define inhibit_libc in LIBGCC2_CFLAGS.
1831 # This prevents libgcc2 from containing any code which requires libc
1833 : ${inhibit_libc=false}
1834 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1835 test x$with_newlib = xyes ; } &&
1836 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1839 AC_SUBST(inhibit_libc)
1841 # When building gcc with a cross-compiler, we need to adjust things so
1842 # that the generator programs are still built with the native compiler.
1843 # Also, we cannot run fixincludes.
1845 # These are the normal (build=host) settings:
1846 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1847 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1848 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1849 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1851 # And these apply if build != host, or we are generating coverage data
1852 if test x$build != x$host || test "x$coverage_flags" != x
1854 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1855 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1858 # Expand extra_headers to include complete path.
1859 # This substitutes for lots of t-* files.
1861 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1862 for file in ${extra_headers} ; do
1863 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1866 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1867 if test x"$use_gcc_tgmath" = xyes
1868 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1871 # Define collect2 in Makefile.
1872 case $host_can_use_collect2 in
1874 *) collect2='collect2$(exeext)' ;;
1876 AC_SUBST([collect2])
1878 # Add a definition of USE_COLLECT2 if system wants one.
1879 case $use_collect2 in
1880 no) use_collect2= ;;
1883 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1884 xm_defines="${xm_defines} USE_COLLECT2"
1885 case $host_can_use_collect2 in
1887 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1893 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1894 [Define to the name of the LTO plugin DSO that must be
1895 passed to the linker's -plugin=LIB option.])
1897 # ---------------------------
1898 # Assembler & linker features
1899 # ---------------------------
1901 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1902 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1903 # However when ld-new is first executed from the build tree, libtool will
1904 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1905 # to the build tree. While doing this we need to use the previous-stage
1906 # linker, or we have an infinite loop. The presence of a shell script as
1907 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1908 # the gcc/collect-ld script. So we need to know how libtool works, or
1909 # exec-tool will fail.
1911 m4_defun([_LT_CONFIG_COMMANDS], [])
1914 AC_SUBST(enable_fast_install)
1916 # Identify the assembler which will work hand-in-glove with the newly
1917 # built GCC, so that we can examine its features. This is the assembler
1918 # which will be driven by the driver program.
1920 # If build != host, and we aren't building gas in-tree, we identify a
1921 # build->target assembler and hope that it will have the same features
1922 # as the host->target assembler we'll be using.
1923 gcc_cv_gas_major_version=
1924 gcc_cv_gas_minor_version=
1925 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1927 m4_pattern_allow([AS_FOR_TARGET])dnl
1928 AS_VAR_SET_IF(gcc_cv_as,, [
1929 if test -x "$DEFAULT_ASSEMBLER"; then
1930 gcc_cv_as="$DEFAULT_ASSEMBLER"
1931 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1932 && test -f ../gas/Makefile \
1933 && test x$build = x$host; then
1934 gcc_cv_as=../gas/as-new$build_exeext
1935 elif test -x as$build_exeext; then
1936 # Build using assembler in the current directory.
1937 gcc_cv_as=./as$build_exeext
1938 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
1939 gcc_cv_as="$AS_FOR_TARGET"
1941 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1944 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1945 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1946 case "$ORIGINAL_AS_FOR_TARGET" in
1947 ./as | ./as$build_exeext) ;;
1948 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1951 AC_MSG_CHECKING(what assembler to use)
1952 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1953 # Single tree build which includes gas. We want to prefer it
1954 # over whatever linker top-level may have detected, since
1955 # we'll use what we're building after installation anyway.
1956 AC_MSG_RESULT(newly built gas)
1958 _gcc_COMPUTE_GAS_VERSION
1959 in_tree_gas_is_elf=no
1960 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1961 || (grep 'obj_format = multi' ../gas/Makefile \
1962 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1964 in_tree_gas_is_elf=yes
1967 AC_MSG_RESULT($gcc_cv_as)
1971 # Identify the linker which will work hand-in-glove with the newly
1972 # built GCC, so that we can examine its features. This is the linker
1973 # which will be driven by the driver program.
1975 # If build != host, and we aren't building gas in-tree, we identify a
1976 # build->target linker and hope that it will have the same features
1977 # as the host->target linker we'll be using.
1978 gcc_cv_gld_major_version=
1979 gcc_cv_gld_minor_version=
1980 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1981 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1983 AS_VAR_SET_IF(gcc_cv_ld,, [
1984 if test -x "$DEFAULT_LINKER"; then
1985 gcc_cv_ld="$DEFAULT_LINKER"
1986 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1987 && test -f ../ld/Makefile \
1988 && test x$build = x$host; then
1989 gcc_cv_ld=../ld/ld-new$build_exeext
1990 elif test -x collect-ld$build_exeext; then
1991 # Build using linker in the current directory.
1992 gcc_cv_ld=./collect-ld$build_exeext
1993 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
1994 gcc_cv_ld="$LD_FOR_TARGET"
1996 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1999 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2000 PLUGIN_LD=`basename $gcc_cv_ld`
2001 AC_ARG_WITH(plugin-ld,
2002 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2003 [if test x"$withval" != x; then
2004 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2005 PLUGIN_LD="$withval"
2007 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2008 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
2010 # Check to see if we are using gold instead of ld
2011 AC_MSG_CHECKING(whether we are using gold)
2013 if test x$gcc_cv_ld != x; then
2014 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2015 | grep "GNU gold" > /dev/null; then
2019 AC_MSG_RESULT($ld_is_gold)
2021 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2022 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2023 case "$ORIGINAL_LD_FOR_TARGET" in
2024 ./collect-ld | ./collect-ld$build_exeext) ;;
2025 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2028 AC_MSG_CHECKING(what linker to use)
2029 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2030 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2031 # Single tree build which includes ld. We want to prefer it
2032 # over whatever linker top-level may have detected, since
2033 # we'll use what we're building after installation anyway.
2034 AC_MSG_RESULT(newly built ld)
2036 in_tree_ld_is_elf=no
2037 if (grep 'EMUL = .*elf' ../ld/Makefile \
2038 || grep 'EMUL = .*linux' ../ld/Makefile \
2039 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2040 in_tree_ld_is_elf=yes
2041 elif test "$ld_is_gold" = yes; then
2042 in_tree_ld_is_elf=yes
2044 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
2047 gcc_cv_gld_version=`sed -n -e 's/^[ ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
2048 if test x$gcc_cv_gld_version != x; then
2052 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2053 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2056 AC_MSG_RESULT($gcc_cv_ld)
2060 # Figure out what nm we will be using.
2061 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2062 AS_VAR_SET_IF(gcc_cv_nm,, [
2063 if test -f $gcc_cv_binutils_srcdir/configure.in \
2064 && test -f ../binutils/Makefile \
2065 && test x$build = x$host; then
2066 gcc_cv_nm=../binutils/nm-new$build_exeext
2067 elif test -x nm$build_exeext; then
2068 gcc_cv_nm=./nm$build_exeext
2069 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2070 gcc_cv_nm="$NM_FOR_TARGET"
2072 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2075 AC_MSG_CHECKING(what nm to use)
2076 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2077 # Single tree build which includes binutils.
2078 AC_MSG_RESULT(newly built nm)
2081 AC_MSG_RESULT($gcc_cv_nm)
2085 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2086 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2087 case "$ORIGINAL_NM_FOR_TARGET" in
2088 ./nm | ./nm$build_exeext) ;;
2089 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2093 # Figure out what objdump we will be using.
2094 AS_VAR_SET_IF(gcc_cv_objdump,, [
2095 if test -f $gcc_cv_binutils_srcdir/configure.in \
2096 && test -f ../binutils/Makefile \
2097 && test x$build = x$host; then
2098 # Single tree build which includes binutils.
2099 gcc_cv_objdump=../binutils/objdump$build_exeext
2100 elif test -x objdump$build_exeext; then
2101 gcc_cv_objdump=./objdump$build_exeext
2102 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2103 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2105 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2108 AC_MSG_CHECKING(what objdump to use)
2109 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2110 # Single tree build which includes binutils.
2111 AC_MSG_RESULT(newly built objdump)
2112 elif test x$gcc_cv_objdump = x; then
2113 AC_MSG_RESULT(not found)
2115 AC_MSG_RESULT($gcc_cv_objdump)
2118 # Figure out what readelf we will be using.
2119 AS_VAR_SET_IF(gcc_cv_readelf,, [
2120 if test -f $gcc_cv_binutils_srcdir/configure.in \
2121 && test -f ../binutils/Makefile \
2122 && test x$build = x$host; then
2123 # Single tree build which includes binutils.
2124 gcc_cv_readelf=../binutils/readelf$build_exeext
2125 elif test -x readelf$build_exeext; then
2126 gcc_cv_readelf=./readelf$build_exeext
2128 AC_PATH_PROG(gcc_cv_readelf, readelf)
2131 AC_MSG_CHECKING(what readelf to use)
2132 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2133 # Single tree build which includes binutils.
2134 AC_MSG_RESULT(newly built readelf)
2135 elif test x$gcc_cv_readelf = x; then
2136 AC_MSG_RESULT(not found)
2138 AC_MSG_RESULT($gcc_cv_readelf)
2141 # Figure out what assembler alignment features are present.
2142 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2146 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2147 [Define if your assembler supports .balign and .p2align.])])
2149 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2152 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2153 [Define if your assembler supports specifying the maximum number
2154 of bytes to skip when using the GAS .p2align command.])])
2156 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2159 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2160 [Define if your assembler supports .literal16.])])
2162 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2164 [conftest_label1: .word 0
2166 conftest_label2: .word 0
2168 [if test x$gcc_cv_nm != x; then
2169 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2170 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2171 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2173 else gcc_cv_as_subsection_m1=yes
2175 rm -f conftest.nm1 conftest.nm2
2177 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2178 [Define if your assembler supports .subsection and .subsection -1 starts
2179 emitting at the beginning of your section.])])
2181 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2184 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2186 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2188 [ .weakref foobar, barfnot],,
2189 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2191 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2194 .NSUBSPA $CODE$,COMDAT],,
2195 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2197 # .hidden needs to be supported in both the assembler and the linker,
2198 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2199 # This is irritatingly difficult to feature test for; we have to check the
2200 # date string after the version number. If we've got an in-tree
2201 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2203 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2204 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2208 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2209 # STV_HIDDEN, so disable .hidden support if so.
2211 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2212 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2213 cat > conftest.s <<EOF
2220 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2221 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2222 grep '\.hidden default' > /dev/null; then
2225 gcc_cv_as_hidden=yes
2228 # Assume bug is present if objdump is missing.
2233 gcc_cv_as_hidden=yes
2238 # Darwin as has some visibility support, though with a different syntax.
2239 gcc_cv_as_hidden=yes
2243 # gnu_indirect_function type is an extension proposed at
2244 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2245 # selection of function implementation
2246 AC_ARG_ENABLE(gnu-indirect-function,
2247 [AS_HELP_STRING([--enable-gnu-indirect-function],
2248 [enable the use of the @gnu_indirect_function to glibc systems])],
2249 [case $enable_gnu_indirect_function in
2251 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2252 Valid choices are 'yes' and 'no'.]) ;;
2254 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2255 if test x$enable_gnu_indirect_function = xyes; then
2256 AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2257 [Define if your system supports gnu indirect functions.])
2261 if test $in_tree_ld != yes ; then
2262 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2263 if echo "$ld_ver" | grep GNU > /dev/null; then
2264 if test x"$ld_is_gold" = xyes; then
2265 # GNU gold --version looks like this:
2267 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2269 # We extract the binutils version which is more familiar and specific
2270 # than the gold version.
2271 ld_vers=`echo $ld_ver | sed -n \
2272 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2274 # GNU ld --version looks like this:
2276 # GNU ld (GNU Binutils) 2.21.51.20110225
2277 ld_vers=`echo $ld_ver | sed -n \
2278 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2280 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'`
2281 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2282 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2283 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2288 # Solaris 2 ld -V output looks like this for a regular version:
2290 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2292 # but test versions add stuff at the end:
2294 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2296 ld_ver=`$gcc_cv_ld -V 2>&1`
2297 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2298 ld_vers=`echo $ld_ver | sed -n \
2299 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2300 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2301 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2309 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2310 [[if test $in_tree_ld = yes ; then
2312 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 \
2313 && test $in_tree_ld_is_elf = yes; then
2314 gcc_cv_ld_hidden=yes
2317 gcc_cv_ld_hidden=yes
2318 if test x"$ld_is_gold" = xyes; then
2320 elif echo "$ld_ver" | grep GNU > /dev/null; then
2321 if test 0"$ld_date" -lt 20020404; then
2322 if test -n "$ld_date"; then
2323 # If there was date string, but was earlier than 2002-04-04, fail
2325 elif test -z "$ld_vers"; then
2326 # If there was no date string nor ld version number, something is wrong
2329 test -z "$ld_vers_patch" && ld_vers_patch=0
2330 if test "$ld_vers_major" -lt 2; then
2332 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2333 gcc_cv_ld_hidden="no"
2334 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2342 # Darwin ld has some visibility support.
2343 gcc_cv_ld_hidden=yes
2345 hppa64*-*-hpux* | ia64*-*-hpux*)
2346 gcc_cv_ld_hidden=yes
2349 # .hidden support was backported to Solaris 8, starting with ld
2351 if test "$ld_vers_minor" -ge 276; then
2352 gcc_cv_ld_hidden=yes
2357 *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2358 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2359 # .symbolic was only added in Solaris 9 12/02.
2360 gcc_cv_ld_hidden=yes
2368 libgcc_visibility=no
2369 AC_SUBST(libgcc_visibility)
2370 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2371 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2372 libgcc_visibility=yes
2373 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2374 [Define if your assembler and linker support .hidden.])
2377 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2378 gcc_cv_ld_ro_rw_mix=unknown
2379 if test $in_tree_ld = yes ; then
2380 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 \
2381 && test $in_tree_ld_is_elf = yes; then
2382 gcc_cv_ld_ro_rw_mix=read-write
2384 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2385 echo '.section myfoosect, "a"' > conftest1.s
2386 echo '.section myfoosect, "aw"' > conftest2.s
2387 echo '.byte 1' >> conftest2.s
2388 echo '.section myfoosect, "a"' > conftest3.s
2389 echo '.byte 0' >> conftest3.s
2390 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2391 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2392 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2393 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2394 conftest2.o conftest3.o > /dev/null 2>&1; then
2395 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2396 | sed -e '/myfoosect/!d' -e N`
2397 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2398 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2399 gcc_cv_ld_ro_rw_mix=read-only
2401 gcc_cv_ld_ro_rw_mix=read-write
2406 rm -f conftest.* conftest[123].*
2409 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2410 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2411 [Define if your linker links a mix of read-only
2412 and read-write sections into a read-write section.])
2414 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2416 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2417 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2425 [[# GAS versions before 2.11 do not support uleb128,
2426 # despite appearing to.
2427 # ??? There exists an elf-specific test that will crash
2428 # the assembler. Perhaps it's better to figure out whether
2429 # arbitrary sections are supported and try the test.
2430 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2431 if echo "$as_ver" | grep GNU > /dev/null; then
2432 as_vers=`echo $as_ver | sed -n \
2433 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2434 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2435 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2436 if test $as_major -eq 2 && test $as_minor -lt 11
2438 else gcc_cv_as_leb128=yes
2441 [AC_DEFINE(HAVE_AS_LEB128, 1,
2442 [Define if your assembler supports .sleb128 and .uleb128.])])
2444 # Check if we have assembler support for unwind directives.
2445 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2452 .cfi_escape 1, 2, 3, 4, 5
2456 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2457 # read-only and read-write sections, we need to make sure that the
2458 # assembler used emits read-write .eh_frame sections.
2459 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2460 if test "x$gcc_cv_objdump" != x; then
2461 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2462 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2463 gcc_cv_as_cfi_directive=no
2466 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2467 # On Solaris/x86, make sure that GCC and gas agree on using
2468 # read-only .eh_frame sections for 64-bit.
2469 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2470 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2471 sed -e /.eh_frame/!d -e N | \
2472 grep READONLY > /dev/null; then
2473 gcc_cv_as_cfi_directive=yes
2475 gcc_cv_as_cfi_directive=no
2479 gcc_cv_as_cfi_directive=yes
2484 # no objdump, err on the side of caution
2485 gcc_cv_as_cfi_directive=no
2488 gcc_cv_as_cfi_directive=yes
2492 gcc_cv_as_cfi_directive=yes
2495 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2496 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2500 .cfi_adjust_cfa_offset 64
2502 .cfi_adjust_cfa_offset 128
2505 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2506 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2507 gcc_cv_as_cfi_advance_working=yes
2511 # no objdump, err on the side of caution
2512 gcc_cv_as_cfi_advance_working=no
2514 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2515 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2516 [`if test $gcc_cv_as_cfi_directive = yes \
2517 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2518 [Define 0/1 if your assembler supports CFI directives.])
2520 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2521 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2522 gcc_cv_as_cfi_personality_directive, ,,
2525 .cfi_personality 0, symbol
2527 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2528 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2529 then echo 1; else echo 0; fi`],
2530 [Define 0/1 if your assembler supports .cfi_personality.])
2532 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2533 gcc_cv_as_cfi_sections_directive, ,,
2535 .cfi_sections .debug_frame, .eh_frame
2539 win32 | pe | cygwin* | mingw32* | uwin*)
2540 # Need to check that we generated the correct relocation for the
2541 # .debug_frame section. This was fixed for binutils 2.21.
2542 gcc_cv_as_cfi_sections_directive=no
2543 if test "x$gcc_cv_objdump" != x; then
2544 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2545 grep secrel > /dev/null; then
2546 gcc_cv_as_cfi_sections_directive=yes
2551 gcc_cv_as_cfi_sections_directive=yes
2554 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2555 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2556 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2557 then echo 1; else echo 0; fi`],
2558 [Define 0/1 if your assembler supports .cfi_sections.])
2560 # GAS versions up to and including 2.11.0 may mis-optimize
2562 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2570 .section .eh_frame,"aw",@progbits
2572 .4byte .LECIE1-.LSCIE1
2586 .4byte .LEFDE1-.LASFDE1
2588 .4byte .LASFDE1-__FRAME_BEGIN__
2596 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2597 cat > conftest.lit <<EOF
2598 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2599 0010 01000000 12000000 18000000 00000000 ................
2600 0020 08000000 04080000 0044 .........D @&t@
2602 cat > conftest.big <<EOF
2603 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2604 0010 00000001 00000012 00000018 00000000 ................
2605 0020 00000008 04000000 0844 .........D @&t@
2607 # If the assembler didn't choke, and we can objdump,
2608 # and we got the correct data, then succeed.
2609 # The text in the here-document typically retains its unix-style line
2610 # endings, while the output of objdump will use host line endings.
2611 # Therefore, use diff -b for the comparisons.
2612 if test x$gcc_cv_objdump != x \
2613 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2614 | tail -3 > conftest.got \
2615 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2616 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2618 gcc_cv_as_eh_frame=yes
2619 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2620 gcc_cv_as_eh_frame=buggy
2622 # Uh oh, what do we do now?
2623 gcc_cv_as_eh_frame=no
2626 if test $gcc_cv_as_eh_frame = buggy; then
2627 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2628 [Define if your assembler mis-optimizes .eh_frame data.])
2631 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2632 [elf,2,12,0], [--fatal-warnings],
2633 [.section .rodata.str, "aMS", @progbits, 1])
2634 if test $gcc_cv_as_shf_merge = no; then
2635 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2636 [elf,2,12,0], [--fatal-warnings],
2637 [.section .rodata.str, "aMS", %progbits, 1])
2639 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2640 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2641 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2643 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2644 gcc_cv_as_comdat_group,
2645 [elf,2,16,0], [--fatal-warnings],
2646 [.section .text,"axG",@progbits,.foo,comdat])
2647 if test $gcc_cv_as_comdat_group = yes; then
2648 gcc_cv_as_comdat_group_percent=no
2649 gcc_cv_as_comdat_group_group=no
2651 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2652 gcc_cv_as_comdat_group_percent,
2653 [elf,2,16,0], [--fatal-warnings],
2654 [.section .text,"axG",%progbits,.foo,comdat])
2655 if test $gcc_cv_as_comdat_group_percent = yes; then
2656 gcc_cv_as_comdat_group_group=no
2659 # Sun as uses a completely different syntax.
2664 .group foo,".text%foo",#comdat
2665 .section ".text%foo", #alloc,#execinstr,#progbits
2670 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2672 .group foo,.text%foo,#comdat
2673 .section .text%foo, "ax", @progbits
2679 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2680 gcc_cv_as_comdat_group_group,
2686 if test x"$ld_is_gold" = xyes; then
2688 elif test $in_tree_ld = yes ; then
2690 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 \
2691 && test $in_tree_ld_is_elf = yes; then
2694 elif echo "$ld_ver" | grep GNU > /dev/null; then
2696 if test 0"$ld_date" -lt 20050308; then
2697 if test -n "$ld_date"; then
2698 # If there was date string, but was earlier than 2005-03-08, fail
2700 elif test "$ld_vers_major" -lt 2; then
2702 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2709 *-*-solaris2.1[1-9]*)
2711 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2712 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2715 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2716 # least ld version 1.2267.
2717 if test "$ld_vers_major" -gt 1; then
2719 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2721 elif test "$ld_vers_minor" -ge 2267; then
2726 # Assume linkers other than GNU ld don't support COMDAT group.
2732 # Allow overriding the automatic COMDAT group tests above.
2733 AC_ARG_ENABLE(comdat,
2734 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2735 [comdat_group="$enable_comdat"])
2736 if test $comdat_group = no; then
2737 gcc_cv_as_comdat_group=no
2738 gcc_cv_as_comdat_group_percent=no
2739 gcc_cv_as_comdat_group_group=no
2741 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2742 [`if test $gcc_cv_as_comdat_group = yes \
2743 || test $gcc_cv_as_comdat_group_percent = yes \
2744 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2745 [Define 0/1 if your assembler and linker support COMDAT groups.])
2747 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2748 gcc_cv_as_discriminator,
2752 .loc 1 1 0 discriminator 1],,
2753 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2754 [Define if your assembler supports the .loc discriminator sub-directive.])])
2756 # Thread-local storage - the check is heavily parameterized.
2765 .section ".tdata","awT",@progbits
2768 ldq $27,__tls_get_addr($29) !literal!1
2769 lda $16,foo($29) !tlsgd!1
2770 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2771 ldq $27,__tls_get_addr($29) !literal!2
2772 lda $16,foo($29) !tlsldm!2
2773 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2774 ldq $1,foo($29) !gotdtprel
2775 ldah $2,foo($29) !dtprelhi
2776 lda $3,foo($2) !dtprello
2777 lda $4,foo($29) !dtprel
2778 ldq $1,foo($29) !gottprel
2779 ldah $2,foo($29) !tprelhi
2780 lda $3,foo($2) !tprello
2781 lda $4,foo($29) !tprel'
2784 tls_as_opt=--fatal-warnings
2786 cris-*-*|crisv32-*-*)
2788 .section ".tdata","awT",@progbits
2795 tls_as_opt=--fatal-warnings
2799 .section ".tdata","awT",@progbits
2811 .section ".tdata","awT",@progbits
2815 addil LT%foo-$tls_gdidx$,gp
2816 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2819 addil LT%foo-$tls_ldidx$,gp
2821 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2822 addil LR%foo-$tls_dtpoff$,%ret0
2823 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2825 addil LT%foo-$tls_ieoff$,gp
2826 ldw RT%foo-$tls_ieoff$(%r1),%t2
2829 addil LR%foo-$tls_leoff$,%t1
2830 ldo RR%foo-$tls_leoff$(%r1),%t2'
2833 tls_as_opt=--fatal-warnings
2837 .section ".tdata","awT",%progbits
2848 i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*)
2850 i[34567]86-*-solaris2.*)
2852 tga_func=___tls_get_addr
2854 x86_64-*-solaris2.1[0-9]*)
2856 tga_func=__tls_get_addr
2862 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2864 .section .tdata,"awt",@progbits'
2868 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2869 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2873 .section ".tdata","awT",@progbits'
2876 tls_as_opt="--fatal-warnings"
2878 conftest_s="$conftest_s
2882 leal foo@tlsgd(,%ebx,1), %eax
2883 leal foo@tlsldm(%ebx), %eax
2884 leal foo@dtpoff(%eax), %edx
2885 movl foo@gottpoff(%ebx), %eax
2886 subl foo@gottpoff(%ebx), %eax
2887 addl foo@gotntpoff(%ebx), %eax
2888 movl foo@indntpoff, %eax
2889 movl \$foo@tpoff, %eax
2890 subl \$foo@tpoff, %eax
2891 leal foo@ntpoff(%ecx), %eax"
2895 .section ".tdata","awT",@progbits
2899 leaq foo@TLSGD(%rip), %rdi
2900 leaq foo@TLSLD(%rip), %rdi
2901 leaq foo@DTPOFF(%rax), %rdx
2902 movq foo@GOTTPOFF(%rip), %rax
2903 movq $foo@TPOFF, %rax'
2906 tls_as_opt=--fatal-warnings
2910 .section ".tdata","awT",@progbits
2913 addl r16 = @ltoff(@dtpmod(foo#)), gp
2914 addl r17 = @ltoff(@dtprel(foo#)), gp
2915 addl r18 = @ltoff(@tprel(foo#)), gp
2916 addl r19 = @dtprel(foo#), gp
2917 adds r21 = @dtprel(foo#), r13
2918 movl r23 = @dtprel(foo#)
2919 addl r20 = @tprel(foo#), gp
2920 adds r22 = @tprel(foo#), r13
2921 movl r24 = @tprel(foo#)'
2924 tls_as_opt=--fatal-warnings
2928 .section .tdata,"awT",@progbits
2932 addiu $4, $28, %tlsgd(x)
2933 addiu $4, $28, %tlsldm(x)
2934 lui $4, %dtprel_hi(x)
2935 addiu $4, $4, %dtprel_lo(x)
2936 lw $4, %gottprel(x)($28)
2937 lui $4, %tprel_hi(x)
2938 addiu $4, $4, %tprel_lo(x)'
2941 tls_as_opt='-32 --fatal-warnings'
2945 .section .tdata,"awT",@progbits
2950 move.l x@TLSGD(%a5),%a0
2951 move.l x@TLSLDM(%a5),%a0
2952 move.l x@TLSLDO(%a5),%a0
2953 move.l x@TLSIE(%a5),%a0
2954 move.l x@TLSLE(%a5),%a0'
2957 tls_as_opt='--fatal-warnings'
2961 .section ".tdata","awT",@progbits
2969 addi 3,31,ld0@got@tlsgd
2971 addi 3,31,x1@got@tlsld
2974 addis 9,3,x2@dtprel@ha
2975 addi 9,9,x2@dtprel@l
2976 lwz 9,x3@got@tprel(31)
2979 addis 9,2,x2@tprel@ha
2980 addi 9,9,x2@tprel@l'
2983 tls_as_opt="-a32 --fatal-warnings"
2987 .section ".tdata","awT",@progbits
2995 addi 3,2,ld0@got@tlsgd
3001 addi 3,2,x1@got@tlsld
3007 addis 9,3,x2@dtprel@ha
3008 addi 9,9,x2@dtprel@l
3011 ld 9,x3@got@dtprel(2)
3017 tls_as_opt="-a64 --fatal-warnings"
3021 .section ".tdata","awT",@progbits
3030 l %r1,foo@GOTNTPOFF(%r12)
3031 l %r1,0(%r1):tls_load:foo
3032 bas %r14,0(%r1,%r13):tls_gdcall:foo
3033 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3036 tls_as_opt="-m31 --fatal-warnings"
3040 .section ".tdata","awT",@progbits
3048 lg %r1,foo@GOTNTPOFF(%r12)
3049 larl %r1,foo@INDNTPOFF
3050 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3051 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3054 tls_as_opt="-m64 -Aesame --fatal-warnings"
3056 sh-*-* | sh[34]-*-*)
3058 .section ".tdata","awT",@progbits
3068 tls_as_opt=--fatal-warnings
3072 sparc*-sun-solaris2.*)
3074 tga_func=__tls_get_addr
3080 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3082 .section ".tdata",#alloc,#write,#tls'
3087 .section ".tdata","awT",@progbits'
3090 tls_as_opt="-32 --fatal-warnings"
3092 conftest_s="$conftest_s
3095 sethi %tgd_hi22(foo), %o0
3096 add %o0, %tgd_lo10(foo), %o1
3097 add %l7, %o1, %o0, %tgd_add(foo)
3098 call __tls_get_addr, %tgd_call(foo)
3099 sethi %tldm_hi22(foo), %l1
3100 add %l1, %tldm_lo10(foo), %l2
3101 add %l7, %l2, %o0, %tldm_add(foo)
3102 call __tls_get_addr, %tldm_call(foo)
3103 sethi %tldo_hix22(foo), %l3
3104 xor %l3, %tldo_lox10(foo), %l4
3105 add %o0, %l4, %l5, %tldo_add(foo)
3106 sethi %tie_hi22(foo), %o3
3107 add %o3, %tie_lo10(foo), %o3
3108 ld [%l7 + %o3], %o2, %tie_ld(foo)
3109 add %g7, %o2, %o4, %tie_add(foo)
3110 sethi %tle_hix22(foo), %l1
3111 xor %l1, %tle_lox10(foo), %o5
3112 ld [%g7 + %o5], %o1"
3116 .section ".tdata","awT",@progbits
3119 movi a8, foo@TLSFUNC
3120 movi a10, foo@TLSARG
3121 callx8.tls a8, foo@TLSCALL'
3128 if test "x$enable_tls" = xno ; then
3129 : # TLS explicitly disabled.
3130 elif test "x$enable_tls" = xyes ; then
3131 set_have_as_tls=yes # TLS explicitly enabled.
3132 elif test -z "$tls_first_major"; then
3133 : # If we don't have a check, assume no support.
3135 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3136 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3137 [set_have_as_tls=yes])
3141 # IRIX 6.5 rld and libc.so lack TLS support, so even if gas and gld
3142 # with TLS support are in use, native TLS cannot work.
3146 # Tru64 UNIX loader and libc.so lack TLS support, so even if gas and
3147 # gld with TLS support are in use, native TLS cannot work.
3150 # TLS was introduced in the Solaris 9 FCS release and backported to
3151 # Solaris 8 patches. Support for GNU-style TLS on x86 was only
3152 # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
3153 # ld and GCC don't support any longer.
3155 AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3157 # Check ld and ld.so.1 TLS support.
3158 if echo "$ld_ver" | grep GNU > /dev/null; then
3159 # Assume all interesting versions of GNU ld have TLS support.
3160 # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3164 # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
3166 min_tls_ld_vers_minor=280
3168 # Solaris 8/SPARC ld has TLS support since version 1.272.
3169 sparc*-*-solaris2.8)
3170 min_tls_ld_vers_minor=272
3172 # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3174 min_tls_ld_vers_minor=374
3176 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3177 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3178 min_tls_ld_vers_minor=343
3181 if test "$ld_vers_major" -gt 1 || \
3182 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3188 AC_MSG_RESULT($ld_tls_support)
3191 save_LDFLAGS="$LDFLAGS"
3195 AC_MSG_CHECKING(alternate thread library)
3197 # TLS support was backported to Solaris 8 patches, but only lives in
3198 # the alternate thread library which became the default in Solaris 9.
3199 # We want to always use that, irrespective of TLS support.
3201 # Take multilib subdir into account. There's no spec to handle
3202 # this. The 64 symlink exists since Solaris 8.
3203 lwp_dir=/usr/lib/lwp
3204 lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3205 LDFLAGS="-L$lwp_dir -R$lwp_dir"
3212 # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3213 AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3214 [Define to the linker flags to use for -pthread.])
3215 AC_MSG_RESULT($lwp_dir)
3217 AC_MSG_CHECKING(library containing $tga_func)
3218 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3219 # (32-bit x86) only lived in libthread, so check for that. Keep
3220 # set_have_as_tls if found, disable if not.
3221 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3222 # Clear LIBS if we cannot support TLS.
3223 if test $set_have_as_tls = no; then
3226 # Always define LIB_TLS_SPEC, even without TLS support.
3227 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3228 [Define to the library containing __tls_get_addr/___tls_get_addr.])
3229 AC_MSG_RESULT($LIBS)
3232 LDFLAGS="$save_LDFLAGS"
3235 if test $set_have_as_tls = yes ; then
3236 AC_DEFINE(HAVE_AS_TLS, 1,
3237 [Define if your assembler and linker support thread-local storage.])
3240 # Target-specific assembler checks.
3242 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3243 gcc_cv_ld_static_dynamic=no
3244 gcc_cv_ld_static_option='-Bstatic'
3245 gcc_cv_ld_dynamic_option='-Bdynamic'
3246 if test $in_tree_ld = yes ; then
3247 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
3248 gcc_cv_ld_static_dynamic=yes
3250 elif test x$gcc_cv_ld != x; then
3251 # Check if linker supports -Bstatic/-Bdynamic option
3252 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3253 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3254 gcc_cv_ld_static_dynamic=yes
3257 # Tru64 UNIX support -noso/-so_archive instead of -Bstatic/-Bdynamic.
3259 gcc_cv_ld_static_dynamic=yes
3260 gcc_cv_ld_static_option="-noso"
3261 gcc_cv_ld_dynamic_option="-so_archive"
3263 # HP-UX ld uses -a flags to select between shared and archive.
3265 if test x"$gnu_ld" = xno; then
3266 gcc_cv_ld_static_dynamic=yes
3267 gcc_cv_ld_static_option="-aarchive_shared"
3268 gcc_cv_ld_dynamic_option="-adefault"
3271 # IRIX 6 ld supports -Bstatic/-Bdynamic.
3273 gcc_cv_ld_static_dynamic=yes
3275 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3277 gcc_cv_ld_static_dynamic=yes
3282 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3283 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3284 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3285 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3286 [Define to the linker option to disable use of shared objects.])
3287 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3288 [Define to the linker option to enable use of shared objects.])
3290 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3292 if test x"$demangler_in_ld" = xyes; then
3293 AC_MSG_CHECKING(linker --demangle support)
3294 gcc_cv_ld_demangle=no
3295 if test $in_tree_ld = yes; then
3296 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 \
3297 gcc_cv_ld_demangle=yes
3299 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3300 # Check if the GNU linker supports --demangle option
3301 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3302 gcc_cv_ld_demangle=yes
3305 if test x"$gcc_cv_ld_demangle" = xyes; then
3306 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3307 [Define if your linker supports --demangle option.])
3309 AC_MSG_RESULT($gcc_cv_ld_demangle)
3312 AC_MSG_CHECKING(linker plugin support)
3314 if test -f liblto_plugin.la; then
3315 save_ld_ver="$ld_ver"
3316 save_ld_vers_major="$ld_vers_major"
3317 save_ld_vers_minor="$ld_vers_minor"
3318 save_ld_is_gold="$ld_is_gold"
3322 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3324 # FIXME: ld_is_gold?
3325 ld_vers_major="$gcc_cv_gld_major_version"
3326 ld_vers_minor="$gcc_cv_gld_minor_version"
3328 # Determine plugin linker version.
3329 # FIXME: Partial duplicate from above, generalize.
3331 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3332 if echo "$ld_ver" | grep GNU > /dev/null; then
3333 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3335 ld_vers=`echo $ld_ver | sed -n \
3336 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3338 ld_vers=`echo $ld_ver | sed -n \
3339 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3341 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3342 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3347 # Determine plugin support.
3348 if echo "$ld_ver" | grep GNU > /dev/null; then
3349 # Require GNU ld or gold 2.21+ for plugin support by default.
3350 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3352 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3353 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3358 ld_ver="$save_ld_ver"
3359 ld_vers_major="$save_ld_vers_major"
3360 ld_vers_minor="$save_ld_vers_minor"
3361 ld_is_gold="$save_ld_is_gold"
3363 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3364 [Define to the level of your linker's plugin support.])
3365 AC_MSG_RESULT($gcc_cv_lto_plugin)
3368 # All TARGET_ABI_OSF targets.
3369 alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3370 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3371 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3374 extbl $3, $2, $3 !lituse_bytoff!1
3375 ldq $2, a($29) !literal!1
3376 ldq $4, b($29) !literal!2
3377 ldq_u $3, 0($2) !lituse_base!1
3378 ldq $27, f($29) !literal!5
3379 jsr $26, ($27), f !lituse_jsr!5
3380 ldah $29, 0($26) !gpdisp!3
3381 lda $0, c($29) !gprel
3382 ldah $1, d($29) !gprelhigh
3383 lda $1, d($1) !gprellow
3384 lda $29, 0($29) !gpdisp!3],,
3385 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3386 [Define if your assembler supports explicit relocations.])])
3387 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3388 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3391 ldq $27, a($29) !literal!1
3392 jsr $26, ($27), a !lituse_jsrdirect!1],,
3393 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3394 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3398 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3399 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3400 [-no-mul-bug-abort], [.text],,
3401 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3402 [Define if your assembler supports the -no-mul-bug-abort option.])])
3406 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3407 [.register %g2, #scratch],,
3408 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3409 [Define if your assembler supports .register.])])
3411 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3413 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3414 [Define if your assembler supports -relax option.])])
3416 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3417 gcc_cv_as_sparc_gotdata_op,,
3424 sethi %gdop_hix22(foo), %g1
3425 xor %g1, %gdop_lox10(foo), %g1
3426 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3427 [if test x$gcc_cv_ld != x \
3428 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3429 if test x$gcc_cv_objdump != x; then
3430 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3431 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3432 gcc_cv_as_sparc_gotdata_op=no
3434 gcc_cv_as_sparc_gotdata_op=yes
3439 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3440 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3442 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3443 gcc_cv_as_sparc_ua_pcrel,,
3451 .uaword %r_disp32(foo)],
3452 [if test x$gcc_cv_ld != x \
3453 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3454 gcc_cv_as_sparc_ua_pcrel=yes
3457 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3458 [Define if your assembler and linker support unaligned PC relative relocs.])
3460 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3461 gcc_cv_as_sparc_ua_pcrel_hidden,,
3466 .uaword %r_disp32(foo)
3467 .byte 0x32, 0x33, 0x34
3472 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3473 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3474 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3475 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3476 if $gcc_cv_objdump -R conftest 2> /dev/null \
3477 | grep 'DISP32' > /dev/null 2>&1; then
3480 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3484 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3485 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3486 ]) # unaligned pcrel relocs
3488 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3489 gcc_cv_as_sparc_offsetable_lo10,,
3492 or %g1, %lo(ab) + 12, %g1
3493 or %g1, %lo(ab + 12), %g1],
3494 [if test x$gcc_cv_objdump != x \
3495 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3496 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3497 gcc_cv_as_sparc_offsetable_lo10=yes
3499 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3500 [Define if your assembler supports offsetable %lo().])])
3502 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3503 gcc_cv_as_sparc_fmaf,,
3506 .register %g2, #scratch
3507 .register %g3, #scratch
3509 fmaddd %f0, %f2, %f4, %f6
3510 addxccc %g1, %g2, %g3
3511 fsrl32 %f2, %f4, %f8
3512 fnaddd %f10, %f12, %f14],,
3513 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3514 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3518 i[34567]86-*-* | x86_64-*-*)
3522 # Full C++ conformance when using a shared libstdc++-v3 requires some
3523 # support from the Cygwin DLL, which in more recent versions exports
3524 # wrappers to aid in interposing and redirecting operators new, delete,
3525 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3526 # are configuring for a version of Cygwin that exports the wrappers.
3527 if test x$host = x$target; then
3528 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3530 # Can't check presence of libc functions during cross-compile, so
3531 # we just have to assume we're building for an up-to-date target.
3532 gcc_ac_cygwin_dll_wrappers=yes
3534 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3535 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3536 [Define if you want to generate code by default that assumes that the
3537 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3540 cygwin* | pe | mingw32*)
3541 # Recent binutils allows the three-operand form of ".comm" on PE. This
3542 # definition is used unconditionally to initialise the default state of
3543 # the target option variable that governs usage of the feature.
3544 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3545 [2,19,52],,[.comm foo,1,32])
3546 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3547 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3548 [Define if your assembler supports specifying the alignment
3549 of objects allocated using the GAS .comm command.])
3550 # Used for DWARF 2 in PE
3551 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3552 gcc_cv_as_ix86_pe_secrel32,
3558 [if test x$gcc_cv_ld != x \
3559 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3560 gcc_cv_as_ix86_pe_secrel32=yes
3563 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3564 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3565 # Test if the assembler supports the extended form of the .section
3566 # directive that specifies section alignment. LTO support uses this,
3567 # but normally only after installation, so we warn but don't fail the
3568 # configure if LTO is enabled but the assembler does not support it.
3569 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3570 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3571 if test x$gcc_cv_as_section_has_align != xyes; then
3572 case ",$enable_languages," in
3574 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3578 # Test if the assembler supports the section flag 'e' for specifying
3579 # an excluded section.
3580 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3584 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3585 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3586 [Define if your assembler supports specifying the section flag e.])
3590 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3591 gcc_cv_as_ix86_filds,,,
3592 [filds mem; fists mem],,
3593 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3594 [Define if your assembler uses filds and fists mnemonics.])])
3596 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3597 gcc_cv_as_ix86_fildq,,,
3598 [fildq mem; fistpq mem],,
3599 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3600 [Define if your assembler uses fildq and fistq mnemonics.])])
3602 gcc_GAS_CHECK_FEATURE([cmov syntax],
3603 gcc_cv_as_ix86_cmov_sun_syntax,,,
3604 [cmovl.l %edx, %eax],,
3605 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3606 [Define if your assembler supports the Sun syntax for cmov.])])
3608 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3609 gcc_cv_as_ix86_ffreep,,,
3611 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3612 [Define if your assembler supports the ffreep mnemonic.])])
3614 gcc_GAS_CHECK_FEATURE([.quad directive],
3615 gcc_cv_as_ix86_quad,,,
3617 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3618 [Define if your assembler supports the .quad directive.])])
3620 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3621 gcc_cv_as_ix86_sahf,,,
3624 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3625 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3627 gcc_GAS_CHECK_FEATURE([swap suffix],
3628 gcc_cv_as_ix86_swap,,,
3629 [movl.s %esp, %ebp],,
3630 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3631 [Define if your assembler supports the swap suffix.])])
3633 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3634 gcc_cv_as_ix86_diff_sect_delta,,,
3642 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3643 [Define if your assembler supports the subtraction of symbols in different sections.])])
3645 # These two are used unconditionally by i386.[ch]; it is to be defined
3646 # to 1 if the feature is present, 0 otherwise.
3647 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3648 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3654 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3655 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3656 [Define true if the assembler supports '.long foo@GOTOFF'.])
3658 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3659 gcc_cv_as_ix86_rep_lock_prefix,,,
3661 lock addl %edi, (%eax,%esi)
3662 lock orl $0, (%esp)],,
3663 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3664 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3666 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3667 gcc_cv_as_ix86_tlsgdplt,,,
3668 [call tls_gd@tlsgdplt],,
3669 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3670 [Define if your assembler supports @tlsgdplt.])])
3672 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3673 gcc_cv_as_ix86_tlsldmplt,,,
3674 [call tls_ld@tlsldmplt],,
3675 [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1,
3676 [Define if your assembler supports @tlsldmplt.])])
3681 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3682 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3684 addl r15 = @ltoffx(x#), gp
3686 ld8.mov r16 = [[r15]], x#],,
3687 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3688 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3694 *-*-aix*) conftest_s=' .machine "pwr5"
3698 gcc_GAS_CHECK_FEATURE([.machine directive support],
3699 gcc_cv_as_machine_directive,,,
3700 [ .machine ppc7400])
3701 if test x$gcc_cv_as_machine_directive != xyes; then
3702 echo "*** This target requires an assembler supporting \".machine\"" >&2
3703 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3704 test x$build = x$target && exit 1
3708 *) conftest_s=' .machine power4
3713 gcc_GAS_CHECK_FEATURE([mfcr field support],
3714 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3716 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3717 [Define if your assembler supports mfcr field.])])
3720 *-*-aix*) conftest_s=' .machine "pwr5"
3723 *) conftest_s=' .machine power5
3728 gcc_GAS_CHECK_FEATURE([popcntb support],
3729 gcc_cv_as_powerpc_popcntb, [2,17,0],,
3731 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3732 [Define if your assembler supports popcntb field.])])
3735 *-*-aix*) conftest_s=' .machine "pwr5x"
3738 *) conftest_s=' .machine power5
3743 gcc_GAS_CHECK_FEATURE([fp round support],
3744 gcc_cv_as_powerpc_fprnd, [2,17,0],,
3746 [AC_DEFINE(HAVE_AS_FPRND, 1,
3747 [Define if your assembler supports fprnd.])])
3750 *-*-aix*) conftest_s=' .machine "pwr6"
3753 *) conftest_s=' .machine power6
3758 gcc_GAS_CHECK_FEATURE([move fp gpr support],
3759 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3761 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3762 [Define if your assembler supports mffgpr and mftgpr.])])
3765 *-*-aix*) conftest_s=' .csect .text[[PR]]
3767 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3771 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3772 *) conftest_s=' .text
3774 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3777 gcc_GAS_CHECK_FEATURE([rel16 relocs],
3778 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3780 [AC_DEFINE(HAVE_AS_REL16, 1,
3781 [Define if your assembler supports R_PPC_REL16 relocs.])])
3784 *-*-aix*) conftest_s=' .machine "pwr6"
3787 *) conftest_s=' .machine power6
3792 gcc_GAS_CHECK_FEATURE([compare bytes support],
3793 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3795 [AC_DEFINE(HAVE_AS_CMPB, 1,
3796 [Define if your assembler supports cmpb.])])
3799 *-*-aix*) conftest_s=' .machine "pwr6"
3802 *) conftest_s=' .machine power6
3807 gcc_GAS_CHECK_FEATURE([decimal float support],
3808 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3810 [AC_DEFINE(HAVE_AS_DFP, 1,
3811 [Define if your assembler supports DFP instructions.])])
3814 *-*-aix*) conftest_s=' .machine "pwr7"
3817 *) conftest_s=' .machine power7
3822 gcc_GAS_CHECK_FEATURE([vector-scalar support],
3823 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3825 [AC_DEFINE(HAVE_AS_VSX, 1,
3826 [Define if your assembler supports VSX instructions.])])
3829 *-*-aix*) conftest_s=' .machine "pwr7"
3832 *) conftest_s=' .machine power7
3837 gcc_GAS_CHECK_FEATURE([popcntd support],
3838 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3840 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3841 [Define if your assembler supports POPCNTD instructions.])])
3844 *-*-aix*) conftest_s=' .csect .text[[PR]]
3846 *) conftest_s=' .text
3850 gcc_GAS_CHECK_FEATURE([lwsync support],
3851 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3853 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3854 [Define if your assembler supports LWSYNC instructions.])])
3857 *-*-aix*) conftest_s=' .machine "476"
3860 *) conftest_s=' .machine "476"
3865 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3866 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3868 [AC_DEFINE(HAVE_AS_DCI, 1,
3869 [Define if your assembler supports the DCI/ICI instructions.])])
3871 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3872 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3873 [.gnu_attribute 4,1],,
3874 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3875 [Define if your assembler supports .gnu_attribute.])])
3877 gcc_GAS_CHECK_FEATURE([tls marker support],
3878 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3879 [ bl __tls_get_addr(x@tlsgd)],,
3880 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3881 [Define if your assembler supports arg info for __tls_get_addr.])])
3885 gcc_GAS_CHECK_FEATURE([.ref support],
3886 gcc_cv_as_aix_ref, [2.21.0],,
3887 [ .csect stuff[[rw]]
3893 [AC_DEFINE(HAVE_AS_REF, 1,
3894 [Define if your assembler supports .ref])])
3900 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3901 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3902 [ lw $4,%gp_rel(foo)($4)],,
3903 [if test x$target_cpu_default = x
3904 then target_cpu_default=MASK_EXPLICIT_RELOCS
3905 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3907 gcc_GAS_CHECK_FEATURE([-mno-shared support],
3908 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3909 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3910 [Define if the assembler understands -mno-shared.])])
3912 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3913 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3914 [.gnu_attribute 4,1],,
3915 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3916 [Define if your assembler supports .gnu_attribute.])])
3918 gcc_GAS_CHECK_FEATURE([.dtprelword support],
3919 gcc_cv_as_mips_dtprelword, [2,18,0],,
3920 [.section .tdata,"awT",@progbits
3924 .dtprelword x+0x8000],,
3925 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3926 [Define if your assembler supports .dtprelword.])])
3928 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3929 gcc_cv_as_mips_dspr1_mult,,,
3939 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3940 [Define if your assembler supports DSPR1 mult.])])
3942 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3943 gcc_cv_as_ld_jalr_reloc=no
3944 if test $gcc_cv_as_mips_explicit_relocs = yes; then
3945 if test $in_tree_ld = yes ; then
3946 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 \
3947 && test $in_tree_ld_is_elf = yes; then
3948 gcc_cv_as_ld_jalr_reloc=yes
3950 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3951 echo ' .ent x' > conftest.s
3952 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s
3953 echo ' ld $25,%call16(y)($28)' >> conftest.s
3954 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
3955 echo '1: jalr $25' >> conftest.s
3956 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
3957 echo '1: jalr $25' >> conftest.s
3958 echo ' .end x' >> conftest.s
3959 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3960 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3961 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3962 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3963 gcc_cv_as_ld_jalr_reloc=yes
3969 if test $gcc_cv_as_ld_jalr_reloc = yes; then
3970 if test x$target_cpu_default = x; then
3971 target_cpu_default=MASK_RELAX_PIC_CALLS
3973 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3976 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3978 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3979 [gcc_cv_ld_mips_personality_relaxation],
3980 [gcc_cv_ld_mips_personality_relaxation=no
3981 if test $in_tree_ld = yes ; then
3982 if test "$gcc_cv_gld_major_version" -eq 2 \
3983 -a "$gcc_cv_gld_minor_version" -ge 21 \
3984 -o "$gcc_cv_gld_major_version" -gt 2; then
3985 gcc_cv_ld_mips_personality_relaxation=yes
3987 elif test x$gcc_cv_as != x \
3988 -a x$gcc_cv_ld != x \
3989 -a x$gcc_cv_readelf != x ; then
3990 cat > conftest.s <<EOF
3992 .cfi_personality 0x80,indirect_ptr
3999 .section .data,"aw",@progbits
4003 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4004 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4005 if $gcc_cv_readelf -d conftest 2>&1 \
4006 | grep TEXTREL > /dev/null 2>&1; then
4008 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4009 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4012 gcc_cv_ld_mips_personality_relaxation=yes
4016 rm -f conftest.s conftest.o conftest])
4017 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4018 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4019 [Define if your linker can relax absolute .eh_frame personality
4020 pointers into PC-relative form.])
4025 # Mips and HP-UX need the GNU assembler.
4026 # Linux on IA64 might be able to use the Intel assembler.
4029 mips*-*-* | *-*-hpux* )
4030 if test x$gas_flag = xyes \
4031 || test x"$host" != x"$build" \
4032 || test ! -x "$gcc_cv_as" \
4033 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4036 echo "*** This configuration requires the GNU assembler" >&2
4042 # ??? Not all targets support dwarf2 debug_line, even within a version
4043 # of gas. Moreover, we need to emit a valid instruction to trigger any
4044 # info to the output file. So, as supported targets are added to gas 2.11,
4045 # add some instruction here to (also) show we expect this might work.
4046 # ??? Once 2.11 is released, probably need to add first known working
4047 # version to the per-target configury.
4049 alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
4050 | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
4060 if test x"$insn" != x; then
4062 .file 1 \"conftest.s\"
4065 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4066 gcc_cv_as_dwarf2_debug_line,
4067 [elf,2,11,0],, [$conftest_s],
4068 [if test x$gcc_cv_objdump != x \
4069 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4070 | grep debug_line > /dev/null 2>&1; then
4071 gcc_cv_as_dwarf2_debug_line=yes
4074 # The .debug_line file table must be in the exact order that
4075 # we specified the files, since these indices are also used
4076 # by DW_AT_decl_file. Approximate this test by testing if
4077 # the assembler bitches if the same index is assigned twice.
4078 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4079 gcc_cv_as_dwarf2_file_buggy,,,
4083 if test $gcc_cv_as_dwarf2_debug_line = yes \
4084 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4085 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4086 [Define if your assembler supports dwarf2 .file/.loc directives,
4087 and preserves file table indices exactly as given.])
4090 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4091 gcc_cv_as_gdwarf2_flag,
4092 [elf,2,11,0], [--gdwarf2], [$insn],,
4093 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4094 [Define if your assembler supports the --gdwarf2 option.])])
4096 gcc_GAS_CHECK_FEATURE([--gstabs option],
4097 gcc_cv_as_gstabs_flag,
4098 [elf,2,11,0], [--gstabs], [$insn],
4099 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4100 # and warns about it, but still exits successfully. So check for
4102 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4104 else gcc_cv_as_gstabs_flag=yes
4106 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4107 [Define if your assembler supports the --gstabs option.])])
4109 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4110 gcc_cv_as_debug_prefix_map_flag,
4111 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4112 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4113 [Define if your assembler supports the --debug-prefix-map option.])])
4116 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4119 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4120 [Define if your assembler supports .lcomm with an alignment field.])])
4122 AC_ARG_ENABLE(gnu-unique-object,
4123 [AS_HELP_STRING([--enable-gnu-unique-object],
4124 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4125 [case $enable_gnu_unique_object in
4127 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4128 Valid choices are 'yes' and 'no'.]) ;;
4130 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4132 [.type foo, @gnu_unique_object],,
4133 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4134 [[if test x$host = x$build -a x$host = x$target &&
4135 ldd --version 2>/dev/null &&
4136 glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4137 glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4138 glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4139 glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4140 if test "$glibcnum" -ge 2011 ; then
4141 enable_gnu_unique_object=yes
4144 if test x$enable_gnu_unique_object = xyes; then
4145 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4146 [Define if your assembler supports @gnu_unique_object.])
4149 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4150 [gcc_cv_as_line_zero],
4151 [gcc_cv_as_line_zero=no
4152 if test $in_tree_gas = yes; then
4153 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4154 elif test "x$gcc_cv_as" != x; then
4155 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4156 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4157 test "x`cat conftest.out`" = x
4159 gcc_cv_as_line_zero=yes
4161 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4162 cat conftest.s >&AS_MESSAGE_LOG_FD
4163 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4164 cat conftest.out >&AS_MESSAGE_LOG_FD
4166 rm -f conftest.o conftest.s conftest.out
4168 if test "x$gcc_cv_as_line_zero" = xyes; then
4169 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4170 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4173 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4174 gcc_cv_ld_eh_frame_hdr=no
4175 if test $in_tree_ld = yes ; then
4176 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 \
4177 && test $in_tree_ld_is_elf = yes; then
4178 gcc_cv_ld_eh_frame_hdr=yes
4180 elif test x$gcc_cv_ld != x; then
4181 if echo "$ld_ver" | grep GNU > /dev/null; then
4182 # Check if linker supports --eh-frame-hdr option
4183 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4184 gcc_cv_ld_eh_frame_hdr=yes
4189 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4190 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4191 gcc_cv_ld_eh_frame_hdr=yes
4197 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4198 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4199 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4200 [Define if your linker supports .eh_frame_hdr.])
4202 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4204 AC_MSG_CHECKING(linker position independent executable support)
4206 if test $in_tree_ld = yes ; then
4207 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 \
4208 && test $in_tree_ld_is_elf = yes; then
4211 elif test x$gcc_cv_ld != x; then
4212 # Check if linker supports -pie option
4213 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4217 if test x"$gcc_cv_ld_pie" = xyes; then
4218 AC_DEFINE(HAVE_LD_PIE, 1,
4219 [Define if your linker supports -pie option.])
4221 AC_MSG_RESULT($gcc_cv_ld_pie)
4223 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4224 gcc_cv_ld_eh_gc_sections=no
4225 if test $in_tree_ld = yes ; then
4226 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 \
4227 && test $in_tree_ld_is_elf = yes; then
4228 gcc_cv_ld_eh_gc_sections=yes
4230 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4231 cat > conftest.s <<EOF
4234 .type _start, @function
4237 .size _start, .-_start
4238 .section .text.foo,"ax",@progbits
4239 .type foo, @function
4243 .section .gcc_except_table.foo,"a",@progbits
4246 .section .eh_frame,"a",@progbits
4249 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4250 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4251 | grep "gc-sections option ignored" > /dev/null; then
4252 gcc_cv_ld_eh_gc_sections=no
4253 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4254 | grep gcc_except_table > /dev/null; then
4255 gcc_cv_ld_eh_gc_sections=yes
4256 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4257 if test x$gcc_cv_as_comdat_group != xyes; then
4258 gcc_cv_ld_eh_gc_sections=no
4259 cat > conftest.s <<EOF
4262 .type _start, @function
4265 .size _start, .-_start
4266 .section .gnu.linkonce.t.foo,"ax",@progbits
4267 .type foo, @function
4271 .section .gcc_except_table.foo,"a",@progbits
4274 .section .eh_frame,"a",@progbits
4277 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4278 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4279 | grep "gc-sections option ignored" > /dev/null; then
4280 gcc_cv_ld_eh_gc_sections=no
4281 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4282 | grep gcc_except_table > /dev/null; then
4283 gcc_cv_ld_eh_gc_sections=yes
4289 rm -f conftest.s conftest.o conftest
4293 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4294 gcc_cv_ld_eh_gc_sections=no
4297 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4298 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4299 [Define if your linker supports garbage collection of
4300 sections in presence of EH frames.])
4302 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4304 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4305 gcc_cv_ld_eh_gc_sections_bug=no
4306 if test $in_tree_ld = yes ; then
4307 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 \
4308 && test $in_tree_ld_is_elf = yes; then
4309 gcc_cv_ld_eh_gc_sections_bug=yes
4311 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
4312 gcc_cv_ld_eh_gc_sections_bug=yes
4313 cat > conftest.s <<EOF
4316 .type _start, @function
4319 .size _start, .-_start
4320 .section .text.startup.foo,"ax",@progbits
4321 .type foo, @function
4325 .section .gcc_except_table.foo,"a",@progbits
4328 .section .eh_frame,"a",@progbits
4331 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4332 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4333 | grep "gc-sections option ignored" > /dev/null; then
4335 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4336 | grep gcc_except_table > /dev/null; then
4337 gcc_cv_ld_eh_gc_sections_bug=no
4340 rm -f conftest.s conftest.o conftest
4342 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4343 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4344 [Define if your linker has buggy garbage collection of
4345 sections support when .text.startup.foo like sections are used.])
4347 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4353 AC_CACHE_CHECK(linker --as-needed support,
4354 gcc_cv_ld_as_needed,
4355 [gcc_cv_ld_as_needed=no
4356 if test $in_tree_ld = yes ; then
4357 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
4358 && test $in_tree_ld_is_elf = yes; then
4359 gcc_cv_ld_as_needed=yes
4361 elif test x$gcc_cv_ld != x; then
4362 # Check if linker supports --as-needed and --no-as-needed options
4363 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4364 gcc_cv_ld_as_needed=yes
4368 if test x"$gcc_cv_ld_as_needed" = xyes; then
4369 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4370 [Define if your linker supports --as-needed and --no-as-needed options.])
4373 case "$target:$tm_file" in
4374 powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4375 AC_CACHE_CHECK(linker support for omitting dot symbols,
4376 gcc_cv_ld_no_dot_syms,
4377 [gcc_cv_ld_no_dot_syms=no
4378 if test $in_tree_ld = yes ; then
4379 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
4380 gcc_cv_ld_no_dot_syms=yes
4382 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4383 cat > conftest1.s <<EOF
4387 cat > conftest2.s <<EOF
4388 .section ".opd","aw"
4393 .quad .LEfoo,.TOC.@tocbase,0
4399 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4400 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4401 && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4402 gcc_cv_ld_no_dot_syms=yes
4404 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4407 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4408 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4409 [Define if your PowerPC64 linker only needs function descriptor syms.])
4412 AC_CACHE_CHECK(linker large toc support,
4413 gcc_cv_ld_large_toc,
4414 [gcc_cv_ld_large_toc=no
4415 if test $in_tree_ld = yes ; then
4416 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
4417 gcc_cv_ld_large_toc=yes
4419 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4420 cat > conftest.s <<EOF
4421 .section ".tbss","awT",@nobits
4427 addis 9,13,ie0@got@tprel@ha
4428 ld 9,ie0@got@tprel@l(9)
4430 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4431 && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4432 gcc_cv_ld_large_toc=yes
4434 rm -f conftest conftest.o conftest.s
4437 if test x"$gcc_cv_ld_large_toc" = xyes; then
4438 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4439 [Define if your PowerPC64 linker supports a large TOC.])
4444 AC_CACHE_CHECK(linker --build-id support,
4446 [gcc_cv_ld_buildid=no
4447 if test $in_tree_ld = yes ; then
4448 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4449 "$gcc_cv_gld_minor_version" -ge 18 -o \
4450 "$gcc_cv_gld_major_version" -gt 2 \
4451 && test $in_tree_ld_is_elf = yes; then
4452 gcc_cv_ld_buildid=yes
4454 elif test x$gcc_cv_ld != x; then
4455 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4456 gcc_cv_ld_buildid=yes
4459 if test x"$gcc_cv_ld_buildid" = xyes; then
4460 AC_DEFINE(HAVE_LD_BUILDID, 1,
4461 [Define if your linker supports --build-id.])
4464 AC_ARG_ENABLE(linker-build-id,
4465 [AS_HELP_STRING([--enable-linker-build-id],
4466 [compiler will always pass --build-id to linker])],
4468 enable_linker_build_id=no)
4470 if test x"$enable_linker_build_id" = xyes; then
4471 if test x"$gcc_cv_ld_buildid" = xyes; then
4472 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4473 [Define if gcc should always pass --build-id to linker.])
4475 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4479 # In binutils 2.21, GNU ld gained support for new emulations fully
4480 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4481 AC_CACHE_CHECK(linker *_sol2 emulation support,
4482 gcc_cv_ld_sol2_emulation,
4483 [gcc_cv_ld_sol2_emulation=no
4484 if test $in_tree_ld = yes ; then
4485 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4486 "$gcc_cv_gld_minor_version" -ge 21 -o \
4487 "$gcc_cv_gld_major_version" -gt 2 \
4488 && test $in_tree_ld_is_elf = yes; then
4489 gcc_cv_ld_sol2_emulation=yes
4491 elif test x$gcc_cv_ld != x; then
4492 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4493 grep _sol2 > /dev/null; then
4494 gcc_cv_ld_sol2_emulation=yes
4497 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4498 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4499 [Define if your linker supports the *_sol2 emulations.])
4502 AC_CACHE_CHECK(linker --sysroot support,
4504 [gcc_cv_ld_sysroot=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 16 -o "$gcc_cv_gld_major_version" -gt 2 ; then
4507 gcc_cv_ld_sysroot=yes
4509 elif test x$gcc_cv_ld != x; then
4510 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4511 gcc_cv_ld_sysroot=yes
4514 if test x"$gcc_cv_ld_sysroot" = xyes; then
4515 AC_DEFINE(HAVE_LD_SYSROOT, 1,
4516 [Define if your linker supports --sysroot.])
4519 if test x$with_sysroot = x && test x$host = x$target \
4520 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4521 && test "$prefix" != "NONE"; then
4522 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4523 [Define to PREFIX/include if cpp should also search that directory.])
4526 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4527 if test "x$with_headers" != x; then
4528 target_header_dir=$with_headers
4529 elif test "x$with_sysroot" = x; then
4530 target_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4531 elif test "x$with_build_sysroot" != "x"; then
4532 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4533 elif test "x$with_sysroot" = xyes; then
4534 target_header_dir="${exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4536 target_header_dir="${with_sysroot}${native_system_header_dir}"
4539 target_header_dir=${native_system_header_dir}
4542 # Test for stack protector support in target C library.
4543 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4544 gcc_cv_libc_provides_ssp,
4545 [gcc_cv_libc_provides_ssp=no
4547 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4548 [# glibc 2.4 and later provides __stack_chk_fail and
4549 # either __stack_chk_guard, or TLS access to stack guard canary.
4550 if test -f $target_header_dir/features.h \
4551 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
4552 $target_header_dir/features.h > /dev/null; then
4553 if $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+([1-9][0-9]|[3-9])' \
4554 $target_header_dir/features.h > /dev/null; then
4555 gcc_cv_libc_provides_ssp=yes
4556 elif $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+2' \
4557 $target_header_dir/features.h > /dev/null \
4558 && $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+([1-9][0-9]|[4-9])' \
4559 $target_header_dir/features.h > /dev/null; then
4560 gcc_cv_libc_provides_ssp=yes
4561 elif $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
4562 $target_header_dir/features.h > /dev/null && \
4563 test -f $target_header_dir/bits/uClibc_config.h && \
4564 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
4565 $target_header_dir/bits/uClibc_config.h > /dev/null; then
4566 gcc_cv_libc_provides_ssp=yes
4571 # Avoid complicated tests (see
4572 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4573 # simply assert that glibc does provide this, which is true for all
4574 # realistically usable GNU/Hurd configurations.
4575 gcc_cv_libc_provides_ssp=yes;;
4576 *-*-darwin* | *-*-freebsd*)
4577 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4578 [echo "no __stack_chk_fail on this target"])
4580 *) gcc_cv_libc_provides_ssp=no ;;
4583 if test x$gcc_cv_libc_provides_ssp = xyes; then
4584 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4585 [Define if your target C library provides stack protector support])
4588 # Test for <sys/sdt.h> on the target.
4589 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4590 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4592 if test -f $target_header_dir/sys/sdt.h; then
4594 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4595 [Define if your target C library provides sys/sdt.h])
4597 AC_MSG_RESULT($have_sys_sdt_h)
4599 # Check if TFmode long double should be used by default or not.
4600 # Some glibc targets used DFmode long double, but with glibc 2.4
4601 # and later they can use TFmode.
4603 powerpc*-*-linux* | \
4607 AC_ARG_WITH(long-double-128,
4608 [AS_HELP_STRING([--with-long-double-128],
4609 [use 128-bit long double by default])],
4610 gcc_cv_target_ldbl128="$with_long_double_128",
4611 [[gcc_cv_target_ldbl128=no
4612 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4613 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4614 && gcc_cv_target_ldbl128=yes
4618 if test x$gcc_cv_target_ldbl128 = xyes; then
4619 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4620 [Define if TFmode long double should be the default])
4623 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
4624 gcc_cv_target_dl_iterate_phdr=unknown
4627 # <link.h> needs both a dl_iterate_phdr declaration and support for
4628 # compilation with largefile support.
4629 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
4630 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
4631 gcc_cv_target_dl_iterate_phdr=yes
4633 gcc_cv_target_dl_iterate_phdr=no
4637 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
4638 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
4639 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
4640 [Define if your target C library provides the `dl_iterate_phdr' function.])
4642 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
4644 # Find out what GC implementation we want, or may, use.
4646 [AS_HELP_STRING([--with-gc={page,zone}],
4647 [choose the garbage collection mechanism to use
4648 with the compiler])],
4655 AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4658 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4663 echo "Using $GGC for garbage collection."
4665 # Libraries to use on the host. This will normally be set by the top
4666 # level Makefile. Here we simply capture the value for our Makefile.
4667 if test -z "${HOST_LIBS+set}"; then
4672 # Use the system's zlib library.
4674 zlibinc="-I\$(srcdir)/../zlib"
4675 AC_ARG_WITH(system-zlib,
4676 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
4683 dnl Very limited version of automake's enable-maintainer-mode
4685 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4686 dnl maintainer-mode is disabled by default
4687 AC_ARG_ENABLE(maintainer-mode,
4688 [AS_HELP_STRING([--enable-maintainer-mode],
4689 [enable make rules and dependencies not useful
4690 (and sometimes confusing) to the casual installer])],
4691 maintainer_mode=$enableval,
4694 AC_MSG_RESULT($maintainer_mode)
4696 if test "$maintainer_mode" = "yes"; then
4707 # Make empty files to contain the specs and options for each language.
4708 # Then add #include lines to for a compiler that has specs and/or options.
4714 # These (without "all_") are set in each config-lang.in.
4715 # `language' must be a single word so is spelled singularly.
4718 all_outputs='Makefile'
4719 # List of language makefile fragments.
4721 # Additional files for gengtype
4722 all_gtfiles="$target_gtfiles"
4724 # These are the languages that are set in --enable-languages,
4725 # and are available in the GCC tree.
4726 all_selected_languages=
4728 # Add the language fragments.
4729 # Languages are added via two mechanisms. Some information must be
4730 # recorded in makefile variables, these are defined in config-lang.in.
4731 # We accumulate them and plug them into the main Makefile.
4732 # The other mechanism is a set of hooks for each of the main targets
4733 # like `clean', `install', etc.
4735 language_hooks="Make-hooks"
4737 for lang in ${srcdir}/*/config-lang.in
4740 test "$lang" = "${srcdir}/*/config-lang.in" && continue
4742 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
4743 if test "x$lang_alias" = x
4745 echo "$lang doesn't set \$language." 1>&2
4748 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4749 subdirs="$subdirs $subdir"
4751 # $gcc_subdir is where the gcc integration files are to be found
4752 # for a language, both for internal compiler purposes (compiler
4753 # sources implementing front-end to GCC tree converters), and for
4754 # build infrastructure purposes (Make-lang.in, etc.)
4756 # This will be <subdir> (relative to $srcdir) if a line like
4757 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4758 # is found in <langdir>/config-lang.in, and will remain <langdir>
4761 # Except for the language alias (fetched above), the regular
4762 # "config-lang.in" contents are always retrieved from $gcc_subdir,
4763 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4764 # only this and the language alias.
4766 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
4767 if [ "$gcc_subdir" = "" ]; then
4768 gcc_subdir="$subdir"
4771 case ",$enable_languages," in
4773 all_selected_languages="$all_selected_languages $lang_alias"
4774 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4775 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4787 . ${srcdir}/$gcc_subdir/config-lang.in
4788 if test "x$language" = x
4790 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4795 case ",$enable_languages," in
4798 for i in $subdir_requires; do
4799 test -f "${srcdir}/$i/config-lang.in" && continue
4807 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4808 if test -f $srcdir/$gcc_subdir/lang.opt; then
4809 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4810 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
4812 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4813 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4815 all_languages="$all_languages $language"
4816 all_compilers="$all_compilers $compilers"
4817 all_outputs="$all_outputs $outputs"
4818 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4819 case ",$enable_languages," in
4821 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4823 AC_SUBST(enable_lto)
4829 # Pick up gtfiles for c
4831 . ${srcdir}/c-config-lang.in
4832 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4835 for language in $all_selected_languages
4837 check_languages="$check_languages check-$language"
4840 # We link each language in with a set of hooks, reached indirectly via
4841 # lang.${target}. Only do so for selected languages.
4845 target_list="all.cross start.encap rest.encap tags \
4846 install-common install-man install-info install-pdf install-html dvi \
4847 pdf html uninstall info man srcextra srcman srcinfo \
4848 mostlyclean clean distclean maintainer-clean install-plugin"
4850 for t in $target_list
4853 for lang in $all_selected_languages
4857 echo "lang.$t: $x" >> Make-hooks
4861 # Option include files
4864 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
4865 option_includes="option-includes.mk"
4866 AC_SUBST_FILE(option_includes)
4874 echo "dir ." > .gdbinit
4875 echo "dir ${srcdir}" >> .gdbinit
4876 if test x$gdb_needs_out_file_path = xyes
4878 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4880 if test "x$subdirs" != x; then
4883 echo "dir ${srcdir}/$s" >> .gdbinit
4886 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4888 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4889 AC_SUBST(gcc_tooldir)
4892 # Find a directory in which to install a shared libgcc.
4894 AC_ARG_ENABLE(version-specific-runtime-libs,
4895 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
4896 [specify that runtime libraries should be
4897 installed in a compiler-specific directory])])
4899 # Substitute configuration variables
4902 AC_SUBST(all_compilers)
4903 AC_SUBST(all_gtfiles)
4904 AC_SUBST(all_lang_makefrags)
4905 AC_SUBST(all_languages)
4906 AC_SUBST(all_selected_languages)
4907 AC_SUBST(build_exeext)
4908 AC_SUBST(build_install_headers_dir)
4909 AC_SUBST(build_xm_file_list)
4910 AC_SUBST(build_xm_include_list)
4911 AC_SUBST(build_xm_defines)
4912 AC_SUBST(build_file_translate)
4913 AC_SUBST(check_languages)
4914 AC_SUBST(cpp_install_dir)
4915 AC_SUBST(xmake_file)
4916 AC_SUBST(tmake_file)
4917 AC_SUBST(TM_ENDIAN_CONFIG)
4918 AC_SUBST(TM_MULTILIB_CONFIG)
4919 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4920 AC_SUBST(extra_gcc_objs)
4921 AC_SUBST(user_headers_inc_next_pre)
4922 AC_SUBST(user_headers_inc_next_post)
4923 AC_SUBST(extra_headers_list)
4924 AC_SUBST(extra_objs)
4925 AC_SUBST(extra_passes)
4926 AC_SUBST(extra_programs)
4927 AC_SUBST(float_h_file)
4928 AC_SUBST(gcc_config_arguments)
4929 AC_SUBST(gcc_gxx_include_dir)
4930 AC_SUBST(host_exeext)
4931 AC_SUBST(host_xm_file_list)
4932 AC_SUBST(host_xm_include_list)
4933 AC_SUBST(host_xm_defines)
4934 AC_SUBST(out_host_hook_obj)
4936 AC_SUBST(lang_opt_files)
4937 AC_SUBST(lang_specs_files)
4938 AC_SUBST(lang_tree_files)
4939 AC_SUBST(local_prefix)
4941 AC_SUBST(objc_boehm_gc)
4943 AC_SUBST(out_object_file)
4944 AC_SUBST(common_out_file)
4945 AC_SUBST(common_out_object_file)
4946 AC_SUBST(tm_file_list)
4947 AC_SUBST(tm_include_list)
4948 AC_SUBST(tm_defines)
4949 AC_SUBST(tm_p_file_list)
4950 AC_SUBST(tm_p_include_list)
4951 AC_SUBST(xm_file_list)
4952 AC_SUBST(xm_include_list)
4953 AC_SUBST(xm_defines)
4954 AC_SUBST(use_gcc_stdint)
4955 AC_SUBST(c_target_objs)
4956 AC_SUBST(cxx_target_objs)
4957 AC_SUBST(fortran_target_objs)
4958 AC_SUBST(target_cpu_default)
4960 AC_SUBST_FILE(language_hooks)
4963 if test x${build} = x${host} ; then
4964 if test x${host} = x${target} ; then
4965 echo "Links are now set up to build a native compiler for ${target}." 1>&2
4967 echo "Links are now set up to build a cross-compiler" 1>&2
4968 echo " from ${host} to ${target}." 1>&2
4971 if test x${host} = x${target} ; then
4972 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4973 echo " for ${target}." 1>&2
4975 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4976 echo " from ${host} to ${target}." 1>&2
4980 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4981 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4983 AC_ARG_VAR(PPLLIBS,[How to link PPL])
4984 AC_ARG_VAR(PPLINC,[How to find PPL include files])
4986 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4987 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4988 if test "x${CLOOGLIBS}" != "x" ; then
4989 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
4992 # Check for plugin support
4993 AC_ARG_ENABLE(plugin,
4994 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
4995 enable_plugin=$enableval,
4996 enable_plugin=yes; default_plugin=yes)
5002 if test x$build = x$host; then
5003 export_sym_check="nm${exeext} -g"
5004 elif test x$host = x$target; then
5005 export_sym_check="$gcc_cv_nm -g"
5011 if test x$build = x$host; then
5012 export_sym_check="objdump${exeext} -T"
5013 elif test x$host = x$target; then
5014 export_sym_check="$gcc_cv_objdump -T"
5021 if test x"$enable_plugin" = x"yes"; then
5023 AC_MSG_CHECKING([for exported symbols])
5024 if test "x$export_sym_check" != x; then
5025 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5026 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
5027 if $export_sym_check conftest | grep foobar > /dev/null; then
5028 : # No need to use a flag
5029 AC_MSG_RESULT([yes])
5031 AC_MSG_RESULT([yes])
5032 AC_MSG_CHECKING([for -rdynamic])
5033 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
5034 if $export_sym_check conftest | grep foobar > /dev/null; then
5036 pluginlibs="-rdynamic"
5041 AC_MSG_RESULT([$plugin_rdynamic])
5044 AC_MSG_RESULT([unable to check])
5049 AC_SEARCH_LIBS([dlopen], [dl])
5050 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5051 pluginlibs="$pluginlibs -ldl"
5055 # Check that we can build shared objects with -fPIC -shared
5056 saved_LDFLAGS="$LDFLAGS"
5057 saved_CFLAGS="$CFLAGS"
5060 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5061 CFLAGS="$CFLAGS -fPIC"
5062 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5065 CFLAGS="$CFLAGS -fPIC"
5066 LDFLAGS="$LDFLAGS -fPIC -shared"
5069 AC_MSG_CHECKING([for -fPIC -shared])
5071 [extern int X;],[return X == 0;],
5072 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5073 [AC_MSG_RESULT([no]); have_pic_shared=no])
5074 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5078 LDFLAGS="$saved_LDFLAGS"
5079 CFLAGS="$saved_CFLAGS"
5081 # If plugin support had been requested but not available, fail.
5082 if test x"$enable_plugin" = x"no" ; then
5083 if test x"$default_plugin" != x"yes"; then
5085 Building GCC with plugin support requires a host that supports
5086 -fPIC, -shared, -ldl and -rdynamic.])
5091 AC_SUBST(pluginlibs)
5092 AC_SUBST(enable_plugin)
5093 if test x"$enable_plugin" = x"yes"; then
5094 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5098 AC_ARG_ENABLE(libquadmath-support,
5099 [AS_HELP_STRING([--disable-libquadmath-support],
5100 [disable libquadmath support for Fortran])],
5101 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5102 ENABLE_LIBQUADMATH_SUPPORT=yes)
5103 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5104 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5105 [Define to 1 to enable libquadmath support])
5109 # Specify what hash style to use by default.
5110 AC_ARG_WITH([linker-hash-style],
5111 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5112 [specify the linker hash style])],
5113 [case x"$withval" in
5115 LINKER_HASH_STYLE=sysv
5118 LINKER_HASH_STYLE=gnu
5121 LINKER_HASH_STYLE=both
5124 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5127 [LINKER_HASH_STYLE=''])
5128 if test x"${LINKER_HASH_STYLE}" != x; then
5129 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5130 [The linker hash style])
5133 # Configure the subdirectories
5134 # AC_CONFIG_SUBDIRS($subdirs)
5136 # Create the Makefile
5137 # and configure language subdirectories
5138 AC_CONFIG_FILES($all_outputs)
5140 AC_CONFIG_COMMANDS([default],
5142 case ${CONFIG_HEADERS} in
5143 *auto-host.h:config.in*)
5146 # Make sure all the subdirs exist.
5147 for d in $subdirs doc build common c-family
5149 test -d $d || mkdir $d
5152 [subdirs='$subdirs'])