configure.in (HAVE_SPARC_UA_PCREL_HIDDEN): Test whether %r_disp32() works properly...

[thirdparty/gcc.git] / gcc / configure.in

# configure.in for GCC
# Process this file with autoconf to generate a configuration script.

# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

#This file is part of GCC.

#GCC is free software; you can redistribute it and/or modify it under
#the terms of the GNU General Public License as published by the Free
#Software Foundation; either version 2, or (at your option) any later
#version.

#GCC is distributed in the hope that it will be useful, but WITHOUT
#ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
#FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
#for more details.

#You should have received a copy of the GNU General Public License
#along with GCC; see the file COPYING.  If not, write to the Free
#Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#02111-1307, USA.

# Initialization and defaults
AC_PREREQ(2.13)
AC_INIT(tree.c)
AC_CONFIG_HEADER(auto-host.h:config.in)

remove=rm
hard_link=ln
symbolic_link='ln -s'
copy=cp

# Check for bogus environment variables.
# Test if LIBRARY_PATH contains the notation for the current directory
# since this would lead to problems installing/building glibc.
# LIBRARY_PATH contains the current directory if one of the following
# is true:
# - one of the terminals (":" and ";") is the first or last sign
# - two terminals occur directly after each other
# - the path contains an element with a dot in it
AC_MSG_CHECKING(LIBRARY_PATH variable)
changequote(,)dnl
case ${LIBRARY_PATH} in
  [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
    library_path_setting="contains current directory"
    ;;
  *)
    library_path_setting="ok"
    ;;
esac
changequote([,])dnl
AC_MSG_RESULT($library_path_setting)
if test "$library_path_setting" != "ok"; then
AC_MSG_ERROR([
*** LIBRARY_PATH shouldn't contain the current directory when
*** building gcc. Please change the environment variable
*** and run configure again.])
fi

# Test if GCC_EXEC_PREFIX contains the notation for the current directory
# since this would lead to problems installing/building glibc.
# GCC_EXEC_PREFIX contains the current directory if one of the following
# is true:
# - one of the terminals (":" and ";") is the first or last sign
# - two terminals occur directly after each other
# - the path contains an element with a dot in it
AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
changequote(,)dnl
case ${GCC_EXEC_PREFIX} in
  [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
    gcc_exec_prefix_setting="contains current directory"
    ;;
  *)
    gcc_exec_prefix_setting="ok"
    ;;
esac
changequote([,])dnl
AC_MSG_RESULT($gcc_exec_prefix_setting)
if test "$gcc_exec_prefix_setting" != "ok"; then
AC_MSG_ERROR([
*** GCC_EXEC_PREFIX shouldn't contain the current directory when
*** building gcc. Please change the environment variable
*** and run configure again.])
fi

# Check for additional parameters

# With GNU ld
AC_ARG_WITH(gnu-ld,
[  --with-gnu-ld           arrange to work with GNU ld.],
gnu_ld_flag="$with_gnu_ld",
gnu_ld_flag=no)

# With pre-defined ld
AC_ARG_WITH(ld,
[  --with-ld               arrange to use the specified ld (full pathname)],
DEFAULT_LINKER="$with_ld")
if test x"${DEFAULT_LINKER+set}" = x"set"; then
  if test ! -x "$DEFAULT_LINKER"; then
    AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
  elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
    gnu_ld_flag=yes
  fi
  AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
        [Define to enable the use of a default linker.])
fi

# With GNU as
AC_ARG_WITH(gnu-as,
[  --with-gnu-as           arrange to work with GNU as],
gas_flag="$with_gnu_as",
gas_flag=no)

AC_ARG_WITH(as,
[  --with-as               arrange to use the specified as (full pathname)],
DEFAULT_ASSEMBLER="$with_as")
if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
  if test ! -x "$DEFAULT_ASSEMBLER"; then
    AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
  elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
    gas_flag=yes
  fi
  AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
        [Define to enable the use of a default assembler.])
fi

# With stabs
AC_ARG_WITH(stabs,
[  --with-stabs            arrange to use stabs instead of host debug format],
stabs="$with_stabs",
stabs=no)

# With ELF
AC_ARG_WITH(elf,
[  --with-elf              arrange to use ELF instead of host debug format],
elf="$with_elf",
elf=no)

# Specify the local prefix
local_prefix=
AC_ARG_WITH(local-prefix,
[  --with-local-prefix=DIR specifies directory to put local include],
[case "${withval}" in
yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
no)     ;;
*)      local_prefix=$with_local_prefix ;;
esac])

# Default local prefix if it is empty
if test x$local_prefix = x; then
        local_prefix=/usr/local
fi

# Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
# passed in by the toplevel make and thus we'd get different behavior
# depending on where we built the sources.
gcc_gxx_include_dir=
# Specify the g++ header file directory
AC_ARG_WITH(gxx-include-dir,
[  --with-gxx-include-dir=DIR
                          specifies directory to put g++ header files],
[case "${withval}" in
yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
no)     ;;
*)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
esac])

if test x${gcc_gxx_include_dir} = x; then
  if test x${enable_version_specific_runtime_libs} = xyes; then
    gcc_gxx_include_dir='${libsubdir}/include/g++'
  else
    topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
changequote(<<, >>)dnl
    gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
changequote([, ])dnl
  fi
fi

# Determine whether or not multilibs are enabled.
AC_ARG_ENABLE(multilib,
[  --enable-multilib       enable library support for multiple ABIs],
[], [enable_multilib=yes])
AC_SUBST(enable_multilib)

# Enable expensive internal checks
AC_ARG_ENABLE(checking,
[  --enable-checking[=LIST]
                          enable expensive run-time checks.  With LIST,
                          enable only specific categories of checks.
                          Categories are: misc,tree,rtl,gc,gcac; default
                          is misc,tree,gc],
[ac_checking=
ac_tree_checking=
ac_rtl_checking=
ac_gc_checking=
ac_gc_always_collect=
case "${enableval}" in
yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;;
no)     ;;
*)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
        set fnord $enableval; shift
        IFS="$ac_save_IFS"
        for check
        do
                case $check in
                misc)   ac_checking=1 ;;
                tree)   ac_tree_checking=1 ;;
                rtl)    ac_rtl_checking=1 ;;
                gc)     ac_gc_checking=1 ;;
                gcac)   ac_gc_always_collect=1 ;;
                *)      AC_MSG_ERROR(unknown check category $check) ;;
                esac
        done
        ;;
esac
], 
# Enable some checks by default for development versions of GCC
[ac_checking=1; ac_tree_checking=1; ac_gc_checking=1;])
if test x$ac_checking != x ; then
  AC_DEFINE(ENABLE_CHECKING, 1,
[Define if you want more run-time sanity checks.  This one gets a grab
   bag of miscellaneous but relatively cheap checks.])
fi
if test x$ac_tree_checking != x ; then
  AC_DEFINE(ENABLE_TREE_CHECKING, 1,
[Define if you want all operations on trees (the basic data
   structure of the front ends) to be checked for dynamic type safety
   at runtime.  This is moderately expensive.])
fi
if test x$ac_rtl_checking != x ; then
  AC_DEFINE(ENABLE_RTL_CHECKING, 1,
[Define if you want all operations on RTL (the basic data structure
   of the optimizer and back end) to be checked for dynamic type safety
   at runtime.  This is quite expensive.])
fi
if test x$ac_gc_checking != x ; then
  AC_DEFINE(ENABLE_GC_CHECKING, 1,
[Define if you want the garbage collector to do object poisoning and
   other memory allocation checks.  This is quite expensive.])
fi
if test x$ac_gc_always_collect != x ; then
  AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
[Define if you want the garbage collector to operate in maximally
   paranoid mode, validating the entire heap and collecting garbage at
   every opportunity.  This is extremely expensive.])
fi


AC_ARG_ENABLE(cpp,
[  --disable-cpp           don't provide a user-visible C preprocessor],
[], [enable_cpp=yes])

AC_ARG_WITH(cpp_install_dir,
[  --with-cpp-install-dir=DIR
                          install the user visible C preprocessor in DIR
                          (relative to PREFIX) as well as PREFIX/bin],
[if test x$withval = xyes; then
  AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
elif test x$withval != xno; then
  cpp_install_dir=$withval
fi])

# Enable Multibyte Characters for C/C++
AC_ARG_ENABLE(c-mbchar,
[  --enable-c-mbchar       enable multibyte characters for C and C++],
if test x$enable_c_mbchar != xno; then
  AC_DEFINE(MULTIBYTE_CHARS, 1,
  [Define if you want the C and C++ compilers to support multibyte
   character sets for source code.])
fi)
  
# Enable threads
# Pass with no value to take the default
# Pass with a value to specify a thread package
AC_ARG_ENABLE(threads,
[  --enable-threads        enable thread usage for target GCC
  --enable-threads=LIB    use LIB thread package for target GCC],,
enable_threads='')

enable_threads_flag=$enable_threads
# Check if a valid thread package
case x${enable_threads_flag} in
        x | xno)
                # No threads
                target_thread_file='single'
                ;;
        xyes)
                # default
                target_thread_file=''
                ;;
        xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
        xsolaris | xwin32 | xdce | xrtems| xvxworks | xaix)
                target_thread_file=$enable_threads_flag
                ;;
        *)
                echo "$enable_threads is an unknown thread package" 1>&2
                exit 1
                ;;
