m68k-coff removed libgloss to fix a multiple definition of crt0

[gcc.git] / gcc / configure.in

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

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

#This file is part of GNU CC.

#GNU CC 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.

#GNU CC 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 GNU CC; 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/g++"-${libstdcxx_interface}
changequote([, ])dnl
  fi
fi

# 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])

# Link cpplib into the compiler proper, for C/C++/ObjC.
AC_ARG_ENABLE(c-cpplib,
[  --enable-c-cpplib       link cpplib directly into C and C++ compilers
                           (HIGHLY EXPERIMENTAL).],
if test x$enable_c_cpplib != xno; then
  extra_c_objs="${extra_c_objs} libcpp.a"
  extra_cxx_objs="${extra_cxx_objs} ../libcpp.a"
  AC_DEFINE(USE_CPPLIB, 1,
  [Define if you want the preprocessor merged into the C and C++ compilers.
   This mode is not ready for production use.])
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 | 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 DWARF2.],
dwarf2="$with_dwarf2",
dwarf2=no)

AC_ARG_ENABLE(shared,
[  --disable-shared       don't provide a shared libgcc.],
[], [enable_shared=yes])
AC_SUBST(enable_shared)

# Determine the host, build, and target systems
AC_CANONICAL_SYSTEM

# Find the native compiler
AC_PROG_CC
AC_PROG_CC_C_O
if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
  NO_MINUS_C_MINUS_O=yes
fi
AC_SUBST(NO_MINUS_C_MINUS_O)

gcc_AC_C_LONG_DOUBLE

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 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'.
stage1_warn_cflags=" -W -Wall -Wtraditional -Wwrite-strings -Wstrict-prototypes -Wmissing-prototypes"
stage2_warn_cflags="$stage1_warn_cflags -pedantic -Wno-long-long"
if test "x$GCC" = "xyes"; then 
  if test $ac_cv_prog_cc_no_long_long = yes; then
    stage1_warn_cflags="$stage1_warn_cflags -pedantic -Wno-long-long"
  fi
else
  stage1_warn_cflags=""
fi

# Stage specific cflags for build.
case $build in
vax-*-*)
  if test x$GCC = xyes
  then
    stage1_warn_cflags="$stage1_warn_cflags -Wa,-J"
  else
    stage1_warn_cflags="$stage1_warn_cflags -J"
  fi
  ;;
esac

AC_SUBST(stage1_warn_cflags)
AC_SUBST(stage2_warn_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

AC_C_INLINE

# Find some useful tools
AC_PROG_AWK
AC_PROG_LEX
gcc_AC_PROG_LN
gcc_AC_PROG_LN_S
gcc_AC_C_VOLATILE
AC_PROG_RANLIB
AC_PROG_YACC
gcc_AC_PROG_INSTALL

AC_HEADER_STDC
AC_HEADER_TIME
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 stab.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 iconv.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=])

# See if GNAT has been installed
AC_CHECK_PROG(gnat, gnatbind, 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.]*\)],
  [3.1[2-9] | 3.[2-9][0-9] | 4.* | 1.6[89] | 1.7[0-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 or installed.])
  BUILD_INFO=
  INSTALL_INFO=
else
  BUILD_INFO=info               AC_SUBST(BUILD_INFO)
  INSTALL_INFO=install-info     AC_SUBST(INSTALL_INFO)
fi

# See if the stage1 system preprocessor understands the ANSI C
# preprocessor stringification operator.
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

#
# Determine if enumerated bitfields are unsigned.   ISO C says they can 
# be either signed or unsigned.
#
AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
[AC_TRY_RUN(#include <stdlib.h>
enum t { BLAH = 128 } ;
struct s_t { enum t member : 8; } s ;
int main(void)
{            
        s.member = BLAH;
        if (s.member < 0) exit(1);
        exit(0);

}, gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
if test $gcc_cv_enum_bf_unsigned = yes; then
  AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
    [Define if enumerated bitfields are treated as unsigned values.])
fi

AC_CHECK_FUNCS(strtoul bsearch putenv popen bcopy bzero bcmp \
        index rindex strchr strrchr kill getrlimit setrlimit atoll atoq \
        sysconf isascii gettimeofday strsignal putc_unlocked fputc_unlocked \
        fputs_unlocked getrusage valloc iconv nl_langinfo)

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_VFPRINTF_DOPRNT
gcc_AC_FUNC_PRINTF_PTR

case "${host}" in
*-*-uwin*)
  # Under some versions of uwin, vfork is notoriously buggy and the test 
  # can hang configure; on other versions, vfork exists just as a stub.
  # FIXME: This should be removed once vfork in uwin's runtime is fixed.
  ac_cv_func_vfork_works=no
  ;;
esac
AC_FUNC_VFORK
AC_FUNC_MMAP_ANYWHERE
AC_FUNC_MMAP_FILE

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

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

# 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

        out_file=
        xmake_file=
        tmake_file=
        extra_headers=
        extra_passes=
        extra_parts=
        extra_programs=
        extra_objs=
        extra_host_objs=
        extra_gcc_objs=
        xm_defines=
        float_format=
        # Set this to force installation and use of collect2.
        use_collect2=
        # Set this to override the default target model.
        target_cpu_default=
        # Set this to control how the header file directory is installed.
        install_headers_dir=install-headers-tar
        # Set this to a non-empty list of args to pass to cpp if the target
        # wants its .md file passed through cpp.
        md_cppflags=
        # Set this if directory names should be truncated to 14 characters.
        truncate_target=
        # Set this if gdb needs a dir command with `dirname $out_file`
        gdb_needs_out_file_path=
        # Set this if the build machine requires executables to have a
        # file name suffix.
        exeext=
        # Set this to control which thread package will be used.
        thread_file=
        # Reinitialize these from the flag values every loop pass, since some
        # configure entries modify them.
        gas="$gas_flag"
        gnu_ld="$gnu_ld_flag"
        enable_threads=$enable_threads_flag

        # Set default cpu_type, tm_file, tm_p_file and xm_file so it can be
        # updated in each machine entry.
        tm_p_file=
        cpu_type=`echo $machine | sed 's/-.*$//'`
        case $machine in
        alpha*-*-*)
                cpu_type=alpha
                ;;
        strongarm*-*-*)
                cpu_type=arm
                ;;
        arm*-*-*)
                cpu_type=arm
                ;;
        c*-convex-*)
                cpu_type=convex
                ;;
changequote(,)dnl
        i[34567]86-*-*)
changequote([,])dnl
                cpu_type=i386
                ;;
        hppa*-*-*)
                cpu_type=pa
                ;;
        m68000-*-*)
                cpu_type=m68k
                ;;
        mips*-*-*)
                cpu_type=mips
                ;;
        pj*-*-*)
                cpu_type=pj
                ;;
        powerpc*-*-*)
                cpu_type=rs6000
                ;;
        pyramid-*-*)
                cpu_type=pyr
                ;;
        sparc*-*-*)
                cpu_type=sparc
                ;;
        esac

        tm_file=${cpu_type}/${cpu_type}.h
        xm_file=${cpu_type}/xm-${cpu_type}.h
        if test -f ${srcdir}/config/${cpu_type}/${cpu_type}-protos.h;
        then
                tm_p_file=${cpu_type}/${cpu_type}-protos.h;
        fi
        # On a.out targets, we need to use collect2.
        case $machine in
        *-*-*aout*)
                use_collect2=yes
                ;;
        esac    

        # Common parts for linux and openbsd systems
        case $machine in
        *-*-linux*)
                xm_defines="HAVE_ATEXIT POSIX BSTRING"
                ;;
        *-*-openbsd*)
                tm_file=${cpu_type}/openbsd.h
                tmake_file="t-libc-ok t-openbsd"
                # avoid surprises, always provide an xm-openbsd file 
                xm_file=${cpu_type}/xm-openbsd.h
                # don't depend on processor x-fragments as well
                xmake_file=none
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                        tmake_file="${tmake_file} t-openbsd-thread"
                fi
                ;;
        esac

        case $machine in
        # Support site-specific machine types.
        *local*)
                cpu_type=`echo $machine | sed -e 's/-.*//'`
                rest=`echo $machine | sed -e "s/$cpu_type-//"`
                xm_file=${cpu_type}/xm-$rest.h
                tm_file=${cpu_type}/$rest.h
                if test -f $srcdir/config/${cpu_type}/x-$rest; \
                then xmake_file=${cpu_type}/x-$rest; \
                else true; \
                fi
                if test -f $srcdir/config/${cpu_type}/t-$rest; \
                then tmake_file=${cpu_type}/t-$rest; \
                else true; \
                fi
                ;;
        1750a-*-*)
                ;;
        a29k-*-bsd* | a29k-*-sym1*)
                tm_file="${tm_file} a29k/unix.h"
                xm_defines=USG
                xmake_file=a29k/x-unix
                use_collect2=yes
                ;;
        a29k-*-udi | a29k-*-coff)
                tm_file="${tm_file} dbxcoff.h a29k/udi.h"
                tmake_file=a29k/t-a29kbare
                ;;
        a29k-wrs-vxworks*)
                tm_file="${tm_file} dbxcoff.h a29k/udi.h a29k/vx29k.h"
                tmake_file=a29k/t-vx29k
                extra_parts="crtbegin.o crtend.o"
                thread_file='vxworks'
                ;;
        a29k-*-*)                       # Default a29k environment.
                use_collect2=yes
                ;;
        alpha-*-interix)
                tm_file="${tm_file} alpha/alpha32.h interix.h alpha/alpha-interix.h"

                # GAS + IEEE_CONFORMANT+IEEE (no inexact);
                #target_cpu_default="MASK_GAS|MASK_IEEE_CONFORMANT|MASK_IEEE"

                # GAS + IEEE_CONFORMANT
                target_cpu_default="MASK_GAS|MASK_IEEE_CONFORMANT"

                xm_file="alpha/xm-alpha-interix.h xm-interix.h"
                xmake_file="x-interix alpha/t-pe"
                tmake_file="alpha/t-alpha alpha/t-interix alpha/t-ieee"
                if test x$enable_threads = xyes ; then
                        thread_file='posix'
                fi
                if test x$stabs = xyes ; then
                        tm_file="${tm_file} dbxcoff.h"
                fi
                #prefix='$$INTERIX_ROOT'/usr/contrib
                #local_prefix='$$INTERIX_ROOT'/usr/contrib
                ;;
        alpha*-*-linux*ecoff*)
                tm_file="${tm_file} alpha/linux-ecoff.h alpha/linux.h"
                target_cpu_default="MASK_GAS"
                tmake_file="alpha/t-alpha alpha/t-ieee"
                gas=no
                xmake_file=none
                gas=yes gnu_ld=yes
                ;;
        alpha*-*-linux*libc1*)
                tm_file="${tm_file} alpha/elf.h alpha/linux.h alpha/linux-elf.h"
                target_cpu_default="MASK_GAS"
                tmake_file="t-linux t-linux-gnulibc1 alpha/t-alpha alpha/t-crtbe alpha/t-ieee"
                extra_parts="crtbegin.o crtend.o crtbeginS.o crtendS.o"
                xmake_file=none
                gas=yes gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        alpha*-*-linux*)
                tm_file="${tm_file} alpha/elf.h alpha/linux.h alpha/linux-elf.h"
                target_cpu_default="MASK_GAS"
                tmake_file="t-linux alpha/t-crtbe alpha/t-alpha alpha/t-ieee"
                extra_parts="crtbegin.o crtend.o crtbeginS.o crtendS.o"
                xmake_file=none
                gas=yes gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        alpha*-*-netbsd*)
                tm_file="${tm_file} alpha/elf.h alpha/netbsd.h alpha/netbsd-elf.h"
                target_cpu_default="MASK_GAS"
                tmake_file="alpha/t-crtbe alpha/t-alpha alpha/t-ieee"
                extra_parts="crtbegin.o crtend.o crtbeginS.o crtendS.o"
                xmake_file=none
                gas=yes gnu_ld=yes
                ;;

        alpha*-*-openbsd*)
                # default x-alpha is only appropriate for dec-osf.
                target_cpu_default="MASK_GAS"
                tmake_file="alpha/t-alpha alpha/t-ieee"
                ;;
                
        alpha*-dec-osf*)
                if test x$stabs = xyes
                then
                        tm_file="${tm_file} dbx.h"
                fi
                if test x$gas != xyes
                then
                        extra_passes="mips-tfile mips-tdump"
                fi
                use_collect2=yes
                tmake_file="alpha/t-alpha alpha/t-ieee alpha/t-osf"
                xmake_file=alpha/x-osf
                case $machine in
                  *-*-osf1*)
                    tm_file="${tm_file} alpha/osf.h alpha/osf12.h alpha/osf2or3.h"
                    ;;
changequote(,)dnl
                  *-*-osf[23]*)
changequote([,])dnl
                    tm_file="${tm_file} alpha/osf.h alpha/osf2or3.h"
                    ;;
                  *-*-osf4*)
                    tm_file="${tm_file} alpha/osf.h"
                    tmake_file="$tmake_file alpha/t-osf4"
                    # Some versions of OSF4 (specifically X4.0-9 296.7) have
                    # a broken tar, so we use cpio instead.
                    install_headers_dir=install-headers-cpio
                    ;;
                  *-*-osf5*)
                    tm_file="${tm_file} alpha/osf.h alpha/osf5.h"
                    tmake_file="$tmake_file alpha/t-osf4"
                    ;;
                esac
                case $machine in
changequote(,)dnl
                  *-*-osf4.0[b-z] | *-*-osf4.[1-9]* | *-*-osf5*)
changequote([,])dnl
                    target_cpu_default=MASK_SUPPORT_ARCH
                    ;;
                esac
                ;;
        alpha*-*-vxworks*)
                tm_file="${tm_file} dbx.h alpha/vxworks.h"
                tmake_file="alpha/t-alpha alpha/t-ieee"
                if [ x$gas != xyes ]
                then
                        extra_passes="mips-tfile mips-tdump"
                fi
                use_collect2=yes
                thread_file='vxworks'
                ;;
        alpha*-*-winnt*)
                tm_file="${tm_file} alpha/alpha32.h alpha/win-nt.h winnt/win-nt.h"
                xm_file="${xm_file} config/winnt/xm-winnt.h alpha/xm-winnt.h"
                tmake_file="t-libc-ok alpha/t-alpha alpha/t-ieee"
                xmake_file=winnt/x-winnt
                extra_host_objs=oldnames.o
                extra_gcc_objs="spawnv.o oldnames.o"
                if test x$gnu_ld != xyes
                then
                        extra_programs=ld.exe
                fi
                if test x$enable_threads = xyes; then
                        thread_file='win32'
                fi
                ;;
        alpha*-dec-vms*)
                tm_file=alpha/vms.h
                xm_file="${xm_file} alpha/xm-vms.h"
                tmake_file="alpha/t-alpha alpha/t-vms alpha/t-ieee"
                ;;
        arc-*-elf*)
                extra_parts="crtinit.o crtfini.o"
                ;;
        arm-*-coff* | armel-*-coff*)
                tm_file=arm/coff.h
                tmake_file=arm/t-arm-coff
                ;;
        arm-*-vxworks*)
                tm_file=arm/vxarm.h
                tmake_file=arm/t-arm-coff
                thread_file='vxworks'
                ;;
