# First, test for a proper version of make, but only where one is required.

ifeq (,$(.VARIABLES)) # The variable .VARIABLES, new with 3.80, is never empty.
$(error GNU make version 3.80 or newer is required.)
endif

# -------------------------------
# Standard Autoconf-set variables
# -------------------------------
VPATH=../gcc-10.2.0

build_alias=arm-apple-darwin21.1.0
build_vendor=apple
build_os=darwin21.1.0
build=arm-apple-darwin21.1.0
host_alias=arm-apple-darwin21.1.0
host_vendor=apple
host_os=darwin21.1.0
host=arm-apple-darwin21.1.0
target_alias=i686-elf
target_vendor=pc
target_os=elf
target=i686-pc-elf

program_transform_name = s&^&i686-elf-&

prefix = /usr/local/x86_64elfgcc
exec_prefix = ${prefix}

srcdir = ../gcc-10.2.0

bindir = ${exec_prefix}/bin
sbindir = ${exec_prefix}/sbin
libexecdir = ${exec_prefix}/libexec
datadir = ${datarootdir}
sysconfdir = ${prefix}/etc
sharedstatedir = ${prefix}/com
localstatedir = ${prefix}/var
libdir = ${exec_prefix}/lib
includedir = ${prefix}/include
oldincludedir = /usr/include
infodir = ${datarootdir}/info
datarootdir = ${prefix}/share
docdir = ${datarootdir}/doc/${PACKAGE}
pdfdir = ${docdir}
htmldir = ${docdir}
mandir = ${datarootdir}/man
man1dir = $(mandir)/man1
man2dir = $(mandir)/man2
man3dir = $(mandir)/man3
man4dir = $(mandir)/man4
man5dir = $(mandir)/man5
man6dir = $(mandir)/man6
man7dir = $(mandir)/man7
man8dir = $(mandir)/man8
man9dir = $(mandir)/man9

INSTALL = /usr/bin/install -c
INSTALL_PROGRAM = ${INSTALL}
INSTALL_SCRIPT = ${INSTALL}
INSTALL_DATA = ${INSTALL} -m 644
LN = ln
LN_S = ln -s
MAINT = #
MAINTAINER_MODE_FALSE =
MAINTAINER_MODE_TRUE = #

# -------------------------------------------------
# Miscellaneous non-standard autoconf-set variables
# -------------------------------------------------

# The gcc driver likes to know the arguments it was configured with.
TOPLEVEL_CONFIGURE_ARGUMENTS=../gcc-10.2.0/configure --prefix=/usr/local/x86_64elfgcc --target=i686-elf --disable-nls --enable-languages=c,c++ --without-headers --enable-interwork --enable-multilib --with-gmp=/opt/homebrew/Cellar/gmp/6.2.1 --with-mpc=/opt/homebrew/Cellar/libmpc/1.2.1 --with-mpfr=/opt/homebrew/Cellar/mpfr/4.1.0

tooldir = ${exec_prefix}/i686-elf
build_tooldir = ${exec_prefix}/i686-elf

# This is the name of the environment variable used for the path to
# the libraries.
RPATH_ENVVAR = DYLD_LIBRARY_PATH

# On targets where RPATH_ENVVAR is PATH, a subdirectory of the GCC build path
# is used instead of the directory itself to avoid including built
# executables in PATH.
GCC_SHLIB_SUBDIR =

# Build programs are put under this directory.
BUILD_SUBDIR = build-arm-apple-darwin21.1.0
# This is set by the configure script to the arguments to use when configuring
# directories built for the build system.
BUILD_CONFIGARGS =  --cache-file=./config.cache '--prefix=/usr/local/x86_64elfgcc' '--disable-nls' '--without-headers' '--enable-interwork' '--enable-multilib' '--with-gmp=/opt/homebrew/Cellar/gmp/6.2.1' '--with-mpc=/opt/homebrew/Cellar/libmpc/1.2.1' '--with-mpfr=/opt/homebrew/Cellar/mpfr/4.1.0' '--enable-languages=c,c++,lto' --program-transform-name='s&^&i686-elf-&' --disable-option-checking --with-build-subdir="$(BUILD_SUBDIR)"

# Linker flags to use on the host, for stage1 or when not
# bootstrapping.
STAGE1_LDFLAGS =