esac

AC_ARG_ENABLE(objc-gc,
[  --enable-objc-gc       enable the use of Boehm's garbage collector with
                          the GNU Objective-C runtime],
if test x$enable_objc_gc = xno; then
        objc_boehm_gc=''
else
        objc_boehm_gc=1
fi,
objc_boehm_gc='')

AC_ARG_WITH(dwarf2,
[  --with-dwarf2           force the default debug format to be DWARF 2],
dwarf2="$with_dwarf2",
dwarf2=no)

AC_ARG_ENABLE(shared,
[  --disable-shared        don't provide a shared libgcc],
[
  case $enable_shared in
  yes | no) ;;
  *)
    enable_shared=no
    IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
    for pkg in $enableval; do
      if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
        enable_shared=yes
      fi
    done
    IFS="$ac_save_ifs"
    ;;
  esac
], [enable_shared=yes])
AC_SUBST(enable_shared)

# Determine the host, build, and target systems
AC_CANONICAL_SYSTEM

# Set program_transform_name
AC_ARG_PROGRAM

# Find the native compiler
AC_PROG_CC
AC_PROG_CC_C_O
# autoconf is lame and doesn't give us any substitution variable for this.
if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
  NO_MINUS_C_MINUS_O=yes
else
  OUTPUT_OPTION='-o $@'
fi
AC_SUBST(NO_MINUS_C_MINUS_O)
AC_SUBST(OUTPUT_OPTION)

# See if GNAT has been installed
gcc_AC_PROG_GNAT

AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
ac_cv_prog_cc_no_long_long,
[save_CFLAGS="$CFLAGS"
CFLAGS="-Wno-long-long"
AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
               ac_cv_prog_cc_no_long_long=no)
CFLAGS="$save_CFLAGS"])

if test x$have_gnat != xno ; then 
AC_CACHE_CHECK(whether ${ADAC} accepts -Wno-long-long,
ac_cv_prog_adac_no_long_long,
[cat >conftest.adb <<EOF
procedure conftest is begin null; end conftest;
EOF
if $ADAC -Wno-long-long -c conftest.adb 1>&5 2>&5 ; then
  ac_cv_prog_adac_no_long_long=yes
else
  ac_cv_prog_adac_no_long_long=no
fi
rm -f conftest*])
else
  ac_cv_prog_adac_no_long_long=yes
fi

strict1_warn=
if test $ac_cv_prog_cc_no_long_long = yes && \
    test $ac_cv_prog_adac_no_long_long = yes ; then
  strict1_warn="-pedantic -Wno-long-long"
fi
AC_SUBST(strict1_warn)

AC_PROG_CPP
AC_C_INLINE
gcc_AC_C_VOLATILE

gcc_AC_C_LONG_DOUBLE
gcc_AC_C_LONG_LONG
gcc_AC_C__BOOL

# sizeof(char) is 1 by definition.
gcc_AC_COMPILE_CHECK_SIZEOF(short)
gcc_AC_COMPILE_CHECK_SIZEOF(int)
gcc_AC_COMPILE_CHECK_SIZEOF(long)
if test $ac_cv_c_long_long = yes; then
  gcc_AC_COMPILE_CHECK_SIZEOF(long long)
fi
if test $ac_cv_c___int64 = yes; then
  gcc_AC_COMPILE_CHECK_SIZEOF(__int64)
fi

gcc_AC_C_CHARSET

# If the native compiler is GCC, we can enable warnings even in stage1.  
# That's useful for people building cross-compilers, or just running a
# quick `make'.
warn_cflags=
if test "x$GCC" = "xyes"; then
  warn_cflags='$(GCC_WARN_CFLAGS)'
fi
AC_SUBST(warn_cflags)

# Stage specific cflags for build.
stage1_cflags=
case $build in
vax-*-*)
  if test x$GCC = xyes
  then
    stage1_cflags="-Wa,-J"
  else
    stage1_cflags="-J"
  fi
  ;;
powerpc-*-darwin*)
  # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
  # sources; use -no-cpp-precomp to get to GNU cpp.
  # Apple's GCC has bugs in designated initializer handling, so disable
  # that too.
  stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
  ;;
esac
AC_SUBST(stage1_cflags)

AC_PROG_MAKE_SET

AC_MSG_CHECKING([whether a default assembler was specified])
if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
    if test x"$gas_flag" = x"no"; then
        AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
    else
        AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
    fi
else
    AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING([whether a default linker was specified])
if test x"${DEFAULT_LINKER+set}" = x"set"; then
    if test x"$gnu_ld_flag" = x"no"; then
        AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
    else
        AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
    fi
else
    AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(for GNU C library)
AC_CACHE_VAL(gcc_cv_glibc,
[AC_TRY_COMPILE(
  [#include <features.h>],[
#if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
#error Not a GNU C library system
#endif], 
  [gcc_cv_glibc=yes], 
  gcc_cv_glibc=no)])
AC_MSG_RESULT($gcc_cv_glibc)
if test $gcc_cv_glibc = yes; then
  AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
fi

# Find some useful tools
AC_PROG_AWK
gcc_AC_PROG_LN
gcc_AC_PROG_LN_S
AC_PROG_RANLIB
gcc_AC_PROG_INSTALL

AC_HEADER_STDC
AC_HEADER_TIME
gcc_AC_HEADER_STDBOOL
gcc_AC_HEADER_STRING
AC_HEADER_SYS_WAIT
AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
                 fcntl.h unistd.h sys/file.h sys/time.h \
                 sys/resource.h sys/param.h sys/times.h sys/stat.h \
                 direct.h malloc.h langinfo.h)

# Check for thread headers.
AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])

# These tests can't be done till we know if we have limits.h.
gcc_AC_C_CHAR_BIT
gcc_AC_C_COMPILE_ENDIAN
gcc_AC_C_FLOAT_FORMAT

# See if we have the mktemp command.
AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)

# Do we have a single-tree copy of texinfo?
if test -f $srcdir/../texinfo/Makefile.in; then
  MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
  gcc_cv_prog_makeinfo_modern=yes
  AC_MSG_RESULT([Using makeinfo from the unified source tree.])
else
  # See if makeinfo has been installed and is modern enough
  # that we can use it.
  gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
  [GNU texinfo.* \([0-9][0-9.]*\)],
  [4.[1-9]*])
fi

if test $gcc_cv_prog_makeinfo_modern = no; then
  AC_MSG_WARN([
*** Makeinfo is missing or too old.
*** Info documentation will not be built.])
  BUILD_INFO=
else
  BUILD_INFO=info               AC_SUBST(BUILD_INFO)
fi

# Is pod2man recent enough to regenerate manpages?
AC_MSG_CHECKING([for recent Pod::Man])
if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
  AC_MSG_RESULT(yes)
  GENERATED_MANPAGES=generated-manpages         AC_SUBST(GENERATED_MANPAGES)
else
  AC_MSG_RESULT(no)
  GENERATED_MANPAGES=
fi

# How about lex?
dnl Don't use AC_PROG_LEX; we insist on flex.
dnl LEXLIB is not useful in gcc.
if test -f $srcdir/../flex/skel.c; then
  FLEX='$(objdir)/../flex/flex'
else
  AC_CHECK_PROG(FLEX, flex, flex, false)
fi

# Bison?
# The -L switch is so bison can find its skeleton file.
if test -f $srcdir/../bison/bison.simple; then
  BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
else
  AC_CHECK_PROG(BISON, bison, bison, false)
fi

# These libraries may be used by collect2.
# We may need a special search path to get them linked.
AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
[save_LIBS="$LIBS"
for libs in '' -lld -lmld \
                '-L/usr/lib/cmplrs/cc2.11 -lmld' \
                '-L/usr/lib/cmplrs/cc3.11 -lmld'
do
        LIBS="$libs"
        AC_TRY_LINK_FUNC(ldopen,
                [gcc_cv_collect2_libs="$libs"; break])
done
LIBS="$save_LIBS"
test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
case $gcc_cv_collect2_libs in
        "none required")        ;;
        *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
esac
AC_SUBST(COLLECT2_LIBS)

# When building Ada code on Alpha, we need exc_resume which is usually in
# -lexc.  So test for it.
save_LIBS="$LIBS"
LIBS=
AC_SEARCH_LIBS(exc_resume, exc)
GNAT_LIBEXC="$LIBS"
LIBS="$save_LIBS"
AC_SUBST(GNAT_LIBEXC)

# See if the stage1 system preprocessor understands the ANSI C
# preprocessor stringification operator.  (Used by symcat.h.)
AC_C_STRINGIZE

# Use <inttypes.h> only if it exists,
# doesn't clash with <sys/types.h>, and declares intmax_t.
AC_MSG_CHECKING(for inttypes.h)
AC_CACHE_VAL(gcc_cv_header_inttypes_h,
[AC_TRY_COMPILE(
  [#include <sys/types.h>
#include <inttypes.h>],
  [intmax_t i = -1;],
  [gcc_cv_header_inttypes_h=yes],
  gcc_cv_header_inttypes_h=no)])
AC_MSG_RESULT($gcc_cv_header_inttypes_h)
if test $gcc_cv_header_inttypes_h = yes; then
  AC_DEFINE(HAVE_INTTYPES_H, 1,
        [Define if you have a working <inttypes.h> header file.])
fi

dnl Disabled until we have a complete test for buggy enum bitfields.
dnl gcc_AC_C_ENUM_BF_UNSIGNED

AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
        sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
        fwrite_unlocked fprintf_unlocked getrusage nl_langinfo lstat)