changequote(,)dnl
        arm-*-riscix1.[01]*)            # Acorn RISC machine (early versions)
changequote([,])dnl
                tm_file=arm/riscix1-1.h
                use_collect2=yes
                ;;
        arm-*-riscix*)                  # Acorn RISC machine
                if test x$gas = xyes
                then
                    tm_file=arm/rix-gas.h
                else
                    tm_file=arm/riscix.h
                fi
                xmake_file=arm/x-riscix
                tmake_file=arm/t-riscix
                use_collect2=yes
                ;;
        arm-semi-aout | armel-semi-aout)
                tm_file=arm/semi.h
                tmake_file=arm/t-semi
                ;;
        arm-semi-aof | armel-semi-aof)
                tm_file=arm/semiaof.h
                tmake_file=arm/t-semiaof
                ;;
        arm*-*-netbsd*)
                tm_file=arm/netbsd.h
                tmake_file="t-netbsd arm/t-netbsd"
                use_collect2=yes
                ;;
        arm*-*-linux*aout*)             # ARM GNU/Linux with a.out
                cpu_type=arm
                xmake_file=x-linux
                tm_file=arm/linux-aout.h
                tmake_file=arm/t-linux
                gnu_ld=yes
                ;;
        arm*-*-linux*oldld*)            # ARM GNU/Linux with old ELF linker
                xm_file=arm/xm-linux.h
                xmake_file=x-linux
                tm_file="arm/linux-oldld.h arm/linux-elf.h"
                case $machine in
                armv2*-*-*)
                        tm_file="arm/linux-elf26.h $tm_file"
                        ;;
                esac
                tmake_file="t-linux arm/t-linux"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                case x${enable_threads} in
                x | xyes | xpthreads | xposix)
                        thread_file='posix'
                        ;;
                esac
                ;;
        arm*-*-linux*)          # ARM GNU/Linux with ELF
                xm_file=arm/xm-linux.h
                xmake_file=x-linux
                tm_file="arm/linux-elf.h"
                case $machine in
                armv2*-*-*)
                        tm_file="arm/linux-elf26.h $tm_file"
                        ;;
                esac
                tmake_file="t-linux arm/t-linux"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                case x${enable_threads} in
                x | xyes | xpthreads | xposix)
                        thread_file='posix'
                        ;;
                esac
                ;;
        arm*-*-uclinux*)                # ARM ucLinux
                tm_file=arm/uclinux-elf.h
                tmake_file=arm/t-arm-elf
                ;;
        arm*-*-aout)
                tm_file=arm/aout.h
                tmake_file=arm/t-arm-aout
                ;;
        arm*-*-ecos-elf)
                tm_file=arm/ecos-elf.h
                tmake_file=arm/t-arm-elf
                ;; 
        arm*-*-elf)
                tm_file=arm/unknown-elf.h
                tmake_file=arm/t-arm-elf
                ;;
        arm*-*-conix*)
                tm_file=arm/conix-elf.h
                tmake_file=arm/t-arm-elf
                ;;
        arm*-*-oabi)
                tm_file=arm/unknown-elf-oabi.h
                tmake_file=arm/t-arm-elf
                ;;
        arm-*-pe*)
                tm_file=arm/pe.h
                tmake_file=arm/t-pe
                extra_objs="pe.o"
                ;;
        avr-*-*)
                ;;
        c1-convex-*)                    # Convex C1
                target_cpu_default=1
                use_collect2=yes
                ;;
        c2-convex-*)                    # Convex C2
                target_cpu_default=2
                use_collect2=yes
                ;;
        c32-convex-*)
                target_cpu_default=4
                use_collect2=yes
                ;;
        c34-convex-*)
                target_cpu_default=8
                use_collect2=yes
                ;;
        c38-convex-*)
                target_cpu_default=16           
                use_collect2=yes
                ;;
        c4x-*)
                cpu_type=c4x
                float_format=c4x
                tmake_file=c4x/t-c4x
                ;;
        clipper-intergraph-clix*)
                tm_file="${tm_file} svr3.h clipper/clix.h"
                xm_file=clipper/xm-clix.h
                xmake_file=clipper/x-clix
                extra_headers=va-clipper.h
                extra_parts="crtbegin.o crtend.o"
                install_headers_dir=install-headers-cpio
                ;;
        d30v-*)
                float_format=i64
                ;;
        dsp16xx-*)
                ;;
        elxsi-elxsi-*)
                use_collect2=yes
                ;;
        fr30-*-elf)
                tm_file="fr30/fr30.h"
                tmake_file=fr30/t-fr30
                extra_parts="crti.o crtn.o crtbegin.o crtend.o"
                ;;
        h8300-*-*)
                float_format=i32
                ;;
        hppa*-*-linux*)
                target_cpu_default="(MASK_PA_11 | MASK_GAS | MASK_JUMP_IN_DELAY)"
                tm_file="${tm_file} pa/elf.h linux.h pa/pa-linux.h"
                tmake_file="t-linux pa/t-linux"
                extra_parts="crtbegin.o crtend.o"
                xmake_file=none
                gas=yes gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        hppa*-*-openbsd*)
                target_cpu_default="MASK_PA_11"
                tmake_file=pa/t-openbsd
                ;;
        hppa1.1-*-pro*)
                target_cpu_default="(MASK_JUMP_IN_DELAY | MASK_PORTABLE_RUNTIME | MASK_GAS | MASK_NO_SPACE_REGS | MASK_SOFT_FLOAT)"
                tm_file="${tm_file} pa/pa32-regs.h elfos.h pa/elf.h pa/pa-pro-end.h libgloss.h"
                xm_file=pa/xm-papro.h
                tmake_file=pa/t-pro
                ;;
        hppa1.1-*-osf*)
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-osf.h"
                use_collect2=yes
                ;;
        hppa1.1-*-rtems*)
                target_cpu_default="(MASK_JUMP_IN_DELAY | MASK_PORTABLE_RUNTIME | MASK_GAS | MASK_NO_SPACE_REGS | MASK_SOFT_FLOAT)"
                tm_file="${tm_file} pa/pa32-regs.h elfos.h pa/elf.h pa/pa-pro-end.h libgloss.h pa/rtems.h"
                xm_file=pa/xm-papro.h
                tmake_file=pa/t-pro
                ;;
        hppa1.0-*-osf*)
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-osf.h"
                use_collect2=yes
                ;;
        hppa1.1-*-bsd*)
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h"
                target_cpu_default="MASK_PA_11"
                use_collect2=yes
                ;;
        hppa1.0-*-bsd*)
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h"
                use_collect2=yes
                ;;
        hppa1.0-*-hpux7*)
                tm_file="pa/pa-oldas.h ${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux7.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
changequote(,)dnl
        hppa1.0-*-hpux8.0[0-2]*)
changequote([,])dnl
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                else
                        tm_file="pa/pa-oldas.h ${tm_file}"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
changequote(,)dnl
        hppa1.1-*-hpux8.0[0-2]*)
changequote([,])dnl
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                else
                        tm_file="pa/pa-oldas.h ${tm_file}"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.1-*-hpux8*)
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.0-*-hpux8*)
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.1-*-hpux10* | hppa2*-*-hpux10*)
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/long_double.h pa/som.h pa/pa-hpux.h pa/pa-hpux10.h"
                float_format=i128
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                tmake_file=pa/t-pa
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                if test x$enable_threads = x; then
                    enable_threads=$have_pthread_h
                fi
                case x${enable_threads} in
                xyes | xdce)
                        tmake_file="${tmake_file} pa/t-dce-thr"
                        ;;
                esac
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.0-*-hpux10*)
                tm_file="${tm_file} pa/pa32-regs.h pa/long_double.h pa/som.h pa/pa-hpux.h pa/pa-hpux10.h"
                float_format=i128
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                tmake_file=pa/t-pa
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                if test x$enable_threads = x; then
                    enable_threads=$have_pthread_h
                fi
                case x${enable_threads} in
                xyes | xdce)
                        tmake_file="${tmake_file} pa/t-dce-thr"
                        ;;
                esac
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa*64*-*-hpux11*)
                target_cpu_default="MASK_PA_11"
                xm_file=pa/xm-pa64hpux.h
                xmake_file=pa/x-pa-hpux
                tmake_file=pa/t-pa
                tm_file="pa/pa64-start.h ${tm_file} pa/pa64-regs.h pa/long_double.h pa/elf.h pa/pa-hpux.h pa/pa-hpux11.h pa/pa-64.h"
                float_format=i128
                tmake_file=pa/t-pa64
                target_cpu_default="(MASK_PA_11|MASK_PA_20)"

                if [[ x$gas = xyes ]]
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
#               if [[ x$enable_threads = x ]]; then
#                   enable_threads=$have_pthread_h
#               fi
#               if [[ x$enable_threads = xyes ]]; then
#                       thread_file='dce'
#                       tmake_file="${tmake_file} pa/t-dce-thr"
#               fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.1-*-hpux11* | hppa2*-*-hpux11*)
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/long_double.h pa/som.h pa/pa-hpux.h pa/pa-hpux11.h"
                float_format=i128
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                tmake_file=pa/t-pa
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
#               if test x$enable_threads = x; then
#                   enable_threads=$have_pthread_h
#               fi
#               if test x$enable_threads = xyes; then
#                       thread_file='dce'
#                       tmake_file="${tmake_file} pa/t-dce-thr"
#               fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.0-*-hpux11*)
                tm_file="${tm_file} pa/pa32-regs.h pa/long_double.h pa/som.h pa/pa-hpux.h pa/pa-hpux11.h"
                float_format=i128
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
#               if test x$enable_threads = x; then
#                   enable_threads=$have_pthread_h
#               fi
#               if test x$enable_threads = xyes; then
#                       thread_file='dce'
#                       tmake_file="${tmake_file} pa/t-dce-thr"
#               fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.1-*-hpux* | hppa2*-*-hpux*)
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h pa/pa-hpux9.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.0-*-hpux*)
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h pa/pa-hpux9.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.1-*-hiux* | hppa2*-*-hiux*)
                target_cpu_default="MASK_PA_11"
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h pa/pa-hiux.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa1.0-*-hiux*)
                tm_file="${tm_file} pa/pa32-regs.h pa/som.h pa/pa-hpux.h pa/pa-hiux.h"
                xm_file=pa/xm-pahpux.h
                xmake_file=pa/x-pa-hpux
                if test x$gas = xyes
                then
                        tm_file="${tm_file} pa/pa-gas.h"
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                ;;
        hppa*-*-lites*)
                tm_file="${tm_file} pa/pa32-regs.h elfos.h pa/elf.h"
                target_cpu_default="MASK_PA_11"
                use_collect2=yes
                ;;
        hppa*-*-mpeix*)
                tm_file="${tm_file} pa/pa32-regs.h pa/long_double.h pa/som.h pa/pa-mpeix.h"
                xm_file=pa/xm-pampeix.h 
                xmake_file=pa/x-pa-mpeix 
                echo "You must use gas. Assuming it is already installed." 
                install_headers_dir=install-headers-tar
                use_collect2=yes 
                ;; 
        i370-*-opened*)                  # IBM 360/370/390 Architecture
                xm_file=i370/xm-oe.h
                tm_file=i370/oe.h
                xmake_file=i370/x-oe
                tmake_file=i370/t-oe
                ;;
        i370-*-mvs*)
                xm_file=i370/xm-mvs.h
                tm_file=i370/mvs.h
                tmake_file=i370/t-mvs
                ;;
        i370-*-linux*)
                xm_file="xm-linux.h i370/xm-linux.h"
                xmake_file=x-linux
                tm_file="i370/linux.h ${tm_file}"
                tmake_file="t-linux i370/t-linux"
                # broken_install=yes
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                # extra_parts="crtbegin.o crtend.o"
                gnu_ld=yes
                gas=yes
                elf=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
changequote(,)dnl
        i[34567]86-*-elf*)
changequote([,])dnl
                xm_file="${xm_file} xm-svr4.h i386/xm-sysv4.h"
                tm_file=i386/i386elf.h
                tmake_file=i386/t-i386elf
                xmake_file=x-svr4
                ;;
changequote(,)dnl
        i[34567]86-ibm-aix*)            # IBM PS/2 running AIX
changequote([,])dnl
                if test x$gas = xyes
                then
                        tm_file=i386/aix386.h
                        extra_parts="crtbegin.o crtend.o"
                        tmake_file=i386/t-crtstuff
                else
                        tm_file=i386/aix386ng.h
                        use_collect2=yes
                fi
                xm_file="xm-alloca.h i386/xm-aix.h ${xm_file}"
                xm_defines=USG
                xmake_file=i386/x-aix
                ;;
changequote(,)dnl
        i[34567]86-ncr-sysv4*)          # NCR 3000 - ix86 running system V.4
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG POSIX SMALL_ARG_MAX"
                xmake_file=i386/x-ncr3000
                if test x$stabs = xyes -a x$gas = xyes
                then
                        tm_file=i386/sysv4gdb.h
                else
                        tm_file=i386/sysv4.h
                fi
                extra_parts="crtbegin.o crtend.o"
                tmake_file=i386/t-crtpic
                ;;
changequote(,)dnl
        i[34567]86-next-*)
changequote([,])dnl
                tm_file=i386/next.h
                xm_file=i386/xm-next.h
                tmake_file=i386/t-next
                xmake_file=i386/x-next
                extra_objs=nextstep.o
                extra_parts="crtbegin.o crtend.o"
                if test x$enable_threads = xyes; then
                        thread_file='mach'
                fi
                ;;
changequote(,)dnl
        i[34567]86-*-netware)           # Intel 80386's running netware
changequote([,])dnl
                tm_file=i386/netware.h
                tmake_file=i386/t-netware
                ;;
changequote(,)dnl
        i[34567]86-sequent-bsd*)                # 80386 from Sequent
changequote([,])dnl
                use_collect2=yes
                if test x$gas = xyes
                then
                        tm_file=i386/seq-gas.h
                else
                        tm_file=i386/sequent.h
                fi
                ;;
changequote(,)dnl
        i[34567]86-sequent-ptx1*)
changequote([,])dnl
                xm_defines="USG SVR3"
                xmake_file=i386/x-sysv3
                tm_file=i386/seq-sysv3.h
                tmake_file=i386/t-crtstuff
                extra_parts="crtbegin.o crtend.o"
                install_headers_dir=install-headers-cpio
                ;;