# Libraries to use on the host, for stage1 or when not bootstrapping.
STAGE1_LIBS =

# Linker flags to use for stage2 and later.
POSTSTAGE1_LDFLAGS = -static-libstdc++ -static-libgcc

# Libraries to use for stage2 and later.
POSTSTAGE1_LIBS =

# This is the list of variables to export in the environment when
# configuring any subdirectory.  It must also be exported whenever
# recursing into a build directory in case that directory's Makefile
# re-runs configure.
BASE_EXPORTS = \
    FLEX="$(FLEX)"; export FLEX; \
    LEX="$(LEX)"; export LEX; \
    BISON="$(BISON)"; export BISON; \
    YACC="$(YACC)"; export YACC; \
    M4="$(M4)"; export M4; \
    SED="$(SED)"; export SED; \
    AWK="$(AWK)"; export AWK; \
    MAKEINFO="$(MAKEINFO)"; export MAKEINFO;

# This is the list of variables to export in the environment when
# configuring subdirectories for the build system.
BUILD_EXPORTS = \
    $(BASE_EXPORTS) \
    AR="$(AR_FOR_BUILD)"; export AR; \
    AS="$(AS_FOR_BUILD)"; export AS; \
    CC="$(CC_FOR_BUILD)"; export CC; \
    CFLAGS="$(CFLAGS_FOR_BUILD)"; export CFLAGS; \
    CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
    CXX="$(CXX_FOR_BUILD)"; export CXX; \
    CXXFLAGS="$(CXXFLAGS_FOR_BUILD)"; export CXXFLAGS; \
    GFORTRAN="$(GFORTRAN_FOR_BUILD)"; export GFORTRAN; \
    GOC="$(GOC_FOR_BUILD)"; export GOC; \
    GOCFLAGS="$(GOCFLAGS_FOR_BUILD)"; export GOCFLAGS; \
    GDC="$(GDC_FOR_BUILD)"; export GDC; \
    GDCFLAGS="$(GDCFLAGS_FOR_BUILD)"; export GDCFLAGS; \
    DLLTOOL="$(DLLTOOL_FOR_BUILD)"; export DLLTOOL; \
    LD="$(LD_FOR_BUILD)"; export LD; \
    LDFLAGS="$(LDFLAGS_FOR_BUILD)"; export LDFLAGS; \
    NM="$(NM_FOR_BUILD)"; export NM; \
    RANLIB="$(RANLIB_FOR_BUILD)"; export RANLIB; \
    WINDRES="$(WINDRES_FOR_BUILD)"; export WINDRES; \
    WINDMC="$(WINDMC_FOR_BUILD)"; export WINDMC;

# These variables must be set on the make command line for directories
# built for the build system to override those in BASE_FLAGS_TO_PASS.
EXTRA_BUILD_FLAGS = \
    CFLAGS="$(CFLAGS_FOR_BUILD)" \
    LDFLAGS="$(LDFLAGS_FOR_BUILD)"