AC_CHECK_TYPE(ssize_t, int)

# Try to determine the array type of the second argument of getgroups
# for the target system (int or gid_t).
AC_TYPE_GETGROUPS
if test "${target}" = "${build}"; then
  TARGET_GETGROUPS_T=$ac_cv_type_getgroups
else
  case "${target}" in
        # This condition may need some tweaking.  It should include all
        # targets where the array type of the second argument of getgroups
        # is int and the type of gid_t is not equivalent to int.
        *-*-sunos* | *-*-ultrix*)
                TARGET_GETGROUPS_T=int
                ;;
        *)
                TARGET_GETGROUPS_T=gid_t
                ;;
  esac
fi
AC_SUBST(TARGET_GETGROUPS_T)

gcc_AC_FUNC_PRINTF_PTR

case "${host}" in
*-*-uwin*)
  AC_MSG_ERROR([
*** UWIN may not be used as a host platform because
*** linking with posix.dll is not allowed by the GNU GPL])
  ;;
*-*-*vms*)
  # Under VMS, vfork works very different than on Unix. The standard test 
  # won't work, and it isn't easily adaptable. It makes more sense to
  # just force it.
  ac_cv_func_vfork_works=yes
  ;;
esac
AC_FUNC_VFORK
AC_FUNC_MMAP_ANYWHERE
AC_FUNC_MMAP_FILE

AM_ICONV

# We will need to find libiberty.h and ansidecl.h
saved_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
        strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
        fprintf_unlocked strstr errno \
        malloc realloc calloc free basename getopt clock, , ,[
#include "ansidecl.h"
#include "system.h"])

gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
#include "ansidecl.h"
#include "system.h"
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
])

gcc_AC_CHECK_DECLS(times, , ,[
#include "ansidecl.h"
#include "system.h"
#ifdef HAVE_SYS_TIMES_H
#include <sys/times.h>
#endif
])

