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 # Add -Wold-style-definition if it's accepted
336 [whether ${CC} accepts -Wold-style-definition],
337 [ac_cv_prog_cc_w_old_style_definition],
338 [save_CFLAGS="$CFLAGS"
339 CFLAGS="-Wold-style-definition"
340 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
341 [ac_cv_prog_cc_w_old_style_definition=yes],
342 [ac_cv_prog_cc_w_old_style_definition=no])
343 CFLAGS="$save_CFLAGS"
345 if test $ac_cv_prog_cc_w_old_style_definition = yes ; then
346 strict1_warn="${strict1_warn} -Wold-style-definition"
349 # Enable -Werror, period.
350 AC_ARG_ENABLE(werror_always,
351 [ --enable-werror-always enable -Werror always], [],
352 [enable_werror_always=no])
353 if test x${enable_werror_always} = xyes ; then
354 strict1_warn="${strict1_warn} -Werror"
358 # If the native compiler is GCC, we can enable warnings even in stage1.
359 # That's useful for people building cross-compilers, or just running a
362 if test "x$GCC" = "xyes"; then
363 warn_cflags='$(GCC_WARN_CFLAGS)'
365 AC_SUBST(warn_cflags)
367 # Enable -Werror in bootstrap stage2 and later.
368 # Change the default to "no" on release branches.
369 AC_ARG_ENABLE(werror,
370 [ --enable-werror enable -Werror in bootstrap stage2 and later], [],
372 if test x$enable_werror = xyes ; then
377 # Enable expensive internal checks
378 AC_ARG_ENABLE(checking,
379 [ --enable-checking[=LIST]
380 enable expensive run-time checks. With LIST,
381 enable only specific categories of checks.
382 Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
383 default is misc,tree,gc,rtlflag],
389 ac_gc_always_collect=
391 case "${enableval}" in
392 yes) ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
393 ac_rtlflag_checking=1 ;;
395 *) IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
396 set fnord $enableval; shift
401 misc) ac_checking=1 ;;
402 tree) ac_tree_checking=1 ;;
403 rtlflag) ac_rtlflag_checking=1 ;;
404 rtl) ac_rtl_checking=1 ;;
405 gc) ac_gc_checking=1 ;;
406 gcac) ac_gc_always_collect=1 ;;
407 fold) ac_fold_checking=1 ;;
408 valgrind) ac_checking_valgrind=1 ;;
409 *) AC_MSG_ERROR(unknown check category $check) ;;
415 # Enable some checks by default for development versions of GCC
416 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
418 if test x$ac_checking != x ; then
419 AC_DEFINE(ENABLE_CHECKING, 1,
420 [Define if you want more run-time sanity checks. This one gets a grab
421 bag of miscellaneous but relatively cheap checks.])
422 nocommon_flag=-fno-common
424 AC_SUBST(nocommon_flag)
425 if test x$ac_tree_checking != x ; then
426 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
427 [Define if you want all operations on trees (the basic data
428 structure of the front ends) to be checked for dynamic type safety
429 at runtime. This is moderately expensive.])
431 if test x$ac_rtl_checking != x ; then
432 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
433 [Define if you want all operations on RTL (the basic data structure
434 of the optimizer and back end) to be checked for dynamic type safety
435 at runtime. This is quite expensive.])
437 if test x$ac_rtlflag_checking != x ; then
438 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
439 [Define if you want RTL flag accesses to be checked against the RTL
440 codes that are supported for each access macro. This is relatively
443 if test x$ac_gc_checking != x ; then
444 AC_DEFINE(ENABLE_GC_CHECKING, 1,
445 [Define if you want the garbage collector to do object poisoning and
446 other memory allocation checks. This is quite expensive.])
448 if test x$ac_gc_always_collect != x ; then
449 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
450 [Define if you want the garbage collector to operate in maximally
451 paranoid mode, validating the entire heap and collecting garbage at
452 every opportunity. This is extremely expensive.])
454 if test x$ac_fold_checking != x ; then
455 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
456 [Define if you want fold checked that it never destructs its argument.
457 This is quite expensive.])
459 valgrind_path_defines=
462 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
463 dnl # an if statement. This was the source of very frustrating bugs
464 dnl # in converting to autoconf 2.5x!
465 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
467 if test x$ac_checking_valgrind != x ; then
468 # It is certainly possible that there's valgrind but no valgrind.h.
469 # GCC relies on making annotations so we must have both.
470 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
472 [#include <valgrind/memcheck.h>
473 #ifndef VALGRIND_DISCARD
474 #error VALGRIND_DISCARD not defined
476 [gcc_cv_header_valgrind_memcheck_h=yes],
477 [gcc_cv_header_valgrind_memcheck_h=no])
478 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
479 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
481 [#include <memcheck.h>
482 #ifndef VALGRIND_DISCARD
483 #error VALGRIND_DISCARD not defined
485 [gcc_cv_header_memcheck_h=yes],
486 gcc_cv_header_memcheck_h=no)
487 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
488 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
489 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
490 if test "x$valgrind_path" = "x" \
491 || (test $have_valgrind_h = no \
492 && test $gcc_cv_header_memcheck_h = no \
493 && test $gcc_cv_header_valgrind_memcheck_h = no); then
494 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
496 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
497 valgrind_command="$valgrind_path -q"
498 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
499 [Define if you want to run subprograms and generated programs
500 through valgrind (a memory checker). This is extremely expensive.])
501 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
502 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
503 [Define if valgrind's valgrind/memcheck.h header is installed.])
505 if test $gcc_cv_header_memcheck_h = yes; then
506 AC_DEFINE(HAVE_MEMCHECK_H, 1,
507 [Define if valgrind's memcheck.h header is installed.])
510 AC_SUBST(valgrind_path_defines)
511 AC_SUBST(valgrind_command)
513 # Enable code coverage collection
514 AC_ARG_ENABLE(coverage,
515 [ --enable-coverage[=LEVEL]
516 enable compiler\'s code coverage collection.
517 Use to measure compiler performance and locate
518 unused parts of the compiler. With LEVEL, specify
519 optimization. Values are opt, noopt,
521 [case "${enableval}" in
523 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
526 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
529 # a.k.a. --disable-coverage
533 AC_MSG_ERROR(unknown coverage setting $enableval)
537 AC_SUBST(coverage_flags)
539 AC_ARG_ENABLE(gather-detailed-mem-stats,
540 [ --enable-gather-detailed-mem-stats enable detailed memory allocation stats gathering], [],
541 [enable_gather_detailed_mem_stats=no])
542 if test x$enable_gather_detailed_mem_stats = xyes ; then
543 AC_DEFINE(GATHER_STATISTICS, 1,
544 [Define to enable detailed memory allocation stats gathering.])
547 # -------------------------------
548 # Miscenalleous configure options
549 # -------------------------------
553 [ --with-stabs arrange to use stabs instead of host debug format],
557 # Determine whether or not multilibs are enabled.
558 AC_ARG_ENABLE(multilib,
559 [ --enable-multilib enable library support for multiple ABIs],
560 [], [enable_multilib=yes])
561 AC_SUBST(enable_multilib)
563 # Enable __cxa_atexit for C++.
564 AC_ARG_ENABLE(__cxa_atexit,
565 [ --enable-__cxa_atexit enable __cxa_atexit for C++],
569 # Pass with no value to take the default
570 # Pass with a value to specify a thread package
571 AC_ARG_ENABLE(threads,
572 [ --enable-threads enable thread usage for target GCC
573 --enable-threads=LIB use LIB thread package for target GCC],,
576 AC_ARG_ENABLE(objc-gc,
577 [ --enable-objc-gc enable the use of Boehm's garbage collector with
578 the GNU Objective-C runtime],
579 if test x$enable_objc_gc = xno; then
587 [ --with-dwarf2 force the default debug format to be DWARF 2],
588 dwarf2="$with_dwarf2",
591 AC_ARG_ENABLE(shared,
592 [ --disable-shared don't provide a shared libgcc],
594 case $enable_shared in
598 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
599 for pkg in $enableval; do
600 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
607 ], [enable_shared=yes])
608 AC_SUBST(enable_shared)
611 [ --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
613 case ${with_sysroot} in
614 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
615 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
618 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
619 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
621 if test "x$exec_prefix" = xNONE; then
622 if test "x$prefix" = xNONE; then
623 test_prefix=/usr/local
628 test_prefix=$exec_prefix
630 case ${TARGET_SYSTEM_ROOT} in
631 "${test_prefix}"|"${test_prefix}/"*|\
632 '${exec_prefix}'|'${exec_prefix}/'*)
633 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
634 TARGET_SYSTEM_ROOT_DEFINE="$t"
639 TARGET_SYSTEM_ROOT_DEFINE=
640 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
642 AC_SUBST(TARGET_SYSTEM_ROOT)
643 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
644 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
646 # Build with intermodule optimisations
647 AC_ARG_ENABLE(intermodule,
648 [ --enable-intermodule build the compiler in one step],
649 [case ${enable_intermodule} in
650 yes) onestep="-onestep";;
656 # Sanity check enable_languages in case someone does not run the toplevel
657 # configure # script.
658 AC_ARG_ENABLE(languages,
659 [ --enable-languages=LIST specify which front-ends to build],
660 [case ,${enable_languages}, in
662 # go safe -- we cannot be much sure without the toplevel
664 # analysis of which target libs are present and usable
668 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
673 enable_languages=c,${enable_languages}
676 [enable_languages=c])
679 for lang in ${srcdir}/*/config-lang.in
682 # The odd quoting in the next line works around
683 # an apparent bug in bash 1.12 on linux.
685 ${srcdir}/[*]/config-lang.in) ;;
687 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
688 if test "x$lang_alias" = x
690 echo "$lang doesn't set \$language." 1>&2
693 case ",$enable_languages," in
695 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;;
703 # -------------------------
704 # Checks for other programs
705 # -------------------------
709 # Find some useful tools
711 # We need awk to run opts.sh (to create options.c and options.h).
712 # Bail out if it's missing.
714 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
722 # See if cmp has --ignore-initial.
723 gcc_AC_PROG_CMP_IGNORE_INITIAL
725 # See if we have the mktemp command.
726 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
728 # Do we have a single-tree copy of texinfo?
729 if test -f $srcdir/../texinfo/Makefile.in; then
730 MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
731 gcc_cv_prog_makeinfo_modern=yes
732 AC_MSG_RESULT([Using makeinfo from the unified source tree.])
734 # See if makeinfo has been installed and is modern enough
735 # that we can use it.
736 gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
737 [GNU texinfo.* \([0-9][0-9.]*\)],
741 if test $gcc_cv_prog_makeinfo_modern = no; then
743 *** Makeinfo is missing or too old.
744 *** Info documentation will not be built.])
747 BUILD_INFO=info AC_SUBST(BUILD_INFO)
750 # Is pod2man recent enough to regenerate manpages?
751 AC_MSG_CHECKING([for recent Pod::Man])
752 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
754 GENERATED_MANPAGES=generated-manpages AC_SUBST(GENERATED_MANPAGES)
761 dnl Don't use AC_PROG_LEX; we insist on flex.
762 dnl LEXLIB is not useful in gcc.
763 if test -f $srcdir/../flex/skel.c; then
764 FLEX='$(objdir)/../flex/flex'
766 AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
770 # The -L switch is so bison can find its skeleton file.
771 if test -f $srcdir/../bison/bison.simple; then
772 BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
774 AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
777 # --------------------
778 # Checks for C headers
779 # --------------------
781 AC_MSG_CHECKING(for GNU C library)
782 AC_CACHE_VAL(gcc_cv_glibc,
784 [#include <features.h>],[
785 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
786 #error Not a GNU C library system
790 AC_MSG_RESULT($gcc_cv_glibc)
791 if test $gcc_cv_glibc = yes; then
792 AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
795 # Need to reject headers which give warnings, so that the -Werror bootstrap
796 # works later. *sigh* This needs to come before all header checks.
801 gcc_AC_HEADER_STDBOOL
804 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
805 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
806 sys/resource.h sys/param.h sys/times.h sys/stat.h \
807 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
809 # Check for thread headers.
810 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
811 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
813 # These tests can't be done till we know if we have limits.h.
821 # Stage specific cflags for build.
827 stage1_cflags="-Wa,-J"
833 # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
834 # sources; use -no-cpp-precomp to get to GNU cpp.
835 # Apple's GCC has bugs in designated initializer handling, so disable
837 stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
840 AC_SUBST(stage1_cflags)
842 # These libraries may be used by collect2.
843 # We may need a special search path to get them linked.
844 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
846 for libs in '' -lld -lmld \
847 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
848 '-L/usr/lib/cmplrs/cc3.11 -lmld'
851 AC_TRY_LINK_FUNC(ldopen,
852 [gcc_cv_collect2_libs="$libs"; break])
855 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
856 case $gcc_cv_collect2_libs in
858 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
860 AC_SUBST(COLLECT2_LIBS)
862 # When building Ada code on Alpha, we need exc_resume which is usually in
863 # -lexc. So test for it.
866 AC_SEARCH_LIBS(exc_resume, exc)
869 AC_SUBST(GNAT_LIBEXC)
871 # Some systems put ldexp and frexp in libm instead of libc; assume
872 # they're both in the same place. jcf-dump needs them.
875 AC_SEARCH_LIBS(ldexp, m)
880 # Use <inttypes.h> only if it exists,
881 # doesn't clash with <sys/types.h>, and declares intmax_t.
882 AC_MSG_CHECKING(for inttypes.h)
883 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
885 [#include <sys/types.h>
886 #include <inttypes.h>],
888 [gcc_cv_header_inttypes_h=yes],
889 gcc_cv_header_inttypes_h=no)])
890 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
891 if test $gcc_cv_header_inttypes_h = yes; then
892 AC_DEFINE(HAVE_INTTYPES_H, 1,
893 [Define if you have a working <inttypes.h> header file.])
896 dnl Disabled until we have a complete test for buggy enum bitfields.
897 dnl gcc_AC_C_ENUM_BF_UNSIGNED
899 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
900 sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
901 fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
902 scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
905 if test x$ac_cv_func_mbstowcs = xyes; then
906 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
907 [ AC_TRY_RUN([#include <stdlib.h>
913 gcc_cv_func_mbstowcs_works=yes,
914 gcc_cv_func_mbstowcs_works=no,
915 gcc_cv_func_mbstowcs_works=yes)])
916 if test x$gcc_cv_func_mbstowcs_works = xyes; then
917 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
918 [Define this macro if mbstowcs does not crash when its
919 first argument is NULL.])
923 AC_CHECK_TYPE(ssize_t, int)
925 # Try to determine the array type of the second argument of getgroups
926 # for the target system (int or gid_t).
928 if test "${target}" = "${build}"; then
929 TARGET_GETGROUPS_T=$ac_cv_type_getgroups
932 # This condition may need some tweaking. It should include all
933 # targets where the array type of the second argument of getgroups
934 # is int and the type of gid_t is not equivalent to int.
935 *-*-sunos* | *-*-ultrix*)
936 TARGET_GETGROUPS_T=int
939 TARGET_GETGROUPS_T=gid_t
943 AC_SUBST(TARGET_GETGROUPS_T)
945 gcc_AC_FUNC_PRINTF_PTR
946 gcc_AC_FUNC_MMAP_BLACKLIST
950 # Under VMS, vfork works very differently than on Unix. The standard test
951 # won't work, and it isn't easily adaptable. It makes more sense to
953 ac_cv_func_vfork_works=yes
959 # Until we have in-tree GNU iconv:
961 AC_SUBST(LIBICONV_DEP)
965 # We will need to find libiberty.h and ansidecl.h
966 saved_CFLAGS="$CFLAGS"
967 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
968 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
969 strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
970 fprintf_unlocked strstr errno snprintf vasprintf \
971 malloc realloc calloc free basename getopt clock, , ,[
972 #include "ansidecl.h"
973 #include "system.h"])
975 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
976 #include "ansidecl.h"
978 #ifdef HAVE_SYS_RESOURCE_H
979 #include <sys/resource.h>
984 #include "ansidecl.h"
986 #ifdef HAVE_SYS_RESOURCE_H
987 #include <sys/resource.h>
989 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
990 [Define to \`long' if <sys/resource.h> doesn't define.])])
992 gcc_AC_CHECK_DECLS(ldgetname, , ,[
993 #include "ansidecl.h"
1000 gcc_AC_CHECK_DECLS(times, , ,[
1001 #include "ansidecl.h"
1003 #ifdef HAVE_SYS_TIMES_H
1004 #include <sys/times.h>
1008 # More time-related stuff.
1009 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1011 #include "ansidecl.h"
1013 #ifdef HAVE_SYS_TIMES_H
1014 #include <sys/times.h>
1016 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
1017 if test $ac_cv_struct_tms = yes; then
1018 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1019 [Define if <sys/times.h> defines struct tms.])
1022 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1023 # revisit after autoconf 2.50.
1024 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1026 #include "ansidecl.h"
1028 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
1029 if test $gcc_cv_type_clock_t = yes; then
1030 AC_DEFINE(HAVE_CLOCK_T, 1,
1031 [Define if <time.h> defines clock_t.])
1034 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
1036 #include "ansidecl.h"
1039 [if ((uchar *)0) return 0;
1040 if (sizeof(uchar)) return 0;],
1041 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
1042 if test $ac_cv_type_uchar = yes; then
1043 AC_DEFINE(HAVE_UCHAR, 1,
1044 [Define if <sys/types.h> defines \`uchar'.])
1047 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1048 CFLAGS="$saved_CFLAGS"
1050 gcc_AC_INITFINI_ARRAY
1052 # mkdir takes a single argument on some systems.
1053 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1061 # With Setjmp/Longjmp based exception handling.
1062 AC_ARG_ENABLE(sjlj-exceptions,
1063 [ --enable-sjlj-exceptions
1064 arrange to use setjmp/longjmp exception handling],
1065 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1066 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1067 [Define 0/1 to force the choice for exception handling model.])])
1069 if test x$host = x$target; then
1070 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
1072 use_libunwind_default=no
1074 # Use libunwind based exception handling.
1075 AC_ARG_ENABLE(libunwind-exceptions,
1076 [ --enable-libunwind-exceptions force use libunwind for exceptions],
1077 use_libunwind_exceptions=$enableval,
1078 use_libunwind_exceptions=$use_libunwind_default)
1079 if test x"$use_libunwind_exceptions" = xyes; then
1080 AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
1081 [Define if gcc should use -lunwind.])
1084 # --------------------------------------------------------
1085 # Build, host, and target specific configuration fragments
1086 # --------------------------------------------------------
1088 # Collect build-machine-specific information.
1089 . ${srcdir}/config.build
1091 # Collect host-machine-specific information.
1092 . ${srcdir}/config.host
1096 # Collect target-machine-specific information.
1097 . ${srcdir}/config.gcc
1099 extra_objs="${host_extra_objs} ${extra_objs}"
1100 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1102 # Default the target-machine variables that were not explicitly set.
1103 if test x"$tm_file" = x
1104 then tm_file=$cpu_type/$cpu_type.h; fi
1106 if test x"$extra_headers" = x
1107 then extra_headers=; fi
1109 if test x$md_file = x
1110 then md_file=$cpu_type/$cpu_type.md; fi
1112 if test x$out_file = x
1113 then out_file=$cpu_type/$cpu_type.c; fi
1115 if test x"$tmake_file" = x
1116 then tmake_file=$cpu_type/t-$cpu_type
1119 if test x"$dwarf2" = xyes
1120 then tm_file="$tm_file tm-dwarf2.h"
1123 # Say what files are being used for the output code and MD file.
1124 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1125 echo "Using \`$srcdir/config/$md_file' as machine description file."
1127 # If any of the xm_file variables contain nonexistent files, warn
1128 # about them and drop them.
1131 for x in $build_xm_file; do
1132 if test -f $srcdir/config/$x
1134 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1140 for x in $host_xm_file; do
1141 if test -f $srcdir/config/$x
1143 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1149 for x in $xm_file; do
1150 if test -f $srcdir/config/$x
1152 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1158 for f in $tm_file; do
1161 if test $count = ax; then
1162 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1164 echo "Using the following target machine macro files:"
1165 for f in $tm_file; do
1166 echo " $srcdir/config/$f"
1170 if test x$need_64bit_hwint = xyes; then
1171 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1172 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1176 for f in $host_xm_file; do
1179 if test $count = a; then
1181 elif test $count = ax; then
1182 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1184 echo "Using the following host machine macro files:"
1185 for f in $host_xm_file; do
1186 echo " $srcdir/config/$f"
1189 echo "Using ${out_host_hook_obj} for host machine hooks."
1191 if test "$host_xm_file" != "$build_xm_file"; then
1193 for f in $build_xm_file; do
1196 if test $count = a; then
1198 elif test $count = ax; then
1199 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1201 echo "Using the following build machine macro files:"
1202 for f in $build_xm_file; do
1203 echo " $srcdir/config/$f"
1212 # Check if a valid thread package
1213 case ${enable_threads} in
1216 target_thread_file='single'
1220 target_thread_file='single'
1222 aix | dce | gnat | irix | posix | rtems | \
1223 single | solaris | vxworks | win32 )
1224 target_thread_file=${enable_threads}
1227 echo "${enable_threads} is an unknown thread package" 1>&2
1232 if test x${thread_file} = x; then
1233 # No thread file set by target-specific clauses in config.gcc,
1234 # so use file chosen by default logic above
1235 thread_file=${target_thread_file}
1238 # Make gthr-default.h if we have a thread file.
1240 if test $thread_file != single; then
1241 rm -f gthr-default.h
1242 echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1243 gthread_flags=-DHAVE_GTHR_DEFAULT
1245 AC_SUBST(gthread_flags)
1251 if test x$enable___cxa_atexit = xyes || \
1252 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1253 AC_CHECK_FUNC(__cxa_atexit,
1254 [AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1255 [Define if you want to use __cxa_atexit, rather than atexit, to
1256 register C++ destructors for local statics and global objects.
1257 This is essential for fully standards-compliant handling of
1258 destructors, but requires __cxa_atexit in libc.])],
1259 echo "__cxa_atexit can't be enabled on this target")
1262 # Look for a file containing extra machine modes.
1263 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1264 extra_modes_file='$(srcdir)'/config/${extra_modes}
1265 AC_SUBST(extra_modes_file)
1266 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1267 [Define to the name of a file containing a list of extra machine modes
1268 for this architecture.])
1271 # auto-host.h is the file containing items generated by autoconf and is
1272 # the first file included by config.h.
1273 # If host=build, it is correct to have bconfig include auto-host.h
1274 # as well. If host!=build, we are in error and need to do more
1275 # work to find out the build config parameters.
1276 if test x$host = x$build
1278 build_auto=auto-host.h
1281 # We create a subdir, then run autoconf in the subdir.
1282 # To prevent recursion we set host and build for the new
1283 # invocation of configure to the build for this invocation
1290 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1291 *) realsrcdir=../${srcdir};;
1293 saved_CFLAGS="${CFLAGS}"
1294 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1295 ${realsrcdir}/configure \
1296 --enable-languages=${enable_languages-all} \
1297 --target=$target_alias --host=$build_alias --build=$build_alias
1298 CFLAGS="${saved_CFLAGS}"
1300 # We just finished tests for the build machine, so rename
1301 # the file auto-build.h in the gcc directory.
1302 mv auto-host.h ../auto-build.h
1305 build_auto=auto-build.h
1306 FORBUILD=../${build_subdir}
1310 tm_file="${tm_file} defaults.h"
1311 tm_p_file="${tm_p_file} tm-preds.h"
1312 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1313 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1314 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1315 # put this back in temporarily.
1316 xm_file="ansidecl.h ${xm_file}"
1322 # Get the version trigger filename from the toplevel
1323 if test "${with_gcc_version_trigger+set}" = set; then
1324 gcc_version_trigger=$with_gcc_version_trigger
1326 gcc_version_trigger=${srcdir}/version.c
1329 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1330 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1332 # Compile in configure arguments.
1333 if test -f configargs.h ; then
1334 # Being re-configured.
1335 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1336 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1338 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1341 # Double all backslashes and backslash all quotes to turn
1342 # gcc_config_arguments into a C string.
1343 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1344 $gcc_config_arguments
1346 gcc_config_arguments_str=`cat conftest.out`
1349 cat > configargs.h <<EOF
1350 /* Generated automatically. */
1351 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1352 static const char thread_model[] = "$thread_file";
1354 static const struct {
1355 const char *name, *value;
1356 } configure_default_options[] = $configure_default_options;
1360 # Internationalization
1362 VERSION="$gcc_version"
1366 ZW_GNU_GETTEXT_SISTER_DIR
1368 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1369 # -liconv on the link line twice.
1370 case "$LIBINTL" in *$LIBICONV*)
1374 # Windows32 Registry support for specifying GCC installation paths.
1375 AC_ARG_ENABLE(win32-registry,
1376 [ --disable-win32-registry
1377 disable lookup of installation paths in the
1378 Registry on Windows hosts
1379 --enable-win32-registry enable registry lookup (default)
1380 --enable-win32-registry=KEY
1381 use KEY instead of GCC version as the last portion
1382 of the registry key],,)
1384 win32 | pe | cygwin* | mingw32* | uwin*)
1385 AC_MSG_CHECKING(whether windows registry support is requested)
1386 if test "x$enable_win32_registry" != xno; then
1387 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1388 [Define to 1 if installation paths should be looked up in Windows32
1389 Registry. Ignored on non windows32 hosts.])
1391 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1396 # Check if user specified a different registry key.
1397 case "x${enable_win32_registry}" in
1400 gcc_cv_win32_registry_key="$VERSION"
1403 # no registry lookup.
1404 gcc_cv_win32_registry_key=''
1407 # user-specified key.
1408 gcc_cv_win32_registry_key="$enable_win32_registry"
1412 if test "x$enable_win32_registry" != xno; then
1413 AC_MSG_CHECKING(registry key on windows hosts)
1414 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1415 [Define to be the last portion of registry key on windows hosts.])
1416 AC_MSG_RESULT($gcc_cv_win32_registry_key)
1421 # Get an absolute path to the GCC top-level source directory
1422 holddir=`${PWDCMD-pwd}`
1424 topdir=`${PWDCMD-pwd}`
1427 # Conditionalize the makefile for this host machine.
1429 for f in ${host_xmake_file}
1431 if test -f ${srcdir}/config/$f
1433 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1437 # Conditionalize the makefile for this target machine.
1439 for f in ${tmake_file}
1441 if test -f ${srcdir}/config/$f
1443 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1446 tmake_file="${tmake_file_}"
1448 symbolic_link='ln -s'
1450 # If the host doesn't support symlinks, modify CC in
1451 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1452 # Otherwise, we can use "CC=$(CC)".
1454 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1456 cc_set_by_configure="\$(CC)"
1457 quoted_cc_set_by_configure="\$(CC)"
1458 stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1459 quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1462 if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1464 symbolic_link="cp -p"
1468 cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1469 quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1470 stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1471 quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1475 out_object_file=`basename $out_file .c`.o
1479 for f in $tm_file; do
1482 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1483 tm_include_list="${tm_include_list} $f"
1486 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1487 tm_include_list="${tm_include_list} config/$f"
1494 for f in $tm_p_file; do
1497 tm_p_file_list="${tm_p_file_list} $f"
1498 tm_p_include_list="${tm_p_include_list} $f"
1501 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1502 tm_p_include_list="${tm_p_include_list} config/$f"
1508 for f in $xm_file; do
1511 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1512 xm_include_list="${xm_include_list} $f"
1515 xm_file_list="${xm_file_list} $f"
1516 xm_include_list="${xm_include_list} $f"
1519 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1520 xm_include_list="${xm_include_list} config/$f"
1526 host_xm_include_list=
1527 for f in $host_xm_file; do
1530 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1531 host_xm_include_list="${host_xm_include_list} $f"
1534 host_xm_file_list="${host_xm_file_list} $f"
1535 host_xm_include_list="${host_xm_include_list} $f"
1538 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1539 host_xm_include_list="${host_xm_include_list} config/$f"
1545 for f in $build_xm_file; do
1548 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1549 build_xm_include_list="${build_xm_include_list} $f"
1551 auto-build.h | auto-host.h )
1552 build_xm_file_list="${build_xm_file_list} $f"
1553 build_xm_include_list="${build_xm_include_list} $f"
1556 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1557 build_xm_include_list="${build_xm_include_list} config/$f"
1562 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1563 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1564 CROSS= AC_SUBST(CROSS)
1565 ALL=all.internal AC_SUBST(ALL)
1566 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1567 if test x$host != x$target
1569 CROSS="-DCROSS_COMPILE"
1571 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1572 case "$host","$target" in
1573 # Darwin crosses can use the host system's libraries and headers,
1574 # because of the fat library support. Of course, it must be the
1575 # same version of Darwin on both sides. Allow the user to
1576 # just say --target=foo-darwin without a version number to mean
1577 # "the version on this system".
1578 *-*-darwin*,*-*-darwin*)
1579 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1580 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1581 if test $hostos = $targetos -o $targetos = darwin ; then
1583 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1588 i?86-*-*,x86_64-*-* \
1589 | powerpc*-*-*,powerpc64*-*-*)
1590 CROSS="$CROSS -DNATIVE_CROSS" ;;
1592 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1593 # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1594 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1597 # If this is a cross-compiler that does not
1598 # have its own set of headers then define
1601 # If this is using newlib, without having the headers available now,
1602 # then define inhibit_libc in LIBGCC2_CFLAGS.
1603 # This prevents libgcc2 from containing any code which requires libc
1606 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1607 test x$with_newlib = xyes ; } &&
1608 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1609 inhibit_libc=-Dinhibit_libc
1611 AC_SUBST(inhibit_libc)
1613 # When building gcc with a cross-compiler, we need to adjust things so
1614 # that the generator programs are still built with the native compiler.
1615 # Also, we cannot run fixincludes or fix-header.
1617 # These are the normal (build=host) settings:
1618 BUILD_PREFIX= AC_SUBST(BUILD_PREFIX)
1619 BUILD_PREFIX_1=ignore- AC_SUBST(BUILD_PREFIX_1)
1620 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1621 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1623 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1625 # Possibly disable fixproto, on a per-target basis.
1626 case ${use_fixproto} in
1631 STMP_FIXPROTO=stmp-fixproto
1634 AC_SUBST(STMP_FIXPROTO)
1636 # And these apply if build != host, or we are generating coverage data
1637 if test x$build != x$host || test "x$coverage_flags" != x
1640 BUILD_PREFIX_1=build-
1641 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1643 if test "x$TARGET_SYSTEM_ROOT" = x; then
1649 # Expand extra_headers to include complete path.
1650 # This substitutes for lots of t-* files.
1652 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1653 for file in ${extra_headers} ; do
1654 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1657 # Define collect2 in Makefile.
1658 case $host_can_use_collect2 in
1660 *) collect2='collect2$(exeext)' ;;
1662 AC_SUBST([collect2])
1664 # Add a definition of USE_COLLECT2 if system wants one.
1665 case $use_collect2 in
1666 no) use_collect2= ;;
1669 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1670 xm_defines="${xm_defines} USE_COLLECT2"
1671 case $host_can_use_collect2 in
1673 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1679 # ---------------------------
1680 # Assembler & linker features
1681 # ---------------------------
1683 # Identify the assembler which will work hand-in-glove with the newly
1684 # built GCC, so that we can examine its features. This is the assembler
1685 # which will be driven by the driver program.
1687 # If build != host, and we aren't building gas in-tree, we identify a
1688 # build->target assembler and hope that it will have the same features
1689 # as the host->target assembler we'll be using.
1690 AC_MSG_CHECKING(what assembler to use)
1693 gcc_cv_gas_major_version=
1694 gcc_cv_gas_minor_version=
1695 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1696 if test -x "$DEFAULT_ASSEMBLER"; then
1697 gcc_cv_as="$DEFAULT_ASSEMBLER"
1698 elif test -x "$AS"; then
1700 elif test -x as$host_exeext; then
1701 # Build using assembler in the current directory.
1702 gcc_cv_as=./as$host_exeext
1703 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1704 && test -f ../gas/Makefile; then
1705 # Single tree build which includes gas.
1707 _gcc_COMPUTE_GAS_VERSION
1708 rm -f as$host_exeext
1709 $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1710 in_tree_gas_is_elf=no
1711 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1712 || (grep 'obj_format = multi' ../gas/Makefile \
1713 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1715 in_tree_gas_is_elf=yes
1719 if test "x$gcc_cv_as" = x; then
1720 # Search the same directories that the installed compiler will
1721 # search. Else we may find the wrong assembler and lose. If we
1722 # do not find a suitable assembler binary, then try the user's
1725 # Also note we have to check MD_EXEC_PREFIX before checking the
1726 # user's path. Unfortunately, there is no good way to get at the
1727 # value of MD_EXEC_PREFIX here. So we do a brute force search
1728 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1729 # to be fixed as part of the make/configure rewrite too.
1731 if test "x$exec_prefix" = xNONE; then
1732 if test "x$prefix" = xNONE; then
1733 test_prefix=/usr/local
1738 test_prefix=$exec_prefix
1741 # If the loop below does not find an assembler, then use whatever
1742 # one we can find in the users's path.
1744 if test "x$program_prefix" != xNONE; then
1745 gcc_cv_as=${program_prefix}as$host_exeext
1747 gcc_cv_as=`echo as | sed "${program_transform_name}"`$host_exeext
1750 test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1751 $test_prefix/libexec/gcc/$target_noncanonical \
1752 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1753 /usr/lib/gcc/$target_noncanonical \
1754 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1755 $test_prefix/$target_noncanonical/bin"
1757 if test x$host = x$target; then
1758 test_dirs="$test_dirs \
1763 /bsd43/usr/lib/cmplrs/cc \
1764 /usr/cross64/usr/bin \
1765 /usr/lib/cmplrs/cc \
1766 /sysv/usr/lib/cmplrs/cc \
1767 /svr4/usr/lib/cmplrs/cc \
1771 for dir in $test_dirs; do
1772 if test -x $dir/as$host_exeext; then
1773 gcc_cv_as=$dir/as$host_exeext
1778 case $in_tree_gas in
1780 AC_MSG_RESULT("newly built gas")
1783 AC_MSG_RESULT($gcc_cv_as)
1787 # Identify the linker which will work hand-in-glove with the newly
1788 # built GCC, so that we can examine its features. This is the linker
1789 # which will be driven by the driver program.
1791 # If build != host, and we aren't building gas in-tree, we identify a
1792 # build->target linker and hope that it will have the same features
1793 # as the host->target linker we'll be using.
1794 AC_MSG_CHECKING(what linker to use)
1797 gcc_cv_gld_major_version=
1798 gcc_cv_gld_minor_version=
1799 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1800 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1801 if test -x "$DEFAULT_LINKER"; then
1802 gcc_cv_ld="$DEFAULT_LINKER"
1803 elif test -x "$LD_FOR_TARGET"; then
1804 gcc_cv_ld="$LD_FOR_TARGET"
1805 elif test -x "$LD" && test x$host = x$target; then
1807 elif test -x collect-ld$host_exeext; then
1808 # Build using linker in the current directory.
1809 gcc_cv_ld=./collect-ld$host_exeext
1810 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1811 && test -f ../ld/Makefile; then
1812 # Single tree build which includes ld.
1814 in_tree_ld_is_elf=no
1815 if (grep 'EMUL = .*elf' ../ld/Makefile \
1816 || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1817 in_tree_ld_is_elf=yes
1819 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
1822 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1824 if test x$gcc_cv_gld_version != x; then
1829 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1830 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1832 rm -f collect-ld$host_exeext
1833 $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1837 if test "x$gcc_cv_ld" = x; then
1838 # Search the same directories that the installed compiler will
1839 # search. Else we may find the wrong linker and lose. If we
1840 # do not find a suitable linker binary, then try the user's
1843 # Also note we have to check MD_EXEC_PREFIX before checking the
1844 # user's path. Unfortunately, there is no good way to get at the
1845 # value of MD_EXEC_PREFIX here. So we do a brute force search
1846 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1847 # to be fixed as part of the make/configure rewrite too.
1849 if test "x$exec_prefix" = xNONE; then
1850 if test "x$prefix" = xNONE; then
1851 test_prefix=/usr/local
1856 test_prefix=$exec_prefix
1859 # If the loop below does not find an linker, then use whatever
1860 # one we can find in the users's path.
1862 if test "x$program_prefix" != xNONE; then
1863 gcc_cv_ld=${program_prefix}ld$host_exeext
1865 gcc_cv_ld=`echo ld | sed "${program_transform_name}"`$host_exeext
1868 test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1869 $test_prefix/libexec/gcc/$target_noncanonical \
1870 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1871 /usr/lib/gcc/$target_noncanonical \
1872 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1873 $test_prefix/$target_noncanonical/bin"
1875 if test x$host = x$target; then
1876 test_dirs="$test_dirs \
1881 /bsd43/usr/lib/cmplrs/cc \
1882 /usr/cross64/usr/bin \
1883 /usr/lib/cmplrs/cc \
1884 /sysv/usr/lib/cmplrs/cc \
1885 /svr4/usr/lib/cmplrs/cc \
1889 for dir in $test_dirs; do
1890 if test -x $dir/ld$host_exeext; then
1891 gcc_cv_ld=$dir/ld$host_exeext
1898 AC_MSG_RESULT("newly built ld")
1901 AC_MSG_RESULT($gcc_cv_ld)
1905 # Figure out what nm we will be using.
1906 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1907 AC_MSG_CHECKING(what nm to use)
1909 if test -x nm$host_exeext; then
1910 gcc_cv_nm=./nm$host_exeext
1911 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1912 && test -f ../binutils/Makefile; then
1913 # Single tree build which includes binutils.
1915 gcc_cv_nm=./nm$host_exeext
1916 rm -f nm$host_exeext
1917 $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1918 elif test "x$program_prefix" != xNONE; then
1919 gcc_cv_nm=${program_prefix}nm$host_exeext
1921 gcc_cv_nm=`echo nm | sed "${program_transform_name}"`$host_exeext
1924 yes) AC_MSG_RESULT("newly built nm") ;;
1925 no) AC_MSG_RESULT($gcc_cv_nm) ;;
1928 # Figure out what objdump we will be using.
1929 AC_MSG_CHECKING(what objdump to use)
1931 if test -x objdump$host_exeext; then
1932 gcc_cv_objdump=./objdump$host_exeext
1933 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1934 && test -f ../binutils/Makefile; then
1935 # Single tree build which includes binutils.
1937 gcc_cv_objdump=./objdump$host_exeext
1938 rm -f objdump$host_exeext
1939 $symbolic_link ../binutils/objdump$host_exeext \
1940 objdump$host_exeext 2>/dev/null
1941 elif test "x$program_prefix" != xNONE; then
1942 gcc_cv_objdump=${program_prefix}objdump$host_exeext
1944 gcc_cv_objdump=`echo objdump | \
1945 sed "${program_transform_name}"`$host_exeext
1947 case $in_tree_objdump in
1948 yes) AC_MSG_RESULT("newly built objdump") ;;
1949 no) AC_MSG_RESULT($gcc_cv_objdump) ;;
1952 # Figure out what assembler alignment features are present.
1953 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1957 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1958 [Define if your assembler supports .balign and .p2align.])])
1960 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
1963 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
1964 [Define if your assembler supports specifying the maximum number
1965 of bytes to skip when using the GAS .p2align command.])])
1967 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
1969 [conftest_label1: .word 0
1971 conftest_label2: .word 0
1973 [if test x$gcc_cv_nm != x; then
1974 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1975 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1976 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
1978 else gcc_cv_as_subsection_m1=yes
1980 rm -f conftest.nm1 conftest.nm2
1982 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1983 [Define if your assembler supports .subsection and .subsection -1 starts
1984 emitting at the beginning of your section.])])
1986 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
1989 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
1991 # .hidden needs to be supported in both the assembler and the linker,
1992 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1993 # This is irritatingly difficult to feature test for; we have to check the
1994 # date string after the version number. If we've got an in-tree
1995 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
1997 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
1998 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2003 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2004 [if test $in_tree_ld = yes ; then
2006 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 \
2007 && test $in_tree_ld_is_elf = yes; then
2008 gcc_cv_ld_hidden=yes
2011 gcc_cv_ld_hidden=yes
2012 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2013 if echo "$ld_ver" | grep GNU > /dev/null; then
2015 ld_vers=`echo $ld_ver | sed -n \
2016 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2017 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2018 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2019 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
2020 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
2021 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p'`
2022 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'`
2023 if test 0"$ld_date" -lt 20020404; then
2024 if test -n "$ld_date"; then
2025 # If there was date string, but was earlier than 2002-04-04, fail
2027 elif test -z "$ld_vers"; then
2028 # If there was no date string nor ld version number, something is wrong
2031 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2032 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2033 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2034 test -z "$ld_vers_patch" && ld_vers_patch=0
2035 if test "$ld_vers_major" -lt 2; then
2037 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2038 gcc_cv_ld_hidden="no"
2039 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2047 hppa64*-*-hpux* | ia64*-*-hpux*)
2048 gcc_cv_ld_hidden=yes
2056 libgcc_visibility=no
2057 AC_SUBST(libgcc_visibility)
2058 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2059 libgcc_visibility=yes
2060 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2061 [Define if your assembler and linker support .hidden.])
2064 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2065 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2073 [# GAS versions before 2.11 do not support uleb128,
2074 # despite appearing to.
2075 # ??? There exists an elf-specific test that will crash
2076 # the assembler. Perhaps it's better to figure out whether
2077 # arbitrary sections are supported and try the test.
2078 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2079 if echo "$as_ver" | grep GNU > /dev/null; then
2081 as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
2082 as_major=`echo $as_ver | sed 's/\..*//'`
2083 as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
2085 if test $as_major -eq 2 && test $as_minor -lt 11
2087 else gcc_cv_as_leb128=yes
2090 [AC_DEFINE(HAVE_AS_LEB128, 1,
2091 [Define if your assembler supports .sleb128 and .uleb128.])])
2093 # GAS versions up to and including 2.11.0 may mis-optimize
2095 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2103 .section .eh_frame,"aw",@progbits
2105 .4byte .LECIE1-.LSCIE1
2119 .4byte .LEFDE1-.LASFDE1
2121 .4byte .LASFDE1-__FRAME_BEGIN__
2129 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2130 cat > conftest.lit <<EOF
2131 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2132 0010 01000000 12000000 18000000 00000000 ................
2133 0020 08000000 04080000 0044 .........D @&t@
2135 cat > conftest.big <<EOF
2136 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2137 0010 00000001 00000012 00000018 00000000 ................
2138 0020 00000008 04000000 0844 .........D @&t@
2140 # If the assembler didn't choke, and we can objdump,
2141 # and we got the correct data, then succeed.
2142 if test x$gcc_cv_objdump != x \
2143 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2144 | tail -3 > conftest.got \
2145 && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2146 || cmp conftest.big conftest.got > /dev/null 2>&1; }
2148 gcc_cv_as_eh_frame=yes
2149 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2150 gcc_cv_as_eh_frame=buggy
2152 # Uh oh, what do we do now?
2153 gcc_cv_as_eh_frame=no
2156 if test $gcc_cv_as_eh_frame = buggy; then
2157 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2158 [Define if your assembler mis-optimizes .eh_frame data.])
2161 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2162 [elf,2,12,0], [--fatal-warnings],
2163 [.section .rodata.str, "aMS", @progbits, 1])
2164 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2165 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2166 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2168 # Thread-local storage - the check is heavily parametrized.
2177 .section ".tdata","awT",@progbits
2180 ldq $27,__tls_get_addr($29) !literal!1
2181 lda $16,foo($29) !tlsgd!1
2182 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2183 ldq $27,__tls_get_addr($29) !literal!2
2184 lda $16,foo($29) !tlsldm!2
2185 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2186 ldq $1,foo($29) !gotdtprel
2187 ldah $2,foo($29) !dtprelhi
2188 lda $3,foo($2) !dtprello
2189 lda $4,foo($29) !dtprel
2190 ldq $1,foo($29) !gottprel
2191 ldah $2,foo($29) !tprelhi
2192 lda $3,foo($2) !tprello
2193 lda $4,foo($29) !tprel'
2196 tls_as_opt=--fatal-warnings
2200 .section ".tdata","awT",@progbits
2204 leal foo@TLSGD(,%ebx,1), %eax
2205 leal foo@TLSLDM(%ebx), %eax
2206 leal foo@DTPOFF(%eax), %edx
2207 movl foo@GOTTPOFF(%ebx), %eax
2208 subl foo@GOTTPOFF(%ebx), %eax
2209 addl foo@GOTNTPOFF(%ebx), %eax
2210 movl foo@INDNTPOFF, %eax
2211 movl $foo@TPOFF, %eax
2212 subl $foo@TPOFF, %eax
2213 leal foo@NTPOFF(%ecx), %eax'
2216 tls_as_opt=--fatal-warnings
2220 .section ".tdata","awT",@progbits
2224 leaq foo@TLSGD(%rip), %rdi
2225 leaq foo@TLSLD(%rip), %rdi
2226 leaq foo@DTPOFF(%rax), %rdx
2227 movq foo@GOTTPOFF(%rip), %rax
2228 movq $foo@TPOFF, %rax'
2231 tls_as_opt=--fatal-warnings
2235 .section ".tdata","awT",@progbits
2238 addl r16 = @ltoff(@dtpmod(foo#)), gp
2239 addl r17 = @ltoff(@dtprel(foo#)), gp
2240 addl r18 = @ltoff(@tprel(foo#)), gp
2241 addl r19 = @dtprel(foo#), gp
2242 adds r21 = @dtprel(foo#), r13
2243 movl r23 = @dtprel(foo#)
2244 addl r20 = @tprel(foo#), gp
2245 adds r22 = @tprel(foo#), r13
2246 movl r24 = @tprel(foo#)'
2249 tls_as_opt=--fatal-warnings
2253 .section ".tdata","awT",@progbits
2261 addi 3,31,ld0@got@tlsgd
2263 addi 3,31,x1@got@tlsld
2266 addis 9,3,x2@dtprel@ha
2267 addi 9,9,x2@dtprel@l
2268 lwz 9,x3@got@tprel(31)
2271 addis 9,2,x2@tprel@ha
2272 addi 9,9,x2@tprel@l'
2275 tls_as_opt="-a32 --fatal-warnings"
2279 .section ".tdata","awT",@progbits
2287 addi 3,2,ld0@got@tlsgd
2293 addi 3,2,x1@got@tlsld
2299 addis 9,3,x2@dtprel@ha
2300 addi 9,9,x2@dtprel@l
2303 ld 9,x3@got@dtprel(2)
2309 tls_as_opt="-a64 --fatal-warnings"
2313 .section ".tdata","awT",@progbits
2322 l %r1,foo@GOTNTPOFF(%r12)
2323 l %r1,0(%r1):tls_load:foo
2324 bas %r14,0(%r1,%r13):tls_gdcall:foo
2325 bas %r14,0(%r1,%r13):tls_ldcall:foo'
2328 tls_as_opt="-m31 --fatal-warnings"
2332 .section ".tdata","awT",@progbits
2340 lg %r1,foo@GOTNTPOFF(%r12)
2341 larl %r1,foo@INDNTPOFF
2342 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
2343 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2346 tls_as_opt="-m64 -Aesame --fatal-warnings"
2348 sh-*-* | sh[34]-*-*)
2350 .section ".tdata","awT",@progbits
2360 tls_as_opt=--fatal-warnings
2364 sparc*-sun-solaris2.*)
2371 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2373 .section ".tdata",#alloc,#write,#tls
2376 sethi %tgd_hi22(foo), %o0
2377 add %o0, %tgd_lo10(foo), %o1
2378 add %l7, %o1, %o0, %tgd_add(foo)
2379 call __tls_get_addr, %tgd_call(foo)
2380 sethi %tldm_hi22(foo), %l1
2381 add %l1, %tldm_lo10(foo), %l2
2382 add %l7, %l2, %o0, %tldm_add(foo)
2383 call __tls_get_addr, %tldm_call(foo)
2384 sethi %tldo_hix22(foo), %l3
2385 xor %l3, %tldo_lox10(foo), %l4
2386 add %o0, %l4, %l5, %tldo_add(foo)
2387 sethi %tie_hi22(foo), %o3
2388 add %o3, %tie_lo10(foo), %o3
2389 ld [%l7 + %o3], %o2, %tie_ld(foo)
2390 add %g7, %o2, %o4, %tie_add(foo)
2391 sethi %tle_hix22(foo), %l1
2392 xor %l1, %tle_lox10(foo), %o5
2393 ld [%g7 + %o5], %o1'
2398 .section ".tdata","awT",@progbits
2401 sethi %tgd_hi22(foo), %o0
2402 add %o0, %tgd_lo10(foo), %o1
2403 add %l7, %o1, %o0, %tgd_add(foo)
2404 call __tls_get_addr, %tgd_call(foo)
2405 sethi %tldm_hi22(foo), %l1
2406 add %l1, %tldm_lo10(foo), %l2
2407 add %l7, %l2, %o0, %tldm_add(foo)
2408 call __tls_get_addr, %tldm_call(foo)
2409 sethi %tldo_hix22(foo), %l3
2410 xor %l3, %tldo_lox10(foo), %l4
2411 add %o0, %l4, %l5, %tldo_add(foo)
2412 sethi %tie_hi22(foo), %o3
2413 add %o3, %tie_lo10(foo), %o3
2414 ld [%l7 + %o3], %o2, %tie_ld(foo)
2415 add %g7, %o2, %o4, %tie_add(foo)
2416 sethi %tle_hix22(foo), %l1
2417 xor %l1, %tle_lox10(foo), %o5
2418 ld [%g7 + %o5], %o1'
2421 tls_as_opt="-32 --fatal-warnings"
2426 if test -z "$tls_first_major"; then
2427 : # If we don't have a check, assume no support.
2429 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2430 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2431 [AC_DEFINE(HAVE_AS_TLS, 1,
2432 [Define if your assembler supports thread-local storage.])])
2435 # Target-specific assembler checks.
2438 # All TARGET_ABI_OSF targets.
2439 alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2440 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2441 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2444 extbl $3, $2, $3 !lituse_bytoff!1
2445 ldq $2, a($29) !literal!1
2446 ldq $4, b($29) !literal!2
2447 ldq_u $3, 0($2) !lituse_base!1
2448 ldq $27, f($29) !literal!5
2449 jsr $26, ($27), f !lituse_jsr!5
2450 ldah $29, 0($26) !gpdisp!3
2451 lda $0, c($29) !gprel
2452 ldah $1, d($29) !gprelhigh
2453 lda $1, d($1) !gprellow
2454 lda $29, 0($29) !gpdisp!3],,
2455 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2456 [Define if your assembler supports explicit relocations.])])
2460 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2461 gcc_cv_as_cris_no_mul_bug,[2,15,91],
2462 [-no-mul-bug-abort], [.text],,
2463 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2464 [Define if your assembler supports the -no-mul-bug-abort option.])])
2468 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2469 [.register %g2, #scratch],,
2470 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2471 [Define if your assembler supports .register.])])
2473 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2475 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2476 [Define if your assembler supports -relax option.])])
2478 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2479 gcc_cv_as_sparc_ua_pcrel,,
2487 .uaword %r_disp32(foo)],
2488 [if test x$gcc_cv_ld != x \
2489 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2490 gcc_cv_as_sparc_ua_pcrel=yes
2493 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2494 [Define if your assembler and linker support unaligned PC relative relocs.])
2496 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2497 gcc_cv_as_sparc_ua_pcrel_hidden,,
2502 .uaword %r_disp32(foo)
2503 .byte 0x32, 0x33, 0x34
2508 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2509 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2510 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2511 | grep ' 31000000 07323334' > /dev/null 2>&1; then
2512 if $gcc_cv_objdump -R conftest 2> /dev/null \
2513 | grep 'DISP32' > /dev/null 2>&1; then
2516 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2520 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2521 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2522 ]) # unaligned pcrel relocs
2524 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2525 gcc_cv_as_sparc_offsetable_lo10,,
2528 or %g1, %lo(ab) + 12, %g1
2529 or %g1, %lo(ab + 12), %g1],
2530 [if test x$gcc_cv_objdump != x \
2531 && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2532 | grep ' 82106000 82106000' > /dev/null 2>&1; then
2533 gcc_cv_as_offsetable_lo10=yes
2535 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2536 [Define if your assembler supports offsetable %lo().])])
2540 i[34567]86-*-* | x86_64-*-*)
2542 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2543 gcc_cv_as_ix86_filds_fists,
2544 [2,9,0],, [filds mem; fists mem],,
2545 [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2546 [Define if your assembler uses the new HImode fild and fist notation.])])
2548 gcc_GAS_CHECK_FEATURE([cmov syntax],
2549 gcc_cv_as_ix86_cmov_sun_syntax,,,
2550 [cmovl.l %edx, %eax],,
2551 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2552 [Define if your assembler supports the Sun syntax for cmov.])])
2554 # This one is used unconditionally by i386.[ch]; it is to be defined
2555 # to 1 if the feature is present, 0 otherwise.
2556 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2557 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2563 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2564 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2565 [Define true if the assembler supports '.long foo@GOTOFF'.])
2569 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2570 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2572 addl r15 = @ltoffx(x#), gp
2574 ld8.mov r16 = [[r15]], x#],,
2575 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2576 [Define if your assembler supports ltoffx and ldxmov relocations.])])
2582 *-*-aix*) conftest_s=' .csect .text[[PR]]
2584 *-*-darwin*) conftest_s=' .text
2586 *) conftest_s=' .text
2590 gcc_GAS_CHECK_FEATURE([mfcr field support],
2591 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2593 [AC_DEFINE(HAVE_AS_MFCRF, 1,
2594 [Define if your assembler supports mfcr field.])])
2598 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2599 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2600 [ lw $4,%gp_rel(foo)($4)],,
2601 [if test x$target_cpu_default = x
2602 then target_cpu_default=MASK_EXPLICIT_RELOCS
2603 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2608 # ??? Not all targets support dwarf2 debug_line, even within a version
2609 # of gas. Moreover, we need to emit a valid instruction to trigger any
2610 # info to the output file. So, as supported targets are added to gas 2.11,
2611 # add some instruction here to (also) show we expect this might work.
2612 # ??? Once 2.11 is released, probably need to add first known working
2613 # version to the per-target configury.
2615 i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2616 | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2617 | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2620 ia64*-*-* | s390*-*-*)
2627 if test x"$insn" != x; then
2629 .file 1 \"conftest.s\"
2632 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2633 gcc_cv_as_dwarf2_debug_line,
2634 [elf,2,11,0],, [$conftest_s],
2635 [# ??? This fails with non-gnu grep. Maybe use objdump?
2636 if grep debug_line conftest.o > /dev/null 2>&1; then
2637 gcc_cv_as_dwarf2_debug_line=yes
2640 # The .debug_line file table must be in the exact order that
2641 # we specified the files, since these indices are also used
2642 # by DW_AT_decl_file. Approximate this test by testing if
2643 # the assembler bitches if the same index is assigned twice.
2644 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2645 gcc_cv_as_dwarf2_file_buggy,,,
2649 if test $gcc_cv_as_dwarf2_debug_line = yes \
2650 && test $gcc_cv_as_dwarf2_file_buggy = no; then
2651 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2652 [Define if your assembler supports dwarf2 .file/.loc directives,
2653 and preserves file table indices exactly as given.])
2656 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2657 gcc_cv_as_gdwarf2_flag,
2658 [elf,2,11,0], [--gdwarf2], [$insn],,
2659 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2660 [Define if your assembler supports the --gdwarf2 option.])])
2662 gcc_GAS_CHECK_FEATURE([--gstabs option],
2663 gcc_cv_as_gstabs_flag,
2664 [elf,2,11,0], [--gstabs], [$insn],
2665 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2666 # and warns about it, but still exits successfully. So check for
2668 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2670 else gcc_cv_as_gstabs_flag=yes
2672 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2673 [Define if your assembler supports the --gstabs option.])])
2676 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2677 gcc_cv_ld_ro_rw_mix=unknown
2678 if test $in_tree_ld = yes ; then
2679 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 \
2680 && test $in_tree_ld_is_elf = yes; then
2681 gcc_cv_ld_ro_rw_mix=read-write
2683 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2684 echo '.section myfoosect, "a"' > conftest1.s
2685 echo '.section myfoosect, "aw"' > conftest2.s
2686 echo '.byte 1' >> conftest2.s
2687 echo '.section myfoosect, "a"' > conftest3.s
2688 echo '.byte 0' >> conftest3.s
2689 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2690 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2691 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2692 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2693 conftest2.o conftest3.o > /dev/null 2>&1; then
2694 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2695 | sed -e '/myfoosect/!d' -e N`
2696 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2697 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2698 gcc_cv_ld_ro_rw_mix=read-only
2700 gcc_cv_ld_ro_rw_mix=read-write
2705 rm -f conftest.* conftest[123].*
2708 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2709 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2710 [Define if your linker links a mix of read-only
2711 and read-write sections into a read-write section.])
2713 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2715 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2716 gcc_cv_ld_eh_frame_hdr=no
2717 if test $in_tree_ld = yes ; then
2718 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 \
2719 && test $in_tree_ld_is_elf = yes; then
2720 gcc_cv_ld_eh_frame_hdr=yes
2722 elif test x$gcc_cv_ld != x; then
2723 # Check if linker supports --eh-frame-hdr option
2724 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2725 gcc_cv_ld_eh_frame_hdr=yes
2728 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2729 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2730 [Define if your linker supports --eh-frame-hdr option.])
2732 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2734 AC_MSG_CHECKING(linker position independent executable support)
2736 if test $in_tree_ld = yes ; then
2737 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 \
2738 && test $in_tree_ld_is_elf = yes; then
2741 elif test x$gcc_cv_ld != x; then
2742 # Check if linker supports -pie option
2743 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2747 if test x"$gcc_cv_ld_pie" = xyes; then
2748 AC_DEFINE(HAVE_LD_PIE, 1,
2749 [Define if your linker supports -pie option.])
2751 AC_MSG_RESULT($gcc_cv_ld_pie)
2757 AC_MSG_CHECKING(linker --as-needed support)
2758 gcc_cv_ld_as_needed=no
2759 if test $in_tree_ld = yes ; then
2760 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 \
2761 && test $in_tree_ld_is_elf = yes; then
2762 gcc_cv_ld_as_needed=yes
2764 elif test x$gcc_cv_ld != x; then
2765 # Check if linker supports --as-needed and --no-as-needed options
2766 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
2767 gcc_cv_ld_as_needed=yes
2770 if test x"$gcc_cv_ld_as_needed" = xyes; then
2771 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
2772 [Define if your linker supports --as-needed and --no-as-needed options.])
2774 AC_MSG_RESULT($gcc_cv_ld_as_needed)
2776 if test x$with_sysroot = x && test x$host = x$target \
2777 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2778 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2779 [Define to PREFIX/include if cpp should also search that directory.])
2782 # Find out what GC implementation we want, or may, use.
2784 [ --with-gc={page,zone} choose the garbage collection mechanism to use
2791 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2796 echo "Using $GGC for garbage collection."
2798 # Use the system's zlib library.
2800 zlibinc="-I\$(srcdir)/../zlib"
2801 AC_ARG_WITH(system-zlib,
2802 [ --with-system-zlib use installed libz],
2809 dnl Very limited version of automake's enable-maintainer-mode
2811 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2812 dnl maintainer-mode is disabled by default
2813 AC_ARG_ENABLE(maintainer-mode,
2814 [ --enable-maintainer-mode
2815 enable make rules and dependencies not useful
2816 (and sometimes confusing) to the casual installer],
2817 maintainer_mode=$enableval,
2820 AC_MSG_RESULT($maintainer_mode)
2822 if test "$maintainer_mode" = "yes"; then
2833 # Make empty files to contain the specs and options for each language.
2834 # Then add #include lines to for a compiler that has specs and/or options.
2839 for subdir in . $subdirs
2841 if test -f $srcdir/$subdir/lang.opt; then
2842 lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2844 if test -f $srcdir/$subdir/lang-specs.h; then
2845 lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2847 if test -f $srcdir/$subdir/$subdir-tree.def; then
2848 lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2852 # These (without "all_") are set in each config-lang.in.
2853 # `language' must be a single word so is spelled singularly.
2858 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2859 # List of language makefile fragments.
2861 # List of language subdirectory makefiles. Deprecated.
2863 # Files for gengtype
2864 all_gtfiles="$target_gtfiles"
2865 # Files for gengtype with language
2866 all_gtfiles_files_langs=
2867 all_gtfiles_files_files=
2869 # Add the language fragments.
2870 # Languages are added via two mechanisms. Some information must be
2871 # recorded in makefile variables, these are defined in config-lang.in.
2872 # We accumulate them and plug them into the main Makefile.
2873 # The other mechanism is a set of hooks for each of the main targets
2874 # like `clean', `install', etc.
2876 language_hooks="Make-hooks"
2886 . ${srcdir}/$s/config-lang.in
2887 if test "x$language" = x
2889 echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2892 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2893 if test -f ${srcdir}/$s/Makefile.in
2894 then all_lang_makefiles="$s/Makefile"
2896 all_languages="$all_languages $language"
2897 if test "x$boot_language" = xyes
2899 all_boot_languages="$all_boot_languages $language"
2901 all_compilers="$all_compilers $compilers"
2902 all_stagestuff="$all_stagestuff $stagestuff"
2903 all_outputs="$all_outputs $outputs"
2904 all_gtfiles="$all_gtfiles $gtfiles"
2907 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2908 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2912 # Pick up gtfiles for c
2915 . ${srcdir}/c-config-lang.in
2916 all_gtfiles="$all_gtfiles $gtfiles"
2919 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2920 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2924 for language in $all_languages
2926 check_languages="$check_languages check-$language"
2929 # We link each language in with a set of hooks, reached indirectly via
2934 target_list="all.build all.cross start.encap rest.encap tags \
2935 install-normal install-common install-man \
2936 uninstall info man srcextra srcman srcinfo \
2937 mostlyclean clean distclean maintainer-clean \
2938 stage1 stage2 stage3 stage4 stageprofile stagefeedback"
2939 for t in $target_list
2942 for lang in $all_languages
2946 echo "lang.$t: $x" >> Make-hooks
2955 echo "dir ." > .gdbinit
2956 echo "dir ${srcdir}" >> .gdbinit
2957 if test x$gdb_needs_out_file_path = xyes
2959 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2961 if test "x$subdirs" != x; then
2964 echo "dir ${srcdir}/$s" >> .gdbinit
2967 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2969 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2970 # absolute path for gcc_tooldir based on inserting the number of up-directory
2971 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2972 # $(libsubdir)/@(unlibsubdir) based path.
2973 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2974 # make and thus we'd get different behavior depending on where we built the
2976 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2977 gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
2979 changequote(<<, >>)dnl
2980 # An explanation of the sed strings:
2981 # -e 's|^\$(prefix)||' matches and eliminates 'prefix' from 'exec_prefix'
2982 # -e 's|/$||' match a trailing forward slash and eliminates it
2983 # -e 's|^[^/]|/|' forces the string to start with a forward slash (*)
2984 # -e 's|/[^/]*|../|g' replaces each occurrence of /<directory> with ../
2986 # (*) Note this pattern overwrites the first character of the string
2987 # with a forward slash if one is not already present. This is not a
2988 # problem because the exact names of the sub-directories concerned is
2989 # unimportant, just the number of them matters.
2991 # The practical upshot of these patterns is like this:
2993 # prefix exec_prefix result
2994 # ------ ----------- ------
2996 # /foo/ /foo/bar ../
2997 # /foo /foo/bar/ ../
2998 # /foo/ /foo/bar/ ../
2999 # /foo /foo/bar/ugg ../../
3002 gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
3003 changequote([, ])dnl
3005 AC_SUBST(gcc_tooldir)
3008 # Find a directory in which to install a shared libgcc.
3010 AC_ARG_ENABLE(version-specific-runtime-libs,
3011 [ --enable-version-specific-runtime-libs
3012 specify that runtime libraries should be
3013 installed in a compiler-specific directory])
3015 AC_ARG_WITH(slibdir,
3016 [ --with-slibdir=DIR shared libraries in DIR [LIBDIR]],
3017 slibdir="$with_slibdir",
3018 if test "${enable_version_specific_runtime_libs+set}" = set; then
3019 slibdir='$(libsubdir)'
3020 elif test "$host" != "$target"; then
3021 slibdir='$(build_tooldir)/lib'
3027 objdir=`${PWDCMD-pwd}`
3030 # Substitute configuration variables
3033 AC_SUBST(all_boot_languages)
3034 AC_SUBST(all_compilers)
3035 AC_SUBST(all_gtfiles)
3036 AC_SUBST(all_gtfiles_files_langs)
3037 AC_SUBST(all_gtfiles_files_files)
3038 AC_SUBST(all_lang_makefrags)
3039 AC_SUBST(all_lang_makefiles)
3040 AC_SUBST(all_languages)
3041 AC_SUBST(all_stagestuff)
3042 AC_SUBST(build_exeext)
3043 AC_SUBST(build_install_headers_dir)
3044 AC_SUBST(build_xm_file_list)
3045 AC_SUBST(build_xm_include_list)
3046 AC_SUBST(build_xm_defines)
3047 AC_SUBST(check_languages)
3048 AC_SUBST(cc_set_by_configure)
3049 AC_SUBST(quoted_cc_set_by_configure)
3050 AC_SUBST(cpp_install_dir)
3051 AC_SUBST(xmake_file)
3052 AC_SUBST(tmake_file)
3053 AC_SUBST(extra_gcc_objs)
3054 AC_SUBST(extra_headers_list)
3055 AC_SUBST(extra_objs)
3056 AC_SUBST(extra_parts)
3057 AC_SUBST(extra_passes)
3058 AC_SUBST(extra_programs)
3059 AC_SUBST(float_h_file)
3060 AC_SUBST(gcc_config_arguments)
3061 AC_SUBST(gcc_gxx_include_dir)
3062 AC_SUBST(libstdcxx_incdir)
3063 AC_SUBST(gcc_version)
3064 AC_SUBST(gcc_version_full)
3065 AC_SUBST(gcc_version_trigger)
3066 AC_SUBST(host_exeext)
3067 AC_SUBST(host_xm_file_list)
3068 AC_SUBST(host_xm_include_list)
3069 AC_SUBST(host_xm_defines)
3070 AC_SUBST(out_host_hook_obj)
3072 AC_SUBST(lang_opt_files)
3073 AC_SUBST(lang_specs_files)
3074 AC_SUBST(lang_tree_files)
3075 AC_SUBST(local_prefix)
3077 AC_SUBST(objc_boehm_gc)
3079 AC_SUBST(out_object_file)
3080 AC_SUBST(stage_prefix_set_by_configure)
3081 AC_SUBST(quoted_stage_prefix_set_by_configure)
3082 AC_SUBST(symbolic_link)
3083 AC_SUBST(thread_file)
3084 AC_SUBST(tm_file_list)
3085 AC_SUBST(tm_include_list)
3086 AC_SUBST(tm_defines)
3087 AC_SUBST(tm_p_file_list)
3088 AC_SUBST(tm_p_include_list)
3089 AC_SUBST(xm_file_list)
3090 AC_SUBST(xm_include_list)
3091 AC_SUBST(xm_defines)
3092 AC_SUBST(target_noncanonical)
3093 AC_SUBST(c_target_objs)
3094 AC_SUBST(cxx_target_objs)
3095 AC_SUBST(target_cpu_default)
3097 AC_SUBST_FILE(language_hooks)
3099 # If it doesn't already exist, create document directory
3100 echo "checking for the document directory." 1>&2
3101 if test -d doc ; then
3108 if test x${build} = x${host} ; then
3109 if test x${host} = x${target} ; then
3110 echo "Links are now set up to build a native compiler for ${target}." 1>&2
3112 echo "Links are now set up to build a cross-compiler" 1>&2
3113 echo " from ${host} to ${target}." 1>&2
3116 if test x${host} = x${target} ; then
3117 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3118 echo " for ${target}." 1>&2
3120 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3121 echo " from ${host} to ${target}." 1>&2
3125 # Configure the subdirectories
3126 # AC_CONFIG_SUBDIRS($subdirs)
3128 # Create the Makefile
3129 # and configure language subdirectories
3130 AC_CONFIG_FILES($all_outputs)
3132 AC_CONFIG_COMMANDS([default],
3134 case ${CONFIG_HEADERS} in
3135 *auto-host.h:config.in*)
3138 # Make sure all the subdirs exist.
3141 test -d $d || mkdir $d
3143 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3144 # bootstrapping and the installation procedure can still use
3145 # CC="stage1/xgcc -Bstage1/". If the host doesn't support symlinks,
3146 # FLAGS_TO_PASS has been modified to solve the problem there.
3147 # This is virtually a duplicate of what happens in configure.lang; we do
3148 # an extra check to make sure this only happens if ln -s can be used.
3149 if test "$symbolic_link" = "ln -s"; then
3150 for d in ${subdirs} fixinc ; do
3151 STARTDIR=`${PWDCMD-pwd}`
3153 for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3156 $symbolic_link ../$t $t 2>/dev/null
3163 symbolic_link='$symbolic_link'
projects / thirdparty / gcc.git / blob