changequote(,)dnl
        i[34567]86-sequent-ptx2* | i[34567]86-sequent-sysv3*)
changequote([,])dnl
                xm_defines="USG SVR3"
                xmake_file=i386/x-sysv3
                tm_file=i386/seq2-sysv3.h
                tmake_file=i386/t-crtstuff
                extra_parts="crtbegin.o crtend.o"
                install_headers_dir=install-headers-cpio
                ;;
changequote(,)dnl
        i[34567]86-sequent-ptx4* | i[34567]86-sequent-sysv4*)
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG POSIX SMALL_ARG_MAX"
                xmake_file=x-svr4
                tm_file=i386/ptx4-i.h
                tmake_file=t-svr4
                extra_parts="crtbegin.o crtend.o"
                install_headers_dir=install-headers-cpio
                ;;
        i386-sun-sunos*)                # Sun i386 roadrunner
                xm_defines=USG
                tm_file=i386/sun.h
                use_collect2=yes
                ;;
changequote(,)dnl
        i[34567]86-wrs-vxworks*)
changequote([,])dnl
                tm_file=i386/vxi386.h
                tmake_file=i386/t-i386bare
                thread_file='vxworks'
                ;;
changequote(,)dnl
        i[34567]86-*-aout*)
changequote([,])dnl
                tm_file=i386/i386-aout.h
                tmake_file=i386/t-i386bare
                ;;
changequote(,)dnl
        i[34567]86-*-beoself* | i[34567]86-*-beos*)
changequote([,])dnl
                xm_file=i386/xm-beos.h
                tmake_file='i386/t-beos i386/t-crtpic'
                tm_file=i386/beos-elf.h
                xmake_file=i386/x-beos
                extra_parts='crtbegin.o crtend.o'
                ;;
changequote(,)dnl
        i[34567]86-*-bsdi* | i[34567]86-*-bsd386*)
changequote([,])dnl
                tm_file=i386/bsd386.h
#               tmake_file=t-libc-ok
                ;;
changequote(,)dnl
        i[34567]86-*-bsd*)
changequote([,])dnl
                tm_file=i386/386bsd.h
#               tmake_file=t-libc-ok
# Next line turned off because both 386BSD and BSD/386 use GNU ld.
#               use_collect2=yes
                ;;
changequote(,)dnl
        i[34567]86-*-freebsd[12] | i[34567]86-*-freebsd[12].* | i[34567]86-*-freebsd*aout*)
changequote([,])dnl
                tm_file="i386/freebsd-aout.h i386/perform.h"
                tmake_file=t-freebsd
                ;;
changequote(,)dnl
        i[34567]86-*-freebsd*)
changequote([,])dnl
                tm_file="i386/i386.h i386/att.h svr4.h freebsd.h i386/freebsd.h i386/perform.h"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                tmake_file=t-freebsd
                gas=yes
                gnu_ld=yes
                stabs=yes
                case x${enable_threads} in
                xyes | xpthreads | xposix)
                        thread_file='posix'
                        tmake_file="${tmake_file} t-freebsd-thread"
                        ;;
                esac
                ;;
changequote(,)dnl
        i[34567]86-*-netbsd*)
changequote([,])dnl
                tm_file=i386/netbsd.h
                tmake_file=t-netbsd
                use_collect2=yes
                ;;
changequote(,)dnl
        i[34567]86-*-openbsd*)
changequote([,])dnl
                # we need collect2 until our bug is fixed...
                use_collect2=yes
                ;;
changequote(,)dnl
        i[34567]86-*-coff*)
changequote([,])dnl
                tm_file=i386/i386-coff.h
                tmake_file=i386/t-i386bare
                ;;
changequote(,)dnl
        i[34567]86-*-isc*)              # 80386 running ISC system
changequote([,])dnl
                xm_file="${xm_file} i386/xm-isc.h"
                xm_defines="USG SVR3"
                case $machine in
changequote(,)dnl
                  i[34567]86-*-isc[34]*)
changequote([,])dnl
                    xmake_file=i386/x-isc3
                    ;;
                  *)
                    xmake_file=i386/x-isc
                    ;;
                esac
                if test x$gas = xyes -a x$stabs = xyes
                then
                        tm_file=i386/iscdbx.h
                        tmake_file=i386/t-svr3dbx
                        extra_parts="svr3.ifile svr3z.ifile"
                else
                        tm_file=i386/isccoff.h
                        tmake_file=i386/t-crtstuff
                        extra_parts="crtbegin.o crtend.o"
                fi
                tmake_file="$tmake_file i386/t-i386bare"
                install_headers_dir=install-headers-cpio
                ;;
changequote(,)dnl
        i[34567]86-*-linux*oldld*)      # Intel 80386's running GNU/Linux
changequote([,])dnl                     # with a.out format using
                                        # pre BFD linkers
                xmake_file=x-linux-aout
                tmake_file="t-linux-aout i386/t-crtstuff"
                tm_file=i386/linux-oldld.h
                gnu_ld=yes
                float_format=i386
                ;;
changequote(,)dnl
        i[34567]86-*-linux*aout*)       # Intel 80386's running GNU/Linux
changequote([,])dnl                     # with a.out format
                xmake_file=x-linux-aout
                tmake_file="t-linux-aout i386/t-crtstuff"
                tm_file=i386/linux-aout.h
                gnu_ld=yes
                float_format=i386
                ;;
changequote(,)dnl
        i[34567]86-*-linux*libc1)       # Intel 80386's running GNU/Linux
changequote([,])dnl                     # with ELF format using the
                                        # GNU/Linux C library 5
                xmake_file=x-linux      
                tm_file=i386/linux.h    
                tmake_file="t-linux t-linux-gnulibc1 i386/t-crtstuff"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                float_format=i386
                if test x$enable_threads = xyes; then
                        thread_file='single'
                fi
                ;;
changequote(,)dnl
        i[34567]86-*-linux*)    # Intel 80386's running GNU/Linux
changequote([,])dnl                     # with ELF format using glibc 2
                                        # aka GNU/Linux C library 6
                xmake_file=x-linux
                tm_file=i386/linux.h
                tmake_file="t-linux i386/t-crtstuff"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                float_format=i386
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
changequote(,)dnl
        i[34567]86-*-gnu*)
                float_format=i386
changequote([,])dnl
                ;;
changequote(,)dnl
        i[34567]86-go32-msdos | i[34567]86-*-go32*)
changequote([,])dnl
                echo "GO32/DJGPP V1.X is no longer supported. Use *-pc-msdosdjgpp for DJGPP V2.X instead."
                exit 1
                ;;
changequote(,)dnl
        i[34567]86-pc-msdosdjgpp*)
changequote([,])dnl
                xm_file=i386/xm-djgpp.h
                tm_file=i386/djgpp.h
                tmake_file=i386/t-djgpp
                xmake_file=i386/x-djgpp
                gnu_ld=yes
                gas=yes
                exeext=.exe
                float_format=none
                case $host in *pc-msdosdjgpp*)
                        target_alias=djgpp
                        ;;
                esac
                ;;
changequote(,)dnl
        i[34567]86-moss-msdos* | i[34567]86-*-moss*)
changequote([,])dnl
                tm_file=i386/moss.h
                tmake_file=t-libc-ok
                gnu_ld=yes
                gas=yes
                ;;
changequote(,)dnl
        i[34567]86-*-lynxos*)
changequote([,])dnl
                if test x$gas = xyes
                then
                        tm_file=i386/lynx.h
                else
                        tm_file=i386/lynx-ng.h
                fi
                xm_file=i386/xm-lynx.h
                tmake_file=i386/t-i386bare
                xmake_file=x-lynx
                ;;
changequote(,)dnl
        i[34567]86-*-mach*)
changequote([,])dnl
                tm_file=i386/mach.h
#               tmake_file=t-libc-ok
                use_collect2=yes
                ;;
changequote(,)dnl
        i[34567]86-*-osfrose*)          # 386 using OSF/rose
changequote([,])dnl
                if test x$elf = xyes
                then
                        tm_file=i386/osfelf.h
                        use_collect2=
                else
                        tm_file=i386/osfrose.h
                        use_collect2=yes
                fi
                xm_file="i386/xm-osf.h ${xm_file}"
                xmake_file=i386/x-osfrose
                tmake_file=i386/t-osf
                extra_objs=halfpic.o
                ;;
changequote(,)dnl
        i[34567]86-go32-rtems*)
changequote([,])dnl
                cpu_type=i386
                xm_file=i386/xm-go32.h
                tm_file=i386/go32-rtems.h
                tmake_file="i386/t-go32 t-rtems"
                ;;
changequote(,)dnl
        i[34567]86-*-rtemscoff*)
changequote([,])dnl
                cpu_type=i386
                tm_file=i386/rtems.h
                tmake_file="i386/t-i386bare t-rtems"
                ;;
changequote(,)dnl
        i[34567]86-*-rtems*|i[34567]86-*-rtemself*)
changequote([,])dnl
                cpu_type=i386
                tm_file=i386/rtemself.h
                extra_parts="crtbegin.o crtend.o crti.o crtn.o"
                tmake_file="i386/t-rtems-i386 i386/t-crtstuff t-rtems"
                ;;
changequote(,)dnl
        i[34567]86-*-sco3.2v5*) # 80386 running SCO Open Server 5
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file} i386/xm-sco5.h"
                xm_defines="USG SVR3"
                xmake_file=i386/x-sco5
                install_headers_dir=install-headers-cpio
                tm_file=i386/sco5.h
                if test x$gas = xyes
                then
                        tm_file="i386/sco5gas.h ${tm_file}"
                        tmake_file=i386/t-sco5gas
                else
                        tmake_file=i386/t-sco5
                fi
                tmake_file="$tmake_file i386/t-i386bare"
                extra_parts="crti.o crtbegin.o crtend.o crtbeginS.o crtendS.o"
                ;;
changequote(,)dnl
        i[34567]86-*-sco3.2v4*)         # 80386 running SCO 3.2v4 system
changequote([,])dnl
                xm_file="${xm_file} i386/xm-sco.h"
                xm_defines="USG SVR3 BROKEN_LDEXP SMALL_ARG_MAX"
                xmake_file=i386/x-sco4
                install_headers_dir=install-headers-cpio
                if test x$stabs = xyes
                then
                        tm_file=i386/sco4dbx.h
                        tmake_file=i386/t-svr3dbx
                        extra_parts="svr3.ifile svr3z.rfile"
                else
                        tm_file=i386/sco4.h
                        tmake_file=i386/t-crtstuff
                        extra_parts="crtbegin.o crtend.o"
                fi
                tmake_file="$tmake_file i386/t-i386bare"
                # The default EAFS filesystem supports long file names.
                # Truncating the target makes $host != $target which
                # makes gcc think it is doing a cross-compile.
                # truncate_target=yes
                ;;
changequote(,)dnl
        i[34567]86-*-sco*)              # 80386 running SCO system
changequote([,])dnl
                xm_file=i386/xm-sco.h
                xmake_file=i386/x-sco
                install_headers_dir=install-headers-cpio
                if test x$stabs = xyes
                then
                        tm_file=i386/scodbx.h
                        tmake_file=i386/t-svr3dbx
                        extra_parts="svr3.ifile svr3z.rfile"
                else
                        tm_file=i386/sco.h
                        extra_parts="crtbegin.o crtend.o"
                        tmake_file=i386/t-crtstuff
                fi
                tmake_file="$tmake_file i386/t-i386bare"
                truncate_target=yes
                ;;
changequote(,)dnl
        i[34567]86-*-solaris2*)
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG POSIX SMALL_ARG_MAX"
                tm_file=i386/sol2.h
                if test x$gas = xyes; then
                        # Only needed if gas does not support -s
                        tm_file="i386/sol2gas.h ${tm_file}"
                fi
                tmake_file="i386/t-i386bare i386/t-sol2"
                extra_parts="crt1.o crti.o crtn.o gcrt1.o gmon.o crtbegin.o crtend.o"
                xmake_file=x-svr4
                if test x${enable_threads} = x; then
                    enable_threads=$have_pthread_h
                    if test x${enable_threads} = x; then
                        enable_threads=$have_thread_h
                    fi
                fi
                if test x${enable_threads} = xyes; then
                    if test x${have_pthread_h} = xyes; then
                        thread_file='posix'
                    else
                        thread_file='solaris'
                    fi
                fi
                ;;
changequote(,)dnl
       i[34567]86-*-sysv5*)           # Intel x86 on System V Release 5
changequote([,])dnl
               xm_file="xm-alloca.h ${xm_file}"
               xm_defines="USG POSIX"
               tm_file=i386/sysv5.h
               if test x$stabs = xyes
               then
                       tm_file="${tm_file} dbx.h"
               fi
               tmake_file="i386/t-i386bare i386/t-crtpic"
               xmake_file=x-svr4
               extra_parts="crtbegin.o crtend.o"
               if test x$enable_threads = xyes; then
                       thread_file='posix'
               fi
               ;;
changequote(,)dnl
        i[34567]86-*-sysv4*)            # Intel 80386's running system V.4
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG POSIX SMALL_ARG_MAX"
                tm_file=i386/sysv4.h
                if test x$stabs = xyes
                then
                        tm_file="${tm_file} dbx.h"
                fi
                tmake_file="i386/t-i386bare i386/t-crtpic"
                xmake_file=x-svr4
                extra_parts="crtbegin.o crtend.o"
                ;;
changequote(,)dnl
        i[34567]86-*-udk*)      # Intel x86 on SCO UW/OSR5 Dev Kit
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG POSIX"
                tm_file=i386/udk.h
                tmake_file="i386/t-i386bare i386/t-crtpic i386/t-udk"
                xmake_file=x-svr4
                extra_parts="crtbegin.o crtend.o"
                install_headers_dir=install-headers-cpio
                ;;
changequote(,)dnl
        i[34567]86-*-osf1*)             # Intel 80386's running OSF/1 1.3+
changequote([,])dnl
                cpu_type=i386
                xm_file="${xm_file} xm-svr4.h i386/xm-sysv4.h i386/xm-osf1elf.h"
                xm_defines="USE_C_ALLOCA SMALL_ARG_MAX"
                if test x$stabs = xyes
                then
                        tm_file=i386/osf1elfgdb.h
                else
                        tm_file=i386/osf1elf.h
                fi
                tmake_file=i386/t-osf1elf
                xmake_file=i386/x-osf1elf
                extra_parts="crti.o crtn.o crtbegin.o crtend.o"
                ;;
changequote(,)dnl
        i[34567]86-*-sysv*)             # Intel 80386's running system V