# More time-related stuff.
AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
AC_TRY_COMPILE([
#include "ansidecl.h"
#include "system.h"
#ifdef HAVE_SYS_TIMES_H
#include <sys/times.h>
#endif
], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
if test $ac_cv_struct_tms = yes; then
  AC_DEFINE(HAVE_STRUCT_TMS, 1,
  [Define if <sys/times.h> defines struct tms.])
fi

# use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
# revisit after autoconf 2.50.
AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
AC_TRY_COMPILE([
#include "ansidecl.h"
#include "system.h"
], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
if test $gcc_cv_type_clock_t = yes; then
  AC_DEFINE(HAVE_CLOCK_T, 1,
  [Define if <time.h> defines clock_t.])
fi

# Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
CFLAGS="$saved_CFLAGS"

# mkdir takes a single argument on some systems. 
gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG

# File extensions
manext='.1'
objext='.o'
AC_SUBST(manext)
AC_SUBST(objext)

build_xm_file=
build_xm_defines=
build_install_headers_dir=install-headers-tar
build_exeext=
host_xm_file=
host_xm_defines=
host_xmake_file=
host_truncate_target=
host_exeext=

# Decode the host machine, then the target machine.
# For the host machine, we save the xm_file variable as host_xm_file;
# then we decode the target machine and forget everything else
# that came from the host machine.
for machine in $build $host $target; do
        . ${srcdir}/config.gcc
done

extra_objs="${host_extra_objs} ${extra_objs}"

# Default the target-machine variables that were not explicitly set.
if test x"$tm_file" = x
then tm_file=$cpu_type/$cpu_type.h; fi

if test x"$extra_headers" = x
then extra_headers=; fi

if test x$md_file = x
then md_file=$cpu_type/$cpu_type.md; fi

if test x$out_file = x
then out_file=$cpu_type/$cpu_type.c; fi

if test x"$tmake_file" = x
then tmake_file=$cpu_type/t-$cpu_type
fi

if test x"$dwarf2" = xyes
then tm_file="$tm_file tm-dwarf2.h"
fi

if test x$float_format = x
then float_format=i64
fi

if test $float_format = none
then float_h_file=Makefile.in
else float_h_file=float-$float_format.h
fi

# Handle cpp installation.
if test x$enable_cpp != xno
then
  tmake_file="$tmake_file t-install-cpp"
fi

# Say what files are being used for the output code and MD file.
echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
echo "Using \`$srcdir/config/$md_file' as machine description file."

# If any of the xm_file variables contain nonexistent files, warn
# about them and drop them.

bx=
for x in $build_xm_file; do
  if    test -f $srcdir/config/$x
  then      bx="$bx $x"
  else      AC_MSG_WARN($srcdir/config/$x does not exist.)
  fi
done
build_xm_file="$bx"

hx=
for x in $host_xm_file; do
  if    test -f $srcdir/config/$x
  then      hx="$hx $x"
  else      AC_MSG_WARN($srcdir/config/$x does not exist.)
  fi
done
host_xm_file="$hx"

tx=
for x in $xm_file; do
  if    test -f $srcdir/config/$x
  then      tx="$tx $x"
  else      AC_MSG_WARN($srcdir/config/$x does not exist.)
  fi
done
xm_file="$tx"

count=a
for f in $tm_file; do
        count=${count}x
done
if test $count = ax; then
        echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
else
        echo "Using the following target machine macro files:"
        for f in $tm_file; do
                echo "  $srcdir/config/$f"
        done
fi

count=a
for f in $host_xm_file; do
        count=${count}x
done
if test $count = a; then
        :
elif test $count = ax; then
        echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
else
        echo "Using the following host machine macro files:"
        for f in $host_xm_file; do
                echo "  $srcdir/config/$f"
        done
fi

if test "$host_xm_file" != "$build_xm_file"; then
        count=a
        for f in $build_xm_file; do
                count=${count}x
        done
        if test $count = a; then
                :
        elif test $count = ax; then
                echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
        else
                echo "Using the following build machine macro files:"
                for f in $build_xm_file; do
                        echo "  $srcdir/config/$f"
                done
        fi
fi

if test x$thread_file = x; then
        if test x$target_thread_file != x; then
                thread_file=$target_thread_file
        else
                thread_file='single'
        fi
fi

# auto-host.h is the file containing items generated by autoconf and is
# the first file included by config.h.
# If host=build, it is correct to have hconfig include auto-host.h
# as well.  If host!=build, we are in error and need to do more 
# work to find out the build config parameters.
if test x$host = x$build
then
        build_auto=auto-host.h
        FORBUILD=..
else
        # We create a subdir, then run autoconf in the subdir.
        # To prevent recursion we set host and build for the new
        # invocation of configure to the build for this invocation
        # of configure. 
        tempdir=build.$$
        rm -rf $tempdir
        mkdir $tempdir
        cd $tempdir
        case ${srcdir} in
        /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
        *) realsrcdir=../${srcdir};;
        esac
        saved_CFLAGS="${CFLAGS}"
        CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
        ${realsrcdir}/configure \
                --target=$target --host=$build --build=$build
        CFLAGS="${saved_CFLAGS}"

        # We just finished tests for the build machine, so rename
        # the file auto-build.h in the gcc directory.
        mv auto-host.h ../auto-build.h
        cd ..
        rm -rf $tempdir
        build_auto=auto-build.h
        FORBUILD=../$build
fi
AC_SUBST(FORBUILD)

tm_file="${tm_file} defaults.h"
host_xm_file="auto-host.h ansidecl.h ${host_xm_file} ${tm_file}"
build_xm_file="${build_auto} ansidecl.h ${build_xm_file} ${tm_file}"
xm_file="ansidecl.h ${xm_file} ${tm_file}"

# Truncate the target if necessary
if test x$host_truncate_target != x; then
        target=`echo $target | sed -e 's/\(..............\).*/\1/'`
fi

# Get the version trigger filename from the toplevel
if test "${with_gcc_version_trigger+set}" = set; then
        gcc_version_trigger=$with_gcc_version_trigger
else
        gcc_version_trigger=${srcdir}/version.c
fi
changequote(,)dnl
gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`

# Compile in configure arguments.
if test -f configargs.h ; then
        # Being re-configured.
        gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
        gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
else
        gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
fi
cat > configargs.h <<EOF
/* Generated automatically. */
static const char configuration_arguments[] = "$gcc_config_arguments";
static const char thread_model[] = "$thread_file";
EOF
changequote([,])dnl

# Internationalization
PACKAGE=gcc
VERSION="$gcc_version"
AC_SUBST(PACKAGE)
AC_SUBST(VERSION)

# Enable NLS support by default
AC_ARG_ENABLE(nls,
  [  --enable-nls            use Native Language Support (default)],
  , enable_nls=yes)

# if cross compiling, disable NLS support.
# It's not worth the trouble, at least for now.

if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
  AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
  enable_nls=no
fi

AM_GNU_GETTEXT

# Windows32 Registry support for specifying GCC installation paths.
AC_ARG_ENABLE(win32-registry,
[  --disable-win32-registry
                          disable lookup of installation paths in the
                          Registry on Windows hosts
  --enable-win32-registry enable registry lookup (default)
  --enable-win32-registry=KEY
                          use KEY instead of GCC version as the last portion
                          of the registry key],,)
case $host_os in
        win32 | pe | cygwin* | mingw32* | uwin*)
AC_MSG_CHECKING(whether windows registry support is requested)
if test "x$enable_win32_registry" != xno; then
  AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
[Define to 1 if installation paths should be looked up in Windows32
   Registry. Ignored on non windows32 hosts.])
  AC_MSG_RESULT(yes)
  AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
else
  AC_MSG_RESULT(no)
fi

# Check if user specified a different registry key.
case "x${enable_win32_registry}" in
x | xyes)
  # default.
  gcc_cv_win32_registry_key="$VERSION"
  ;;
xno)
  # no registry lookup.
  gcc_cv_win32_registry_key=''
  ;;
*)
  # user-specified key.
  gcc_cv_win32_registry_key="$enable_win32_registry"
  ;;
esac

if test "x$enable_win32_registry" != xno; then
  AC_MSG_CHECKING(registry key on windows hosts)
  AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
        [Define to be the last portion of registry key on windows hosts.])
  AC_MSG_RESULT($gcc_cv_win32_registry_key)
fi
;;
esac

# Get an absolute path to the GCC top-level source directory
holddir=`pwd`
cd $srcdir
topdir=`pwd`
cd $holddir

# Conditionalize the makefile for this host machine.
# Make-host contains the concatenation of all host makefile fragments
# [there can be more than one].  This file is built by configure.frag.
host_overrides=Make-host
dep_host_xmake_file=
for f in .. ${host_xmake_file}
do
        if test -f ${srcdir}/config/$f
        then
                dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
        fi
done

# Conditionalize the makefile for this target machine.
# Make-target contains the concatenation of all host makefile fragments
# [there can be more than one].  This file is built by configure.frag.
target_overrides=Make-target
dep_tmake_file=
for f in .. ${tmake_file}
do
        if test -f ${srcdir}/config/$f
        then
                dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
        fi
done

# If the host doesn't support symlinks, modify CC in
# FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
# Otherwise, we can use "CC=$(CC)".
rm -f symtest.tem
if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
then
        cc_set_by_configure="\$(CC)"
        quoted_cc_set_by_configure="\$(CC)"
        stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
        quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
else
        rm -f symtest.tem
        if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
        then
                symbolic_link="cp -p"
        else
                symbolic_link="cp"
        fi
        cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
        quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
        stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
        quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
fi
rm -f symtest.tem

out_object_file=`basename $out_file .c`.o

tm_file_list=
for f in $tm_file; do
  case $f in
    ansidecl.h )
       tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
    defaults.h )
       tm_file_list="${tm_file_list} $f" ;;
    *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
  esac
done

tm_p_file_list=
for f in $tm_p_file; do
    tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
done

host_xm_file_list=
for f in $host_xm_file; do
  case $f in
    ansidecl.h )
       host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
    auto-host.h | defaults.h )
       host_xm_file_list="${host_xm_file_list} $f" ;;
    *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
  esac
done

build_xm_file_list=
for f in $build_xm_file; do
  case $f in
    ansidecl.h )
       build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
    auto-build.h | auto-host.h | defaults.h )
       build_xm_file_list="${build_xm_file_list} $f" ;;
    *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
  esac
done

# Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
# Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
CROSS=                                          AC_SUBST(CROSS)
ALL=all.internal                                AC_SUBST(ALL)
SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
if test x$host != x$target
then
        CROSS="-DCROSS_COMPILE"
        ALL=all.cross
        SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
fi

# If this is a cross-compiler that does not
# have its own set of headers then define
# inhibit_libc

# If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
# This prevents libgcc2 from containing any code which requires libc
# support.
inhibit_libc=
if [test x$host != x$target] && [test x$with_headers = x]; then
       inhibit_libc=-Dinhibit_libc
else
       if [test x$with_newlib = xyes]; then
               inhibit_libc=-Dinhibit_libc
       fi
fi
AC_SUBST(inhibit_libc)

# When building gcc with a cross-compiler, we need to adjust things so
# that the generator programs are still built with the native compiler.
# Also, we cannot run fixincludes or fix-header.
# Note that the terminology here is wrong; it should be BUILD_* throughout.
# FIXME.

# These are the normal (build=host) settings:
HOST_PREFIX=                    AC_SUBST(HOST_PREFIX)
HOST_PREFIX_1=ignore-           AC_SUBST(HOST_PREFIX_1)
HOST_CC='$(CC)'                 AC_SUBST(HOST_CC)
HOST_CFLAGS='$(ALL_CFLAGS)'     AC_SUBST(HOST_CFLAGS)

STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)

# And these apply if build != host.
if test x$build != x$host
then
    HOST_PREFIX=build-
    HOST_PREFIX_1=build-
    HOST_CC='$(CC_FOR_BUILD)'
    HOST_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'

    STMP_FIXINC=
    STMP_FIXPROTO=
fi

# Expand extra_headers to include complete path.
# This substitutes for lots of t-* files.
extra_headers_list=
if test "x$extra_headers" = x
then true
else
        # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
        for file in $extra_headers;
        do
                extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
        done
fi

if test x$use_collect2 = xno; then
        use_collect2=
fi

# Add a definition of USE_COLLECT2 if system wants one.
if test x$use_collect2 != x
then
        host_xm_defines="${host_xm_defines} USE_COLLECT2"
        xm_defines="${xm_defines} USE_COLLECT2"
fi

# If we have gas in the build tree, make a link to it.
if test -f ../gas/Makefile; then
        rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
fi

# If we have nm and objdump in the build tree, make a link to them.
if test -f ../binutils/Makefile; then
        rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
        rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$host_exeext 2>/dev/null
fi

# If we have ld in the build tree, make a link to it.
if test -f ../ld/Makefile; then
        rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
fi

# Figure out what assembler we will be using.
AC_MSG_CHECKING(what assembler to use)
gcc_cv_as=
gcc_cv_gas_major_version=
gcc_cv_gas_minor_version=
gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
if test -x "$DEFAULT_ASSEMBLER"; then
        gcc_cv_as="$DEFAULT_ASSEMBLER"
elif test -x "$AS"; then
        gcc_cv_as="$AS"
elif test -x as$host_exeext; then
        # Build using assembler in the current directory.
        gcc_cv_as=./as$host_exeext
elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
        # Single tree build which includes gas.
        for f in $gcc_cv_as_bfd_srcdir/configure $gcc_cv_as_gas_srcdir/configure $gcc_cv_as_gas_srcdir/configure.in $gcc_cv_as_gas_srcdir/Makefile.in
        do
changequote(,)dnl
                gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
changequote([,])dnl
                if test x$gcc_cv_gas_version != x; then
                        break
                fi
        done
changequote(,)dnl
        gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
        gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
changequote([,])dnl
fi

if test "x$gcc_cv_as" = x -a x$build = x$host; then
        # Search the same directories that the installed compiler will
        # search.  Else we may find the wrong assembler and lose.  If we
        # do not find a suitable assembler binary, then try the user's
        # path.
        #
        # Also note we have to check MD_EXEC_PREFIX before checking the
        # user's path.  Unfortunately, there is no good way to get at the
        # value of MD_EXEC_PREFIX here.  So we do a brute force search
        # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
        # to be fixed as part of the make/configure rewrite too.

        if test "x$exec_prefix" = xNONE; then
                if test "x$prefix" = xNONE; then
                        test_prefix=/usr/local
                else
                        test_prefix=$prefix
                fi
        else
                test_prefix=$exec_prefix
        fi

        # If the loop below does not find an assembler, then use whatever
        # one we can find in the users's path.
        # user's path.
        if test "x$program_prefix" != xNONE; then
                gcc_cv_as=${program_prefix}as$host_exeext
        else
                gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
        fi

        test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
                   $test_prefix/lib/gcc-lib/$target_alias \
                   /usr/lib/gcc/$target_alias/$gcc_version \
                   /usr/lib/gcc/$target_alias \
                   $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
                   $test_prefix/$target_alias/bin"

        if test x$host = x$target; then
            test_dirs="$test_dirs \
                   /usr/libexec \
                   /usr/ccs/gcc \
                   /usr/ccs/bin \
                   /udk/usr/ccs/bin \
                   /bsd43/usr/lib/cmplrs/cc \
                   /usr/cross64/usr/bin \
                   /usr/lib/cmplrs/cc \
                   /sysv/usr/lib/cmplrs/cc \
                   /svr4/usr/lib/cmplrs/cc \
                   /usr/bin"
        fi

        for dir in $test_dirs; do
                if test -x $dir/as$host_exeext; then
                        gcc_cv_as=$dir/as$host_exeext
                        break;
                fi
        done
fi
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  AC_MSG_RESULT("newly built gas")
else
  AC_MSG_RESULT($gcc_cv_as)
fi

# Figure out what linker we will be using.
AC_MSG_CHECKING(what linker to use)
gcc_cv_ld=
gcc_cv_gld_major_version=
gcc_cv_gld_minor_version=
gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
if test -x "$DEFAULT_LINKER"; then
        gcc_cv_ld="$DEFAULT_LINKER"
elif test -x "$LD"; then
        gcc_cv_ld="$LD"
elif test -x ld$host_exeext; then
        # Build using linker in the current directory.
        gcc_cv_ld=./ld$host_exeext
elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then
        # Single tree build which includes ld.
        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
        do
changequote(,)dnl
                gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
changequote([,])dnl
                if test x$gcc_cv_gld_version != x; then
                        break
                fi
        done
changequote(,)dnl
        gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
        gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
changequote([,])dnl
fi

if test "x$gcc_cv_ld" = x -a x$build = x$host; then
        # Search the same directories that the installed compiler will
        # search.  Else we may find the wrong linker and lose.  If we
        # do not find a suitable linker binary, then try the user's
        # path.
        #
        # Also note we have to check MD_EXEC_PREFIX before checking the
        # user's path.  Unfortunately, there is no good way to get at the
        # value of MD_EXEC_PREFIX here.  So we do a brute force search
        # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
        # to be fixed as part of the make/configure rewrite too.

        if test "x$exec_prefix" = xNONE; then
                if test "x$prefix" = xNONE; then
                        test_prefix=/usr/local
                else
                        test_prefix=$prefix
                fi
        else
                test_prefix=$exec_prefix
        fi

        # If the loop below does not find an linker, then use whatever
        # one we can find in the users's path.
        # user's path.
        if test "x$program_prefix" != xNONE; then
                gcc_cv_ld=${program_prefix}ld$host_exeext
        else
                gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
        fi

        test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
                   $test_prefix/lib/gcc-lib/$target_alias \
                   /usr/lib/gcc/$target_alias/$gcc_version \
                   /usr/lib/gcc/$target_alias \
                   $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
                   $test_prefix/$target_alias/bin"

        if test x$host = x$target; then
            test_dirs="$test_dirs \
                   /usr/libexec \
                   /usr/ccs/gcc \
                   /usr/ccs/bin \
                   /udk/usr/ccs/bin \
                   /bsd43/usr/lib/cmplrs/cc \
                   /usr/cross64/usr/bin \
                   /usr/lib/cmplrs/cc \
                   /sysv/usr/lib/cmplrs/cc \
                   /svr4/usr/lib/cmplrs/cc \
                   /usr/bin"
        fi

        for dir in $test_dirs; do
                if test -x $dir/ld$host_exeext; then
                        gcc_cv_ld=$dir/ld$host_exeext
                        break;
                fi
        done
fi
if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
  AC_MSG_RESULT("newly built ld")
else
  AC_MSG_RESULT($gcc_cv_ld)
fi

# Figure out what nm we will be using.
AC_MSG_CHECKING(what nm to use)
if test -x nm$host_exeext; then
        gcc_cv_nm=./nm$host_exeext
elif test x$build = x$host; then
        if test "x$program_prefix" != xNONE; then
                gcc_cv_nm=${program_prefix}nm$host_exeext
        else
                gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
        fi
fi
AC_MSG_RESULT($gcc_cv_nm)

# Figure out what objdump we will be using.
AC_MSG_CHECKING(what objdump to use)
if test -x objdump$host_exeext; then
        gcc_cv_objdump=./objdump$host_exeext
elif test x$build = x$host; then
        if test "x$program_prefix" != xNONE; then
                gcc_cv_objdump=${program_prefix}objdump$host_exeext
        else
                gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext
        fi
fi
AC_MSG_RESULT($gcc_cv_objdump)

# Figure out what assembler alignment features are present.
AC_MSG_CHECKING(assembler alignment features)
gcc_cv_as_alignment_features=none
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
        # Gas version 2.6 and later support for .balign and .p2align.
        # bytes to skip when using .p2align.
        if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 6 -o "$gcc_cv_gas_major_version" -gt 2; then
                gcc_cv_as_alignment_features=".balign and .p2align"
                AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
        fi
        # Gas version 2.8 and later support specifying the maximum
        # bytes to skip when using .p2align.
        if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 8 -o "$gcc_cv_gas_major_version" -gt 2; then
                gcc_cv_as_alignment_features=".p2align including maximum skip"
                AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
        fi
elif test x$gcc_cv_as != x; then
        # Check if we have .balign and .p2align
        echo ".balign  4" > conftest.s
        echo ".p2align  2" >> conftest.s
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_alignment_features=".balign and .p2align"
                AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
        fi
        rm -f conftest.s conftest.o
        # Check if specifying the maximum bytes to skip when
        # using .p2align is supported.
        echo ".p2align 4,,7" > conftest.s
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_alignment_features=".p2align including maximum skip"
                AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
        fi
        rm -f conftest.s conftest.o
fi
AC_MSG_RESULT($gcc_cv_as_alignment_features)

AC_MSG_CHECKING(assembler subsection support)
gcc_cv_as_subsections=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
    gcc_cv_as_subsections="working .subsection -1"
  fi
elif test x$gcc_cv_as != x; then
        # Check if we have .subsection
        echo ".subsection 1" > conftest.s
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_subsections=".subsection"
                if test x$gcc_cv_nm != x; then
                        cat > conftest.s <<EOF
conftest_label1: .word 0
.subsection -1
conftest_label2: .word 0
.previous
EOF
                        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                                $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
                                $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
                                if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
                                        :
                                else
                                        gcc_cv_as_subsections="working .subsection -1"
                                fi
                        fi
                fi
        fi
        rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
fi
if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
        AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
[Define if your assembler supports .subsection and .subsection -1 starts
   emitting at the beginning of your section.])
fi
AC_MSG_RESULT($gcc_cv_as_subsections)

AC_MSG_CHECKING(assembler weak support)
gcc_cv_as_weak=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 2 -o "$gcc_cv_gas_major_version" -gt 2; then
    gcc_cv_as_weak="yes"
  fi
elif test x$gcc_cv_as != x; then
        # Check if we have .weak
        echo "  .weak foobar" > conftest.s
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_weak="yes"
        fi
        rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
fi
if test x"$gcc_cv_as_weak" = xyes; then
        AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
fi
AC_MSG_RESULT($gcc_cv_as_weak)

AC_MSG_CHECKING(assembler hidden support)
gcc_cv_as_hidden=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 10 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
    gcc_cv_as_hidden="yes"
  fi
elif test x$gcc_cv_as != x; then
        # Check if we have .hidden
        echo "  .hidden foobar" > conftest.s
        echo "foobar:" >> conftest.s
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_hidden="yes"
        fi
        rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
fi
if test x"$gcc_cv_as_hidden" = xyes; then
        AC_DEFINE(HAVE_GAS_HIDDEN, 1,
                [Define if your assembler supports .hidden.])
fi
AC_MSG_RESULT($gcc_cv_as_hidden)
libgcc_visibility=$gcc_cv_as_hidden
AC_SUBST(libgcc_visibility)

AC_MSG_CHECKING(assembler leb128 support)
gcc_cv_as_leb128=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 11 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
    gcc_cv_as_leb128="yes"
  fi
elif test x$gcc_cv_as != x; then
        # Check if we have .[us]leb128, and support symbol arithmetic with it.
        cat > conftest.s <<EOF
        .data
        .uleb128 L2 - L1
L1:
        .uleb128 1280
        .sleb128 -1010
L2:
EOF
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_leb128="yes"

                # GAS versions before 2.11 do not support uleb128,
                # despite appearing to.
                # ??? There exists an elf-specific test that will crash
                # the assembler.  Perhaps it's better to figure out whether
                # arbitrary sections are supported and try the test.
                as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
                if echo "$as_ver" | grep GNU > /dev/null; then
changequote(,)dnl
                        as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
                        as_major=`echo $as_ver | sed 's/\..*//'`
                        as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
changequote([,])dnl
                        if test $as_major -eq 2 -a $as_minor -lt 11; then
                                gcc_cv_as_leb128="no"
                        fi
                fi
        fi
        rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
fi
if test x"$gcc_cv_as_leb128" = xyes; then
        AC_DEFINE(HAVE_AS_LEB128, 1,
                [Define if your assembler supports .uleb128.])
fi
AC_MSG_RESULT($gcc_cv_as_leb128)

AC_MSG_CHECKING(assembler eh_frame optimization)
gcc_cv_as_eh_frame=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 12 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
    gcc_cv_as_eh_frame="yes"
  fi
elif test x$gcc_cv_as != x; then
        # Check if this is GAS.
        as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
        rm -f a.out 2> /dev/null
        if echo "$as_ver" | grep GNU > /dev/null; then
                # Versions up to and including 2.11.0 may mis-optimize
                # .eh_frame data.  Try something.
                cat > conftest.s <<EOF
        .text
.LFB1:
        .4byte  0
.L1:
        .4byte  0
.LFE1:
        .section        .eh_frame,"aw",@progbits
__FRAME_BEGIN__:
        .4byte  .LECIE1-.LSCIE1
.LSCIE1:
        .4byte  0x0
        .byte   0x1
        .ascii "z\0"
        .byte   0x1
        .byte   0x78
        .byte   0x1a
        .byte   0x0
        .byte   0x4
        .4byte  1
        .p2align 1
.LECIE1:
.LSFDE1:
        .4byte  .LEFDE1-.LASFDE1
.LASFDE1:
        .4byte  .LASFDE1-__FRAME_BEGIN__
        .4byte  .LFB1
        .4byte  .LFE1-.LFB1
        .byte   0x4
        .4byte  .LFE1-.LFB1
        .byte   0x4
        .4byte  .L1-.LFB1
.LEFDE1:
EOF
                cat > conftest.lit <<EOF
 0000 10000000 00000000 017a0001 781a0004  .........z..x...
 0010 01000000 12000000 18000000 00000000  ................
 0020 08000000 04080000 0044               .........D      
EOF
                cat > conftest.big <<EOF
 0000 00000010 00000000 017a0001 781a0004  .........z..x...
 0010 00000001 00000012 00000018 00000000  ................
 0020 00000008 04000000 0844               .........D      
EOF
                # If the assembler didn't choke, and we can objdump,
                # and we got the correct data, then succeed.
                if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
                   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
                      | tail -3 > conftest.got \
                   && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
                        || cmp conftest.big conftest.got > /dev/null 2>&1; }
                then
                        gcc_cv_as_eh_frame="yes"
                else
                        gcc_cv_as_eh_frame="bad"
                        if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
                                AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
        [Define if your assembler mis-optimizes .eh_frame data.])
                        fi
                fi
        fi
        rm -f conftest.*
fi
AC_MSG_RESULT($gcc_cv_as_eh_frame)

AC_MSG_CHECKING(assembler section merging support)
gcc_cv_as_shf_merge=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
  if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 12 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
    gcc_cv_as_shf_merge=yes
  fi
elif test x$gcc_cv_as != x; then
        # Check if we support SHF_MERGE sections
        echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
        if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_shf_merge=yes
        fi
        rm -f conftest.s conftest.o
fi
if test x"$gcc_cv_as_shf_merge" = xyes; then
        AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
[Define if your assembler supports marking sections with SHF_MERGE flag.])
fi
AC_MSG_RESULT($gcc_cv_as_shf_merge)

case "$target" in
  # All TARGET_ABI_OSF targets.
  alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
    AC_CACHE_CHECK([assembler supports explicit relocations],
        gcc_cv_as_explicit_relocs, [
        gcc_cv_as_explicit_relocs=unknown
        if test x$gcc_cv_gas_major_version != x \
                -a x$gcc_cv_gas_minor_version != x
        then
           if test "$gcc_cv_gas_major_version" -eq 2 \
                   -a "$gcc_cv_gas_minor_version" -ge 12 \
                   -o "$gcc_cv_gas_major_version" -gt 2; then
              gcc_cv_as_explicit_relocs=yes
           fi
        elif test x$gcc_cv_as != x; then
            cat > conftest.s << 'EOF'
        .set nomacro
        .text
        extbl   $3, $2, $3      !lituse_bytoff!1
        ldq     $2, a($29)      !literal!1
        ldq     $4, b($29)      !literal!2
        ldq_u   $3, 0($2)       !lituse_base!1
        ldq     $27, f($29)     !literal!5
        jsr     $26, ($27), f   !lituse_jsr!5
        ldah    $29, 0($26)     !gpdisp!3
        lda     $0, c($29)      !gprel
        ldah    $1, d($29)      !gprelhigh
        lda     $1, d($1)       !gprellow
        lda     $29, 0($29)     !gpdisp!3
EOF
            if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_explicit_relocs=yes
            else
                gcc_cv_as_explicit_relocs=no
            fi
            rm -f conftest.s conftest.o
        fi
    ])
    if test "x$gcc_cv_as_explicit_relocs" = xyes; then
        AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
                [Define if your assembler supports explicit relocations.])
    fi
    ;;
  sparc*-*-*)
    AC_CACHE_CHECK([assembler .register pseudo-op support],
        gcc_cv_as_register_pseudo_op, [
        gcc_cv_as_register_pseudo_op=unknown
        if test x$gcc_cv_as != x; then
            # Check if we have .register
            echo ".register %g2, #scratch" > conftest.s
            if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_register_pseudo_op=yes
            else
                gcc_cv_as_register_pseudo_op=no
            fi
            rm -f conftest.s conftest.o
        fi
    ])
    if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
        AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
                [Define if your assembler supports .register.])
    fi

    AC_CACHE_CHECK([assembler supports -relax],
        gcc_cv_as_relax_opt, [
        gcc_cv_as_relax_opt=unknown
        if test x$gcc_cv_as != x; then
            # Check if gas supports -relax
            echo ".text" > conftest.s
            if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
                gcc_cv_as_relax_opt=yes
            else
                gcc_cv_as_relax_opt=no
            fi
            rm -f conftest.s conftest.o
        fi
    ])
    if test "x$gcc_cv_as_relax_opt" = xyes; then
        AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
                [Define if your assembler supports -relax option.])
    fi

    AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
        gcc_cv_as_sparc_ua_pcrel, [
        gcc_cv_as_sparc_ua_pcrel=unknown
        if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
            gcc_cv_as_sparc_ua_pcrel=no
            echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
            if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
               && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
                gcc_cv_as_sparc_ua_pcrel=yes
            fi
            rm -f conftest.s conftest.o conftest
        fi
    ])
    if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
        AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
                [Define if your assembler and linker support unaligned PC relative relocs.])
    fi

    AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
        gcc_cv_as_sparc_ua_pcrel_hidden, [
        if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
            gcc_cv_as_sparc_ua_pcrel_hidden=unknown
            if test x$gcc_cv_objdump != x; then
                gcc_cv_as_sparc_ua_pcrel_hidden=no
                echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
                echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
                echo "foo: .skip 4" >> conftest.s
                if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
                   && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
                   && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
                      | grep ' 31000000 07323334' > /dev/null 2>&1; then
                    if $gcc_cv_objdump -R conftest 2> /dev/null \
                       | grep 'DISP32' > /dev/null 2>&1; then
                        :
                    else
                        gcc_cv_as_sparc_ua_pcrel_hidden=yes
                    fi
                fi
            fi
            rm -f conftest.s conftest.o conftest
        else
            gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
        fi
    ])
    if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
        AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
                [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
    fi

    case "$tm_file" in
    *64*)
        AC_CACHE_CHECK([for 64 bit support in assembler ($gcc_cv_as)],
            gcc_cv_as_flags64, [
                if test -n "$gcc_cv_as"; then
                    echo ".xword foo" > conftest.s
                    gcc_cv_as_flags64=no
                    for flag in "-xarch=v9" "-64 -Av9"; do
                        if $gcc_cv_as $flag -o conftest.o conftest.s \
                            > /dev/null 2>&1; then
                            gcc_cv_as_flags64=$flag
                            break
                        fi
                    done
                    rm -f conftest.s conftest.o
                else
                    if test "$gas" = yes; then
                        gcc_cv_as_flags64="-64 -Av9"
                    else
                        gcc_cv_as_flags64="-xarch=v9"
                    fi
                fi
        ])
        if test "x$gcc_cv_as_flags64" = xno; then
changequote(, )
            tmake_file=`echo " $tmake_file " | sed -e 's, sparc/t-sol2-64 , ,' -e 's,^ ,,' -e 's, $,,'`
            dep_tmake_file=`echo " $dep_tmake_file " | sed -e 's, [^ ]*/config/sparc/t-sol2-64 , ,' -e 's,^ ,,' -e 's, $,,'`
changequote([, ])
        else
            AC_DEFINE_UNQUOTED(AS_SPARC64_FLAG, "$gcc_cv_as_flags64",
                        [Define if the assembler supports 64bit sparc.])
        fi
        ;;
    *) gcc_cv_as_flags64=${gcc_cv_as_flags64-no}
        ;;
    esac

    if test "x$gcc_cv_as_flags64" != xno; then
        AC_CACHE_CHECK([for assembler offsetable %lo() support],
            gcc_cv_as_offsetable_lo10, [
            gcc_cv_as_offsetable_lo10=unknown
            if test "x$gcc_cv_as" != x; then
                # Check if assembler has offsetable %lo()
                echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
                echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
                if $gcc_cv_as $gcc_cv_as_flags64 -o conftest.o conftest.s \
                        > /dev/null 2>&1 &&
                   $gcc_cv_as $gcc_cv_as_flags64 -o conftest1.o conftest1.s \
                        > /dev/null 2>&1; then
                    if cmp conftest.o conftest1.o > /dev/null 2>&1; then
                        gcc_cv_as_offsetable_lo10=no
                    else
                        gcc_cv_as_offsetable_lo10=yes
                    fi
                else
                    gcc_cv_as_offsetable_lo10=no
                fi
                rm -f conftest.s conftest.o conftest1.s conftest1.o
            fi
        ])
        if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
            AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
                [Define if your assembler supports offsetable %lo().])
        fi
    fi

    ;;

changequote(,)dnl
  i[34567]86-*-* | x86_64-*-*)
changequote([,])dnl
    AC_MSG_CHECKING(assembler instructions)
    gcc_cv_as_instructions=
    if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
      if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2; then
        gcc_cv_as_instructions="filds fists"
      fi
    elif test x$gcc_cv_as != x; then
        set "filds fists" "filds mem; fists mem"
        while test $# -gt 0
        do
                echo "$2" > conftest.s
                if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
                        gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
                fi
                shift 2
        done
        rm -f conftest.s conftest.o
    fi
    if test x"$gcc_cv_as_instructions" != x; then
        AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
    fi
    AC_MSG_RESULT($gcc_cv_as_instructions)

    AC_MSG_CHECKING(assembler GOTOFF in data directives)
    gcc_cv_as_gotoff_in_data=no
    if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
    then
      if test "$gcc_cv_gas_major_version" -eq 2 \
         -a "$gcc_cv_gas_minor_version" -ge 11 \
         -o "$gcc_cv_gas_major_version" -gt 2; then
        gcc_cv_as_gotoff_in_data=yes
      fi
    elif test x$gcc_cv_as != x; then
        cat > conftest.s <<EOF
        .text
.L0:
        nop
        .data
        .long .L0@GOTOFF
EOF
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
          gcc_cv_as_gotoff_in_data=yes
        fi
    fi
    AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
      [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
      [Define true if the assembler supports '.long foo@GOTOFF'.])
    AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
    ;;
esac

AC_MSG_CHECKING(assembler dwarf2 debug_line support)
gcc_cv_as_dwarf2_debug_line=no
# ??? Not all targets support dwarf2 debug_line, even within a version
# of gas.  Moreover, we need to emit a valid instruction to trigger any
# info to the output file.  So, as supported targets are added to gas 2.11,
# add some instruction here to (also) show we expect this might work.
# ??? Once 2.11 is released, probably need to add first known working
# version to the per-target configury.
case "$target" in
  i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* | x86_64*-*-*)
    insn="nop"
    ;;
  ia64*-*-*)
    insn="nop 0"
    ;;
  esac
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
then
  if test "$gcc_cv_gas_major_version" -eq 2 \
        -a "$gcc_cv_gas_minor_version" -ge 11 \
        -o "$gcc_cv_gas_major_version" -gt 2 \
     && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
     && test x"$insn" != x ; then
    gcc_cv_as_dwarf2_debug_line="yes"
  fi
elif test x$gcc_cv_as != x -a x"$insn" != x ; then
        echo '  .file 1 "conftest.s"' > conftest.s
        echo '  .loc 1 3 0' >> conftest.s
        echo "  $insn" >> conftest.s
        # ??? This fails with non-gnu grep.
        if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
           && grep debug_line conftest.o > /dev/null 2>&1 ; then
                # The .debug_line file table must be in the exact order that
                # we specified the files, since these indices are also used
                # by DW_AT_decl_file.  Approximate this test by testing if
                # the assembler bitches if the same index is assigned twice.
                echo '  .file 1 "foo.s"' > conftest.s
                echo '  .file 1 "bar.s"' >> conftest.s
                if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
                then
                  gcc_cv_as_dwarf2_debug_line="no"
                else
                  gcc_cv_as_dwarf2_debug_line="yes"
                fi
        fi
        rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
fi
if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
        AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
[Define if your assembler supports dwarf2 .file/.loc directives,
   and preserves file table indices exactly as given.])
fi
AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)

AC_MSG_CHECKING(assembler --gdwarf2 support)
gcc_cv_as_gdwarf2_flag=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
then
  if test "$gcc_cv_gas_major_version" -eq 2 \
        -a "$gcc_cv_gas_minor_version" -ge 11 \
        -o "$gcc_cv_gas_major_version" -gt 2 \
     && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
     && test x"$insn" != x ; then
    gcc_cv_as_gdwarf2_debug_flag="yes"
  fi
elif test x$gcc_cv_as != x -a x"$insn" != x ; then
        echo '' > conftest.s
        # ??? This fails with non-gnu grep.
        if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
          then
          gcc_cv_as_gdwarf2_flag="yes"
        fi
        rm -f conftest.s conftest.o
fi
if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
        AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
[Define if your assembler supports the --gdwarf2 option.])
fi
AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)

AC_MSG_CHECKING(assembler --gstabs support)
gcc_cv_as_gstabs_flag=no
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
then
  if test "$gcc_cv_gas_major_version" -eq 2 \
        -a "$gcc_cv_gas_minor_version" -ge 11 \
        -o "$gcc_cv_gas_major_version" -gt 2 \
     && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
     && test x"$insn" != x ; then
    gcc_cv_as_gstabs_debug_flag="yes"
  fi
elif test x$gcc_cv_as != x -a x"$insn" != x ; then
        echo '' > conftest.s
        # ??? This fails with non-gnu grep.
        if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
          gcc_cv_as_gstabs_flag="yes"
        fi
        rm -f conftest.s conftest.o
fi
if test x"$gcc_cv_as_gstabs_flag" = xyes; then
        AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
[Define if your assembler supports the --gstabs option.])
fi
AC_MSG_RESULT($gcc_cv_as_gstabs_flag)

AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
gcc_cv_ld_eh_frame_hdr=no
if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
  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 && grep 'EMUL = elf' ../ld/Makefile > /dev/null; then
    gcc_cv_ld_eh_frame_hdr=yes
  fi
elif test x$gcc_cv_ld != x; then
        # Check if linker supports --eh-frame-hdr option
        if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
                gcc_cv_ld_eh_frame_hdr=yes
        fi
fi
if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
        AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
[Define if your linker supports --eh-frame-hdr option.])
fi
AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)

if test "$prefix" != "/usr" && test "$prefix" != "/usr/local" ; then
  AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
fi

# Figure out what language subdirectories are present.
# Look if the user specified --enable-languages="..."; if not, use
# the environment variable $LANGUAGES if defined. $LANGUAGES might
# go away some day.
# NB:  embedded tabs in this IF block -- do not untabify
if test x"${enable_languages+set}" != xset; then
        if test x"${LANGUAGES+set}" = xset; then
                enable_languages="${LANGUAGES}"
                AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])

        else
                enable_languages=all
        fi
else
        if test x"${enable_languages}" = x ||
           test x"${enable_languages}" = xyes;
        then
                AC_MSG_ERROR([--enable-languages needs at least one language argument])
        fi
fi
enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`

# First scan to see if an enabled language requires some other language.
# We assume that a given config-lang.in will list all the language
# front ends it requires, even if some are required indirectly.
for lang in ${srcdir}/*/config-lang.in ..
do
   case $lang in
    ..)
       ;;
    # The odd quoting in the next line works around
    # an apparent bug in bash 1.12 on linux.
changequote(,)dnl
    ${srcdir}/[*]/config-lang.in)
       ;;
    *)
       lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
       this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
       for other in $this_lang_requires
       do
          case ,${enable_languages}, in
           *,$other,*)
              ;;
           *,all,*)
              ;;
           *,$lang_alias,*)
              enable_languages="$enable_languages,$other"
              ;;
          esac
       done
       ;;
changequote([,])dnl
   esac
done

subdirs=
for lang in ${srcdir}/*/config-lang.in ..
do
        case $lang in
        ..) ;;
        # The odd quoting in the next line works around
        # an apparent bug in bash 1.12 on linux.