# This is the list of directories to built for the host system.
SUBDIRS =  intl libiberty zlib libbacktrace libcpp libdecnumber fixincludes gcc libcc1 lto-plugin
TARGET_CONFIGDIRS =  libgcc libstdc++-v3 libssp libquadmath
# This is set by the configure script to the arguments to use when configuring
# directories built for the host system.
HOST_CONFIGARGS =  --cache-file=./config.cache  '--prefix=/usr/local/x86_64elfgcc' '--disable-nls' '--without-headers' '--enable-interwork' '--enable-multilib' '--with-gmp=/opt/homebrew/Cellar/gmp/6.2.1' '--with-mpc=/opt/homebrew/Cellar/libmpc/1.2.1' '--with-mpfr=/opt/homebrew/Cellar/mpfr/4.1.0' '--enable-languages=c,c++,lto' --program-transform-name='s&^&i686-elf-&' --disable-option-checking
# Host programs are put under this directory, which is . except if building
# with srcdir=..
HOST_SUBDIR = .
# This is the list of variables to export in the environment when
# configuring subdirectories for the host system.  We need to pass
# some to the GCC configure because of its hybrid host/target nature.
HOST_EXPORTS = \
    $(BASE_EXPORTS) \
    CC="$(CC)"; export CC; \
    ADA_CFLAGS="$(ADA_CFLAGS)"; export ADA_CFLAGS; \
    CFLAGS="$(CFLAGS)"; export CFLAGS; \
    CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
    CXX="$(CXX)"; export CXX; \
    CXXFLAGS="$(CXXFLAGS)"; export CXXFLAGS; \
    GFORTRAN="$(GFORTRAN)"; export GFORTRAN; \
    GOC="$(GOC)"; export GOC; \
    GDC="$(GDC)"; export GDC; \
    AR="$(AR)"; export AR; \
    AS="$(AS)"; export AS; \
    CC_FOR_BUILD="$(CC_FOR_BUILD)"; export CC_FOR_BUILD; \
    CXX_FOR_BUILD="$(CXX_FOR_BUILD)"; export CXX_FOR_BUILD; \
    DLLTOOL="$(DLLTOOL)"; export DLLTOOL; \
    LD="$(LD)"; export LD; \
    LDFLAGS="$(STAGE1_LDFLAGS) $(LDFLAGS)"; export LDFLAGS; \
    NM="$(NM)"; export NM; \
    RANLIB="$(RANLIB)"; export RANLIB; \
    WINDRES="$(WINDRES)"; export WINDRES; \
    WINDMC="$(WINDMC)"; export WINDMC; \
    OBJCOPY="$(OBJCOPY)"; export OBJCOPY; \
    OBJDUMP="$(OBJDUMP)"; export OBJDUMP; \
    OTOOL="$(OTOOL)"; export OTOOL; \
    READELF="$(READELF)"; export READELF; \
    AR_FOR_TARGET="$(AR_FOR_TARGET)"; export AR_FOR_TARGET; \
    AS_FOR_TARGET="$(AS_FOR_TARGET)"; export AS_FOR_TARGET; \
    GCC_FOR_TARGET="$(GCC_FOR_TARGET)"; export GCC_FOR_TARGET; \
    LD_FOR_TARGET="$(LD_FOR_TARGET)"; export LD_FOR_TARGET; \
    NM_FOR_TARGET="$(NM_FOR_TARGET)"; export NM_FOR_TARGET; \
    OBJDUMP_FOR_TARGET="$(OBJDUMP_FOR_TARGET)"; export OBJDUMP_FOR_TARGET; \
    OBJCOPY_FOR_TARGET="$(OBJCOPY_FOR_TARGET)"; export OBJCOPY_FOR_TARGET; \
    OTOOL_FOR_TARGET="$(OTOOL_FOR_TARGET)"; export OTOOL_FOR_TARGET; \
    RANLIB_FOR_TARGET="$(RANLIB_FOR_TARGET)"; export RANLIB_FOR_TARGET; \
    READELF_FOR_TARGET="$(READELF_FOR_TARGET)"; export READELF_FOR_TARGET; \
    TOPLEVEL_CONFIGURE_ARGUMENTS="$(TOPLEVEL_CONFIGURE_ARGUMENTS)"; export TOPLEVEL_CONFIGURE_ARGUMENTS; \
    HOST_LIBS="$(STAGE1_LIBS)"; export HOST_LIBS; \
    GMPLIBS="$(HOST_GMPLIBS)"; export GMPLIBS; \
    GMPINC="$(HOST_GMPINC)"; export GMPINC; \
    ISLLIBS="$(HOST_ISLLIBS)"; export ISLLIBS; \
    ISLINC="$(HOST_ISLINC)"; export ISLINC; \
    LIBELFLIBS="$(HOST_LIBELFLIBS)"; export LIBELFLIBS; \
    LIBELFINC="$(HOST_LIBELFINC)"; export LIBELFINC; \
    XGCC_FLAGS_FOR_TARGET="$(XGCC_FLAGS_FOR_TARGET)"; export XGCC_FLAGS_FOR_TARGET; \
    $(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR);

POSTSTAGE1_CXX_EXPORT = \
    CXX='$(CXX)'; export CXX; \
    CXX_FOR_BUILD='$(CXX_FOR_BUILD)'; export CXX_FOR_BUILD;

