update

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

# 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"
		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"
		    # 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"
		    ;;
		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
 		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"
		;;
# This hasn't been upgraded to GCC 2.
#	fx80-alliant-*)			# Alliant FX/80
#		;;
	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-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"
		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 libgloss.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
		;;
# This has not been updated to GCC 2.
#	ns32k-ns-genix*)
#		xm_defines=USG
#		xmake_file=ns32k/x-genix
#		tm_file=ns32k/genix.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
		;;
# This has not been updated to GCC 2.
#	pyramid-*-*)
#		cpu_type=pyr
#		xmake_file=pyr/x-pyr
#		use_collect2=yes
#		;;

  	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"
		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"
                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
		xmake_file=sparc/x-sysv4
		extra_parts="crt1.o crti.o crtn.o gcrt1.o gmon.o crtbegin.o crtend.o"
		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
		;;
# This hasn't been upgraded to GCC 2.
#	tahoe-harris-*)			# Harris tahoe, using COFF.
#		tm_file=tahoe/harris.h
#		;;
#	tahoe-*-bsd*)			# tahoe running BSD
#		;;

	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.])
		;;
# This hasn't been upgraded to GCC 2.
#	tron-*-*)
#		cpu_type=gmicro
#		use_collect2=yes
#		;;
	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; 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}'
])