changequote([,])dnl
                xm_defines="USG SVR3"
                xmake_file=i386/x-sysv3
                if test x$gas = xyes
                then
                        if test x$stabs = xyes
                        then
                                tm_file=i386/svr3dbx.h
                                tmake_file=i386/t-svr3dbx
                                extra_parts="svr3.ifile svr3z.rfile"
                        else
                                tm_file=i386/svr3gas.h
                                extra_parts="crtbegin.o crtend.o"
                                tmake_file=i386/t-crtstuff
                        fi
                else
                        tm_file=i386/sysv3.h
                        extra_parts="crtbegin.o crtend.o"
                        tmake_file=i386/t-crtstuff
                fi
                tmake_file="$tmake_file i386/t-crtpic"
                ;;
        i386-*-vsta)                    # Intel 80386's running VSTa kernel
                xm_file="${xm_file} i386/xm-vsta.h"
                tm_file=i386/vsta.h
                tmake_file=i386/t-vsta
                xmake_file=i386/x-vsta
                ;;
changequote(,)dnl
        i[34567]86-*-win32)
changequote([,])dnl
                xm_file="${xm_file} i386/xm-cygwin.h"
                tmake_file=i386/t-cygwin
                tm_file=i386/win32.h
                xmake_file=i386/x-cygwin
                extra_objs=winnt.o
                if test x$enable_threads = xyes; then
                        thread_file='win32'
                fi
                exeext=.exe
                ;;
changequote(,)dnl
        i[34567]86-*-pe | i[34567]86-*-cygwin*)
changequote([,])dnl
                xm_file="${xm_file} i386/xm-cygwin.h"
                tmake_file=i386/t-cygwin
                tm_file=i386/cygwin.h
                xmake_file=i386/x-cygwin
                extra_objs=winnt.o
                if test x$enable_threads = xyes; then
                        thread_file='win32'
                fi
                exeext=.exe
                ;;
changequote(,)dnl
        i[34567]86-*-mingw32*)
changequote([,])dnl
                tm_file=i386/mingw32.h
                xm_file="${xm_file} i386/xm-mingw32.h"
                tmake_file="i386/t-cygwin i386/t-mingw32"
                extra_objs=winnt.o
                xmake_file=i386/x-cygwin
                if test x$enable_threads = xyes; then
                        thread_file='win32'
                fi
                exeext=.exe
                case $machine in
                        *mingw32msv*)
                                ;;
                        *minwg32crt* | *mingw32*)
                                tm_file="${tm_file} i386/crtdll.h"
                                ;;
                esac
                ;;
changequote(,)dnl
        i[34567]86-*-uwin*)
changequote([,])dnl
                tm_file=i386/uwin.h
                xm_file="${xm_file} i386/xm-uwin.h"
                xm_defines="USG NO_STAB_H"
                tmake_file="i386/t-cygwin i386/t-uwin"
                extra_objs=winnt.o
                xmake_file=i386/x-cygwin
                if test x$enable_threads = xyes; then
                        thread_file='win32'
                fi
                exeext=.exe
                ;;
changequote(,)dnl
        i[34567]86-*-interix*)
changequote([,])dnl
                tm_file="i386/i386-interix.h interix.h"
                xm_file="i386/xm-i386-interix.h xm-interix.h"
                xm_defines="USG"
                tmake_file="i386/t-interix"
                extra_objs=interix.o
                xmake_file=x-interix
                if test x$enable_threads = xyes ; then
                        thread_file='posix'
                fi
                if test x$stabs = xyes ; then
                        tm_file="${tm_file} dbxcoff.h"
                fi
                ;;
changequote(,)dnl
        i[34567]86-*-winnt3*)
changequote([,])dnl
                tm_file=i386/win-nt.h
                out_file=i386/i386.c
                xm_file="xm-winnt.h ${xm_file}"
                xmake_file=winnt/x-winnt
                tmake_file=i386/t-winnt
                extra_host_objs="winnt.o oldnames.o"
                extra_gcc_objs="spawnv.o oldnames.o"
                if test x$gnu_ld != xyes
                then
                        extra_programs=ld.exe
                fi
                if test x$enable_threads = xyes; then
                        thread_file='win32'
                fi
                ;;
changequote(,)dnl
        i[34567]86-dg-dgux*)
changequote([,])dnl
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG POSIX"
                out_file=i386/dgux.c
                tm_file=i386/dgux.h
                tmake_file=i386/t-dgux
                xmake_file=i386/x-dgux
                install_headers_dir=install-headers-cpio
              ;;
        i860-alliant-*)         # Alliant FX/2800
                tm_file="${tm_file} svr4.h i860/sysv4.h i860/fx2800.h"
                xm_file="${xm_file}"
                xmake_file=i860/x-fx2800
                tmake_file=i860/t-fx2800
                extra_parts="crtbegin.o crtend.o"
                ;;
        i860-*-bsd*)
                tm_file="${tm_file} i860/bsd.h"
                if test x$gas = xyes
                then
                        tm_file="${tm_file} i860/bsd-gas.h"
                fi
                use_collect2=yes
                ;;
        i860-*-mach*)
                tm_file="${tm_file} i860/mach.h"
                tmake_file=t-libc-ok
                ;;
        i860-*-osf*)                    # Intel Paragon XP/S, OSF/1AD
                tm_file="${tm_file} svr3.h i860/paragon.h"
                xm_defines="USG SVR3"
                tmake_file=t-osf
                ;;
        i860-*-sysv3*)
                tm_file="${tm_file} svr3.h i860/sysv3.h"
                xm_defines="USG SVR3"
                xmake_file=i860/x-sysv3
                extra_parts="crtbegin.o crtend.o"
                ;;
        i860-*-sysv4*)
                tm_file="${tm_file} svr4.h i860/sysv4.h"
                xm_defines="USG SVR3"
                xmake_file=i860/x-sysv4
                tmake_file=t-svr4
                extra_parts="crtbegin.o crtend.o"
                ;;
        i960-wrs-vxworks5 | i960-wrs-vxworks5.0*)
                tm_file="${tm_file} i960/vx960.h"
                tmake_file=i960/t-vxworks960
                use_collect2=yes
                thread_file='vxworks'
                ;;
        i960-wrs-vxworks5* | i960-wrs-vxworks)
                tm_file="${tm_file} dbxcoff.h i960/i960-coff.h i960/vx960-coff.h"
                tmake_file=i960/t-vxworks960
                use_collect2=yes
                thread_file='vxworks'
                ;;
        i960-wrs-vxworks*)
                tm_file="${tm_file} i960/vx960.h"
                tmake_file=i960/t-vxworks960
                use_collect2=yes
                thread_file='vxworks'
                ;;
        i960-*-coff*)
                tm_file="${tm_file} dbxcoff.h i960/i960-coff.h libgloss.h"
                tmake_file=i960/t-960bare
                use_collect2=yes
                ;;
        i960-*-rtems)
                tmake_file="i960/t-960bare t-rtems"
                tm_file="${tm_file} dbxcoff.h i960/rtems.h"
                use_collect2=yes
                ;;
        i960-*-*)                       # Default i960 environment.
                use_collect2=yes
                ;;
        ia64*-*-elf*)
                tm_file=ia64/elf.h
                tmake_file="ia64/t-ia64"
                target_cpu_default="0"
                if test x$gas = xyes
                then
                        target_cpu_default="${target_cpu_default}|MASK_GNU_AS"
                fi
                if test x$gnu_ld = xyes
                then
                        target_cpu_default="${target_cpu_default}|MASK_GNU_LD"
                fi
                float_format=i386
                ;;
        ia64*-*-linux*)
                tm_file=ia64/linux.h
                tmake_file="t-linux ia64/t-ia64 ia64/t-glibc"
                target_cpu_default="MASK_GNU_AS|MASK_GNU_LD"
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                float_format=i386
                ;;
        m32r-*-elf*)
                extra_parts="crtinit.o crtfini.o"
                ;;
        # m68hc11 and m68hc12 share the same machine description.
        m68hc11-*-*|m6811-*-*)
                tm_file="m68hc11/m68hc11.h"
                xm_file="m68hc11/xm-m68hc11.h"
                tm_p_file="m68hc11/m68hc11-protos.h"
                md_file="m68hc11/m68hc11.md"
                out_file="m68hc11/m68hc11.c"
                tmake_file="m68hc11/t-m68hc11-gas"
                ;;
        m68hc12-*-*|m6812-*-*)
                tm_file="m68hc11/m68hc12.h"
                tm_p_file="m68hc11/m68hc11-protos.h"
                xm_file="m68hc11/xm-m68hc11.h"
                md_file="m68hc11/m68hc11.md"
                out_file="m68hc11/m68hc11.c"
                tmake_file="m68hc11/t-m68hc11-gas"
                ;;
        m68000-convergent-sysv*)
                tm_file=m68k/ctix.h
                xm_file="m68k/xm-3b1.h ${xm_file}"
                xm_defines=USG
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68000-hp-bsd*)                 # HP 9000/200 running BSD
                tm_file=m68k/hp2bsd.h
                xmake_file=m68k/x-hp2bsd
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68000-hp-hpux*)                # HP 9000 series 300
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG"
                if test x$gas = xyes
                then
                        xmake_file=m68k/x-hp320g
                        tm_file=m68k/hp310g.h
                else
                        xmake_file=m68k/x-hp320
                        tm_file=m68k/hp310.h
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68000-sun-sunos3*)
                tm_file=m68k/sun2.h
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68000-sun-sunos4*)
                tm_file=m68k/sun2o4.h
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68000-att-sysv*)
                xm_file="m68k/xm-3b1.h ${xm_file}"
                xm_defines=USG
                if test x$gas = xyes
                then
                        tm_file=m68k/3b1g.h
                else
                        tm_file=m68k/3b1.h
                fi
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-apple-aux*)                # Apple Macintosh running A/UX
                xm_defines="USG AUX"
                tmake_file=m68k/t-aux
                install_headers_dir=install-headers-cpio
                extra_headers=math-68881.h
                extra_parts="crt1.o mcrt1.o maccrt1.o crt2.o crtn.o"
                tm_file=
                if test "$gnu_ld" = yes
                then
                        tm_file="${tm_file} m68k/auxgld.h"
                else
                        tm_file="${tm_file} m68k/auxld.h"
                fi
                if test "$gas" = yes
                then
                        tm_file="${tm_file} m68k/auxgas.h"
                else
                        tm_file="${tm_file} m68k/auxas.h"
                fi
                tm_file="${tm_file} m68k/a-ux.h"
                float_format=m68k
                ;;
        m68k-apollo-*)
                tm_file=m68k/apollo68.h
                xmake_file=m68k/x-apollo68
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-altos-sysv*)                  # Altos 3068
                if test x$gas = xyes
                then
                        tm_file=m68k/altos3068.h
                        xm_defines=USG
                else
                        echo "The Altos is supported only with the GNU assembler" 1>&2
                        exit 1
                fi
                extra_headers=math-68881.h
                ;;
        m68k-bull-sysv*)                # Bull DPX/2
                if test x$gas = xyes
                then
                        if test x$stabs = xyes
                        then
                                tm_file=m68k/dpx2cdbx.h
                        else
                                tm_file=m68k/dpx2g.h
                        fi
                else
                        tm_file=m68k/dpx2.h
                fi
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines=USG
                xmake_file=m68k/x-dpx2
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-atari-sysv4*)              # Atari variant of V.4.
                tm_file=m68k/atari.h
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG FULL_PROTOTYPES"
                tmake_file=t-svr4
                extra_parts="crtbegin.o crtend.o"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-motorola-sysv*)
                tm_file=m68k/mot3300.h
                xm_file="xm-alloca.h m68k/xm-mot3300.h ${xm_file}"
                if test x$gas = xyes
                then
                        xmake_file=m68k/x-mot3300-gas
                        if test x$gnu_ld = xyes
                        then
                                tmake_file=m68k/t-mot3300-gald
                        else
                                tmake_file=m68k/t-mot3300-gas
                                use_collect2=yes
                        fi
                else
                        xmake_file=m68k/x-mot3300
                        if test x$gnu_ld = xyes
                        then
                                tmake_file=m68k/t-mot3300-gld
                        else
                                tmake_file=m68k/t-mot3300
                                use_collect2=yes
                        fi
                fi
                gdb_needs_out_file_path=yes
                extra_parts="crt0.o mcrt0.o"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-ncr-sysv*)                 # NCR Tower 32 SVR3
                tm_file=m68k/tower-as.h
                xm_defines="USG SVR3"
                xmake_file=m68k/x-tower
                extra_parts="crtbegin.o crtend.o"
                extra_headers=math-68881.h
                ;;
        m68k-plexus-sysv*)
                tm_file=m68k/plexus.h
                xm_file="xm-alloca.h m68k/xm-plexus.h ${xm_file}"
                xm_defines=USG
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-tti-*)
                tm_file=m68k/pbb.h
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines=USG
                extra_headers=math-68881.h
                ;;
        m68k-crds-unos*)
                xm_file="xm-alloca.h m68k/xm-crds.h ${xm_file}"
                xm_defines="USG unos"
                xmake_file=m68k/x-crds
                tm_file=m68k/crds.h
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-cbm-sysv4*)                # Commodore variant of V.4.
                tm_file=m68k/amix.h
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG FULL_PROTOTYPES"
                xmake_file=m68k/x-amix
                tmake_file=t-svr4
                extra_parts="crtbegin.o crtend.o"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-ccur-rtu)
                tm_file=m68k/ccur-GAS.h
                xmake_file=m68k/x-ccur
                extra_headers=math-68881.h
                use_collect2=yes
                float_format=m68k
                ;;
        m68k-hp-bsd4.4*)                # HP 9000/3xx running 4.4bsd
                tm_file=m68k/hp3bsd44.h
                xmake_file=m68k/x-hp3bsd44
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-hp-bsd*)                   # HP 9000/3xx running Berkeley Unix
                tm_file=m68k/hp3bsd.h
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-isi-bsd*)
                if test x$with_fp = xno
                then
                        tm_file=m68k/isi-nfp.h
                else
                        tm_file=m68k/isi.h
                        float_format=m68k
                fi
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-hp-hpux7*) # HP 9000 series 300 running HPUX version 7.
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG"
                if test x$gas = xyes
                then
                        xmake_file=m68k/x-hp320g
                        tm_file=m68k/hp320g.h
                else
                        xmake_file=m68k/x-hp320
                        tm_file=m68k/hpux7.h
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-hp-hpux*)  # HP 9000 series 300
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines="USG"
                if test x$gas = xyes
                then
                        xmake_file=m68k/x-hp320g
                        tm_file=m68k/hp320g.h
                else
                        xmake_file=m68k/x-hp320
                        tm_file=m68k/hp320.h
                fi
                install_headers_dir=install-headers-cpio
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-sun-mach*)
                tm_file=m68k/sun3mach.h
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-sony-newsos3*)
                if test x$gas = xyes
                then
                        tm_file=m68k/news3gas.h
                else
                        tm_file=m68k/news3.h
                fi
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-sony-bsd* | m68k-sony-newsos*)
                if test x$gas = xyes
                then
                        tm_file=m68k/newsgas.h
                else
                        tm_file=m68k/news.h
                fi
                use_collect2=yes
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-next-nextstep2*)
                tm_file=m68k/next21.h
                xm_file="m68k/xm-next.h ${xm_file}"
                tmake_file=m68k/t-next
                xmake_file=m68k/x-next
                extra_objs=nextstep.o
                extra_headers=math-68881.h
                use_collect2=yes
                float_format=m68k
                ;;