# Similar, for later GCC stages.
POSTSTAGE1_HOST_EXPORTS = \
    $(HOST_EXPORTS) \
    CC="$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/prev-gcc/xgcc$(exeext) \
      -B$$r/$(HOST_SUBDIR)/prev-gcc/ -B$(build_tooldir)/bin/ \
      $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \
    CC_FOR_BUILD="$$CC"; export CC_FOR_BUILD; \
    $(POSTSTAGE1_CXX_EXPORT) \
    $(LTO_EXPORTS) \
    GDC="$$r/$(HOST_SUBDIR)/prev-gcc/gdc$(exeext) -B$$r/$(HOST_SUBDIR)/prev-gcc/ \
      -B$(build_tooldir)/bin/ $(GDC_FLAGS_FOR_TARGET) \
      -B$$r/prev-$(TARGET_SUBDIR)/libphobos/src \
      -I$$r/prev-$(TARGET_SUBDIR)/libphobos/libdruntime -I$$s/libphobos/libdruntime \
      -L$$r/prev-$(TARGET_SUBDIR)/libphobos/src/.libs \
      -L$$r/prev-$(TARGET_SUBDIR)/libphobos/libdruntime/.libs"; \
    export GDC; \
    GDC_FOR_BUILD="$$GDC"; export GDC_FOR_BUILD; \
    GNATBIND="$$r/$(HOST_SUBDIR)/prev-gcc/gnatbind"; export GNATBIND; \
    LDFLAGS="$(POSTSTAGE1_LDFLAGS) $(BOOT_LDFLAGS)"; export LDFLAGS; \
    HOST_LIBS="$(POSTSTAGE1_LIBS)"; export HOST_LIBS;

