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 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 [ --with-local-prefix=DIR specifies directory to put local include],
109 [case "${withval}" in
110 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
112 *) local_prefix=$with_local_prefix ;;
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117 local_prefix=/usr/local
120 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
121 # passed in by the toplevel make and thus we'd get different behavior
122 # depending on where we built the sources.
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [ --with-gxx-include-dir=DIR
127 specifies directory to put g++ header files],
128 [case "${withval}" in
129 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
131 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
134 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
135 if test x${gcc_gxx_include_dir} = x; then
136 if test x${enable_version_specific_runtime_libs} = xyes; then
137 gcc_gxx_include_dir='${libsubdir}/include/c++'
139 libstdcxx_incdir='include/c++/$(version)'
140 if test x$host != x$target; then
141 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
143 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
147 AC_ARG_WITH(cpp_install_dir,
148 [ --with-cpp-install-dir=DIR
149 install the user visible C preprocessor in DIR
150 (relative to PREFIX) as well as PREFIX/bin],
151 [if test x$withval = xyes; then
152 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
153 elif test x$withval != xno; then
154 cpp_install_dir=$withval
157 # We would like to our source tree to be readonly. However when releases or
158 # pre-releases are generated, the flex/bison generated files as well as the
159 # various formats of manuals need to be included along with the rest of the
160 # sources. Therefore we have --enable-generated-files-in-srcdir to do
163 AC_MSG_CHECKING([whether to place generated files in the source directory])
164 dnl generated-files-in-srcdir is disabled by default
165 AC_ARG_ENABLE(generated-files-in-srcdir,
166 [ --enable-generated-files-in-srcdir
167 put copies of generated files in source dir
168 intended for creating source tarballs for users
169 without texinfo bison or flex.],
170 generated_files_in_srcdir=$enableval,
171 generated_files_in_srcdir=no)
173 AC_MSG_RESULT($generated_files_in_srcdir)
175 if test "$generated_files_in_srcdir" = "yes"; then
182 # -------------------
183 # Find default linker
184 # -------------------
188 [ --with-gnu-ld arrange to work with GNU ld.],
189 gnu_ld_flag="$with_gnu_ld",
192 # With pre-defined ld
194 [ --with-ld arrange to use the specified ld (full pathname)],
195 DEFAULT_LINKER="$with_ld")
196 if test x"${DEFAULT_LINKER+set}" = x"set"; then
197 if test ! -x "$DEFAULT_LINKER"; then
198 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
199 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
202 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
203 [Define to enable the use of a default linker.])
206 gnu_ld=`if test x"$gnu_ld_flag" = x"yes"; then echo 1; else echo 0; fi`
207 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld, [Define if using GNU ld.])
209 AC_MSG_CHECKING([whether a default linker was specified])
210 if test x"${DEFAULT_LINKER+set}" = x"set"; then
211 if test x"$gnu_ld_flag" = x"no"; then
212 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
214 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
220 # With demangler in GNU ld
221 AC_ARG_WITH(demangler-in-ld,
222 [ --with-demangler-in-ld try to use demangler in GNU ld.],
223 demangler_in_ld="$with_demangler_in_ld",
226 # ----------------------
227 # Find default assembler
228 # ----------------------
232 [ --with-gnu-as arrange to work with GNU as],
233 gas_flag="$with_gnu_as",
237 [ --with-as arrange to use the specified as (full pathname)],
238 DEFAULT_ASSEMBLER="$with_as")
239 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
240 if test ! -x "$DEFAULT_ASSEMBLER"; then
241 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
242 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
245 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
246 [Define to enable the use of a default assembler.])
249 gnu_as=`if test x"$gas_flag" = x"yes"; then echo 1; else echo 0; fi`
250 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as, [Define if using GNU as.])
252 AC_MSG_CHECKING([whether a default assembler was specified])
253 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
254 if test x"$gas_flag" = x"no"; then
255 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
257 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
267 # If a non-executable a.out is present (e.g. created by GNU as above even if
268 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
269 # file, even when creating an executable, so an execution test fails.
270 # Remove possible default executable files to avoid this.
272 # FIXME: This really belongs into AC_PROG_CC and can be removed once
273 # Autoconf includes it.
274 rm -f a.out a.exe b.out
276 # Find the native compiler
280 ACX_PROG_GNAT([-I"$srcdir"/ada])
282 # autoconf is lame and doesn't give us any substitution variable for this.
283 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
284 NO_MINUS_C_MINUS_O=yes
286 OUTPUT_OPTION='-o $@'
288 AC_SUBST(NO_MINUS_C_MINUS_O)
289 AC_SUBST(OUTPUT_OPTION)
291 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
292 # optimizations to be activated explicitly by the toplevel.
295 *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
299 # -------------------------
300 # Check C compiler features
301 # -------------------------
303 AC_USE_SYSTEM_EXTENSIONS
309 # sizeof(char) is 1 by definition.
310 AC_CHECK_SIZEOF(void *)
311 AC_CHECK_SIZEOF(short)
313 AC_CHECK_SIZEOF(long)
314 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
315 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
318 # ---------------------
319 # Warnings and checking
320 # ---------------------
322 # Check $CC warning features (if it's GCC).
323 # We want to use -pedantic, but we don't want warnings about
327 # So, we only use -pedantic if we can disable those warnings.
329 ACX_PROG_CC_WARNING_OPTS(
330 m4_quote(m4_do([-W -Wall -Wwrite-strings -Wcast-qual])), [loose_warn])
331 ACX_PROG_CC_WARNING_OPTS(
332 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
334 ACX_PROG_CC_WARNING_OPTS(
335 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
336 ACX_PROG_CC_WARNING_OPTS(
337 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
338 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
339 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
340 [-Wno-overlength-strings])), [strict_warn])
341 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
343 # The above macros do nothing if the compiler is not GCC. However, the
344 # Makefile has more goo to add other flags, so these variables are used
345 # to enable warnings only for GCC.
348 if test "x$GCC" = "xyes"; then
349 warn_cflags='$(GCC_WARN_CFLAGS)'
350 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
352 AC_SUBST(warn_cflags)
353 AC_SUBST(warn_cxxflags)
355 # Enable expensive internal checks
357 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
361 AC_ARG_ENABLE(checking,
362 [ --enable-checking[=LIST]
363 enable expensive run-time checks. With LIST,
364 enable only specific categories of checks.
365 Categories are: yes,no,all,none,release.
366 Flags are: assert,df,fold,gc,gcac,gimple,misc,
367 rtlflag,rtl,runtime,tree,valgrind,types.],
368 [ac_checking_flags="${enableval}"],[
369 # Determine the default checks.
370 if test x$is_release = x ; then
371 ac_checking_flags=yes
373 ac_checking_flags=release
375 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
376 for check in release $ac_checking_flags
379 # these set all the flags to specific states
380 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
381 ac_fold_checking= ; ac_gc_checking=1 ;
382 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
383 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
384 ac_tree_checking=1 ; ac_valgrind_checking= ;
385 ac_types_checking=1 ;;
386 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
387 ac_fold_checking= ; ac_gc_checking= ;
388 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
389 ac_rtlflag_checking= ; ac_runtime_checking= ;
390 ac_tree_checking= ; ac_valgrind_checking= ;
391 ac_types_checking= ;;
392 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
393 ac_fold_checking=1 ; ac_gc_checking=1 ;
394 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
395 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
396 ac_tree_checking=1 ; ac_valgrind_checking= ;
397 ac_types_checking=1 ;;
398 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
399 ac_fold_checking= ; ac_gc_checking= ;
400 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
401 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
402 ac_tree_checking= ; ac_valgrind_checking= ;
403 ac_types_checking= ;;
404 # these enable particular checks
405 assert) ac_assert_checking=1 ;;
406 df) ac_df_checking=1 ;;
407 fold) ac_fold_checking=1 ;;
408 gc) ac_gc_checking=1 ;;
409 gcac) ac_gc_always_collect=1 ;;
410 gimple) ac_gimple_checking=1 ;;
411 misc) ac_checking=1 ;;
412 rtl) ac_rtl_checking=1 ;;
413 rtlflag) ac_rtlflag_checking=1 ;;
414 runtime) ac_runtime_checking=1 ;;
415 tree) ac_tree_checking=1 ;;
416 types) ac_types_checking=1 ;;
417 valgrind) ac_valgrind_checking=1 ;;
418 *) AC_MSG_ERROR(unknown check category $check) ;;
424 if test x$ac_checking != x ; then
425 AC_DEFINE(ENABLE_CHECKING, 1,
426 [Define if you want more run-time sanity checks. This one gets a grab
427 bag of miscellaneous but relatively cheap checks.])
428 nocommon_flag=-fno-common
430 AC_SUBST(nocommon_flag)
431 if test x$ac_df_checking != x ; then
432 AC_DEFINE(ENABLE_DF_CHECKING, 1,
433 [Define if you want more run-time sanity checks for dataflow.])
435 if test x$ac_assert_checking != x ; then
436 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
437 [Define if you want assertions enabled. This is a cheap check.])
439 if test x$ac_gimple_checking != x ; then
440 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
441 [Define if you want operations on GIMPLE (the basic data structure of
442 the high-level optimizers) to be checked for dynamic type safety at
443 runtime. This is moderately expensive.])
445 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
446 if test x$ac_runtime_checking != x ; then
447 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
448 [Define if you want runtime assertions enabled. This is a cheap check.])
450 if test x$ac_tree_checking != x ; then
451 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
452 [Define if you want all operations on trees (the basic data
453 structure of the front ends) to be checked for dynamic type safety
454 at runtime. This is moderately expensive. The tree browser debugging
455 routines will also be enabled by this option.
457 TREEBROWSER=tree-browser.o
459 if test x$ac_types_checking != x ; then
460 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
461 [Define if you want all gimple types to be verified after gimplifiation.
465 AC_SUBST(TREEBROWSER)
466 if test x$ac_rtl_checking != x ; then
467 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
468 [Define if you want all operations on RTL (the basic data structure
469 of the optimizer and back end) to be checked for dynamic type safety
470 at runtime. This is quite expensive.])
472 if test x$ac_rtlflag_checking != x ; then
473 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
474 [Define if you want RTL flag accesses to be checked against the RTL
475 codes that are supported for each access macro. This is relatively
478 if test x$ac_gc_checking != x ; then
479 AC_DEFINE(ENABLE_GC_CHECKING, 1,
480 [Define if you want the garbage collector to do object poisoning and
481 other memory allocation checks. This is quite expensive.])
483 if test x$ac_gc_always_collect != x ; then
484 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
485 [Define if you want the garbage collector to operate in maximally
486 paranoid mode, validating the entire heap and collecting garbage at
487 every opportunity. This is extremely expensive.])
489 if test x$ac_fold_checking != x ; then
490 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
491 [Define if you want fold checked that it never destructs its argument.
492 This is quite expensive.])
494 valgrind_path_defines=
497 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
498 dnl # an if statement. This was the source of very frustrating bugs
499 dnl # in converting to autoconf 2.5x!
500 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
502 if test x$ac_valgrind_checking != x ; then
503 # It is certainly possible that there's valgrind but no valgrind.h.
504 # GCC relies on making annotations so we must have both.
505 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
506 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
507 [[#include <valgrind/memcheck.h>
508 #ifndef VALGRIND_DISCARD
509 #error VALGRIND_DISCARD not defined
511 [gcc_cv_header_valgrind_memcheck_h=yes],
512 [gcc_cv_header_valgrind_memcheck_h=no])
513 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
514 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
515 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
516 [[#include <memcheck.h>
517 #ifndef VALGRIND_DISCARD
518 #error VALGRIND_DISCARD not defined
520 [gcc_cv_header_memcheck_h=yes],
521 [gcc_cv_header_memcheck_h=no])
522 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
523 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
524 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
525 if test "x$valgrind_path" = "x" \
526 || (test $have_valgrind_h = no \
527 && test $gcc_cv_header_memcheck_h = no \
528 && test $gcc_cv_header_valgrind_memcheck_h = no); then
529 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
531 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
532 valgrind_command="$valgrind_path -q"
533 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
534 [Define if you want to run subprograms and generated programs
535 through valgrind (a memory checker). This is extremely expensive.])
536 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
537 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
538 [Define if valgrind's valgrind/memcheck.h header is installed.])
540 if test $gcc_cv_header_memcheck_h = yes; then
541 AC_DEFINE(HAVE_MEMCHECK_H, 1,
542 [Define if valgrind's memcheck.h header is installed.])
545 AC_SUBST(valgrind_path_defines)
546 AC_SUBST(valgrind_command)
548 # Enable code coverage collection
549 AC_ARG_ENABLE(coverage,
550 [ --enable-coverage[=LEVEL]
551 enable compiler's code coverage collection.
552 Use to measure compiler performance and locate
553 unused parts of the compiler. With LEVEL, specify
554 optimization. Values are opt, noopt,
556 [case "${enableval}" in
558 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
561 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
564 # a.k.a. --disable-coverage
568 AC_MSG_ERROR(unknown coverage setting $enableval)
572 AC_SUBST(coverage_flags)
574 AC_ARG_ENABLE(gather-detailed-mem-stats,
575 [ --enable-gather-detailed-mem-stats enable detailed memory allocation stats gathering], [],
576 [enable_gather_detailed_mem_stats=no])
577 if test x$enable_gather_detailed_mem_stats = xyes ; then
578 AC_DEFINE(GATHER_STATISTICS, 1,
579 [Define to enable detailed memory allocation stats gathering.])
582 # -------------------------------
583 # Miscenalleous configure options
584 # -------------------------------
586 # See if we are building gcc with C++.
587 AC_ARG_ENABLE(build-with-cxx,
588 [ --enable-build-with-cxx build with C++ compiler instead of C compiler],
589 ENABLE_BUILD_WITH_CXX=$enableval,
590 ENABLE_BUILD_WITH_CXX=no)
591 AC_SUBST(ENABLE_BUILD_WITH_CXX)
595 [ --with-stabs arrange to use stabs instead of host debug format],
599 # Determine whether or not multilibs are enabled.
600 AC_ARG_ENABLE(multilib,
601 [ --enable-multilib enable library support for multiple ABIs],
602 [], [enable_multilib=yes])
603 AC_SUBST(enable_multilib)
605 # Enable __cxa_atexit for C++.
606 AC_ARG_ENABLE(__cxa_atexit,
607 [ --enable-__cxa_atexit enable __cxa_atexit for C++],
610 # Enable C extension for decimal float if target supports it.
611 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
613 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
614 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
615 [Define to 1 to enable decimal float extension to C.])
617 # Use default_decimal_float for dependency.
618 enable_decimal_float=$default_decimal_float
620 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
621 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
622 [Define to 1 to specify that we are using the BID decimal floating
623 point format instead of DPD])
625 # Enable C extension for fixed-point arithmetic.
626 AC_ARG_ENABLE(fixed-point,
627 [ --enable-fixed-point enable fixed-point arithmetic extension to C],
635 AC_MSG_WARN([fixed-point is not supported on IRIX, ignored])
636 enable_fixed_point=no
639 enable_fixed_point=yes
644 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
645 enable_fixed_point=no
649 AC_SUBST(enable_fixed_point)
651 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
652 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
653 [Define to 1 to enable fixed-point arithmetic extension to C.])
656 # Pass with no value to take the default
657 # Pass with a value to specify a thread package
658 AC_ARG_ENABLE(threads,
659 [ --enable-threads enable thread usage for target GCC
660 --enable-threads=LIB use LIB thread package for target GCC],,
664 [ --enable-tls enable or disable generation of tls code
665 overriding the assembler check for tls support],
669 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
670 Valid choices are 'yes' and 'no'.]) ;;
674 AC_ARG_ENABLE(objc-gc,
675 [ --enable-objc-gc enable the use of Boehm's garbage collector with
676 the GNU Objective-C runtime],
677 if test x$enable_objc_gc = xno; then
685 [ --with-dwarf2 force the default debug format to be DWARF 2],
686 dwarf2="$with_dwarf2",
689 AC_ARG_ENABLE(shared,
690 [ --disable-shared don't provide a shared libgcc],
692 case $enable_shared in
696 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
697 for pkg in $enableval; do
698 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
705 ], [enable_shared=yes])
706 AC_SUBST(enable_shared)
708 AC_ARG_WITH(build-sysroot,
709 [ --with-build-sysroot=sysroot
710 use sysroot as the system root during the build])
713 [ --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
715 case ${with_sysroot} in
716 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
717 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
720 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
721 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
723 if test "x$prefix" = xNONE; then
724 test_prefix=/usr/local
728 if test "x$exec_prefix" = xNONE; then
729 test_exec_prefix=$test_prefix
731 test_exec_prefix=$exec_prefix
733 case ${TARGET_SYSTEM_ROOT} in
734 "${test_prefix}"|"${test_prefix}/"*|\
735 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
736 '${prefix}'|'${prefix}/'*|\
737 '${exec_prefix}'|'${exec_prefix}/'*)
738 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
739 TARGET_SYSTEM_ROOT_DEFINE="$t"
744 TARGET_SYSTEM_ROOT_DEFINE=
745 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
747 AC_SUBST(TARGET_SYSTEM_ROOT)
748 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
749 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
752 [AS_HELP_STRING([--with-specs=SPECS],
753 [add SPECS to driver command-line processing])],
754 [CONFIGURE_SPECS=$withval],
757 AC_SUBST(CONFIGURE_SPECS)
759 ACX_PKGVERSION([GCC])
760 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
762 # Sanity check enable_languages in case someone does not run the toplevel
763 # configure # script.
764 AC_ARG_ENABLE(languages,
765 [ --enable-languages=LIST specify which front-ends to build],
766 [case ,${enable_languages}, in
768 # go safe -- we cannot be much sure without the toplevel
770 # analysis of which target libs are present and usable
774 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
779 enable_languages=c,${enable_languages}
782 [enable_languages=c])
784 AC_ARG_WITH(multilib-list,
785 [ --with-multilib-list Select multilibs (SH only)],
787 with_multilib_list=default)
789 # -------------------------
790 # Checks for other programs
791 # -------------------------
795 # Find some useful tools
797 # We need awk to create options.c and options.h.
798 # Bail out if it's missing.
800 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
808 # By default, the Darwin ranlib will not treat common symbols as
809 # definitions when building the archive table of contents. Other
810 # ranlibs do that; pass an option to the Darwin ranlib that makes
811 # it behave similarly.
817 AC_SUBST(ranlib_flags)
821 # See if cmp has --ignore-initial.
822 gcc_AC_PROG_CMP_IGNORE_INITIAL
824 # See if we have the mktemp command.
825 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
827 # See if makeinfo has been installed and is modern enough
828 # that we can use it.
829 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
830 [GNU texinfo.* \([0-9][0-9.]*\)],
831 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
832 if test $gcc_cv_prog_makeinfo_modern = no; then
834 *** Makeinfo is missing or too old.
835 *** Info documentation will not be built.])
842 # Is pod2man recent enough to regenerate manpages?
843 AC_MSG_CHECKING([for recent Pod::Man])
844 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
846 GENERATED_MANPAGES=generated-manpages
851 AC_SUBST(GENERATED_MANPAGES)
853 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
856 dnl Don't use AC_PROG_LEX; we insist on flex.
857 dnl LEXLIB is not useful in gcc.
858 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
861 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
863 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
864 # check for build == host before using them.
867 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
868 && test -d ../binutils ; then
869 NM='${objdir}/../binutils/nm-new'
871 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
875 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
876 && test -d ../binutils ; then
877 AR='${objdir}/../binutils/ar'
879 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
883 # --------------------
884 # Checks for C headers
885 # --------------------
887 # Need to reject headers which give warnings, so that the -Werror bootstrap
888 # works later. *sigh* This needs to come before all header checks.
895 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
896 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
897 sys/resource.h sys/param.h sys/times.h sys/stat.h \
898 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
900 # Check for thread headers.
901 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
902 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
904 # These tests can't be done till we know if we have limits.h.
913 # These libraries may be used by collect2.
914 # We may need a special search path to get them linked.
915 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
917 for libs in '' -lld -lmld \
918 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
919 '-L/usr/lib/cmplrs/cc3.11 -lmld'
922 AC_TRY_LINK_FUNC(ldopen,
923 [gcc_cv_collect2_libs="$libs"; break])
926 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
927 case $gcc_cv_collect2_libs in
929 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
931 AC_SUBST(COLLECT2_LIBS)
933 # When building Ada code on Alpha, we need exc_resume which is usually in
934 # -lexc. So test for it.
937 AC_SEARCH_LIBS(exc_resume, exc)
940 AC_SUBST(GNAT_LIBEXC)
942 # Some systems put ldexp and frexp in libm instead of libc; assume
943 # they're both in the same place. jcf-dump needs them.
946 AC_SEARCH_LIBS(ldexp, m)
951 # Use <inttypes.h> only if it exists,
952 # doesn't clash with <sys/types.h>, and declares intmax_t.
953 AC_MSG_CHECKING(for inttypes.h)
954 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
955 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
956 [[#include <sys/types.h>
957 #include <inttypes.h>]],
958 [[intmax_t i = -1;]])],
959 [gcc_cv_header_inttypes_h=yes],
960 [gcc_cv_header_inttypes_h=no])])
961 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
962 if test $gcc_cv_header_inttypes_h = yes; then
963 AC_DEFINE(HAVE_INTTYPES_H, 1,
964 [Define if you have a working <inttypes.h> header file.])
967 dnl Disabled until we have a complete test for buggy enum bitfields.
968 dnl gcc_AC_C_ENUM_BF_UNSIGNED
970 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
971 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
972 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
973 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
974 putchar_unlocked putc_unlocked)
975 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
976 sysconf strsignal getrusage nl_langinfo \
977 gettimeofday mbstowcs wcswidth mmap setlocale \
980 if test x$ac_cv_func_mbstowcs = xyes; then
981 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
982 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
988 [gcc_cv_func_mbstowcs_works=yes],
989 [gcc_cv_func_mbstowcs_works=no],
990 [gcc_cv_func_mbstowcs_works=yes])])
991 if test x$gcc_cv_func_mbstowcs_works = xyes; then
992 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
993 [Define this macro if mbstowcs does not crash when its
994 first argument is NULL.])
998 AC_CHECK_TYPE(ssize_t, int)
999 AC_CHECK_TYPE(caddr_t, char *)
1001 gcc_AC_FUNC_MMAP_BLACKLIST
1005 # Under VMS, vfork works very differently than on Unix. The standard test
1006 # won't work, and it isn't easily adaptable. It makes more sense to
1008 ac_cv_func_vfork_works=yes
1014 # Until we have in-tree GNU iconv:
1016 AC_SUBST(LIBICONV_DEP)
1022 # We will need to find libiberty.h and ansidecl.h
1023 saved_CFLAGS="$CFLAGS"
1024 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1025 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1026 strsignal strstr strverscmp \
1027 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1028 free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1029 #include "ansidecl.h"
1030 #include "system.h"])
1032 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1033 #include "ansidecl.h"
1035 #ifdef HAVE_SYS_RESOURCE_H
1036 #include <sys/resource.h>
1040 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1041 #include "ansidecl.h"
1043 #ifdef HAVE_SYS_RESOURCE_H
1044 #include <sys/resource.h>
1046 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1047 [Define to `long' if <sys/resource.h> doesn't define.])])
1049 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1050 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1051 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1052 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1053 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1054 #include "ansidecl.h"
1063 gcc_AC_CHECK_DECLS(times, , ,[
1064 #include "ansidecl.h"
1066 #ifdef HAVE_SYS_TIMES_H
1067 #include <sys/times.h>
1071 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1072 #include "ansidecl.h"
1077 # More time-related stuff.
1078 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1079 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1080 #include "ansidecl.h"
1082 #ifdef HAVE_SYS_TIMES_H
1083 #include <sys/times.h>
1085 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1086 if test $ac_cv_struct_tms = yes; then
1087 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1088 [Define if <sys/times.h> defines struct tms.])
1091 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1092 # revisit after autoconf 2.50.
1093 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1094 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1095 #include "ansidecl.h"
1097 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1098 if test $gcc_cv_type_clock_t = yes; then
1099 AC_DEFINE(HAVE_CLOCK_T, 1,
1100 [Define if <time.h> defines clock_t.])
1103 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1104 CFLAGS="$saved_CFLAGS"
1106 gcc_AC_INITFINI_ARRAY
1108 # mkdir takes a single argument on some systems.
1109 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1117 # With Setjmp/Longjmp based exception handling.
1118 AC_ARG_ENABLE(sjlj-exceptions,
1119 [ --enable-sjlj-exceptions
1120 arrange to use setjmp/longjmp exception handling],
1123 if test $enableval != yes; then
1124 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1129 force_sjlj_exceptions=yes],
1132 force_sjlj_exceptions=yes
1136 force_sjlj_exceptions=no
1139 if test $force_sjlj_exceptions = yes; then
1140 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1141 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1142 [Define 0/1 to force the choice for exception handling model.])
1145 # For platforms with the unwind ABI which includes an unwind library,
1146 # libunwind, we can choose to use the system libunwind.
1147 # config.gcc also contains tests of with_system_libunwind.
1148 GCC_CHECK_UNWIND_GETIPINFO
1150 # --------------------------------------------------------
1151 # Build, host, and target specific configuration fragments
1152 # --------------------------------------------------------
1154 # Collect build-machine-specific information.
1155 . ${srcdir}/config.build
1157 # Collect host-machine-specific information.
1158 . ${srcdir}/config.host
1162 # Collect target-machine-specific information.
1163 . ${srcdir}/config.gcc
1165 extra_objs="${host_extra_objs} ${extra_objs}"
1166 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1168 # Default the target-machine variables that were not explicitly set.
1169 if test x"$tm_file" = x
1170 then tm_file=$cpu_type/$cpu_type.h; fi
1172 if test x"$extra_headers" = x
1173 then extra_headers=; fi
1175 if test x$md_file = x
1176 then md_file=$cpu_type/$cpu_type.md; fi
1178 if test x$out_file = x
1179 then out_file=$cpu_type/$cpu_type.c; fi
1181 if test x"$tmake_file" = x
1182 then tmake_file=$cpu_type/t-$cpu_type
1185 if test x"$dwarf2" = xyes
1186 then tm_file="$tm_file tm-dwarf2.h"
1189 # Say what files are being used for the output code and MD file.
1190 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1191 echo "Using \`$srcdir/config/$md_file' as machine description file."
1193 # If any of the xm_file variables contain nonexistent files, warn
1194 # about them and drop them.
1197 for x in $build_xm_file; do
1198 if test -f $srcdir/config/$x
1200 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1206 for x in $host_xm_file; do
1207 if test -f $srcdir/config/$x
1209 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1215 for x in $xm_file; do
1216 if test -f $srcdir/config/$x
1218 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1224 for f in $tm_file; do
1227 if test $count = ax; then
1228 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1230 echo "Using the following target machine macro files:"
1231 for f in $tm_file; do
1232 echo " $srcdir/config/$f"
1236 if test x$need_64bit_hwint = xyes; then
1237 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1238 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1241 if test x$use_long_long_for_widest_fast_int = xyes; then
1242 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1243 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1244 efficiently supported by the host hardware.])
1248 for f in $host_xm_file; do
1251 if test $count = a; then
1253 elif test $count = ax; then
1254 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1256 echo "Using the following host machine macro files:"
1257 for f in $host_xm_file; do
1258 echo " $srcdir/config/$f"
1261 echo "Using ${out_host_hook_obj} for host machine hooks."
1263 if test "$host_xm_file" != "$build_xm_file"; then
1265 for f in $build_xm_file; do
1268 if test $count = a; then
1270 elif test $count = ax; then
1271 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1273 echo "Using the following build machine macro files:"
1274 for f in $build_xm_file; do
1275 echo " $srcdir/config/$f"
1282 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1283 gcc_cv_mcontext_underscores,
1285 #include <sys/cdefs.h>
1286 #include <sys/signal.h>
1287 #include <ucontext.h>
1288 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1290 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1291 if test $gcc_cv_mcontext_underscores = yes; then
1292 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1293 [mcontext_t fields start with __])
1302 # Check if a valid thread package
1303 case ${enable_threads} in
1306 target_thread_file='single'
1310 target_thread_file='single'
1312 aix | dce | gnat | irix | posix | posix95 | rtems | \
1313 single | solaris | vxworks | win32 | mipssde)
1314 target_thread_file=${enable_threads}
1317 echo "${enable_threads} is an unknown thread package" 1>&2
1322 if test x${thread_file} = x; then
1323 # No thread file set by target-specific clauses in config.gcc,
1324 # so use file chosen by default logic above
1325 thread_file=${target_thread_file}
1328 # Make gthr-default.h if we have a thread file.
1330 if test $thread_file != single; then
1331 echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h-t
1332 if diff gthr-default.h-t gthr-default.h 2>/dev/null; then
1333 rm -f gthr-default.h-t
1335 mv -f gthr-default.h-t gthr-default.h
1337 gthread_flags=-DHAVE_GTHR_DEFAULT
1339 AC_SUBST(gthread_flags)
1346 if test x$enable___cxa_atexit = xyes || \
1347 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1348 if test x$host = x$target; then
1350 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1351 # keyed to flag_use_cxa_atexit
1356 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1357 [echo "__cxa_atexit can't be enabled on this target"])
1361 # We can't check for __cxa_atexit when building a cross, so assume
1365 if test x$use_cxa_atexit = xyes; then
1366 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1367 [Define if you want to use __cxa_atexit, rather than atexit, to
1368 register C++ destructors for local statics and global objects.
1369 This is essential for fully standards-compliant handling of
1370 destructors, but requires __cxa_atexit in libc.])
1374 # Look for a file containing extra machine modes.
1375 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1376 extra_modes_file='$(srcdir)'/config/${extra_modes}
1377 AC_SUBST(extra_modes_file)
1378 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1379 [Define to the name of a file containing a list of extra machine modes
1380 for this architecture.])
1383 # Convert extra_options into a form suitable for Makefile use.
1386 for f in $extra_options; do
1387 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1388 all_opt_files="$all_opt_files $srcdir/config/$f"
1390 AC_SUBST(extra_opt_files)
1392 # auto-host.h is the file containing items generated by autoconf and is
1393 # the first file included by config.h.
1394 # If host=build, it is correct to have bconfig include auto-host.h
1395 # as well. If host!=build, we are in error and need to do more
1396 # work to find out the build config parameters.
1397 if test x$host = x$build
1399 build_auto=auto-host.h
1401 # We create a subdir, then run autoconf in the subdir.
1402 # To prevent recursion we set host and build for the new
1403 # invocation of configure to the build for this invocation
1410 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1411 *) realsrcdir=../${srcdir};;
1413 saved_CFLAGS="${CFLAGS}"
1414 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1415 LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1416 ${realsrcdir}/configure \
1417 --enable-languages=${enable_languages-all} \
1418 --target=$target_alias --host=$build_alias --build=$build_alias
1419 CFLAGS="${saved_CFLAGS}"
1421 # We just finished tests for the build machine, so rename
1422 # the file auto-build.h in the gcc directory.
1423 mv auto-host.h ../auto-build.h
1426 build_auto=auto-build.h
1428 AC_SUBST(build_subdir)
1430 tm_file="${tm_file} defaults.h"
1431 tm_p_file="${tm_p_file} tm-preds.h"
1432 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1433 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1434 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1435 # put this back in temporarily.
1436 xm_file="auto-host.h ansidecl.h ${xm_file}"
1443 # Compile in configure arguments.
1444 if test -f configargs.h ; then
1445 # Being re-configured.
1446 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1447 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1449 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1452 # Double all backslashes and backslash all quotes to turn
1453 # gcc_config_arguments into a C string.
1454 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1455 $gcc_config_arguments
1457 gcc_config_arguments_str=`cat conftest.out`
1460 cat > configargs.h <<EOF
1461 /* Generated automatically. */
1462 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1463 static const char thread_model[] = "$thread_file";
1465 static const struct {
1466 const char *name, *value;
1467 } configure_default_options[] = $configure_default_options;
1472 gcc_BASEVER=`cat $srcdir/BASE-VER`
1473 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1474 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1475 if test -f $srcdir/REVISION ; then
1476 gcc_REVISION=`cat $srcdir/REVISION`
1480 cat > plugin-version.h <<EOF
1481 #include "configargs.h"
1483 static char basever[] = "$gcc_BASEVER";
1484 static char datestamp[] = "$gcc_DATESTAMP";
1485 static char devphase[] = "$gcc_DEVPHASE";
1486 static char revision[] = "$gcc_REVISION";
1488 /* FIXME plugins: We should make the version information more precise.
1489 One way to do is to add a checksum. */
1491 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1493 configuration_arguments};
1497 # Internationalization
1498 ZW_GNU_GETTEXT_SISTER_DIR
1500 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1501 # -liconv on the link line twice.
1502 case "$LIBINTL" in *$LIBICONV*)
1506 AC_ARG_ENABLE(secureplt,
1507 [ --enable-secureplt enable -msecure-plt by default for PowerPC],
1510 AC_ARG_ENABLE(leading-mingw64-underscores,
1511 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1512 [Enable leading underscores on 64 bit mingw targets]),
1514 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1515 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1516 [Define if we should use leading underscore on 64 bit mingw targets])])
1519 [ --enable-cld enable -mcld by default for 32bit x86], [],
1522 AC_ARG_ENABLE(frame-pointer,
1523 [ --enable-frame-pointer enable -fno-omit-frame-pointer by default for 32bit x86], [],
1526 linux* | darwin[[8912]]*)
1527 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1529 enable_frame_pointer=no
1532 enable_frame_pointer=yes
1537 # Windows32 Registry support for specifying GCC installation paths.
1538 AC_ARG_ENABLE(win32-registry,
1539 [ --disable-win32-registry
1540 disable lookup of installation paths in the
1541 Registry on Windows hosts
1542 --enable-win32-registry enable registry lookup (default)
1543 --enable-win32-registry=KEY
1544 use KEY instead of GCC version as the last portion
1545 of the registry key],,)
1548 win32 | pe | cygwin* | mingw32* | uwin*)
1549 if test "x$enable_win32_registry" != xno; then
1550 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1553 if test "x$enable_win32_registry" != xno; then
1554 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1555 [Define to 1 if installation paths should be looked up in the Windows
1556 Registry. Ignored on non-Windows hosts.])
1558 if test "x$enable_win32_registry" != xyes \
1559 && test "x$enable_win32_registry" != x; then
1560 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1561 [Define to be the last component of the Windows registry key under which
1562 to look for installation paths. The full key used will be
1563 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1564 The default is the GCC version number.])
1570 # Get an absolute path to the GCC top-level source directory
1571 holddir=`${PWDCMD-pwd}`
1573 topdir=`${PWDCMD-pwd}`
1576 # Conditionalize the makefile for this host machine.
1578 for f in ${host_xmake_file}
1580 if test -f ${srcdir}/config/$f
1582 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1586 # Conditionalize the makefile for this target machine.
1588 for f in ${tmake_file}
1590 if test -f ${srcdir}/config/$f
1592 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1595 tmake_file="${tmake_file_}"
1597 out_object_file=`basename $out_file .c`.o
1599 tm_file_list="options.h"
1600 tm_include_list="options.h insn-constants.h"
1601 for f in $tm_file; do
1604 f=`echo $f | sed 's/^..//'`
1605 tm_file_list="${tm_file_list} $f"
1606 tm_include_list="${tm_include_list} $f"
1609 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1610 tm_include_list="${tm_include_list} $f"
1613 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1614 tm_include_list="${tm_include_list} config/$f"
1621 for f in $tm_p_file; do
1624 tm_p_file_list="${tm_p_file_list} $f"
1625 tm_p_include_list="${tm_p_include_list} $f"
1628 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1629 tm_p_include_list="${tm_p_include_list} config/$f"
1635 for f in $xm_file; do
1638 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1639 xm_include_list="${xm_include_list} $f"
1642 xm_file_list="${xm_file_list} $f"
1643 xm_include_list="${xm_include_list} $f"
1646 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1647 xm_include_list="${xm_include_list} config/$f"
1653 host_xm_include_list=
1654 for f in $host_xm_file; do
1657 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1658 host_xm_include_list="${host_xm_include_list} $f"
1661 host_xm_file_list="${host_xm_file_list} $f"
1662 host_xm_include_list="${host_xm_include_list} $f"
1665 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1666 host_xm_include_list="${host_xm_include_list} config/$f"
1672 for f in $build_xm_file; do
1675 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1676 build_xm_include_list="${build_xm_include_list} $f"
1678 auto-build.h | auto-host.h )
1679 build_xm_file_list="${build_xm_file_list} $f"
1680 build_xm_include_list="${build_xm_include_list} $f"
1683 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1684 build_xm_include_list="${build_xm_include_list} config/$f"
1689 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1690 # cross-compiler which does not use the native headers and libraries.
1691 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1692 CROSS= AC_SUBST(CROSS)
1693 ALL=all.internal AC_SUBST(ALL)
1694 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1696 if test "x$with_build_sysroot" != x; then
1697 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1699 # This value is used, even on a native system, because
1700 # CROSS_SYSTEM_HEADER_DIR is just
1701 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1702 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1705 if test x$host != x$target
1707 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1709 SYSTEM_HEADER_DIR=$build_system_header_dir
1710 case "$host","$target" in
1711 # Darwin crosses can use the host system's libraries and headers,
1712 # because of the fat library support. Of course, it must be the
1713 # same version of Darwin on both sides. Allow the user to
1714 # just say --target=foo-darwin without a version number to mean
1715 # "the version on this system".
1716 *-*-darwin*,*-*-darwin*)
1717 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1718 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1719 if test $hostos = $targetos -o $targetos = darwin ; then
1721 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1726 i?86-*-*,x86_64-*-* \
1727 | powerpc*-*-*,powerpc64*-*-*)
1728 CROSS="$CROSS -DNATIVE_CROSS" ;;
1733 if test "x$with_headers" = x; then
1740 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1741 SYSTEM_HEADER_DIR=$build_system_header_dir
1744 # If this is a cross-compiler that does not
1745 # have its own set of headers then define
1748 # If this is using newlib, without having the headers available now,
1749 # then define inhibit_libc in LIBGCC2_CFLAGS.
1750 # This prevents libgcc2 from containing any code which requires libc
1752 : ${inhibit_libc=false}
1753 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1754 test x$with_newlib = xyes ; } &&
1755 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1758 AC_SUBST(inhibit_libc)
1760 # When building gcc with a cross-compiler, we need to adjust things so
1761 # that the generator programs are still built with the native compiler.
1762 # Also, we cannot run fixincludes.
1764 # These are the normal (build=host) settings:
1765 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1766 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1767 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1768 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1770 # And these apply if build != host, or we are generating coverage data
1771 if test x$build != x$host || test "x$coverage_flags" != x
1773 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1774 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1777 # Expand extra_headers to include complete path.
1778 # This substitutes for lots of t-* files.
1780 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1781 for file in ${extra_headers} ; do
1782 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1785 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1786 if test x"$use_gcc_tgmath" = xyes
1787 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1790 # Define collect2 in Makefile.
1791 case $host_can_use_collect2 in
1793 *) collect2='collect2$(exeext)' ;;
1795 AC_SUBST([collect2])
1797 # Add a definition of USE_COLLECT2 if system wants one.
1798 case $use_collect2 in
1799 no) use_collect2= ;;
1802 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1803 xm_defines="${xm_defines} USE_COLLECT2"
1804 case $host_can_use_collect2 in
1806 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1812 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1813 [Define to the name of the LTO plugin DSO that must be
1814 passed to the linker's -plugin=LIB option.])
1816 # ---------------------------
1817 # Assembler & linker features
1818 # ---------------------------
1820 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1821 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1822 # However when ld-new is first executed from the build tree, libtool will
1823 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1824 # to the build tree. While doing this we need to use the previous-stage
1825 # linker, or we have an infinite loop. The presence of a shell script as
1826 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1827 # the gcc/collect-ld script. So we need to know how libtool works, or
1828 # exec-tool will fail.
1830 m4_defun([_LT_CONFIG_COMMANDS], [])
1833 AC_SUBST(enable_fast_install)
1835 # Identify the assembler which will work hand-in-glove with the newly
1836 # built GCC, so that we can examine its features. This is the assembler
1837 # which will be driven by the driver program.
1839 # If build != host, and we aren't building gas in-tree, we identify a
1840 # build->target assembler and hope that it will have the same features
1841 # as the host->target assembler we'll be using.
1842 gcc_cv_gas_major_version=
1843 gcc_cv_gas_minor_version=
1844 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1846 m4_pattern_allow([AS_FOR_TARGET])dnl
1847 AS_VAR_SET_IF(gcc_cv_as,, [
1848 if test -x "$DEFAULT_ASSEMBLER"; then
1849 gcc_cv_as="$DEFAULT_ASSEMBLER"
1850 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1851 && test -f ../gas/Makefile \
1852 && test x$build = x$host; then
1853 gcc_cv_as=../gas/as-new$build_exeext
1854 elif test -x as$build_exeext; then
1855 # Build using assembler in the current directory.
1856 gcc_cv_as=./as$build_exeext
1857 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
1858 gcc_cv_as="$AS_FOR_TARGET"
1860 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1863 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1864 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1865 case "$ORIGINAL_AS_FOR_TARGET" in
1866 ./as | ./as$build_exeext) ;;
1867 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1870 AC_MSG_CHECKING(what assembler to use)
1871 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1872 # Single tree build which includes gas. We want to prefer it
1873 # over whatever linker top-level may have detected, since
1874 # we'll use what we're building after installation anyway.
1875 AC_MSG_RESULT(newly built gas)
1877 _gcc_COMPUTE_GAS_VERSION
1878 in_tree_gas_is_elf=no
1879 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1880 || (grep 'obj_format = multi' ../gas/Makefile \
1881 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1883 in_tree_gas_is_elf=yes
1886 AC_MSG_RESULT($gcc_cv_as)
1890 # Identify the linker which will work hand-in-glove with the newly
1891 # built GCC, so that we can examine its features. This is the linker
1892 # which will be driven by the driver program.
1894 # If build != host, and we aren't building gas in-tree, we identify a
1895 # build->target linker and hope that it will have the same features
1896 # as the host->target linker we'll be using.
1897 gcc_cv_gld_major_version=
1898 gcc_cv_gld_minor_version=
1899 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1900 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1902 AS_VAR_SET_IF(gcc_cv_ld,, [
1903 if test -x "$DEFAULT_LINKER"; then
1904 gcc_cv_ld="$DEFAULT_LINKER"
1905 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1906 && test -f ../ld/Makefile \
1907 && test x$build = x$host; then
1908 gcc_cv_ld=../ld/ld-new$build_exeext
1909 elif test -x collect-ld$build_exeext; then
1910 # Build using linker in the current directory.
1911 gcc_cv_ld=./collect-ld$build_exeext
1912 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
1913 gcc_cv_ld="$LD_FOR_TARGET"
1915 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1918 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
1919 PLUGIN_LD=`basename $gcc_cv_ld`
1920 AC_ARG_WITH(plugin-ld,
1921 [ --with-plugin-ld=[[ARG]] specify the plugin linker],
1922 [if test x"$withval" != x; then
1923 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
1924 PLUGIN_LD="$withval"
1926 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
1927 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
1929 # Check to see if we are using gold instead of ld
1930 AC_MSG_CHECKING(whether we are using gold)
1932 if test x$gcc_cv_ld != x; then
1933 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
1934 | grep "GNU gold" > /dev/null; then
1938 AC_MSG_RESULT($ld_is_gold)
1940 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
1941 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
1942 case "$ORIGINAL_LD_FOR_TARGET" in
1943 ./collect-ld | ./collect-ld$build_exeext) ;;
1944 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
1947 AC_MSG_CHECKING(what linker to use)
1948 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then
1949 # Single tree build which includes ld. We want to prefer it
1950 # over whatever linker top-level may have detected, since
1951 # we'll use what we're building after installation anyway.
1952 AC_MSG_RESULT(newly built ld)
1954 in_tree_ld_is_elf=no
1955 if (grep 'EMUL = .*elf' ../ld/Makefile \
1956 || grep 'EMUL = .*linux' ../ld/Makefile \
1957 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1958 in_tree_ld_is_elf=yes
1960 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
1963 gcc_cv_gld_version=`sed -n -e 's/^[ ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1964 if test x$gcc_cv_gld_version != x; then
1968 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1969 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1972 AC_MSG_RESULT($gcc_cv_ld)
1976 # Figure out what nm we will be using.
1977 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1978 AS_VAR_SET_IF(gcc_cv_nm,, [
1979 if test -f $gcc_cv_binutils_srcdir/configure.in \
1980 && test -f ../binutils/Makefile \
1981 && test x$build = x$host; then
1982 gcc_cv_nm=../binutils/nm-new$build_exeext
1983 elif test -x nm$build_exeext; then
1984 gcc_cv_nm=./nm$build_exeext
1985 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
1986 gcc_cv_nm="$NM_FOR_TARGET"
1988 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
1991 AC_MSG_CHECKING(what nm to use)
1992 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
1993 # Single tree build which includes binutils.
1994 AC_MSG_RESULT(newly built nm)
1997 AC_MSG_RESULT($gcc_cv_nm)
2001 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2002 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2003 case "$ORIGINAL_NM_FOR_TARGET" in
2004 ./nm | ./nm$build_exeext) ;;
2005 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2009 # Figure out what objdump we will be using.
2010 AS_VAR_SET_IF(gcc_cv_objdump,, [
2011 if test -f $gcc_cv_binutils_srcdir/configure.in \
2012 && test -f ../binutils/Makefile \
2013 && test x$build = x$host; then
2014 # Single tree build which includes binutils.
2015 gcc_cv_objdump=../binutils/objdump$build_exeext
2016 elif test -x objdump$build_exeext; then
2017 gcc_cv_objdump=./objdump$build_exeext
2018 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2019 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2021 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2024 AC_MSG_CHECKING(what objdump to use)
2025 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2026 # Single tree build which includes binutils.
2027 AC_MSG_RESULT(newly built objdump)
2028 elif test x$gcc_cv_objdump = x; then
2029 AC_MSG_RESULT(not found)
2031 AC_MSG_RESULT($gcc_cv_objdump)
2034 # Figure out what readelf we will be using.
2035 AS_VAR_SET_IF(gcc_cv_readelf,, [
2036 if test -f $gcc_cv_binutils_srcdir/configure.in \
2037 && test -f ../binutils/Makefile \
2038 && test x$build = x$host; then
2039 # Single tree build which includes binutils.
2040 gcc_cv_readelf=../binutils/readelf$build_exeext
2041 elif test -x readelf$build_exeext; then
2042 gcc_cv_readelf=./readelf$build_exeext
2044 AC_PATH_PROG(gcc_cv_readelf, readelf)
2047 AC_MSG_CHECKING(what readelf to use)
2048 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2049 # Single tree build which includes binutils.
2050 AC_MSG_RESULT(newly built readelf)
2051 elif test x$gcc_cv_readelf = x; then
2052 AC_MSG_RESULT(not found)
2054 AC_MSG_RESULT($gcc_cv_readelf)
2057 # Figure out what assembler alignment features are present.
2058 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2062 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2063 [Define if your assembler supports .balign and .p2align.])])
2065 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2068 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2069 [Define if your assembler supports specifying the maximum number
2070 of bytes to skip when using the GAS .p2align command.])])
2072 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2075 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2076 [Define if your assembler supports .literal16.])])
2078 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2080 [conftest_label1: .word 0
2082 conftest_label2: .word 0
2084 [if test x$gcc_cv_nm != x; then
2085 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2086 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2087 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2089 else gcc_cv_as_subsection_m1=yes
2091 rm -f conftest.nm1 conftest.nm2
2093 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2094 [Define if your assembler supports .subsection and .subsection -1 starts
2095 emitting at the beginning of your section.])])
2097 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2100 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2102 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2104 [ .weakref foobar, barfnot],,
2105 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2107 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2110 .NSUBSPA $CODE$,COMDAT],,
2111 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2113 # .hidden needs to be supported in both the assembler and the linker,
2114 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2115 # This is irritatingly difficult to feature test for; we have to check the
2116 # date string after the version number. If we've got an in-tree
2117 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2119 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2120 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2124 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2125 # STV_HIDDEN, so disable .hidden support if so.
2128 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2129 cat > conftest.s <<EOF
2136 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2137 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2138 grep '\.hidden default' > /dev/null; then
2141 gcc_cv_as_hidden=yes
2144 # Assume bug is present if objdump is missing.
2149 gcc_cv_as_hidden=yes
2153 # gnu_indirect_function type is an extension proposed at
2154 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2155 # selection of function implementation
2156 AC_ARG_ENABLE(gnu-indirect-function,
2157 [AS_HELP_STRING([--enable-gnu-indirect-function],
2158 [enable the use of the @gnu_indirect_function to glibc systems])],
2159 [case $enable_gnu_indirect_function in
2161 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2162 Valid choices are 'yes' and 'no'.]) ;;
2164 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2165 if test x$enable_gnu_indirect_function = xyes; then
2166 AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2167 [Define if your system supports gnu indirect functions.])
2171 if test $in_tree_ld != yes ; then
2172 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2173 if test x"$ld_is_gold" = xyes; then
2174 gcc_cv_ld_hidden=yes
2175 elif echo "$ld_ver" | grep GNU > /dev/null; then
2176 ld_vers=`echo $ld_ver | sed -n \
2177 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2178 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'`
2179 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2180 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2181 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2186 # Solaris 2 ld -V output looks like this for a regular version:
2188 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2190 # but test versions add stuff at the end:
2192 # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2194 ld_ver=`$gcc_cv_ld -V 2>&1`
2195 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2196 ld_vers=`echo $ld_ver | sed -n \
2197 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2198 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2199 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2207 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2208 [[if test $in_tree_ld = yes ; then
2210 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 \
2211 && test $in_tree_ld_is_elf = yes; then
2212 gcc_cv_ld_hidden=yes
2215 gcc_cv_ld_hidden=yes
2216 if echo "$ld_ver" | grep GNU > /dev/null; then
2217 if test 0"$ld_date" -lt 20020404; then
2218 if test -n "$ld_date"; then
2219 # If there was date string, but was earlier than 2002-04-04, fail
2221 elif test -z "$ld_vers"; then
2222 # If there was no date string nor ld version number, something is wrong
2225 test -z "$ld_vers_patch" && ld_vers_patch=0
2226 if test "$ld_vers_major" -lt 2; then
2228 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2229 gcc_cv_ld_hidden="no"
2230 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2237 hppa64*-*-hpux* | ia64*-*-hpux*)
2238 gcc_cv_ld_hidden=yes
2241 # .hidden support was backported to Solaris 8, starting with ld
2243 if test "$ld_vers_minor" -ge 276; then
2244 gcc_cv_ld_hidden=yes
2249 *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2250 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2251 # .symbolic was only added in Solaris 9 12/02.
2252 gcc_cv_ld_hidden=yes
2260 libgcc_visibility=no
2261 AC_SUBST(libgcc_visibility)
2262 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2263 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2264 libgcc_visibility=yes
2265 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2266 [Define if your assembler and linker support .hidden.])
2269 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2270 gcc_cv_ld_ro_rw_mix=unknown
2271 if test $in_tree_ld = yes ; then
2272 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 \
2273 && test $in_tree_ld_is_elf = yes; then
2274 gcc_cv_ld_ro_rw_mix=read-write
2276 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2277 echo '.section myfoosect, "a"' > conftest1.s
2278 echo '.section myfoosect, "aw"' > conftest2.s
2279 echo '.byte 1' >> conftest2.s
2280 echo '.section myfoosect, "a"' > conftest3.s
2281 echo '.byte 0' >> conftest3.s
2282 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2283 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2284 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2285 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2286 conftest2.o conftest3.o > /dev/null 2>&1; then
2287 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2288 | sed -e '/myfoosect/!d' -e N`
2289 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2290 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2291 gcc_cv_ld_ro_rw_mix=read-only
2293 gcc_cv_ld_ro_rw_mix=read-write
2298 rm -f conftest.* conftest[123].*
2301 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2302 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2303 [Define if your linker links a mix of read-only
2304 and read-write sections into a read-write section.])
2306 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2308 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2309 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2317 [[# GAS versions before 2.11 do not support uleb128,
2318 # despite appearing to.
2319 # ??? There exists an elf-specific test that will crash
2320 # the assembler. Perhaps it's better to figure out whether
2321 # arbitrary sections are supported and try the test.
2322 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2323 if echo "$as_ver" | grep GNU > /dev/null; then
2324 as_vers=`echo $as_ver | sed -n \
2325 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2326 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2327 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2328 if test $as_major -eq 2 && test $as_minor -lt 11
2330 else gcc_cv_as_leb128=yes
2333 [AC_DEFINE(HAVE_AS_LEB128, 1,
2334 [Define if your assembler supports .sleb128 and .uleb128.])])
2336 # Check if we have assembler support for unwind directives.
2337 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2344 .cfi_escape 1, 2, 3, 4, 5
2348 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2349 # read-only and read-write sections, we need to make sure that the
2350 # assembler used emits read-write .eh_frame sections.
2351 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2352 if test "x$gcc_cv_objdump" != x; then
2353 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2354 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2355 gcc_cv_as_cfi_directive=no
2358 i?86-*-solaris2.1[[0-9]]*)
2359 # On Solaris/x86, make sure that GCC and gas agree on using
2360 # read-only .eh_frame sections for 64-bit.
2361 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2362 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2363 sed -e /.eh_frame/!d -e N | \
2364 grep READONLY > /dev/null; then
2365 gcc_cv_as_cfi_directive=yes
2367 gcc_cv_as_cfi_directive=no
2371 gcc_cv_as_cfi_directive=yes
2376 # no objdump, err on the side of caution
2377 gcc_cv_as_cfi_directive=no
2380 gcc_cv_as_cfi_directive=yes
2384 gcc_cv_as_cfi_directive=yes
2387 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2388 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2392 .cfi_adjust_cfa_offset 64
2394 .cfi_adjust_cfa_offset 128
2397 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2398 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2399 gcc_cv_as_cfi_advance_working=yes
2403 # no objdump, err on the side of caution
2404 gcc_cv_as_cfi_advance_working=no
2406 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2407 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2408 [`if test $gcc_cv_as_cfi_directive = yes \
2409 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2410 [Define 0/1 if your assembler supports CFI directives.])
2412 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2413 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2414 gcc_cv_as_cfi_personality_directive, ,,
2417 .cfi_personality 0, symbol
2419 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2420 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2421 then echo 1; else echo 0; fi`],
2422 [Define 0/1 if your assembler supports .cfi_personality.])
2424 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2425 gcc_cv_as_cfi_sections_directive, ,,
2427 .cfi_sections .debug_frame, .eh_frame
2431 win32 | pe | cygwin* | mingw32* | uwin*)
2432 # Need to check that we generated the correct relocation for the
2433 # .debug_frame section. This was fixed for binutils 2.21.
2434 gcc_cv_as_cfi_sections_directive=no
2435 if test "x$gcc_cv_objdump" != x; then
2436 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2437 grep secrel > /dev/null; then
2438 gcc_cv_as_cfi_sections_directive=yes
2443 gcc_cv_as_cfi_sections_directive=yes
2446 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2447 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2448 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2449 then echo 1; else echo 0; fi`],
2450 [Define 0/1 if your assembler supports .cfi_sections.])
2452 # GAS versions up to and including 2.11.0 may mis-optimize
2454 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2462 .section .eh_frame,"aw",@progbits
2464 .4byte .LECIE1-.LSCIE1
2478 .4byte .LEFDE1-.LASFDE1
2480 .4byte .LASFDE1-__FRAME_BEGIN__
2488 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2489 cat > conftest.lit <<EOF
2490 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2491 0010 01000000 12000000 18000000 00000000 ................
2492 0020 08000000 04080000 0044 .........D @&t@
2494 cat > conftest.big <<EOF
2495 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2496 0010 00000001 00000012 00000018 00000000 ................
2497 0020 00000008 04000000 0844 .........D @&t@
2499 # If the assembler didn't choke, and we can objdump,
2500 # and we got the correct data, then succeed.
2501 # The text in the here-document typically retains its unix-style line
2502 # endings, while the output of objdump will use host line endings.
2503 # Therefore, use diff -b for the comparisons.
2504 if test x$gcc_cv_objdump != x \
2505 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2506 | tail -3 > conftest.got \
2507 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2508 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2510 gcc_cv_as_eh_frame=yes
2511 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2512 gcc_cv_as_eh_frame=buggy
2514 # Uh oh, what do we do now?
2515 gcc_cv_as_eh_frame=no
2518 if test $gcc_cv_as_eh_frame = buggy; then
2519 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2520 [Define if your assembler mis-optimizes .eh_frame data.])
2523 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2524 [elf,2,12,0], [--fatal-warnings],
2525 [.section .rodata.str, "aMS", @progbits, 1])
2526 if test $gcc_cv_as_shf_merge = no; then
2527 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2528 [elf,2,12,0], [--fatal-warnings],
2529 [.section .rodata.str, "aMS", %progbits, 1])
2531 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2532 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2533 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2535 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2536 [elf,2,16,0], [--fatal-warnings],
2537 [.section .text,"axG",@progbits,.foo,comdat])
2538 if test $gcc_cv_as_comdat_group = yes; then
2539 gcc_cv_as_comdat_group_percent=no
2541 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2542 [elf,2,16,0], [--fatal-warnings],
2543 [.section .text,"axG",%progbits,.foo,comdat])
2545 if test x"$ld_is_gold" = xyes; then
2547 elif test $in_tree_ld = yes ; then
2549 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 \
2550 && test $in_tree_ld_is_elf = yes; then
2553 elif echo "$ld_ver" | grep GNU > /dev/null; then
2555 if test 0"$ld_date" -lt 20050308; then
2556 if test -n "$ld_date"; then
2557 # If there was date string, but was earlier than 2005-03-08, fail
2559 elif test "$ld_vers_major" -lt 2; then
2561 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2568 *-*-solaris2.1[1-9]*)
2569 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2570 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2573 # FIXME: Maybe need to refine later when COMDAT group support with
2574 # Sun as is implemented.
2575 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 1688; then
2582 # Assume linkers other than GNU ld don't support COMDAT group.
2588 # Allow overriding the automatic COMDAT group tests above.
2589 AC_ARG_ENABLE(comdat,
2590 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2591 [comdat_group="$enable_comdat"])
2592 if test $comdat_group = no; then
2593 gcc_cv_as_comdat_group=no
2594 gcc_cv_as_comdat_group_percent=no
2596 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2597 [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2598 [Define 0/1 if your assembler and linker support COMDAT groups.])
2600 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2601 gcc_cv_as_discriminator,
2605 .loc 1 1 0 discriminator 1],,
2606 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2607 [Define if your assembler supports the .loc discriminator sub-directive.])])
2609 # Thread-local storage - the check is heavily parameterized.
2618 .section ".tdata","awT",@progbits
2621 ldq $27,__tls_get_addr($29) !literal!1
2622 lda $16,foo($29) !tlsgd!1
2623 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2624 ldq $27,__tls_get_addr($29) !literal!2
2625 lda $16,foo($29) !tlsldm!2
2626 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2627 ldq $1,foo($29) !gotdtprel
2628 ldah $2,foo($29) !dtprelhi
2629 lda $3,foo($2) !dtprello
2630 lda $4,foo($29) !dtprel
2631 ldq $1,foo($29) !gottprel
2632 ldah $2,foo($29) !tprelhi
2633 lda $3,foo($2) !tprello
2634 lda $4,foo($29) !tprel'
2637 tls_as_opt=--fatal-warnings
2639 cris-*-*|crisv32-*-*)
2641 .section ".tdata","awT",@progbits
2648 tls_as_opt=--fatal-warnings
2652 .section ".tdata","awT",@progbits
2664 .section ".tdata","awT",@progbits
2668 addil LT%foo-$tls_gdidx$,gp
2669 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2672 addil LT%foo-$tls_ldidx$,gp
2674 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2675 addil LR%foo-$tls_dtpoff$,%ret0
2676 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2678 addil LT%foo-$tls_ieoff$,gp
2679 ldw RT%foo-$tls_ieoff$(%r1),%t2
2682 addil LR%foo-$tls_leoff$,%t1
2683 ldo RR%foo-$tls_leoff$(%r1),%t2'
2686 tls_as_opt=--fatal-warnings
2690 .section ".tdata","awT",%progbits
2703 i[34567]86-*-solaris2.*)
2705 tga_func=___tls_get_addr
2711 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2713 .section .tdata,"awt",@progbits'
2717 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2718 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2722 .section ".tdata","awT",@progbits'
2725 tls_as_opt="--fatal-warnings"
2727 conftest_s="$conftest_s
2731 leal foo@tlsgd(,%ebx,1), %eax
2732 leal foo@tlsldm(%ebx), %eax
2733 leal foo@dtpoff(%eax), %edx
2734 movl foo@gottpoff(%ebx), %eax
2735 subl foo@gottpoff(%ebx), %eax
2736 addl foo@gotntpoff(%ebx), %eax
2737 movl foo@indntpoff, %eax
2738 movl \$foo@tpoff, %eax
2739 subl \$foo@tpoff, %eax
2740 leal foo@ntpoff(%ecx), %eax"
2744 .section ".tdata","awT",@progbits
2748 leaq foo@TLSGD(%rip), %rdi
2749 leaq foo@TLSLD(%rip), %rdi
2750 leaq foo@DTPOFF(%rax), %rdx
2751 movq foo@GOTTPOFF(%rip), %rax
2752 movq $foo@TPOFF, %rax'
2755 tls_as_opt=--fatal-warnings
2759 .section ".tdata","awT",@progbits
2762 addl r16 = @ltoff(@dtpmod(foo#)), gp
2763 addl r17 = @ltoff(@dtprel(foo#)), gp
2764 addl r18 = @ltoff(@tprel(foo#)), gp
2765 addl r19 = @dtprel(foo#), gp
2766 adds r21 = @dtprel(foo#), r13
2767 movl r23 = @dtprel(foo#)
2768 addl r20 = @tprel(foo#), gp
2769 adds r22 = @tprel(foo#), r13
2770 movl r24 = @tprel(foo#)'
2773 tls_as_opt=--fatal-warnings
2777 .section .tdata,"awT",@progbits
2781 addiu $4, $28, %tlsgd(x)
2782 addiu $4, $28, %tlsldm(x)
2783 lui $4, %dtprel_hi(x)
2784 addiu $4, $4, %dtprel_lo(x)
2785 lw $4, %gottprel(x)($28)
2786 lui $4, %tprel_hi(x)
2787 addiu $4, $4, %tprel_lo(x)'
2790 tls_as_opt='-32 --fatal-warnings'
2794 .section .tdata,"awT",@progbits
2799 move.l x@TLSGD(%a5),%a0
2800 move.l x@TLSLDM(%a5),%a0
2801 move.l x@TLSLDO(%a5),%a0
2802 move.l x@TLSIE(%a5),%a0
2803 move.l x@TLSLE(%a5),%a0'
2806 tls_as_opt='--fatal-warnings'
2810 .section ".tdata","awT",@progbits
2818 addi 3,31,ld0@got@tlsgd
2820 addi 3,31,x1@got@tlsld
2823 addis 9,3,x2@dtprel@ha
2824 addi 9,9,x2@dtprel@l
2825 lwz 9,x3@got@tprel(31)
2828 addis 9,2,x2@tprel@ha
2829 addi 9,9,x2@tprel@l'
2832 tls_as_opt="-a32 --fatal-warnings"
2836 .section ".tdata","awT",@progbits
2844 addi 3,2,ld0@got@tlsgd
2850 addi 3,2,x1@got@tlsld
2856 addis 9,3,x2@dtprel@ha
2857 addi 9,9,x2@dtprel@l
2860 ld 9,x3@got@dtprel(2)
2866 tls_as_opt="-a64 --fatal-warnings"
2870 .section ".tdata","awT",@progbits
2879 l %r1,foo@GOTNTPOFF(%r12)
2880 l %r1,0(%r1):tls_load:foo
2881 bas %r14,0(%r1,%r13):tls_gdcall:foo
2882 bas %r14,0(%r1,%r13):tls_ldcall:foo'
2885 tls_as_opt="-m31 --fatal-warnings"
2889 .section ".tdata","awT",@progbits
2897 lg %r1,foo@GOTNTPOFF(%r12)
2898 larl %r1,foo@INDNTPOFF
2899 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
2900 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2903 tls_as_opt="-m64 -Aesame --fatal-warnings"
2905 sh-*-* | sh[34]-*-*)
2907 .section ".tdata","awT",@progbits
2917 tls_as_opt=--fatal-warnings
2921 sparc*-sun-solaris2.*)
2923 tga_func=__tls_get_addr
2929 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2931 .section ".tdata",#alloc,#write,#tls'
2936 .section ".tdata","awT",@progbits'
2939 tls_as_opt="-32 --fatal-warnings"
2941 conftest_s="$conftest_s
2944 sethi %tgd_hi22(foo), %o0
2945 add %o0, %tgd_lo10(foo), %o1
2946 add %l7, %o1, %o0, %tgd_add(foo)
2947 call __tls_get_addr, %tgd_call(foo)
2948 sethi %tldm_hi22(foo), %l1
2949 add %l1, %tldm_lo10(foo), %l2
2950 add %l7, %l2, %o0, %tldm_add(foo)
2951 call __tls_get_addr, %tldm_call(foo)
2952 sethi %tldo_hix22(foo), %l3
2953 xor %l3, %tldo_lox10(foo), %l4
2954 add %o0, %l4, %l5, %tldo_add(foo)
2955 sethi %tie_hi22(foo), %o3
2956 add %o3, %tie_lo10(foo), %o3
2957 ld [%l7 + %o3], %o2, %tie_ld(foo)
2958 add %g7, %o2, %o4, %tie_add(foo)
2959 sethi %tle_hix22(foo), %l1
2960 xor %l1, %tle_lox10(foo), %o5
2961 ld [%g7 + %o5], %o1"
2965 .section ".tdata","awT",@progbits
2968 movi a8, foo@TLSFUNC
2969 movi a10, foo@TLSARG
2970 callx8.tls a8, foo@TLSCALL'
2977 if test "x$enable_tls" = xno ; then
2978 : # TLS explicitly disabled.
2979 elif test "x$enable_tls" = xyes ; then
2980 set_have_as_tls=yes # TLS explicitly enabled.
2981 elif test -z "$tls_first_major"; then
2982 : # If we don't have a check, assume no support.
2984 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2985 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2986 [set_have_as_tls=yes])
2990 # IRIX 6.5 rld and libc.so lack TLS support, so even if gas and gld
2991 # with TLS support are in use, native TLS cannot work.
2995 # Tru64 UNIX loader and libc.so lack TLS support, so even if gas and
2996 # gld with TLS support are in use, native TLS cannot work.
2999 # TLS was introduced in the Solaris 9 FCS release and backported to
3000 # Solaris 8 patches. Support for GNU-style TLS on x86 was only
3001 # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
3002 # ld and GCC don't support any longer.
3004 AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3006 # Check ld and ld.so.1 TLS support.
3007 if echo "$ld_ver" | grep GNU > /dev/null; then
3008 # Assume all interesting versions of GNU ld have TLS support.
3009 # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3013 # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
3015 min_tls_ld_vers_minor=280
3017 # Solaris 8/SPARC ld has TLS support since version 1.272.
3018 sparc*-*-solaris2.8)
3019 min_tls_ld_vers_minor=272
3021 # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3023 min_tls_ld_vers_minor=374
3025 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3026 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3027 min_tls_ld_vers_minor=343
3030 if test "$ld_vers_major" -gt 1 || \
3031 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3037 AC_MSG_RESULT($ld_tls_support)
3040 save_LDFLAGS="$LDFLAGS"
3044 AC_MSG_CHECKING(alternate thread library)
3046 # TLS support was backported to Solaris 8 patches, but only lives in
3047 # the alternate thread library which became the default in Solaris 9.
3048 # We want to always use that, irrespective of TLS support.
3050 # Take multilib subdir into account. There's no spec to handle
3051 # this. The 64 symlink exists since Solaris 8.
3052 lwp_dir=/usr/lib/lwp
3053 lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3054 LDFLAGS="-L$lwp_dir -R$lwp_dir"
3061 # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3062 AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3063 [Define to the linker flags to use for -pthread.])
3064 AC_MSG_RESULT($lwp_dir)
3066 AC_MSG_CHECKING(library containing $tga_func)
3067 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3068 # (32-bit x86) only lived in libthread, so check for that. Keep
3069 # set_have_as_tls if found, disable if not.
3070 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3071 # Clear LIBS if we cannot support TLS.
3072 if test $set_have_as_tls = no; then
3075 # Always define LIB_TLS_SPEC, even without TLS support.
3076 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3077 [Define to the library containing __tls_get_addr/___tls_get_addr.])
3078 AC_MSG_RESULT($LIBS)
3081 LDFLAGS="$save_LDFLAGS"
3084 if test $set_have_as_tls = yes ; then
3085 AC_DEFINE(HAVE_AS_TLS, 1,
3086 [Define if your assembler and linker support thread-local storage.])
3089 # Target-specific assembler checks.
3091 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3092 gcc_cv_ld_static_dynamic=no
3093 if test $in_tree_ld = yes ; then
3094 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
3095 gcc_cv_ld_static_dynamic=yes
3097 elif test x$gcc_cv_ld != x; then
3098 # Check if linker supports -Bstatic/-Bdynamic option
3099 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3100 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3101 gcc_cv_ld_static_dynamic=yes
3104 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3105 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3106 [Define if your linker supports -Bstatic/-Bdynamic option.])
3108 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3110 if test x"$demangler_in_ld" = xyes; then
3111 AC_MSG_CHECKING(linker --demangle support)
3112 gcc_cv_ld_demangle=no
3113 if test $in_tree_ld = yes; then
3114 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 \
3115 gcc_cv_ld_demangle=yes
3117 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3118 # Check if the GNU linker supports --demangle option
3119 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3120 gcc_cv_ld_demangle=yes
3123 if test x"$gcc_cv_ld_demangle" = xyes; then
3124 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3125 [Define if your linker supports --demangle option.])
3127 AC_MSG_RESULT($gcc_cv_ld_demangle)
3131 # All TARGET_ABI_OSF targets.
3132 alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3133 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3134 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3137 extbl $3, $2, $3 !lituse_bytoff!1
3138 ldq $2, a($29) !literal!1
3139 ldq $4, b($29) !literal!2
3140 ldq_u $3, 0($2) !lituse_base!1
3141 ldq $27, f($29) !literal!5
3142 jsr $26, ($27), f !lituse_jsr!5
3143 ldah $29, 0($26) !gpdisp!3
3144 lda $0, c($29) !gprel
3145 ldah $1, d($29) !gprelhigh
3146 lda $1, d($1) !gprellow
3147 lda $29, 0($29) !gpdisp!3],,
3148 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3149 [Define if your assembler supports explicit relocations.])])
3150 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3151 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3154 ldq $27, a($29) !literal!1
3155 jsr $26, ($27), a !lituse_jsrdirect!1],,
3156 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3157 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3161 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3162 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3163 [-no-mul-bug-abort], [.text],,
3164 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3165 [Define if your assembler supports the -no-mul-bug-abort option.])])
3169 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3170 [.register %g2, #scratch],,
3171 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3172 [Define if your assembler supports .register.])])
3174 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3176 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3177 [Define if your assembler supports -relax option.])])
3179 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3180 gcc_cv_as_sparc_gotdata_op,,
3186 sethi %gdop_hix22(foo), %g1
3187 xor %g1, %gdop_lox10(foo), %g1
3188 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3189 [if test x$gcc_cv_ld != x \
3190 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3191 if $gcc_cv_ld -v | grep GNU >/dev/null 2>&1; then
3192 if test x$gcc_cv_objdump != x; then
3193 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3194 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3195 gcc_cv_as_sparc_gotdata_op=no
3197 gcc_cv_as_sparc_gotdata_op=yes
3201 gcc_cv_as_sparc_gotdata_op=yes
3205 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3206 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3208 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3209 gcc_cv_as_sparc_ua_pcrel,,
3217 .uaword %r_disp32(foo)],
3218 [if test x$gcc_cv_ld != x \
3219 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3220 gcc_cv_as_sparc_ua_pcrel=yes
3223 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3224 [Define if your assembler and linker support unaligned PC relative relocs.])
3226 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3227 gcc_cv_as_sparc_ua_pcrel_hidden,,
3232 .uaword %r_disp32(foo)
3233 .byte 0x32, 0x33, 0x34
3238 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3239 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3240 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3241 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3242 if $gcc_cv_objdump -R conftest 2> /dev/null \
3243 | grep 'DISP32' > /dev/null 2>&1; then
3246 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3250 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3251 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3252 ]) # unaligned pcrel relocs
3254 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3255 gcc_cv_as_sparc_offsetable_lo10,,
3258 or %g1, %lo(ab) + 12, %g1
3259 or %g1, %lo(ab + 12), %g1],
3260 [if test x$gcc_cv_objdump != x \
3261 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3262 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3263 gcc_cv_as_sparc_offsetable_lo10=yes
3265 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3266 [Define if your assembler supports offsetable %lo().])])
3270 i[34567]86-*-* | x86_64-*-*)
3274 # Full C++ conformance when using a shared libstdc++-v3 requires some
3275 # support from the Cygwin DLL, which in more recent versions exports
3276 # wrappers to aid in interposing and redirecting operators new, delete,
3277 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3278 # are configuring for a version of Cygwin that exports the wrappers.
3279 if test x$host = x$target; then
3280 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3282 # Can't check presence of libc functions during cross-compile, so
3283 # we just have to assume we're building for an up-to-date target.
3284 gcc_ac_cygwin_dll_wrappers=yes
3286 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3287 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3288 [Define if you want to generate code by default that assumes that the
3289 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3292 cygwin* | pe | mingw32*)
3293 # Recent binutils allows the three-operand form of ".comm" on PE. This
3294 # definition is used unconditionally to initialise the default state of
3295 # the target option variable that governs usage of the feature.
3296 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3297 [2,19,52],,[.comm foo,1,32])
3298 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3299 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3300 [Define if your assembler supports specifying the alignment
3301 of objects allocated using the GAS .comm command.])
3302 # Used for DWARF 2 in PE
3303 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3304 gcc_cv_as_ix86_pe_secrel32,
3310 [if test x$gcc_cv_ld != x \
3311 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3312 gcc_cv_as_ix86_pe_secrel32=yes
3315 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3316 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3317 # Test if the assembler supports the extended form of the .section
3318 # directive that specifies section alignment. LTO support uses this,
3319 # but normally only after installation, so we warn but don't fail the
3320 # configure if LTO is enabled but the assembler does not support it.
3321 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3322 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3323 if test x$gcc_cv_as_section_has_align != xyes; then
3324 case ",$enable_languages," in
3326 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3333 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3334 gcc_cv_as_ix86_filds,,,
3335 [filds mem; fists mem],,
3336 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3337 [Define if your assembler uses filds and fists mnemonics.])])
3339 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3340 gcc_cv_as_ix86_fildq,,,
3341 [fildq mem; fistpq mem],,
3342 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3343 [Define if your assembler uses fildq and fistq mnemonics.])])
3345 gcc_GAS_CHECK_FEATURE([cmov syntax],
3346 gcc_cv_as_ix86_cmov_sun_syntax,,,
3347 [cmovl.l %edx, %eax],,
3348 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3349 [Define if your assembler supports the Sun syntax for cmov.])])
3351 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3352 gcc_cv_as_ix86_ffreep,,,
3354 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3355 [Define if your assembler supports the ffreep mnemonic.])])
3357 gcc_GAS_CHECK_FEATURE([.quad directive],
3358 gcc_cv_as_ix86_quad,,,
3360 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3361 [Define if your assembler supports the .quad directive.])])
3363 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3364 gcc_cv_as_ix86_sahf,,,
3367 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3368 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3370 gcc_GAS_CHECK_FEATURE([swap suffix],
3371 gcc_cv_as_ix86_swap,,,
3372 [movl.s %esp, %ebp],,
3373 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3374 [Define if your assembler supports the swap suffix.])])
3376 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3377 gcc_cv_as_ix86_diff_sect_delta,,,
3385 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3386 [Define if your assembler supports the subtraction of symbols in different sections.])])
3388 # These two are used unconditionally by i386.[ch]; it is to be defined
3389 # to 1 if the feature is present, 0 otherwise.
3390 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3391 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3397 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3398 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3399 [Define true if the assembler supports '.long foo@GOTOFF'.])
3401 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3402 gcc_cv_as_ix86_rep_lock_prefix,,,
3404 lock addl %edi, (%eax,%esi)
3405 lock orl $0, (%esp)],,
3406 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3407 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3412 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3413 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3415 addl r15 = @ltoffx(x#), gp
3417 ld8.mov r16 = [[r15]], x#],,
3418 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3419 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3425 *-*-aix*) conftest_s=' .machine "pwr5"
3429 gcc_GAS_CHECK_FEATURE([.machine directive support],
3430 gcc_cv_as_machine_directive,,,
3431 [ .machine ppc7400])
3432 if test x$gcc_cv_as_machine_directive != xyes; then
3433 echo "*** This target requires an assembler supporting \".machine\"" >&2
3434 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3435 test x$build = x$target && exit 1
3439 *) conftest_s=' .machine power4
3444 gcc_GAS_CHECK_FEATURE([mfcr field support],
3445 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3447 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3448 [Define if your assembler supports mfcr field.])])
3451 *-*-aix*) conftest_s=' .machine "pwr5"
3454 *) conftest_s=' .machine power5
3459 gcc_GAS_CHECK_FEATURE([popcntb support],
3460 gcc_cv_as_powerpc_popcntb, [2,17,0],,
3462 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3463 [Define if your assembler supports popcntb field.])])
3466 *-*-aix*) conftest_s=' .machine "pwr5x"
3469 *) conftest_s=' .machine power5
3474 gcc_GAS_CHECK_FEATURE([fp round support],
3475 gcc_cv_as_powerpc_fprnd, [2,17,0],,
3477 [AC_DEFINE(HAVE_AS_FPRND, 1,
3478 [Define if your assembler supports fprnd.])])
3481 *-*-aix*) conftest_s=' .machine "pwr6"
3484 *) conftest_s=' .machine power6
3489 gcc_GAS_CHECK_FEATURE([move fp gpr support],
3490 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3492 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3493 [Define if your assembler supports mffgpr and mftgpr.])])
3496 *-*-aix*) conftest_s=' .csect .text[[PR]]
3498 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3502 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3503 *) conftest_s=' .text
3505 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3508 gcc_GAS_CHECK_FEATURE([rel16 relocs],
3509 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3511 [AC_DEFINE(HAVE_AS_REL16, 1,
3512 [Define if your assembler supports R_PPC_REL16 relocs.])])
3515 *-*-aix*) conftest_s=' .machine "pwr6"
3518 *) conftest_s=' .machine power6
3523 gcc_GAS_CHECK_FEATURE([compare bytes support],
3524 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3526 [AC_DEFINE(HAVE_AS_CMPB, 1,
3527 [Define if your assembler supports cmpb.])])
3530 *-*-aix*) conftest_s=' .machine "pwr6"
3533 *) conftest_s=' .machine power6
3538 gcc_GAS_CHECK_FEATURE([decimal float support],
3539 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3541 [AC_DEFINE(HAVE_AS_DFP, 1,
3542 [Define if your assembler supports DFP instructions.])])
3545 *-*-aix*) conftest_s=' .machine "pwr7"
3548 *) conftest_s=' .machine power7
3553 gcc_GAS_CHECK_FEATURE([vector-scalar support],
3554 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3556 [AC_DEFINE(HAVE_AS_VSX, 1,
3557 [Define if your assembler supports VSX instructions.])])
3560 *-*-aix*) conftest_s=' .machine "pwr7"
3563 *) conftest_s=' .machine power7
3568 gcc_GAS_CHECK_FEATURE([popcntd support],
3569 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3571 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3572 [Define if your assembler supports POPCNTD instructions.])])
3575 *-*-aix*) conftest_s=' .csect .text[[PR]]
3577 *) conftest_s=' .text
3581 gcc_GAS_CHECK_FEATURE([lwsync support],
3582 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3584 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3585 [Define if your assembler supports LWSYNC instructions.])])
3588 *-*-aix*) conftest_s=' .machine "476"
3591 *) conftest_s=' .machine "476"
3596 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3597 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3599 [AC_DEFINE(HAVE_AS_DCI, 1,
3600 [Define if your assembler supports the DCI/ICI instructions.])])
3602 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3603 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3604 [.gnu_attribute 4,1],,
3605 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3606 [Define if your assembler supports .gnu_attribute.])])
3608 gcc_GAS_CHECK_FEATURE([tls marker support],
3609 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3610 [ bl __tls_get_addr(x@tlsgd)],,
3611 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3612 [Define if your assembler supports arg info for __tls_get_addr.])])
3616 gcc_GAS_CHECK_FEATURE([.ref support],
3617 gcc_cv_as_aix_ref, [2.21.0],,
3618 [ .csect stuff[[rw]]
3624 [AC_DEFINE(HAVE_AS_REF, 1,
3625 [Define if your assembler supports .ref])])
3631 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3632 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3633 [ lw $4,%gp_rel(foo)($4)],,
3634 [if test x$target_cpu_default = x
3635 then target_cpu_default=MASK_EXPLICIT_RELOCS
3636 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3638 gcc_GAS_CHECK_FEATURE([-mno-shared support],
3639 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3640 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3641 [Define if the assembler understands -mno-shared.])])
3643 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3644 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3645 [.gnu_attribute 4,1],,
3646 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3647 [Define if your assembler supports .gnu_attribute.])])
3649 gcc_GAS_CHECK_FEATURE([.dtprelword support],
3650 gcc_cv_as_mips_dtprelword, [2,18,0],,
3651 [.section .tdata,"awT",@progbits
3655 .dtprelword x+0x8000],,
3656 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3657 [Define if your assembler supports .dtprelword.])])
3659 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3660 gcc_cv_as_mips_dspr1_mult,,,
3670 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3671 [Define if your assembler supports DSPR1 mult.])])
3673 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3674 gcc_cv_as_ld_jalr_reloc=no
3675 if test $gcc_cv_as_mips_explicit_relocs = yes; then
3676 if test $in_tree_ld = yes ; then
3677 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 \
3678 && test $in_tree_ld_is_elf = yes; then
3679 gcc_cv_as_ld_jalr_reloc=yes
3681 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3682 echo ' .ent x' > conftest.s
3683 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s
3684 echo ' ld $25,%call16(y)($28)' >> conftest.s
3685 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
3686 echo '1: jalr $25' >> conftest.s
3687 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
3688 echo '1: jalr $25' >> conftest.s
3689 echo ' .end x' >> conftest.s
3690 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3691 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3692 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3693 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3694 gcc_cv_as_ld_jalr_reloc=yes
3700 if test $gcc_cv_as_ld_jalr_reloc = yes; then
3701 if test x$target_cpu_default = x; then
3702 target_cpu_default=MASK_RELAX_PIC_CALLS
3704 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3707 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3709 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3710 [gcc_cv_ld_mips_personality_relaxation],
3711 [gcc_cv_ld_mips_personality_relaxation=no
3712 if test $in_tree_ld = yes ; then
3713 if test "$gcc_cv_gld_major_version" -eq 2 \
3714 -a "$gcc_cv_gld_minor_version" -ge 21 \
3715 -o "$gcc_cv_gld_major_version" -gt 2; then
3716 gcc_cv_ld_mips_personality_relaxation=yes
3718 elif test x$gcc_cv_as != x \
3719 -a x$gcc_cv_ld != x \
3720 -a x$gcc_cv_readelf != x ; then
3721 cat > conftest.s <<EOF
3723 .cfi_personality 0x80,indirect_ptr
3730 .section .data,"aw",@progbits
3734 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
3735 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
3736 if $gcc_cv_readelf -d conftest 2>&1 \
3737 | grep TEXTREL > /dev/null 2>&1; then
3739 elif $gcc_cv_readelf --relocs conftest 2>&1 \
3740 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
3743 gcc_cv_ld_mips_personality_relaxation=yes
3747 rm -f conftest.s conftest.o conftest])
3748 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
3749 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
3750 [Define if your linker can relax absolute .eh_frame personality
3751 pointers into PC-relative form.])
3756 # Mips and HP-UX need the GNU assembler.
3757 # Linux on IA64 might be able to use the Intel assembler.
3760 mips*-*-* | *-*-hpux* )
3761 if test x$gas_flag = xyes \
3762 || test x"$host" != x"$build" \
3763 || test ! -x "$gcc_cv_as" \
3764 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3767 echo "*** This configuration requires the GNU assembler" >&2
3773 # ??? Not all targets support dwarf2 debug_line, even within a version
3774 # of gas. Moreover, we need to emit a valid instruction to trigger any
3775 # info to the output file. So, as supported targets are added to gas 2.11,
3776 # add some instruction here to (also) show we expect this might work.
3777 # ??? Once 2.11 is released, probably need to add first known working
3778 # version to the per-target configury.
3780 alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
3781 | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
3791 if test x"$insn" != x; then
3793 .file 1 \"conftest.s\"
3796 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3797 gcc_cv_as_dwarf2_debug_line,
3798 [elf,2,11,0],, [$conftest_s],
3799 [if test x$gcc_cv_objdump != x \
3800 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3801 | grep debug_line > /dev/null 2>&1; then
3802 gcc_cv_as_dwarf2_debug_line=yes
3805 # The .debug_line file table must be in the exact order that
3806 # we specified the files, since these indices are also used
3807 # by DW_AT_decl_file. Approximate this test by testing if
3808 # the assembler bitches if the same index is assigned twice.
3809 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3810 gcc_cv_as_dwarf2_file_buggy,,,
3814 if test $gcc_cv_as_dwarf2_debug_line = yes \
3815 && test $gcc_cv_as_dwarf2_file_buggy = no; then
3816 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3817 [Define if your assembler supports dwarf2 .file/.loc directives,
3818 and preserves file table indices exactly as given.])
3821 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3822 gcc_cv_as_gdwarf2_flag,
3823 [elf,2,11,0], [--gdwarf2], [$insn],,
3824 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3825 [Define if your assembler supports the --gdwarf2 option.])])
3827 gcc_GAS_CHECK_FEATURE([--gstabs option],
3828 gcc_cv_as_gstabs_flag,
3829 [elf,2,11,0], [--gstabs], [$insn],
3830 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3831 # and warns about it, but still exits successfully. So check for
3833 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3835 else gcc_cv_as_gstabs_flag=yes
3837 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3838 [Define if your assembler supports the --gstabs option.])])
3840 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3841 gcc_cv_as_debug_prefix_map_flag,
3842 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3843 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3844 [Define if your assembler supports the --debug-prefix-map option.])])
3847 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
3850 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
3851 [Define if your assembler supports .lcomm with an alignment field.])])
3853 AC_ARG_ENABLE(gnu-unique-object,
3854 [ --enable-gnu-unique-object enable the use of the @gnu_unique_object ELF extension on
3856 [case $enable_gnu_unique_object in
3858 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
3859 Valid choices are 'yes' and 'no'.]) ;;
3861 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
3863 [.type foo, @gnu_unique_object],,
3864 # Also check for ld.so support, i.e. glibc 2.11 or higher.
3865 [[if test x$host = x$build -a x$host = x$target &&
3866 glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
3867 glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
3868 glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
3869 glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
3870 if test "$glibcnum" -ge 2011 ; then
3871 enable_gnu_unique_object=yes
3874 if test x$enable_gnu_unique_object = xyes; then
3875 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
3876 [Define if your assembler supports @gnu_unique_object.])
3879 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3880 [gcc_cv_as_line_zero],
3881 [gcc_cv_as_line_zero=no
3882 if test $in_tree_gas = yes; then
3883 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3884 elif test "x$gcc_cv_as" != x; then
3885 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3886 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3887 test "x`cat conftest.out`" = x
3889 gcc_cv_as_line_zero=yes
3891 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3892 cat conftest.s >&AS_MESSAGE_LOG_FD
3893 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3894 cat conftest.out >&AS_MESSAGE_LOG_FD
3896 rm -f conftest.o conftest.s conftest.out
3898 if test "x$gcc_cv_as_line_zero" = xyes; then
3899 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3900 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3903 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3904 gcc_cv_ld_eh_frame_hdr=no
3905 if test $in_tree_ld = yes ; then
3906 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 \
3907 && test $in_tree_ld_is_elf = yes; then
3908 gcc_cv_ld_eh_frame_hdr=yes
3910 elif test x$gcc_cv_ld != x; then
3911 # Check if linker supports --eh-frame-hdr option
3912 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3913 gcc_cv_ld_eh_frame_hdr=yes
3916 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3917 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3918 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3919 [Define if your linker supports --eh-frame-hdr option.])
3921 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3923 AC_MSG_CHECKING(linker position independent executable support)
3925 if test $in_tree_ld = yes ; then
3926 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 \
3927 && test $in_tree_ld_is_elf = yes; then
3930 elif test x$gcc_cv_ld != x; then
3931 # Check if linker supports -pie option
3932 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3936 if test x"$gcc_cv_ld_pie" = xyes; then
3937 AC_DEFINE(HAVE_LD_PIE, 1,
3938 [Define if your linker supports -pie option.])
3940 AC_MSG_RESULT($gcc_cv_ld_pie)
3942 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3943 gcc_cv_ld_eh_gc_sections=no
3944 if test $in_tree_ld = yes ; then
3945 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 \
3946 && test $in_tree_ld_is_elf = yes; then
3947 gcc_cv_ld_eh_gc_sections=yes
3949 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3950 cat > conftest.s <<EOF
3953 .type _start, @function
3956 .size _start, .-_start
3957 .section .text.foo,"ax",@progbits
3958 .type foo, @function
3962 .section .gcc_except_table.foo,"a",@progbits
3965 .section .eh_frame,"a",@progbits
3968 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3969 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3970 | grep "gc-sections option ignored" > /dev/null; then
3971 gcc_cv_ld_eh_gc_sections=no
3972 elif $gcc_cv_objdump -h conftest 2> /dev/null \
3973 | grep gcc_except_table > /dev/null; then
3974 gcc_cv_ld_eh_gc_sections=yes
3975 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3976 if test x$gcc_cv_as_comdat_group != xyes; then
3977 gcc_cv_ld_eh_gc_sections=no
3978 cat > conftest.s <<EOF
3981 .type _start, @function
3984 .size _start, .-_start
3985 .section .gnu.linkonce.t.foo,"ax",@progbits
3986 .type foo, @function
3990 .section .gcc_except_table.foo,"a",@progbits
3993 .section .eh_frame,"a",@progbits
3996 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3997 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3998 | grep "gc-sections option ignored" > /dev/null; then
3999 gcc_cv_ld_eh_gc_sections=no
4000 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4001 | grep gcc_except_table > /dev/null; then
4002 gcc_cv_ld_eh_gc_sections=yes
4008 rm -f conftest.s conftest.o conftest
4012 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4013 gcc_cv_ld_eh_gc_sections=no
4016 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4017 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4018 [Define if your linker supports garbage collection of
4019 sections in presence of EH frames.])
4021 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4027 AC_CACHE_CHECK(linker --as-needed support,
4028 gcc_cv_ld_as_needed,
4029 [gcc_cv_ld_as_needed=no
4030 if test $in_tree_ld = yes ; then
4031 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 \
4032 && test $in_tree_ld_is_elf = yes; then
4033 gcc_cv_ld_as_needed=yes
4035 elif test x$gcc_cv_ld != x; then
4036 # Check if linker supports --as-needed and --no-as-needed options
4037 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4038 gcc_cv_ld_as_needed=yes
4042 if test x"$gcc_cv_ld_as_needed" = xyes; then
4043 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4044 [Define if your linker supports --as-needed and --no-as-needed options.])
4047 case "$target:$tm_file" in
4048 powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4049 AC_CACHE_CHECK(linker support for omitting dot symbols,
4050 gcc_cv_ld_no_dot_syms,
4051 [gcc_cv_ld_no_dot_syms=no
4052 if test $in_tree_ld = yes ; then
4053 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
4054 gcc_cv_ld_no_dot_syms=yes
4056 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4057 cat > conftest1.s <<EOF
4061 cat > conftest2.s <<EOF
4062 .section ".opd","aw"
4067 .quad .LEfoo,.TOC.@tocbase,0
4073 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4074 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4075 && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4076 gcc_cv_ld_no_dot_syms=yes
4078 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4081 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4082 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4083 [Define if your PowerPC64 linker only needs function descriptor syms.])
4086 AC_CACHE_CHECK(linker large toc support,
4087 gcc_cv_ld_large_toc,
4088 [gcc_cv_ld_large_toc=no
4089 if test $in_tree_ld = yes ; then
4090 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
4091 gcc_cv_ld_large_toc=yes
4093 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4094 cat > conftest.s <<EOF
4095 .section ".tbss","awT",@nobits
4101 addis 9,13,ie0@got@tprel@ha
4102 ld 9,ie0@got@tprel@l(9)
4104 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4105 && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4106 gcc_cv_ld_large_toc=yes
4108 rm -f conftest conftest.o conftest.s
4111 if test x"$gcc_cv_ld_large_toc" = xyes; then
4112 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4113 [Define if your PowerPC64 linker supports a large TOC.])
4118 AC_CACHE_CHECK(linker --build-id support,
4120 [gcc_cv_ld_buildid=no
4121 if test $in_tree_ld = yes ; then
4122 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4123 "$gcc_cv_gld_minor_version" -ge 18 -o \
4124 "$gcc_cv_gld_major_version" -gt 2 \
4125 && test $in_tree_ld_is_elf = yes; then
4126 gcc_cv_ld_buildid=yes
4128 elif test x$gcc_cv_ld != x; then
4129 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4130 gcc_cv_ld_buildid=yes
4133 if test x"$gcc_cv_ld_buildid" = xyes; then
4134 AC_DEFINE(HAVE_LD_BUILDID, 1,
4135 [Define if your linker supports --build-id.])
4138 AC_ARG_ENABLE(linker-build-id,
4139 [ --enable-linker-build-id
4140 compiler will always pass --build-id to linker],
4142 enable_linker_build_id=no)
4144 if test x"$enable_linker_build_id" = xyes; then
4145 if test x"$gcc_cv_ld_buildid" = xyes; then
4146 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4147 [Define if gcc should always pass --build-id to linker.])
4149 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4153 # In binutils 2.21, GNU ld gained support for new emulations fully
4154 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4155 AC_CACHE_CHECK(linker *_sol2 emulation support,
4156 gcc_cv_ld_sol2_emulation,
4157 [gcc_cv_ld_sol2_emulation=no
4158 if test $in_tree_ld = yes ; then
4159 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4160 "$gcc_cv_gld_minor_version" -ge 21 -o \
4161 "$gcc_cv_gld_major_version" -gt 2 \
4162 && test $in_tree_ld_is_elf = yes; then
4163 gcc_cv_ld_sol2_emulation=yes
4165 elif test x$gcc_cv_ld != x; then
4166 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4167 grep _sol2 > /dev/null; then
4168 gcc_cv_ld_sol2_emulation=yes
4171 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4172 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4173 [Define if your linker supports the *_sol2 emulations.])
4176 AC_CACHE_CHECK(linker --sysroot support,
4178 [gcc_cv_ld_sysroot=no
4179 if test $in_tree_ld = yes ; then
4180 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
4181 gcc_cv_ld_sysroot=yes
4183 elif test x$gcc_cv_ld != x; then
4184 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4185 gcc_cv_ld_sysroot=yes
4188 if test x"$gcc_cv_ld_sysroot" = xyes; then
4189 AC_DEFINE(HAVE_LD_SYSROOT, 1,
4190 [Define if your linker supports --sysroot.])
4193 if test x$with_sysroot = x && test x$host = x$target \
4194 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4195 && test "$prefix" != "NONE"; then
4196 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4197 [Define to PREFIX/include if cpp should also search that directory.])
4200 # Test for stack protector support in target C library.
4201 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4202 gcc_cv_libc_provides_ssp,
4203 [gcc_cv_libc_provides_ssp=no
4205 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4206 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4207 if test "x$with_headers" != x; then
4208 glibc_header_dir=$with_headers
4209 elif test "x$with_sysroot" = x; then
4210 glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4211 elif test "x$with_build_sysroot" != "x"; then
4212 glibc_header_dir="${with_build_sysroot}/usr/include"
4213 elif test "x$with_sysroot" = xyes; then
4214 glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4216 glibc_header_dir="${with_sysroot}/usr/include"
4219 glibc_header_dir=/usr/include
4221 [# glibc 2.4 and later provides __stack_chk_fail and
4222 # either __stack_chk_guard, or TLS access to stack guard canary.
4223 if test -f $glibc_header_dir/features.h \
4224 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
4225 $glibc_header_dir/features.h > /dev/null; then
4226 if $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+([1-9][0-9]|[3-9])' \
4227 $glibc_header_dir/features.h > /dev/null; then
4228 gcc_cv_libc_provides_ssp=yes
4229 elif $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+2' \
4230 $glibc_header_dir/features.h > /dev/null \
4231 && $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+([1-9][0-9]|[4-9])' \
4232 $glibc_header_dir/features.h > /dev/null; then
4233 gcc_cv_libc_provides_ssp=yes
4234 elif $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
4235 $glibc_header_dir/features.h > /dev/null && \
4236 test -f $glibc_header_dir/bits/uClibc_config.h && \
4237 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
4238 $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
4239 gcc_cv_libc_provides_ssp=yes
4244 # Avoid complicated tests (see
4245 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4246 # simply assert that glibc does provide this, which is true for all
4247 # realistically usable GNU/Hurd configurations.
4248 gcc_cv_libc_provides_ssp=yes;;
4249 *-*-darwin* | *-*-freebsd*)
4250 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4251 [echo "no __stack_chk_fail on this target"])
4253 *) gcc_cv_libc_provides_ssp=no ;;
4256 if test x$gcc_cv_libc_provides_ssp = xyes; then
4257 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4258 [Define if your target C library provides stack protector support])
4261 # Check if TFmode long double should be used by default or not.
4262 # Some glibc targets used DFmode long double, but with glibc 2.4
4263 # and later they can use TFmode.
4265 powerpc*-*-linux* | \
4270 AC_ARG_WITH(long-double-128,
4271 [ --with-long-double-128 Use 128-bit long double by default.],
4272 gcc_cv_target_ldbl128="$with_long_double_128",
4273 [[gcc_cv_target_ldbl128=no
4274 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4275 if test "x$with_sysroot" = x; then
4276 glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4277 elif test "x$with_build_sysroot" != "x"; then
4278 glibc_header_dir="${with_build_sysroot}/usr/include"
4279 elif test "x$with_sysroot" = xyes; then
4280 glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4282 glibc_header_dir="${with_sysroot}/usr/include"
4285 glibc_header_dir=/usr/include
4287 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4288 $glibc_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4289 && gcc_cv_target_ldbl128=yes
4293 if test x$gcc_cv_target_ldbl128 = xyes; then
4294 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4295 [Define if TFmode long double should be the default])
4298 # Find out what GC implementation we want, or may, use.
4300 [ --with-gc={page,zone} choose the garbage collection mechanism to use
4308 AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4311 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4316 echo "Using $GGC for garbage collection."
4318 # Libraries to use on the host. This will normally be set by the top
4319 # level Makefile. Here we simply capture the value for our Makefile.
4320 if test -z "${HOST_LIBS+set}"; then
4325 # Use the system's zlib library.
4327 zlibinc="-I\$(srcdir)/../zlib"
4328 AC_ARG_WITH(system-zlib,
4329 [ --with-system-zlib use installed libz],
4336 dnl Very limited version of automake's enable-maintainer-mode
4338 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4339 dnl maintainer-mode is disabled by default
4340 AC_ARG_ENABLE(maintainer-mode,
4341 [ --enable-maintainer-mode
4342 enable make rules and dependencies not useful
4343 (and sometimes confusing) to the casual installer],
4344 maintainer_mode=$enableval,
4347 AC_MSG_RESULT($maintainer_mode)
4349 if test "$maintainer_mode" = "yes"; then
4360 # Make empty files to contain the specs and options for each language.
4361 # Then add #include lines to for a compiler that has specs and/or options.
4367 # These (without "all_") are set in each config-lang.in.
4368 # `language' must be a single word so is spelled singularly.
4371 all_outputs='Makefile'
4372 # List of language makefile fragments.
4374 # Additional files for gengtype
4375 all_gtfiles="$target_gtfiles"
4377 # These are the languages that are set in --enable-languages,
4378 # and are available in the GCC tree.
4379 all_selected_languages=
4381 # Add the language fragments.
4382 # Languages are added via two mechanisms. Some information must be
4383 # recorded in makefile variables, these are defined in config-lang.in.
4384 # We accumulate them and plug them into the main Makefile.
4385 # The other mechanism is a set of hooks for each of the main targets
4386 # like `clean', `install', etc.
4388 language_hooks="Make-hooks"
4390 for lang in ${srcdir}/*/config-lang.in
4393 test "$lang" = "${srcdir}/*/config-lang.in" && continue
4395 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
4396 if test "x$lang_alias" = x
4398 echo "$lang doesn't set \$language." 1>&2
4401 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4402 subdirs="$subdirs $subdir"
4404 # $gcc_subdir is where the gcc integration files are to be found
4405 # for a language, both for internal compiler purposes (compiler
4406 # sources implementing front-end to GCC tree converters), and for
4407 # build infrastructure purposes (Make-lang.in, etc.)
4409 # This will be <subdir> (relative to $srcdir) if a line like
4410 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4411 # is found in <langdir>/config-lang.in, and will remain <langdir>
4414 # Except for the language alias (fetched above), the regular
4415 # "config-lang.in" contents are always retrieved from $gcc_subdir,
4416 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4417 # only this and the language alias.
4419 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
4420 if [ "$gcc_subdir" = "" ]; then
4421 gcc_subdir="$subdir"
4424 case ",$enable_languages," in
4426 all_selected_languages="$all_selected_languages $lang_alias"
4427 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4428 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4440 . ${srcdir}/$gcc_subdir/config-lang.in
4441 if test "x$language" = x
4443 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4448 case ",$enable_languages," in
4451 for i in $subdir_requires; do
4452 test -f "${srcdir}/$i/config-lang.in" && continue
4460 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4461 if test -f $srcdir/$gcc_subdir/lang.opt; then
4462 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4463 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
4465 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4466 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4468 all_languages="$all_languages $language"
4469 all_compilers="$all_compilers $compilers"
4470 all_outputs="$all_outputs $outputs"
4471 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4472 case ",$enable_languages," in
4474 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4476 AC_SUBST(enable_lto)
4482 # Pick up gtfiles for c
4484 . ${srcdir}/c-config-lang.in
4485 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4488 for language in $all_selected_languages
4490 check_languages="$check_languages check-$language"
4493 # We link each language in with a set of hooks, reached indirectly via
4494 # lang.${target}. Only do so for selected languages.
4498 target_list="all.cross start.encap rest.encap tags \
4499 install-common install-man install-info install-pdf install-html dvi \
4500 pdf html uninstall info man srcextra srcman srcinfo \
4501 mostlyclean clean distclean maintainer-clean install-plugin"
4503 for t in $target_list
4506 for lang in $all_selected_languages
4510 echo "lang.$t: $x" >> Make-hooks
4514 # Option include files
4517 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
4518 option_includes="option-includes.mk"
4519 AC_SUBST_FILE(option_includes)
4527 echo "dir ." > .gdbinit
4528 echo "dir ${srcdir}" >> .gdbinit
4529 if test x$gdb_needs_out_file_path = xyes
4531 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4533 if test "x$subdirs" != x; then
4536 echo "dir ${srcdir}/$s" >> .gdbinit
4539 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4541 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4542 AC_SUBST(gcc_tooldir)
4545 # Find a directory in which to install a shared libgcc.
4547 AC_ARG_ENABLE(version-specific-runtime-libs,
4548 [ --enable-version-specific-runtime-libs
4549 specify that runtime libraries should be
4550 installed in a compiler-specific directory])
4552 AC_ARG_WITH(slibdir,
4553 [ --with-slibdir=DIR shared libraries in DIR [[LIBDIR]]],
4554 slibdir="$with_slibdir",
4555 if test "${enable_version_specific_runtime_libs+set}" = set; then
4556 slibdir='$(libsubdir)'
4557 elif test "$host" != "$target"; then
4558 slibdir='$(build_tooldir)/lib'
4564 # Substitute configuration variables
4567 AC_SUBST(all_compilers)
4568 AC_SUBST(all_gtfiles)
4569 AC_SUBST(all_lang_makefrags)
4570 AC_SUBST(all_languages)
4571 AC_SUBST(all_selected_languages)
4572 AC_SUBST(build_exeext)
4573 AC_SUBST(build_install_headers_dir)
4574 AC_SUBST(build_xm_file_list)
4575 AC_SUBST(build_xm_include_list)
4576 AC_SUBST(build_xm_defines)
4577 AC_SUBST(build_file_translate)
4578 AC_SUBST(check_languages)
4579 AC_SUBST(cpp_install_dir)
4580 AC_SUBST(xmake_file)
4581 AC_SUBST(tmake_file)
4582 AC_SUBST(TM_ENDIAN_CONFIG)
4583 AC_SUBST(TM_MULTILIB_CONFIG)
4584 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4585 AC_SUBST(extra_gcc_objs)
4586 AC_SUBST(user_headers_inc_next_pre)
4587 AC_SUBST(user_headers_inc_next_post)
4588 AC_SUBST(extra_headers_list)
4589 AC_SUBST(extra_objs)
4590 AC_SUBST(extra_parts)
4591 AC_SUBST(extra_passes)
4592 AC_SUBST(extra_programs)
4593 AC_SUBST(float_h_file)
4594 AC_SUBST(gcc_config_arguments)
4595 AC_SUBST(gcc_gxx_include_dir)
4596 AC_SUBST(host_exeext)
4597 AC_SUBST(host_xm_file_list)
4598 AC_SUBST(host_xm_include_list)
4599 AC_SUBST(host_xm_defines)
4600 AC_SUBST(out_host_hook_obj)
4602 AC_SUBST(lang_opt_files)
4603 AC_SUBST(lang_specs_files)
4604 AC_SUBST(lang_tree_files)
4605 AC_SUBST(local_prefix)
4607 AC_SUBST(objc_boehm_gc)
4609 AC_SUBST(out_object_file)
4610 AC_SUBST(thread_file)
4611 AC_SUBST(tm_file_list)
4612 AC_SUBST(tm_include_list)
4613 AC_SUBST(tm_defines)
4614 AC_SUBST(tm_p_file_list)
4615 AC_SUBST(tm_p_include_list)
4616 AC_SUBST(xm_file_list)
4617 AC_SUBST(xm_include_list)
4618 AC_SUBST(xm_defines)
4619 AC_SUBST(use_gcc_stdint)
4620 AC_SUBST(c_target_objs)
4621 AC_SUBST(cxx_target_objs)
4622 AC_SUBST(fortran_target_objs)
4623 AC_SUBST(target_cpu_default)
4625 AC_SUBST_FILE(language_hooks)
4628 if test x${build} = x${host} ; then
4629 if test x${host} = x${target} ; then
4630 echo "Links are now set up to build a native compiler for ${target}." 1>&2
4632 echo "Links are now set up to build a cross-compiler" 1>&2
4633 echo " from ${host} to ${target}." 1>&2
4636 if test x${host} = x${target} ; then
4637 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4638 echo " for ${target}." 1>&2
4640 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4641 echo " from ${host} to ${target}." 1>&2
4645 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4646 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4648 AC_ARG_VAR(PPLLIBS,[How to link PPL])
4649 AC_ARG_VAR(PPLINC,[How to find PPL include files])
4651 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4652 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4653 if test "x${CLOOGLIBS}" != "x" ; then
4654 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
4657 # Check for plugin support
4658 AC_ARG_ENABLE(plugin,
4659 [ --enable-plugin enable plugin support],
4660 enable_plugin=$enableval,
4661 enable_plugin=yes; default_plugin=yes)
4667 if test x$build = x$host; then
4668 export_sym_check="nm${exeext} -g"
4669 elif test x$host = x$target; then
4670 export_sym_check="$gcc_cv_nm -g"
4676 if test x$build = x$host; then
4677 export_sym_check="objdump${exeext} -T"
4678 elif test x$host = x$target; then
4679 export_sym_check="$gcc_cv_objdump -T"
4686 if test x"$enable_plugin" = x"yes"; then
4688 AC_MSG_CHECKING([for exported symbols])
4689 if test "x$export_sym_check" != x; then
4690 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
4691 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
4692 if $export_sym_check conftest | grep foobar > /dev/null; then
4693 : # No need to use a flag
4694 AC_MSG_RESULT([yes])
4696 AC_MSG_RESULT([yes])
4697 AC_MSG_CHECKING([for -rdynamic])
4698 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
4699 if $export_sym_check conftest | grep foobar > /dev/null; then
4701 pluginlibs="-rdynamic"
4706 AC_MSG_RESULT([$plugin_rdynamic])
4709 AC_MSG_RESULT([unable to check])
4714 AC_SEARCH_LIBS([dlopen], [dl])
4715 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
4716 pluginlibs="$pluginlibs -ldl"
4720 # Check that we can build shared objects with -fPIC -shared
4721 saved_LDFLAGS="$LDFLAGS"
4722 saved_CFLAGS="$CFLAGS"
4725 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
4726 CFLAGS="$CFLAGS -fPIC"
4727 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
4730 CFLAGS="$CFLAGS -fPIC"
4731 LDFLAGS="$LDFLAGS -fPIC -shared"
4734 AC_MSG_CHECKING([for -fPIC -shared])
4736 [extern int X;],[return X == 0;],
4737 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
4738 [AC_MSG_RESULT([no]); have_pic_shared=no])
4739 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
4743 LDFLAGS="$saved_LDFLAGS"
4744 CFLAGS="$saved_CFLAGS"
4746 # If plugin support had been requested but not available, fail.
4747 if test x"$enable_plugin" = x"no" ; then
4748 if test x"$default_plugin" != x"yes"; then
4750 Building GCC with plugin support requires a host that supports
4751 -fPIC, -shared, -ldl and -rdynamic.])
4756 AC_SUBST(pluginlibs)
4757 AC_SUBST(enable_plugin)
4758 if test x"$enable_plugin" = x"yes"; then
4759 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
4762 # Configure the subdirectories
4763 # AC_CONFIG_SUBDIRS($subdirs)
4765 # Create the Makefile
4766 # and configure language subdirectories
4767 AC_CONFIG_FILES($all_outputs)
4769 AC_CONFIG_COMMANDS([default],
4771 case ${CONFIG_HEADERS} in
4772 *auto-host.h:config.in*)
4775 # Make sure all the subdirs exist.
4776 for d in $subdirs doc build c-family
4778 test -d $d || mkdir $d
4781 [subdirs='$subdirs'])