changequote(,)dnl
        ${srcdir}/[*]/config-lang.in) ;;
        *)
          lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
          this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
          build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
          if test "x$lang_alias" = x
          then
                echo "$lang doesn't set \$language." 1>&2
                exit 1
          fi
          case ${build_by_default},${enable_languages}, in
          *,$lang_alias,*) add_this_lang=yes ;;
          no,*) add_this_lang=no ;;
          *,all,*) add_this_lang=yes ;;
          *) add_this_lang=no ;;
          esac
          if test x"${add_this_lang}" = xyes; then
                case $lang in
                    ${srcdir}/ada/config-lang.in)
                        if test x$have_gnat = xyes ; then
                                subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
                        fi
                        ;;
                    *)
                        subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
                        ;;
                esac
          fi
          ;;
changequote([,])dnl
        esac
done

# Make gthr-default.h if we have a thread file.
gthread_flags=
if test $thread_file != single; then
    rm -f gthr-default.h
    echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
    gthread_flags=-DHAVE_GTHR_DEFAULT
fi
AC_SUBST(gthread_flags)

# Find out what GC implementation we want, or may, use.
AC_ARG_WITH(gc,
[  --with-gc={simple,page} choose the garbage collection mechanism to use
                          with the compiler],
[case "$withval" in
  simple | page)
    GGC=ggc-$withval
    ;;
  *)
    AC_MSG_ERROR([$withval is an invalid option to --with-gc])
    ;;