# Target libraries are put under this directory:
TARGET_SUBDIR = i686-elf
# This is set by the configure script to the arguments to use when configuring
# directories built for the target.
TARGET_CONFIGARGS = --cache-file=./config.cache --with-cross-host=arm-apple-darwin21.1.0   '--prefix=/usr/local/x86_64elfgcc' '--disable-nls' '--without-headers' '--enable-interwork' '--enable-multilib' '--enable-languages=c,c++,lto' --program-transform-name='s&^&i686-elf-&' --disable-option-checking --with-target-subdir="$(TARGET_SUBDIR)"
# This is the list of variables to export in the environment when
# configuring subdirectories for the target system.
BASE_TARGET_EXPORTS = \
    $(BASE_EXPORTS) \
    AR="$(AR_FOR_TARGET)"; export AR; \
    AS="$(COMPILER_AS_FOR_TARGET)"; export AS; \
    CC="$(CC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \
    CFLAGS="$(CFLAGS_FOR_TARGET)"; export CFLAGS; \
    CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
    CPPFLAGS="$(CPPFLAGS_FOR_TARGET)"; export CPPFLAGS; \
    CXXFLAGS="$(CXXFLAGS_FOR_TARGET)"; export CXXFLAGS; \
    GFORTRAN="$(GFORTRAN_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GFORTRAN; \
    GOC="$(GOC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GOC; \
    GDC="$(GDC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GDC; \
    DLLTOOL="$(DLLTOOL_FOR_TARGET)"; export DLLTOOL; \
    LD="$(COMPILER_LD_FOR_TARGET)"; export LD; \
    LDFLAGS="$(LDFLAGS_FOR_TARGET)"; export LDFLAGS; \
    LIPO="$(LIPO_FOR_TARGET)"; export LIPO; \
    NM="$(COMPILER_NM_FOR_TARGET)"; export NM; \
    OBJDUMP="$(OBJDUMP_FOR_TARGET)"; export OBJDUMP; \
    OBJCOPY="$(OBJCOPY_FOR_TARGET)"; export OBJCOPY; \
    OTOOL="$(OTOOL_FOR_TARGET)"; export OTOOL; \
    RANLIB="$(RANLIB_FOR_TARGET)"; export RANLIB; \
    READELF="$(READELF_FOR_TARGET)"; export READELF; \
    STRIP="$(STRIP_FOR_TARGET)"; export STRIP; \
    WINDRES="$(WINDRES_FOR_TARGET)"; export WINDRES; \
    WINDMC="$(WINDMC_FOR_TARGET)"; export WINDMC; \
    $(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \
    TARGET_CONFIGDIRS="$(TARGET_CONFIGDIRS)"; export TARGET_CONFIGDIRS;

RAW_CXX_TARGET_EXPORTS = \
    $(BASE_TARGET_EXPORTS) \
    CXX_FOR_TARGET="$(RAW_CXX_FOR_TARGET)"; export CXX_FOR_TARGET; \
    CXX="$(RAW_CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;

NORMAL_TARGET_EXPORTS = \
    $(BASE_TARGET_EXPORTS) \
    CXX="$(CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;

# Where to find GMP
HOST_GMPLIBS = -L/opt/homebrew/Cellar/gmp/6.2.1/lib -L/opt/homebrew/Cellar/mpfr/4.1.0/lib -L/opt/homebrew/Cellar/libmpc/1.2.1/lib -lmpc -lmpfr -lgmp
HOST_GMPINC = -I/opt/homebrew/Cellar/gmp/6.2.1/include -I/opt/homebrew/Cellar/mpfr/4.1.0/include -I/opt/homebrew/Cellar/libmpc/1.2.1/include

# Where to find isl
HOST_ISLLIBS =
HOST_ISLINC =

# Where to find libelf
HOST_LIBELFLIBS = @libelflibs@
HOST_LIBELFINC = @libelfinc@

# ----------------------------------------------
# Programs producing files for the BUILD machine
# ----------------------------------------------

SHELL = /bin/sh

# pwd command to use.  Allow user to override default by setting PWDCMD in
# the environment to account for automounters.  The make variable must not
# be called PWDCMD, otherwise the value set here is passed to make
# subprocesses and overrides the setting from the user's environment.
# Don't use PWD since it is a common shell environment variable and we
# don't want to corrupt it.
PWD_COMMAND = $${PWDCMD-pwd}

# compilers to use to create programs which must be run in the build
# environment.
AR_FOR_BUILD = $(AR)
AS_FOR_BUILD = $(AS)
CC_FOR_BUILD = $(CC)
CFLAGS_FOR_BUILD = -g -O2
CXXFLAGS_FOR_BUILD = -g -O2
CXX_FOR_BUILD = $(CXX)
DLLTOOL_FOR_BUILD = $(DLLTOOL)
GFORTRAN_FOR_BUILD = $(GFORTRAN)
GOC_FOR_BUILD = $(GOC)
GDC_FOR_BUILD = $(GDC)
LDFLAGS_FOR_BUILD = -L/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib
LD_FOR_BUILD = $(LD)
NM_FOR_BUILD = $(NM)
RANLIB_FOR_BUILD = $(RANLIB)
WINDMC_FOR_BUILD = $(WINDMC)
WINDRES_FOR_BUILD = $(WINDRES)

# Special variables passed down in EXTRA_GCC_FLAGS.  They are defined
# here so that they can be overridden by Makefile fragments.
BUILD_PREFIX = @BUILD_PREFIX@
BUILD_PREFIX_1 = @BUILD_PREFIX_1@

# Flags to pass to stage2 and later makes.  They are defined
# here so that they can be overridden by Makefile fragments.
BOOT_CFLAGS= -g -O2
BOOT_LDFLAGS=
BOOT_ADAFLAGS= -gnatpg

AWK = awk
SED = /usr/bin/sed
BISON = bison
YACC = bison -y
FLEX = flex
LEX = flex
M4 = gm4
MAKEINFO = makeinfo
EXPECT = expect
RUNTEST = runtest

AUTO_PROFILE = gcc-auto-profile -c 10000000

# This just becomes part of the MAKEINFO definition passed down to
# sub-makes.  It lets flags be given on the command line while still
# using the makeinfo from the object tree.
# (Default to avoid splitting info files by setting the threshold high.)
MAKEINFOFLAGS = --split-size=5000000

# ---------------------------------------------
# Programs producing files for the HOST machine
# ---------------------------------------------

AS = as
AR = ar
AR_FLAGS = rc
CC = gcc
CXX = g++
DLLTOOL = dlltool
LD = /Library/Developer/CommandLineTools/usr/bin/ld
LIPO = lipo
NM = nm
OBJDUMP = objdump
OTOOL = otool
RANLIB = ranlib
READELF = readelf
STRIP = strip
WINDRES = windres
WINDMC = windmc

GDC = @GDC@
GNATBIND = no
GNATMAKE = no

CFLAGS = -g -O2
LDFLAGS = -L/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib
LIBCFLAGS = $(CFLAGS)
CXXFLAGS = -g -O2
LIBCXXFLAGS = $(CXXFLAGS) -fno-implicit-templates
GOCFLAGS = $(CFLAGS)
GDCFLAGS = $(CFLAGS)

CREATE_GCOV = create_gcov

TFLAGS =

# Defaults for all stages; some are overridden below.

STAGE_CFLAGS = $(BOOT_CFLAGS)
STAGE_TFLAGS = $(TFLAGS)
STAGE_CONFIGURE_FLAGS=


# Defaults for stage 1; some are overridden below.
STAGE1_CFLAGS = $(STAGE_CFLAGS)
STAGE1_CXXFLAGS = $(CXXFLAGS)
STAGE1_TFLAGS = $(STAGE_TFLAGS)
STAGE1_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage 2; some are overridden below.
STAGE2_CFLAGS = $(STAGE_CFLAGS)
STAGE2_CXXFLAGS = $(CXXFLAGS)
STAGE2_TFLAGS = $(STAGE_TFLAGS)
STAGE2_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage 3; some are overridden below.
STAGE3_CFLAGS = $(STAGE_CFLAGS)
STAGE3_CXXFLAGS = $(CXXFLAGS)
STAGE3_TFLAGS = $(STAGE_TFLAGS)
STAGE3_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage 4; some are overridden below.
STAGE4_CFLAGS = $(STAGE_CFLAGS)
STAGE4_CXXFLAGS = $(CXXFLAGS)
STAGE4_TFLAGS = $(STAGE_TFLAGS)
STAGE4_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage profile; some are overridden below.
STAGEprofile_CFLAGS = $(STAGE_CFLAGS)
STAGEprofile_CXXFLAGS = $(CXXFLAGS)
STAGEprofile_TFLAGS = $(STAGE_TFLAGS)
STAGEprofile_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage train; some are overridden below.
STAGEtrain_CFLAGS = $(STAGE_CFLAGS)
STAGEtrain_CXXFLAGS = $(CXXFLAGS)
STAGEtrain_TFLAGS = $(STAGE_TFLAGS)
STAGEtrain_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage feedback; some are overridden below.
STAGEfeedback_CFLAGS = $(STAGE_CFLAGS)
STAGEfeedback_CXXFLAGS = $(CXXFLAGS)
STAGEfeedback_TFLAGS = $(STAGE_TFLAGS)
STAGEfeedback_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage autoprofile; some are overridden below.
STAGEautoprofile_CFLAGS = $(STAGE_CFLAGS)
STAGEautoprofile_CXXFLAGS = $(CXXFLAGS)
STAGEautoprofile_TFLAGS = $(STAGE_TFLAGS)
STAGEautoprofile_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

# Defaults for stage autofeedback; some are overridden below.
STAGEautofeedback_CFLAGS = $(STAGE_CFLAGS)
STAGEautofeedback_CXXFLAGS = $(CXXFLAGS)
STAGEautofeedback_TFLAGS = $(STAGE_TFLAGS)
STAGEautofeedback_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)