changequote(,)dnl
        m68k-next-nextstep[34]*)
changequote([,])dnl
                tm_file=m68k/next.h
                xm_file="m68k/xm-next.h ${xm_file}"
                tmake_file=m68k/t-next
                xmake_file=m68k/x-next
                extra_objs=nextstep.o
                extra_parts="crtbegin.o crtend.o"
                extra_headers=math-68881.h
                float_format=m68k
                if test x$enable_threads = xyes; then
                        thread_file='mach'
                fi
                ;;
        m68k-sun-sunos3*)
                if test x$with_fp = xno
                then
                        tm_file=m68k/sun3n3.h
                else
                        tm_file=m68k/sun3o3.h
                        float_format=m68k
                fi
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-sun-sunos*)                        # For SunOS 4 (the default).
                if test x$with_fp = xno
                then
                        tm_file=m68k/sun3n.h
                else
                        tm_file=m68k/sun3.h
                        float_format=m68k
                fi
                use_collect2=yes
                extra_headers=math-68881.h
                ;;
        m68k-wrs-vxworks*)
                tm_file=m68k/vxm68k.h
                tmake_file=m68k/t-vxworks68
                extra_headers=math-68881.h
                thread_file='vxworks'
                float_format=m68k
                ;;
        m68k-*-aout*)
                tmake_file=m68k/t-m68kbare
                tm_file="m68k/m68k-aout.h libgloss.h"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-*-coff*)
                tmake_file=m68k/t-m68kbare
                tm_file="m68k/m68k-coff.h dbx.h"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68020-*-elf* | m68k-*-elf*)
                tm_file="m68k/m68020-elf.h"
                xm_file=m68k/xm-m68kv.h
                tmake_file=m68k/t-m68kelf
                header_files=math-68881.h
                ;;
        m68k-*-lynxos*)
                if test x$gas = xyes
                then
                        tm_file=m68k/lynx.h
                else
                        tm_file=m68k/lynx-ng.h
                fi
                xm_file=m68k/xm-lynx.h
                xmake_file=x-lynx
                tmake_file=m68k/t-lynx
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k*-*-netbsd*)
                tm_file=m68k/netbsd.h
                tmake_file=t-netbsd
                float_format=m68k
                use_collect2=yes
                ;;
        m68k*-*-openbsd*)
                float_format=m68k
                # we need collect2 until our bug is fixed...
                use_collect2=yes
                ;;
        m68k-*-sysv3*)                  # Motorola m68k's running system V.3
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines=USG
                xmake_file=m68k/x-m68kv
                extra_parts="crtbegin.o crtend.o"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-*-sysv4*)                  # Motorola m68k's running system V.4
                tm_file=m68k/m68kv4.h
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines=USG
                tmake_file=t-svr4
                extra_parts="crtbegin.o crtend.o"
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-*-linux*aout*)             # Motorola m68k's running GNU/Linux
                                        # with a.out format
                xmake_file=x-linux
                tm_file=m68k/linux-aout.h
                tmake_file="t-linux-aout m68k/t-linux-aout"
                extra_headers=math-68881.h
                float_format=m68k
                gnu_ld=yes
                ;;
        m68k-*-linux*libc1)             # Motorola m68k's running GNU/Linux
                                        # with ELF format using the
                                        # GNU/Linux C library 5
                xmake_file=x-linux
                tm_file=m68k/linux.h
                tmake_file="t-linux t-linux-gnulibc1 m68k/t-linux"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                extra_headers=math-68881.h
                float_format=m68k
                gnu_ld=yes
                ;;
        m68k-*-linux*)          # Motorola m68k's running GNU/Linux
                                        # with ELF format using glibc 2
                                        # aka the GNU/Linux C library 6.
                xmake_file=x-linux
                tm_file=m68k/linux.h
                tmake_file="t-linux m68k/t-linux"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                extra_headers=math-68881.h
                float_format=m68k
                gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        m68k-*-psos*)
                tmake_file=m68k/t-m68kbare
                tm_file=m68k/m68k-psos.h
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-*-rtemscoff*)
                tmake_file="m68k/t-m68kbare t-rtems"
                tm_file=m68k/rtems.h
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m68k-*-rtemself*|m68k-*-rtems*)
                tmake_file="m68k/t-m68kbare t-rtems m68k/t-crtstuff"
                tm_file=m68k/rtemself.h
                extra_headers=math-68881.h
                float_format=m68k
                ;;
        m88k-dg-dgux*)
                case $machine in
                  m88k-dg-dguxbcs*)
                    tm_file=m88k/dguxbcs.h
                    tmake_file=m88k/t-dguxbcs
                    ;;
                  *)
                    tm_file=m88k/dgux.h
                    tmake_file=m88k/t-dgux
                    ;;
                esac
                extra_parts="crtbegin.o bcscrtbegin.o crtend.o m88kdgux.ld"
                xmake_file=m88k/x-dgux
                if test x$gas = xyes
                then
                        tmake_file=m88k/t-dgux-gas
                fi
                ;;
        m88k-dolphin-sysv3*)
                tm_file=m88k/dolph.h
                extra_parts="crtbegin.o crtend.o"
                xm_file="m88k/xm-sysv3.h ${xm_file}"
                xmake_file=m88k/x-dolph
                if test x$gas = xyes
                then
                        tmake_file=m88k/t-m88k-gas
                fi
                ;;
        m88k-tektronix-sysv3)
                tm_file=m88k/tekXD88.h
                extra_parts="crtbegin.o crtend.o"
                xm_file="m88k/xm-sysv3.h ${xm_file}"
                xmake_file=m88k/x-tekXD88
                if test x$gas = xyes
                then
                        tmake_file=m88k/t-m88k-gas
                fi
                ;;
        m88k-*-aout*)
                tm_file=m88k/m88k-aout.h
                ;;
        m88k-*-coff*)
                tm_file=m88k/m88k-coff.h
                tmake_file=m88k/t-bug
                ;;
        m88k-*-luna*)
                tm_file=m88k/luna.h
                extra_parts="crtbegin.o crtend.o"
                if test x$gas = xyes
                then
                        tmake_file=m88k/t-luna-gas
                else
                        tmake_file=m88k/t-luna
                fi
                ;;
        m88k-*-openbsd*)
                tmake_file="${tmake_file} m88k/t-luna-gas"
                tm_file="m88k/aout-dbx.h aoutos.h m88k/m88k.h openbsd.h ${tm_file}"
                xm_file="xm-openbsd.h m88k/xm-m88k.h ${xm_file}"
                ;;
        m88k-*-sysv3*)
                tm_file=m88k/sysv3.h
                extra_parts="crtbegin.o crtend.o"
                xm_file="m88k/xm-sysv3.h ${xm_file}"
                xmake_file=m88k/x-sysv3
                if test x$gas = xyes
                then
                        tmake_file=m88k/t-m88k-gas
                fi
                ;;
        m88k-*-sysv4*)
                tm_file=m88k/sysv4.h
                extra_parts="crtbegin.o crtend.o"
                xmake_file=m88k/x-sysv4
                tmake_file=m88k/t-sysv4
                ;;
        mcore-*-elf)
                tm_file=mcore/mcore-elf.h
                tmake_file=mcore/t-mcore
                ;;
        mcore-*-pe*)
                tm_file=mcore/mcore-pe.h
                tmake_file=mcore/t-mcore-pe
                ;;
        mips-sgi-irix6*)                # SGI System V.4., IRIX 6
                if test "x$gnu_ld" = xyes
                then
                        tm_file="mips/iris6.h mips/iris6gld.h"
                else
                        tm_file=mips/iris6.h
                fi
                tmake_file=mips/t-iris6
                xm_file=mips/xm-iris6.h
                xmake_file=mips/x-iris6
#               if test x$enable_threads = xyes; then
#                       thread_file='irix'
#               fi
                ;;
        mips-wrs-vxworks)
                tm_file="mips/elf.h mips/vxworks.h"
                tmake_file=mips/t-ecoff
                gas=yes
                gnu_ld=yes
                extra_parts="crtbegin.o crtend.o"
                thread_file='vxworks'
                ;;
        mips-sgi-irix5cross64)          # Irix5 host, Irix 6 target, cross64
                tm_file="mips/iris6.h mips/cross64.h"
                xm_defines=USG
                xm_file="mips/xm-iris5.h"
                xmake_file=mips/x-iris
                tmake_file=mips/t-cross64
                # See comment in mips/iris[56].h files.
                use_collect2=yes
#               if test x$enable_threads = xyes; then
#                       thread_file='irix'
#               fi
                ;;
        mips-sni-sysv4)
                if test x$gas = xyes
                then
                        if test x$stabs = xyes
                        then
                                tm_file=mips/iris5gdb.h
                        else
                                tm_file="mips/sni-svr4.h mips/sni-gas.h"
                        fi
                else
                        tm_file=mips/sni-svr4.h
                fi
                xm_defines=USG
                xmake_file=mips/x-sni-svr4
                tmake_file=mips/t-mips-gas
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-sgi-irix5*)                # SGI System V.4., IRIX 5
                if test x$gas = xyes
                then
                        tm_file="mips/iris5.h mips/iris5gas.h"
                        if test x$stabs = xyes
                        then
                                tm_file="${tm_file} dbx.h"
                        fi
                else
                        tm_file=mips/iris5.h
                fi
                xm_defines=USG
                xm_file="mips/xm-iris5.h"
                xmake_file=mips/x-iris
                # mips-tfile doesn't work yet
                tmake_file=mips/t-mips-gas
                # See comment in mips/iris5.h file.
                use_collect2=yes
#               if test x$enable_threads = xyes; then
#                       thread_file='irix'
#               fi
                ;;
        mips-sgi-irix4loser*)           # Mostly like a MIPS.
                tm_file="mips/iris4loser.h mips/iris3.h ${tm_file} mips/iris4.h"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-iris
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
#               if test x$enable_threads = xyes; then
#                       thread_file='irix'
#               fi
                ;;
        mips-sgi-irix4*)                # Mostly like a MIPS.
                tm_file="mips/iris3.h ${tm_file} mips/iris4.h"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-iris
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
#               if test x$enable_threads = xyes; then
#                       thread_file='irix'
#               fi
                ;;
        mips-sgi-*)                     # Mostly like a MIPS.
                tm_file="mips/iris3.h ${tm_file}"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-iris3
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-dec-osfrose*)              # Decstation running OSF/1 reference port with OSF/rose.
                tm_file="mips/osfrose.h ${tm_file}"
                xmake_file=mips/x-osfrose
                tmake_file=mips/t-osfrose
                extra_objs=halfpic.o
                use_collect2=yes
                ;;
        mips-dec-osf*)                  # Decstation running OSF/1 as shipped by DIGITAL
                tm_file=mips/dec-osf1.h
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xmake_file=mips/x-dec-osf1
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        tmake_file=mips/t-ultrix
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-dec-bsd*)                  # Decstation running 4.4 BSD
              tm_file=mips/dec-bsd.h
              if test x$gas = xyes
              then
                        tmake_file=mips/t-mips-gas
              else
                        tmake_file=mips/t-ultrix
                        extra_passes="mips-tfile mips-tdump"
              fi
              if test x$gnu_ld != xyes
              then
                        use_collect2=yes
              fi
              ;;
        mipsel-*-netbsd* | mips-dec-netbsd*)    # Decstation running NetBSD
                tm_file=mips/netbsd.h
                # On NetBSD, the headers are already okay, except for math.h.
                tmake_file=t-netbsd
                ;;
        mips*-*-linux*)                         # Linux MIPS, either endian.
                xmake_file=x-linux
                case $machine in
                       mips*el-*)  tm_file="mips/elfl.h mips/linux.h" ;;
                       *)         tm_file="mips/elf.h mips/linux.h" ;;
                esac
                tmake_file=t-linux
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                gas=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        mips*el-*-openbsd*)     # mips little endian
                target_cpu_default="MASK_GAS|MASK_ABICALLS"
                ;;
        mips*-*-openbsd*)               # mips big endian
                target_cpu_default="MASK_GAS|MASK_ABICALLS"
                tm_file="mips/openbsd-be.h ${tm_file}"
                ;;
        mips-sony-bsd* | mips-sony-newsos*)     # Sony NEWS 3600 or risc/news.
                tm_file="mips/news4.h ${tm_file}"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                xmake_file=mips/x-sony
                ;;
        mips-sony-sysv*)                # Sony NEWS 3800 with NEWSOS5.0.
                                        # That is based on svr4.
                # t-svr4 is not right because this system doesn't use ELF.
                tm_file="mips/news5.h ${tm_file}"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-tandem-sysv4*)             # Tandem S2 running NonStop UX
                tm_file="mips/svr4-5.h mips/svr4-t.h"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-sysv
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                        extra_parts="crtbegin.o crtend.o"
                else
                        tmake_file=mips/t-mips
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-*-ultrix* | mips-dec-mach3)        # Decstation.
                tm_file="mips/ultrix.h ${tm_file}"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xmake_file=mips/x-ultrix
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        tmake_file=mips/t-ultrix
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
changequote(,)dnl
        mips-*-riscos[56789]bsd*)
changequote([,])dnl
                tm_file=mips/bsd-5.h    # MIPS BSD 4.3, RISC-OS 5.0
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                if test x$gas = xyes
                then
                        tmake_file=mips/t-bsd-gas
                else
                        tmake_file=mips/t-bsd
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
changequote(,)dnl
        mips-*-bsd* | mips-*-riscosbsd* | mips-*-riscos[1234]bsd*)
changequote([,])dnl
                tm_file="mips/bsd-4.h ${tm_file}" # MIPS BSD 4.3, RISC-OS 4.0
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                if test x$gas = xyes
                then
                        tmake_file=mips/t-bsd-gas
                else
                        tmake_file=mips/t-bsd
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
changequote(,)dnl
        mips-*-riscos[56789]sysv4*)
changequote([,])dnl
                tm_file=mips/svr4-5.h   # MIPS System V.4., RISC-OS 5.0
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xmake_file=mips/x-sysv
                if test x$gas = xyes
                then
                        tmake_file=mips/t-svr4-gas
                else
                        tmake_file=mips/t-svr4
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
changequote(,)dnl
        mips-*-sysv4* | mips-*-riscos[1234]sysv4* | mips-*-riscossysv4*)
