2 # Process this file with autoconf to generate a configuration script.
4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5 # 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 2, 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 COPYING. If not, write to the Free
21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 # --------------------------------
25 # Initialization and sanity checks
26 # --------------------------------
30 AC_CONFIG_SRCDIR(tree.c)
31 AC_CONFIG_HEADER(auto-host.h:config.in)
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 _GCC_TOPLEV_NONCANONICAL_TARGET
41 # Determine the target- and build-specific subdirectories
44 # Set program_transform_name
47 # Check for bogus environment variables.
48 # Test if LIBRARY_PATH contains the notation for the current directory
49 # since this would lead to problems installing/building glibc.
50 # LIBRARY_PATH contains the current directory if one of the following
52 # - one of the terminals (":" and ";") is the first or last sign
53 # - two terminals occur directly after each other
54 # - the path contains an element with a dot in it
55 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 case ${LIBRARY_PATH} in
58 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
59 library_path_setting="contains current directory"
62 library_path_setting="ok"
66 AC_MSG_RESULT($library_path_setting)
67 if test "$library_path_setting" != "ok"; then
69 *** LIBRARY_PATH shouldn't contain the current directory when
70 *** building gcc. Please change the environment variable
71 *** and run configure again.])
74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
75 # since this would lead to problems installing/building glibc.
76 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # - one of the terminals (":" and ";") is the first or last sign
79 # - two terminals occur directly after each other
80 # - the path contains an element with a dot in it
81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 case ${GCC_EXEC_PREFIX} in
84 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
85 gcc_exec_prefix_setting="contains current directory"
88 gcc_exec_prefix_setting="ok"
92 AC_MSG_RESULT($gcc_exec_prefix_setting)
93 if test "$gcc_exec_prefix_setting" != "ok"; then
95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
96 *** building gcc. Please change the environment variable
97 *** and run configure again.])
104 # Specify the local prefix
106 AC_ARG_WITH(local-prefix,
107 [ --with-local-prefix=DIR specifies directory to put local include],
108 [case "${withval}" in
109 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
111 *) local_prefix=$with_local_prefix ;;
114 # Default local prefix if it is empty
115 if test x$local_prefix = x; then
116 local_prefix=/usr/local
119 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
120 # passed in by the toplevel make and thus we'd get different behavior
121 # depending on where we built the sources.
123 # Specify the g++ header file directory
124 AC_ARG_WITH(gxx-include-dir,
125 [ --with-gxx-include-dir=DIR
126 specifies directory to put g++ header files],
127 [case "${withval}" in
128 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
130 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
133 if test x${gcc_gxx_include_dir} = x; then
134 if test x${enable_version_specific_runtime_libs} = xyes; then
135 gcc_gxx_include_dir='${libsubdir}/include/c++'
137 topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
138 changequote(<<, >>)dnl
139 gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
144 AC_ARG_WITH(cpp_install_dir,
145 [ --with-cpp-install-dir=DIR
146 install the user visible C preprocessor in DIR
147 (relative to PREFIX) as well as PREFIX/bin],
148 [if test x$withval = xyes; then
149 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
150 elif test x$withval != xno; then
151 cpp_install_dir=$withval
154 # We would like to our source tree to be readonly. However when releases or
155 # pre-releases are generated, the flex/bison generated files as well as the
156 # various formats of manuals need to be included along with the rest of the
157 # sources. Therefore we have --enable-generated-files-in-srcdir to do
160 AC_MSG_CHECKING([whether to place generated files in the source directory])
161 dnl generated-files-in-srcdir is disabled by default
162 AC_ARG_ENABLE(generated-files-in-srcdir,
163 [ --enable-generated-files-in-srcdir
164 put copies of generated files in source dir
165 intended for creating source tarballs for users
166 without texinfo bison or flex.],
167 generated_files_in_srcdir=$enableval,
168 generated_files_in_srcdir=no)
170 AC_MSG_RESULT($generated_files_in_srcdir)
172 if test "$generated_files_in_srcdir" = "yes"; then
179 # -------------------
180 # Find default linker
181 # -------------------
185 [ --with-gnu-ld arrange to work with GNU ld.],
186 gnu_ld_flag="$with_gnu_ld",
189 # With pre-defined ld
191 [ --with-ld arrange to use the specified ld (full pathname)],
192 DEFAULT_LINKER="$with_ld")
193 if test x"${DEFAULT_LINKER+set}" = x"set"; then
194 if test ! -x "$DEFAULT_LINKER"; then
195 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
196 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
199 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
200 [Define to enable the use of a default linker.])
203 AC_MSG_CHECKING([whether a default linker was specified])
204 if test x"${DEFAULT_LINKER+set}" = x"set"; then
205 if test x"$gnu_ld_flag" = x"no"; then
206 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
208 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
214 # With demangler in GNU ld
215 AC_ARG_WITH(demangler-in-ld,
216 [ --with-demangler-in-ld try to use demangler in GNU ld.],
217 demangler_in_ld="$with_demangler_in_ld",
220 # ----------------------
221 # Find default assembler
222 # ----------------------
226 [ --with-gnu-as arrange to work with GNU as],
227 gas_flag="$with_gnu_as",
231 [ --with-as arrange to use the specified as (full pathname)],
232 DEFAULT_ASSEMBLER="$with_as")
233 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
234 if test ! -x "$DEFAULT_ASSEMBLER"; then
235 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
236 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
239 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
240 [Define to enable the use of a default assembler.])
243 AC_MSG_CHECKING([whether a default assembler was specified])
244 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
245 if test x"$gas_flag" = x"no"; then
246 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
248 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
258 # If a non-executable a.out is present (e.g. created by GNU as above even if
259 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
260 # file, even when creating an executable, so an execution test fails.
261 # Remove possible default executable files to avoid this.
263 # FIXME: This really belongs into AC_PROG_CC and can be removed once
264 # Autoconf includes it.
265 rm -f a.out a.exe b.out
267 # Find the native compiler
270 # autoconf is lame and doesn't give us any substitution variable for this.
271 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
272 NO_MINUS_C_MINUS_O=yes
274 OUTPUT_OPTION='-o $@'
276 AC_SUBST(NO_MINUS_C_MINUS_O)
277 AC_SUBST(OUTPUT_OPTION)
279 # -------------------------
280 # Check C compiler features
281 # -------------------------
288 # sizeof(char) is 1 by definition.
289 AC_COMPILE_CHECK_SIZEOF(void *)
290 AC_COMPILE_CHECK_SIZEOF(short)
291 AC_COMPILE_CHECK_SIZEOF(int)
292 AC_COMPILE_CHECK_SIZEOF(long)
293 if test $ac_cv_c_long_long = yes; then
294 AC_COMPILE_CHECK_SIZEOF(long long)
296 if test $ac_cv_c___int64 = yes; then
297 AC_COMPILE_CHECK_SIZEOF(__int64)
300 # ---------------------
301 # Warnings and checking
302 # ---------------------
304 # Check $CC warning features (if it's GCC).
305 # We want to use -pedantic, but we don't want warnings about
308 # So, we only use -pedantic if we can disable those warnings.
311 [whether ${CC} accepts -Wno-long-long],
312 [ac_cv_prog_cc_w_no_long_long],
313 [save_CFLAGS="$CFLAGS"
314 CFLAGS="-Wno-long-long"
315 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
316 [ac_cv_prog_cc_w_no_long_long=yes],
317 [ac_cv_prog_cc_w_no_long_long=no])
318 CFLAGS="$save_CFLAGS"
322 [whether ${CC} accepts -Wno-variadic-macros],
323 [ac_cv_prog_cc_w_no_variadic_macros],
324 [save_CFLAGS="$CFLAGS"
325 CFLAGS="-Wno-variadic-macros"
326 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
327 [ac_cv_prog_cc_w_no_variadic_macros=yes],
328 [ac_cv_prog_cc_w_no_variadic_macros=no])
329 CFLAGS="$save_CFLAGS"
333 if test $ac_cv_prog_cc_w_no_long_long = yes \
334 && test $ac_cv_prog_cc_w_no_variadic_macros = yes ; then
335 strict1_warn="-pedantic -Wno-long-long -Wno-variadic-macros"
337 AC_SUBST(strict1_warn)
339 # Add -Wold-style-definition if it's accepted
341 [whether ${CC} accepts -Wold-style-definition],
342 [ac_cv_prog_cc_w_old_style_definition],
343 [save_CFLAGS="$CFLAGS"
344 CFLAGS="-Wold-style-definition"
345 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
346 [ac_cv_prog_cc_w_old_style_definition=yes],
347 [ac_cv_prog_cc_w_old_style_definition=no])
348 CFLAGS="$save_CFLAGS"
350 if test $ac_cv_prog_cc_w_old_style_definition = yes ; then
351 strict1_warn="${strict1_warn} -Wold-style-definition"
354 # Enable -Werror, period.
355 AC_ARG_ENABLE(werror_always,
356 [ --enable-werror-always enable -Werror always], [],
357 [enable_werror_always=no])
358 if test x${enable_werror_always} = xyes ; then
359 strict1_warn="${strict1_warn} -Werror"
363 # If the native compiler is GCC, we can enable warnings even in stage1.
364 # That's useful for people building cross-compilers, or just running a
367 if test "x$GCC" = "xyes"; then
368 warn_cflags='$(GCC_WARN_CFLAGS)'
370 AC_SUBST(warn_cflags)
372 # Enable -Werror in bootstrap stage2 and later.
373 # Change the default to "no" on release branches.
374 AC_ARG_ENABLE(werror,
375 [ --enable-werror enable -Werror in bootstrap stage2 and later], [],
377 if test x$enable_werror = xyes ; then
382 # Enable expensive internal checks
383 AC_ARG_ENABLE(checking,
384 [ --enable-checking[=LIST]
385 enable expensive run-time checks. With LIST,
386 enable only specific categories of checks.
387 Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
388 default is misc,tree,gc,rtlflag],
394 ac_gc_always_collect=
396 case "${enableval}" in
397 yes) ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
398 ac_rtlflag_checking=1 ;;
400 *) IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
401 set fnord $enableval; shift
406 misc) ac_checking=1 ;;
407 tree) ac_tree_checking=1 ;;
408 rtlflag) ac_rtlflag_checking=1 ;;
409 rtl) ac_rtl_checking=1 ;;
410 gc) ac_gc_checking=1 ;;
411 gcac) ac_gc_always_collect=1 ;;
412 fold) ac_fold_checking=1 ;;
413 valgrind) ac_checking_valgrind=1 ;;
414 *) AC_MSG_ERROR(unknown check category $check) ;;
420 # Enable some checks by default for development versions of GCC
421 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
423 if test x$ac_checking != x ; then
424 AC_DEFINE(ENABLE_CHECKING, 1,
425 [Define if you want more run-time sanity checks. This one gets a grab
426 bag of miscellaneous but relatively cheap checks.])
427 nocommon_flag=-fno-common
429 AC_SUBST(nocommon_flag)
430 if test x$ac_tree_checking != x ; then
431 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
432 [Define if you want all operations on trees (the basic data
433 structure of the front ends) to be checked for dynamic type safety
434 at runtime. This is moderately expensive. The tree browser debugging
435 routines will also be enabled by this option.
437 TREEBROWSER=tree-browser.o
439 AC_SUBST(TREEBROWSER)
440 if test x$ac_rtl_checking != x ; then
441 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
442 [Define if you want all operations on RTL (the basic data structure
443 of the optimizer and back end) to be checked for dynamic type safety
444 at runtime. This is quite expensive.])
446 if test x$ac_rtlflag_checking != x ; then
447 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
448 [Define if you want RTL flag accesses to be checked against the RTL
449 codes that are supported for each access macro. This is relatively
452 if test x$ac_gc_checking != x ; then
453 AC_DEFINE(ENABLE_GC_CHECKING, 1,
454 [Define if you want the garbage collector to do object poisoning and
455 other memory allocation checks. This is quite expensive.])
457 if test x$ac_gc_always_collect != x ; then
458 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
459 [Define if you want the garbage collector to operate in maximally
460 paranoid mode, validating the entire heap and collecting garbage at
461 every opportunity. This is extremely expensive.])
463 if test x$ac_fold_checking != x ; then
464 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
465 [Define if you want fold checked that it never destructs its argument.
466 This is quite expensive.])
468 valgrind_path_defines=
471 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
472 dnl # an if statement. This was the source of very frustrating bugs
473 dnl # in converting to autoconf 2.5x!
474 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
476 if test x$ac_checking_valgrind != x ; then
477 # It is certainly possible that there's valgrind but no valgrind.h.
478 # GCC relies on making annotations so we must have both.
479 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
481 [#include <valgrind/memcheck.h>
482 #ifndef VALGRIND_DISCARD
483 #error VALGRIND_DISCARD not defined
485 [gcc_cv_header_valgrind_memcheck_h=yes],
486 [gcc_cv_header_valgrind_memcheck_h=no])
487 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
488 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
490 [#include <memcheck.h>
491 #ifndef VALGRIND_DISCARD
492 #error VALGRIND_DISCARD not defined
494 [gcc_cv_header_memcheck_h=yes],
495 gcc_cv_header_memcheck_h=no)
496 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
497 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
498 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
499 if test "x$valgrind_path" = "x" \
500 || (test $have_valgrind_h = no \
501 && test $gcc_cv_header_memcheck_h = no \
502 && test $gcc_cv_header_valgrind_memcheck_h = no); then
503 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
505 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
506 valgrind_command="$valgrind_path -q"
507 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
508 [Define if you want to run subprograms and generated programs
509 through valgrind (a memory checker). This is extremely expensive.])
510 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
511 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
512 [Define if valgrind's valgrind/memcheck.h header is installed.])
514 if test $gcc_cv_header_memcheck_h = yes; then
515 AC_DEFINE(HAVE_MEMCHECK_H, 1,
516 [Define if valgrind's memcheck.h header is installed.])
519 AC_SUBST(valgrind_path_defines)
520 AC_SUBST(valgrind_command)
522 AC_ARG_ENABLE(mapped-location,
523 [ --enable-mapped-location location_t is fileline integer cookie],,
524 enable_mapped_location=no)
526 if test "$enable_mapped_location" = yes ; then
527 AC_DEFINE(USE_MAPPED_LOCATION, 1,
528 [Define if location_t is fileline integer cookie.])
531 # Enable code coverage collection
532 AC_ARG_ENABLE(coverage,
533 [ --enable-coverage[=LEVEL]
534 enable compiler\'s code coverage collection.
535 Use to measure compiler performance and locate
536 unused parts of the compiler. With LEVEL, specify
537 optimization. Values are opt, noopt,
539 [case "${enableval}" in
541 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
544 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
547 # a.k.a. --disable-coverage
551 AC_MSG_ERROR(unknown coverage setting $enableval)
555 AC_SUBST(coverage_flags)
557 AC_ARG_ENABLE(gather-detailed-mem-stats,
558 [ --enable-gather-detailed-mem-stats enable detailed memory allocation stats gathering], [],
559 [enable_gather_detailed_mem_stats=no])
560 if test x$enable_gather_detailed_mem_stats = xyes ; then
561 AC_DEFINE(GATHER_STATISTICS, 1,
562 [Define to enable detailed memory allocation stats gathering.])
565 # -------------------------------
566 # Miscenalleous configure options
567 # -------------------------------
571 [ --with-stabs arrange to use stabs instead of host debug format],
575 # Determine whether or not multilibs are enabled.
576 AC_ARG_ENABLE(multilib,
577 [ --enable-multilib enable library support for multiple ABIs],
578 [], [enable_multilib=yes])
579 AC_SUBST(enable_multilib)
581 # Enable __cxa_atexit for C++.
582 AC_ARG_ENABLE(__cxa_atexit,
583 [ --enable-__cxa_atexit enable __cxa_atexit for C++],
587 # Pass with no value to take the default
588 # Pass with a value to specify a thread package
589 AC_ARG_ENABLE(threads,
590 [ --enable-threads enable thread usage for target GCC
591 --enable-threads=LIB use LIB thread package for target GCC],,
594 AC_ARG_ENABLE(objc-gc,
595 [ --enable-objc-gc enable the use of Boehm's garbage collector with
596 the GNU Objective-C runtime],
597 if test x$enable_objc_gc = xno; then
605 [ --with-dwarf2 force the default debug format to be DWARF 2],
606 dwarf2="$with_dwarf2",
609 AC_ARG_ENABLE(shared,
610 [ --disable-shared don't provide a shared libgcc],
612 case $enable_shared in
616 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
617 for pkg in $enableval; do
618 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
625 ], [enable_shared=yes])
626 AC_SUBST(enable_shared)
629 [ --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
631 case ${with_sysroot} in
632 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
633 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
636 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
637 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
639 if test "x$exec_prefix" = xNONE; then
640 if test "x$prefix" = xNONE; then
641 test_prefix=/usr/local
646 test_prefix=$exec_prefix
648 case ${TARGET_SYSTEM_ROOT} in
649 "${test_prefix}"|"${test_prefix}/"*|\
650 '${exec_prefix}'|'${exec_prefix}/'*)
651 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
652 TARGET_SYSTEM_ROOT_DEFINE="$t"
657 TARGET_SYSTEM_ROOT_DEFINE=
658 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
660 AC_SUBST(TARGET_SYSTEM_ROOT)
661 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
662 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
664 # Build with intermodule optimisations
665 AC_ARG_ENABLE(intermodule,
666 [ --enable-intermodule build the compiler in one step],
667 [case ${enable_intermodule} in
668 yes) onestep="-onestep";;
674 # Sanity check enable_languages in case someone does not run the toplevel
675 # configure # script.
676 AC_ARG_ENABLE(languages,
677 [ --enable-languages=LIST specify which front-ends to build],
678 [case ,${enable_languages}, in
680 # go safe -- we cannot be much sure without the toplevel
682 # analysis of which target libs are present and usable
686 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
691 enable_languages=c,${enable_languages}
694 [enable_languages=c])
697 for lang in ${srcdir}/*/config-lang.in
700 # The odd quoting in the next line works around
701 # an apparent bug in bash 1.12 on linux.
703 ${srcdir}/[*]/config-lang.in) ;;
705 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
706 if test "x$lang_alias" = x
708 echo "$lang doesn't set \$language." 1>&2
711 case ",$enable_languages," in
713 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;;
721 # -------------------------
722 # Checks for other programs
723 # -------------------------
727 # Find some useful tools
729 # We need awk to create options.c and options.h.
730 # Bail out if it's missing.
732 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
740 # By default, the Darwin ranlib will not treat common symbols as
741 # definitions when building the archive table of contents. Other
742 # ranlibs do that; pass an option to the Darwin ranlib that makes
743 # it behave similarly.
749 AC_SUBST(ranlib_flags)
753 # See if cmp has --ignore-initial.
754 gcc_AC_PROG_CMP_IGNORE_INITIAL
756 # See if we have the mktemp command.
757 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
759 # Do we have a single-tree copy of texinfo?
760 if test -f $srcdir/../texinfo/Makefile.in; then
761 MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
762 gcc_cv_prog_makeinfo_modern=yes
763 AC_MSG_RESULT([Using makeinfo from the unified source tree.])
765 # See if makeinfo has been installed and is modern enough
766 # that we can use it.
767 gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
768 [GNU texinfo.* \([0-9][0-9.]*\)],
772 if test $gcc_cv_prog_makeinfo_modern = no; then
774 *** Makeinfo is missing or too old.
775 *** Info documentation will not be built.])
778 BUILD_INFO=info AC_SUBST(BUILD_INFO)
781 # Is pod2man recent enough to regenerate manpages?
782 AC_MSG_CHECKING([for recent Pod::Man])
783 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
785 GENERATED_MANPAGES=generated-manpages AC_SUBST(GENERATED_MANPAGES)
792 dnl Don't use AC_PROG_LEX; we insist on flex.
793 dnl LEXLIB is not useful in gcc.
794 if test x${build} = x${host} && test -f $srcdir/../flex/skel.c; then
795 FLEX='$(objdir)/../flex/flex'
797 AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
801 # The -L switch is so bison can find its skeleton file.
802 if test x${build} = x${host} && test -f $srcdir/../bison/bison.simple; then
803 BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
805 AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
808 # --------------------
809 # Checks for C headers
810 # --------------------
812 AC_MSG_CHECKING(for GNU C library)
813 AC_CACHE_VAL(gcc_cv_glibc,
815 [#include <features.h>],[
816 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
817 #error Not a GNU C library system
821 AC_MSG_RESULT($gcc_cv_glibc)
822 if test $gcc_cv_glibc = yes; then
823 AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
826 # Need to reject headers which give warnings, so that the -Werror bootstrap
827 # works later. *sigh* This needs to come before all header checks.
834 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
835 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
836 sys/resource.h sys/param.h sys/times.h sys/stat.h \
837 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
839 # Check for thread headers.
840 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
841 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
843 # These tests can't be done till we know if we have limits.h.
851 # Stage specific cflags for build.
857 stage1_cflags="-Wa,-J"
863 # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
864 # sources; use -no-cpp-precomp to get to GNU cpp.
865 # Apple's GCC has bugs in designated initializer handling, so disable
867 stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
870 AC_SUBST(stage1_cflags)
872 # These libraries may be used by collect2.
873 # We may need a special search path to get them linked.
874 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
876 for libs in '' -lld -lmld \
877 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
878 '-L/usr/lib/cmplrs/cc3.11 -lmld'
881 AC_TRY_LINK_FUNC(ldopen,
882 [gcc_cv_collect2_libs="$libs"; break])
885 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
886 case $gcc_cv_collect2_libs in
888 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
890 AC_SUBST(COLLECT2_LIBS)
892 # When building Ada code on Alpha, we need exc_resume which is usually in
893 # -lexc. So test for it.
896 AC_SEARCH_LIBS(exc_resume, exc)
899 AC_SUBST(GNAT_LIBEXC)
901 # Some systems put ldexp and frexp in libm instead of libc; assume
902 # they're both in the same place. jcf-dump needs them.
905 AC_SEARCH_LIBS(ldexp, m)
910 # Use <inttypes.h> only if it exists,
911 # doesn't clash with <sys/types.h>, and declares intmax_t.
912 AC_MSG_CHECKING(for inttypes.h)
913 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
915 [#include <sys/types.h>
916 #include <inttypes.h>],
918 [gcc_cv_header_inttypes_h=yes],
919 gcc_cv_header_inttypes_h=no)])
920 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
921 if test $gcc_cv_header_inttypes_h = yes; then
922 AC_DEFINE(HAVE_INTTYPES_H, 1,
923 [Define if you have a working <inttypes.h> header file.])
926 dnl Disabled until we have a complete test for buggy enum bitfields.
927 dnl gcc_AC_C_ENUM_BF_UNSIGNED
929 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
930 sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
931 fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
932 scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
935 if test x$ac_cv_func_mbstowcs = xyes; then
936 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
937 [ AC_TRY_RUN([#include <stdlib.h>
943 gcc_cv_func_mbstowcs_works=yes,
944 gcc_cv_func_mbstowcs_works=no,
945 gcc_cv_func_mbstowcs_works=yes)])
946 if test x$gcc_cv_func_mbstowcs_works = xyes; then
947 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
948 [Define this macro if mbstowcs does not crash when its
949 first argument is NULL.])
953 AC_CHECK_TYPE(ssize_t, int)
955 # Try to determine the array type of the second argument of getgroups
956 # for the target system (int or gid_t).
958 if test "${target}" = "${build}"; then
959 TARGET_GETGROUPS_T=$ac_cv_type_getgroups
962 # This condition may need some tweaking. It should include all
963 # targets where the array type of the second argument of getgroups
964 # is int and the type of gid_t is not equivalent to int.
965 *-*-sunos* | *-*-ultrix*)
966 TARGET_GETGROUPS_T=int
969 TARGET_GETGROUPS_T=gid_t
973 AC_SUBST(TARGET_GETGROUPS_T)
975 gcc_AC_FUNC_PRINTF_PTR
976 gcc_AC_FUNC_MMAP_BLACKLIST
980 # Under VMS, vfork works very differently than on Unix. The standard test
981 # won't work, and it isn't easily adaptable. It makes more sense to
983 ac_cv_func_vfork_works=yes
989 # Until we have in-tree GNU iconv:
991 AC_SUBST(LIBICONV_DEP)
995 # We will need to find libiberty.h and ansidecl.h
996 saved_CFLAGS="$CFLAGS"
997 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
998 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
999 strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
1000 fprintf_unlocked strstr errno snprintf vasprintf \
1001 malloc realloc calloc free basename getopt clock, , ,[
1002 #include "ansidecl.h"
1003 #include "system.h"])
1005 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1006 #include "ansidecl.h"
1008 #ifdef HAVE_SYS_RESOURCE_H
1009 #include <sys/resource.h>
1014 #include "ansidecl.h"
1016 #ifdef HAVE_SYS_RESOURCE_H
1017 #include <sys/resource.h>
1019 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
1020 [Define to \`long' if <sys/resource.h> doesn't define.])])
1022 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1023 #include "ansidecl.h"
1030 gcc_AC_CHECK_DECLS(times, , ,[
1031 #include "ansidecl.h"
1033 #ifdef HAVE_SYS_TIMES_H
1034 #include <sys/times.h>
1038 # More time-related stuff.
1039 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1041 #include "ansidecl.h"
1043 #ifdef HAVE_SYS_TIMES_H
1044 #include <sys/times.h>
1046 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
1047 if test $ac_cv_struct_tms = yes; then
1048 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1049 [Define if <sys/times.h> defines struct tms.])
1052 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1053 # revisit after autoconf 2.50.
1054 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1056 #include "ansidecl.h"
1058 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
1059 if test $gcc_cv_type_clock_t = yes; then
1060 AC_DEFINE(HAVE_CLOCK_T, 1,
1061 [Define if <time.h> defines clock_t.])
1064 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1065 CFLAGS="$saved_CFLAGS"
1067 gcc_AC_INITFINI_ARRAY
1069 # mkdir takes a single argument on some systems.
1070 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1078 # With Setjmp/Longjmp based exception handling.
1079 AC_ARG_ENABLE(sjlj-exceptions,
1080 [ --enable-sjlj-exceptions
1081 arrange to use setjmp/longjmp exception handling],
1082 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1083 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1084 [Define 0/1 to force the choice for exception handling model.])])
1086 if test x$host = x$target; then
1087 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
1089 use_libunwind_default=no
1091 # Use libunwind based exception handling.
1092 AC_ARG_ENABLE(libunwind-exceptions,
1093 [ --enable-libunwind-exceptions force use libunwind for exceptions],
1094 use_libunwind_exceptions=$enableval,
1095 use_libunwind_exceptions=$use_libunwind_default)
1096 if test x"$use_libunwind_exceptions" = xyes; then
1097 AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
1098 [Define if gcc should use -lunwind.])
1101 # --------------------------------------------------------
1102 # Build, host, and target specific configuration fragments
1103 # --------------------------------------------------------
1105 # Collect build-machine-specific information.
1106 . ${srcdir}/config.build
1108 # Collect host-machine-specific information.
1109 . ${srcdir}/config.host
1113 # Collect target-machine-specific information.
1114 . ${srcdir}/config.gcc
1116 extra_objs="${host_extra_objs} ${extra_objs}"
1117 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1119 # Default the target-machine variables that were not explicitly set.
1120 if test x"$tm_file" = x
1121 then tm_file=$cpu_type/$cpu_type.h; fi
1123 if test x"$extra_headers" = x
1124 then extra_headers=; fi
1126 if test x$md_file = x
1127 then md_file=$cpu_type/$cpu_type.md; fi
1129 if test x$out_file = x
1130 then out_file=$cpu_type/$cpu_type.c; fi
1132 if test x"$tmake_file" = x
1133 then tmake_file=$cpu_type/t-$cpu_type
1136 if test x"$dwarf2" = xyes
1137 then tm_file="$tm_file tm-dwarf2.h"
1140 # Say what files are being used for the output code and MD file.
1141 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1142 echo "Using \`$srcdir/config/$md_file' as machine description file."
1144 # If any of the xm_file variables contain nonexistent files, warn
1145 # about them and drop them.
1148 for x in $build_xm_file; do
1149 if test -f $srcdir/config/$x
1151 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1157 for x in $host_xm_file; do
1158 if test -f $srcdir/config/$x
1160 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1166 for x in $xm_file; do
1167 if test -f $srcdir/config/$x
1169 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1175 for f in $tm_file; do
1178 if test $count = ax; then
1179 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1181 echo "Using the following target machine macro files:"
1182 for f in $tm_file; do
1183 echo " $srcdir/config/$f"
1187 if test x$need_64bit_hwint = xyes; then
1188 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1189 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1193 for f in $host_xm_file; do
1196 if test $count = a; then
1198 elif test $count = ax; then
1199 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1201 echo "Using the following host machine macro files:"
1202 for f in $host_xm_file; do
1203 echo " $srcdir/config/$f"
1206 echo "Using ${out_host_hook_obj} for host machine hooks."
1208 if test "$host_xm_file" != "$build_xm_file"; then
1210 for f in $build_xm_file; do
1213 if test $count = a; then
1215 elif test $count = ax; then
1216 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1218 echo "Using the following build machine macro files:"
1219 for f in $build_xm_file; do
1220 echo " $srcdir/config/$f"
1229 # Check if a valid thread package
1230 case ${enable_threads} in
1233 target_thread_file='single'
1237 target_thread_file='single'
1239 aix | dce | gnat | irix | posix | rtems | \
1240 single | solaris | vxworks | win32 )
1241 target_thread_file=${enable_threads}
1244 echo "${enable_threads} is an unknown thread package" 1>&2
1249 if test x${thread_file} = x; then
1250 # No thread file set by target-specific clauses in config.gcc,
1251 # so use file chosen by default logic above
1252 thread_file=${target_thread_file}
1255 # Make gthr-default.h if we have a thread file.
1257 if test $thread_file != single; then
1258 rm -f gthr-default.h
1259 echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1260 gthread_flags=-DHAVE_GTHR_DEFAULT
1262 AC_SUBST(gthread_flags)
1268 if test x$enable___cxa_atexit = xyes || \
1269 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1270 AC_CHECK_FUNC(__cxa_atexit,
1271 [AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1272 [Define if you want to use __cxa_atexit, rather than atexit, to
1273 register C++ destructors for local statics and global objects.
1274 This is essential for fully standards-compliant handling of
1275 destructors, but requires __cxa_atexit in libc.])],
1276 echo "__cxa_atexit can't be enabled on this target")
1279 # Look for a file containing extra machine modes.
1280 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1281 extra_modes_file='$(srcdir)'/config/${extra_modes}
1282 AC_SUBST(extra_modes_file)
1283 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1284 [Define to the name of a file containing a list of extra machine modes
1285 for this architecture.])
1288 # auto-host.h is the file containing items generated by autoconf and is
1289 # the first file included by config.h.
1290 # If host=build, it is correct to have bconfig include auto-host.h
1291 # as well. If host!=build, we are in error and need to do more
1292 # work to find out the build config parameters.
1293 if test x$host = x$build
1295 build_auto=auto-host.h
1298 # We create a subdir, then run autoconf in the subdir.
1299 # To prevent recursion we set host and build for the new
1300 # invocation of configure to the build for this invocation
1307 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1308 *) realsrcdir=../${srcdir};;
1310 saved_CFLAGS="${CFLAGS}"
1311 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1312 ${realsrcdir}/configure \
1313 --enable-languages=${enable_languages-all} \
1314 --target=$target_alias --host=$build_alias --build=$build_alias
1315 CFLAGS="${saved_CFLAGS}"
1317 # We just finished tests for the build machine, so rename
1318 # the file auto-build.h in the gcc directory.
1319 mv auto-host.h ../auto-build.h
1322 build_auto=auto-build.h
1323 FORBUILD=../${build_subdir}
1327 tm_file="${tm_file} defaults.h"
1328 tm_p_file="${tm_p_file} tm-preds.h"
1329 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1330 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1331 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1332 # put this back in temporarily.
1333 xm_file="ansidecl.h ${xm_file}"
1339 # Get the version trigger filename from the toplevel
1340 if test "${with_gcc_version_trigger+set}" = set; then
1341 gcc_version_trigger=$with_gcc_version_trigger
1343 gcc_version_trigger=${srcdir}/version.c
1346 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1347 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1349 # Compile in configure arguments.
1350 if test -f configargs.h ; then
1351 # Being re-configured.
1352 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1353 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1355 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1358 # Double all backslashes and backslash all quotes to turn
1359 # gcc_config_arguments into a C string.
1360 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1361 $gcc_config_arguments
1363 gcc_config_arguments_str=`cat conftest.out`
1366 cat > configargs.h <<EOF
1367 /* Generated automatically. */
1368 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1369 static const char thread_model[] = "$thread_file";
1371 static const struct {
1372 const char *name, *value;
1373 } configure_default_options[] = $configure_default_options;
1377 # Internationalization
1379 VERSION="$gcc_version"
1383 ZW_GNU_GETTEXT_SISTER_DIR
1385 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1386 # -liconv on the link line twice.
1387 case "$LIBINTL" in *$LIBICONV*)
1391 # Windows32 Registry support for specifying GCC installation paths.
1392 AC_ARG_ENABLE(win32-registry,
1393 [ --disable-win32-registry
1394 disable lookup of installation paths in the
1395 Registry on Windows hosts
1396 --enable-win32-registry enable registry lookup (default)
1397 --enable-win32-registry=KEY
1398 use KEY instead of GCC version as the last portion
1399 of the registry key],,)
1401 win32 | pe | cygwin* | mingw32* | uwin*)
1402 AC_MSG_CHECKING(whether windows registry support is requested)
1403 if test "x$enable_win32_registry" != xno; then
1404 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1405 [Define to 1 if installation paths should be looked up in Windows32
1406 Registry. Ignored on non windows32 hosts.])
1408 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1413 # Check if user specified a different registry key.
1414 case "x${enable_win32_registry}" in
1417 gcc_cv_win32_registry_key="$VERSION"
1420 # no registry lookup.
1421 gcc_cv_win32_registry_key=''
1424 # user-specified key.
1425 gcc_cv_win32_registry_key="$enable_win32_registry"
1429 if test "x$enable_win32_registry" != xno; then
1430 AC_MSG_CHECKING(registry key on windows hosts)
1431 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1432 [Define to be the last portion of registry key on windows hosts.])
1433 AC_MSG_RESULT($gcc_cv_win32_registry_key)
1438 # Get an absolute path to the GCC top-level source directory
1439 holddir=`${PWDCMD-pwd}`
1441 topdir=`${PWDCMD-pwd}`
1444 # Conditionalize the makefile for this host machine.
1446 for f in ${host_xmake_file}
1448 if test -f ${srcdir}/config/$f
1450 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1454 # Conditionalize the makefile for this target machine.
1456 for f in ${tmake_file}
1458 if test -f ${srcdir}/config/$f
1460 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1463 tmake_file="${tmake_file_}"
1465 symbolic_link='ln -s'
1467 # If the host doesn't support symlinks, modify CC in
1468 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1469 # Otherwise, we can use "CC=$(CC)".
1471 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1473 cc_set_by_configure="\$(CC)"
1474 quoted_cc_set_by_configure="\$(CC)"
1475 stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1476 quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1479 if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1481 symbolic_link="cp -p"
1485 cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1486 quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1487 stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1488 quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1492 out_object_file=`basename $out_file .c`.o
1496 for f in $tm_file; do
1499 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1500 tm_include_list="${tm_include_list} $f"
1503 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1504 tm_include_list="${tm_include_list} config/$f"
1511 for f in $tm_p_file; do
1514 tm_p_file_list="${tm_p_file_list} $f"
1515 tm_p_include_list="${tm_p_include_list} $f"
1518 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1519 tm_p_include_list="${tm_p_include_list} config/$f"
1525 for f in $xm_file; do
1528 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1529 xm_include_list="${xm_include_list} $f"
1532 xm_file_list="${xm_file_list} $f"
1533 xm_include_list="${xm_include_list} $f"
1536 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1537 xm_include_list="${xm_include_list} config/$f"
1543 host_xm_include_list=
1544 for f in $host_xm_file; do
1547 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1548 host_xm_include_list="${host_xm_include_list} $f"
1551 host_xm_file_list="${host_xm_file_list} $f"
1552 host_xm_include_list="${host_xm_include_list} $f"
1555 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1556 host_xm_include_list="${host_xm_include_list} config/$f"
1562 for f in $build_xm_file; do
1565 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1566 build_xm_include_list="${build_xm_include_list} $f"
1568 auto-build.h | auto-host.h )
1569 build_xm_file_list="${build_xm_file_list} $f"
1570 build_xm_include_list="${build_xm_include_list} $f"
1573 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1574 build_xm_include_list="${build_xm_include_list} config/$f"
1579 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1580 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1581 CROSS= AC_SUBST(CROSS)
1582 ALL=all.internal AC_SUBST(ALL)
1583 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1584 if test x$host != x$target
1586 CROSS="-DCROSS_COMPILE"
1588 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1589 case "$host","$target" in
1590 # Darwin crosses can use the host system's libraries and headers,
1591 # because of the fat library support. Of course, it must be the
1592 # same version of Darwin on both sides. Allow the user to
1593 # just say --target=foo-darwin without a version number to mean
1594 # "the version on this system".
1595 *-*-darwin*,*-*-darwin*)
1596 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1597 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1598 if test $hostos = $targetos -o $targetos = darwin ; then
1600 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1605 i?86-*-*,x86_64-*-* \
1606 | powerpc*-*-*,powerpc64*-*-*)
1607 CROSS="$CROSS -DNATIVE_CROSS" ;;
1609 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1610 # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1611 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1614 # If this is a cross-compiler that does not
1615 # have its own set of headers then define
1618 # If this is using newlib, without having the headers available now,
1619 # then define inhibit_libc in LIBGCC2_CFLAGS.
1620 # This prevents libgcc2 from containing any code which requires libc
1623 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1624 test x$with_newlib = xyes ; } &&
1625 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1626 inhibit_libc=-Dinhibit_libc
1628 AC_SUBST(inhibit_libc)
1630 # When building gcc with a cross-compiler, we need to adjust things so
1631 # that the generator programs are still built with the native compiler.
1632 # Also, we cannot run fixincludes or fix-header.
1634 # These are the normal (build=host) settings:
1635 BUILD_PREFIX= AC_SUBST(BUILD_PREFIX)
1636 BUILD_PREFIX_1=ignore- AC_SUBST(BUILD_PREFIX_1)
1637 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1638 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1640 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1642 # Possibly disable fixproto, on a per-target basis.
1643 case ${use_fixproto} in
1648 STMP_FIXPROTO=stmp-fixproto
1651 AC_SUBST(STMP_FIXPROTO)
1653 # And these apply if build != host, or we are generating coverage data
1654 if test x$build != x$host || test "x$coverage_flags" != x
1657 BUILD_PREFIX_1=build-
1658 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1660 if test "x$TARGET_SYSTEM_ROOT" = x; then
1666 # Expand extra_headers to include complete path.
1667 # This substitutes for lots of t-* files.
1669 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1670 for file in ${extra_headers} ; do
1671 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1674 # Define collect2 in Makefile.
1675 case $host_can_use_collect2 in
1677 *) collect2='collect2$(exeext)' ;;
1679 AC_SUBST([collect2])
1681 # Add a definition of USE_COLLECT2 if system wants one.
1682 case $use_collect2 in
1683 no) use_collect2= ;;
1686 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1687 xm_defines="${xm_defines} USE_COLLECT2"
1688 case $host_can_use_collect2 in
1690 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1696 # ---------------------------
1697 # Assembler & linker features
1698 # ---------------------------
1700 # Identify the assembler which will work hand-in-glove with the newly
1701 # built GCC, so that we can examine its features. This is the assembler
1702 # which will be driven by the driver program.
1704 # If build != host, and we aren't building gas in-tree, we identify a
1705 # build->target assembler and hope that it will have the same features
1706 # as the host->target assembler we'll be using.
1707 AC_MSG_CHECKING(what assembler to use)
1710 gcc_cv_gas_major_version=
1711 gcc_cv_gas_minor_version=
1712 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1713 if test -x "$DEFAULT_ASSEMBLER"; then
1714 gcc_cv_as="$DEFAULT_ASSEMBLER"
1715 elif test -x as$host_exeext; then
1716 # Build using assembler in the current directory.
1717 gcc_cv_as=./as$host_exeext
1718 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1719 && test -f ../gas/Makefile \
1720 && test x$build = x$host; then
1721 # Single tree build which includes gas. We want to prefer it
1722 # over whatever linker top-level may have detected, since
1723 # we'll use what we're building after installation anyway.
1725 _gcc_COMPUTE_GAS_VERSION
1726 rm -f as$host_exeext
1727 $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1728 in_tree_gas_is_elf=no
1729 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1730 || (grep 'obj_format = multi' ../gas/Makefile \
1731 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1733 in_tree_gas_is_elf=yes
1735 m4_pattern_allow([AS_FOR_TARGET])dnl
1736 elif test -x "$AS_FOR_TARGET"; then
1737 gcc_cv_as="$AS_FOR_TARGET"
1738 elif test -x "$AS" && test x$host = x$target; then
1742 if test "x$gcc_cv_as" = x; then
1743 # Search the same directories that the installed compiler will
1744 # search. Else we may find the wrong assembler and lose. If we
1745 # do not find a suitable assembler binary, then try the user's
1748 # Also note we have to check MD_EXEC_PREFIX before checking the
1749 # user's path. Unfortunately, there is no good way to get at the
1750 # value of MD_EXEC_PREFIX here. So we do a brute force search
1751 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1752 # to be fixed as part of the make/configure rewrite too.
1754 if test "x$exec_prefix" = xNONE; then
1755 if test "x$prefix" = xNONE; then
1756 test_prefix=/usr/local
1761 test_prefix=$exec_prefix
1764 # If the loop below does not find an assembler, then use whatever
1765 # one we can find in the users's path.
1767 if test "x$program_prefix" != xNONE; then
1768 gcc_cv_as=${program_prefix}as$host_exeext
1770 gcc_cv_as=`echo as | sed "${program_transform_name}"`$host_exeext
1773 test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1774 $test_prefix/libexec/gcc/$target_noncanonical \
1775 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1776 /usr/lib/gcc/$target_noncanonical \
1777 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1778 $test_prefix/$target_noncanonical/bin"
1780 if test x$host = x$target; then
1781 test_dirs="$test_dirs \
1786 /bsd43/usr/lib/cmplrs/cc \
1787 /usr/cross64/usr/bin \
1788 /usr/lib/cmplrs/cc \
1789 /sysv/usr/lib/cmplrs/cc \
1790 /svr4/usr/lib/cmplrs/cc \
1794 for dir in $test_dirs; do
1795 if test -x $dir/as$host_exeext; then
1796 gcc_cv_as=$dir/as$host_exeext
1801 case $in_tree_gas in
1803 AC_MSG_RESULT("newly built gas")
1806 AC_MSG_RESULT($gcc_cv_as)
1810 # Identify the linker which will work hand-in-glove with the newly
1811 # built GCC, so that we can examine its features. This is the linker
1812 # which will be driven by the driver program.
1814 # If build != host, and we aren't building gas in-tree, we identify a
1815 # build->target linker and hope that it will have the same features
1816 # as the host->target linker we'll be using.
1817 AC_MSG_CHECKING(what linker to use)
1820 gcc_cv_gld_major_version=
1821 gcc_cv_gld_minor_version=
1822 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1823 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1824 if test -x "$DEFAULT_LINKER"; then
1825 gcc_cv_ld="$DEFAULT_LINKER"
1826 elif test -x collect-ld$host_exeext; then
1827 # Build using linker in the current directory.
1828 gcc_cv_ld=./collect-ld$host_exeext
1829 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1830 && test -f ../ld/Makefile \
1831 && test x$build = x$host; then
1832 # Single tree build which includes ld. We want to prefer it
1833 # over whatever linker top-level may have detected, since
1834 # we'll use what we're building after installation anyway.
1836 in_tree_ld_is_elf=no
1837 if (grep 'EMUL = .*elf' ../ld/Makefile \
1838 || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1839 in_tree_ld_is_elf=yes
1841 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
1844 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1846 if test x$gcc_cv_gld_version != x; then
1851 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1852 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1854 rm -f collect-ld$host_exeext
1855 $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1857 elif test -x "$LD_FOR_TARGET"; then
1858 gcc_cv_ld="$LD_FOR_TARGET"
1859 elif test -x "$LD" && test x$host = x$target; then
1863 if test "x$gcc_cv_ld" = x; then
1864 # Search the same directories that the installed compiler will
1865 # search. Else we may find the wrong linker and lose. If we
1866 # do not find a suitable linker binary, then try the user's
1869 # Also note we have to check MD_EXEC_PREFIX before checking the
1870 # user's path. Unfortunately, there is no good way to get at the
1871 # value of MD_EXEC_PREFIX here. So we do a brute force search
1872 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1873 # to be fixed as part of the make/configure rewrite too.
1875 if test "x$exec_prefix" = xNONE; then
1876 if test "x$prefix" = xNONE; then
1877 test_prefix=/usr/local
1882 test_prefix=$exec_prefix
1885 # If the loop below does not find an linker, then use whatever
1886 # one we can find in the users's path.
1888 if test "x$program_prefix" != xNONE; then
1889 gcc_cv_ld=${program_prefix}ld$host_exeext
1891 gcc_cv_ld=`echo ld | sed "${program_transform_name}"`$host_exeext
1894 test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1895 $test_prefix/libexec/gcc/$target_noncanonical \
1896 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1897 /usr/lib/gcc/$target_noncanonical \
1898 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1899 $test_prefix/$target_noncanonical/bin"
1901 if test x$host = x$target; then
1902 test_dirs="$test_dirs \
1907 /bsd43/usr/lib/cmplrs/cc \
1908 /usr/cross64/usr/bin \
1909 /usr/lib/cmplrs/cc \
1910 /sysv/usr/lib/cmplrs/cc \
1911 /svr4/usr/lib/cmplrs/cc \
1915 for dir in $test_dirs; do
1916 if test -x $dir/ld$host_exeext; then
1917 gcc_cv_ld=$dir/ld$host_exeext
1924 AC_MSG_RESULT("newly built ld")
1927 AC_MSG_RESULT($gcc_cv_ld)
1931 # Figure out what nm we will be using.
1932 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1933 AC_MSG_CHECKING(what nm to use)
1935 if test -x nm$host_exeext; then
1936 gcc_cv_nm=./nm$host_exeext
1937 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1938 && test -f ../binutils/Makefile; then
1939 # Single tree build which includes binutils.
1941 gcc_cv_nm=./nm$host_exeext
1942 rm -f nm$host_exeext
1943 $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1944 elif test "x$program_prefix" != xNONE; then
1945 gcc_cv_nm=${program_prefix}nm$host_exeext
1947 gcc_cv_nm=`echo nm | sed "${program_transform_name}"`$host_exeext
1950 yes) AC_MSG_RESULT("newly built nm") ;;
1951 no) AC_MSG_RESULT($gcc_cv_nm) ;;
1954 # Figure out what objdump we will be using.
1955 AC_MSG_CHECKING(what objdump to use)
1957 if test -x objdump$host_exeext; then
1958 gcc_cv_objdump=./objdump$host_exeext
1959 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1960 && test -f ../binutils/Makefile; then
1961 # Single tree build which includes binutils.
1963 gcc_cv_objdump=./objdump$host_exeext
1964 rm -f objdump$host_exeext
1965 $symbolic_link ../binutils/objdump$host_exeext \
1966 objdump$host_exeext 2>/dev/null
1967 elif test "x$program_prefix" != xNONE; then
1968 gcc_cv_objdump=${program_prefix}objdump$host_exeext
1970 gcc_cv_objdump=`echo objdump | \
1971 sed "${program_transform_name}"`$host_exeext
1973 case $in_tree_objdump in
1974 yes) AC_MSG_RESULT("newly built objdump") ;;
1975 no) AC_MSG_RESULT($gcc_cv_objdump) ;;
1978 # Figure out what assembler alignment features are present.
1979 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1983 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1984 [Define if your assembler supports .balign and .p2align.])])
1986 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
1989 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
1990 [Define if your assembler supports specifying the maximum number
1991 of bytes to skip when using the GAS .p2align command.])])
1993 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
1995 [conftest_label1: .word 0
1997 conftest_label2: .word 0
1999 [if test x$gcc_cv_nm != x; then
2000 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2001 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2002 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2004 else gcc_cv_as_subsection_m1=yes
2006 rm -f conftest.nm1 conftest.nm2
2008 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2009 [Define if your assembler supports .subsection and .subsection -1 starts
2010 emitting at the beginning of your section.])])
2012 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2015 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2017 # .hidden needs to be supported in both the assembler and the linker,
2018 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2019 # This is irritatingly difficult to feature test for; we have to check the
2020 # date string after the version number. If we've got an in-tree
2021 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2023 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2024 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2029 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2030 [if test $in_tree_ld = yes ; then
2032 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 \
2033 && test $in_tree_ld_is_elf = yes; then
2034 gcc_cv_ld_hidden=yes
2037 gcc_cv_ld_hidden=yes
2038 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2039 if echo "$ld_ver" | grep GNU > /dev/null; then
2041 ld_vers=`echo $ld_ver | sed -n \
2042 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2043 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2044 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2045 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
2046 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
2047 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p'`
2048 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'`
2049 if test 0"$ld_date" -lt 20020404; then
2050 if test -n "$ld_date"; then
2051 # If there was date string, but was earlier than 2002-04-04, fail
2053 elif test -z "$ld_vers"; then
2054 # If there was no date string nor ld version number, something is wrong
2057 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2058 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2059 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2060 test -z "$ld_vers_patch" && ld_vers_patch=0
2061 if test "$ld_vers_major" -lt 2; then
2063 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2064 gcc_cv_ld_hidden="no"
2065 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2073 hppa64*-*-hpux* | ia64*-*-hpux*)
2074 gcc_cv_ld_hidden=yes
2082 libgcc_visibility=no
2083 AC_SUBST(libgcc_visibility)
2084 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2085 libgcc_visibility=yes
2086 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2087 [Define if your assembler and linker support .hidden.])
2090 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2091 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2099 [# GAS versions before 2.11 do not support uleb128,
2100 # despite appearing to.
2101 # ??? There exists an elf-specific test that will crash
2102 # the assembler. Perhaps it's better to figure out whether
2103 # arbitrary sections are supported and try the test.
2104 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2105 if echo "$as_ver" | grep GNU > /dev/null; then
2107 as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
2108 as_major=`echo $as_ver | sed 's/\..*//'`
2109 as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
2111 if test $as_major -eq 2 && test $as_minor -lt 11
2113 else gcc_cv_as_leb128=yes
2116 [AC_DEFINE(HAVE_AS_LEB128, 1,
2117 [Define if your assembler supports .sleb128 and .uleb128.])])
2119 # GAS versions up to and including 2.11.0 may mis-optimize
2121 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2129 .section .eh_frame,"aw",@progbits
2131 .4byte .LECIE1-.LSCIE1
2145 .4byte .LEFDE1-.LASFDE1
2147 .4byte .LASFDE1-__FRAME_BEGIN__
2155 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2156 cat > conftest.lit <<EOF
2157 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2158 0010 01000000 12000000 18000000 00000000 ................
2159 0020 08000000 04080000 0044 .........D @&t@
2161 cat > conftest.big <<EOF
2162 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2163 0010 00000001 00000012 00000018 00000000 ................
2164 0020 00000008 04000000 0844 .........D @&t@
2166 # If the assembler didn't choke, and we can objdump,
2167 # and we got the correct data, then succeed.
2168 if test x$gcc_cv_objdump != x \
2169 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2170 | tail -3 > conftest.got \
2171 && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2172 || cmp conftest.big conftest.got > /dev/null 2>&1; }
2174 gcc_cv_as_eh_frame=yes
2175 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2176 gcc_cv_as_eh_frame=buggy
2178 # Uh oh, what do we do now?
2179 gcc_cv_as_eh_frame=no
2182 if test $gcc_cv_as_eh_frame = buggy; then
2183 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2184 [Define if your assembler mis-optimizes .eh_frame data.])
2187 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2188 [elf,2,12,0], [--fatal-warnings],
2189 [.section .rodata.str, "aMS", @progbits, 1])
2190 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2191 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2192 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2194 # Thread-local storage - the check is heavily parametrized.
2203 .section ".tdata","awT",@progbits
2206 ldq $27,__tls_get_addr($29) !literal!1
2207 lda $16,foo($29) !tlsgd!1
2208 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2209 ldq $27,__tls_get_addr($29) !literal!2
2210 lda $16,foo($29) !tlsldm!2
2211 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2212 ldq $1,foo($29) !gotdtprel
2213 ldah $2,foo($29) !dtprelhi
2214 lda $3,foo($2) !dtprello
2215 lda $4,foo($29) !dtprel
2216 ldq $1,foo($29) !gottprel
2217 ldah $2,foo($29) !tprelhi
2218 lda $3,foo($2) !tprello
2219 lda $4,foo($29) !tprel'
2222 tls_as_opt=--fatal-warnings
2226 .section ".tdata","awT",@progbits
2230 leal foo@TLSGD(,%ebx,1), %eax
2231 leal foo@TLSLDM(%ebx), %eax
2232 leal foo@DTPOFF(%eax), %edx
2233 movl foo@GOTTPOFF(%ebx), %eax
2234 subl foo@GOTTPOFF(%ebx), %eax
2235 addl foo@GOTNTPOFF(%ebx), %eax
2236 movl foo@INDNTPOFF, %eax
2237 movl $foo@TPOFF, %eax
2238 subl $foo@TPOFF, %eax
2239 leal foo@NTPOFF(%ecx), %eax'
2242 tls_as_opt=--fatal-warnings
2246 .section ".tdata","awT",@progbits
2250 leaq foo@TLSGD(%rip), %rdi
2251 leaq foo@TLSLD(%rip), %rdi
2252 leaq foo@DTPOFF(%rax), %rdx
2253 movq foo@GOTTPOFF(%rip), %rax
2254 movq $foo@TPOFF, %rax'
2257 tls_as_opt=--fatal-warnings
2261 .section ".tdata","awT",@progbits
2264 addl r16 = @ltoff(@dtpmod(foo#)), gp
2265 addl r17 = @ltoff(@dtprel(foo#)), gp
2266 addl r18 = @ltoff(@tprel(foo#)), gp
2267 addl r19 = @dtprel(foo#), gp
2268 adds r21 = @dtprel(foo#), r13
2269 movl r23 = @dtprel(foo#)
2270 addl r20 = @tprel(foo#), gp
2271 adds r22 = @tprel(foo#), r13
2272 movl r24 = @tprel(foo#)'
2275 tls_as_opt=--fatal-warnings
2279 .section ".tdata","awT",@progbits
2287 addi 3,31,ld0@got@tlsgd
2289 addi 3,31,x1@got@tlsld
2292 addis 9,3,x2@dtprel@ha
2293 addi 9,9,x2@dtprel@l
2294 lwz 9,x3@got@tprel(31)
2297 addis 9,2,x2@tprel@ha
2298 addi 9,9,x2@tprel@l'
2301 tls_as_opt="-a32 --fatal-warnings"
2305 .section ".tdata","awT",@progbits
2313 addi 3,2,ld0@got@tlsgd
2319 addi 3,2,x1@got@tlsld
2325 addis 9,3,x2@dtprel@ha
2326 addi 9,9,x2@dtprel@l
2329 ld 9,x3@got@dtprel(2)
2335 tls_as_opt="-a64 --fatal-warnings"
2339 .section ".tdata","awT",@progbits
2348 l %r1,foo@GOTNTPOFF(%r12)
2349 l %r1,0(%r1):tls_load:foo
2350 bas %r14,0(%r1,%r13):tls_gdcall:foo
2351 bas %r14,0(%r1,%r13):tls_ldcall:foo'
2354 tls_as_opt="-m31 --fatal-warnings"
2358 .section ".tdata","awT",@progbits
2366 lg %r1,foo@GOTNTPOFF(%r12)
2367 larl %r1,foo@INDNTPOFF
2368 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
2369 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2372 tls_as_opt="-m64 -Aesame --fatal-warnings"
2374 sh-*-* | sh[34]-*-*)
2376 .section ".tdata","awT",@progbits
2386 tls_as_opt=--fatal-warnings
2390 sparc*-sun-solaris2.*)
2397 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2399 .section ".tdata",#alloc,#write,#tls
2402 sethi %tgd_hi22(foo), %o0
2403 add %o0, %tgd_lo10(foo), %o1
2404 add %l7, %o1, %o0, %tgd_add(foo)
2405 call __tls_get_addr, %tgd_call(foo)
2406 sethi %tldm_hi22(foo), %l1
2407 add %l1, %tldm_lo10(foo), %l2
2408 add %l7, %l2, %o0, %tldm_add(foo)
2409 call __tls_get_addr, %tldm_call(foo)
2410 sethi %tldo_hix22(foo), %l3
2411 xor %l3, %tldo_lox10(foo), %l4
2412 add %o0, %l4, %l5, %tldo_add(foo)
2413 sethi %tie_hi22(foo), %o3
2414 add %o3, %tie_lo10(foo), %o3
2415 ld [%l7 + %o3], %o2, %tie_ld(foo)
2416 add %g7, %o2, %o4, %tie_add(foo)
2417 sethi %tle_hix22(foo), %l1
2418 xor %l1, %tle_lox10(foo), %o5
2419 ld [%g7 + %o5], %o1'
2424 .section ".tdata","awT",@progbits
2427 sethi %tgd_hi22(foo), %o0
2428 add %o0, %tgd_lo10(foo), %o1
2429 add %l7, %o1, %o0, %tgd_add(foo)
2430 call __tls_get_addr, %tgd_call(foo)
2431 sethi %tldm_hi22(foo), %l1
2432 add %l1, %tldm_lo10(foo), %l2
2433 add %l7, %l2, %o0, %tldm_add(foo)
2434 call __tls_get_addr, %tldm_call(foo)
2435 sethi %tldo_hix22(foo), %l3
2436 xor %l3, %tldo_lox10(foo), %l4
2437 add %o0, %l4, %l5, %tldo_add(foo)
2438 sethi %tie_hi22(foo), %o3
2439 add %o3, %tie_lo10(foo), %o3
2440 ld [%l7 + %o3], %o2, %tie_ld(foo)
2441 add %g7, %o2, %o4, %tie_add(foo)
2442 sethi %tle_hix22(foo), %l1
2443 xor %l1, %tle_lox10(foo), %o5
2444 ld [%g7 + %o5], %o1'
2447 tls_as_opt="-32 --fatal-warnings"
2452 if test -z "$tls_first_major"; then
2453 : # If we don't have a check, assume no support.
2455 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2456 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2457 [AC_DEFINE(HAVE_AS_TLS, 1,
2458 [Define if your assembler supports thread-local storage.])])
2461 # Target-specific assembler checks.
2463 if test x"$demangler_in_ld" = xyes; then
2464 AC_MSG_CHECKING(linker --demangle support)
2465 gcc_cv_ld_demangle=no
2466 if test $in_tree_ld = yes; then
2467 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 \
2468 gcc_cv_ld_demangle=yes
2470 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
2471 # Check if the GNU linker supports --demangle option
2472 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
2473 gcc_cv_ld_demangle=yes
2476 if test x"$gcc_cv_ld_demangle" = xyes; then
2477 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
2478 [Define if your linker supports --demangle option.])
2480 AC_MSG_RESULT($gcc_cv_ld_demangle)
2484 # All TARGET_ABI_OSF targets.
2485 alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2486 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2487 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2490 extbl $3, $2, $3 !lituse_bytoff!1
2491 ldq $2, a($29) !literal!1
2492 ldq $4, b($29) !literal!2
2493 ldq_u $3, 0($2) !lituse_base!1
2494 ldq $27, f($29) !literal!5
2495 jsr $26, ($27), f !lituse_jsr!5
2496 ldah $29, 0($26) !gpdisp!3
2497 lda $0, c($29) !gprel
2498 ldah $1, d($29) !gprelhigh
2499 lda $1, d($1) !gprellow
2500 lda $29, 0($29) !gpdisp!3],,
2501 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2502 [Define if your assembler supports explicit relocations.])])
2506 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2507 gcc_cv_as_cris_no_mul_bug,[2,15,91],
2508 [-no-mul-bug-abort], [.text],,
2509 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2510 [Define if your assembler supports the -no-mul-bug-abort option.])])
2514 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2515 [.register %g2, #scratch],,
2516 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2517 [Define if your assembler supports .register.])])
2519 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2521 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2522 [Define if your assembler supports -relax option.])])
2524 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2525 gcc_cv_as_sparc_ua_pcrel,,
2533 .uaword %r_disp32(foo)],
2534 [if test x$gcc_cv_ld != x \
2535 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2536 gcc_cv_as_sparc_ua_pcrel=yes
2539 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2540 [Define if your assembler and linker support unaligned PC relative relocs.])
2542 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2543 gcc_cv_as_sparc_ua_pcrel_hidden,,
2548 .uaword %r_disp32(foo)
2549 .byte 0x32, 0x33, 0x34
2554 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2555 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2556 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2557 | grep ' 31000000 07323334' > /dev/null 2>&1; then
2558 if $gcc_cv_objdump -R conftest 2> /dev/null \
2559 | grep 'DISP32' > /dev/null 2>&1; then
2562 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2566 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2567 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2568 ]) # unaligned pcrel relocs
2570 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2571 gcc_cv_as_sparc_offsetable_lo10,,
2574 or %g1, %lo(ab) + 12, %g1
2575 or %g1, %lo(ab + 12), %g1],
2576 [if test x$gcc_cv_objdump != x \
2577 && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2578 | grep ' 82106000 82106000' > /dev/null 2>&1; then
2579 gcc_cv_as_offsetable_lo10=yes
2581 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2582 [Define if your assembler supports offsetable %lo().])])
2586 i[34567]86-*-* | x86_64-*-*)
2589 cygwin* | pe | mingw32*)
2590 # Used for DWARF 2 in PE
2591 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
2592 gcc_cv_as_ix86_pe_secrel32,
2598 [if test x$gcc_cv_ld != x \
2599 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
2600 gcc_cv_as_ix86_pe_secrel32=yes
2603 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
2604 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
2608 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2609 gcc_cv_as_ix86_filds_fists,
2610 [2,9,0],, [filds mem; fists mem],,
2611 [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2612 [Define if your assembler uses the new HImode fild and fist notation.])])
2614 gcc_GAS_CHECK_FEATURE([cmov syntax],
2615 gcc_cv_as_ix86_cmov_sun_syntax,,,
2616 [cmovl.l %edx, %eax],,
2617 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2618 [Define if your assembler supports the Sun syntax for cmov.])])
2620 # This one is used unconditionally by i386.[ch]; it is to be defined
2621 # to 1 if the feature is present, 0 otherwise.
2622 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2623 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2629 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2630 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2631 [Define true if the assembler supports '.long foo@GOTOFF'.])
2635 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2636 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2638 addl r15 = @ltoffx(x#), gp
2640 ld8.mov r16 = [[r15]], x#],,
2641 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2642 [Define if your assembler supports ltoffx and ldxmov relocations.])])
2648 *-*-aix*) conftest_s=' .csect .text[[PR]]
2650 *-*-darwin*) conftest_s=' .text
2652 *) conftest_s=' .text
2656 gcc_GAS_CHECK_FEATURE([mfcr field support],
2657 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2659 [AC_DEFINE(HAVE_AS_MFCRF, 1,
2660 [Define if your assembler supports mfcr field.])])
2664 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2665 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2666 [ lw $4,%gp_rel(foo)($4)],,
2667 [if test x$target_cpu_default = x
2668 then target_cpu_default=MASK_EXPLICIT_RELOCS
2669 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2674 # ??? Not all targets support dwarf2 debug_line, even within a version
2675 # of gas. Moreover, we need to emit a valid instruction to trigger any
2676 # info to the output file. So, as supported targets are added to gas 2.11,
2677 # add some instruction here to (also) show we expect this might work.
2678 # ??? Once 2.11 is released, probably need to add first known working
2679 # version to the per-target configury.
2681 i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2682 | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2683 | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2686 ia64*-*-* | s390*-*-*)
2693 if test x"$insn" != x; then
2695 .file 1 \"conftest.s\"
2698 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2699 gcc_cv_as_dwarf2_debug_line,
2700 [elf,2,11,0],, [$conftest_s],
2701 [# ??? This fails with non-gnu grep. Maybe use objdump?
2702 if grep debug_line conftest.o > /dev/null 2>&1; then
2703 gcc_cv_as_dwarf2_debug_line=yes
2706 # The .debug_line file table must be in the exact order that
2707 # we specified the files, since these indices are also used
2708 # by DW_AT_decl_file. Approximate this test by testing if
2709 # the assembler bitches if the same index is assigned twice.
2710 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2711 gcc_cv_as_dwarf2_file_buggy,,,
2715 if test $gcc_cv_as_dwarf2_debug_line = yes \
2716 && test $gcc_cv_as_dwarf2_file_buggy = no; then
2717 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2718 [Define if your assembler supports dwarf2 .file/.loc directives,
2719 and preserves file table indices exactly as given.])
2722 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2723 gcc_cv_as_gdwarf2_flag,
2724 [elf,2,11,0], [--gdwarf2], [$insn],,
2725 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2726 [Define if your assembler supports the --gdwarf2 option.])])
2728 gcc_GAS_CHECK_FEATURE([--gstabs option],
2729 gcc_cv_as_gstabs_flag,
2730 [elf,2,11,0], [--gstabs], [$insn],
2731 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2732 # and warns about it, but still exits successfully. So check for
2734 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2736 else gcc_cv_as_gstabs_flag=yes
2738 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2739 [Define if your assembler supports the --gstabs option.])])
2742 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2743 gcc_cv_ld_ro_rw_mix=unknown
2744 if test $in_tree_ld = yes ; then
2745 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 \
2746 && test $in_tree_ld_is_elf = yes; then
2747 gcc_cv_ld_ro_rw_mix=read-write
2749 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2750 echo '.section myfoosect, "a"' > conftest1.s
2751 echo '.section myfoosect, "aw"' > conftest2.s
2752 echo '.byte 1' >> conftest2.s
2753 echo '.section myfoosect, "a"' > conftest3.s
2754 echo '.byte 0' >> conftest3.s
2755 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2756 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2757 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2758 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2759 conftest2.o conftest3.o > /dev/null 2>&1; then
2760 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2761 | sed -e '/myfoosect/!d' -e N`
2762 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2763 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2764 gcc_cv_ld_ro_rw_mix=read-only
2766 gcc_cv_ld_ro_rw_mix=read-write
2771 rm -f conftest.* conftest[123].*
2774 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2775 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2776 [Define if your linker links a mix of read-only
2777 and read-write sections into a read-write section.])
2779 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2781 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2782 gcc_cv_ld_eh_frame_hdr=no
2783 if test $in_tree_ld = yes ; then
2784 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 \
2785 && test $in_tree_ld_is_elf = yes; then
2786 gcc_cv_ld_eh_frame_hdr=yes
2788 elif test x$gcc_cv_ld != x; then
2789 # Check if linker supports --eh-frame-hdr option
2790 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2791 gcc_cv_ld_eh_frame_hdr=yes
2794 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2795 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2796 [Define if your linker supports --eh-frame-hdr option.])
2798 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2800 AC_MSG_CHECKING(linker position independent executable support)
2802 if test $in_tree_ld = yes ; then
2803 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 \
2804 && test $in_tree_ld_is_elf = yes; then
2807 elif test x$gcc_cv_ld != x; then
2808 # Check if linker supports -pie option
2809 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2813 if test x"$gcc_cv_ld_pie" = xyes; then
2814 AC_DEFINE(HAVE_LD_PIE, 1,
2815 [Define if your linker supports -pie option.])
2817 AC_MSG_RESULT($gcc_cv_ld_pie)
2823 AC_CACHE_CHECK(linker --as-needed support,
2824 gcc_cv_ld_as_needed,
2825 [gcc_cv_ld_as_needed=no
2826 if test $in_tree_ld = yes ; then
2827 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 \
2828 && test $in_tree_ld_is_elf = yes; then
2829 gcc_cv_ld_as_needed=yes
2831 elif test x$gcc_cv_ld != x; then
2832 # Check if linker supports --as-needed and --no-as-needed options
2833 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
2834 gcc_cv_ld_as_needed=yes
2838 if test x"$gcc_cv_ld_as_needed" = xyes; then
2839 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
2840 [Define if your linker supports --as-needed and --no-as-needed options.])
2843 if test x$with_sysroot = x && test x$host = x$target \
2844 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2845 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2846 [Define to PREFIX/include if cpp should also search that directory.])
2849 # Find out what GC implementation we want, or may, use.
2851 [ --with-gc={page,zone} choose the garbage collection mechanism to use
2858 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2863 echo "Using $GGC for garbage collection."
2865 # Use the system's zlib library.
2867 zlibinc="-I\$(srcdir)/../zlib"
2868 AC_ARG_WITH(system-zlib,
2869 [ --with-system-zlib use installed libz],
2876 dnl Very limited version of automake's enable-maintainer-mode
2878 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2879 dnl maintainer-mode is disabled by default
2880 AC_ARG_ENABLE(maintainer-mode,
2881 [ --enable-maintainer-mode
2882 enable make rules and dependencies not useful
2883 (and sometimes confusing) to the casual installer],
2884 maintainer_mode=$enableval,
2887 AC_MSG_RESULT($maintainer_mode)
2889 if test "$maintainer_mode" = "yes"; then
2896 AC_MSG_CHECKING([whether to use libbanshee for points-to alias analysis])
2897 AC_ARG_WITH(libbanshee,
2898 [ --with-libbanshee enable libbanshee],
2899 libbanshee="$with_libbanshee",
2902 if test x"$libbanshee" = xyes; then
2903 BANSHEELIB="../libbanshee/points-to/libandersen.a ../libbanshee/engine/libbansheeengine.a ../libbanshee/libcompat/libbansheecompat.a "
2904 BANSHEEINC="-I\$(srcdir)/../libbanshee/libcompat -I\$(srcdir)/../libbanshee -I\$(srcdir)/../libbanshee/points-to"
2905 ANDER="tree-alias-ander.o"
2906 AC_DEFINE(HAVE_BANSHEE, 1, [Define if BANSHEE is available])
2912 AC_MSG_RESULT($with_libbanshee)
2915 AC_SUBST(BANSHEEINC)
2916 AC_SUBST(BANSHEELIB)
2922 # Make empty files to contain the specs and options for each language.
2923 # Then add #include lines to for a compiler that has specs and/or options.
2928 for subdir in . $subdirs
2930 if test -f $srcdir/$subdir/lang.opt; then
2931 lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2933 if test -f $srcdir/$subdir/lang-specs.h; then
2934 lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2936 if test -f $srcdir/$subdir/$subdir-tree.def; then
2937 lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2941 # These (without "all_") are set in each config-lang.in.
2942 # `language' must be a single word so is spelled singularly.
2947 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders libada-mk'
2948 # List of language makefile fragments.
2950 # List of language subdirectory makefiles. Deprecated.
2952 # Files for gengtype
2953 all_gtfiles="$target_gtfiles"
2954 # Files for gengtype with language
2955 all_gtfiles_files_langs=
2956 all_gtfiles_files_files=
2958 # Add the language fragments.
2959 # Languages are added via two mechanisms. Some information must be
2960 # recorded in makefile variables, these are defined in config-lang.in.
2961 # We accumulate them and plug them into the main Makefile.
2962 # The other mechanism is a set of hooks for each of the main targets
2963 # like `clean', `install', etc.
2965 language_hooks="Make-hooks"
2975 . ${srcdir}/$s/config-lang.in
2976 if test "x$language" = x
2978 echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2981 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2982 if test -f ${srcdir}/$s/Makefile.in
2983 then all_lang_makefiles="$s/Makefile"
2985 all_languages="$all_languages $language"
2986 if test "x$boot_language" = xyes
2988 all_boot_languages="$all_boot_languages $language"
2990 all_compilers="$all_compilers $compilers"
2991 all_stagestuff="$all_stagestuff $stagestuff"
2992 all_outputs="$all_outputs $outputs"
2993 all_gtfiles="$all_gtfiles $gtfiles"
2996 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2997 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3001 # Pick up gtfiles for c
3004 . ${srcdir}/c-config-lang.in
3005 all_gtfiles="$all_gtfiles $gtfiles"
3008 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3009 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3013 for language in $all_languages
3015 check_languages="$check_languages check-$language"
3018 # We link each language in with a set of hooks, reached indirectly via
3023 target_list="all.build all.cross start.encap rest.encap tags \
3024 install-normal install-common install-man \
3025 uninstall info man srcextra srcman srcinfo \
3026 mostlyclean clean distclean maintainer-clean \
3027 stage1 stage2 stage3 stage4 stageprofile stagefeedback"
3028 for t in $target_list
3031 for lang in $all_languages
3035 echo "lang.$t: $x" >> Make-hooks
3044 echo "dir ." > .gdbinit
3045 echo "dir ${srcdir}" >> .gdbinit
3046 if test x$gdb_needs_out_file_path = xyes
3048 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3050 if test "x$subdirs" != x; then
3053 echo "dir ${srcdir}/$s" >> .gdbinit
3056 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3058 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
3059 # absolute path for gcc_tooldir based on inserting the number of up-directory
3060 # movements required to get from $(exec_prefix) to $(prefix) into the basic
3061 # $(libsubdir)/@(unlibsubdir) based path.
3062 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
3063 # make and thus we'd get different behavior depending on where we built the
3065 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
3066 gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
3068 changequote(<<, >>)dnl
3069 # An explanation of the sed strings:
3070 # -e 's|^\$(prefix)||' matches and eliminates 'prefix' from 'exec_prefix'
3071 # -e 's|/$||' match a trailing forward slash and eliminates it
3072 # -e 's|^[^/]|/|' forces the string to start with a forward slash (*)
3073 # -e 's|/[^/]*|../|g' replaces each occurrence of /<directory> with ../
3075 # (*) Note this pattern overwrites the first character of the string
3076 # with a forward slash if one is not already present. This is not a
3077 # problem because the exact names of the sub-directories concerned is
3078 # unimportant, just the number of them matters.
3080 # The practical upshot of these patterns is like this:
3082 # prefix exec_prefix result
3083 # ------ ----------- ------
3085 # /foo/ /foo/bar ../
3086 # /foo /foo/bar/ ../
3087 # /foo/ /foo/bar/ ../
3088 # /foo /foo/bar/ugg ../../
3091 gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
3092 changequote([, ])dnl
3094 AC_SUBST(gcc_tooldir)
3097 # Find a directory in which to install a shared libgcc.
3099 AC_ARG_ENABLE(version-specific-runtime-libs,
3100 [ --enable-version-specific-runtime-libs
3101 specify that runtime libraries should be
3102 installed in a compiler-specific directory])
3104 AC_ARG_WITH(slibdir,
3105 [ --with-slibdir=DIR shared libraries in DIR [LIBDIR]],
3106 slibdir="$with_slibdir",
3107 if test "${enable_version_specific_runtime_libs+set}" = set; then
3108 slibdir='$(libsubdir)'
3109 elif test "$host" != "$target"; then
3110 slibdir='$(build_tooldir)/lib'
3116 objdir=`${PWDCMD-pwd}`
3119 # Substitute configuration variables
3122 AC_SUBST(all_boot_languages)
3123 AC_SUBST(all_compilers)
3124 AC_SUBST(all_gtfiles)
3125 AC_SUBST(all_gtfiles_files_langs)
3126 AC_SUBST(all_gtfiles_files_files)
3127 AC_SUBST(all_lang_makefrags)
3128 AC_SUBST(all_lang_makefiles)
3129 AC_SUBST(all_languages)
3130 AC_SUBST(all_stagestuff)
3131 AC_SUBST(build_exeext)
3132 AC_SUBST(build_install_headers_dir)
3133 AC_SUBST(build_xm_file_list)
3134 AC_SUBST(build_xm_include_list)
3135 AC_SUBST(build_xm_defines)
3136 AC_SUBST(check_languages)
3137 AC_SUBST(cc_set_by_configure)
3138 AC_SUBST(quoted_cc_set_by_configure)
3139 AC_SUBST(cpp_install_dir)
3140 AC_SUBST(xmake_file)
3141 AC_SUBST(tmake_file)
3142 AC_SUBST(extra_gcc_objs)
3143 AC_SUBST(extra_headers_list)
3144 AC_SUBST(extra_objs)
3145 AC_SUBST(extra_parts)
3146 AC_SUBST(extra_passes)
3147 AC_SUBST(extra_programs)
3148 AC_SUBST(float_h_file)
3149 AC_SUBST(gcc_config_arguments)
3150 AC_SUBST(gcc_gxx_include_dir)
3151 AC_SUBST(libstdcxx_incdir)
3152 AC_SUBST(gcc_version)
3153 AC_SUBST(gcc_version_full)
3154 AC_SUBST(gcc_version_trigger)
3155 AC_SUBST(host_exeext)
3156 AC_SUBST(host_xm_file_list)
3157 AC_SUBST(host_xm_include_list)
3158 AC_SUBST(host_xm_defines)
3159 AC_SUBST(out_host_hook_obj)
3161 AC_SUBST(lang_opt_files)
3162 AC_SUBST(lang_specs_files)
3163 AC_SUBST(lang_tree_files)
3164 AC_SUBST(local_prefix)
3166 AC_SUBST(objc_boehm_gc)
3168 AC_SUBST(out_object_file)
3169 AC_SUBST(stage_prefix_set_by_configure)
3170 AC_SUBST(quoted_stage_prefix_set_by_configure)
3171 AC_SUBST(symbolic_link)
3172 AC_SUBST(thread_file)
3173 AC_SUBST(tm_file_list)
3174 AC_SUBST(tm_include_list)
3175 AC_SUBST(tm_defines)
3176 AC_SUBST(tm_p_file_list)
3177 AC_SUBST(tm_p_include_list)
3178 AC_SUBST(xm_file_list)
3179 AC_SUBST(xm_include_list)
3180 AC_SUBST(xm_defines)
3181 AC_SUBST(target_noncanonical)
3182 AC_SUBST(c_target_objs)
3183 AC_SUBST(cxx_target_objs)
3184 AC_SUBST(target_cpu_default)
3186 AC_SUBST_FILE(language_hooks)
3188 # If it doesn't already exist, create document directory
3189 echo "checking for the document directory." 1>&2
3190 if test -d doc ; then
3197 if test x${build} = x${host} ; then
3198 if test x${host} = x${target} ; then
3199 echo "Links are now set up to build a native compiler for ${target}." 1>&2
3201 echo "Links are now set up to build a cross-compiler" 1>&2
3202 echo " from ${host} to ${target}." 1>&2
3205 if test x${host} = x${target} ; then
3206 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3207 echo " for ${target}." 1>&2
3209 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3210 echo " from ${host} to ${target}." 1>&2
3214 AC_ARG_VAR(GMPLIBS,[How to link GMP])
3215 AC_ARG_VAR(GMPINC,[How to find GMP include files])
3217 # Configure the subdirectories
3218 # AC_CONFIG_SUBDIRS($subdirs)
3220 # Create the Makefile
3221 # and configure language subdirectories
3222 AC_CONFIG_FILES($all_outputs)
3224 AC_CONFIG_COMMANDS([default],
3226 case ${CONFIG_HEADERS} in
3227 *auto-host.h:config.in*)
3230 # Make sure all the subdirs exist.
3233 test -d $d || mkdir $d
3235 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3236 # bootstrapping and the installation procedure can still use
3237 # CC="stage1/xgcc -Bstage1/". If the host doesn't support symlinks,
3238 # FLAGS_TO_PASS has been modified to solve the problem there.
3239 # This is virtually a duplicate of what happens in configure.lang; we do
3240 # an extra check to make sure this only happens if ln -s can be used.
3241 if test "$symbolic_link" = "ln -s"; then
3242 for d in ${subdirs} fixinc ; do
3243 STARTDIR=`${PWDCMD-pwd}`
3245 for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3248 $symbolic_link ../$t $t 2>/dev/null
3255 symbolic_link='$symbolic_link'