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, 2012 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 gcc_gxx_include_dir_add_sysroot=0
149 if test "${with_sysroot+set}" = set; then
150 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
151 if test "${gcc_gxx_without_sysroot}"; then
152 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
153 gcc_gxx_include_dir_add_sysroot=1
157 AC_ARG_WITH(cpp_install_dir,
158 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
159 [install the user visible C preprocessor in DIR
160 (relative to PREFIX) as well as PREFIX/bin])],
161 [if test x$withval = xyes; then
162 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
163 elif test x$withval != xno; then
164 cpp_install_dir=$withval
167 # We would like to our source tree to be readonly. However when releases or
168 # pre-releases are generated, the flex/bison generated files as well as the
169 # various formats of manuals need to be included along with the rest of the
170 # sources. Therefore we have --enable-generated-files-in-srcdir to do
173 AC_MSG_CHECKING([whether to place generated files in the source directory])
174 dnl generated-files-in-srcdir is disabled by default
175 AC_ARG_ENABLE(generated-files-in-srcdir,
176 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
177 [put copies of generated files in source dir
178 intended for creating source tarballs for users
179 without texinfo bison or flex])],
180 generated_files_in_srcdir=$enableval,
181 generated_files_in_srcdir=no)
183 AC_MSG_RESULT($generated_files_in_srcdir)
185 if test "$generated_files_in_srcdir" = "yes"; then
192 # -------------------
193 # Find default linker
194 # -------------------
198 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
199 gnu_ld_flag="$with_gnu_ld",
202 # With pre-defined ld
204 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
205 DEFAULT_LINKER="$with_ld")
206 if test x"${DEFAULT_LINKER+set}" = x"set"; then
207 if test ! -x "$DEFAULT_LINKER"; then
208 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
209 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
212 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
213 [Define to enable the use of a default linker.])
216 AC_MSG_CHECKING([whether a default linker was specified])
217 if test x"${DEFAULT_LINKER+set}" = x"set"; then
218 if test x"$gnu_ld_flag" = x"no"; then
219 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
221 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
227 # With demangler in GNU ld
228 AC_ARG_WITH(demangler-in-ld,
229 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
230 demangler_in_ld="$with_demangler_in_ld",
233 # ----------------------
234 # Find default assembler
235 # ----------------------
239 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
240 gas_flag="$with_gnu_as",
244 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
245 DEFAULT_ASSEMBLER="$with_as")
246 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
247 if test ! -x "$DEFAULT_ASSEMBLER"; then
248 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
249 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
252 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
253 [Define to enable the use of a default assembler.])
256 AC_MSG_CHECKING([whether a default assembler was specified])
257 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
258 if test x"$gas_flag" = x"no"; then
259 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
261 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
271 # If a non-executable a.out is present (e.g. created by GNU as above even if
272 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
273 # file, even when creating an executable, so an execution test fails.
274 # Remove possible default executable files to avoid this.
276 # FIXME: This really belongs into AC_PROG_CC and can be removed once
277 # Autoconf includes it.
278 rm -f a.out a.exe b.out
280 # Find the native compiler
284 ACX_PROG_GNAT([-I"$srcdir"/ada])
286 # autoconf is lame and doesn't give us any substitution variable for this.
287 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
288 NO_MINUS_C_MINUS_O=yes
290 OUTPUT_OPTION='-o $@'
292 AC_SUBST(NO_MINUS_C_MINUS_O)
293 AC_SUBST(OUTPUT_OPTION)
295 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
296 # optimizations to be activated explicitly by the toplevel.
299 *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
303 # Determine PICFLAG for target gnatlib.
304 GCC_PICFLAG_FOR_TARGET
305 AC_SUBST(PICFLAG_FOR_TARGET)
307 # -------------------------
308 # Check C compiler features
309 # -------------------------
311 AC_USE_SYSTEM_EXTENSIONS
317 # sizeof(char) is 1 by definition.
318 AC_CHECK_SIZEOF(void *)
319 AC_CHECK_SIZEOF(short)
321 AC_CHECK_SIZEOF(long)
322 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
323 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
326 # ---------------------
327 # Warnings and checking
328 # ---------------------
330 # Check $CC warning features (if it's GCC).
331 # We want to use -pedantic, but we don't want warnings about
335 # * C++11 narrowing conversions in { }
336 # So, we only use -pedantic if we can disable those warnings.
338 ACX_PROG_CC_WARNING_OPTS(
339 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual])), [loose_warn])
340 ACX_PROG_CC_WARNING_OPTS(
341 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
343 ACX_PROG_CC_WARNING_OPTS(
344 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
345 ACX_PROG_CC_WARNING_OPTS(
346 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
347 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
348 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
349 [-Wno-overlength-strings])), [strict_warn])
350 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
352 # The above macros do nothing if the compiler is not GCC. However, the
353 # Makefile has more goo to add other flags, so these variables are used
354 # to enable warnings only for GCC.
357 if test "x$GCC" = "xyes"; then
358 warn_cflags='$(GCC_WARN_CFLAGS)'
359 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
361 AC_SUBST(warn_cflags)
362 AC_SUBST(warn_cxxflags)
364 # Disable exceptions and RTTI if building with g++
365 ACX_PROG_CC_WARNING_OPTS(
366 m4_quote(m4_do([-fno-exceptions -fno-rtti])), [noexception_flags])
368 # Enable expensive internal checks
370 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
374 AC_ARG_ENABLE(checking,
375 [AS_HELP_STRING([[--enable-checking[=LIST]]],
376 [enable expensive run-time checks. With LIST,
377 enable only specific categories of checks.
378 Categories are: yes,no,all,none,release.
379 Flags are: assert,df,fold,gc,gcac,gimple,misc,
380 rtlflag,rtl,runtime,tree,valgrind,types])],
381 [ac_checking_flags="${enableval}"],[
382 # Determine the default checks.
383 if test x$is_release = x ; then
384 ac_checking_flags=yes
386 ac_checking_flags=release
388 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
389 for check in release $ac_checking_flags
392 # these set all the flags to specific states
393 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
394 ac_fold_checking= ; ac_gc_checking=1 ;
395 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
396 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
397 ac_tree_checking=1 ; ac_valgrind_checking= ;
398 ac_types_checking=1 ;;
399 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
400 ac_fold_checking= ; ac_gc_checking= ;
401 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
402 ac_rtlflag_checking= ; ac_runtime_checking= ;
403 ac_tree_checking= ; ac_valgrind_checking= ;
404 ac_types_checking= ;;
405 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
406 ac_fold_checking=1 ; ac_gc_checking=1 ;
407 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
408 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
409 ac_tree_checking=1 ; ac_valgrind_checking= ;
410 ac_types_checking=1 ;;
411 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
412 ac_fold_checking= ; ac_gc_checking= ;
413 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
414 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
415 ac_tree_checking= ; ac_valgrind_checking= ;
416 ac_types_checking= ;;
417 # these enable particular checks
418 assert) ac_assert_checking=1 ;;
419 df) ac_df_checking=1 ;;
420 fold) ac_fold_checking=1 ;;
421 gc) ac_gc_checking=1 ;;
422 gcac) ac_gc_always_collect=1 ;;
423 gimple) ac_gimple_checking=1 ;;
424 misc) ac_checking=1 ;;
425 rtl) ac_rtl_checking=1 ;;
426 rtlflag) ac_rtlflag_checking=1 ;;
427 runtime) ac_runtime_checking=1 ;;
428 tree) ac_tree_checking=1 ;;
429 types) ac_types_checking=1 ;;
430 valgrind) ac_valgrind_checking=1 ;;
431 *) AC_MSG_ERROR(unknown check category $check) ;;
437 if test x$ac_checking != x ; then
438 AC_DEFINE(ENABLE_CHECKING, 1,
439 [Define if you want more run-time sanity checks. This one gets a grab
440 bag of miscellaneous but relatively cheap checks.])
441 nocommon_flag=-fno-common
443 AC_SUBST(nocommon_flag)
444 if test x$ac_df_checking != x ; then
445 AC_DEFINE(ENABLE_DF_CHECKING, 1,
446 [Define if you want more run-time sanity checks for dataflow.])
448 if test x$ac_assert_checking != x ; then
449 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
450 [Define if you want assertions enabled. This is a cheap check.])
452 if test x$ac_gimple_checking != x ; then
453 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
454 [Define if you want operations on GIMPLE (the basic data structure of
455 the high-level optimizers) to be checked for dynamic type safety at
456 runtime. This is moderately expensive.])
458 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
459 if test x$ac_runtime_checking != x ; then
460 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
461 [Define if you want runtime assertions enabled. This is a cheap check.])
463 if test x$ac_tree_checking != x ; then
464 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
465 [Define if you want all operations on trees (the basic data
466 structure of the front ends) to be checked for dynamic type safety
467 at runtime. This is moderately expensive. The tree browser debugging
468 routines will also be enabled by this option.
470 TREEBROWSER=tree-browser.o
472 if test x$ac_types_checking != x ; then
473 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
474 [Define if you want all gimple types to be verified after gimplifiation.
478 AC_SUBST(TREEBROWSER)
479 if test x$ac_rtl_checking != x ; then
480 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
481 [Define if you want all operations on RTL (the basic data structure
482 of the optimizer and back end) to be checked for dynamic type safety
483 at runtime. This is quite expensive.])
485 if test x$ac_rtlflag_checking != x ; then
486 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
487 [Define if you want RTL flag accesses to be checked against the RTL
488 codes that are supported for each access macro. This is relatively
491 if test x$ac_gc_checking != x ; then
492 AC_DEFINE(ENABLE_GC_CHECKING, 1,
493 [Define if you want the garbage collector to do object poisoning and
494 other memory allocation checks. This is quite expensive.])
496 if test x$ac_gc_always_collect != x ; then
497 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
498 [Define if you want the garbage collector to operate in maximally
499 paranoid mode, validating the entire heap and collecting garbage at
500 every opportunity. This is extremely expensive.])
502 if test x$ac_fold_checking != x ; then
503 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
504 [Define if you want fold checked that it never destructs its argument.
505 This is quite expensive.])
507 valgrind_path_defines=
510 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
511 dnl # an if statement. This was the source of very frustrating bugs
512 dnl # in converting to autoconf 2.5x!
513 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
515 if test x$ac_valgrind_checking != x ; then
516 # It is certainly possible that there's valgrind but no valgrind.h.
517 # GCC relies on making annotations so we must have both.
518 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
519 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
520 [[#include <valgrind/memcheck.h>
521 #ifndef VALGRIND_DISCARD
522 #error VALGRIND_DISCARD not defined
524 [gcc_cv_header_valgrind_memcheck_h=yes],
525 [gcc_cv_header_valgrind_memcheck_h=no])
526 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
527 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
528 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
529 [[#include <memcheck.h>
530 #ifndef VALGRIND_DISCARD
531 #error VALGRIND_DISCARD not defined
533 [gcc_cv_header_memcheck_h=yes],
534 [gcc_cv_header_memcheck_h=no])
535 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
536 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
537 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
538 if test "x$valgrind_path" = "x" \
539 || (test $have_valgrind_h = no \
540 && test $gcc_cv_header_memcheck_h = no \
541 && test $gcc_cv_header_valgrind_memcheck_h = no); then
542 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
544 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
545 valgrind_command="$valgrind_path -q"
546 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
547 [Define if you want to run subprograms and generated programs
548 through valgrind (a memory checker). This is extremely expensive.])
549 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
550 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
551 [Define if valgrind's valgrind/memcheck.h header is installed.])
553 if test $gcc_cv_header_memcheck_h = yes; then
554 AC_DEFINE(HAVE_MEMCHECK_H, 1,
555 [Define if valgrind's memcheck.h header is installed.])
558 AC_SUBST(valgrind_path_defines)
559 AC_SUBST(valgrind_command)
561 # Enable code coverage collection
562 AC_ARG_ENABLE(coverage,
563 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
564 [enable compiler's code coverage collection.
565 Use to measure compiler performance and locate
566 unused parts of the compiler. With LEVEL, specify
567 optimization. Values are opt, noopt,
569 [case "${enableval}" in
571 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
574 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
577 # a.k.a. --disable-coverage
581 AC_MSG_ERROR(unknown coverage setting $enableval)
585 AC_SUBST(coverage_flags)
587 AC_ARG_ENABLE(gather-detailed-mem-stats,
588 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
589 [enable detailed memory allocation stats gathering])], [],
590 [enable_gather_detailed_mem_stats=no])
591 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
592 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
593 [Define to enable detailed memory allocation stats gathering.])
595 # -------------------------------
596 # Miscenalleous configure options
597 # -------------------------------
599 # See if we are building gcc with C++.
600 AC_ARG_ENABLE(build-with-cxx,
601 [AS_HELP_STRING([--enable-build-with-cxx],
602 [build with C++ compiler instead of C compiler])],
603 ENABLE_BUILD_WITH_CXX=$enableval,
604 ENABLE_BUILD_WITH_CXX=no)
605 AC_SUBST(ENABLE_BUILD_WITH_CXX)
606 if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
607 AC_DEFINE(ENABLE_BUILD_WITH_CXX, 1,
608 [Define if building with C++.])
613 [AS_HELP_STRING([--with-stabs],
614 [arrange to use stabs instead of host debug format])],
618 # Determine whether or not multilibs are enabled.
619 AC_ARG_ENABLE(multilib,
620 [AS_HELP_STRING([--enable-multilib],
621 [enable library support for multiple ABIs])],
622 [], [enable_multilib=yes])
623 AC_SUBST(enable_multilib)
625 # Enable __cxa_atexit for C++.
626 AC_ARG_ENABLE(__cxa_atexit,
627 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
630 # Enable C extension for decimal float if target supports it.
631 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
633 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
634 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
635 [Define to 1 to enable decimal float extension to C.])
637 # Use default_decimal_float for dependency.
638 enable_decimal_float=$default_decimal_float
640 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
641 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
642 [Define to 1 to specify that we are using the BID decimal floating
643 point format instead of DPD])
645 # Enable C extension for fixed-point arithmetic.
646 AC_ARG_ENABLE(fixed-point,
647 [AS_HELP_STRING([--enable-fixed-point],
648 [enable fixed-point arithmetic extension to C])],
653 enable_fixed_point=yes
657 enable_fixed_point=yes
660 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
661 enable_fixed_point=no
665 AC_SUBST(enable_fixed_point)
667 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
668 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
669 [Define to 1 to enable fixed-point arithmetic extension to C.])
672 # Pass with no value to take the default
673 # Pass with a value to specify a thread package
674 AC_ARG_ENABLE(threads,
675 [AS_HELP_STRING([[--enable-threads[=LIB]]],
676 [enable thread usage for target GCC,
677 using LIB thread package])],,
681 [AS_HELP_STRING([--enable-tls],
682 [enable or disable generation of tls code
683 overriding the assembler check for tls support])],
687 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
688 Valid choices are 'yes' and 'no'.]) ;;
692 AC_ARG_ENABLE(objc-gc,
693 [AS_HELP_STRING([--enable-objc-gc],
694 [enable the use of Boehm's garbage collector with
695 the GNU Objective-C runtime])],
696 if test x$enable_objc_gc = xno; then
704 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
705 dwarf2="$with_dwarf2",
708 AC_ARG_ENABLE(shared,
709 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
711 case $enable_shared in
715 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
716 for pkg in $enableval; do
717 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
724 ], [enable_shared=yes])
725 AC_SUBST(enable_shared)
727 AC_ARG_WITH([native-system-header-dir],
728 [ --with-native-system-header-dir=dir
729 use dir as the directory to look for standard
730 system header files in. Defaults to /usr/include.],
732 case ${with_native_system_header_dir} in
733 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
734 /* | [[A-Za-z]]:[[\\/]]*) ;;
735 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
737 configured_native_system_header_dir="${withval}"
738 ], [configured_native_system_header_dir=])
740 AC_ARG_WITH(build-sysroot,
741 [AS_HELP_STRING([--with-build-sysroot=sysroot],
742 [use sysroot as the system root during the build])],
743 [if test x"$withval" != x ; then
744 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
746 [SYSROOT_CFLAGS_FOR_TARGET=])
747 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
749 if test "x$prefix" = xNONE; then
750 test_prefix=/usr/local
754 if test "x$exec_prefix" = xNONE; then
755 test_exec_prefix=$test_prefix
757 test_exec_prefix=$exec_prefix
761 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
762 [search for usr/lib, usr/include, et al, within DIR])],
764 case ${with_sysroot} in
765 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
766 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
769 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
770 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
772 case ${TARGET_SYSTEM_ROOT} in
773 "${test_prefix}"|"${test_prefix}/"*|\
774 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
775 '${prefix}'|'${prefix}/'*|\
776 '${exec_prefix}'|'${exec_prefix}/'*)
777 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
778 TARGET_SYSTEM_ROOT_DEFINE="$t"
783 TARGET_SYSTEM_ROOT_DEFINE=
784 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
786 AC_SUBST(TARGET_SYSTEM_ROOT)
787 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
788 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
791 [AS_HELP_STRING([--with-specs=SPECS],
792 [add SPECS to driver command-line processing])],
793 [CONFIGURE_SPECS=$withval],
796 AC_SUBST(CONFIGURE_SPECS)
798 ACX_PKGVERSION([GCC])
799 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
801 # Sanity check enable_languages in case someone does not run the toplevel
802 # configure # script.
803 AC_ARG_ENABLE(languages,
804 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
805 [case ,${enable_languages}, in
807 # go safe -- we cannot be much sure without the toplevel
809 # analysis of which target libs are present and usable
813 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
818 enable_languages=c,${enable_languages}
821 [enable_languages=c])
823 AC_ARG_WITH(multilib-list,
824 [AS_HELP_STRING([--with-multilib-list], [select multilibs (SH and x86-64 only)])],
826 with_multilib_list=default)
828 # -------------------------
829 # Checks for other programs
830 # -------------------------
834 # Find some useful tools
836 # We need awk to create options.c and options.h.
837 # Bail out if it's missing.
839 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
846 AC_SUBST(ranlib_flags)
850 # See if cmp has --ignore-initial.
851 gcc_AC_PROG_CMP_IGNORE_INITIAL
853 # See if we have the mktemp command.
854 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
856 # See if makeinfo has been installed and is modern enough
857 # that we can use it.
858 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
859 [GNU texinfo.* \([0-9][0-9.]*\)],
860 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
861 if test $gcc_cv_prog_makeinfo_modern = no; then
863 *** Makeinfo is missing or too old.
864 *** Info documentation will not be built.])
871 # Is pod2man recent enough to regenerate manpages?
872 AC_MSG_CHECKING([for recent Pod::Man])
873 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
875 GENERATED_MANPAGES=generated-manpages
880 AC_SUBST(GENERATED_MANPAGES)
882 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
885 dnl Don't use AC_PROG_LEX; we insist on flex.
886 dnl LEXLIB is not useful in gcc.
887 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
890 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
892 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
893 # check for build == host before using them.
896 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
897 && test -d ../binutils ; then
898 NM='${objdir}/../binutils/nm-new'
900 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
904 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
905 && test -d ../binutils ; then
906 AR='${objdir}/../binutils/ar'
908 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
912 # --------------------
913 # Checks for C headers
914 # --------------------
916 # Need to reject headers which give warnings, so that the -Werror bootstrap
917 # works later. *sigh* This needs to come before all header checks.
924 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
925 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
926 sys/resource.h sys/param.h sys/times.h sys/stat.h \
927 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
929 # Check for thread headers.
930 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
931 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
933 # These tests can't be done till we know if we have limits.h.
937 # ----------------------
938 # Checks for C++ headers
939 # ----------------------
941 dnl Autoconf will give an error in the configure script if there is no
942 dnl C++ preprocessor. Hack to prevent that.
943 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
945 m4_popdef([AC_MSG_ERROR])[]dnl
949 AC_CHECK_HEADERS(unordered_map)
950 AC_CHECK_HEADERS(tr1/unordered_map)
951 AC_CHECK_HEADERS(ext/hash_map)
960 # These libraries may be used by collect2.
961 # We may need a special search path to get them linked.
962 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
964 for libs in '' -lld -lmld \
965 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
966 '-L/usr/lib/cmplrs/cc3.11 -lmld'
969 AC_TRY_LINK_FUNC(ldopen,
970 [gcc_cv_collect2_libs="$libs"; break])
973 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
974 case $gcc_cv_collect2_libs in
976 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
978 AC_SUBST(COLLECT2_LIBS)
980 # When building Ada code on Alpha, we need exc_resume which is usually in
981 # -lexc. So test for it.
984 AC_SEARCH_LIBS(exc_resume, exc)
987 AC_SUBST(GNAT_LIBEXC)
989 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
992 AC_SEARCH_LIBS(kstat_open, kstat)
993 EXTRA_GCC_LIBS="$LIBS"
995 AC_SUBST(EXTRA_GCC_LIBS)
997 # Some systems put ldexp and frexp in libm instead of libc; assume
998 # they're both in the same place. jcf-dump needs them.
1001 AC_SEARCH_LIBS(ldexp, m)
1006 # Use <inttypes.h> only if it exists,
1007 # doesn't clash with <sys/types.h>, and declares intmax_t.
1008 AC_MSG_CHECKING(for inttypes.h)
1009 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1010 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1011 [[#include <sys/types.h>
1012 #include <inttypes.h>]],
1013 [[intmax_t i = -1;]])],
1014 [gcc_cv_header_inttypes_h=yes],
1015 [gcc_cv_header_inttypes_h=no])])
1016 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1017 if test $gcc_cv_header_inttypes_h = yes; then
1018 AC_DEFINE(HAVE_INTTYPES_H, 1,
1019 [Define if you have a working <inttypes.h> header file.])
1022 dnl Disabled until we have a complete test for buggy enum bitfields.
1023 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1025 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1026 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1027 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1028 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1029 putchar_unlocked putc_unlocked)
1030 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1031 sysconf strsignal getrusage nl_langinfo \
1032 gettimeofday mbstowcs wcswidth mmap setlocale \
1033 gcc_UNLOCKED_FUNCS madvise)
1035 if test x$ac_cv_func_mbstowcs = xyes; then
1036 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1037 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1043 [gcc_cv_func_mbstowcs_works=yes],
1044 [gcc_cv_func_mbstowcs_works=no],
1045 [gcc_cv_func_mbstowcs_works=yes])])
1046 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1047 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1048 [Define this macro if mbstowcs does not crash when its
1049 first argument is NULL.])
1053 AC_CHECK_TYPE(ssize_t, int)
1054 AC_CHECK_TYPE(caddr_t, char *)
1056 GCC_AC_FUNC_MMAP_BLACKLIST
1060 # Under VMS, vfork works very differently than on Unix. The standard test
1061 # won't work, and it isn't easily adaptable. It makes more sense to
1063 ac_cv_func_vfork_works=yes
1068 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1069 # iconv() prototype.
1070 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1071 [AC_LANG_PUSH([C++])
1073 AC_LANG_POP([C++])],
1076 # Until we have in-tree GNU iconv:
1078 AC_SUBST(LIBICONV_DEP)
1084 # We will need to find libiberty.h and ansidecl.h
1085 saved_CFLAGS="$CFLAGS"
1086 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1087 saved_CXXFLAGS="$CXXFLAGS"
1088 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include"
1089 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1090 strsignal strstr stpcpy strverscmp \
1091 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1092 free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1093 #include "ansidecl.h"
1094 #include "system.h"])
1096 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1097 #include "ansidecl.h"
1099 #ifdef HAVE_SYS_RESOURCE_H
1100 #include <sys/resource.h>
1104 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1105 #include "ansidecl.h"
1107 #ifdef HAVE_SYS_RESOURCE_H
1108 #include <sys/resource.h>
1110 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1111 [Define to `long' if <sys/resource.h> doesn't define.])])
1113 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1114 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1115 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1116 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1117 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1118 #include "ansidecl.h"
1127 gcc_AC_CHECK_DECLS(times, , ,[
1128 #include "ansidecl.h"
1130 #ifdef HAVE_SYS_TIMES_H
1131 #include <sys/times.h>
1135 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1136 #include "ansidecl.h"
1141 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1143 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1144 [AC_LANG_PUSH([C++])
1145 gcc_AC_CHECK_DECLS(madvise, , ,[
1146 #include "ansidecl.h"
1149 AC_LANG_POP([C++])],
1150 [gcc_AC_CHECK_DECLS(madvise, , ,[
1151 #include "ansidecl.h"
1156 # More time-related stuff.
1157 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1158 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1159 #include "ansidecl.h"
1161 #ifdef HAVE_SYS_TIMES_H
1162 #include <sys/times.h>
1164 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1165 if test $ac_cv_struct_tms = yes; then
1166 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1167 [Define if <sys/times.h> defines struct tms.])
1170 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1171 # revisit after autoconf 2.50.
1172 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1173 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1174 #include "ansidecl.h"
1176 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1177 if test $gcc_cv_type_clock_t = yes; then
1178 AC_DEFINE(HAVE_CLOCK_T, 1,
1179 [Define if <time.h> defines clock_t.])
1182 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1183 CFLAGS="$saved_CFLAGS"
1184 CXXFLAGS="$saved_CXXFLAGS"
1186 # mkdir takes a single argument on some systems.
1187 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1195 # With Setjmp/Longjmp based exception handling.
1196 AC_ARG_ENABLE(sjlj-exceptions,
1197 [AS_HELP_STRING([--enable-sjlj-exceptions],
1198 [arrange to use setjmp/longjmp exception handling])],
1201 if test $enableval != yes; then
1202 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1207 force_sjlj_exceptions=yes],
1210 force_sjlj_exceptions=yes
1214 force_sjlj_exceptions=no
1217 if test $force_sjlj_exceptions = yes; then
1218 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1219 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1220 [Define 0/1 to force the choice for exception handling model.])
1223 # --------------------------------------------------------
1224 # Build, host, and target specific configuration fragments
1225 # --------------------------------------------------------
1227 # Collect build-machine-specific information.
1228 . ${srcdir}/config.build
1230 # Collect host-machine-specific information.
1231 . ${srcdir}/config.host
1235 # Collect target-machine-specific information.
1236 . ${srcdir}/config.gcc
1238 extra_objs="${host_extra_objs} ${extra_objs}"
1239 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1241 # Default the target-machine variables that were not explicitly set.
1242 if test x"$tm_file" = x
1243 then tm_file=$cpu_type/$cpu_type.h; fi
1245 if test x"$extra_headers" = x
1246 then extra_headers=; fi
1248 if test x$md_file = x
1249 then md_file=$cpu_type/$cpu_type.md; fi
1251 if test x$out_file = x
1252 then out_file=$cpu_type/$cpu_type.c; fi
1254 if test x"$tmake_file" = x
1255 then tmake_file=$cpu_type/t-$cpu_type
1258 # Support --enable-initfini-array.
1259 if test x$enable_initfini_array != xno; then
1260 tm_file="${tm_file} initfini-array.h"
1263 if test x"$dwarf2" = xyes
1264 then tm_file="$tm_file tm-dwarf2.h"
1267 # Say what files are being used for the output code and MD file.
1268 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1269 echo "Using \`$srcdir/config/$md_file' as machine description file."
1271 # If any of the xm_file variables contain nonexistent files, warn
1272 # about them and drop them.
1275 for x in $build_xm_file; do
1276 if test -f $srcdir/config/$x
1278 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1284 for x in $host_xm_file; do
1285 if test -f $srcdir/config/$x
1287 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1293 for x in $xm_file; do
1294 if test -f $srcdir/config/$x
1296 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1302 for f in $tm_file; do
1305 if test $count = ax; then
1306 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1308 echo "Using the following target machine macro files:"
1309 for f in $tm_file; do
1310 echo " $srcdir/config/$f"
1314 if test x$need_64bit_hwint = xyes; then
1315 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1316 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1319 if test x$use_long_long_for_widest_fast_int = xyes; then
1320 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1321 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1322 efficiently supported by the host hardware.])
1325 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1326 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1328 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1329 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1332 for f in $host_xm_file; do
1335 if test $count = a; then
1337 elif test $count = ax; then
1338 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1340 echo "Using the following host machine macro files:"
1341 for f in $host_xm_file; do
1342 echo " $srcdir/config/$f"
1345 echo "Using ${out_host_hook_obj} for host machine hooks."
1347 if test "$host_xm_file" != "$build_xm_file"; then
1349 for f in $build_xm_file; do
1352 if test $count = a; then
1354 elif test $count = ax; then
1355 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1357 echo "Using the following build machine macro files:"
1358 for f in $build_xm_file; do
1359 echo " $srcdir/config/$f"
1364 if test -n "$configured_native_system_header_dir"; then
1365 native_system_header_dir=$configured_native_system_header_dir
1367 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1368 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1372 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1373 gcc_cv_mcontext_underscores,
1375 #include <sys/cdefs.h>
1376 #include <sys/signal.h>
1377 #include <ucontext.h>
1378 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1380 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1381 if test $gcc_cv_mcontext_underscores = yes; then
1382 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1383 [mcontext_t fields start with __])
1392 # Check if a valid thread package
1393 case ${enable_threads} in
1396 target_thread_file='single'
1400 target_thread_file='single'
1402 aix | dce | lynx | mipssde | posix | rtems | \
1403 single | tpf | vxworks | win32)
1404 target_thread_file=${enable_threads}
1407 echo "${enable_threads} is an unknown thread package" 1>&2
1412 if test x${thread_file} = x; then
1413 # No thread file set by target-specific clauses in config.gcc,
1414 # so use file chosen by default logic above
1415 thread_file=${target_thread_file}
1423 if test x$enable___cxa_atexit = xyes || \
1424 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1425 if test x$host = x$target; then
1427 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1428 # keyed to flag_use_cxa_atexit
1433 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1434 [echo "__cxa_atexit can't be enabled on this target"])
1438 # We can't check for __cxa_atexit when building a cross, so assume
1442 if test x$use_cxa_atexit = xyes; then
1443 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1444 [Define if you want to use __cxa_atexit, rather than atexit, to
1445 register C++ destructors for local statics and global objects.
1446 This is essential for fully standards-compliant handling of
1447 destructors, but requires __cxa_atexit in libc.])
1451 # Look for a file containing extra machine modes.
1452 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1453 extra_modes_file='$(srcdir)'/config/${extra_modes}
1454 AC_SUBST(extra_modes_file)
1455 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1456 [Define to the name of a file containing a list of extra machine modes
1457 for this architecture.])
1460 # Convert extra_options into a form suitable for Makefile use.
1463 for f in $extra_options; do
1464 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1465 all_opt_files="$all_opt_files $srcdir/config/$f"
1467 AC_SUBST(extra_opt_files)
1469 # auto-host.h is the file containing items generated by autoconf and is
1470 # the first file included by config.h.
1471 # If host=build, it is correct to have bconfig include auto-host.h
1472 # as well. If host!=build, we are in error and need to do more
1473 # work to find out the build config parameters.
1474 if test x$host = x$build
1476 build_auto=auto-host.h
1478 # We create a subdir, then run autoconf in the subdir.
1479 # To prevent recursion we set host and build for the new
1480 # invocation of configure to the build for this invocation
1487 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1488 *) realsrcdir=../${srcdir};;
1490 saved_CFLAGS="${CFLAGS}"
1491 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1492 LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1493 ${realsrcdir}/configure \
1494 --enable-languages=${enable_languages-all} \
1495 --target=$target_alias --host=$build_alias --build=$build_alias
1496 CFLAGS="${saved_CFLAGS}"
1498 # We just finished tests for the build machine, so rename
1499 # the file auto-build.h in the gcc directory.
1500 mv auto-host.h ../auto-build.h
1503 build_auto=auto-build.h
1505 AC_SUBST(build_subdir)
1507 tm_file="${tm_file} defaults.h"
1508 tm_p_file="${tm_p_file} tm-preds.h"
1509 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1510 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1511 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1512 # put this back in temporarily.
1513 xm_file="auto-host.h ansidecl.h ${xm_file}"
1520 # Compile in configure arguments.
1521 if test -f configargs.h ; then
1522 # Being re-configured.
1523 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1524 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1526 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1529 # Double all backslashes and backslash all quotes to turn
1530 # gcc_config_arguments into a C string.
1531 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1532 $gcc_config_arguments
1534 gcc_config_arguments_str=`cat conftest.out`
1537 cat > configargs.h <<EOF
1538 /* Generated automatically. */
1539 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1540 static const char thread_model[] = "$thread_file";
1542 static const struct {
1543 const char *name, *value;
1544 } configure_default_options[] = $configure_default_options;
1549 gcc_BASEVER=`cat $srcdir/BASE-VER`
1550 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1551 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1552 if test -f $srcdir/REVISION ; then
1553 gcc_REVISION=`cat $srcdir/REVISION`
1557 cat > plugin-version.h <<EOF
1558 #include "configargs.h"
1560 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1561 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1562 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1563 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1565 static char basever[] = "$gcc_BASEVER";
1566 static char datestamp[] = "$gcc_DATESTAMP";
1567 static char devphase[] = "$gcc_DEVPHASE";
1568 static char revision[] = "$gcc_REVISION";
1570 /* FIXME plugins: We should make the version information more precise.
1571 One way to do is to add a checksum. */
1573 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1575 configuration_arguments};
1579 # Internationalization
1580 ZW_GNU_GETTEXT_SISTER_DIR
1582 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1583 # -liconv on the link line twice.
1584 case "$LIBINTL" in *$LIBICONV*)
1588 AC_ARG_ENABLE(secureplt,
1589 [AS_HELP_STRING([--enable-secureplt],
1590 [enable -msecure-plt by default for PowerPC])],
1593 AC_ARG_ENABLE(leading-mingw64-underscores,
1594 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1595 [enable leading underscores on 64 bit mingw targets]),
1597 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1598 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1599 [Define if we should use leading underscore on 64 bit mingw targets])])
1602 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1605 AC_ARG_ENABLE(frame-pointer,
1606 [AS_HELP_STRING([--enable-frame-pointer],
1607 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1610 linux* | darwin[[8912]]*)
1611 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1613 enable_frame_pointer=no
1616 enable_frame_pointer=yes
1621 # Windows32 Registry support for specifying GCC installation paths.
1622 AC_ARG_ENABLE(win32-registry,
1623 [AS_HELP_STRING([--disable-win32-registry],
1624 [disable lookup of installation paths in the
1625 Registry on Windows hosts])
1626 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1627 AS_HELP_STRING([--enable-win32-registry=KEY],
1628 [use KEY instead of GCC version as the last portion
1629 of the registry key])],,)
1632 win32 | pe | cygwin* | mingw32* | uwin*)
1633 if test "x$enable_win32_registry" != xno; then
1634 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1637 if test "x$enable_win32_registry" != xno; then
1638 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1639 [Define to 1 if installation paths should be looked up in the Windows
1640 Registry. Ignored on non-Windows hosts.])
1642 if test "x$enable_win32_registry" != xyes \
1643 && test "x$enable_win32_registry" != x; then
1644 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1645 [Define to be the last component of the Windows registry key under which
1646 to look for installation paths. The full key used will be
1647 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1648 The default is the GCC version number.])
1654 # Get an absolute path to the GCC top-level source directory
1655 holddir=`${PWDCMD-pwd}`
1657 topdir=`${PWDCMD-pwd}`
1660 # Conditionalize the makefile for this host machine.
1662 for f in ${host_xmake_file}
1664 if test -f ${srcdir}/config/$f
1666 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1670 # Conditionalize the makefile for this target machine.
1672 for f in ${tmake_file}
1674 if test -f ${srcdir}/config/$f
1676 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1679 tmake_file="${tmake_file_}"
1681 out_object_file=`basename $out_file .c`.o
1682 common_out_object_file=`basename $common_out_file .c`.o
1684 tm_file_list="options.h"
1685 tm_include_list="options.h insn-constants.h"
1686 for f in $tm_file; do
1689 f=`echo $f | sed 's/^..//'`
1690 tm_file_list="${tm_file_list} $f"
1691 tm_include_list="${tm_include_list} $f"
1694 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1695 tm_include_list="${tm_include_list} $f"
1698 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1699 tm_include_list="${tm_include_list} config/$f"
1706 for f in $tm_p_file; do
1709 tm_p_file_list="${tm_p_file_list} $f"
1710 tm_p_include_list="${tm_p_include_list} $f"
1713 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1714 tm_p_include_list="${tm_p_include_list} config/$f"
1720 for f in $xm_file; do
1723 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1724 xm_include_list="${xm_include_list} $f"
1727 xm_file_list="${xm_file_list} $f"
1728 xm_include_list="${xm_include_list} $f"
1731 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1732 xm_include_list="${xm_include_list} config/$f"
1738 host_xm_include_list=
1739 for f in $host_xm_file; do
1742 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1743 host_xm_include_list="${host_xm_include_list} $f"
1746 host_xm_file_list="${host_xm_file_list} $f"
1747 host_xm_include_list="${host_xm_include_list} $f"
1750 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1751 host_xm_include_list="${host_xm_include_list} config/$f"
1757 for f in $build_xm_file; do
1760 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1761 build_xm_include_list="${build_xm_include_list} $f"
1763 auto-build.h | auto-host.h )
1764 build_xm_file_list="${build_xm_file_list} $f"
1765 build_xm_include_list="${build_xm_include_list} $f"
1768 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1769 build_xm_include_list="${build_xm_include_list} config/$f"
1774 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1775 # cross-compiler which does not use the native headers and libraries.
1776 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1777 CROSS= AC_SUBST(CROSS)
1778 ALL=all.internal AC_SUBST(ALL)
1779 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1781 if test "x$with_build_sysroot" != x; then
1782 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1784 # This value is used, even on a native system, because
1785 # CROSS_SYSTEM_HEADER_DIR is just
1786 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1787 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1790 if test x$host != x$target
1792 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1794 SYSTEM_HEADER_DIR=$build_system_header_dir
1795 case "$host","$target" in
1796 # Darwin crosses can use the host system's libraries and headers,
1797 # because of the fat library support. Of course, it must be the
1798 # same version of Darwin on both sides. Allow the user to
1799 # just say --target=foo-darwin without a version number to mean
1800 # "the version on this system".
1801 *-*-darwin*,*-*-darwin*)
1802 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1803 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1804 if test $hostos = $targetos -o $targetos = darwin ; then
1806 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1811 i?86-*-*,x86_64-*-* \
1812 | powerpc*-*-*,powerpc64*-*-*)
1813 CROSS="$CROSS -DNATIVE_CROSS" ;;
1818 if test "x$with_headers" = x; then
1825 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1826 SYSTEM_HEADER_DIR=$build_system_header_dir
1829 # If this is a cross-compiler that does not
1830 # have its own set of headers then define
1833 # If this is using newlib, without having the headers available now,
1834 # then define inhibit_libc in LIBGCC2_CFLAGS.
1835 # This prevents libgcc2 from containing any code which requires libc
1837 : ${inhibit_libc=false}
1838 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1839 test x$with_newlib = xyes ; } &&
1840 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1843 AC_SUBST(inhibit_libc)
1845 # When building gcc with a cross-compiler, we need to adjust things so
1846 # that the generator programs are still built with the native compiler.
1847 # Also, we cannot run fixincludes.
1849 # These are the normal (build=host) settings:
1850 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1851 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1852 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1853 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1854 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1855 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1857 # And these apply if build != host, or we are generating coverage data
1858 if test x$build != x$host || test "x$coverage_flags" != x
1860 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1861 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1864 # Expand extra_headers to include complete path.
1865 # This substitutes for lots of t-* files.
1867 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1868 for file in ${extra_headers} ; do
1869 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1872 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1873 if test x"$use_gcc_tgmath" = xyes
1874 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1877 # Define collect2 in Makefile.
1878 case $host_can_use_collect2 in
1880 *) collect2='collect2$(exeext)' ;;
1882 AC_SUBST([collect2])
1884 # Add a definition of USE_COLLECT2 if system wants one.
1885 case $use_collect2 in
1886 no) use_collect2= ;;
1889 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1890 xm_defines="${xm_defines} USE_COLLECT2"
1891 case $host_can_use_collect2 in
1893 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1899 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1900 [Define to the name of the LTO plugin DSO that must be
1901 passed to the linker's -plugin=LIB option.])
1903 # ---------------------------
1904 # Assembler & linker features
1905 # ---------------------------
1907 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1908 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1909 # However when ld-new is first executed from the build tree, libtool will
1910 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1911 # to the build tree. While doing this we need to use the previous-stage
1912 # linker, or we have an infinite loop. The presence of a shell script as
1913 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1914 # the gcc/collect-ld script. So we need to know how libtool works, or
1915 # exec-tool will fail.
1917 m4_defun([_LT_CONFIG_COMMANDS], [])
1920 AC_SUBST(enable_fast_install)
1922 # Identify the assembler which will work hand-in-glove with the newly
1923 # built GCC, so that we can examine its features. This is the assembler
1924 # which will be driven by the driver program.
1926 # If build != host, and we aren't building gas in-tree, we identify a
1927 # build->target assembler and hope that it will have the same features
1928 # as the host->target assembler we'll be using.
1929 gcc_cv_gas_major_version=
1930 gcc_cv_gas_minor_version=
1931 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1933 m4_pattern_allow([AS_FOR_TARGET])dnl
1934 AS_VAR_SET_IF(gcc_cv_as,, [
1935 if test -x "$DEFAULT_ASSEMBLER"; then
1936 gcc_cv_as="$DEFAULT_ASSEMBLER"
1937 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1938 && test -f ../gas/Makefile \
1939 && test x$build = x$host; then
1940 gcc_cv_as=../gas/as-new$build_exeext
1941 elif test -x as$build_exeext; then
1942 # Build using assembler in the current directory.
1943 gcc_cv_as=./as$build_exeext
1944 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
1945 gcc_cv_as="$AS_FOR_TARGET"
1947 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1950 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1951 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1952 case "$ORIGINAL_AS_FOR_TARGET" in
1953 ./as | ./as$build_exeext) ;;
1954 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1957 AC_MSG_CHECKING(what assembler to use)
1958 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1959 # Single tree build which includes gas. We want to prefer it
1960 # over whatever linker top-level may have detected, since
1961 # we'll use what we're building after installation anyway.
1962 AC_MSG_RESULT(newly built gas)
1964 _gcc_COMPUTE_GAS_VERSION
1965 in_tree_gas_is_elf=no
1966 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1967 || (grep 'obj_format = multi' ../gas/Makefile \
1968 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1970 in_tree_gas_is_elf=yes
1973 AC_MSG_RESULT($gcc_cv_as)
1977 # Identify the linker which will work hand-in-glove with the newly
1978 # built GCC, so that we can examine its features. This is the linker
1979 # which will be driven by the driver program.
1981 # If build != host, and we aren't building gas in-tree, we identify a
1982 # build->target linker and hope that it will have the same features
1983 # as the host->target linker we'll be using.
1984 gcc_cv_gld_major_version=
1985 gcc_cv_gld_minor_version=
1986 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1987 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1989 AS_VAR_SET_IF(gcc_cv_ld,, [
1990 if test -x "$DEFAULT_LINKER"; then
1991 gcc_cv_ld="$DEFAULT_LINKER"
1992 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1993 && test -f ../ld/Makefile \
1994 && test x$build = x$host; then
1995 gcc_cv_ld=../ld/ld-new$build_exeext
1996 elif test -x collect-ld$build_exeext; then
1997 # Build using linker in the current directory.
1998 gcc_cv_ld=./collect-ld$build_exeext
1999 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2000 gcc_cv_ld="$LD_FOR_TARGET"
2002 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2005 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2006 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2007 AC_ARG_WITH(plugin-ld,
2008 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2009 [if test x"$withval" != x; then
2010 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2011 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2013 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2014 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2016 # Check to see if we are using gold instead of ld
2017 AC_MSG_CHECKING(whether we are using gold)
2019 if test x$gcc_cv_ld != x; then
2020 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2021 | grep "GNU gold" > /dev/null; then
2025 AC_MSG_RESULT($ld_is_gold)
2027 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2028 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2029 case "$ORIGINAL_LD_FOR_TARGET" in
2030 ./collect-ld | ./collect-ld$build_exeext) ;;
2031 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2034 AC_MSG_CHECKING(what linker to use)
2035 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2036 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2037 # Single tree build which includes ld. We want to prefer it
2038 # over whatever linker top-level may have detected, since
2039 # we'll use what we're building after installation anyway.
2040 AC_MSG_RESULT(newly built ld)
2042 in_tree_ld_is_elf=no
2043 if (grep 'EMUL = .*elf' ../ld/Makefile \
2044 || grep 'EMUL = .*linux' ../ld/Makefile \
2045 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2046 in_tree_ld_is_elf=yes
2047 elif test "$ld_is_gold" = yes; then
2048 in_tree_ld_is_elf=yes
2050 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
2053 gcc_cv_gld_version=`sed -n -e 's/^[ ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
2054 if test x$gcc_cv_gld_version != x; then
2058 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2059 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2062 AC_MSG_RESULT($gcc_cv_ld)
2066 # Figure out what nm we will be using.
2067 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2068 AS_VAR_SET_IF(gcc_cv_nm,, [
2069 if test -f $gcc_cv_binutils_srcdir/configure.in \
2070 && test -f ../binutils/Makefile \
2071 && test x$build = x$host; then
2072 gcc_cv_nm=../binutils/nm-new$build_exeext
2073 elif test -x nm$build_exeext; then
2074 gcc_cv_nm=./nm$build_exeext
2075 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2076 gcc_cv_nm="$NM_FOR_TARGET"
2078 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2081 AC_MSG_CHECKING(what nm to use)
2082 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2083 # Single tree build which includes binutils.
2084 AC_MSG_RESULT(newly built nm)
2087 AC_MSG_RESULT($gcc_cv_nm)
2091 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2092 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2093 case "$ORIGINAL_NM_FOR_TARGET" in
2094 ./nm | ./nm$build_exeext) ;;
2095 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2099 # Figure out what objdump we will be using.
2100 AS_VAR_SET_IF(gcc_cv_objdump,, [
2101 if test -f $gcc_cv_binutils_srcdir/configure.in \
2102 && test -f ../binutils/Makefile \
2103 && test x$build = x$host; then
2104 # Single tree build which includes binutils.
2105 gcc_cv_objdump=../binutils/objdump$build_exeext
2106 elif test -x objdump$build_exeext; then
2107 gcc_cv_objdump=./objdump$build_exeext
2108 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2109 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2111 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2114 AC_MSG_CHECKING(what objdump to use)
2115 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2116 # Single tree build which includes binutils.
2117 AC_MSG_RESULT(newly built objdump)
2118 elif test x$gcc_cv_objdump = x; then
2119 AC_MSG_RESULT(not found)
2121 AC_MSG_RESULT($gcc_cv_objdump)
2124 # Figure out what readelf we will be using.
2125 AS_VAR_SET_IF(gcc_cv_readelf,, [
2126 if test -f $gcc_cv_binutils_srcdir/configure.in \
2127 && test -f ../binutils/Makefile \
2128 && test x$build = x$host; then
2129 # Single tree build which includes binutils.
2130 gcc_cv_readelf=../binutils/readelf$build_exeext
2131 elif test -x readelf$build_exeext; then
2132 gcc_cv_readelf=./readelf$build_exeext
2134 AC_PATH_PROG(gcc_cv_readelf, readelf)
2137 AC_MSG_CHECKING(what readelf to use)
2138 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2139 # Single tree build which includes binutils.
2140 AC_MSG_RESULT(newly built readelf)
2141 elif test x$gcc_cv_readelf = x; then
2142 AC_MSG_RESULT(not found)
2144 AC_MSG_RESULT($gcc_cv_readelf)
2147 # Figure out what assembler alignment features are present.
2148 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2152 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2153 [Define if your assembler supports .balign and .p2align.])])
2155 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2158 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2159 [Define if your assembler supports specifying the maximum number
2160 of bytes to skip when using the GAS .p2align command.])])
2162 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2165 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2166 [Define if your assembler supports .literal16.])])
2168 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2170 [conftest_label1: .word 0
2172 conftest_label2: .word 0
2174 [if test x$gcc_cv_nm != x; then
2175 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2176 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2177 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2179 else gcc_cv_as_subsection_m1=yes
2181 rm -f conftest.nm1 conftest.nm2
2183 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2184 [Define if your assembler supports .subsection and .subsection -1 starts
2185 emitting at the beginning of your section.])])
2187 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2190 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2192 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2194 [ .weakref foobar, barfnot],,
2195 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2197 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2200 .NSUBSPA $CODE$,COMDAT],,
2201 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2203 # .hidden needs to be supported in both the assembler and the linker,
2204 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2205 # This is irritatingly difficult to feature test for; we have to check the
2206 # date string after the version number. If we've got an in-tree
2207 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2209 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2210 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2214 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2215 # STV_HIDDEN, so disable .hidden support if so.
2217 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2218 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2219 cat > conftest.s <<EOF
2226 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2227 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2228 grep '\.hidden default' > /dev/null; then
2231 gcc_cv_as_hidden=yes
2234 # Assume bug is present if objdump is missing.
2239 gcc_cv_as_hidden=yes
2244 # Darwin as has some visibility support, though with a different syntax.
2245 gcc_cv_as_hidden=yes
2249 # gnu_indirect_function type is an extension proposed at
2250 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2251 # selection of function implementation
2252 AC_ARG_ENABLE(gnu-indirect-function,
2253 [AS_HELP_STRING([--enable-gnu-indirect-function],
2254 [enable the use of the @gnu_indirect_function to glibc systems])],
2255 [case $enable_gnu_indirect_function in
2257 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2258 Valid choices are 'yes' and 'no'.]) ;;
2260 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2261 if test x$enable_gnu_indirect_function = xyes; then
2262 AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2263 [Define if your system supports gnu indirect functions.])
2267 if test $in_tree_ld != yes ; then
2268 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2269 if echo "$ld_ver" | grep GNU > /dev/null; then
2270 if test x"$ld_is_gold" = xyes; then
2271 # GNU gold --version looks like this:
2273 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2275 # We extract the binutils version which is more familiar and specific
2276 # than the gold version.
2277 ld_vers=`echo $ld_ver | sed -n \
2278 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2280 # GNU ld --version looks like this:
2282 # GNU ld (GNU Binutils) 2.21.51.20110225
2283 ld_vers=`echo $ld_ver | sed -n \
2284 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2286 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'`
2287 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2288 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2289 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2293 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2296 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2297 # /usr/ccs/bin/ld has been configured.
2298 ld_ver=`$gcc_cv_ld -V 2>&1`
2299 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2300 ld_vers=`echo $ld_ver | sed -n \
2301 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2302 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2303 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2311 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2312 [[if test $in_tree_ld = yes ; then
2314 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 \
2315 && test $in_tree_ld_is_elf = yes; then
2316 gcc_cv_ld_hidden=yes
2319 gcc_cv_ld_hidden=yes
2320 if test x"$ld_is_gold" = xyes; then
2322 elif echo "$ld_ver" | grep GNU > /dev/null; then
2323 if test 0"$ld_date" -lt 20020404; then
2324 if test -n "$ld_date"; then
2325 # If there was date string, but was earlier than 2002-04-04, fail
2327 elif test -z "$ld_vers"; then
2328 # If there was no date string nor ld version number, something is wrong
2331 test -z "$ld_vers_patch" && ld_vers_patch=0
2332 if test "$ld_vers_major" -lt 2; then
2334 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2335 gcc_cv_ld_hidden="no"
2336 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2344 # Darwin ld has some visibility support.
2345 gcc_cv_ld_hidden=yes
2347 hppa64*-*-hpux* | ia64*-*-hpux*)
2348 gcc_cv_ld_hidden=yes
2350 *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2351 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2352 # .symbolic was only added in Solaris 9 12/02.
2353 gcc_cv_ld_hidden=yes
2361 libgcc_visibility=no
2362 AC_SUBST(libgcc_visibility)
2363 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2364 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2365 libgcc_visibility=yes
2366 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2367 [Define if your assembler and linker support .hidden.])
2370 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2371 gcc_cv_ld_ro_rw_mix=unknown
2372 if test $in_tree_ld = yes ; then
2373 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 \
2374 && test $in_tree_ld_is_elf = yes; then
2375 gcc_cv_ld_ro_rw_mix=read-write
2377 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2378 echo '.section myfoosect, "a"' > conftest1.s
2379 echo '.section myfoosect, "aw"' > conftest2.s
2380 echo '.byte 1' >> conftest2.s
2381 echo '.section myfoosect, "a"' > conftest3.s
2382 echo '.byte 0' >> conftest3.s
2383 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2384 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2385 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2386 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2387 conftest2.o conftest3.o > /dev/null 2>&1; then
2388 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2389 | sed -e '/myfoosect/!d' -e N`
2390 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2391 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2392 gcc_cv_ld_ro_rw_mix=read-only
2394 gcc_cv_ld_ro_rw_mix=read-write
2399 rm -f conftest.* conftest[123].*
2402 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2403 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2404 [Define if your linker links a mix of read-only
2405 and read-write sections into a read-write section.])
2407 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2409 gcc_AC_INITFINI_ARRAY
2411 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2412 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2420 [[# GAS versions before 2.11 do not support uleb128,
2421 # despite appearing to.
2422 # ??? There exists an elf-specific test that will crash
2423 # the assembler. Perhaps it's better to figure out whether
2424 # arbitrary sections are supported and try the test.
2425 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2426 if echo "$as_ver" | grep GNU > /dev/null; then
2427 as_vers=`echo $as_ver | sed -n \
2428 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2429 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2430 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2431 if test $as_major -eq 2 && test $as_minor -lt 11
2433 else gcc_cv_as_leb128=yes
2436 [AC_DEFINE(HAVE_AS_LEB128, 1,
2437 [Define if your assembler supports .sleb128 and .uleb128.])])
2439 # Check if we have assembler support for unwind directives.
2440 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2447 .cfi_escape 1, 2, 3, 4, 5
2451 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2452 # read-only and read-write sections, we need to make sure that the
2453 # assembler used emits read-write .eh_frame sections.
2454 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2455 if test "x$gcc_cv_objdump" != x; then
2456 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2457 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2458 gcc_cv_as_cfi_directive=no
2461 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2462 # On Solaris/x86, make sure that GCC and gas agree on using
2463 # read-only .eh_frame sections for 64-bit.
2464 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2465 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2466 sed -e /.eh_frame/!d -e N | \
2467 grep READONLY > /dev/null; then
2468 gcc_cv_as_cfi_directive=yes
2470 gcc_cv_as_cfi_directive=no
2474 gcc_cv_as_cfi_directive=yes
2479 # no objdump, err on the side of caution
2480 gcc_cv_as_cfi_directive=no
2483 gcc_cv_as_cfi_directive=yes
2487 gcc_cv_as_cfi_directive=yes
2490 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2491 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2495 .cfi_adjust_cfa_offset 64
2497 .cfi_adjust_cfa_offset 128
2500 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2501 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2502 gcc_cv_as_cfi_advance_working=yes
2506 # no objdump, err on the side of caution
2507 gcc_cv_as_cfi_advance_working=no
2509 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2510 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2511 [`if test $gcc_cv_as_cfi_directive = yes \
2512 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2513 [Define 0/1 if your assembler supports CFI directives.])
2515 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2516 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2517 gcc_cv_as_cfi_personality_directive, ,,
2520 .cfi_personality 0, symbol
2522 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2523 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2524 then echo 1; else echo 0; fi`],
2525 [Define 0/1 if your assembler supports .cfi_personality.])
2527 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2528 gcc_cv_as_cfi_sections_directive, ,,
2530 .cfi_sections .debug_frame, .eh_frame
2534 win32 | pe | cygwin* | mingw32* | uwin*)
2535 # Need to check that we generated the correct relocation for the
2536 # .debug_frame section. This was fixed for binutils 2.21.
2537 gcc_cv_as_cfi_sections_directive=no
2538 if test "x$gcc_cv_objdump" != x; then
2539 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2540 grep secrel > /dev/null; then
2541 gcc_cv_as_cfi_sections_directive=yes
2546 gcc_cv_as_cfi_sections_directive=yes
2549 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2550 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2551 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2552 then echo 1; else echo 0; fi`],
2553 [Define 0/1 if your assembler supports .cfi_sections.])
2555 # GAS versions up to and including 2.11.0 may mis-optimize
2557 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2565 .section .eh_frame,"aw",@progbits
2567 .4byte .LECIE1-.LSCIE1
2581 .4byte .LEFDE1-.LASFDE1
2583 .4byte .LASFDE1-__FRAME_BEGIN__
2591 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2592 cat > conftest.lit <<EOF
2593 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2594 0010 01000000 12000000 18000000 00000000 ................
2595 0020 08000000 04080000 0044 .........D @&t@
2597 cat > conftest.big <<EOF
2598 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2599 0010 00000001 00000012 00000018 00000000 ................
2600 0020 00000008 04000000 0844 .........D @&t@
2602 # If the assembler didn't choke, and we can objdump,
2603 # and we got the correct data, then succeed.
2604 # The text in the here-document typically retains its unix-style line
2605 # endings, while the output of objdump will use host line endings.
2606 # Therefore, use diff -b for the comparisons.
2607 if test x$gcc_cv_objdump != x \
2608 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2609 | tail -3 > conftest.got \
2610 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2611 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2613 gcc_cv_as_eh_frame=yes
2614 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2615 gcc_cv_as_eh_frame=buggy
2617 # Uh oh, what do we do now?
2618 gcc_cv_as_eh_frame=no
2621 if test $gcc_cv_as_eh_frame = buggy; then
2622 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2623 [Define if your assembler mis-optimizes .eh_frame data.])
2626 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2627 [elf,2,12,0], [--fatal-warnings],
2628 [.section .rodata.str, "aMS", @progbits, 1])
2629 if test $gcc_cv_as_shf_merge = no; then
2630 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2631 [elf,2,12,0], [--fatal-warnings],
2632 [.section .rodata.str, "aMS", %progbits, 1])
2634 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2635 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2636 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2638 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2639 gcc_cv_as_comdat_group,
2640 [elf,2,16,0], [--fatal-warnings],
2641 [.section .text,"axG",@progbits,.foo,comdat])
2642 if test $gcc_cv_as_comdat_group = yes; then
2643 gcc_cv_as_comdat_group_percent=no
2644 gcc_cv_as_comdat_group_group=no
2646 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2647 gcc_cv_as_comdat_group_percent,
2648 [elf,2,16,0], [--fatal-warnings],
2649 [.section .text,"axG",%progbits,.foo,comdat])
2650 if test $gcc_cv_as_comdat_group_percent = yes; then
2651 gcc_cv_as_comdat_group_group=no
2654 # Sun as uses a completely different syntax.
2659 .group foo,".text%foo",#comdat
2660 .section ".text%foo", #alloc,#execinstr,#progbits
2665 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2667 .group foo,.text%foo,#comdat
2668 .section .text%foo, "ax", @progbits
2674 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2675 gcc_cv_as_comdat_group_group,
2681 if test x"$ld_is_gold" = xyes; then
2683 elif test $in_tree_ld = yes ; then
2685 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 \
2686 && test $in_tree_ld_is_elf = yes; then
2689 elif echo "$ld_ver" | grep GNU > /dev/null; then
2691 if test 0"$ld_date" -lt 20050308; then
2692 if test -n "$ld_date"; then
2693 # If there was date string, but was earlier than 2005-03-08, fail
2695 elif test "$ld_vers_major" -lt 2; then
2697 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2704 *-*-solaris2.1[1-9]*)
2706 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2707 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2710 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2711 # least ld version 1.2267.
2712 if test "$ld_vers_major" -gt 1; then
2714 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2716 elif test "$ld_vers_minor" -ge 2267; then
2721 # Assume linkers other than GNU ld don't support COMDAT group.
2727 # Allow overriding the automatic COMDAT group tests above.
2728 AC_ARG_ENABLE(comdat,
2729 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2730 [comdat_group="$enable_comdat"])
2731 if test $comdat_group = no; then
2732 gcc_cv_as_comdat_group=no
2733 gcc_cv_as_comdat_group_percent=no
2734 gcc_cv_as_comdat_group_group=no
2736 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2737 [`if test $gcc_cv_as_comdat_group = yes \
2738 || test $gcc_cv_as_comdat_group_percent = yes \
2739 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2740 [Define 0/1 if your assembler and linker support COMDAT groups.])
2742 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2743 gcc_cv_as_discriminator,
2747 .loc 1 1 0 discriminator 1],,
2748 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2749 [Define if your assembler supports the .loc discriminator sub-directive.])])
2751 # Thread-local storage - the check is heavily parameterized.
2760 .section ".tdata","awT",@progbits
2763 ldq $27,__tls_get_addr($29) !literal!1
2764 lda $16,foo($29) !tlsgd!1
2765 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2766 ldq $27,__tls_get_addr($29) !literal!2
2767 lda $16,foo($29) !tlsldm!2
2768 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2769 ldq $1,foo($29) !gotdtprel
2770 ldah $2,foo($29) !dtprelhi
2771 lda $3,foo($2) !dtprello
2772 lda $4,foo($29) !dtprel
2773 ldq $1,foo($29) !gottprel
2774 ldah $2,foo($29) !tprelhi
2775 lda $3,foo($2) !tprello
2776 lda $4,foo($29) !tprel'
2779 tls_as_opt=--fatal-warnings
2781 cris-*-*|crisv32-*-*)
2783 .section ".tdata","awT",@progbits
2790 tls_as_opt=--fatal-warnings
2794 .section ".tdata","awT",@progbits
2806 .section ".tdata","awT",@progbits
2810 addil LT%foo-$tls_gdidx$,gp
2811 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2814 addil LT%foo-$tls_ldidx$,gp
2816 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2817 addil LR%foo-$tls_dtpoff$,%ret0
2818 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2820 addil LT%foo-$tls_ieoff$,gp
2821 ldw RT%foo-$tls_ieoff$(%r1),%t2
2824 addil LR%foo-$tls_leoff$,%t1
2825 ldo RR%foo-$tls_leoff$(%r1),%t2'
2828 tls_as_opt=--fatal-warnings
2832 .section ".tdata","awT",%progbits
2843 i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*)
2845 i[34567]86-*-solaris2.*)
2847 tga_func=___tls_get_addr
2849 x86_64-*-solaris2.1[0-9]*)
2851 tga_func=__tls_get_addr
2857 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2859 .section .tdata,"awt",@progbits'
2863 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2864 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2868 .section ".tdata","awT",@progbits'
2871 tls_as_opt="--fatal-warnings"
2873 conftest_s="$conftest_s
2877 leal foo@tlsgd(,%ebx,1), %eax
2878 leal foo@tlsldm(%ebx), %eax
2879 leal foo@dtpoff(%eax), %edx
2880 movl foo@gottpoff(%ebx), %eax
2881 subl foo@gottpoff(%ebx), %eax
2882 addl foo@gotntpoff(%ebx), %eax
2883 movl foo@indntpoff, %eax
2884 movl \$foo@tpoff, %eax
2885 subl \$foo@tpoff, %eax
2886 leal foo@ntpoff(%ecx), %eax"
2890 .section ".tdata","awT",@progbits
2894 leaq foo@TLSGD(%rip), %rdi
2895 leaq foo@TLSLD(%rip), %rdi
2896 leaq foo@DTPOFF(%rax), %rdx
2897 movq foo@GOTTPOFF(%rip), %rax
2898 movq $foo@TPOFF, %rax'
2901 tls_as_opt=--fatal-warnings
2905 .section ".tdata","awT",@progbits
2908 addl r16 = @ltoff(@dtpmod(foo#)), gp
2909 addl r17 = @ltoff(@dtprel(foo#)), gp
2910 addl r18 = @ltoff(@tprel(foo#)), gp
2911 addl r19 = @dtprel(foo#), gp
2912 adds r21 = @dtprel(foo#), r13
2913 movl r23 = @dtprel(foo#)
2914 addl r20 = @tprel(foo#), gp
2915 adds r22 = @tprel(foo#), r13
2916 movl r24 = @tprel(foo#)'
2919 tls_as_opt=--fatal-warnings
2923 .section .tdata,"awT",@progbits
2927 addiu $4, $28, %tlsgd(x)
2928 addiu $4, $28, %tlsldm(x)
2929 lui $4, %dtprel_hi(x)
2930 addiu $4, $4, %dtprel_lo(x)
2931 lw $4, %gottprel(x)($28)
2932 lui $4, %tprel_hi(x)
2933 addiu $4, $4, %tprel_lo(x)'
2936 tls_as_opt='-32 --fatal-warnings'
2940 .section .tdata,"awT",@progbits
2945 move.l x@TLSGD(%a5),%a0
2946 move.l x@TLSLDM(%a5),%a0
2947 move.l x@TLSLDO(%a5),%a0
2948 move.l x@TLSIE(%a5),%a0
2949 move.l x@TLSLE(%a5),%a0'
2952 tls_as_opt='--fatal-warnings'
2956 .section ".tdata","awT",@progbits
2964 addi 3,31,ld0@got@tlsgd
2966 addi 3,31,x1@got@tlsld
2969 addis 9,3,x2@dtprel@ha
2970 addi 9,9,x2@dtprel@l
2971 lwz 9,x3@got@tprel(31)
2974 addis 9,2,x2@tprel@ha
2975 addi 9,9,x2@tprel@l'
2978 tls_as_opt="-a32 --fatal-warnings"
2982 .section ".tdata","awT",@progbits
2990 addi 3,2,ld0@got@tlsgd
2996 addi 3,2,x1@got@tlsld
3002 addis 9,3,x2@dtprel@ha
3003 addi 9,9,x2@dtprel@l
3006 ld 9,x3@got@dtprel(2)
3012 tls_as_opt="-a64 --fatal-warnings"
3016 .section ".tdata","awT",@progbits
3025 l %r1,foo@GOTNTPOFF(%r12)
3026 l %r1,0(%r1):tls_load:foo
3027 bas %r14,0(%r1,%r13):tls_gdcall:foo
3028 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3031 tls_as_opt="-m31 --fatal-warnings"
3035 .section ".tdata","awT",@progbits
3043 lg %r1,foo@GOTNTPOFF(%r12)
3044 larl %r1,foo@INDNTPOFF
3045 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3046 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3049 tls_as_opt="-m64 -Aesame --fatal-warnings"
3051 sh-*-* | sh[34]-*-*)
3053 .section ".tdata","awT",@progbits
3063 tls_as_opt=--fatal-warnings
3067 sparc*-sun-solaris2.*)
3069 tga_func=__tls_get_addr
3075 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3077 .section ".tdata",#alloc,#write,#tls'
3082 .section ".tdata","awT",@progbits'
3085 tls_as_opt="-32 --fatal-warnings"
3087 conftest_s="$conftest_s
3090 sethi %tgd_hi22(foo), %o0
3091 add %o0, %tgd_lo10(foo), %o1
3092 add %l7, %o1, %o0, %tgd_add(foo)
3093 call __tls_get_addr, %tgd_call(foo)
3094 sethi %tldm_hi22(foo), %l1
3095 add %l1, %tldm_lo10(foo), %l2
3096 add %l7, %l2, %o0, %tldm_add(foo)
3097 call __tls_get_addr, %tldm_call(foo)
3098 sethi %tldo_hix22(foo), %l3
3099 xor %l3, %tldo_lox10(foo), %l4
3100 add %o0, %l4, %l5, %tldo_add(foo)
3101 sethi %tie_hi22(foo), %o3
3102 add %o3, %tie_lo10(foo), %o3
3103 ld [%l7 + %o3], %o2, %tie_ld(foo)
3104 add %g7, %o2, %o4, %tie_add(foo)
3105 sethi %tle_hix22(foo), %l1
3106 xor %l1, %tle_lox10(foo), %o5
3107 ld [%g7 + %o5], %o1"
3111 .section ".tdata","awT",@progbits
3114 addli r0, zero, tls_gd(foo)
3115 auli r0, zero, tls_gd_ha16(foo)
3116 addli r0, r0, tls_gd_lo16(foo)
3118 addli r0, zero, tls_ie(foo)
3119 auli r0, r0, tls_ie_ha16(foo)
3120 addli r0, r0, tls_ie_lo16(foo)'
3123 tls_as_opt="--fatal-warnings"
3127 .section ".tdata","awT",@progbits
3130 shl16insli r0, zero, hw0_last_tls_gd(foo)
3131 shl16insli r0, zero, hw1_last_tls_gd(foo)
3132 shl16insli r0, r0, hw0_tls_gd(foo)
3134 shl16insli r0, zero, hw1_last_tls_ie(foo)
3135 shl16insli r0, r0, hw0_tls_ie(foo)'
3138 tls_as_opt="--fatal-warnings"
3142 .section ".tdata","awT",@progbits
3145 movi a8, foo@TLSFUNC
3146 movi a10, foo@TLSARG
3147 callx8.tls a8, foo@TLSCALL'
3154 if test "x$enable_tls" = xno ; then
3155 : # TLS explicitly disabled.
3156 elif test "x$enable_tls" = xyes ; then
3157 set_have_as_tls=yes # TLS explicitly enabled.
3158 elif test -z "$tls_first_major"; then
3159 : # If we don't have a check, assume no support.
3161 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3162 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3163 [set_have_as_tls=yes])
3166 # TLS was introduced in the Solaris 9 FCS release. Support for GNU-style
3167 # TLS on x86 was only introduced in Solaris 9 4/04, replacing the earlier
3168 # Sun style that Sun ld and GCC don't support any longer.
3170 AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3172 # Check ld and ld.so.1 TLS support.
3173 if echo "$ld_ver" | grep GNU > /dev/null; then
3174 # Assume all interesting versions of GNU ld have TLS support.
3175 # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3179 # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3181 min_tls_ld_vers_minor=374
3183 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3184 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3185 min_tls_ld_vers_minor=343
3188 if test "$ld_vers_major" -gt 1 || \
3189 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3195 AC_MSG_RESULT($ld_tls_support)
3198 save_LDFLAGS="$LDFLAGS"
3202 AC_MSG_CHECKING(library containing $tga_func)
3203 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3204 # (32-bit x86) only lived in libthread, so check for that. Keep
3205 # set_have_as_tls if found, disable if not.
3206 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3207 # Clear LIBS if we cannot support TLS.
3208 if test $set_have_as_tls = no; then
3211 # Always define LIB_TLS_SPEC, even without TLS support.
3212 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3213 [Define to the library containing __tls_get_addr/___tls_get_addr.])
3214 AC_MSG_RESULT($LIBS)
3217 LDFLAGS="$save_LDFLAGS"
3220 if test $set_have_as_tls = yes ; then
3221 AC_DEFINE(HAVE_AS_TLS, 1,
3222 [Define if your assembler and linker support thread-local storage.])
3225 # Target-specific assembler checks.
3227 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3228 gcc_cv_ld_static_dynamic=no
3229 gcc_cv_ld_static_option='-Bstatic'
3230 gcc_cv_ld_dynamic_option='-Bdynamic'
3231 if test $in_tree_ld = yes ; then
3232 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
3233 gcc_cv_ld_static_dynamic=yes
3235 elif test x$gcc_cv_ld != x; then
3236 # Check if linker supports -Bstatic/-Bdynamic option
3237 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3238 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3239 gcc_cv_ld_static_dynamic=yes
3242 # HP-UX ld uses -a flags to select between shared and archive.
3244 if test x"$gnu_ld" = xno; then
3245 gcc_cv_ld_static_dynamic=yes
3246 gcc_cv_ld_static_option="-aarchive_shared"
3247 gcc_cv_ld_dynamic_option="-adefault"
3250 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3252 gcc_cv_ld_static_dynamic=yes
3257 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3258 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3259 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3260 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3261 [Define to the linker option to disable use of shared objects.])
3262 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3263 [Define to the linker option to enable use of shared objects.])
3265 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3267 if test x"$demangler_in_ld" = xyes; then
3268 AC_MSG_CHECKING(linker --demangle support)
3269 gcc_cv_ld_demangle=no
3270 if test $in_tree_ld = yes; then
3271 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 \
3272 gcc_cv_ld_demangle=yes
3274 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3275 # Check if the GNU linker supports --demangle option
3276 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3277 gcc_cv_ld_demangle=yes
3280 if test x"$gcc_cv_ld_demangle" = xyes; then
3281 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3282 [Define if your linker supports --demangle option.])
3284 AC_MSG_RESULT($gcc_cv_ld_demangle)
3287 AC_MSG_CHECKING(linker plugin support)
3289 if test -f liblto_plugin.la; then
3290 save_ld_ver="$ld_ver"
3291 save_ld_vers_major="$ld_vers_major"
3292 save_ld_vers_minor="$ld_vers_minor"
3293 save_ld_is_gold="$ld_is_gold"
3297 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3299 # FIXME: ld_is_gold?
3300 ld_vers_major="$gcc_cv_gld_major_version"
3301 ld_vers_minor="$gcc_cv_gld_minor_version"
3303 # Determine plugin linker version.
3304 # FIXME: Partial duplicate from above, generalize.
3306 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3307 if echo "$ld_ver" | grep GNU > /dev/null; then
3308 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3310 ld_vers=`echo $ld_ver | sed -n \
3311 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3313 ld_vers=`echo $ld_ver | sed -n \
3314 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3316 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3317 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3322 # Determine plugin support.
3323 if echo "$ld_ver" | grep GNU > /dev/null; then
3324 # Require GNU ld or gold 2.21+ for plugin support by default.
3325 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3327 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3328 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3333 ld_ver="$save_ld_ver"
3334 ld_vers_major="$save_ld_vers_major"
3335 ld_vers_minor="$save_ld_vers_minor"
3336 ld_is_gold="$save_ld_is_gold"
3338 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3339 [Define to the level of your linker's plugin support.])
3340 AC_MSG_RESULT($gcc_cv_lto_plugin)
3343 # All TARGET_ABI_OSF targets.
3344 alpha*-*-linux* | alpha*-*-*bsd*)
3345 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3346 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3349 extbl $3, $2, $3 !lituse_bytoff!1
3350 ldq $2, a($29) !literal!1
3351 ldq $4, b($29) !literal!2
3352 ldq_u $3, 0($2) !lituse_base!1
3353 ldq $27, f($29) !literal!5
3354 jsr $26, ($27), f !lituse_jsr!5
3355 ldah $29, 0($26) !gpdisp!3
3356 lda $0, c($29) !gprel
3357 ldah $1, d($29) !gprelhigh
3358 lda $1, d($1) !gprellow
3359 lda $29, 0($29) !gpdisp!3],,
3360 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3361 [Define if your assembler supports explicit relocations.])])
3362 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3363 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3366 ldq $27, a($29) !literal!1
3367 jsr $26, ($27), a !lituse_jsrdirect!1],,
3368 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3369 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3373 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3374 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3375 [-no-mul-bug-abort], [.text],,
3376 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3377 [Define if your assembler supports the -no-mul-bug-abort option.])])
3381 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3382 [.register %g2, #scratch],,
3383 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3384 [Define if your assembler supports .register.])])
3386 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3388 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3389 [Define if your assembler supports -relax option.])])
3391 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3392 gcc_cv_as_sparc_gotdata_op,,
3399 sethi %gdop_hix22(foo), %g1
3400 xor %g1, %gdop_lox10(foo), %g1
3401 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3402 [if test x$gcc_cv_ld != x \
3403 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3404 if test x$gcc_cv_objdump != x; then
3405 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3406 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3407 gcc_cv_as_sparc_gotdata_op=no
3409 gcc_cv_as_sparc_gotdata_op=yes
3414 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3415 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3417 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3418 gcc_cv_as_sparc_ua_pcrel,,
3426 .uaword %r_disp32(foo)],
3427 [if test x$gcc_cv_ld != x \
3428 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3429 gcc_cv_as_sparc_ua_pcrel=yes
3432 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3433 [Define if your assembler and linker support unaligned PC relative relocs.])
3435 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3436 gcc_cv_as_sparc_ua_pcrel_hidden,,
3441 .uaword %r_disp32(foo)
3442 .byte 0x32, 0x33, 0x34
3447 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3448 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3449 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3450 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3451 if $gcc_cv_objdump -R conftest 2> /dev/null \
3452 | grep 'DISP32' > /dev/null 2>&1; then
3455 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3459 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3460 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3461 ]) # unaligned pcrel relocs
3463 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3464 gcc_cv_as_sparc_offsetable_lo10,,
3467 or %g1, %lo(ab) + 12, %g1
3468 or %g1, %lo(ab + 12), %g1],
3469 [if test x$gcc_cv_objdump != x \
3470 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3471 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3472 gcc_cv_as_sparc_offsetable_lo10=yes
3474 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3475 [Define if your assembler supports offsetable %lo().])])
3477 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3478 gcc_cv_as_sparc_fmaf,,
3481 .register %g2, #scratch
3482 .register %g3, #scratch
3484 fmaddd %f0, %f2, %f4, %f6
3485 addxccc %g1, %g2, %g3
3486 fsrl32 %f2, %f4, %f8
3487 fnaddd %f10, %f12, %f14],,
3488 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3489 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3493 i[34567]86-*-* | x86_64-*-*)
3497 # Full C++ conformance when using a shared libstdc++-v3 requires some
3498 # support from the Cygwin DLL, which in more recent versions exports
3499 # wrappers to aid in interposing and redirecting operators new, delete,
3500 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3501 # are configuring for a version of Cygwin that exports the wrappers.
3502 if test x$host = x$target; then
3503 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3505 # Can't check presence of libc functions during cross-compile, so
3506 # we just have to assume we're building for an up-to-date target.
3507 gcc_ac_cygwin_dll_wrappers=yes
3509 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3510 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3511 [Define if you want to generate code by default that assumes that the
3512 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3515 cygwin* | pe | mingw32* | interix*)
3516 # Recent binutils allows the three-operand form of ".comm" on PE. This
3517 # definition is used unconditionally to initialise the default state of
3518 # the target option variable that governs usage of the feature.
3519 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3520 [2,19,52],,[.comm foo,1,32])
3521 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3522 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3523 [Define if your assembler supports specifying the alignment
3524 of objects allocated using the GAS .comm command.])
3525 # Used for DWARF 2 in PE
3526 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3527 gcc_cv_as_ix86_pe_secrel32,
3533 [if test x$gcc_cv_ld != x \
3534 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3535 gcc_cv_as_ix86_pe_secrel32=yes
3538 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3539 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3540 # Test if the assembler supports the extended form of the .section
3541 # directive that specifies section alignment. LTO support uses this,
3542 # but normally only after installation, so we warn but don't fail the
3543 # configure if LTO is enabled but the assembler does not support it.
3544 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3545 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3546 if test x$gcc_cv_as_section_has_align != xyes; then
3547 case ",$enable_languages," in
3549 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3553 # Test if the assembler supports the section flag 'e' for specifying
3554 # an excluded section.
3555 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3559 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3560 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3561 [Define if your assembler supports specifying the section flag e.])
3565 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3566 gcc_cv_as_ix86_filds,,,
3567 [filds mem; fists mem],,
3568 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3569 [Define if your assembler uses filds and fists mnemonics.])])
3571 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3572 gcc_cv_as_ix86_fildq,,,
3573 [fildq mem; fistpq mem],,
3574 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3575 [Define if your assembler uses fildq and fistq mnemonics.])])
3577 gcc_GAS_CHECK_FEATURE([cmov syntax],
3578 gcc_cv_as_ix86_cmov_sun_syntax,,,
3579 [cmovl.l %edx, %eax],,
3580 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3581 [Define if your assembler supports the Sun syntax for cmov.])])
3583 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3584 gcc_cv_as_ix86_ffreep,,,
3586 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3587 [Define if your assembler supports the ffreep mnemonic.])])
3589 gcc_GAS_CHECK_FEATURE([.quad directive],
3590 gcc_cv_as_ix86_quad,,,
3592 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3593 [Define if your assembler supports the .quad directive.])])
3595 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3596 gcc_cv_as_ix86_sahf,,,
3599 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3600 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3602 gcc_GAS_CHECK_FEATURE([hle prefixes],
3603 gcc_cv_as_ix86_hle,,,
3605 lock xacquire cmpxchg %esi, (%rcx)
3607 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3608 [Define if your assembler supports HLE prefixes.])])
3610 gcc_GAS_CHECK_FEATURE([swap suffix],
3611 gcc_cv_as_ix86_swap,,,
3612 [movl.s %esp, %ebp],,
3613 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3614 [Define if your assembler supports the swap suffix.])])
3616 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3617 gcc_cv_as_ix86_diff_sect_delta,,,
3625 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3626 [Define if your assembler supports the subtraction of symbols in different sections.])])
3628 # These two are used unconditionally by i386.[ch]; it is to be defined
3629 # to 1 if the feature is present, 0 otherwise.
3630 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3631 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3637 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3638 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3639 [Define true if the assembler supports '.long foo@GOTOFF'.])
3641 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3642 gcc_cv_as_ix86_rep_lock_prefix,,,
3648 lock addl %edi, (%eax,%esi)
3649 lock orl $0, (%esp)],,
3650 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3651 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3653 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3654 gcc_cv_as_ix86_tlsgdplt,,,
3655 [call tls_gd@tlsgdplt],
3656 [if test x$gcc_cv_ld != x \
3657 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3658 gcc_cv_as_ix86_tlsgdplt=yes
3661 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3662 [Define if your assembler and linker support @tlsgdplt.])])
3664 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3665 gcc_cv_as_ix86_tlsldmplt,,,
3667 call tls_ld@tlsldmplt],
3668 [if test x$gcc_cv_ld != x \
3669 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3670 gcc_cv_as_ix86_tlsldmplt=yes
3673 [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1,
3674 [Define if your assembler and linker support @tlsldmplt.])])
3679 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3680 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3682 addl r15 = @ltoffx(x#), gp
3684 ld8.mov r16 = [[r15]], x#],,
3685 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3686 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3692 *-*-aix*) conftest_s=' .machine "pwr5"
3696 gcc_GAS_CHECK_FEATURE([.machine directive support],
3697 gcc_cv_as_machine_directive,,,
3698 [ .machine ppc7400])
3699 if test x$gcc_cv_as_machine_directive != xyes; then
3700 echo "*** This target requires an assembler supporting \".machine\"" >&2
3701 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3702 test x$build = x$target && exit 1
3706 *) conftest_s=' .machine power4
3711 gcc_GAS_CHECK_FEATURE([mfcr field support],
3712 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3714 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3715 [Define if your assembler supports mfcr field.])])
3718 *-*-aix*) conftest_s=' .machine "pwr5"
3721 *) conftest_s=' .machine power5
3726 gcc_GAS_CHECK_FEATURE([popcntb support],
3727 gcc_cv_as_powerpc_popcntb, [2,17,0],,
3729 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3730 [Define if your assembler supports popcntb field.])])
3733 *-*-aix*) conftest_s=' .machine "pwr5x"
3736 *) conftest_s=' .machine power5
3741 gcc_GAS_CHECK_FEATURE([fp round support],
3742 gcc_cv_as_powerpc_fprnd, [2,17,0],,
3744 [AC_DEFINE(HAVE_AS_FPRND, 1,
3745 [Define if your assembler supports fprnd.])])
3748 *-*-aix*) conftest_s=' .machine "pwr6"
3751 *) conftest_s=' .machine power6
3756 gcc_GAS_CHECK_FEATURE([move fp gpr support],
3757 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3759 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3760 [Define if your assembler supports mffgpr and mftgpr.])])
3763 *-*-aix*) conftest_s=' .csect .text[[PR]]
3765 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3769 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3770 *) conftest_s=' .text
3772 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3775 gcc_GAS_CHECK_FEATURE([rel16 relocs],
3776 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3778 [AC_DEFINE(HAVE_AS_REL16, 1,
3779 [Define if your assembler supports R_PPC_REL16 relocs.])])
3782 *-*-aix*) conftest_s=' .machine "pwr6"
3785 *) conftest_s=' .machine power6
3790 gcc_GAS_CHECK_FEATURE([compare bytes support],
3791 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3793 [AC_DEFINE(HAVE_AS_CMPB, 1,
3794 [Define if your assembler supports cmpb.])])
3797 *-*-aix*) conftest_s=' .machine "pwr6"
3800 *) conftest_s=' .machine power6
3805 gcc_GAS_CHECK_FEATURE([decimal float support],
3806 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3808 [AC_DEFINE(HAVE_AS_DFP, 1,
3809 [Define if your assembler supports DFP instructions.])])
3812 *-*-aix*) conftest_s=' .machine "pwr7"
3815 *) conftest_s=' .machine power7
3820 gcc_GAS_CHECK_FEATURE([vector-scalar support],
3821 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3823 [AC_DEFINE(HAVE_AS_VSX, 1,
3824 [Define if your assembler supports VSX instructions.])])
3827 *-*-aix*) conftest_s=' .machine "pwr7"
3830 *) conftest_s=' .machine power7
3835 gcc_GAS_CHECK_FEATURE([popcntd support],
3836 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3838 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3839 [Define if your assembler supports POPCNTD instructions.])])
3842 *-*-aix*) conftest_s=' .csect .text[[PR]]
3844 *) conftest_s=' .text
3848 gcc_GAS_CHECK_FEATURE([lwsync support],
3849 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3851 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3852 [Define if your assembler supports LWSYNC instructions.])])
3855 *-*-aix*) conftest_s=' .machine "476"
3858 *) conftest_s=' .machine "476"
3863 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3864 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3866 [AC_DEFINE(HAVE_AS_DCI, 1,
3867 [Define if your assembler supports the DCI/ICI instructions.])])
3869 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3870 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3871 [.gnu_attribute 4,1],,
3872 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3873 [Define if your assembler supports .gnu_attribute.])])
3875 gcc_GAS_CHECK_FEATURE([tls marker support],
3876 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3877 [ bl __tls_get_addr(x@tlsgd)],,
3878 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3879 [Define if your assembler supports arg info for __tls_get_addr.])])
3883 gcc_GAS_CHECK_FEATURE([.ref support],
3884 gcc_cv_as_aix_ref, [2.21.0],,
3885 [ .csect stuff[[rw]]
3891 [AC_DEFINE(HAVE_AS_REF, 1,
3892 [Define if your assembler supports .ref])])
3898 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3899 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3900 [ lw $4,%gp_rel(foo)($4)],,
3901 [if test x$target_cpu_default = x
3902 then target_cpu_default=MASK_EXPLICIT_RELOCS
3903 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3905 gcc_GAS_CHECK_FEATURE([-mno-shared support],
3906 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3907 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3908 [Define if the assembler understands -mno-shared.])])
3910 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3911 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3912 [.gnu_attribute 4,1],,
3913 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3914 [Define if your assembler supports .gnu_attribute.])])
3916 gcc_GAS_CHECK_FEATURE([.dtprelword support],
3917 gcc_cv_as_mips_dtprelword, [2,18,0],,
3918 [.section .tdata,"awT",@progbits
3922 .dtprelword x+0x8000],,
3923 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3924 [Define if your assembler supports .dtprelword.])])
3926 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3927 gcc_cv_as_mips_dspr1_mult,,,
3937 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3938 [Define if your assembler supports DSPR1 mult.])])
3940 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3941 gcc_cv_as_ld_jalr_reloc=no
3942 if test $gcc_cv_as_mips_explicit_relocs = yes; then
3943 if test $in_tree_ld = yes ; then
3944 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 \
3945 && test $in_tree_ld_is_elf = yes; then
3946 gcc_cv_as_ld_jalr_reloc=yes
3948 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3949 echo ' .ent x' > conftest.s
3950 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s
3951 echo ' ld $25,%call16(y)($28)' >> conftest.s
3952 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
3953 echo '1: jalr $25' >> conftest.s
3954 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
3955 echo '1: jalr $25' >> conftest.s
3956 echo ' .end x' >> conftest.s
3957 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3958 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3959 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3960 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3961 gcc_cv_as_ld_jalr_reloc=yes
3967 if test $gcc_cv_as_ld_jalr_reloc = yes; then
3968 if test x$target_cpu_default = x; then
3969 target_cpu_default=MASK_RELAX_PIC_CALLS
3971 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3974 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3976 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3977 [gcc_cv_ld_mips_personality_relaxation],
3978 [gcc_cv_ld_mips_personality_relaxation=no
3979 if test $in_tree_ld = yes ; then
3980 if test "$gcc_cv_gld_major_version" -eq 2 \
3981 -a "$gcc_cv_gld_minor_version" -ge 21 \
3982 -o "$gcc_cv_gld_major_version" -gt 2; then
3983 gcc_cv_ld_mips_personality_relaxation=yes
3985 elif test x$gcc_cv_as != x \
3986 -a x$gcc_cv_ld != x \
3987 -a x$gcc_cv_readelf != x ; then
3988 cat > conftest.s <<EOF
3990 .cfi_personality 0x80,indirect_ptr
3997 .section .data,"aw",@progbits
4001 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4002 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4003 if $gcc_cv_readelf -d conftest 2>&1 \
4004 | grep TEXTREL > /dev/null 2>&1; then
4006 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4007 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4010 gcc_cv_ld_mips_personality_relaxation=yes
4014 rm -f conftest.s conftest.o conftest])
4015 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4016 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4017 [Define if your linker can relax absolute .eh_frame personality
4018 pointers into PC-relative form.])
4023 # Mips and HP-UX need the GNU assembler.
4024 # Linux on IA64 might be able to use the Intel assembler.
4027 mips*-*-* | *-*-hpux* )
4028 if test x$gas_flag = xyes \
4029 || test x"$host" != x"$build" \
4030 || test ! -x "$gcc_cv_as" \
4031 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4034 echo "*** This configuration requires the GNU assembler" >&2
4040 # ??? Not all targets support dwarf2 debug_line, even within a version
4041 # of gas. Moreover, we need to emit a valid instruction to trigger any
4042 # info to the output file. So, as supported targets are added to gas 2.11,
4043 # add some instruction here to (also) show we expect this might work.
4044 # ??? Once 2.11 is released, probably need to add first known working
4045 # version to the per-target configury.
4047 alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
4048 | pa | rs6000 | score | sparc | spu | tilegx | tilepro | xstormy16 | xtensa)
4058 if test x"$insn" != x; then
4060 .file 1 \"conftest.s\"
4063 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4064 gcc_cv_as_dwarf2_debug_line,
4065 [elf,2,11,0],, [$conftest_s],
4066 [if test x$gcc_cv_objdump != x \
4067 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4068 | grep debug_line > /dev/null 2>&1; then
4069 gcc_cv_as_dwarf2_debug_line=yes
4072 # The .debug_line file table must be in the exact order that
4073 # we specified the files, since these indices are also used
4074 # by DW_AT_decl_file. Approximate this test by testing if
4075 # the assembler bitches if the same index is assigned twice.
4076 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4077 gcc_cv_as_dwarf2_file_buggy,,,
4081 if test $gcc_cv_as_dwarf2_debug_line = yes \
4082 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4083 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4084 [Define if your assembler supports dwarf2 .file/.loc directives,
4085 and preserves file table indices exactly as given.])
4088 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4089 gcc_cv_as_gdwarf2_flag,
4090 [elf,2,11,0], [--gdwarf2], [$insn],,
4091 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4092 [Define if your assembler supports the --gdwarf2 option.])])
4094 gcc_GAS_CHECK_FEATURE([--gstabs option],
4095 gcc_cv_as_gstabs_flag,
4096 [elf,2,11,0], [--gstabs], [$insn],
4097 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4098 # and warns about it, but still exits successfully. So check for
4100 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4102 else gcc_cv_as_gstabs_flag=yes
4104 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4105 [Define if your assembler supports the --gstabs option.])])
4107 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4108 gcc_cv_as_debug_prefix_map_flag,
4109 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4110 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4111 [Define if your assembler supports the --debug-prefix-map option.])])
4114 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4117 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4118 [Define if your assembler supports .lcomm with an alignment field.])])
4120 AC_ARG_ENABLE(gnu-unique-object,
4121 [AS_HELP_STRING([--enable-gnu-unique-object],
4122 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4123 [case $enable_gnu_unique_object in
4125 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4126 Valid choices are 'yes' and 'no'.]) ;;
4128 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4130 [.type foo, '$target_type_format_char'gnu_unique_object],,
4131 # We need to unquote above to to use the definition from config.gcc.
4132 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4133 [[if test x$host = x$build -a x$host = x$target &&
4134 ldd --version 2>/dev/null &&
4135 glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4136 glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4137 glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4138 glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4139 if test "$glibcnum" -ge 2011 ; then
4140 enable_gnu_unique_object=yes
4143 if test x$enable_gnu_unique_object = xyes; then
4144 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4145 [Define if your assembler supports @gnu_unique_object.])
4148 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4149 [gcc_cv_as_line_zero],
4150 [gcc_cv_as_line_zero=no
4151 if test $in_tree_gas = yes; then
4152 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4153 elif test "x$gcc_cv_as" != x; then
4154 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4155 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4156 test "x`cat conftest.out`" = x
4158 gcc_cv_as_line_zero=yes
4160 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4161 cat conftest.s >&AS_MESSAGE_LOG_FD
4162 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4163 cat conftest.out >&AS_MESSAGE_LOG_FD
4165 rm -f conftest.o conftest.s conftest.out
4167 if test "x$gcc_cv_as_line_zero" = xyes; then
4168 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4169 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4172 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4173 gcc_cv_ld_eh_frame_hdr=no
4174 if test $in_tree_ld = yes ; then
4175 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 \
4176 && test $in_tree_ld_is_elf = yes; then
4177 gcc_cv_ld_eh_frame_hdr=yes
4179 elif test x$gcc_cv_ld != x; then
4180 if echo "$ld_ver" | grep GNU > /dev/null; then
4181 # Check if linker supports --eh-frame-hdr option
4182 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4183 gcc_cv_ld_eh_frame_hdr=yes
4188 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4189 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4190 gcc_cv_ld_eh_frame_hdr=yes
4196 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4197 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4198 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4199 [Define if your linker supports .eh_frame_hdr.])
4201 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4203 AC_MSG_CHECKING(linker position independent executable support)
4205 if test $in_tree_ld = yes ; then
4206 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 \
4207 && test $in_tree_ld_is_elf = yes; then
4210 elif test x$gcc_cv_ld != x; then
4211 # Check if linker supports -pie option
4212 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4216 if test x"$gcc_cv_ld_pie" = xyes; then
4217 AC_DEFINE(HAVE_LD_PIE, 1,
4218 [Define if your linker supports -pie option.])
4220 AC_MSG_RESULT($gcc_cv_ld_pie)
4222 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4223 gcc_cv_ld_eh_gc_sections=no
4224 if test $in_tree_ld = yes ; then
4225 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 \
4226 && test $in_tree_ld_is_elf = yes; then
4227 gcc_cv_ld_eh_gc_sections=yes
4229 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4230 cat > conftest.s <<EOF
4233 .type _start, @function
4236 .size _start, .-_start
4237 .section .text.foo,"ax",@progbits
4238 .type foo, @function
4242 .section .gcc_except_table.foo,"a",@progbits
4245 .section .eh_frame,"a",@progbits
4248 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4249 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4250 | grep "gc-sections option ignored" > /dev/null; then
4251 gcc_cv_ld_eh_gc_sections=no
4252 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4253 | grep gcc_except_table > /dev/null; then
4254 gcc_cv_ld_eh_gc_sections=yes
4255 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4256 if test x$gcc_cv_as_comdat_group != xyes; then
4257 gcc_cv_ld_eh_gc_sections=no
4258 cat > conftest.s <<EOF
4261 .type _start, @function
4264 .size _start, .-_start
4265 .section .gnu.linkonce.t.foo,"ax",@progbits
4266 .type foo, @function
4270 .section .gcc_except_table.foo,"a",@progbits
4273 .section .eh_frame,"a",@progbits
4276 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4277 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4278 | grep "gc-sections option ignored" > /dev/null; then
4279 gcc_cv_ld_eh_gc_sections=no
4280 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4281 | grep gcc_except_table > /dev/null; then
4282 gcc_cv_ld_eh_gc_sections=yes
4288 rm -f conftest.s conftest.o conftest
4292 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4293 gcc_cv_ld_eh_gc_sections=no
4296 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4297 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4298 [Define if your linker supports garbage collection of
4299 sections in presence of EH frames.])
4301 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4303 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4304 gcc_cv_ld_eh_gc_sections_bug=no
4305 if test $in_tree_ld = yes ; then
4306 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 \
4307 && test $in_tree_ld_is_elf = yes; then
4308 gcc_cv_ld_eh_gc_sections_bug=yes
4310 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
4311 gcc_cv_ld_eh_gc_sections_bug=yes
4312 cat > conftest.s <<EOF
4315 .type _start, @function
4318 .size _start, .-_start
4319 .section .text.startup.foo,"ax",@progbits
4320 .type foo, @function
4324 .section .gcc_except_table.foo,"a",@progbits
4327 .section .eh_frame,"a",@progbits
4330 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4331 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4332 | grep "gc-sections option ignored" > /dev/null; then
4334 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4335 | grep gcc_except_table > /dev/null; then
4336 gcc_cv_ld_eh_gc_sections_bug=no
4339 rm -f conftest.s conftest.o conftest
4341 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4342 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4343 [Define if your linker has buggy garbage collection of
4344 sections support when .text.startup.foo like sections are used.])
4346 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4352 AC_CACHE_CHECK(linker --as-needed support,
4353 gcc_cv_ld_as_needed,
4354 [gcc_cv_ld_as_needed=no
4355 if test $in_tree_ld = yes ; then
4356 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 \
4357 && test $in_tree_ld_is_elf = yes; then
4358 gcc_cv_ld_as_needed=yes
4360 elif test x$gcc_cv_ld != x; then
4361 # Check if linker supports --as-needed and --no-as-needed options
4362 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4363 gcc_cv_ld_as_needed=yes
4367 if test x"$gcc_cv_ld_as_needed" = xyes; then
4368 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4369 [Define if your linker supports --as-needed and --no-as-needed options.])
4372 case "$target:$tm_file" in
4373 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4376 emul_name="-melf64ppc"
4379 emul_name="-melf64ppc_fbsd"
4382 AC_CACHE_CHECK(linker support for omitting dot symbols,
4383 gcc_cv_ld_no_dot_syms,
4384 [gcc_cv_ld_no_dot_syms=no
4385 if test $in_tree_ld = yes ; then
4386 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
4387 gcc_cv_ld_no_dot_syms=yes
4389 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4390 cat > conftest1.s <<EOF
4394 cat > conftest2.s <<EOF
4395 .section ".opd","aw"
4400 .quad .LEfoo,.TOC.@tocbase,0
4406 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4407 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4408 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4409 gcc_cv_ld_no_dot_syms=yes
4411 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4414 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4415 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4416 [Define if your PowerPC64 linker only needs function descriptor syms.])
4419 AC_CACHE_CHECK(linker large toc support,
4420 gcc_cv_ld_large_toc,
4421 [gcc_cv_ld_large_toc=no
4422 if test $in_tree_ld = yes ; then
4423 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
4424 gcc_cv_ld_large_toc=yes
4426 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4427 cat > conftest.s <<EOF
4428 .section ".tbss","awT",@nobits
4434 addis 9,13,ie0@got@tprel@ha
4435 ld 9,ie0@got@tprel@l(9)
4437 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4438 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4439 gcc_cv_ld_large_toc=yes
4441 rm -f conftest conftest.o conftest.s
4444 if test x"$gcc_cv_ld_large_toc" = xyes; then
4445 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4446 [Define if your PowerPC64 linker supports a large TOC.])
4451 AC_CACHE_CHECK(linker --build-id support,
4453 [gcc_cv_ld_buildid=no
4454 if test $in_tree_ld = yes ; then
4455 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4456 "$gcc_cv_gld_minor_version" -ge 18 -o \
4457 "$gcc_cv_gld_major_version" -gt 2 \
4458 && test $in_tree_ld_is_elf = yes; then
4459 gcc_cv_ld_buildid=yes
4461 elif test x$gcc_cv_ld != x; then
4462 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4463 gcc_cv_ld_buildid=yes
4466 if test x"$gcc_cv_ld_buildid" = xyes; then
4467 AC_DEFINE(HAVE_LD_BUILDID, 1,
4468 [Define if your linker supports --build-id.])
4471 AC_ARG_ENABLE(linker-build-id,
4472 [AS_HELP_STRING([--enable-linker-build-id],
4473 [compiler will always pass --build-id to linker])],
4475 enable_linker_build_id=no)
4477 if test x"$enable_linker_build_id" = xyes; then
4478 if test x"$gcc_cv_ld_buildid" = xyes; then
4479 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4480 [Define if gcc should always pass --build-id to linker.])
4482 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4486 # In binutils 2.21, GNU ld gained support for new emulations fully
4487 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4488 AC_CACHE_CHECK(linker *_sol2 emulation support,
4489 gcc_cv_ld_sol2_emulation,
4490 [gcc_cv_ld_sol2_emulation=no
4491 if test $in_tree_ld = yes ; then
4492 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4493 "$gcc_cv_gld_minor_version" -ge 21 -o \
4494 "$gcc_cv_gld_major_version" -gt 2 \
4495 && test $in_tree_ld_is_elf = yes; then
4496 gcc_cv_ld_sol2_emulation=yes
4498 elif test x$gcc_cv_ld != x; then
4499 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4500 grep _sol2 > /dev/null; then
4501 gcc_cv_ld_sol2_emulation=yes
4504 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4505 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4506 [Define if your linker supports the *_sol2 emulations.])
4509 AC_CACHE_CHECK(linker --sysroot support,
4511 [gcc_cv_ld_sysroot=no
4512 if test $in_tree_ld = yes ; then
4513 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
4514 gcc_cv_ld_sysroot=yes
4516 elif test x$gcc_cv_ld != x; then
4517 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4518 gcc_cv_ld_sysroot=yes
4521 if test x"$gcc_cv_ld_sysroot" = xyes; then
4522 AC_DEFINE(HAVE_LD_SYSROOT, 1,
4523 [Define if your linker supports --sysroot.])
4526 if test x$with_sysroot = x && test x$host = x$target \
4527 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4528 && test "$prefix" != "NONE"; then
4529 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4530 [Define to PREFIX/include if cpp should also search that directory.])
4533 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4534 if test "x$with_headers" != x; then
4535 target_header_dir=$with_headers
4536 elif test "x$with_sysroot" = x; then
4537 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4538 elif test "x$with_build_sysroot" != "x"; then
4539 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4540 elif test "x$with_sysroot" = xyes; then
4541 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4543 target_header_dir="${with_sysroot}${native_system_header_dir}"
4546 target_header_dir=${native_system_header_dir}
4549 # Test for stack protector support in target C library.
4550 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4551 gcc_cv_libc_provides_ssp,
4552 [gcc_cv_libc_provides_ssp=no
4554 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4555 [# glibc 2.4 and later provides __stack_chk_fail and
4556 # either __stack_chk_guard, or TLS access to stack guard canary.
4557 if test -f $target_header_dir/features.h \
4558 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
4559 $target_header_dir/features.h > /dev/null; then
4560 if $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+([1-9][0-9]|[3-9])' \
4561 $target_header_dir/features.h > /dev/null; then
4562 gcc_cv_libc_provides_ssp=yes
4563 elif $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+2' \
4564 $target_header_dir/features.h > /dev/null \
4565 && $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+([1-9][0-9]|[4-9])' \
4566 $target_header_dir/features.h > /dev/null; then
4567 gcc_cv_libc_provides_ssp=yes
4568 elif $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
4569 $target_header_dir/features.h > /dev/null && \
4570 test -f $target_header_dir/bits/uClibc_config.h && \
4571 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
4572 $target_header_dir/bits/uClibc_config.h > /dev/null; then
4573 gcc_cv_libc_provides_ssp=yes
4575 # all versions of Bionic support stack protector
4576 elif test -f $target_header_dir/sys/cdefs.h \
4577 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
4578 $target_header_dir/sys/cdefs.h > /dev/null; then
4579 gcc_cv_libc_provides_ssp=yes
4583 # Avoid complicated tests (see
4584 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4585 # simply assert that glibc does provide this, which is true for all
4586 # realistically usable GNU/Hurd configurations.
4587 gcc_cv_libc_provides_ssp=yes;;
4588 *-*-darwin* | *-*-freebsd*)
4589 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4590 [echo "no __stack_chk_fail on this target"])
4592 *) gcc_cv_libc_provides_ssp=no ;;
4595 if test x$gcc_cv_libc_provides_ssp = xyes; then
4596 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4597 [Define if your target C library provides stack protector support])
4600 # Test for <sys/sdt.h> on the target.
4601 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4602 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4604 if test -f $target_header_dir/sys/sdt.h; then
4606 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4607 [Define if your target C library provides sys/sdt.h])
4609 AC_MSG_RESULT($have_sys_sdt_h)
4611 # Check if TFmode long double should be used by default or not.
4612 # Some glibc targets used DFmode long double, but with glibc 2.4
4613 # and later they can use TFmode.
4615 powerpc*-*-linux* | \
4619 AC_ARG_WITH(long-double-128,
4620 [AS_HELP_STRING([--with-long-double-128],
4621 [use 128-bit long double by default])],
4622 gcc_cv_target_ldbl128="$with_long_double_128",
4623 [[gcc_cv_target_ldbl128=no
4624 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4625 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4626 && gcc_cv_target_ldbl128=yes
4630 if test x$gcc_cv_target_ldbl128 = xyes; then
4631 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4632 [Define if TFmode long double should be the default])
4635 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
4636 gcc_cv_target_dl_iterate_phdr=unknown
4638 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
4639 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
4640 # libdl there, both complicating its use and breaking compatibility
4641 # between Solaris 10 updates.
4642 *-*-solaris2.1[[1-9]]*)
4643 # <link.h> needs both a dl_iterate_phdr declaration and support for
4644 # compilation with largefile support.
4645 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
4646 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
4647 gcc_cv_target_dl_iterate_phdr=yes
4649 gcc_cv_target_dl_iterate_phdr=no
4653 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
4654 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
4655 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
4656 [Define if your target C library provides the `dl_iterate_phdr' function.])
4658 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
4660 # Find out what GC implementation we want, or may, use.
4662 [AS_HELP_STRING([--with-gc={page,zone}],
4663 [choose the garbage collection mechanism to use
4664 with the compiler])],
4671 AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4674 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4679 echo "Using $GGC for garbage collection."
4681 # Libraries to use on the host. This will normally be set by the top
4682 # level Makefile. Here we simply capture the value for our Makefile.
4683 if test -z "${HOST_LIBS+set}"; then
4688 # Use the system's zlib library.
4690 zlibinc="-I\$(srcdir)/../zlib"
4691 AC_ARG_WITH(system-zlib,
4692 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
4699 dnl Very limited version of automake's enable-maintainer-mode
4701 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4702 dnl maintainer-mode is disabled by default
4703 AC_ARG_ENABLE(maintainer-mode,
4704 [AS_HELP_STRING([--enable-maintainer-mode],
4705 [enable make rules and dependencies not useful
4706 (and sometimes confusing) to the casual installer])],
4707 maintainer_mode=$enableval,
4710 AC_MSG_RESULT($maintainer_mode)
4712 if test "$maintainer_mode" = "yes"; then
4723 # Make empty files to contain the specs and options for each language.
4724 # Then add #include lines to for a compiler that has specs and/or options.
4730 # These (without "all_") are set in each config-lang.in.
4731 # `language' must be a single word so is spelled singularly.
4734 all_outputs='Makefile'
4735 # List of language makefile fragments.
4737 # Additional files for gengtype
4738 all_gtfiles="$target_gtfiles"
4740 # These are the languages that are set in --enable-languages,
4741 # and are available in the GCC tree.
4742 all_selected_languages=
4744 # Add the language fragments.
4745 # Languages are added via two mechanisms. Some information must be
4746 # recorded in makefile variables, these are defined in config-lang.in.
4747 # We accumulate them and plug them into the main Makefile.
4748 # The other mechanism is a set of hooks for each of the main targets
4749 # like `clean', `install', etc.
4751 language_hooks="Make-hooks"
4753 for lang in ${srcdir}/*/config-lang.in
4756 test "$lang" = "${srcdir}/*/config-lang.in" && continue
4758 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
4759 if test "x$lang_alias" = x
4761 echo "$lang doesn't set \$language." 1>&2
4764 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4765 subdirs="$subdirs $subdir"
4767 # $gcc_subdir is where the gcc integration files are to be found
4768 # for a language, both for internal compiler purposes (compiler
4769 # sources implementing front-end to GCC tree converters), and for
4770 # build infrastructure purposes (Make-lang.in, etc.)
4772 # This will be <subdir> (relative to $srcdir) if a line like
4773 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4774 # is found in <langdir>/config-lang.in, and will remain <langdir>
4777 # Except for the language alias (fetched above), the regular
4778 # "config-lang.in" contents are always retrieved from $gcc_subdir,
4779 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4780 # only this and the language alias.
4782 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
4783 if [ "$gcc_subdir" = "" ]; then
4784 gcc_subdir="$subdir"
4787 case ",$enable_languages," in
4789 all_selected_languages="$all_selected_languages $lang_alias"
4790 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4791 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4803 . ${srcdir}/$gcc_subdir/config-lang.in
4804 if test "x$language" = x
4806 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4811 case ",$enable_languages," in
4814 for i in $subdir_requires; do
4815 test -f "${srcdir}/$i/config-lang.in" && continue
4823 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4824 if test -f $srcdir/$gcc_subdir/lang.opt; then
4825 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4826 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
4828 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4829 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4831 all_languages="$all_languages $language"
4832 all_compilers="$all_compilers $compilers"
4833 all_outputs="$all_outputs $outputs"
4834 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4835 case ",$enable_languages," in
4837 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4839 AC_SUBST(enable_lto)
4846 for language in $all_selected_languages
4848 check_languages="$check_languages check-$language"
4851 # We link each language in with a set of hooks, reached indirectly via
4852 # lang.${target}. Only do so for selected languages.
4856 target_list="all.cross start.encap rest.encap tags \
4857 install-common install-man install-info install-pdf install-html dvi \
4858 pdf html uninstall info man srcextra srcman srcinfo \
4859 mostlyclean clean distclean maintainer-clean install-plugin"
4861 for t in $target_list
4864 for lang in $all_selected_languages
4868 echo "lang.$t: $x" >> Make-hooks
4872 # Option include files
4875 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
4876 option_includes="option-includes.mk"
4877 AC_SUBST_FILE(option_includes)
4885 echo "dir ." > .gdbinit
4886 echo "dir ${srcdir}" >> .gdbinit
4887 if test x$gdb_needs_out_file_path = xyes
4889 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4891 if test "x$subdirs" != x; then
4894 echo "dir ${srcdir}/$s" >> .gdbinit
4897 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4899 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4900 AC_SUBST(gcc_tooldir)
4903 # Find a directory in which to install a shared libgcc.
4905 AC_ARG_ENABLE(version-specific-runtime-libs,
4906 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
4907 [specify that runtime libraries should be
4908 installed in a compiler-specific directory])])
4910 # Substitute configuration variables
4913 AC_SUBST(all_compilers)
4914 AC_SUBST(all_gtfiles)
4915 AC_SUBST(all_lang_makefrags)
4916 AC_SUBST(all_languages)
4917 AC_SUBST(all_selected_languages)
4918 AC_SUBST(build_exeext)
4919 AC_SUBST(build_install_headers_dir)
4920 AC_SUBST(build_xm_file_list)
4921 AC_SUBST(build_xm_include_list)
4922 AC_SUBST(build_xm_defines)
4923 AC_SUBST(build_file_translate)
4924 AC_SUBST(check_languages)
4925 AC_SUBST(cpp_install_dir)
4926 AC_SUBST(xmake_file)
4927 AC_SUBST(tmake_file)
4928 AC_SUBST(TM_ENDIAN_CONFIG)
4929 AC_SUBST(TM_MULTILIB_CONFIG)
4930 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4931 AC_SUBST(extra_gcc_objs)
4932 AC_SUBST(user_headers_inc_next_pre)
4933 AC_SUBST(user_headers_inc_next_post)
4934 AC_SUBST(extra_headers_list)
4935 AC_SUBST(extra_objs)
4936 AC_SUBST(extra_programs)
4937 AC_SUBST(float_h_file)
4938 AC_SUBST(gcc_config_arguments)
4939 AC_SUBST(gcc_gxx_include_dir)
4940 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
4941 AC_SUBST(host_exeext)
4942 AC_SUBST(host_xm_file_list)
4943 AC_SUBST(host_xm_include_list)
4944 AC_SUBST(host_xm_defines)
4945 AC_SUBST(out_host_hook_obj)
4947 AC_SUBST(lang_opt_files)
4948 AC_SUBST(lang_specs_files)
4949 AC_SUBST(lang_tree_files)
4950 AC_SUBST(local_prefix)
4952 AC_SUBST(objc_boehm_gc)
4954 AC_SUBST(out_object_file)
4955 AC_SUBST(common_out_file)
4956 AC_SUBST(common_out_object_file)
4957 AC_SUBST(tm_file_list)
4958 AC_SUBST(tm_include_list)
4959 AC_SUBST(tm_defines)
4960 AC_SUBST(tm_p_file_list)
4961 AC_SUBST(tm_p_include_list)
4962 AC_SUBST(xm_file_list)
4963 AC_SUBST(xm_include_list)
4964 AC_SUBST(xm_defines)
4965 AC_SUBST(use_gcc_stdint)
4966 AC_SUBST(c_target_objs)
4967 AC_SUBST(cxx_target_objs)
4968 AC_SUBST(fortran_target_objs)
4969 AC_SUBST(target_cpu_default)
4971 AC_SUBST_FILE(language_hooks)
4974 if test x${build} = x${host} ; then
4975 if test x${host} = x${target} ; then
4976 echo "Links are now set up to build a native compiler for ${target}." 1>&2
4978 echo "Links are now set up to build a cross-compiler" 1>&2
4979 echo " from ${host} to ${target}." 1>&2
4982 if test x${host} = x${target} ; then
4983 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4984 echo " for ${target}." 1>&2
4986 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4987 echo " from ${host} to ${target}." 1>&2
4991 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4992 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4994 AC_ARG_VAR(ISLLIBS,[How to link ISL])
4995 AC_ARG_VAR(ISLINC,[How to find ISL include files])
4997 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4998 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4999 if test "x${CLOOGLIBS}" != "x" ; then
5000 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5003 # Check for plugin support
5004 AC_ARG_ENABLE(plugin,
5005 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5006 enable_plugin=$enableval,
5007 enable_plugin=yes; default_plugin=yes)
5013 if test x$build = x$host; then
5014 export_sym_check="nm${exeext} -g"
5015 elif test x$host = x$target; then
5016 export_sym_check="$gcc_cv_nm -g"
5022 if test x$build = x$host; then
5023 export_sym_check="objdump${exeext} -T"
5024 elif test x$host = x$target; then
5025 export_sym_check="$gcc_cv_objdump -T"
5032 if test x"$enable_plugin" = x"yes"; then
5034 AC_MSG_CHECKING([for exported symbols])
5035 if test "x$export_sym_check" != x; then
5036 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5037 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
5038 if $export_sym_check conftest | grep foobar > /dev/null; then
5039 : # No need to use a flag
5040 AC_MSG_RESULT([yes])
5042 AC_MSG_RESULT([yes])
5043 AC_MSG_CHECKING([for -rdynamic])
5044 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
5045 if $export_sym_check conftest | grep foobar > /dev/null; then
5047 pluginlibs="-rdynamic"
5052 AC_MSG_RESULT([$plugin_rdynamic])
5055 AC_MSG_RESULT([unable to check])
5060 AC_SEARCH_LIBS([dlopen], [dl])
5061 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5062 pluginlibs="$pluginlibs -ldl"
5066 # Check that we can build shared objects with -fPIC -shared
5067 saved_LDFLAGS="$LDFLAGS"
5068 saved_CFLAGS="$CFLAGS"
5071 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5072 CFLAGS="$CFLAGS -fPIC"
5073 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5076 CFLAGS="$CFLAGS -fPIC"
5077 LDFLAGS="$LDFLAGS -fPIC -shared"
5080 AC_MSG_CHECKING([for -fPIC -shared])
5082 [extern int X;],[return X == 0;],
5083 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5084 [AC_MSG_RESULT([no]); have_pic_shared=no])
5085 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5089 LDFLAGS="$saved_LDFLAGS"
5090 CFLAGS="$saved_CFLAGS"
5092 # If plugin support had been requested but not available, fail.
5093 if test x"$enable_plugin" = x"no" ; then
5094 if test x"$default_plugin" != x"yes"; then
5096 Building GCC with plugin support requires a host that supports
5097 -fPIC, -shared, -ldl and -rdynamic.])
5102 AC_SUBST(pluginlibs)
5103 AC_SUBST(enable_plugin)
5104 if test x"$enable_plugin" = x"yes"; then
5105 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5109 AC_ARG_ENABLE(libquadmath-support,
5110 [AS_HELP_STRING([--disable-libquadmath-support],
5111 [disable libquadmath support for Fortran])],
5112 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5113 ENABLE_LIBQUADMATH_SUPPORT=yes)
5114 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5115 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5116 [Define to 1 to enable libquadmath support])
5120 # Specify what hash style to use by default.
5121 AC_ARG_WITH([linker-hash-style],
5122 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5123 [specify the linker hash style])],
5124 [case x"$withval" in
5126 LINKER_HASH_STYLE=sysv
5129 LINKER_HASH_STYLE=gnu
5132 LINKER_HASH_STYLE=both
5135 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5138 [LINKER_HASH_STYLE=''])
5139 if test x"${LINKER_HASH_STYLE}" != x; then
5140 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5141 [The linker hash style])
5144 # Configure the subdirectories
5145 # AC_CONFIG_SUBDIRS($subdirs)
5147 # Create the Makefile
5148 # and configure language subdirectories
5149 AC_CONFIG_FILES($all_outputs)
5151 AC_CONFIG_COMMANDS([default],
5153 case ${CONFIG_HEADERS} in
5154 *auto-host.h:config.in*)
5157 # Make sure all the subdirs exist.
5158 for d in $subdirs doc build common c-family
5160 test -d $d || mkdir $d
5163 [subdirs='$subdirs'])