changequote([,])dnl
                tm_file="mips/svr4-4.h ${tm_file}"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-sysv
                if test x$gas = xyes
                then
                        tmake_file=mips/t-svr4-gas
                else
                        tmake_file=mips/t-svr4
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
changequote(,)dnl
        mips-*-riscos[56789]sysv*)
changequote([,])dnl
                tm_file=mips/svr3-5.h   # MIPS System V.3, RISC-OS 5.0
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-sysv
                if test x$gas = xyes
                then
                        tmake_file=mips/t-svr3-gas
                else
                        tmake_file=mips/t-svr3
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-*-sysv* | mips-*-riscos*sysv*)
                tm_file="mips/svr3-4.h ${tm_file}"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                xm_defines=USG
                xmake_file=mips/x-sysv
                if test x$gas = xyes
                then
                        tmake_file=mips/t-svr3-gas
                else
                        tmake_file=mips/t-svr3
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
changequote(,)dnl
        mips-*-riscos[56789]*)          # Default MIPS RISC-OS 5.0.
changequote([,])dnl
                tm_file=mips/mips-5.h
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mips-*-gnu*)
                ;;
        mipsel-*-ecoff*)
                tm_file=mips/ecoffl.h
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                tmake_file=mips/t-ecoff
                ;;
        mips-*-ecoff*)
                tm_file="gofast.h mips/ecoff.h"
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                tmake_file=mips/t-ecoff
                ;;
        mipsel-*-elf*)
                tm_file="mips/elfl.h"
                tmake_file=mips/t-elf
                ;;
        mips-*-elf*)
                tm_file="mips/elf.h"
                tmake_file=mips/t-elf
                ;;
        mips64el-*-elf*)
                tm_file="mips/elfl64.h"
                tmake_file=mips/t-elf
                ;;
        mips64orionel-*-elf*)
                tm_file="mips/elforion.h mips/elfl64.h"
                tmake_file=mips/t-elf
                ;;
        mips64-*-elf*)
                tm_file="mips/elf64.h"
                tmake_file=mips/t-elf
                ;;
        mips64orion-*-elf*)
                tm_file="mips/elforion.h mips/elf64.h"
                tmake_file=mips/t-elf
                ;;
        mips64orion-*-rtems*)
                tm_file="mips/elforion.h mips/elf64.h mips/rtems64.h"
                tmake_file="mips/t-elf t-rtems"
                ;;
        mipstx39el-*-elf*)
                tm_file="mips/r3900.h mips/elfl.h mips/abi64.h"
                tmake_file=mips/t-r3900
                ;;
        mipstx39-*-elf*)
                tm_file="mips/r3900.h mips/elf.h mips/abi64.h"
                tmake_file=mips/t-r3900
                ;;
        mips-*-*)                               # Default MIPS RISC-OS 4.0.
                if test x$stabs = xyes; then
                        tm_file="${tm_file} dbx.h"
                fi
                if test x$gas = xyes
                then
                        tmake_file=mips/t-mips-gas
                else
                        extra_passes="mips-tfile mips-tdump"
                fi
                if test x$gnu_ld != xyes
                then
                        use_collect2=yes
                fi
                ;;
        mn10200-*-*)
                float_format=i32
                cpu_type=mn10200
                tm_file="mn10200/mn10200.h"
                if test x$stabs = xyes
                then
                        tm_file="${tm_file} dbx.h"
                fi
                use_collect2=no
                ;;
        mn10300-*-*)
                cpu_type=mn10300
                tm_file="mn10300/mn10300.h"
                if test x$stabs = xyes
                then
                        tm_file="${tm_file} dbx.h"
                fi
                use_collect2=no
                ;;
        ns32k-encore-bsd*)
                tm_file=ns32k/encore.h
                use_collect2=yes
                ;;
        ns32k-sequent-bsd*)
                tm_file=ns32k/sequent.h
                use_collect2=yes
                ;;
        ns32k-tek6100-bsd*)
                tm_file=ns32k/tek6100.h
                use_collect2=yes
                ;;
        ns32k-tek6200-bsd*)
                tm_file=ns32k/tek6200.h
                use_collect2=yes
                ;;
        ns32k-merlin-*)
                tm_file=ns32k/merlin.h
                use_collect2=yes
                ;;
        ns32k-pc532-mach*)
                tm_file=ns32k/pc532-mach.h
                use_collect2=yes
                ;;
        ns32k-pc532-minix*)
                tm_file=ns32k/pc532-min.h
                xm_file="ns32k/xm-pc532-min.h ${xm-file}"
                xm_defines=USG
                use_collect2=yes
                ;;
        ns32k-*-netbsd*)
                tm_file=ns32k/netbsd.h
                xm_file="ns32k/xm-netbsd.h ${xm_file}"
                # On NetBSD, the headers are already okay, except for math.h.
                tmake_file=t-netbsd
                use_collect2=yes
                ;;
        pdp11-*-bsd)
                tm_file="${tm_file} pdp11/2bsd.h"
                ;;
        pdp11-*-*)
                ;;
        avr-*-*)
                ;;
        ns32k-*-openbsd*)
                # Nothing special
                ;;
        pj*-linux*)
                tm_file="svr4.h pj/linux.h ${tm_file}"
                ;;
        pj-*)
                ;;
        pjl-*)
                tm_file="svr4.h pj/pjl.h ${tm_file}"
                ;;

        romp-*-aos*)
                use_collect2=yes
                ;;
        romp-*-mach*)
                xmake_file=romp/x-mach
                use_collect2=yes
                ;;
        romp-*-openbsd*)
                # Nothing special
                ;;
        powerpc-*-openbsd*)
                tmake_file="${tmake_file} rs6000/t-rs6000 rs6000/t-openbsd"
                ;;
        powerpc-*-beos*)
                cpu_type=rs6000
                tm_file=rs6000/beos.h
                xm_file=rs6000/xm-beos.h
                tmake_file=rs6000/t-beos
                xmake_file=rs6000/x-beos
                ;;
        powerpc-*-sysv*)
                tm_file=rs6000/sysv4.h
                xm_file="rs6000/xm-sysv4.h"
                xm_defines="USG POSIX"
                extra_headers=ppc-asm.h
                tmake_file="rs6000/t-ppcos rs6000/t-ppccomm"
                xmake_file=rs6000/x-sysv4
                ;;
        powerpc-*-eabiaix*)
                tm_file="rs6000/sysv4.h rs6000/eabi.h rs6000/eabiaix.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpc-*-eabisim*)
                tm_file="rs6000/sysv4.h rs6000/eabi.h rs6000/eabisim.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpc-*-elf*)
                tm_file="rs6000/sysv4.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpc-*-eabi*)
                tm_file="rs6000/sysv4.h rs6000/eabi.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpc-*-rtems*)
                tm_file="rs6000/sysv4.h rs6000/eabi.h rs6000/rtems.h"
                tmake_file="rs6000/t-ppcgas t-rtems rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpc-*-linux*libc1)
                tm_file="rs6000/sysv4.h rs6000/linux.h"
                xm_file=rs6000/xm-sysv4.h
                out_file=rs6000/rs6000.c
                tmake_file="rs6000/t-ppcos t-linux t-linux-gnulibc1 rs6000/t-ppccomm"
                xmake_file=x-linux
                extra_headers=ppc-asm.h
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        powerpc-*-linux*)
                tm_file="rs6000/sysv4.h rs6000/linux.h"
                xm_file="rs6000/xm-sysv4.h"
                xm_defines="USG ${xm_defines}"
                out_file=rs6000/rs6000.c
                tmake_file="rs6000/t-ppcos t-linux rs6000/t-ppccomm"
                xmake_file=x-linux
                extra_headers=ppc-asm.h
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                ;;
        powerpc-wrs-vxworks*)
                cpu_type=rs6000
                xm_file="rs6000/xm-sysv4.h"
                xm_defines="USG POSIX"
                tm_file="rs6000/sysv4.h rs6000/vxppc.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                thread_file='vxworks'
                ;;
        powerpcle-wrs-vxworks*)
                cpu_type=rs6000
                xm_file="rs6000/xm-sysv4.h"
                xm_defines="USG POSIX"
                tm_file="rs6000/sysv4.h rs6000/sysv4le.h rs6000/vxppc.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                thread_file='vxworks'
                ;;
        powerpcle-*-sysv*)
                tm_file="rs6000/sysv4.h rs6000/sysv4le.h"
                xm_file="rs6000/xm-sysv4.h"
                xm_defines="USG POSIX"
                tmake_file="rs6000/t-ppcos rs6000/t-ppccomm"
                xmake_file=rs6000/x-sysv4
                extra_headers=ppc-asm.h
                ;;
        powerpcle-*-elf*)
                tm_file="rs6000/sysv4.h rs6000/sysv4le.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpcle-*-eabisim*)
                tm_file="rs6000/sysv4.h rs6000/sysv4le.h rs6000/eabi.h rs6000/eabisim.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpcle-*-eabi*)
                tm_file="rs6000/sysv4.h rs6000/sysv4le.h rs6000/eabi.h"
                tmake_file="rs6000/t-ppcgas rs6000/t-ppccomm"
                extra_headers=ppc-asm.h
                ;;
        powerpcle-*-solaris2*)
                tm_file="rs6000/sysv4.h rs6000/sysv4le.h rs6000/sol2.h"
                xm_file="rs6000/xm-sysv4.h"
                xm_defines="USG POSIX"
                tmake_file="rs6000/t-ppcos rs6000/t-ppccomm"
                xmake_file=rs6000/x-sysv4
                extra_headers=ppc-asm.h
                ;;
changequote(,)dnl
        rs6000-ibm-aix3.[01]*)
changequote([,])dnl
                tm_file=rs6000/aix31.h
                xmake_file=rs6000/x-aix31
                float_format=none
                use_collect2=yes
                ;;
changequote(,)dnl
        rs6000-ibm-aix3.2.[456789]* | powerpc-ibm-aix3.2.[456789]*)
changequote([,])dnl
                tm_file=rs6000/aix3newas.h
                if test x$host != x$target
                then
                        tmake_file=rs6000/t-xnewas
                else
                        tmake_file=rs6000/t-newas
                fi
                float_format=none
                use_collect2=yes
                ;;
changequote(,)dnl
        rs6000-ibm-aix4.[12]* | powerpc-ibm-aix4.[12]*)
changequote([,])dnl
                tm_file=rs6000/aix41.h
                if test x$host != x$target
                then
                        tmake_file=rs6000/t-xnewas
                else
                        tmake_file=rs6000/t-newas
                fi
                if test "$gnu_ld" = yes
                then
                        xmake_file=rs6000/x-aix41-gld
                else
                        tmake_file='rs6000/t-newas'
                fi
                xmake_file=rs6000/x-aix41
                float_format=none
                use_collect2=yes
                ;;
changequote(,)dnl
        rs6000-ibm-aix4.[3456789]* | powerpc-ibm-aix4.[3456789]*)
changequote([,])dnl
                tm_file=rs6000/aix43.h
                tmake_file=rs6000/t-aix43
                xmake_file=rs6000/x-aix41
                float_format=none
                use_collect2=yes
                thread_file='aix'
                ;;
changequote(,)dnl
        rs6000-ibm-aix[56789].* | powerpc-ibm-aix[56789].*)
changequote([,])dnl
                tm_file=rs6000/aix43.h
                tmake_file=rs6000/t-aix43
                xmake_file=rs6000/x-aix41
                float_format=none
                use_collect2=yes
                thread_file='aix'
                ;;
        rs6000-ibm-aix*)
                float_format=none
                use_collect2=yes
                ;;
        rs6000-bull-bosx)
                float_format=none
                use_collect2=yes
                ;;
        rs6000-*-mach*)
                tm_file=rs6000/mach.h
                xm_file="${xm_file} rs6000/xm-mach.h"
                xmake_file=rs6000/x-mach
                use_collect2=yes
                ;;
        rs6000-*-lynxos*)
                tm_file=rs6000/lynx.h
                xm_file=rs6000/xm-lynx.h
                tmake_file=rs6000/t-rs6000
                xmake_file=rs6000/x-lynx
                use_collect2=yes
                ;;
        sh-*-elf*)
                tmake_file="sh/t-sh sh/t-elf"
                tm_file="sh/sh.h sh/elf.h"
                float_format=sh
                ;;
        sh-*-rtemself*)
                tmake_file="sh/t-sh sh/t-elf t-rtems"
                tm_file="sh/sh.h sh/elf.h sh/rtemself.h"
                float_format=sh
                ;;
        sh-*-rtems*)
                tmake_file="sh/t-sh t-rtems"
                tm_file="sh/sh.h sh/rtems.h"
                float_format=sh
                ;;
        sh-*-linux*)
                tm_file="sh/sh.h sh/elf.h sh/linux.h"
                tmake_file="sh/t-sh sh/t-elf sh/t-linux"
                xmake_file=x-linux
                gas=yes gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                float_format=sh
                ;;
        sh-*-*)
                float_format=sh
                ;;
        sparc-tti-*)
                tm_file=sparc/pbd.h
                xm_file="xm-alloca.h ${xm_file}"
                xm_defines=USG
                ;;
        sparc-wrs-vxworks* | sparclite-wrs-vxworks*)
                tm_file=sparc/vxsparc.h
                tmake_file=sparc/t-vxsparc
                use_collect2=yes
                thread_file='vxworks'
                ;;
        sparc-*-aout*)
                tmake_file=sparc/t-sparcbare
                tm_file="sparc/aout.h libgloss.h"
                ;;
        sparc-*-netbsd*)
                tm_file=sparc/netbsd.h
                tmake_file=t-netbsd
                use_collect2=yes
                ;;
        sparc-*-openbsd*)
                # we need collect2 until our bug is fixed...
                use_collect2=yes
                ;;
        sparc-*-bsd*)
                tm_file=sparc/bsd.h
                ;;
        sparc-*-elf*)
                tm_file=sparc/elf.h
                tmake_file=sparc/t-elf
                extra_parts="crti.o crtn.o crtbegin.o crtend.o"
                #float_format=i128
                float_format=i64
                ;;
        sparc-*-linux*aout*)            # Sparc's running GNU/Linux, a.out
                xm_file="${xm_file} sparc/xm-linux.h"
                tm_file=sparc/linux-aout.h
                xmake_file=x-linux
                gnu_ld=yes
                ;;
        sparc-*-linux*libc1*)   # Sparc's running GNU/Linux, libc5
                xm_file="${xm_file} sparc/xm-linux.h"
                xmake_file=x-linux
                tm_file=sparc/linux.h
                tmake_file="t-linux t-linux-gnulibc1"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                float_format=sparc
                ;;
        sparc-*-linux*)         # Sparc's running GNU/Linux, libc6
                xm_file="${xm_file} sparc/xm-linux.h"
                xmake_file=x-linux
                tm_file=sparc/linux.h
                tmake_file="t-linux"
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                float_format=sparc
                ;;
        sparc-*-lynxos*)
                if test x$gas = xyes
                then
                        tm_file=sparc/lynx.h
                else
                        tm_file=sparc/lynx-ng.h
                fi
                xm_file=sparc/xm-lynx.h
                tmake_file=sparc/t-sunos41
                xmake_file=x-lynx
                ;;
        sparc-*-rtemsaout*)
                tmake_file="sparc/t-sparcbare t-rtems"
                tm_file=sparc/rtems.h
                ;;
        sparc-*-rtems*|sparc-*-rtemself*)
                tm_file="sparc/rtemself.h"
                tmake_file="sparc/t-elf t-rtems"
                extra_parts="crti.o crtn.o crtbegin.o crtend.o"
                #float_format=i128
                float_format=i64
                ;;
        sparcv9-*-solaris2*)
                if test x$gnu_ld = xyes
                then
                        tm_file=sparc/sol2-64.h
                else
                        tm_file=sparc/sol2-sld-64.h
                fi
                xm_file="sparc/xm-sysv4-64.h sparc/xm-sol2.h"
                xm_defines="USG POSIX"
                tmake_file="sparc/t-sol2 sparc/t-sol2-64"
                if test x$gnu_ld = xyes; then
                        tmake_file="$tmake_file sparc/t-slibgcc"
                else
                        tmake_file="$tmake_file sparc/t-slibgcc-sld"
                fi
                xmake_file=sparc/x-sysv4
                extra_parts="crt1.o crti.o crtn.o gcrt1.o crtbegin.o crtend.o"
                float_format=none
                if test x${enable_threads} = x ; then
                    enable_threads=$have_pthread_h
                    if test x${enable_threads} = x ; then
                        enable_threads=$have_thread_h
                    fi
                fi
                if test x${enable_threads} = xyes ; then
                    if test x${have_pthread_h} = xyes ; then
                        thread_file='posix'
                    else
                        thread_file='solaris'
                    fi
                fi
                ;;
        sparc-hal-solaris2*)
                xm_file="sparc/xm-sysv4.h sparc/xm-sol2.h"
                xm_defines="USG POSIX"
                tm_file="sparc/sol2.h sparc/hal.h"
                tmake_file="sparc/t-halos sparc/t-sol2"
                if test x$gnu_ld = xyes; then
                        tmake_file="$tmake_file sparc/t-slibgcc"
                else
                        tmake_file="$tmake_file sparc/t-slibgcc-sld"
                fi
                xmake_file=sparc/x-sysv4
                extra_parts="crt1.o crti.o crtn.o gmon.o crtbegin.o crtend.o"
                case $machine in