esac],
[GGC=ggc-page])
AC_SUBST(GGC)
echo "Using $GGC for garbage collection."

# Use the system's zlib library.
zlibdir=-L../zlib
zlibinc="-I\$(srcdir)/../zlib"
AC_ARG_WITH(system-zlib,
[  --with-system-zlib      use installed libz],
zlibdir=
zlibinc=
)
AC_SUBST(zlibdir)
AC_SUBST(zlibinc)

dnl Very limited version of automake's enable-maintainer-mode

AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
  dnl maintainer-mode is disabled by default
  AC_ARG_ENABLE(maintainer-mode,
[  --enable-maintainer-mode
                          enable make rules and dependencies not useful
                          (and sometimes confusing) to the casual installer],
      maintainer_mode=$enableval,
      maintainer_mode=no)

AC_MSG_RESULT($maintainer_mode)

if test "$maintainer_mode" = "yes"; then
  MAINT=''
else
  MAINT='#'
fi
AC_SUBST(MAINT)dnl

# With Setjmp/Longjmp based exception handling.
AC_ARG_ENABLE(sjlj-exceptions,
[  --enable-sjlj-exceptions
                          arrange to use setjmp/longjmp exception handling],
[sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
  [Define 0/1 to force the choice for exception handling model.])])

# Make empty files to contain the specs and options for each language.
# Then add #include lines to for a compiler that has specs and/or options.

