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_WARN([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 # ----------------------
215 # Find default assembler
216 # ----------------------
220 [ --with-gnu-as arrange to work with GNU as],
221 gas_flag="$with_gnu_as",
225 [ --with-as arrange to use the specified as (full pathname)],
226 DEFAULT_ASSEMBLER="$with_as")
227 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
228 if test ! -x "$DEFAULT_ASSEMBLER"; then
229 AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
230 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
233 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
234 [Define to enable the use of a default assembler.])
237 AC_MSG_CHECKING([whether a default assembler was specified])
238 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
239 if test x"$gas_flag" = x"no"; then
240 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
242 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
252 # If a non-executable a.out is present (e.g. created by GNU as above even if
253 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
254 # file, even when creating an executable, so an execution test fails.
255 # Remove possible default executable files to avoid this.
257 # FIXME: This really belongs into AC_PROG_CC and can be removed once
258 # Autoconf includes it.
259 rm -f a.out a.exe b.out
261 # Find the native compiler
264 # autoconf is lame and doesn't give us any substitution variable for this.
265 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
266 NO_MINUS_C_MINUS_O=yes
268 OUTPUT_OPTION='-o $@'
270 AC_SUBST(NO_MINUS_C_MINUS_O)
271 AC_SUBST(OUTPUT_OPTION)
273 # -------------------------
274 # Check C compiler features
275 # -------------------------
283 # sizeof(char) is 1 by definition.
284 AC_COMPILE_CHECK_SIZEOF(void *)
285 AC_COMPILE_CHECK_SIZEOF(short)
286 AC_COMPILE_CHECK_SIZEOF(int)
287 AC_COMPILE_CHECK_SIZEOF(long)
288 if test $ac_cv_c_long_long = yes; then
289 AC_COMPILE_CHECK_SIZEOF(long long)
291 if test $ac_cv_c___int64 = yes; then
292 AC_COMPILE_CHECK_SIZEOF(__int64)
295 # ---------------------
296 # Warnings and checking
297 # ---------------------
299 # Check $CC warning features (if it's GCC).
300 # We want to use -pedantic, but we don't want warnings about
303 # So, we only use -pedantic if we can disable those warnings.
306 [whether ${CC} accepts -Wno-long-long],
307 [ac_cv_prog_cc_w_no_long_long],
308 [save_CFLAGS="$CFLAGS"
309 CFLAGS="-Wno-long-long"
310 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
311 [ac_cv_prog_cc_w_no_long_long=yes],
312 [ac_cv_prog_cc_w_no_long_long=no])
313 CFLAGS="$save_CFLAGS"
317 [whether ${CC} accepts -Wno-variadic-macros],
318 [ac_cv_prog_cc_w_no_variadic_macros],
319 [save_CFLAGS="$CFLAGS"
320 CFLAGS="-Wno-variadic-macros"
321 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
322 [ac_cv_prog_cc_w_no_variadic_macros=yes],
323 [ac_cv_prog_cc_w_no_variadic_macros=no])
324 CFLAGS="$save_CFLAGS"
328 if test $ac_cv_prog_cc_w_no_long_long = yes \
329 && test $ac_cv_prog_cc_w_no_variadic_macros = yes ; then
330 strict1_warn="-pedantic -Wno-long-long -Wno-variadic-macros"
332 AC_SUBST(strict1_warn)
334 # If the native compiler is GCC, we can enable warnings even in stage1.
335 # That's useful for people building cross-compilers, or just running a
338 if test "x$GCC" = "xyes"; then
339 warn_cflags='$(GCC_WARN_CFLAGS)'
341 AC_SUBST(warn_cflags)
343 # Enable -Werror in bootstrap stage2 and later.
344 # Change the default to "no" on release branches.
345 AC_ARG_ENABLE(werror,
346 [ --enable-werror enable -Werror in bootstrap stage2 and later], [],
348 if test x$enable_werror = xyes ; then
353 # Enable expensive internal checks
354 AC_ARG_ENABLE(checking,
355 [ --enable-checking[=LIST]
356 enable expensive run-time checks. With LIST,
357 enable only specific categories of checks.
358 Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
359 default is misc,tree,gc,rtlflag],
365 ac_gc_always_collect=
367 case "${enableval}" in
368 yes) ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
369 ac_rtlflag_checking=1 ;;
371 *) IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
372 set fnord $enableval; shift
377 misc) ac_checking=1 ;;
378 tree) ac_tree_checking=1 ;;
379 rtlflag) ac_rtlflag_checking=1 ;;
380 rtl) ac_rtl_checking=1 ;;
381 gc) ac_gc_checking=1 ;;
382 gcac) ac_gc_always_collect=1 ;;
383 fold) ac_fold_checking=1 ;;
384 valgrind) ac_checking_valgrind=1 ;;
385 *) AC_MSG_ERROR(unknown check category $check) ;;
391 # Enable some checks by default for development versions of GCC
392 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
394 if test x$ac_checking != x ; then
395 AC_DEFINE(ENABLE_CHECKING, 1,
396 [Define if you want more run-time sanity checks. This one gets a grab
397 bag of miscellaneous but relatively cheap checks.])
398 nocommon_flag=-fno-common
400 AC_SUBST(nocommon_flag)
401 if test x$ac_tree_checking != x ; then
402 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
403 [Define if you want all operations on trees (the basic data
404 structure of the front ends) to be checked for dynamic type safety
405 at runtime. This is moderately expensive.])
407 if test x$ac_rtl_checking != x ; then
408 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
409 [Define if you want all operations on RTL (the basic data structure
410 of the optimizer and back end) to be checked for dynamic type safety
411 at runtime. This is quite expensive.])
413 if test x$ac_rtlflag_checking != x ; then
414 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
415 [Define if you want RTL flag accesses to be checked against the RTL
416 codes that are supported for each access macro. This is relatively
419 if test x$ac_gc_checking != x ; then
420 AC_DEFINE(ENABLE_GC_CHECKING, 1,
421 [Define if you want the garbage collector to do object poisoning and
422 other memory allocation checks. This is quite expensive.])
424 if test x$ac_gc_always_collect != x ; then
425 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
426 [Define if you want the garbage collector to operate in maximally
427 paranoid mode, validating the entire heap and collecting garbage at
428 every opportunity. This is extremely expensive.])
430 if test x$ac_fold_checking != x ; then
431 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
432 [Define if you want fold checked that it never destructs its argument.
433 This is quite expensive.])
435 valgrind_path_defines=
438 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
439 dnl # an if statement. This was the source of very frustrating bugs
440 dnl # in converting to autoconf 2.5x!
441 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
443 if test x$ac_checking_valgrind != x ; then
444 # It is certainly possible that there's valgrind but no valgrind.h.
445 # GCC relies on making annotations so we must have both.
446 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
448 [#include <valgrind/memcheck.h>
449 #ifndef VALGRIND_DISCARD
450 #error VALGRIND_DISCARD not defined
452 [gcc_cv_header_valgrind_memcheck_h=yes],
453 [gcc_cv_header_valgrind_memcheck_h=no])
454 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
455 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
457 [#include <memcheck.h>
458 #ifndef VALGRIND_DISCARD
459 #error VALGRIND_DISCARD not defined
461 [gcc_cv_header_memcheck_h=yes],
462 gcc_cv_header_memcheck_h=no)
463 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
464 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
465 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
466 if test "x$valgrind_path" = "x" \
467 || (test $have_valgrind_h = no \
468 && test $gcc_cv_header_memcheck_h = no \
469 && test $gcc_cv_header_valgrind_memcheck_h = no); then
470 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
472 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
473 valgrind_command="$valgrind_path -q"
474 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
475 [Define if you want to run subprograms and generated programs
476 through valgrind (a memory checker). This is extremely expensive.])
477 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
478 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
479 [Define if valgrind's valgrind/memcheck.h header is installed.])
481 if test $gcc_cv_header_memcheck_h = yes; then
482 AC_DEFINE(HAVE_MEMCHECK_H, 1,
483 [Define if valgrind's memcheck.h header is installed.])
486 AC_SUBST(valgrind_path_defines)
487 AC_SUBST(valgrind_command)
489 # Enable code coverage collection
490 AC_ARG_ENABLE(coverage,
491 [ --enable-coverage[=LEVEL]
492 enable compiler\'s code coverage collection.
493 Use to measure compiler performance and locate
494 unused parts of the compiler. With LEVEL, specify
495 optimization. Values are opt, noopt,
497 [case "${enableval}" in
499 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
502 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
505 # a.k.a. --disable-coverage
509 AC_MSG_ERROR(unknown coverage setting $enableval)
513 AC_SUBST(coverage_flags)
515 AC_ARG_ENABLE(gather-detailed-mem-stats,
516 [ --enable-gather-detailed-mem-stats enable detailed memory allocation stats gathering], [],
517 [enable_gather_detailed_mem_stats=no])
518 if test x$enable_gather_detailed_mem_stats = xyes ; then
519 AC_DEFINE(GATHER_STATISTICS, 1,
520 [Define to enable detailed memory allocation stats gathering.])
523 # -------------------------------
524 # Miscenalleous configure options
525 # -------------------------------
529 [ --with-stabs arrange to use stabs instead of host debug format],
533 # Determine whether or not multilibs are enabled.
534 AC_ARG_ENABLE(multilib,
535 [ --enable-multilib enable library support for multiple ABIs],
536 [], [enable_multilib=yes])
537 AC_SUBST(enable_multilib)
539 # Enable __cxa_atexit for C++.
540 AC_ARG_ENABLE(__cxa_atexit,
541 [ --enable-__cxa_atexit enable __cxa_atexit for C++],
545 # Pass with no value to take the default
546 # Pass with a value to specify a thread package
547 AC_ARG_ENABLE(threads,
548 [ --enable-threads enable thread usage for target GCC
549 --enable-threads=LIB use LIB thread package for target GCC],,
551 # Save in case it gets overwritten in config.gcc
552 enable_threads_flag=$enable_threads
554 AC_ARG_ENABLE(objc-gc,
555 [ --enable-objc-gc enable the use of Boehm's garbage collector with
556 the GNU Objective-C runtime],
557 if test x$enable_objc_gc = xno; then
565 [ --with-dwarf2 force the default debug format to be DWARF 2],
566 dwarf2="$with_dwarf2",
569 AC_ARG_ENABLE(shared,
570 [ --disable-shared don't provide a shared libgcc],
572 case $enable_shared in
576 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
577 for pkg in $enableval; do
578 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
585 ], [enable_shared=yes])
586 AC_SUBST(enable_shared)
589 [ --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
591 case ${with_sysroot} in
592 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
593 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
596 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
597 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
599 if test "x$exec_prefix" = xNONE; then
600 if test "x$prefix" = xNONE; then
601 test_prefix=/usr/local
606 test_prefix=$exec_prefix
608 case ${TARGET_SYSTEM_ROOT} in
609 "${test_prefix}"|"${test_prefix}/"*|\
610 '${exec_prefix}'|'${exec_prefix}/'*)
611 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
612 TARGET_SYSTEM_ROOT_DEFINE="$t"
617 TARGET_SYSTEM_ROOT_DEFINE=
618 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
620 AC_SUBST(TARGET_SYSTEM_ROOT)
621 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
622 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
624 # Build with intermodule optimisations
625 AC_ARG_ENABLE(intermodule,
626 [ --enable-intermodule build the compiler in one step],
627 [case ${enable_intermodule} in
628 yes) onestep="-onestep";;
634 # Sanity check enable_languages in case someone does not run the toplevel
635 # configure # script.
636 AC_ARG_ENABLE(languages,
637 [ --enable-languages=LIST specify which front-ends to build],
638 [case ,${enable_languages}, in
640 # go safe -- we cannot be much sure without the toplevel
642 # analysis of which target libs are present and usable
646 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
651 enable_languages=c,${enable_languages}
654 [enable_languages=c])
657 for lang in ${srcdir}/*/config-lang.in
660 # The odd quoting in the next line works around
661 # an apparent bug in bash 1.12 on linux.
663 ${srcdir}/[*]/config-lang.in) ;;
665 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
666 if test "x$lang_alias" = x
668 echo "$lang doesn't set \$language." 1>&2
671 case ",$enable_languages," in
673 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;;
681 # -------------------------
682 # Checks for other programs
683 # -------------------------
687 # Find some useful tools
689 # We need awk to run opts.sh (to create options.c and options.h).
690 # Bail out if it's missing.
692 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
700 # See if cmp has --ignore-initial.
701 gcc_AC_PROG_CMP_IGNORE_INITIAL
703 # See if we have the mktemp command.
704 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
706 # Do we have a single-tree copy of texinfo?
707 if test -f $srcdir/../texinfo/Makefile.in; then
708 MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
709 gcc_cv_prog_makeinfo_modern=yes
710 AC_MSG_RESULT([Using makeinfo from the unified source tree.])
712 # See if makeinfo has been installed and is modern enough
713 # that we can use it.
714 gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
715 [GNU texinfo.* \([0-9][0-9.]*\)],
719 if test $gcc_cv_prog_makeinfo_modern = no; then
721 *** Makeinfo is missing or too old.
722 *** Info documentation will not be built.])
725 BUILD_INFO=info AC_SUBST(BUILD_INFO)
728 # Is pod2man recent enough to regenerate manpages?
729 AC_MSG_CHECKING([for recent Pod::Man])
730 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
732 GENERATED_MANPAGES=generated-manpages AC_SUBST(GENERATED_MANPAGES)
739 dnl Don't use AC_PROG_LEX; we insist on flex.
740 dnl LEXLIB is not useful in gcc.
741 if test -f $srcdir/../flex/skel.c; then
742 FLEX='$(objdir)/../flex/flex'
744 AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
748 # The -L switch is so bison can find its skeleton file.
749 if test -f $srcdir/../bison/bison.simple; then
750 BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
752 AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
755 # --------------------
756 # Checks for C headers
757 # --------------------
759 AC_MSG_CHECKING(for GNU C library)
760 AC_CACHE_VAL(gcc_cv_glibc,
762 [#include <features.h>],[
763 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
764 #error Not a GNU C library system
768 AC_MSG_RESULT($gcc_cv_glibc)
769 if test $gcc_cv_glibc = yes; then
770 AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
773 # Need to reject headers which give warnings, so that the -Werror bootstrap
774 # works later. *sigh* This needs to come before all header checks.
779 gcc_AC_HEADER_STDBOOL
782 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
783 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
784 sys/resource.h sys/param.h sys/times.h sys/stat.h \
785 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
787 # Check for thread headers.
788 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
789 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
791 # These tests can't be done till we know if we have limits.h.
799 # Stage specific cflags for build.
805 stage1_cflags="-Wa,-J"
811 # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
812 # sources; use -no-cpp-precomp to get to GNU cpp.
813 # Apple's GCC has bugs in designated initializer handling, so disable
815 stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
818 AC_SUBST(stage1_cflags)
820 # These libraries may be used by collect2.
821 # We may need a special search path to get them linked.
822 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
824 for libs in '' -lld -lmld \
825 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
826 '-L/usr/lib/cmplrs/cc3.11 -lmld'
829 AC_TRY_LINK_FUNC(ldopen,
830 [gcc_cv_collect2_libs="$libs"; break])
833 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
834 case $gcc_cv_collect2_libs in
836 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
838 AC_SUBST(COLLECT2_LIBS)
840 # When building Ada code on Alpha, we need exc_resume which is usually in
841 # -lexc. So test for it.
844 AC_SEARCH_LIBS(exc_resume, exc)
847 AC_SUBST(GNAT_LIBEXC)
849 # Some systems put ldexp and frexp in libm instead of libc; assume
850 # they're both in the same place. jcf-dump needs them.
853 AC_SEARCH_LIBS(ldexp, m)
858 # Use <inttypes.h> only if it exists,
859 # doesn't clash with <sys/types.h>, and declares intmax_t.
860 AC_MSG_CHECKING(for inttypes.h)
861 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
863 [#include <sys/types.h>
864 #include <inttypes.h>],
866 [gcc_cv_header_inttypes_h=yes],
867 gcc_cv_header_inttypes_h=no)])
868 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
869 if test $gcc_cv_header_inttypes_h = yes; then
870 AC_DEFINE(HAVE_INTTYPES_H, 1,
871 [Define if you have a working <inttypes.h> header file.])
874 dnl Disabled until we have a complete test for buggy enum bitfields.
875 dnl gcc_AC_C_ENUM_BF_UNSIGNED
877 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
878 sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
879 fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
880 scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
883 if test x$ac_cv_func_mbstowcs = xyes; then
884 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
885 [ AC_TRY_RUN([#include <stdlib.h>
891 gcc_cv_func_mbstowcs_works=yes,
892 gcc_cv_func_mbstowcs_works=no,
893 gcc_cv_func_mbstowcs_works=yes)])
894 if test x$gcc_cv_func_mbstowcs_works = xyes; then
895 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
896 [Define this macro if mbstowcs does not crash when its
897 first argument is NULL.])
901 AC_CHECK_TYPE(ssize_t, int)
903 # Try to determine the array type of the second argument of getgroups
904 # for the target system (int or gid_t).
906 if test "${target}" = "${build}"; then
907 TARGET_GETGROUPS_T=$ac_cv_type_getgroups
910 # This condition may need some tweaking. It should include all
911 # targets where the array type of the second argument of getgroups
912 # is int and the type of gid_t is not equivalent to int.
913 *-*-sunos* | *-*-ultrix*)
914 TARGET_GETGROUPS_T=int
917 TARGET_GETGROUPS_T=gid_t
921 AC_SUBST(TARGET_GETGROUPS_T)
923 gcc_AC_FUNC_PRINTF_PTR
924 gcc_AC_FUNC_MMAP_BLACKLIST
928 # Under VMS, vfork works very differently than on Unix. The standard test
929 # won't work, and it isn't easily adaptable. It makes more sense to
931 ac_cv_func_vfork_works=yes
937 # Until we have in-tree GNU iconv:
939 AC_SUBST(LIBICONV_DEP)
943 # We will need to find libiberty.h and ansidecl.h
944 saved_CFLAGS="$CFLAGS"
945 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
946 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
947 strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
948 fprintf_unlocked strstr errno snprintf vasprintf \
949 malloc realloc calloc free basename getopt clock, , ,[
950 #include "ansidecl.h"
951 #include "system.h"])
953 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
954 #include "ansidecl.h"
956 #ifdef HAVE_SYS_RESOURCE_H
957 #include <sys/resource.h>
962 #include "ansidecl.h"
964 #ifdef HAVE_SYS_RESOURCE_H
965 #include <sys/resource.h>
967 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
968 [Define to \`long' if <sys/resource.h> doesn't define.])])
970 gcc_AC_CHECK_DECLS(ldgetname, , ,[
971 #include "ansidecl.h"
978 gcc_AC_CHECK_DECLS(times, , ,[
979 #include "ansidecl.h"
981 #ifdef HAVE_SYS_TIMES_H
982 #include <sys/times.h>
986 # More time-related stuff.
987 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
989 #include "ansidecl.h"
991 #ifdef HAVE_SYS_TIMES_H
992 #include <sys/times.h>
994 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
995 if test $ac_cv_struct_tms = yes; then
996 AC_DEFINE(HAVE_STRUCT_TMS, 1,
997 [Define if <sys/times.h> defines struct tms.])
1000 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1001 # revisit after autoconf 2.50.
1002 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1004 #include "ansidecl.h"
1006 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
1007 if test $gcc_cv_type_clock_t = yes; then
1008 AC_DEFINE(HAVE_CLOCK_T, 1,
1009 [Define if <time.h> defines clock_t.])
1012 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
1014 #include "ansidecl.h"
1017 [if ((uchar *)0) return 0;
1018 if (sizeof(uchar)) return 0;],
1019 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
1020 if test $ac_cv_type_uchar = yes; then
1021 AC_DEFINE(HAVE_UCHAR, 1,
1022 [Define if <sys/types.h> defines \`uchar'.])
1025 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1026 CFLAGS="$saved_CFLAGS"
1028 gcc_AC_INITFINI_ARRAY
1030 # mkdir takes a single argument on some systems.
1031 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1039 # With Setjmp/Longjmp based exception handling.
1040 AC_ARG_ENABLE(sjlj-exceptions,
1041 [ --enable-sjlj-exceptions
1042 arrange to use setjmp/longjmp exception handling],
1043 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1044 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1045 [Define 0/1 to force the choice for exception handling model.])])
1047 if test x$host = x$target; then
1048 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
1050 use_libunwind_default=no
1052 # Use libunwind based exception handling.
1053 AC_ARG_ENABLE(libunwind-exceptions,
1054 [ --enable-libunwind-exceptions force use libunwind for exceptions],
1055 use_libunwind_exceptions=$enableval,
1056 use_libunwind_exceptions=$use_libunwind_default)
1057 if test x"$use_libunwind_exceptions" = xyes; then
1058 AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
1059 [Define if gcc should use -lunwind.])
1062 # --------------------------------------------------------
1063 # Build, host, and target specific configuration fragments
1064 # --------------------------------------------------------
1066 # Collect build-machine-specific information.
1067 . ${srcdir}/config.build
1069 # Collect host-machine-specific information.
1070 . ${srcdir}/config.host
1074 # Collect target-machine-specific information.
1075 . ${srcdir}/config.gcc
1077 extra_objs="${host_extra_objs} ${extra_objs}"
1078 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1080 # Default the target-machine variables that were not explicitly set.
1081 if test x"$tm_file" = x
1082 then tm_file=$cpu_type/$cpu_type.h; fi
1084 if test x"$extra_headers" = x
1085 then extra_headers=; fi
1087 if test x$md_file = x
1088 then md_file=$cpu_type/$cpu_type.md; fi
1090 if test x$out_file = x
1091 then out_file=$cpu_type/$cpu_type.c; fi
1093 if test x"$tmake_file" = x
1094 then tmake_file=$cpu_type/t-$cpu_type
1097 if test x"$dwarf2" = xyes
1098 then tm_file="$tm_file tm-dwarf2.h"
1101 # Say what files are being used for the output code and MD file.
1102 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1103 echo "Using \`$srcdir/config/$md_file' as machine description file."
1105 # If any of the xm_file variables contain nonexistent files, warn
1106 # about them and drop them.
1109 for x in $build_xm_file; do
1110 if test -f $srcdir/config/$x
1112 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1118 for x in $host_xm_file; do
1119 if test -f $srcdir/config/$x
1121 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1127 for x in $xm_file; do
1128 if test -f $srcdir/config/$x
1130 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1136 for f in $tm_file; do
1139 if test $count = ax; then
1140 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1142 echo "Using the following target machine macro files:"
1143 for f in $tm_file; do
1144 echo " $srcdir/config/$f"
1148 if test x$need_64bit_hwint = xyes; then
1149 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1150 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1154 for f in $host_xm_file; do
1157 if test $count = a; then
1159 elif test $count = ax; then
1160 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1162 echo "Using the following host machine macro files:"
1163 for f in $host_xm_file; do
1164 echo " $srcdir/config/$f"
1167 echo "Using ${out_host_hook_obj} for host machine hooks."
1169 if test "$host_xm_file" != "$build_xm_file"; then
1171 for f in $build_xm_file; do
1174 if test $count = a; then
1176 elif test $count = ax; then
1177 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1179 echo "Using the following build machine macro files:"
1180 for f in $build_xm_file; do
1181 echo " $srcdir/config/$f"
1190 # Check if a valid thread package
1191 case ${enable_threads_flag} in
1194 target_thread_file='single'
1198 target_thread_file='single'
1200 aix | dce | gnat | irix | posix | rtems | \
1201 single | solaris | vxworks | win32 )
1202 target_thread_file=${enable_threads_flag}
1205 echo "${enable_threads_flag} is an unknown thread package" 1>&2
1210 if test x${thread_file} = x; then
1211 # No thread file set by target-specific clauses in config.gcc,
1212 # so use file chosen by default logic above
1213 thread_file=${target_thread_file}
1216 # Make gthr-default.h if we have a thread file.
1218 if test $thread_file != single; then
1219 rm -f gthr-default.h
1220 echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1221 gthread_flags=-DHAVE_GTHR_DEFAULT
1223 AC_SUBST(gthread_flags)
1229 if test x$enable___cxa_atexit = xyes || \
1230 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1231 AC_CHECK_FUNC(__cxa_atexit,
1232 [AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1233 [Define if you want to use __cxa_atexit, rather than atexit, to
1234 register C++ destructors for local statics and global objects.
1235 This is essential for fully standards-compliant handling of
1236 destructors, but requires __cxa_atexit in libc.])],
1237 echo "__cxa_atexit can't be enabled on this target")
1240 # Look for a file containing extra machine modes.
1241 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1242 extra_modes_file='$(srcdir)'/config/${extra_modes}
1243 AC_SUBST(extra_modes_file)
1244 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1245 [Define to the name of a file containing a list of extra machine modes
1246 for this architecture.])
1249 # auto-host.h is the file containing items generated by autoconf and is
1250 # the first file included by config.h.
1251 # If host=build, it is correct to have bconfig include auto-host.h
1252 # as well. If host!=build, we are in error and need to do more
1253 # work to find out the build config parameters.
1254 if test x$host = x$build
1256 build_auto=auto-host.h
1259 # We create a subdir, then run autoconf in the subdir.
1260 # To prevent recursion we set host and build for the new
1261 # invocation of configure to the build for this invocation
1268 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1269 *) realsrcdir=../${srcdir};;
1271 saved_CFLAGS="${CFLAGS}"
1272 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1273 ${realsrcdir}/configure \
1274 --enable-languages=${enable_languages-all} \
1275 --target=$target_alias --host=$build_alias --build=$build_alias
1276 CFLAGS="${saved_CFLAGS}"
1278 # We just finished tests for the build machine, so rename
1279 # the file auto-build.h in the gcc directory.
1280 mv auto-host.h ../auto-build.h
1283 build_auto=auto-build.h
1284 FORBUILD=../${build_subdir}
1288 tm_file="${tm_file} defaults.h"
1289 tm_p_file="${tm_p_file} tm-preds.h"
1290 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1291 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1292 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1293 # put this back in temporarily.
1294 xm_file="ansidecl.h ${xm_file}"
1300 # Get the version trigger filename from the toplevel
1301 if test "${with_gcc_version_trigger+set}" = set; then
1302 gcc_version_trigger=$with_gcc_version_trigger
1304 gcc_version_trigger=${srcdir}/version.c
1307 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1308 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1310 # Compile in configure arguments.
1311 if test -f configargs.h ; then
1312 # Being re-configured.
1313 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1314 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1316 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1319 # Double all backslashes and backslash all quotes to turn
1320 # gcc_config_arguments into a C string.
1321 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1322 $gcc_config_arguments
1324 gcc_config_arguments_str=`cat conftest.out`
1327 cat > configargs.h <<EOF
1328 /* Generated automatically. */
1329 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1330 static const char thread_model[] = "$thread_file";
1332 static const struct {
1333 const char *name, *value;
1334 } configure_default_options[] = $configure_default_options;
1338 # Internationalization
1340 VERSION="$gcc_version"
1344 ZW_GNU_GETTEXT_SISTER_DIR
1346 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1347 # -liconv on the link line twice.
1348 case "$LIBINTL" in *$LIBICONV*)
1352 # Windows32 Registry support for specifying GCC installation paths.
1353 AC_ARG_ENABLE(win32-registry,
1354 [ --disable-win32-registry
1355 disable lookup of installation paths in the
1356 Registry on Windows hosts
1357 --enable-win32-registry enable registry lookup (default)
1358 --enable-win32-registry=KEY
1359 use KEY instead of GCC version as the last portion
1360 of the registry key],,)
1362 win32 | pe | cygwin* | mingw32* | uwin*)
1363 AC_MSG_CHECKING(whether windows registry support is requested)
1364 if test "x$enable_win32_registry" != xno; then
1365 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1366 [Define to 1 if installation paths should be looked up in Windows32
1367 Registry. Ignored on non windows32 hosts.])
1369 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1374 # Check if user specified a different registry key.
1375 case "x${enable_win32_registry}" in
1378 gcc_cv_win32_registry_key="$VERSION"
1381 # no registry lookup.
1382 gcc_cv_win32_registry_key=''
1385 # user-specified key.
1386 gcc_cv_win32_registry_key="$enable_win32_registry"
1390 if test "x$enable_win32_registry" != xno; then
1391 AC_MSG_CHECKING(registry key on windows hosts)
1392 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1393 [Define to be the last portion of registry key on windows hosts.])
1394 AC_MSG_RESULT($gcc_cv_win32_registry_key)
1399 # Get an absolute path to the GCC top-level source directory
1400 holddir=`${PWDCMD-pwd}`
1402 topdir=`${PWDCMD-pwd}`
1405 # Conditionalize the makefile for this host machine.
1407 for f in ${host_xmake_file}
1409 if test -f ${srcdir}/config/$f
1411 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1415 # Conditionalize the makefile for this target machine.
1417 for f in ${tmake_file}
1419 if test -f ${srcdir}/config/$f
1421 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1424 tmake_file="${tmake_file_}"
1426 symbolic_link='ln -s'
1428 # If the host doesn't support symlinks, modify CC in
1429 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1430 # Otherwise, we can use "CC=$(CC)".
1432 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1434 cc_set_by_configure="\$(CC)"
1435 quoted_cc_set_by_configure="\$(CC)"
1436 stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1437 quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1440 if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1442 symbolic_link="cp -p"
1446 cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1447 quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1448 stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1449 quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1453 out_object_file=`basename $out_file .c`.o
1457 for f in $tm_file; do
1460 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1461 tm_include_list="${tm_include_list} $f"
1464 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1465 tm_include_list="${tm_include_list} config/$f"
1472 for f in $tm_p_file; do
1475 tm_p_file_list="${tm_p_file_list} $f"
1476 tm_p_include_list="${tm_p_include_list} $f"
1479 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1480 tm_p_include_list="${tm_p_include_list} config/$f"
1486 for f in $xm_file; do
1489 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1490 xm_include_list="${xm_include_list} $f"
1493 xm_file_list="${xm_file_list} $f"
1494 xm_include_list="${xm_include_list} $f"
1497 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1498 xm_include_list="${xm_include_list} config/$f"
1504 host_xm_include_list=
1505 for f in $host_xm_file; do
1508 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1509 host_xm_include_list="${host_xm_include_list} $f"
1512 host_xm_file_list="${host_xm_file_list} $f"
1513 host_xm_include_list="${host_xm_include_list} $f"
1516 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1517 host_xm_include_list="${host_xm_include_list} config/$f"
1523 for f in $build_xm_file; do
1526 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1527 build_xm_include_list="${build_xm_include_list} $f"
1529 auto-build.h | auto-host.h )
1530 build_xm_file_list="${build_xm_file_list} $f"
1531 build_xm_include_list="${build_xm_include_list} $f"
1534 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1535 build_xm_include_list="${build_xm_include_list} config/$f"
1540 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1541 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1542 CROSS= AC_SUBST(CROSS)
1543 ALL=all.internal AC_SUBST(ALL)
1544 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1545 if test x$host != x$target
1547 CROSS="-DCROSS_COMPILE"
1549 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1550 case "$host","$target" in
1551 # Darwin crosses can use the host system's libraries and headers,
1552 # because of the fat library support. Of course, it must be the
1553 # same version of Darwin on both sides. Allow the user to
1554 # just say --target=foo-darwin without a version number to mean
1555 # "the version on this system".
1556 *-*-darwin*,*-*-darwin*)
1557 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1558 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1559 if test $hostos = $targetos -o $targetos = darwin ; then
1561 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1566 i?86-*-*,x86_64-*-* \
1567 | powerpc*-*-*,powerpc64*-*-*)
1568 CROSS="$CROSS -DNATIVE_CROSS" ;;
1570 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1571 # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1572 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1575 # If this is a cross-compiler that does not
1576 # have its own set of headers then define
1579 # If this is using newlib, without having the headers available now,
1580 # then define inhibit_libc in LIBGCC2_CFLAGS.
1581 # This prevents libgcc2 from containing any code which requires libc
1584 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1585 test x$with_newlib = xyes ; } &&
1586 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1587 inhibit_libc=-Dinhibit_libc
1589 AC_SUBST(inhibit_libc)
1591 # When building gcc with a cross-compiler, we need to adjust things so
1592 # that the generator programs are still built with the native compiler.
1593 # Also, we cannot run fixincludes or fix-header.
1595 # These are the normal (build=host) settings:
1596 BUILD_PREFIX= AC_SUBST(BUILD_PREFIX)
1597 BUILD_PREFIX_1=ignore- AC_SUBST(BUILD_PREFIX_1)
1598 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1599 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1601 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1603 # Possibly disable fixproto, on a per-target basis.
1604 case ${use_fixproto} in
1609 STMP_FIXPROTO=stmp-fixproto
1612 AC_SUBST(STMP_FIXPROTO)
1614 # And these apply if build != host, or we are generating coverage data
1615 if test x$build != x$host || test "x$coverage_flags" != x
1618 BUILD_PREFIX_1=build-
1619 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1621 if test "x$TARGET_SYSTEM_ROOT" = x; then
1627 # Expand extra_headers to include complete path.
1628 # This substitutes for lots of t-* files.
1630 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1631 for file in ${extra_headers} ; do
1632 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1635 # Add a definition of USE_COLLECT2 if system wants one.
1636 case $use_collect2 in
1637 no) use_collect2= ;;
1640 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1641 xm_defines="${xm_defines} USE_COLLECT2"
1645 # ---------------------------
1646 # Assembler & linker features
1647 # ---------------------------
1649 # Identify the assembler which will work hand-in-glove with the newly
1650 # built GCC, so that we can examine its features. This is the assembler
1651 # which will be driven by the driver program.
1653 # If build != host, and we aren't building gas in-tree, we identify a
1654 # build->target assembler and hope that it will have the same features
1655 # as the host->target assembler we'll be using.
1656 AC_MSG_CHECKING(what assembler to use)
1659 gcc_cv_gas_major_version=
1660 gcc_cv_gas_minor_version=
1661 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1662 if test -x "$DEFAULT_ASSEMBLER"; then
1663 gcc_cv_as="$DEFAULT_ASSEMBLER"
1664 elif test -x "$AS"; then
1666 elif test -x as$host_exeext; then
1667 # Build using assembler in the current directory.
1668 gcc_cv_as=./as$host_exeext
1669 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1670 && test -f ../gas/Makefile; then
1671 # Single tree build which includes gas.
1673 _gcc_COMPUTE_GAS_VERSION
1674 rm -f as$host_exeext
1675 $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1676 in_tree_gas_is_elf=no
1677 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1678 || (grep 'obj_format = multi' ../gas/Makefile \
1679 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1681 in_tree_gas_is_elf=yes
1685 if test "x$gcc_cv_as" = x; then
1686 # Search the same directories that the installed compiler will
1687 # search. Else we may find the wrong assembler and lose. If we
1688 # do not find a suitable assembler binary, then try the user's
1691 # Also note we have to check MD_EXEC_PREFIX before checking the
1692 # user's path. Unfortunately, there is no good way to get at the
1693 # value of MD_EXEC_PREFIX here. So we do a brute force search
1694 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1695 # to be fixed as part of the make/configure rewrite too.
1697 if test "x$exec_prefix" = xNONE; then
1698 if test "x$prefix" = xNONE; then
1699 test_prefix=/usr/local
1704 test_prefix=$exec_prefix
1707 # If the loop below does not find an assembler, then use whatever
1708 # one we can find in the users's path.
1710 if test "x$program_prefix" != xNONE; then
1711 gcc_cv_as=${program_prefix}as$host_exeext
1713 gcc_cv_as=`echo as | sed "${program_transform_name}"`$host_exeext
1716 test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1717 $test_prefix/libexec/gcc/$target_noncanonical \
1718 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1719 /usr/lib/gcc/$target_noncanonical \
1720 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1721 $test_prefix/$target_noncanonical/bin"
1723 if test x$host = x$target; then
1724 test_dirs="$test_dirs \
1729 /bsd43/usr/lib/cmplrs/cc \
1730 /usr/cross64/usr/bin \
1731 /usr/lib/cmplrs/cc \
1732 /sysv/usr/lib/cmplrs/cc \
1733 /svr4/usr/lib/cmplrs/cc \
1737 for dir in $test_dirs; do
1738 if test -x $dir/as$host_exeext; then
1739 gcc_cv_as=$dir/as$host_exeext
1744 case $in_tree_gas in
1746 AC_MSG_RESULT("newly built gas")
1749 AC_MSG_RESULT($gcc_cv_as)
1753 # Identify the linker which will work hand-in-glove with the newly
1754 # built GCC, so that we can examine its features. This is the linker
1755 # which will be driven by the driver program.
1757 # If build != host, and we aren't building gas in-tree, we identify a
1758 # build->target linker and hope that it will have the same features
1759 # as the host->target linker we'll be using.
1760 AC_MSG_CHECKING(what linker to use)
1763 gcc_cv_gld_major_version=
1764 gcc_cv_gld_minor_version=
1765 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1766 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1767 if test -x "$DEFAULT_LINKER"; then
1768 gcc_cv_ld="$DEFAULT_LINKER"
1769 elif test -x "$LD_FOR_TARGET"; then
1770 gcc_cv_ld="$LD_FOR_TARGET"
1771 elif test -x "$LD" && test x$host = x$target; then
1773 elif test -x collect-ld$host_exeext; then
1774 # Build using linker in the current directory.
1775 gcc_cv_ld=./collect-ld$host_exeext
1776 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1777 && test -f ../ld/Makefile; then
1778 # Single tree build which includes ld.
1780 in_tree_ld_is_elf=no
1781 if (grep 'EMUL = .*elf' ../ld/Makefile \
1782 || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1783 in_tree_ld_is_elf=yes
1785 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
1788 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1790 if test x$gcc_cv_gld_version != x; then
1795 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1796 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1798 rm -f collect-ld$host_exeext
1799 $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1803 if test "x$gcc_cv_ld" = x; then
1804 # Search the same directories that the installed compiler will
1805 # search. Else we may find the wrong linker and lose. If we
1806 # do not find a suitable linker binary, then try the user's
1809 # Also note we have to check MD_EXEC_PREFIX before checking the
1810 # user's path. Unfortunately, there is no good way to get at the
1811 # value of MD_EXEC_PREFIX here. So we do a brute force search
1812 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1813 # to be fixed as part of the make/configure rewrite too.
1815 if test "x$exec_prefix" = xNONE; then
1816 if test "x$prefix" = xNONE; then
1817 test_prefix=/usr/local
1822 test_prefix=$exec_prefix
1825 # If the loop below does not find an linker, then use whatever
1826 # one we can find in the users's path.
1828 if test "x$program_prefix" != xNONE; then
1829 gcc_cv_ld=${program_prefix}ld$host_exeext
1831 gcc_cv_ld=`echo ld | sed "${program_transform_name}"`$host_exeext
1834 test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1835 $test_prefix/libexec/gcc/$target_noncanonical \
1836 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1837 /usr/lib/gcc/$target_noncanonical \
1838 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1839 $test_prefix/$target_noncanonical/bin"
1841 if test x$host = x$target; then
1842 test_dirs="$test_dirs \
1847 /bsd43/usr/lib/cmplrs/cc \
1848 /usr/cross64/usr/bin \
1849 /usr/lib/cmplrs/cc \
1850 /sysv/usr/lib/cmplrs/cc \
1851 /svr4/usr/lib/cmplrs/cc \
1855 for dir in $test_dirs; do
1856 if test -x $dir/ld$host_exeext; then
1857 gcc_cv_ld=$dir/ld$host_exeext
1864 AC_MSG_RESULT("newly built ld")
1867 AC_MSG_RESULT($gcc_cv_ld)
1871 # Figure out what nm we will be using.
1872 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1873 AC_MSG_CHECKING(what nm to use)
1875 if test -x nm$host_exeext; then
1876 gcc_cv_nm=./nm$host_exeext
1877 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1878 && test -f ../binutils/Makefile; then
1879 # Single tree build which includes binutils.
1881 gcc_cv_nm=./nm$host_exeext
1882 rm -f nm$host_exeext
1883 $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1884 elif test "x$program_prefix" != xNONE; then
1885 gcc_cv_nm=${program_prefix}nm$host_exeext
1887 gcc_cv_nm=`echo nm | sed "${program_transform_name}"`$host_exeext
1890 yes) AC_MSG_RESULT("newly built nm") ;;
1891 no) AC_MSG_RESULT($gcc_cv_nm) ;;
1894 # Figure out what objdump we will be using.
1895 AC_MSG_CHECKING(what objdump to use)
1897 if test -x objdump$host_exeext; then
1898 gcc_cv_objdump=./objdump$host_exeext
1899 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1900 && test -f ../binutils/Makefile; then
1901 # Single tree build which includes binutils.
1903 gcc_cv_objdump=./objdump$host_exeext
1904 rm -f objdump$host_exeext
1905 $symbolic_link ../binutils/objdump$host_exeext \
1906 objdump$host_exeext 2>/dev/null
1907 elif test "x$program_prefix" != xNONE; then
1908 gcc_cv_objdump=${program_prefix}objdump$host_exeext
1910 gcc_cv_objdump=`echo objdump | \
1911 sed "${program_transform_name}"`$host_exeext
1913 case $in_tree_objdump in
1914 yes) AC_MSG_RESULT("newly built objdump") ;;
1915 no) AC_MSG_RESULT($gcc_cv_objdump) ;;
1918 # Figure out what assembler alignment features are present.
1919 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1923 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1924 [Define if your assembler supports .balign and .p2align.])])
1926 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
1929 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
1930 [Define if your assembler supports specifying the maximum number
1931 of bytes to skip when using the GAS .p2align command.])])
1933 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
1935 [conftest_label1: .word 0
1937 conftest_label2: .word 0
1939 [if test x$gcc_cv_nm != x; then
1940 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1941 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1942 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
1944 else gcc_cv_as_subsection_m1=yes
1946 rm -f conftest.nm1 conftest.nm2
1948 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1949 [Define if your assembler supports .subsection and .subsection -1 starts
1950 emitting at the beginning of your section.])])
1952 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
1955 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
1957 # .hidden needs to be supported in both the assembler and the linker,
1958 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1959 # This is irritatingly difficult to feature test for; we have to check the
1960 # date string after the version number. If we've got an in-tree
1961 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
1963 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
1964 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
1969 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
1970 [if test $in_tree_ld = yes ; then
1972 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 \
1973 && test $in_tree_ld_is_elf = yes; then
1974 gcc_cv_ld_hidden=yes
1977 gcc_cv_ld_hidden=yes
1978 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
1979 if echo "$ld_ver" | grep GNU > /dev/null; then
1981 ld_vers=`echo $ld_ver | sed -n \
1982 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1983 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1984 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1985 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
1986 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
1987 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p'`
1988 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'`
1989 if test 0"$ld_date" -lt 20020404; then
1990 if test -n "$ld_date"; then
1991 # If there was date string, but was earlier than 2002-04-04, fail
1993 elif test -z "$ld_vers"; then
1994 # If there was no date string nor ld version number, something is wrong
1997 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1998 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1999 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2000 test -z "$ld_vers_patch" && ld_vers_patch=0
2001 if test "$ld_vers_major" -lt 2; then
2003 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2004 gcc_cv_ld_hidden="no"
2005 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2013 hppa64*-*-hpux* | ia64*-*-hpux*)
2014 gcc_cv_ld_hidden=yes
2022 libgcc_visibility=no
2023 AC_SUBST(libgcc_visibility)
2024 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2025 libgcc_visibility=yes
2026 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2027 [Define if your assembler and linker support .hidden.])
2030 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2031 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2039 [# GAS versions before 2.11 do not support uleb128,
2040 # despite appearing to.
2041 # ??? There exists an elf-specific test that will crash
2042 # the assembler. Perhaps it's better to figure out whether
2043 # arbitrary sections are supported and try the test.
2044 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2045 if echo "$as_ver" | grep GNU > /dev/null; then
2047 as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
2048 as_major=`echo $as_ver | sed 's/\..*//'`
2049 as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
2051 if test $as_major -eq 2 && test $as_minor -lt 11
2053 else gcc_cv_as_leb128=yes
2056 [AC_DEFINE(HAVE_AS_LEB128, 1,
2057 [Define if your assembler supports .sleb128 and .uleb128.])])
2059 # GAS versions up to and including 2.11.0 may mis-optimize
2061 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2069 .section .eh_frame,"aw",@progbits
2071 .4byte .LECIE1-.LSCIE1
2085 .4byte .LEFDE1-.LASFDE1
2087 .4byte .LASFDE1-__FRAME_BEGIN__
2095 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2096 cat > conftest.lit <<EOF
2097 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2098 0010 01000000 12000000 18000000 00000000 ................
2099 0020 08000000 04080000 0044 .........D @&t@
2101 cat > conftest.big <<EOF
2102 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2103 0010 00000001 00000012 00000018 00000000 ................
2104 0020 00000008 04000000 0844 .........D @&t@
2106 # If the assembler didn't choke, and we can objdump,
2107 # and we got the correct data, then succeed.
2108 if test x$gcc_cv_objdump != x \
2109 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2110 | tail -3 > conftest.got \
2111 && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2112 || cmp conftest.big conftest.got > /dev/null 2>&1; }
2114 gcc_cv_as_eh_frame=yes
2115 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2116 gcc_cv_as_eh_frame=buggy
2118 # Uh oh, what do we do now?
2119 gcc_cv_as_eh_frame=no
2122 if test $gcc_cv_as_eh_frame = buggy; then
2123 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2124 [Define if your assembler mis-optimizes .eh_frame data.])
2127 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2128 [elf,2,12,0], [--fatal-warnings],
2129 [.section .rodata.str, "aMS", @progbits, 1])
2130 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2131 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2132 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2134 # Thread-local storage - the check is heavily parametrized.
2143 .section ".tdata","awT",@progbits
2146 ldq $27,__tls_get_addr($29) !literal!1
2147 lda $16,foo($29) !tlsgd!1
2148 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2149 ldq $27,__tls_get_addr($29) !literal!2
2150 lda $16,foo($29) !tlsldm!2
2151 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2152 ldq $1,foo($29) !gotdtprel
2153 ldah $2,foo($29) !dtprelhi
2154 lda $3,foo($2) !dtprello
2155 lda $4,foo($29) !dtprel
2156 ldq $1,foo($29) !gottprel
2157 ldah $2,foo($29) !tprelhi
2158 lda $3,foo($2) !tprello
2159 lda $4,foo($29) !tprel'
2162 tls_as_opt=--fatal-warnings
2166 .section ".tdata","awT",@progbits
2170 leal foo@TLSGD(,%ebx,1), %eax
2171 leal foo@TLSLDM(%ebx), %eax
2172 leal foo@DTPOFF(%eax), %edx
2173 movl foo@GOTTPOFF(%ebx), %eax
2174 subl foo@GOTTPOFF(%ebx), %eax
2175 addl foo@GOTNTPOFF(%ebx), %eax
2176 movl foo@INDNTPOFF, %eax
2177 movl $foo@TPOFF, %eax
2178 subl $foo@TPOFF, %eax
2179 leal foo@NTPOFF(%ecx), %eax'
2182 tls_as_opt=--fatal-warnings
2186 .section ".tdata","awT",@progbits
2190 leaq foo@TLSGD(%rip), %rdi
2191 leaq foo@TLSLD(%rip), %rdi
2192 leaq foo@DTPOFF(%rax), %rdx
2193 movq foo@GOTTPOFF(%rip), %rax
2194 movq $foo@TPOFF, %rax'
2197 tls_as_opt=--fatal-warnings
2201 .section ".tdata","awT",@progbits
2204 addl r16 = @ltoff(@dtpmod(foo#)), gp
2205 addl r17 = @ltoff(@dtprel(foo#)), gp
2206 addl r18 = @ltoff(@tprel(foo#)), gp
2207 addl r19 = @dtprel(foo#), gp
2208 adds r21 = @dtprel(foo#), r13
2209 movl r23 = @dtprel(foo#)
2210 addl r20 = @tprel(foo#), gp
2211 adds r22 = @tprel(foo#), r13
2212 movl r24 = @tprel(foo#)'
2215 tls_as_opt=--fatal-warnings
2219 .section ".tdata","awT",@progbits
2227 addi 3,31,ld0@got@tlsgd
2229 addi 3,31,x1@got@tlsld
2232 addis 9,3,x2@dtprel@ha
2233 addi 9,9,x2@dtprel@l
2234 lwz 9,x3@got@tprel(31)
2237 addis 9,2,x2@tprel@ha
2238 addi 9,9,x2@tprel@l'
2241 tls_as_opt="-a32 --fatal-warnings"
2245 .section ".tdata","awT",@progbits
2253 addi 3,2,ld0@got@tlsgd
2259 addi 3,2,x1@got@tlsld
2265 addis 9,3,x2@dtprel@ha
2266 addi 9,9,x2@dtprel@l
2269 ld 9,x3@got@dtprel(2)
2275 tls_as_opt="-a64 --fatal-warnings"
2279 .section ".tdata","awT",@progbits
2288 l %r1,foo@GOTNTPOFF(%r12)
2289 l %r1,0(%r1):tls_load:foo
2290 bas %r14,0(%r1,%r13):tls_gdcall:foo
2291 bas %r14,0(%r1,%r13):tls_ldcall:foo'
2294 tls_as_opt="-m31 --fatal-warnings"
2298 .section ".tdata","awT",@progbits
2306 lg %r1,foo@GOTNTPOFF(%r12)
2307 larl %r1,foo@INDNTPOFF
2308 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
2309 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2312 tls_as_opt="-m64 -Aesame --fatal-warnings"
2314 sh-*-* | sh[34]-*-*)
2316 .section ".tdata","awT",@progbits
2326 tls_as_opt=--fatal-warnings
2330 sparc*-sun-solaris2.*)
2337 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2339 .section ".tdata",#alloc,#write,#tls
2342 sethi %tgd_hi22(foo), %o0
2343 add %o0, %tgd_lo10(foo), %o1
2344 add %l7, %o1, %o0, %tgd_add(foo)
2345 call __tls_get_addr, %tgd_call(foo)
2346 sethi %tldm_hi22(foo), %l1
2347 add %l1, %tldm_lo10(foo), %l2
2348 add %l7, %l2, %o0, %tldm_add(foo)
2349 call __tls_get_addr, %tldm_call(foo)
2350 sethi %tldo_hix22(foo), %l3
2351 xor %l3, %tldo_lox10(foo), %l4
2352 add %o0, %l4, %l5, %tldo_add(foo)
2353 sethi %tie_hi22(foo), %o3
2354 add %o3, %tie_lo10(foo), %o3
2355 ld [%l7 + %o3], %o2, %tie_ld(foo)
2356 add %g7, %o2, %o4, %tie_add(foo)
2357 sethi %tle_hix22(foo), %l1
2358 xor %l1, %tle_lox10(foo), %o5
2359 ld [%g7 + %o5], %o1'
2364 .section ".tdata","awT",@progbits
2367 sethi %tgd_hi22(foo), %o0
2368 add %o0, %tgd_lo10(foo), %o1
2369 add %l7, %o1, %o0, %tgd_add(foo)
2370 call __tls_get_addr, %tgd_call(foo)
2371 sethi %tldm_hi22(foo), %l1
2372 add %l1, %tldm_lo10(foo), %l2
2373 add %l7, %l2, %o0, %tldm_add(foo)
2374 call __tls_get_addr, %tldm_call(foo)
2375 sethi %tldo_hix22(foo), %l3
2376 xor %l3, %tldo_lox10(foo), %l4
2377 add %o0, %l4, %l5, %tldo_add(foo)
2378 sethi %tie_hi22(foo), %o3
2379 add %o3, %tie_lo10(foo), %o3
2380 ld [%l7 + %o3], %o2, %tie_ld(foo)
2381 add %g7, %o2, %o4, %tie_add(foo)
2382 sethi %tle_hix22(foo), %l1
2383 xor %l1, %tle_lox10(foo), %o5
2384 ld [%g7 + %o5], %o1'
2387 tls_as_opt="-32 --fatal-warnings"
2392 if test -z "$tls_first_major"; then
2393 : # If we don't have a check, assume no support.
2395 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2396 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2397 [AC_DEFINE(HAVE_AS_TLS, 1,
2398 [Define if your assembler supports thread-local storage.])])
2401 # Target-specific assembler checks.
2404 # All TARGET_ABI_OSF targets.
2405 alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2406 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2407 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2410 extbl $3, $2, $3 !lituse_bytoff!1
2411 ldq $2, a($29) !literal!1
2412 ldq $4, b($29) !literal!2
2413 ldq_u $3, 0($2) !lituse_base!1
2414 ldq $27, f($29) !literal!5
2415 jsr $26, ($27), f !lituse_jsr!5
2416 ldah $29, 0($26) !gpdisp!3
2417 lda $0, c($29) !gprel
2418 ldah $1, d($29) !gprelhigh
2419 lda $1, d($1) !gprellow
2420 lda $29, 0($29) !gpdisp!3],,
2421 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2422 [Define if your assembler supports explicit relocations.])])
2426 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2427 gcc_cv_as_cris_no_mul_bug,[2,15,91],
2428 [-no-mul-bug-abort], [.text],,
2429 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2430 [Define if your assembler supports the -no-mul-bug-abort option.])])
2434 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2435 [.register %g2, #scratch],,
2436 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2437 [Define if your assembler supports .register.])])
2439 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2441 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2442 [Define if your assembler supports -relax option.])])
2444 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2445 gcc_cv_as_sparc_ua_pcrel,,
2453 .uaword %r_disp32(foo)],
2454 [if test x$gcc_cv_ld != x \
2455 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2456 gcc_cv_as_sparc_ua_pcrel=yes
2459 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2460 [Define if your assembler and linker support unaligned PC relative relocs.])
2462 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2463 gcc_cv_as_sparc_ua_pcrel_hidden,,
2468 .uaword %r_disp32(foo)
2469 .byte 0x32, 0x33, 0x34
2474 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2475 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2476 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2477 | grep ' 31000000 07323334' > /dev/null 2>&1; then
2478 if $gcc_cv_objdump -R conftest 2> /dev/null \
2479 | grep 'DISP32' > /dev/null 2>&1; then
2482 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2486 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2487 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2488 ]) # unaligned pcrel relocs
2490 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2491 gcc_cv_as_sparc_offsetable_lo10,,
2494 or %g1, %lo(ab) + 12, %g1
2495 or %g1, %lo(ab + 12), %g1],
2496 [if test x$gcc_cv_objdump != x \
2497 && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2498 | grep ' 82106000 82106000' > /dev/null 2>&1; then
2499 gcc_cv_as_offsetable_lo10=yes
2501 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2502 [Define if your assembler supports offsetable %lo().])])
2506 i[34567]86-*-* | x86_64-*-*)
2508 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2509 gcc_cv_as_ix86_filds_fists,
2510 [2,9,0],, [filds mem; fists mem],,
2511 [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2512 [Define if your assembler uses the new HImode fild and fist notation.])])
2514 gcc_GAS_CHECK_FEATURE([cmov syntax],
2515 gcc_cv_as_ix86_cmov_sun_syntax,,,
2516 [cmovl.l %edx, %eax],,
2517 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2518 [Define if your assembler supports the Sun syntax for cmov.])])
2520 # This one is used unconditionally by i386.[ch]; it is to be defined
2521 # to 1 if the feature is present, 0 otherwise.
2522 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2523 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2529 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2530 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2531 [Define true if the assembler supports '.long foo@GOTOFF'.])
2535 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2536 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2538 addl r15 = @ltoffx(x#), gp
2540 ld8.mov r16 = [[r15]], x#],,
2541 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2542 [Define if your assembler supports ltoffx and ldxmov relocations.])])
2548 *-*-aix*) conftest_s=' .csect .text[[PR]]
2550 *-*-darwin*) conftest_s=' .text
2552 *) conftest_s=' .text
2556 gcc_GAS_CHECK_FEATURE([mfcr field support],
2557 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2559 [AC_DEFINE(HAVE_AS_MFCRF, 1,
2560 [Define if your assembler supports mfcr field.])])
2564 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2565 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2566 [ lw $4,%gp_rel(foo)($4)],,
2567 [if test x$target_cpu_default = x
2568 then target_cpu_default=MASK_EXPLICIT_RELOCS
2569 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2574 # ??? Not all targets support dwarf2 debug_line, even within a version
2575 # of gas. Moreover, we need to emit a valid instruction to trigger any
2576 # info to the output file. So, as supported targets are added to gas 2.11,
2577 # add some instruction here to (also) show we expect this might work.
2578 # ??? Once 2.11 is released, probably need to add first known working
2579 # version to the per-target configury.
2581 i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2582 | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2583 | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2586 ia64*-*-* | s390*-*-*)
2593 if test x"$insn" != x; then
2595 .file 1 \"conftest.s\"
2598 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2599 gcc_cv_as_dwarf2_debug_line,
2600 [elf,2,11,0],, [$conftest_s],
2601 [# ??? This fails with non-gnu grep. Maybe use objdump?
2602 if grep debug_line conftest.o > /dev/null 2>&1; then
2603 gcc_cv_as_dwarf2_debug_line=yes
2606 # The .debug_line file table must be in the exact order that
2607 # we specified the files, since these indices are also used
2608 # by DW_AT_decl_file. Approximate this test by testing if
2609 # the assembler bitches if the same index is assigned twice.
2610 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2611 gcc_cv_as_dwarf2_file_buggy,,,
2615 if test $gcc_cv_as_dwarf2_debug_line = yes \
2616 && test $gcc_cv_as_dwarf2_file_buggy = no; then
2617 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2618 [Define if your assembler supports dwarf2 .file/.loc directives,
2619 and preserves file table indices exactly as given.])
2622 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2623 gcc_cv_as_gdwarf2_flag,
2624 [elf,2,11,0], [--gdwarf2], [$insn],,
2625 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2626 [Define if your assembler supports the --gdwarf2 option.])])
2628 gcc_GAS_CHECK_FEATURE([--gstabs option],
2629 gcc_cv_as_gstabs_flag,
2630 [elf,2,11,0], [--gstabs], [$insn],
2631 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2632 # and warns about it, but still exits successfully. So check for
2634 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2636 else gcc_cv_as_gstabs_flag=yes
2638 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2639 [Define if your assembler supports the --gstabs option.])])
2642 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2643 gcc_cv_ld_ro_rw_mix=unknown
2644 if test $in_tree_ld = yes ; then
2645 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 \
2646 && test $in_tree_ld_is_elf = yes; then
2647 gcc_cv_ld_ro_rw_mix=read-write
2649 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2650 echo '.section myfoosect, "a"' > conftest1.s
2651 echo '.section myfoosect, "aw"' > conftest2.s
2652 echo '.byte 1' >> conftest2.s
2653 echo '.section myfoosect, "a"' > conftest3.s
2654 echo '.byte 0' >> conftest3.s
2655 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2656 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2657 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2658 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2659 conftest2.o conftest3.o > /dev/null 2>&1; then
2660 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2661 | sed -e '/myfoosect/!d' -e N`
2662 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2663 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2664 gcc_cv_ld_ro_rw_mix=read-only
2666 gcc_cv_ld_ro_rw_mix=read-write
2671 rm -f conftest.* conftest[123].*
2674 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2675 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2676 [Define if your linker links a mix of read-only
2677 and read-write sections into a read-write section.])
2679 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2681 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2682 gcc_cv_ld_eh_frame_hdr=no
2683 if test $in_tree_ld = yes ; then
2684 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 \
2685 && test $in_tree_ld_is_elf = yes; then
2686 gcc_cv_ld_eh_frame_hdr=yes
2688 elif test x$gcc_cv_ld != x; then
2689 # Check if linker supports --eh-frame-hdr option
2690 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2691 gcc_cv_ld_eh_frame_hdr=yes
2694 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2695 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2696 [Define if your linker supports --eh-frame-hdr option.])
2698 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2700 AC_MSG_CHECKING(linker position independent executable support)
2702 if test $in_tree_ld = yes ; then
2703 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 \
2704 && test $in_tree_ld_is_elf = yes; then
2707 elif test x$gcc_cv_ld != x; then
2708 # Check if linker supports -pie option
2709 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2713 if test x"$gcc_cv_ld_pie" = xyes; then
2714 AC_DEFINE(HAVE_LD_PIE, 1,
2715 [Define if your linker supports -pie option.])
2717 AC_MSG_RESULT($gcc_cv_ld_pie)
2723 if test x$with_sysroot = x && test x$host = x$target \
2724 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2725 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2726 [Define to PREFIX/include if cpp should also search that directory.])
2729 # Find out what GC implementation we want, or may, use.
2731 [ --with-gc={page,zone} choose the garbage collection mechanism to use
2738 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2743 echo "Using $GGC for garbage collection."
2745 # Use the system's zlib library.
2747 zlibinc="-I\$(srcdir)/../zlib"
2748 AC_ARG_WITH(system-zlib,
2749 [ --with-system-zlib use installed libz],
2756 dnl Very limited version of automake's enable-maintainer-mode
2758 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2759 dnl maintainer-mode is disabled by default
2760 AC_ARG_ENABLE(maintainer-mode,
2761 [ --enable-maintainer-mode
2762 enable make rules and dependencies not useful
2763 (and sometimes confusing) to the casual installer],
2764 maintainer_mode=$enableval,
2767 AC_MSG_RESULT($maintainer_mode)
2769 if test "$maintainer_mode" = "yes"; then
2780 # Make empty files to contain the specs and options for each language.
2781 # Then add #include lines to for a compiler that has specs and/or options.
2786 for subdir in . $subdirs
2788 if test -f $srcdir/$subdir/lang.opt; then
2789 lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2791 if test -f $srcdir/$subdir/lang-specs.h; then
2792 lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2794 if test -f $srcdir/$subdir/$subdir-tree.def; then
2795 lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2799 # These (without "all_") are set in each config-lang.in.
2800 # `language' must be a single word so is spelled singularly.
2805 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2806 # List of language makefile fragments.
2808 # List of language subdirectory makefiles. Deprecated.
2810 # Files for gengtype
2811 all_gtfiles="$target_gtfiles"
2812 # Files for gengtype with language
2813 all_gtfiles_files_langs=
2814 all_gtfiles_files_files=
2816 # Add the language fragments.
2817 # Languages are added via two mechanisms. Some information must be
2818 # recorded in makefile variables, these are defined in config-lang.in.
2819 # We accumulate them and plug them into the main Makefile.
2820 # The other mechanism is a set of hooks for each of the main targets
2821 # like `clean', `install', etc.
2823 language_hooks="Make-hooks"
2833 . ${srcdir}/$s/config-lang.in
2834 if test "x$language" = x
2836 echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2839 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2840 if test -f ${srcdir}/$s/Makefile.in
2841 then all_lang_makefiles="$s/Makefile"
2843 all_languages="$all_languages $language"
2844 if test "x$boot_language" = xyes
2846 all_boot_languages="$all_boot_languages $language"
2848 all_compilers="$all_compilers $compilers"
2849 all_stagestuff="$all_stagestuff $stagestuff"
2850 all_outputs="$all_outputs $outputs"
2851 all_gtfiles="$all_gtfiles $gtfiles"
2854 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2855 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2859 # Pick up gtfiles for c
2862 . ${srcdir}/c-config-lang.in
2863 all_gtfiles="$all_gtfiles $gtfiles"
2866 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2867 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2871 for language in $all_languages
2873 check_languages="$check_languages check-$language"
2876 # We link each language in with a set of hooks, reached indirectly via
2881 target_list="all.build all.cross start.encap rest.encap tags \
2882 install-normal install-common install-man \
2883 uninstall info man srcextra srcman srcinfo \
2884 mostlyclean clean distclean maintainer-clean \
2885 stage1 stage2 stage3 stage4 stageprofile stagefeedback"
2886 for t in $target_list
2889 for lang in $all_languages
2893 echo "lang.$t: $x" >> Make-hooks
2902 echo "dir ." > .gdbinit
2903 echo "dir ${srcdir}" >> .gdbinit
2904 if test x$gdb_needs_out_file_path = xyes
2906 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2908 if test "x$subdirs" != x; then
2911 echo "dir ${srcdir}/$s" >> .gdbinit
2914 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2916 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2917 # absolute path for gcc_tooldir based on inserting the number of up-directory
2918 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2919 # $(libsubdir)/@(unlibsubdir) based path.
2920 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2921 # make and thus we'd get different behavior depending on where we built the
2923 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2924 gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
2926 changequote(<<, >>)dnl
2927 # An explanation of the sed strings:
2928 # -e 's|^\$(prefix)||' matches and eliminates 'prefix' from 'exec_prefix'
2929 # -e 's|/$||' match a trailing forward slash and eliminates it
2930 # -e 's|^[^/]|/|' forces the string to start with a forward slash (*)
2931 # -e 's|/[^/]*|../|g' replaces each occurrence of /<directory> with ../
2933 # (*) Note this pattern overwrites the first character of the string
2934 # with a forward slash if one is not already present. This is not a
2935 # problem because the exact names of the sub-directories concerned is
2936 # unimportant, just the number of them matters.
2938 # The practical upshot of these patterns is like this:
2940 # prefix exec_prefix result
2941 # ------ ----------- ------
2943 # /foo/ /foo/bar ../
2944 # /foo /foo/bar/ ../
2945 # /foo/ /foo/bar/ ../
2946 # /foo /foo/bar/ugg ../../
2949 gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
2950 changequote([, ])dnl
2952 AC_SUBST(gcc_tooldir)
2955 # Find a directory in which to install a shared libgcc.
2957 AC_ARG_ENABLE(version-specific-runtime-libs,
2958 [ --enable-version-specific-runtime-libs
2959 specify that runtime libraries should be
2960 installed in a compiler-specific directory])
2962 AC_ARG_WITH(slibdir,
2963 [ --with-slibdir=DIR shared libraries in DIR [LIBDIR]],
2964 slibdir="$with_slibdir",
2965 if test "${enable_version_specific_runtime_libs+set}" = set; then
2966 slibdir='$(libsubdir)'
2967 elif test "$host" != "$target"; then
2968 slibdir='$(build_tooldir)/lib'
2974 objdir=`${PWDCMD-pwd}`
2977 # Substitute configuration variables
2980 AC_SUBST(all_boot_languages)
2981 AC_SUBST(all_compilers)
2982 AC_SUBST(all_gtfiles)
2983 AC_SUBST(all_gtfiles_files_langs)
2984 AC_SUBST(all_gtfiles_files_files)
2985 AC_SUBST(all_lang_makefrags)
2986 AC_SUBST(all_lang_makefiles)
2987 AC_SUBST(all_languages)
2988 AC_SUBST(all_stagestuff)
2989 AC_SUBST(build_exeext)
2990 AC_SUBST(build_install_headers_dir)
2991 AC_SUBST(build_xm_file_list)
2992 AC_SUBST(build_xm_include_list)
2993 AC_SUBST(build_xm_defines)
2994 AC_SUBST(check_languages)
2995 AC_SUBST(cc_set_by_configure)
2996 AC_SUBST(quoted_cc_set_by_configure)
2997 AC_SUBST(cpp_install_dir)
2998 AC_SUBST(xmake_file)
2999 AC_SUBST(tmake_file)
3000 AC_SUBST(extra_gcc_objs)
3001 AC_SUBST(extra_headers_list)
3002 AC_SUBST(extra_objs)
3003 AC_SUBST(extra_parts)
3004 AC_SUBST(extra_passes)
3005 AC_SUBST(extra_programs)
3006 AC_SUBST(float_h_file)
3007 AC_SUBST(gcc_config_arguments)
3008 AC_SUBST(gcc_gxx_include_dir)
3009 AC_SUBST(libstdcxx_incdir)
3010 AC_SUBST(gcc_version)
3011 AC_SUBST(gcc_version_full)
3012 AC_SUBST(gcc_version_trigger)
3013 AC_SUBST(host_exeext)
3014 AC_SUBST(host_xm_file_list)
3015 AC_SUBST(host_xm_include_list)
3016 AC_SUBST(host_xm_defines)
3017 AC_SUBST(out_host_hook_obj)
3019 AC_SUBST(lang_opt_files)
3020 AC_SUBST(lang_specs_files)
3021 AC_SUBST(lang_tree_files)
3022 AC_SUBST(local_prefix)
3024 AC_SUBST(objc_boehm_gc)
3026 AC_SUBST(out_object_file)
3027 AC_SUBST(stage_prefix_set_by_configure)
3028 AC_SUBST(quoted_stage_prefix_set_by_configure)
3029 AC_SUBST(symbolic_link)
3030 AC_SUBST(thread_file)
3031 AC_SUBST(tm_file_list)
3032 AC_SUBST(tm_include_list)
3033 AC_SUBST(tm_defines)
3034 AC_SUBST(tm_p_file_list)
3035 AC_SUBST(tm_p_include_list)
3036 AC_SUBST(xm_file_list)
3037 AC_SUBST(xm_include_list)
3038 AC_SUBST(xm_defines)
3039 AC_SUBST(target_noncanonical)
3040 AC_SUBST(c_target_objs)
3041 AC_SUBST(cxx_target_objs)
3042 AC_SUBST(target_cpu_default)
3044 AC_SUBST_FILE(language_hooks)
3046 # If it doesn't already exist, create document directory
3047 echo "checking for the document directory." 1>&2
3048 if test -d doc ; then
3055 if test x${build} = x${host} ; then
3056 if test x${host} = x${target} ; then
3057 echo "Links are now set up to build a native compiler for ${target}." 1>&2
3059 echo "Links are now set up to build a cross-compiler" 1>&2
3060 echo " from ${host} to ${target}." 1>&2
3063 if test x${host} = x${target} ; then
3064 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3065 echo " for ${target}." 1>&2
3067 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3068 echo " from ${host} to ${target}." 1>&2
3072 # Configure the subdirectories
3073 # AC_CONFIG_SUBDIRS($subdirs)
3075 # Create the Makefile
3076 # and configure language subdirectories
3077 AC_CONFIG_FILES($all_outputs)
3079 AC_CONFIG_COMMANDS([default],
3081 case ${CONFIG_HEADERS} in
3082 *auto-host.h:config.in*)
3085 # Make sure all the subdirs exist.
3088 test -d $d || mkdir $d
3090 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3091 # bootstrapping and the installation procedure can still use
3092 # CC="stage1/xgcc -Bstage1/". If the host doesn't support symlinks,
3093 # FLAGS_TO_PASS has been modified to solve the problem there.
3094 # This is virtually a duplicate of what happens in configure.lang; we do
3095 # an extra check to make sure this only happens if ln -s can be used.
3096 if test "$symbolic_link" = "ln -s"; then
3097 for d in ${subdirs} fixinc ; do
3098 STARTDIR=`${PWDCMD-pwd}`
3100 for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3103 $symbolic_link ../$t $t 2>/dev/null
3110 symbolic_link='$symbolic_link'