changequote(,)dnl
                *-*-solaris2.[0-4])
changequote([,])dnl
                        float_format=i128
                ;;
                *)
                        float_format=none
                        ;;
                esac
                thread_file='solaris'
                ;;
        sparc-*-solaris2*)
                if test x$gnu_ld = xyes
                then
                        tm_file=sparc/sol2.h
                else
                        tm_file=sparc/sol2-sld.h
                fi
                xm_file="sparc/xm-sysv4.h sparc/xm-sol2.h"
                xm_defines="USG POSIX"
                tmake_file=sparc/t-sol2
                if test x$gnu_ld = xyes; then
                        tmake_file="$tmake_file sparc/t-slibgcc"
                else
                        tmake_file="$tmake_file sparc/t-slibgcc-sld"
                fi
                xmake_file=sparc/x-sysv4
                extra_parts="crt1.o crti.o crtn.o gcrt1.o gmon.o crtbegin.o crtend.o"
# At the moment, 32-to-64 cross compilation doesn't work.
#               case $machine in
#changequote(,)dnl
#               *-*-solaris2.[0-6] | *-*-solaris2.[0-6].*) ;;
#changequote([,])dnl
#               *-*-solaris2*)
#                       if test x$gnu_ld = xyes
#                       then
#                               tm_file=sparc/sol2-64.h
#                       else
#                               tm_file=sparc/sol2-sld-64.h
#                       fi
#                       tmake_file="$tmake_file sparc/t-sol2-64"
#                       ;;
#               esac
                case $machine in
changequote(,)dnl
                *-*-solaris2.[0-4])
changequote([,])dnl
                        float_format=i128
                        ;;
                *)
                        float_format=none
                        ;;
                esac
                if test x${enable_threads} = x; then
                    enable_threads=$have_pthread_h
                    if test x${enable_threads} = x; then
                        enable_threads=$have_thread_h
                    fi
                fi
                if test x${enable_threads} = xyes; then
                    if test x${have_pthread_h} = xyes; then
                        thread_file='posix'
                    else
                        thread_file='solaris'
                    fi
                fi
                ;;
        sparc-*-sunos4.0*)
                tm_file=sparc/sunos4.h
                tmake_file=sparc/t-sunos40
                use_collect2=yes
                ;;
        sparc-*-sunos4*)
                tm_file=sparc/sunos4.h
                tmake_file=sparc/t-sunos41
                use_collect2=yes
                if test x$gas = xyes; then
                        tm_file="${tm_file} sparc/sun4gas.h"
                fi
                ;;
        sparc-*-sunos3*)
                tm_file=sparc/sun4o3.h
                use_collect2=yes
                ;;
        sparc-*-sysv4*)
                tm_file=sparc/sysv4.h
                xm_file="sparc/xm-sysv4.h"
                xm_defines="USG POSIX"
                tmake_file=t-svr4
                xmake_file=sparc/x-sysv4
                extra_parts="crtbegin.o crtend.o"
                ;;
        sparc-*-vxsim*)
                xm_file="sparc/xm-sysv4.h sparc/xm-sol2.h"
                xm_defines="USG POSIX"
                tm_file=sparc/vxsim.h
                tmake_file=sparc/t-vxsparc
                xmake_file=sparc/x-sysv4
                ;;
        sparclet-*-aout*)
                tm_file="sparc/splet.h libgloss.h"
                tmake_file=sparc/t-splet
                ;;
        sparclite-*-coff*)
                tm_file="sparc/litecoff.h libgloss.h"
                tmake_file=sparc/t-sparclite
                ;;
        sparclite-*-aout*)
                tm_file="sparc/lite.h aoutos.h libgloss.h"
                tmake_file=sparc/t-sparclite
                ;;
        sparclite-*-elf*)
                tm_file="sparc/liteelf.h"
                tmake_file=sparc/t-sparclite
                extra_parts="crtbegin.o crtend.o"
                ;;
        sparc86x-*-aout*)
                tm_file="sparc/sp86x-aout.h aoutos.h libgloss.h"
                tmake_file=sparc/t-sp86x
                ;;
        sparc86x-*-elf*)        
                tm_file="sparc/sp86x-elf.h"
                tmake_file=sparc/t-sp86x
                extra_parts="crtbegin.o crtend.o"
                ;;
        sparc64-*-aout*)
                tmake_file=sparc/t-sp64
                tm_file=sparc/sp64-aout.h
                ;;
        sparc64-*-elf*)
                tmake_file=sparc/t-sp64
                tm_file=sparc/sp64-elf.h
                extra_parts="crtbegin.o crtend.o"
                ;;
        sparc64-*-linux*)               # 64-bit Sparc's running GNU/Linux
                tmake_file="t-linux sparc/t-linux64"
                xm_file="sparc/xm-sp64.h sparc/xm-linux.h"
                tm_file=sparc/linux64.h
                xmake_file=x-linux
                extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
                gnu_ld=yes
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
                float_format=sparc
                ;;
        thumb*-*-*)
                AC_MSG_ERROR([
*** The Thumb targets have been depreciated.  The equivalent
*** ARM based toolchain can now generated Thumb instructions
*** when the -mthumb switch is given to the compiler.])
                ;;
        v850-*-rtems*)
                cpu_type=v850
                tm_file="v850/rtems.h"
                xm_file="v850/xm-v850.h"
                tmake_file="v850/t-v850 t-rtems"
                if test x$stabs = xyes
                then
                        tm_file="${tm_file} dbx.h"
                fi
                use_collect2=no
                ;;
        v850-*-*)
                target_cpu_default="TARGET_CPU_generic"
                cpu_type=v850
                tm_file="v850/v850.h"
                xm_file="v850/xm-v850.h"
                tmake_file=v850/t-v850
                if test x$stabs = xyes
                then
                        tm_file="${tm_file} dbx.h"
                fi
                use_collect2=no
                ;;
        vax-*-bsd*)                     # vaxen running BSD
                use_collect2=yes
                float_format=vax
                ;;
        vax-*-sysv*)                    # vaxen running system V
                tm_file="${tm_file} vax/vaxv.h"
                xm_defines=USG
                float_format=vax
                ;;
        vax-*-netbsd*)
                tm_file="${tm_file} netbsd.h vax/netbsd.h"
                tmake_file=t-netbsd
                float_format=vax
                use_collect2=yes
                ;;
        vax-*-openbsd*)
                tmake_file="${tmake_file} vax/t-openbsd"
                tm_file="vax/vax.h vax/openbsd1.h openbsd.h ${tm_file}"
                xm_file="xm-openbsd.h vax/xm-vax.h"
                float_format=vax
                use_collect2=yes
                ;;
        vax-*-ultrix*)                  # vaxen running ultrix
                tm_file="${tm_file} vax/ultrix.h"
                float_format=vax
                ;;
        vax-*-vms*)                     # vaxen running VMS
                xm_file=vax/xm-vms.h
                tm_file=vax/vms.h
                float_format=vax
                ;;
        vax-*-*)                        # vax default entry
                float_format=vax
                ;;
        we32k-att-sysv*)
                xm_file="${xm_file} xm-svr3"
                use_collect2=yes
                ;;
        *)
                echo "Configuration $machine not supported" 1>&2
                exit 1
                ;;
        esac

        case $machine in
        *-*-linux*)
                ;; # Existing GNU/Linux systems do not use the GNU setup.
        *-*-gnu*)
                # On the GNU system, the setup is just about the same on
                # each different CPU.  The specific machines that GNU
                # supports are matched above and just set $cpu_type.
                xm_file="xm-gnu.h ${xm_file}"
                tm_file=${cpu_type}/gnu.h
                extra_parts="crtbegin.o crtend.o crtbeginS.o crtendS.o"
                # GNU always uses ELF.
                elf=yes
                # GNU tools are the only tools.
                gnu_ld=yes
                gas=yes
                xmake_file=x-linux      # These details are the same as Linux.
                tmake_file=t-gnu        # These are not.
                ;;
        *-*-sysv4*)
                xmake_try_sysv=x-sysv
                install_headers_dir=install-headers-cpio
                ;;
        *-*-sysv*)
                install_headers_dir=install-headers-cpio
                ;;
        esac

        # Distinguish i[34567]86
        # Also, do not run mips-tfile on MIPS if using gas.
        # Process --with-cpu= for PowerPC/rs6000
        target_cpu_default2=
        case $machine in
        i486-*-*)
                target_cpu_default2=1
                ;;
        i586-*-*)
                case $target_alias in
                        k6-*)
                                target_cpu_default2=4
                                ;;
                        *)
                                target_cpu_default2=2
                                ;;
                esac
                ;;
        i686-*-* | i786-*-*)
                target_cpu_default2=3
                ;;
        alpha*-*-*)
                case $machine in
changequote(,)dnl
                        alphaev6[78]*)
changequote([,])dnl
                                target_cpu_default2="MASK_CPU_EV6|MASK_BWX|MASK_MAX|MASK_FIX|MASK_CIX"
                                ;;
                        alphaev6*)
                                target_cpu_default2="MASK_CPU_EV6|MASK_BWX|MASK_MAX|MASK_FIX"
                                ;;
                        alphapca56*)
                                target_cpu_default2="MASK_CPU_EV5|MASK_BWX|MASK_MAX"
                                ;;
                        alphaev56*)
                                target_cpu_default2="MASK_CPU_EV5|MASK_BWX"
                                ;;
                        alphaev5*)
                                target_cpu_default2="MASK_CPU_EV5"
                                ;;
                esac
                                
                if test x$gas = xyes
                then
                        if test "$target_cpu_default2" = ""
                        then
                                target_cpu_default2="MASK_GAS"
                        else
                                target_cpu_default2="${target_cpu_default2}|MASK_GAS"
                        fi
                fi
                ;;
        arm*-*-*)
                case "x$with_cpu" in
                        x)
                                # The most generic
                                target_cpu_default2="TARGET_CPU_generic"
                                ;;

                        # Distinguish cores, and major variants
                        # arm7m doesn't exist, but D & I don't affect code
changequote(,)dnl
                        xarm[23678] | xarm250 | xarm[67][01]0 \
                        | xarm7m | xarm7dm | xarm7dmi | xarm7tdmi \
                        | xarm7100 | xarm7500 | xarm7500fe | xarm810 \
                        | xstrongarm | xstrongarm110 | xstrongarm1100)
changequote([,])dnl
                                target_cpu_default2="TARGET_CPU_$with_cpu"
                                ;;

                        xyes | xno)
                                echo "--with-cpu must be passed a value" 1>&2
                                exit 1
                                ;;

                        *)
                                if test x$pass2done = xyes
                                then
                                        echo "Unknown cpu used with --with-cpu=$with_cpu" 1>&2
                                        exit 1
                                fi
                                ;;
                esac
                ;;

        mips*-*-ecoff* | mips*-*-elf*)
                if test x$gas = xyes
                then
                        if test x$gnu_ld = xyes
                        then
                                target_cpu_default2="MASK_GAS|MASK_SPLIT_ADDR"
                        else
                                target_cpu_default2="MASK_GAS"
                        fi
                fi
                ;;
        mips*-*-*)
                if test x$gas = xyes
                then
                        target_cpu_default2="MASK_GAS"
                fi
                ;;
        powerpc*-*-* | rs6000-*-*)
                case "x$with_cpu" in
                        x)
                                ;;

                        xcommon | xpower | xpower2 | xpowerpc | xrios \
                          | xrios1 | xrios2 | xrsc | xrsc1 \
                          | x601 | x602 | x603 | x603e | x604 | x604e | x620 \
                          | xec603e | x740 | x750 | x401 \
                          | x403 | x505 | x801 | x821 | x823 | x860)
                                target_cpu_default2="\"$with_cpu\""
                                ;;

                        xyes | xno)
                                echo "--with-cpu must be passed a value" 1>&2
                                exit 1
                                ;;

                        *)
                                if test x$pass2done = xyes
                                then
                                        echo "Unknown cpu used with --with-cpu=$with_cpu" 1>&2
                                        exit 1
                                fi
                                ;;
                esac
                ;;
        sparc*-*-*)
                case ".$with_cpu" in
                        .)
                                target_cpu_default2=TARGET_CPU_"`echo $machine | sed 's/-.*$//'`"
                                ;;
                        .supersparc | .hypersparc | .ultrasparc | .v7 | .v8 | .v9)
                                target_cpu_default2="TARGET_CPU_$with_cpu"
                                ;;
                        *)
                                if test x$pass2done = xyes
                                then
                                        echo "Unknown cpu used with --with-cpu=$with_cpu" 1>&2
                                        exit 1
                                fi
                                ;;
                esac
                ;;
        esac

        if test "$target_cpu_default2" != ""
        then
                if test "$target_cpu_default" != ""
                then
                        target_cpu_default="(${target_cpu_default}|${target_cpu_default2})"
                else
                        target_cpu_default=$target_cpu_default2
                fi
        fi

        # No need for collect2 if we have the GNU linker.
        # Actually, there is now; GNU ld doesn't handle the EH info or
        # collecting for shared libraries.
        #case x$gnu_ld in
        #xyes)
        #       use_collect2=
        #       ;;
        #esac