lang_specs_files=
lang_options_files=
lang_tree_files=
for subdir in . $subdirs
do
        if test -f $srcdir/$subdir/lang-specs.h; then
            lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
        fi
        if test -f $srcdir/$subdir/lang-options.h; then
            lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
        fi
        if test -f $srcdir/$subdir/$subdir-tree.def; then
            lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
        fi
done

# These (without "all_") are set in each config-lang.in.
# `language' must be a single word so is spelled singularly.
all_languages=
all_boot_languages=
all_compilers=
all_stagestuff=
all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc'
# List of language makefile fragments.
all_lang_makefiles=

# Add the language fragments.
# Languages are added via two mechanisms.  Some information must be
# recorded in makefile variables, these are defined in config-lang.in.
# We accumulate them and plug them into the main Makefile.
# The other mechanism is a set of hooks for each of the main targets
# like `clean', `install', etc.

language_fragments="Make-lang"
language_hooks="Make-hooks"

for s in .. $subdirs
do
        if test $s != ".."
        then
                language=
                boot_language=
                compilers=
                stagestuff=
                outputs=
                . ${srcdir}/$s/config-lang.in
                if test "x$language" = x
                then
                        echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
                        exit 1
                fi
                all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
                if test -f ${srcdir}/$s/Makefile.in
                then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
                fi
                all_languages="$all_languages $language"
                if test "x$boot_language" = xyes
                then
                        all_boot_languages="$all_boot_languages $language"
                fi
                all_compilers="$all_compilers $compilers"
                all_stagestuff="$all_stagestuff $stagestuff"
                all_outputs="$all_outputs $outputs"
        fi