# By default, C and C++ are the only stage1 languages, because they are the
# only ones we require to build with the bootstrap compiler, and also the
# only ones useful for building stage2.

STAGE1_CFLAGS = -g
STAGE1_CHECKING = --enable-checking=yes,types
STAGE1_LANGUAGES = c,c++,lto
# * We force-disable intermodule optimizations, even if
#   --enable-intermodule was passed, since the installed compiler
#   probably can't handle them.  Luckily, autoconf always respects
#   the last argument when conflicting --enable arguments are passed.
# * Likewise, we force-disable coverage flags, since the installed
#   compiler probably has never heard of them.
# * We also disable -Wformat, since older GCCs don't understand newer %s.
STAGE1_CONFIGURE_FLAGS = --disable-intermodule $(STAGE1_CHECKING) \
      --disable-coverage --enable-languages="$(STAGE1_LANGUAGES)" \
      --disable-build-format-warnings

# When using the slow stage1 compiler disable IL verification and forcefully
# enable it when using the stage2 compiler instead.  As we later compare
# stage2 and stage3 we are merely avoid doing redundant work, plus we apply
# checking when building all target libraries for release builds.
STAGE1_TFLAGS += -fno-checking
STAGE2_CFLAGS += -fno-checking
STAGE2_TFLAGS += -fno-checking
STAGE3_CFLAGS += -fchecking=1
STAGE3_TFLAGS += -fchecking=1