# Save data on machine being used to compile GCC in build_xm_file.
# Save data on host machine in vars host_xm_file and host_xmake_file.
        if test x$pass1done = x
        then
                if test x"$xm_file" = x
                then build_xm_file=$cpu_type/xm-$cpu_type.h
                else build_xm_file=$xm_file
                fi
                build_xm_defines=$xm_defines
                build_install_headers_dir=$install_headers_dir
                build_exeext=$exeext
                pass1done=yes
        else
                if test x$pass2done = x
                then
                        if test x"$xm_file" = x
                        then host_xm_file=$cpu_type/xm-$cpu_type.h
                        else host_xm_file=$xm_file
                        fi
                        host_xm_defines=$xm_defines
                        if test x"$xmake_file" = x
                        then xmake_file=$cpu_type/x-$cpu_type
                        fi
                        host_xmake_file="$xmake_file"
                        host_truncate_target=$truncate_target
                        host_extra_gcc_objs=$extra_gcc_objs
                        host_extra_objs=$extra_host_objs
                        host_exeext=$exeext
                        pass2done=yes
                fi
        fi
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"$xm_file" = x
then xm_file=$cpu_type/xm-$cpu_type.h; 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' to output insns."
echo "Using \`$srcdir/config/$md_file' as machine description file."

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 = 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 = 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

# Set up the header files.
# $links is the list of header files to create.
# $vars is the list of shell variables with file names to include.
# auto-host.h is the file containing items generated by autoconf and is
# the first file included by config.h.
null_defines=
host_xm_file="auto-host.h gansidecl.h ${host_xm_file} hwint.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_xm_file="auto-host.h gansidecl.h ${build_xm_file} hwint.h"
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
        /*) realsrcdir=${srcdir};;
        *) realsrcdir=../${srcdir};;
        esac
        CC=${CC_FOR_BUILD} ${realsrcdir}/configure \
                --target=$target --host=$build --build=$build

        # 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_xm_file="auto-build.h gansidecl.h ${build_xm_file} hwint.h"
fi

xm_file="gansidecl.h ${xm_file}"
tm_file="gansidecl.h ${tm_file}"

vars="host_xm_file tm_file tm_p_file xm_file build_xm_file"
links="config.h tm.h tm_p.h tconfig.h hconfig.h"
defines="host_xm_defines null_defines null_defines xm_defines build_xm_defines"

rm -f config.bak
if test -f config.status; then mv -f config.status config.bak; fi

# Make the links.
while test -n "$vars"
do
        set $vars; var=$1; shift; vars=$*
        set $links; link=$1; shift; links=$*
        set $defines; define=$1; shift; defines=$*

        rm -f $link
        # Make sure the file is created, even if it is empty.
        echo >$link

        # Define TARGET_CPU_DEFAULT if the system wants one.
        # This substitutes for lots of *.h files.
        if test "$target_cpu_default" != "" -a $link = tm.h
        then
                echo "#define TARGET_CPU_DEFAULT ($target_cpu_default)" >>$link
        fi

        for file in `eval echo '$'$var`; do
                case $file in
                auto-host.h | auto-build.h )
                        ;;
                *)
                        echo '#ifdef IN_GCC' >>$link
                        ;;
                esac
                echo "#include \"$file\"" >>$link
                case $file in
                auto-host.h | auto-build.h )
                        ;;
                *)
                        echo '#endif' >>$link
                        ;;
                esac
        done

        for def in `eval echo '$'$define`; do
                echo "#ifndef $def" >>$link
                echo "#define $def" >>$link
                echo "#endif" >>$link
        done
done

# 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=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^ \"]*\)[ \"].*/\1/'`
changequote([,])dnl

# Internationalization
PACKAGE=gcc
VERSION="$gcc_version"
AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",
        [Define to the name of the distribution.])
AC_DEFINE_UNQUOTED(VERSION, "$VERSION",
        [Define to the version of the distribution.])
AC_SUBST(PACKAGE)
AC_SUBST(VERSION)

ALL_LINGUAS="en_GB"

# 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
XGETTEXT="AWK='$AWK' \$(SHELL) \$(top_srcdir)/exgettext $XGETTEXT"

# 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.],,)

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)
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

# 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)"
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\`"
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
    gansidecl.h )
       tm_file_list="${tm_file_list} $f" ;;
    *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
  esac
done

host_xm_file_list=
for f in $host_xm_file; do
  case $f in
    auto-host.h | gansidecl.h | hwint.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
    auto-build.h | auto-host.h | gansidecl.h | hwint.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 add cross-make to Makefile.
cross_overrides="/dev/null"
if test x$host != x$target
then
        cross_defines="CROSS=-DCROSS_COMPILE"
        cross_overrides="${topdir}/cross-make"
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 will cause __eprintf to be left out of
# libgcc.a, but that's OK because newlib should have its own version of
# assert.h.
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 fix a few things.
# This must come after cross-make as we want all.build to override
# all.cross.
build_overrides="/dev/null"
if test x$build != x$host
then
        build_overrides="${topdir}/build-make"
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}/ginclude/ to every entry in extra_headers.
        for file in $extra_headers;
        do
                extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/${file}"
        done
fi

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

# Add a definition of USE_COLLECT2 if system wants one.
# Also tell toplev.c what to do.
# This substitutes for lots of t-* files.
if test x$use_collect2 = x
then
        will_use_collect2=
        maybe_use_collect2=
else
        will_use_collect2="collect2"
        maybe_use_collect2="-DUSE_COLLECT2"
fi

# NEED TO CONVERT
# Set MD_DEPS if the real md file is in md.pre-cpp.
# Set MD_CPP to the cpp to pass the md file through.  Md files use ';'
# for line oriented comments, so we must always use a GNU cpp.  If
# building gcc with a cross compiler, use the cross compiler just
# built.  Otherwise, we can use the cpp just built.
md_file_sub=
if test "x$md_cppflags" = x
then
        md_file_sub=$srcdir/config/$md_file
else
        md_file=md
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 in the build tree, make a link to it.
if test -f ../binutils/Makefile; then
        rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$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
#       if test x$use_collect2 = x; then
#               rm -f ld; $symbolic_link ../ld/ld-new$host_exeext ld$host_exeext 2>/dev/null
#       else
                rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
#       fi
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
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_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$host = x$target; then
        # Native build.
        # 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.
        as=as$host_exeext

        test_dirs="$test_prefix/lib/gcc-lib/$target/$gcc_version \
                   $test_prefix/lib/gcc-lib/$target \
                   /usr/lib/gcc/$target/$gcc_version \
                   /usr/lib/gcc/$target \
                   $test_prefix/$target/bin/$target/$gcc_version \
                   $test_prefix/$target/bin \
                   /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"

        for dir in $test_dirs; do
                if test -f $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 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$host = x$target; then
        # Native build.
        gcc_cv_nm=nm$host_exeext
fi
AC_MSG_RESULT($gcc_cv_nm)

# Figure out what assembler alignment features are present.
AC_MSG_CHECKING(assembler alignment features)
gcc_cv_as_alignment_features=
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=
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=
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=
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)

case "$target" in 
  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

    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-*-*)
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" | tr '[a-z ]' '[A-Z_]'`)
    fi
    AC_MSG_RESULT($gcc_cv_as_instructions)
    ;;
esac

# 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.
if test x"${enable_languages+set}" != xset; then
        if test x"${LANGUAGES+set}" = xset; then
                enable_languages="`echo ${LANGUAGES} | tr ' ' ','`"
        else
                enable_languages=all
        fi
else
        if test x"${enable_languages}" = x; then
                AC_MSG_ERROR([--enable-languages needs at least one argument])
        fi
fi
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`
          if test "x$lang_alias" = x
          then
                echo "$lang doesn't set \$language." 1>&2
                exit 1
          fi
          if test x"${enable_languages}" = xall && test x"${lang_alias}" != xCHILL; then
                add_this_lang=yes
          else
                case "${enable_languages}" in
                    ${lang_alias} | "${lang_alias},"* | *",${lang_alias},"* | *",${lang_alias}" )
                        add_this_lang=yes
                        ;;
                    * )
                        add_this_lang=no
                        ;;
                esac
          fi
          if test x"${add_this_lang}" = xyes; then
                case $lang in
                    ${srcdir}/ada/config-lang.in)
                        if test x$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],
[if test $ac_cv_func_mmap_anywhere = yes \
    || test $ac_cv_func_valloc = yes; then
  GGC=ggc-page
else
  GGC=ggc-simple
fi])
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)

# Build a new-abi (c++) system
AC_ARG_ENABLE(new-gxx-abi,
[  --enable-new-gxx-abi
                          select the new abi for g++. You must select an ABI
                          at configuration time, so that the correct runtime
                          support is built. You cannot mix ABIs.],
[AC_DEFINE(ENABLE_NEW_GXX_ABI, 1,
        [Define if you want to always select the new-abi for g++.])
GXX_ABI_FLAG='-fnew-abi'
echo "Building a new-abi g++ compiler."
])
AC_SUBST(GXX_ABI_FLAG)

# Build a new-libstdc++ system (ie libstdc++-v3)
AC_MSG_CHECKING([for libstdc++ to install])
AC_ARG_ENABLE(libstdcxx-v3,
[  --enable-libstdcxx-v3 
                          enable libstdc++-v3 for building and installation],
  [enable_libstdcxx_v3="$enableval"], [enable_libstdcxx_v3=no])

if test x$enable_libstdcxx_v3 = xyes; then
  AC_MSG_RESULT(v3)
  ac_esn=1
else
  AC_MSG_RESULT(v2)
  ac_esn=0
fi
AC_DEFINE_UNQUOTED(ENABLE_STD_NAMESPACE, $ac_esn,
  [Define to 1 if you want to enable namespaces (-fhonor-std) by default.])

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

# 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=
rm -f specs.h options.h gencheck.h
touch specs.h options.h gencheck.h
for subdir in . $subdirs
do
        if test -f $srcdir/$subdir/lang-specs.h; then
                echo "#include \"$subdir/lang-specs.h\"" >>specs.h
                lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
        fi
        if test -f $srcdir/$subdir/lang-options.h; then
                echo "#include \"$subdir/lang-options.h\"" >>options.h
                lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
        fi
        if test -f $srcdir/$subdir/$subdir-tree.def; then
                echo "#include \"$subdir/$subdir-tree.def\"" >>gencheck.h
                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_diff_excludes=
all_outputs='Makefile intl/Makefile po/Makefile.in fixinc/Makefile gccbug mklibgcc'
# List of language makefile fragments.
all_lang_makefiles=
all_headers=
all_lib2funcs=

# 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"
oldstyle_subdirs=

for s in .. $subdirs
do
        if test $s != ".."
        then
                language=
                boot_language=
                compilers=
                stagestuff=
                diff_excludes=
                headers=
                outputs=
                lib2funcs=
                . ${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 ${srcdir}/$s/Makefile.in"
                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_diff_excludes="$all_diff_excludes $diff_excludes"
                all_headers="$all_headers $headers"
                all_outputs="$all_outputs $outputs"
                if test x$outputs = x
                then
                        oldstyle_subdirs="$oldstyle_subdirs $s"
                fi
                all_lib2funcs="$all_lib2funcs $lib2funcs"
        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 \
        install-normal install-common install-info install-man \
        uninstall distdir \
        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

# If we're not building in srcdir, create .gdbinit.

if test ! -f Makefile.in; then
        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" >> .gdbinit
fi

# 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}/
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 occurance 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)

# 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_diff_excludes)
AC_SUBST(all_headers)
AC_SUBST(all_lang_makefiles)
AC_SUBST(all_languages)
AC_SUBST(all_lib2funcs)
AC_SUBST(all_stagestuff)
AC_SUBST(build_exeext)
AC_SUBST(build_install_headers_dir)
AC_SUBST(build_xm_file_list)
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_c_flags)
AC_SUBST(extra_c_objs)
AC_SUBST(extra_cpp_objs)
AC_SUBST(extra_cxx_objs)
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_gxx_include_dir)
AC_SUBST(gcc_version)
AC_SUBST(gcc_version_trigger)
AC_SUBST(host_exeext)
AC_SUBST(host_extra_gcc_objs)
AC_SUBST(host_xm_file_list)
AC_SUBST(install)
AC_SUBST(lang_options_files)
AC_SUBST(lang_specs_files)
AC_SUBST(lang_tree_files)
AC_SUBST(local_prefix)
AC_SUBST(maybe_use_collect2)
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(symbolic_link)
AC_SUBST(thread_file)
AC_SUBST(tm_file_list)
AC_SUBST(will_use_collect2)


AC_SUBST_FILE(target_overrides)
AC_SUBST_FILE(host_overrides)
AC_SUBST(cross_defines)
AC_SUBST_FILE(cross_overrides)
AC_SUBST_FILE(build_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,
[
. $srcdir/configure.lang
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} ; 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
],
[
host='${host}'
build='${build}'
target='${target}'
target_alias='${target_alias}'
srcdir='${srcdir}'
subdirs='${subdirs}'
oldstyle_subdirs='${oldstyle_subdirs}'
symbolic_link='${symbolic_link}'
program_transform_set='${program_transform_set}'
program_transform_name='${program_transform_name}'
dep_host_xmake_file='${dep_host_xmake_file}'
host_xmake_file='${host_xmake_file}'
dep_tmake_file='${dep_tmake_file}'
tmake_file='${tmake_file}'
thread_file='${thread_file}'
gcc_version='${gcc_version}'
gcc_version_trigger='${gcc_version_trigger}'
local_prefix='${local_prefix}'
build_install_headers_dir='${build_install_headers_dir}'
build_exeext='${build_exeext}'
host_exeext='${host_exeext}'
out_file='${out_file}'
gdb_needs_out_file_path='${gdb_needs_out_file_path}'
SET_MAKE='${SET_MAKE}'
target_list='${target_list}'
target_overrides='${target_overrides}'
host_overrides='${host_overrides}'
cross_defines='${cross_defines}'
cross_overrides='${cross_overrides}'
build_overrides='${build_overrides}'
cpp_install_dir='${cpp_install_dir}'
])