done

check_languages=
for language in .. $all_languages
do
        if test $language != ".."
        then
                check_languages="$check_languages check-$language"
        fi
done

# Since we can't use `::' targets, we link each language in
# with a set of hooks, reached indirectly via lang.${target}.

rm -f Make-hooks
touch Make-hooks
target_list="all.build all.cross start.encap rest.encap \
        info dvi generated-manpages \
        install-normal install-common install-info install-man \
        uninstall \
        mostlyclean clean distclean extraclean maintainer-clean \
        stage1 stage2 stage3 stage4"
for t in $target_list
do
        x=
        for lang in .. $all_languages
        do
                if test $lang != ".."; then
                        x="$x $lang.$t"
                fi
        done
        echo "lang.$t: $x" >> Make-hooks
done

# Create .gdbinit.

echo "dir ." > .gdbinit
echo "dir ${srcdir}" >> .gdbinit
if test x$gdb_needs_out_file_path = xyes
then
        echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
fi
if test "x$subdirs" != x; then
        for s in $subdirs
        do
                echo "dir ${srcdir}/$s" >> .gdbinit
        done
fi
echo "source ${srcdir}/gdbinit.in" >> .gdbinit

# Define variables host_canonical and build_canonical
# because some Cygnus local changes in the Makefile depend on them.
build_canonical=${build}
host_canonical=${host}
target_subdir=
if test "${host}" != "${target}" ; then
    target_subdir=${target_alias}/
fi
AC_SUBST(build_canonical)
AC_SUBST(host_canonical)
AC_SUBST(target_subdir)
        
# If $(exec_prefix) exists and is not the same as $(prefix), then compute an
# absolute path for gcc_tooldir based on inserting the number of up-directory
# movements required to get from $(exec_prefix) to $(prefix) into the basic
# $(libsubdir)/@(unlibsubdir) based path.
# Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
# make and thus we'd get different behavior depending on where we built the
# sources.
if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
    gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
else
changequote(<<, >>)dnl
# An explanation of the sed strings:
#  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
#  -e 's|/$||'            match a trailing forward slash and eliminates it
#  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
#  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
#
# (*) Note this pattern overwrites the first character of the string
# with a forward slash if one is not already present.  This is not a
# problem because the exact names of the sub-directories concerned is
# unimportant, just the number of them matters.
#
# The practical upshot of these patterns is like this:
#
#  prefix     exec_prefix        result
#  ------     -----------        ------
#   /foo        /foo/bar          ../
#   /foo/       /foo/bar          ../
#   /foo        /foo/bar/         ../
#   /foo/       /foo/bar/         ../
#   /foo        /foo/bar/ugg      ../../
#
    dollar='$$'
    gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
changequote([, ])dnl
fi
AC_SUBST(gcc_tooldir)
AC_SUBST(dollar)

# Find a directory in which to install a shared libgcc.

AC_ARG_ENABLE(version-specific-runtime-libs,
[  --enable-version-specific-runtime-libs
                          specify that runtime libraries should be
                          installed in a compiler-specific directory])

AC_ARG_WITH(slibdir,
[  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
slibdir="$with_slibdir",
if test "${enable_version_specific_runtime_libs+set}" = set; then
  slibdir='$(libsubdir)'
elif test "$host" != "$target"; then
  slibdir='$(build_tooldir)/lib'
else
  slibdir='$(libdir)'
fi)
AC_SUBST(slibdir)

# Nothing to do for FLOAT_H, float_format already handled.
objdir=`pwd`
AC_SUBST(objdir)

# Process the language and host/target makefile fragments.
${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"

# Substitute configuration variables
AC_SUBST(subdirs)
AC_SUBST(all_boot_languages)
AC_SUBST(all_compilers)
AC_SUBST(all_lang_makefiles)
AC_SUBST(all_languages)
AC_SUBST(all_stagestuff)
AC_SUBST(build_exeext)
AC_SUBST(build_install_headers_dir)
AC_SUBST(build_xm_file_list)
AC_SUBST(build_xm_file)
AC_SUBST(build_xm_defines)
AC_SUBST(check_languages)
AC_SUBST(cc_set_by_configure)
AC_SUBST(quoted_cc_set_by_configure)
AC_SUBST(cpp_install_dir)
AC_SUBST(dep_host_xmake_file)
AC_SUBST(dep_tmake_file)
AC_SUBST(extra_headers_list)
AC_SUBST(extra_objs)
AC_SUBST(extra_parts)
AC_SUBST(extra_passes)
AC_SUBST(extra_programs)
AC_SUBST(float_h_file)
AC_SUBST(gcc_config_arguments)
AC_SUBST(gcc_gxx_include_dir)
AC_SUBST(libstdcxx_incdir)
AC_SUBST(gcc_version)
AC_SUBST(gcc_version_full)
AC_SUBST(gcc_version_trigger)
AC_SUBST(host_exeext)
AC_SUBST(host_extra_gcc_objs)
AC_SUBST(host_xm_file_list)
AC_SUBST(host_xm_file)
AC_SUBST(host_xm_defines)
AC_SUBST(install)
AC_SUBST(lang_options_files)
AC_SUBST(lang_specs_files)
AC_SUBST(lang_tree_files)
AC_SUBST(local_prefix)
AC_SUBST(md_file)
AC_SUBST(objc_boehm_gc)
AC_SUBST(out_file)
AC_SUBST(out_object_file)
AC_SUBST(stage_prefix_set_by_configure)
AC_SUBST(quoted_stage_prefix_set_by_configure)
AC_SUBST(symbolic_link)
AC_SUBST(thread_file)
AC_SUBST(tm_file_list)
AC_SUBST(tm_file)
AC_SUBST(tm_p_file_list)
AC_SUBST(tm_p_file)
AC_SUBST(xm_file)
AC_SUBST(xm_defines)
AC_SUBST(target_alias)
AC_SUBST(c_target_objs)
AC_SUBST(cxx_target_objs)
AC_SUBST(target_cpu_default)

AC_SUBST_FILE(target_overrides)
AC_SUBST_FILE(host_overrides)
AC_SUBST_FILE(language_fragments)
AC_SUBST_FILE(language_hooks)

# Echo that links are built
if test x$host = x$target
then
        str1="native "
else
        str1="cross-"
        str2=" from $host"
fi

if test x$host != x$build
then
        str3=" on a $build system"
fi

if test "x$str2" != x || test "x$str3" != x
then
        str4=
fi

echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2

if test "x$str2" != x || test "x$str3" != x
then
        echo " ${str2}${str3}." 1>&2
fi

# Truncate the target if necessary
if test x$host_truncate_target != x; then
        target=`echo $target | sed -e 's/\(..............\).*/\1/'`
fi

# Configure the subdirectories
# AC_CONFIG_SUBDIRS($subdirs)

# Create the Makefile
# and configure language subdirectories
AC_OUTPUT($all_outputs,
[
case x$CONFIG_HEADERS in
xauto-host.h:config.in)
echo > cstamp-h ;;
esac
# If the host supports symlinks, point stage[1234] at ../stage[1234] so
# bootstrapping and the installation procedure can still use
# CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
# FLAGS_TO_PASS has been modified to solve the problem there.
# This is virtually a duplicate of what happens in configure.lang; we do
# an extra check to make sure this only happens if ln -s can be used.
if test "$symbolic_link" = "ln -s"; then
 for d in .. ${subdirs} fixinc ; do
   if test $d != ..; then
        STARTDIR=`pwd`
        cd $d
        for t in stage1 stage2 stage3 stage4 include
        do
                rm -f $t
                $symbolic_link ../$t $t 2>/dev/null
        done
        cd $STARTDIR
   fi
 done
else true ; fi
# Avoid having to add intl to our include paths.
if test -f intl/libintl.h; then
  echo creating libintl.h
  echo '#include "intl/libintl.h"' >libintl.h
fi
], 
[subdirs='$subdirs'
symbolic_link='$symbolic_link'
])