STAGEprofile_CFLAGS = $(STAGE2_CFLAGS) -fprofile-generate
STAGEprofile_TFLAGS = $(STAGE2_TFLAGS)

STAGEtrain_CFLAGS = $(filter-out -fchecking=1,$(STAGE3_CFLAGS))
STAGEtrain_TFLAGS = $(filter-out -fchecking=1,$(STAGE3_TFLAGS))

STAGEfeedback_CFLAGS = $(STAGE4_CFLAGS) -fprofile-use
STAGEfeedback_TFLAGS = $(STAGE4_TFLAGS)

STAGEautoprofile_CFLAGS = $(STAGE2_CFLAGS) -g
STAGEautoprofile_TFLAGS = $(STAGE2_TFLAGS)

STAGEautofeedback_CFLAGS = $(STAGE3_CFLAGS)
STAGEautofeedback_TFLAGS = $(STAGE3_TFLAGS)

do-compare = cmp --ignore-initial=16 $$f1 $$f2
do-compare3 = $(do-compare)

# -----------------------------------------------
# Programs producing files for the TARGET machine
# -----------------------------------------------

AR_FOR_TARGET=i686-elf-ar
AS_FOR_TARGET=i686-elf-as
CC_FOR_TARGET=$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/

# If GCC_FOR_TARGET is not overriden on the command line, then this
# variable is passed down to the gcc Makefile, where it is used to
# build libgcc2.a.  We define it here so that it can itself be
# overridden on the command line.
GCC_FOR_TARGET=$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/
CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/gcc/xg++ -B$$r/$(HOST_SUBDIR)/gcc/ -nostdinc++ `if test -f $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags; then $(SHELL) $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags --build-includes; else echo -funconfigured-libstdc++-v3 ; fi` -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs
RAW_CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/gcc/xgcc -shared-libgcc -B$$r/$(HOST_SUBDIR)/gcc -nostdinc++ -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs
GFORTRAN_FOR_TARGET=$(STAGE_CC_WRAPPER) i686-elf-gfortran
GOC_FOR_TARGET=$(STAGE_CC_WRAPPER) i686-elf-gccgo
GDC_FOR_TARGET=$(STAGE_CC_WRAPPER) i686-elf-gdc
DLLTOOL_FOR_TARGET=i686-elf-dlltool
LD_FOR_TARGET=i686-elf-ld

LIPO_FOR_TARGET=i686-elf-lipo
NM_FOR_TARGET=i686-elf-nm
OBJDUMP_FOR_TARGET=i686-elf-objdump
OBJCOPY_FOR_TARGET=i686-elf-objcopy
OTOOL_FOR_TARGET=i686-elf-otool
RANLIB_FOR_TARGET=i686-elf-ranlib
READELF_FOR_TARGET=i686-elf-readelf
STRIP_FOR_TARGET=i686-elf-strip
WINDRES_FOR_TARGET=i686-elf-windres
WINDMC_FOR_TARGET=i686-elf-windmc

COMPILER_AS_FOR_TARGET=$$r/$(HOST_SUBDIR)/gcc/as
COMPILER_LD_FOR_TARGET=$$r/$(HOST_SUBDIR)/gcc/collect-ld
COMPILER_NM_FOR_TARGET=$$r/$(HOST_SUBDIR)/gcc/nm

CFLAGS_FOR_TARGET = -g -O2
CXXFLAGS_FOR_TARGET = -g -O2

LIBCFLAGS_FOR_TARGET = $(CFLAGS_FOR_TARGET)
LIBCXXFLAGS_FOR_TARGET = $(CXXFLAGS_FOR_TARGET) -fno-implicit-templates
LDFLAGS_FOR_TARGET =
GOCFLAGS_FOR_TARGET = -O2 -g
GDCFLAGS_FOR_TARGET = -O2 -g

FLAGS_FOR_TARGET =  -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include
SYSROOT_CFLAGS_FOR_TARGET =
DEBUG_PREFIX_CFLAGS_FOR_TARGET =

XGCC_FLAGS_FOR_TARGET = $(FLAGS_FOR_TARGET) $(SYSROOT_CFLAGS_FOR_TARGET) $(DEBUG_PREFIX_CFLAGS_FOR_TARGET)
.
.
.
.
.