#
# Makefile for directory with subdirs to build.
# Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-# 1999, 2000, 2001, 2002 Free Software Foundation
+# 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Free Software Foundation
#
# This file 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 of the License, or
+# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+# along with this program; see the file COPYING3. If not see
+# <http://www.gnu.org/licenses/>.
#
+# First, test for a proper version of make, but only where one is required.
+
+@if gcc
+ifeq (,$(.VARIABLES)) # The variable .VARIABLES, new with 3.80, is never empty.
+$(error GNU make version 3.80 or newer is required.)
+endif
+@endif gcc
+
+# -------------------------------
+# Standard Autoconf-set variables
+# -------------------------------
VPATH=@srcdir@
-links=@configlinks@
-build_alias=@build_alias@
-build_cpu=@build_cpu@
+build_alias=@build_noncanonical@
build_vendor=@build_vendor@
build_os=@build_os@
-build_canonical=@build_cpu@-@build_vendor@-@build_os@
-host_alias=@host_alias@
-host_cpu=@host_cpu@
+build=@build@
+host_alias=@host_noncanonical@
host_vendor=@host_vendor@
host_os=@host_os@
-host_canonical=@host_cpu@-@host_vendor@-@host_os@
-target_alias=@target_alias@
-target_cpu=@target_cpu@
+host=@host@
+target_alias=@target_noncanonical@
target_vendor=@target_vendor@
target_os=@target_os@
-target_canonical=@target_cpu@-@target_vendor@-@target_os@
-
-enable_shared = @enable_shared@
-enable_threads = @enable_threads@
-enable_version_specific_runtime_libs = @enable_version_specific_runtime_libs@
-# The file containing GCC's version number.
-gcc_version_trigger = @gcc_version_trigger@
-gcc_version = @gcc_version@
-
-# The gcc driver likes to know the arguments it was configured with.
-TOPLEVEL_CONFIGURE_ARGUMENTS=@TOPLEVEL_CONFIGURE_ARGUMENTS@
+target=@target@
-srcdir = @srcdir@
+program_transform_name = @program_transform_name@
prefix = @prefix@
exec_prefix = @exec_prefix@
+srcdir = @srcdir@
+
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
includedir = @includedir@
oldincludedir = @oldincludedir@
infodir = @infodir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+pdfdir = @pdfdir@
+htmldir = @htmldir@
mandir = @mandir@
-gxx_include_dir = @gxx_include_dir@
-libstdcxx_incdir = @libstdcxx_incdir@
-
-tooldir = @tooldir@
-build_tooldir = @build_tooldir@
-
-program_transform_name = @program_transform_name@
-
man1dir = $(mandir)/man1
man2dir = $(mandir)/man2
man3dir = $(mandir)/man3
man7dir = $(mandir)/man7
man8dir = $(mandir)/man8
man9dir = $(mandir)/man9
-# Directory in which the compiler finds executables, libraries, etc.
-libsubdir = $(libdir)/gcc-lib/$(target_alias)/$(gcc_version)
-GDB_NLM_DEPS =
-
-SHELL = @config_shell@
-
-# 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.
-PWD = $${PWDCMD-pwd}
-
-# INSTALL_PROGRAM_ARGS is changed by configure.in to use -x for a
-# cygwin host.
-INSTALL_PROGRAM_ARGS =
-
-INSTALL = $(SHELL) $$s/install-sh -c
-INSTALL_PROGRAM = $(INSTALL) $(INSTALL_PROGRAM_ARGS)
-INSTALL_SCRIPT = $(INSTALL)
-INSTALL_DATA = $(INSTALL) -m 644
-
-AS = @AS@
-AR = @AR@
-AR_FLAGS = rc
-CC = @CC@
-
-# Special variables passed down in EXTRA_GCC_FLAGS. They are defined
-# here so that they can be overridden by Makefile fragments.
-BUILD_CC = $(CC_FOR_BUILD)
-BUILD_PREFIX = @BUILD_PREFIX@
-BUILD_PREFIX_1 = @BUILD_PREFIX_1@
-
-CFLAGS = @CFLAGS@
-CXXFLAGS = @CXXFLAGS@
-LDFLAGS =
-LIBCFLAGS = $(CFLAGS)
-CFLAGS_FOR_BUILD = $(CFLAGS)
-# During gcc bootstrap, if we use some random cc for stage1 then
-# CFLAGS will be just -g. We want to ensure that TARGET libraries
-# (which we know are built with gcc) are built with optimizations so
-# prepend -O2 when setting CFLAGS_FOR_TARGET.
-CFLAGS_FOR_TARGET = -O2 $(CFLAGS)
-LDFLAGS_FOR_TARGET =
-LIBCFLAGS_FOR_TARGET = $(CFLAGS_FOR_TARGET)
-PICFLAG =
-PICFLAG_FOR_TARGET =
-
-CXX = @CXX@
-
-# Use -O2 to stress test the compiler.
-LIBCXXFLAGS = $(CXXFLAGS) -fno-implicit-templates
-CXXFLAGS_FOR_TARGET = $(CXXFLAGS)
-LIBCXXFLAGS_FOR_TARGET = $(CXXFLAGS_FOR_TARGET) -fno-implicit-templates
-
-DLLTOOL = @DLLTOOL@
-WINDRES = @WINDRES@
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_DATA = @INSTALL_DATA@
+LN = @LN@
+LN_S = @LN_S@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
-NM = @NM@
-
-LD = @LD@
-
-# These values are substituted by configure.
-DEFAULT_YACC = @DEFAULT_YACC@
-DEFAULT_LEX = @DEFAULT_LEX@
-DEFAULT_M4 = @DEFAULT_M4@
-
-BISON=@BISON@
-USUAL_BISON = `if [ -f $$r/bison/bison ] ; then \
- echo $$r/bison/bison -L $$s/bison/ ; \
- else \
- echo bison ; \
- fi`
-
-YACC=@YACC@
-USUAL_YACC = `if [ -f $$r/bison/bison ] ; then \
- echo $$r/bison/bison -y -L $$s/bison/ ; \
- elif [ -f $$r/byacc/byacc ] ; then \
- echo $$r/byacc/byacc ; \
- else \
- echo ${DEFAULT_YACC} ; \
- fi`
-
-LEX=@LEX@
-USUAL_LEX = `if [ -f $$r/flex/flex ] ; \
- then echo $$r/flex/flex ; \
- else echo ${DEFAULT_LEX} ; fi`
-
-M4 = `if [ -f $$r/m4/m4 ] ; \
- then echo $$r/m4/m4 ; \
- else echo ${DEFAULT_M4} ; fi`
-
-# For an installed makeinfo, we require it to be from texinfo 4 or
-# higher, else we use the "missing" dummy.
-MAKEINFO=@MAKEINFO@
-USUAL_MAKEINFO = `if [ -f $$r/texinfo/makeinfo/makeinfo ] ; \
- then echo $$r/texinfo/makeinfo/makeinfo ; \
- else if (makeinfo --version \
- | egrep 'texinfo[^0-9]*([1-3][0-9]|[4-9])') >/dev/null 2>&1; \
- then echo makeinfo; else echo $$s/missing makeinfo; fi; fi`
-
-# 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.
-MAKEINFOFLAGS =
+# -------------------------------------------------
+# Miscellaneous non-standard autoconf-set variables
+# -------------------------------------------------
-EXPECT = `if [ -f $$r/expect/expect ] ; \
- then echo $$r/expect/expect ; \
- else echo expect ; fi`
-
-RUNTEST = `if [ -f $$s/dejagnu/runtest ] ; \
- then echo $$s/dejagnu/runtest ; \
- else echo runtest ; fi`
-
-
-# compilers to use to create programs which must be run in the build
-# environment.
-CC_FOR_BUILD = @CC_FOR_BUILD@
-CXX_FOR_BUILD = $(CXX)
+# The gcc driver likes to know the arguments it was configured with.
+TOPLEVEL_CONFIGURE_ARGUMENTS=@TOPLEVEL_CONFIGURE_ARGUMENTS@
-SUBDIRS = @configdirs@
+tooldir = @tooldir@
+build_tooldir = @build_tooldir@
-# This is set by the configure script to the list of directories which
-# should be built using the target tools.
-TARGET_CONFIGDIRS = @target_configdirs@
+# This is the name of the environment variable used for the path to
+# the libraries.
+RPATH_ENVVAR = @RPATH_ENVVAR@
-# Target libraries are put under this directory:
-# Changed by configure to $(target_alias) if cross.
-TARGET_SUBDIR = @target_subdir@
+# 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 = @GCC_SHLIB_SUBDIR@
-BUILD_CONFIGDIRS = libiberty
+# Build programs are put under this directory.
BUILD_SUBDIR = @build_subdir@
-
# This is set by the configure script to the arguments to use when configuring
# directories built for the build system.
-BUILD_CONFIGARGS = @build_configargs@
-
+BUILD_CONFIGARGS = @build_configargs@ --with-build-subdir="$(BUILD_SUBDIR)"
+
+# Linker flags to use on the host, for stage1 or when not
+# bootstrapping.
+STAGE1_LDFLAGS = @stage1_ldflags@
+
+# Libraries to use on the host, for stage1 or when not bootstrapping.
+STAGE1_LIBS = @stage1_libs@
+
+# Linker flags to use for stage2 and later.
+POSTSTAGE1_LDFLAGS = @poststage1_ldflags@
+
+# Libraries to use for stage2 and later.
+POSTSTAGE1_LIBS = @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; \
+ GCJ="$(GCJ_FOR_BUILD)"; export GCJ; \
+ GFORTRAN="$(GFORTRAN_FOR_BUILD)"; export GFORTRAN; \
+ GOC="$(GOC_FOR_BUILD)"; export GOC; \
+ GOCFLAGS="$(GOCFLAGS_FOR_BUILD)"; export GOCFLAGS; \
+ 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 = @configdirs@
+TARGET_CONFIGDIRS = @target_configdirs@
# This is set by the configure script to the arguments to use when configuring
# directories built for the host system.
HOST_CONFIGARGS = @host_configargs@
+# Host programs are put under this directory, which is . except if building
+# with srcdir=..
+HOST_SUBDIR = @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; \
+ GCJ="$(GCJ)"; export GCJ; \
+ GFORTRAN="$(GFORTRAN)"; export GFORTRAN; \
+ GOC="$(GOC)"; export GOC; \
+ AR="$(AR)"; export AR; \
+ AS="$(AS)"; export AS; \
+ CC_FOR_BUILD="$(CC_FOR_BUILD)"; export CC_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; \
+ 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; \
+ 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; \
+ ISLINC="$(HOST_ISLINC)"; export ISLINC; \
+ CLOOGLIBS="$(HOST_CLOOGLIBS)"; export CLOOGLIBS; \
+ CLOOGINC="$(HOST_CLOOGINC)"; export CLOOGINC; \
+ LIBELFLIBS="$(HOST_LIBELFLIBS)" ; export LIBELFLIBS; \
+ LIBELFINC="$(HOST_LIBELFINC)" ; export LIBELFINC; \
+@if gcc-bootstrap
+ $(RPATH_ENVVAR)=`echo "$(TARGET_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \
+@endif gcc-bootstrap
+ $(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;
+@if target-libstdc++-v3-bootstrap
+# Override the above if we're bootstrapping C++.
+POSTSTAGE1_CXX_EXPORT = \
+ CXX="$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/prev-gcc/xg++$(exeext) \
+ -B$$r/$(HOST_SUBDIR)/prev-gcc/ -B$(build_tooldir)/bin/ -nostdinc++ \
+ -B$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \
+ -B$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs \
+ -I$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/include/$(TARGET_SUBDIR) \
+ -I$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/include \
+ -I$$s/libstdc++-v3/libsupc++ \
+ -L$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \
+ -L$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs"; \
+ export CXX; \
+ CXX_FOR_BUILD="$$CXX"; export CXX_FOR_BUILD;
+@endif target-libstdc++-v3-bootstrap
+
+# 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) \
+ 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 = @target_subdir@
# This is set by the configure script to the arguments to use when configuring
# directories built for the target.
-TARGET_CONFIGARGS = @target_configargs@
+TARGET_CONFIGARGS = @target_configargs@ --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; \
+ GCJ="$(GCJ_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GCJ; \
+ GFORTRAN="$(GFORTRAN_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GFORTRAN; \
+ GOC="$(GOC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GOC; \
+ 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; \
+ 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; \
+@if gcc-bootstrap
+ $(RPATH_ENVVAR)=`echo "$(TARGET_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \
+@endif gcc-bootstrap
+ $(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 = @gmplibs@
+HOST_GMPINC = @gmpinc@
+
+# Where to find ISL
+HOST_ISLINC = @islinc@
+
+# Where to find CLOOG
+HOST_CLOOGLIBS = @clooglibs@
+HOST_CLOOGINC = @clooginc@
+
+# Where to find libelf
+HOST_LIBELFLIBS = @libelflibs@
+HOST_LIBELFINC = @libelfinc@
+
+EXTRA_CONFIGARGS_LIBJAVA = @EXTRA_CONFIGARGS_LIBJAVA@
+
+# ----------------------------------------------
+# Programs producing files for the BUILD machine
+# ----------------------------------------------
+
+SHELL = @SHELL@
-# This is set by configure to REALLY_SET_LIB_PATH if --enable-shared
-# was used.
-SET_LIB_PATH = @SET_LIB_PATH@
+# 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}
-# This is the name of the environment variable used for the path to
-# the libraries. This may be changed by configure.in.
-RPATH_ENVVAR = @RPATH_ENVVAR@
+# compilers to use to create programs which must be run in the build
+# environment.
+AR_FOR_BUILD = @AR_FOR_BUILD@
+AS_FOR_BUILD = @AS_FOR_BUILD@
+CC_FOR_BUILD = @CC_FOR_BUILD@
+CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
+CXXFLAGS_FOR_BUILD = @CXXFLAGS_FOR_BUILD@
+CXX_FOR_BUILD = @CXX_FOR_BUILD@
+DLLTOOL_FOR_BUILD = @DLLTOOL_FOR_BUILD@
+GCJ_FOR_BUILD = @GCJ_FOR_BUILD@
+GFORTRAN_FOR_BUILD = @GFORTRAN_FOR_BUILD@
+GOC_FOR_BUILD = @GOC_FOR_BUILD@
+LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@
+LD_FOR_BUILD = @LD_FOR_BUILD@
+NM_FOR_BUILD = @NM_FOR_BUILD@
+RANLIB_FOR_BUILD = @RANLIB_FOR_BUILD@
+WINDMC_FOR_BUILD = @WINDMC_FOR_BUILD@
+WINDRES_FOR_BUILD = @WINDRES_FOR_BUILD@
-# This is the list of directories that may be needed in RPATH_ENVVAR
-# so that programs built for the host machine work.
-HOST_LIB_PATH = $$r/bfd:$$r/opcodes
+# 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@
-# This is the list of directories that may be needed in RPATH_ENVVAR
-# so that prorgams built for the target machine work.
-TARGET_LIB_PATH = $$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs:
+# 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 = @SED@
+BISON = @BISON@
+YACC = @YACC@
+FLEX = @FLEX@
+LEX = @LEX@
+M4 = @M4@
+MAKEINFO = @MAKEINFO@
+EXPECT = @EXPECT@
+RUNTEST = @RUNTEST@
+
+# 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
-# configure.in sets SET_LIB_PATH to this if --enable-shared was used.
-# Some platforms don't like blank entries, so we remove duplicate,
-# leading and trailing colons.
-REALLY_SET_LIB_PATH = \
- $(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH):$(TARGET_LIB_PATH):$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR);
+# ---------------------------------------------
+# Programs producing files for the HOST machine
+# ---------------------------------------------
-# Should be substed by configure.in
-FLAGS_FOR_TARGET = @FLAGS_FOR_TARGET@
-CC_FOR_TARGET = @CC_FOR_TARGET@
-CXX_FOR_TARGET = @CXX_FOR_TARGET@
-RAW_CXX_FOR_TARGET = @RAW_CXX_FOR_TARGET@
-CXX_FOR_TARGET_FOR_RECURSIVE_MAKE = @CXX_FOR_TARGET_FOR_RECURSIVE_MAKE@
-RAW_CXX_FOR_TARGET_FOR_RECURSIVE_MAKE = @RAW_CXX_FOR_TARGET_FOR_RECURSIVE_MAKE@
-GCJ_FOR_TARGET = @GCJ_FOR_TARGET@
+AS = @AS@
+AR = @AR@
+AR_FLAGS = rc
+CC = @CC@
+CXX = @CXX@
+DLLTOOL = @DLLTOOL@
+LD = @LD@
+LIPO = @LIPO@
+NM = @NM@
+OBJDUMP = @OBJDUMP@
+RANLIB = @RANLIB@
+READELF = @READELF@
+STRIP = @STRIP@
+WINDRES = @WINDRES@
+WINDMC = @WINDMC@
+
+GNATBIND = @GNATBIND@
+GNATMAKE = @GNATMAKE@
+
+CFLAGS = @CFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBCFLAGS = $(CFLAGS)
+CXXFLAGS = @CXXFLAGS@
+LIBCXXFLAGS = $(CXXFLAGS) -fno-implicit-templates
+GOCFLAGS = $(CFLAGS)
+
+TFLAGS =
+
+# Defaults for all stages; some are overridden below.
+
+STAGE_CFLAGS = $(BOOT_CFLAGS)
+STAGE_TFLAGS = $(TFLAGS)
+STAGE_CONFIGURE_FLAGS=@stage2_werror_flag@
+
+[+ FOR bootstrap-stage +]
+# Defaults for stage [+id+]; some are overridden below.
+STAGE[+id+]_CFLAGS = $(STAGE_CFLAGS)
+STAGE[+id+]_CXXFLAGS = $(CXXFLAGS)
+@if target-libstdc++-v3-bootstrap
+# Override the above if we're bootstrapping C++.
+STAGE[+id+]_CXXFLAGS = $(STAGE[+id+]_CFLAGS)
+@endif target-libstdc++-v3-bootstrap
+STAGE[+id+]_TFLAGS = $(STAGE_TFLAGS)
+STAGE[+id+]_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
+[+ ENDFOR bootstrap-stage +]
+
+# Only build the C compiler for stage1, because that is the only one that
+# we can guarantee will build with the native compiler, and also it is the
+# only thing useful for building stage2. STAGE1_CFLAGS (via CFLAGS),
+# MAKEINFO and MAKEINFOFLAGS are explicitly passed here to make them
+# overrideable (for a bootstrap build stage1 also builds gcc.info).
+
+STAGE1_CFLAGS = @stage1_cflags@
+STAGE1_CHECKING = @stage1_checking@
+STAGE1_LANGUAGES = @stage1_languages@
+# * 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
+
+STAGEprofile_CFLAGS = $(STAGE2_CFLAGS) -fprofile-generate
+STAGEprofile_TFLAGS = $(STAGE2_TFLAGS)
+
+STAGEfeedback_CFLAGS = $(STAGE3_CFLAGS) -fprofile-use
+STAGEfeedback_TFLAGS = $(STAGE3_TFLAGS)
+
+do-compare = @do_compare@
+do-compare3 = $(do-compare)
+
+# -----------------------------------------------
+# Programs producing files for the TARGET machine
+# -----------------------------------------------
+
+AR_FOR_TARGET=@AR_FOR_TARGET@
+AS_FOR_TARGET=@AS_FOR_TARGET@
+CC_FOR_TARGET=$(STAGE_CC_WRAPPER) @CC_FOR_TARGET@
# 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=@GCC_FOR_TARGET@
-USUAL_GCC_FOR_TARGET = $(STAGE_CC_WRAPPER) $$r/gcc/xgcc -B$$r/gcc/ $(FLAGS_FOR_TARGET)
+GCC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GCC_FOR_TARGET@
+CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @CXX_FOR_TARGET@
+RAW_CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @RAW_CXX_FOR_TARGET@
+GCJ_FOR_TARGET=$(STAGE_CC_WRAPPER) @GCJ_FOR_TARGET@
+GFORTRAN_FOR_TARGET=$(STAGE_CC_WRAPPER) @GFORTRAN_FOR_TARGET@
+GOC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GOC_FOR_TARGET@
+DLLTOOL_FOR_TARGET=@DLLTOOL_FOR_TARGET@
+LD_FOR_TARGET=@LD_FOR_TARGET@
-AS_FOR_TARGET=@AS_FOR_TARGET@
-USUAL_AS_FOR_TARGET = ` \
- if [ -f $$r/gas/as-new ] ; then \
- echo $$r/gas/as-new ; \
- elif [ -f $$r/gcc/xgcc ]; then \
- $(CC_FOR_TARGET) -print-prog-name=as ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- echo $(AS); \
- else \
- echo as | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+LIPO_FOR_TARGET=@LIPO_FOR_TARGET@
+NM_FOR_TARGET=@NM_FOR_TARGET@
+OBJDUMP_FOR_TARGET=@OBJDUMP_FOR_TARGET@
+RANLIB_FOR_TARGET=@RANLIB_FOR_TARGET@
+READELF_FOR_TARGET=@READELF_FOR_TARGET@
+STRIP_FOR_TARGET=@STRIP_FOR_TARGET@
+WINDRES_FOR_TARGET=@WINDRES_FOR_TARGET@
+WINDMC_FOR_TARGET=@WINDMC_FOR_TARGET@
-LD_FOR_TARGET=@LD_FOR_TARGET@
-USUAL_LD_FOR_TARGET = ` \
- if [ -f $$r/ld/ld-new ] ; then \
- echo $$r/ld/ld-new ; \
- elif [ -f $$r/gcc/xgcc ]; then \
- $(CC_FOR_TARGET) -print-prog-name=ld ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- echo $(LD); \
- else \
- echo ld | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+COMPILER_AS_FOR_TARGET=@COMPILER_AS_FOR_TARGET@
+COMPILER_LD_FOR_TARGET=@COMPILER_LD_FOR_TARGET@
+COMPILER_NM_FOR_TARGET=@COMPILER_NM_FOR_TARGET@
-DLLTOOL_FOR_TARGET=@DLLTOOL_FOR_TARGET@
-USUAL_DLLTOOL_FOR_TARGET = ` \
- if [ -f $$r/binutils/dlltool ] ; then \
- echo $$r/binutils/dlltool ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- echo $(DLLTOOL); \
- else \
- echo dlltool | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+CFLAGS_FOR_TARGET = @CFLAGS_FOR_TARGET@
+CXXFLAGS_FOR_TARGET = @CXXFLAGS_FOR_TARGET@
-WINDRES_FOR_TARGET=@WINDRES_FOR_TARGET@
-USUAL_WINDRES_FOR_TARGET = ` \
- if [ -f $$r/binutils/windres ] ; then \
- echo $$r/binutils/windres ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- echo $(WINDRES); \
- else \
- echo windres | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+LIBCFLAGS_FOR_TARGET = $(CFLAGS_FOR_TARGET)
+LIBCXXFLAGS_FOR_TARGET = $(CXXFLAGS_FOR_TARGET) -fno-implicit-templates
+LDFLAGS_FOR_TARGET = @LDFLAGS_FOR_TARGET@
+GOCFLAGS_FOR_TARGET = -O2 -g
-AR_FOR_TARGET=@AR_FOR_TARGET@
-USUAL_AR_FOR_TARGET = ` \
- if [ -f $$r/binutils/ar ] ; then \
- echo $$r/binutils/ar ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- echo $(AR); \
- else \
- echo ar | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+FLAGS_FOR_TARGET = @FLAGS_FOR_TARGET@
+SYSROOT_CFLAGS_FOR_TARGET = @SYSROOT_CFLAGS_FOR_TARGET@
+DEBUG_PREFIX_CFLAGS_FOR_TARGET = @DEBUG_PREFIX_CFLAGS_FOR_TARGET@
-RANLIB_FOR_TARGET=@RANLIB_FOR_TARGET@
-USUAL_RANLIB_FOR_TARGET = ` \
- if [ -f $$r/binutils/ranlib ] ; then \
- echo $$r/binutils/ranlib ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- if [ x'$(RANLIB)' != x ]; then \
- echo $(RANLIB); \
- else \
- echo ranlib; \
- fi; \
- else \
- echo ranlib | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+XGCC_FLAGS_FOR_TARGET = $(FLAGS_FOR_TARGET) $(SYSROOT_CFLAGS_FOR_TARGET) $(DEBUG_PREFIX_CFLAGS_FOR_TARGET)
-NM_FOR_TARGET=@NM_FOR_TARGET@
-USUAL_NM_FOR_TARGET = ` \
- if [ -f $$r/binutils/nm-new ] ; then \
- echo $$r/binutils/nm-new ; \
- elif [ -f $$r/gcc/xgcc ]; then \
- $(CC_FOR_TARGET) -print-prog-name=nm ; \
- else \
- if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- echo $(NM); \
- else \
- echo nm | sed '$(program_transform_name)' ; \
- fi; \
- fi`
+# ------------------------------------
+# Miscellaneous targets and flag lists
+# ------------------------------------
# The first rule in the file had better be this one. Don't put any above it.
# This lives here to allow makefile fragments to contain dependencies.
-all: all.normal
-.PHONY: all
+all:
#### host and target specific makefile fragments come in here.
@target_makefile_frag@
@host_makefile_frag@
###
+# This is the list of directories that may be needed in RPATH_ENVVAR
+# so that programs built for the target machine work.
+TARGET_LIB_PATH = [+ FOR target_modules +][+
+ IF lib_path +]$(TARGET_LIB_PATH_[+module+])[+ ENDIF lib_path +][+
+ ENDFOR target_modules +]$(HOST_LIB_PATH_gcc)
+[+ FOR target_modules +][+ IF lib_path +]
+@if target-[+module+]
+TARGET_LIB_PATH_[+module+] = $$r/$(TARGET_SUBDIR)/[+module+]/[+lib_path+]:
+@endif target-[+module+]
+[+ ENDIF lib_path +][+ ENDFOR target_modules +]
+
+
+# This is the list of directories that may be needed in RPATH_ENVVAR
+# so that programs built for the host machine work.
+HOST_LIB_PATH = [+ FOR host_modules +][+
+ IF lib_path +]$(HOST_LIB_PATH_[+module+])[+ ENDIF lib_path +][+
+ ENDFOR host_modules +]
+
+# Define HOST_LIB_PATH_gcc here, for the sake of TARGET_LIB_PATH, ouch
+@if gcc
+HOST_LIB_PATH_gcc = $$r/$(HOST_SUBDIR)/gcc$(GCC_SHLIB_SUBDIR):$$r/$(HOST_SUBDIR)/prev-gcc$(GCC_SHLIB_SUBDIR):
+@endif gcc
+
+[+ FOR host_modules +][+ IF lib_path +]
+@if [+module+]
+HOST_LIB_PATH_[+module+] = \
+ $$r/$(HOST_SUBDIR)/[+module+]/[+lib_path+]:[+ IF bootstrap
+ +]$$r/$(HOST_SUBDIR)/prev-[+module+]/[+lib_path+]:[+ ENDIF bootstrap +]
+@endif [+module+]
+[+ ENDIF lib_path +][+ ENDFOR host_modules +]
+
+CXX_FOR_TARGET_FLAG_TO_PASS = \
+ "CXX_FOR_TARGET=$(CXX_FOR_TARGET)"
+@if target-libstdc++-v3
+# CXX_FOR_TARGET is tricky to get right for target libs that require a
+# functional C++ compiler. When we recurse, if we expand
+# CXX_FOR_TARGET before configuring libstdc++-v3, we won't get
+# libstdc++ include flags from the script. Instead, we get an
+# -funconfigured-* word, so that we'll get errors if this invalid C++
+# command line is used for anything, but also so that we can use the
+# word to decide whether or not to pass on this CXX_FOR_TARGET. If we
+# don't pass it on, sub-make will use the default definition, that
+# re-expands it at the time of use, so we'll get it right when we need
+# it. One potential exception is the expansion of CXX_FOR_TARGET
+# passed down as part of CXX within TARGET_FLAGS, but this wouldn't
+# really work, for C++ host programs can't depend on the current-stage
+# C++ target library.
+CXX_FOR_TARGET_FLAG_TO_PASS = \
+ $(shell if echo "$(CXX_FOR_TARGET)" | grep " -funconfigured-" > /dev/null; then :; else echo '"CXX_FOR_TARGET=$(CXX_FOR_TARGET)"'; fi)
+@endif target-libstdc++-v3
+
# Flags to pass down to all sub-makes.
-# Please keep these in alphabetical order.
-BASE_FLAGS_TO_PASS = \
- "AR_FLAGS=$(AR_FLAGS)" \
- "AR_FOR_TARGET=$(AR_FOR_TARGET)" \
- "AS_FOR_TARGET=$(AS_FOR_TARGET)" \
- "BISON=$(BISON)" \
- "CC_FOR_BUILD=$(CC_FOR_BUILD)" \
- "CC_FOR_TARGET=$(CC_FOR_TARGET)" \
- "CFLAGS=$(CFLAGS)" \
- "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
- "GCJ_FOR_TARGET=$(GCJ_FOR_TARGET)" \
- "CXX_FOR_BUILD=$(CXX_FOR_BUILD)" \
- "CXXFLAGS=$(CXXFLAGS)" \
- "CXXFLAGS_FOR_TARGET=$(CXXFLAGS_FOR_TARGET)" \
- "CXX_FOR_TARGET=$(CXX_FOR_TARGET)" \
- "DESTDIR=$(DESTDIR)" \
- "DLLTOOL_FOR_TARGET=$(DLLTOOL_FOR_TARGET)" \
- "INSTALL=$(INSTALL)" \
- "INSTALL_DATA=$(INSTALL_DATA)" \
- "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
- "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
- "LDFLAGS=$(LDFLAGS)" \
- "LEX=$(LEX)" \
- "LD_FOR_TARGET=$(LD_FOR_TARGET)" \
- "LIBCFLAGS=$(LIBCFLAGS)" \
- "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
- "LIBCXXFLAGS=$(LIBCXXFLAGS)" \
- "LIBCXXFLAGS_FOR_TARGET=$(LIBCXXFLAGS_FOR_TARGET)" \
- "M4=$(M4)" \
- "MAKE=$(MAKE)" \
- "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
- "NM_FOR_TARGET=$(NM_FOR_TARGET)" \
- "RANLIB_FOR_TARGET=$(RANLIB_FOR_TARGET)" \
- "RPATH_ENVVAR=$(RPATH_ENVVAR)" \
- "SHELL=$(SHELL)" \
- "EXPECT=$(EXPECT)" \
- "RUNTEST=$(RUNTEST)" \
- "RUNTESTFLAGS=$(RUNTESTFLAGS)" \
- "TARGET_SUBDIR=$(TARGET_SUBDIR)" \
- "WINDRES_FOR_TARGET=$(WINDRES_FOR_TARGET)" \
- "YACC=$(YACC)" \
- "bindir=$(bindir)" \
- "datadir=$(datadir)" \
- "exec_prefix=$(exec_prefix)" \
- "includedir=$(includedir)" \
- "infodir=$(infodir)" \
- "libdir=$(libdir)" \
- "libexecdir=$(libexecdir)" \
- "lispdir=$(lispdir)" \
- "libstdcxx_incdir=$(libstdcxx_incdir)" \
- "libsubdir=$(libsubdir)" \
- "localstatedir=$(localstatedir)" \
- "mandir=$(mandir)" \
- "oldincludedir=$(oldincludedir)" \
- "prefix=$(prefix)" \
- "sbindir=$(sbindir)" \
- "sharedstatedir=$(sharedstatedir)" \
- "sysconfdir=$(sysconfdir)" \
- "tooldir=$(tooldir)" \
- "build_tooldir=$(build_tooldir)" \
- "gxx_include_dir=$(gxx_include_dir)" \
- "gcc_version=$(gcc_version)" \
- "gcc_version_trigger=$(gcc_version_trigger)" \
- "target_alias=$(target_alias)"
-
-# For any flags above that may contain shell code that varies from one
-# target library to another. When doing recursive invocations of the
-# top-level Makefile, we don't want the outer make to evaluate them,
-# so we pass these variables down unchanged. They must not contain
-# single nor double quotes.
-RECURSE_FLAGS = \
- CXX_FOR_TARGET='$(CXX_FOR_TARGET_FOR_RECURSIVE_MAKE)' \
- RAW_CXX_FOR_TARGET='$(RAW_CXX_FOR_TARGET_FOR_RECURSIVE_MAKE)' \
+BASE_FLAGS_TO_PASS =[+ FOR flags_to_pass +][+ IF optional +] \
+ "`echo '[+flag+]=$([+flag+])' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"[+ ELSE optional +] \
+ "[+flag+]=$([+flag+])"[+ ENDIF optional+][+ ENDFOR flags_to_pass +][+ FOR bootstrap-stage +] \
+ "STAGE[+id+]_CFLAGS=$(STAGE[+id+]_CFLAGS)" \
+ "STAGE[+id+]_CXXFLAGS=$(STAGE[+id+]_CXXFLAGS)" \
+ "STAGE[+id+]_TFLAGS=$(STAGE[+id+]_TFLAGS)"[+ ENDFOR bootstrap-stage +] \
+ $(CXX_FOR_TARGET_FLAG_TO_PASS) \
+ "TFLAGS=$(TFLAGS)" \
+ "CONFIG_SHELL=$(SHELL)" \
+ "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)"
+
+# We leave this in just in case, but it is not needed anymore.
+RECURSE_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS)
# Flags to pass down to most sub-makes, in which we're building with
# the host environment.
-# If any variables are added here, they must be added to do-*, below.
EXTRA_HOST_FLAGS = \
'AR=$(AR)' \
'AS=$(AS)' \
'CC=$(CC)' \
'CXX=$(CXX)' \
'DLLTOOL=$(DLLTOOL)' \
+ 'GCJ=$(GCJ)' \
+ 'GFORTRAN=$(GFORTRAN)' \
+ 'GOC=$(GOC)' \
'LD=$(LD)' \
+ 'LIPO=$(LIPO)' \
'NM=$(NM)' \
- "`echo 'RANLIB=$(RANLIB)' | sed -e s/.*=$$/XFOO=/`" \
- 'WINDRES=$(WINDRES)'
+ 'OBJDUMP=$(OBJDUMP)' \
+ 'RANLIB=$(RANLIB)' \
+ 'READELF=$(READELF)' \
+ 'STRIP=$(STRIP)' \
+ 'WINDRES=$(WINDRES)' \
+ 'WINDMC=$(WINDMC)'
FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS)
-# Flags that are concerned with the location of the X11 include files
-# and library files
-#
-# NOTE: until the top-level is getting the values via autoconf, it only
-# causes problems to have this top-level Makefile overriding the autoconf-set
-# values in child directories. Only variables that don't conflict with
-# autoconf'ed ones should be passed by X11_FLAGS_TO_PASS for now.
-#
-X11_FLAGS_TO_PASS = \
- 'X11_EXTRA_CFLAGS=$(X11_EXTRA_CFLAGS)' \
- 'X11_EXTRA_LIBS=$(X11_EXTRA_LIBS)'
+# Flags to pass to stage1 or when not bootstrapping.
+
+STAGE1_FLAGS_TO_PASS = \
+ LDFLAGS="$${LDFLAGS}" \
+ HOST_LIBS="$${HOST_LIBS}"
+
+# Flags to pass to stage2 and later makes.
+
+POSTSTAGE1_FLAGS_TO_PASS = \
+ CC="$${CC}" CC_FOR_BUILD="$${CC_FOR_BUILD}" \
+ CXX="$${CXX}" CXX_FOR_BUILD="$${CXX_FOR_BUILD}" \
+ GNATBIND="$${GNATBIND}" \
+ LDFLAGS="$${LDFLAGS}" \
+ HOST_LIBS="$${HOST_LIBS}" \
+ "`echo 'ADAFLAGS=$(BOOT_ADAFLAGS)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"
# Flags to pass down to makes which are built with the target environment.
-# The double $ decreases the length of the command line; the variables
-# are set in BASE_FLAGS_TO_PASS, and the sub-make will expand them.
-# If any variables are added here, they must be added to do-*, below.
+# The double $ decreases the length of the command line; those variables
+# are set in BASE_FLAGS_TO_PASS, and the sub-make will expand them. The
+# *_CFLAGS_FOR_TARGET variables are not passed down and most often empty,
+# so we expand them here.
EXTRA_TARGET_FLAGS = \
'AR=$$(AR_FOR_TARGET)' \
- 'AS=$$(AS_FOR_TARGET)' \
- 'CC=$$(CC_FOR_TARGET)' \
+ 'AS=$(COMPILER_AS_FOR_TARGET)' \
+ 'CC=$$(CC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
'CFLAGS=$$(CFLAGS_FOR_TARGET)' \
- 'CXX=$$(CXX_FOR_TARGET)' \
+ 'CXX=$$(CXX_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
'CXXFLAGS=$$(CXXFLAGS_FOR_TARGET)' \
'DLLTOOL=$$(DLLTOOL_FOR_TARGET)' \
- 'LD=$$(LD_FOR_TARGET)' \
+ 'GCJ=$$(GCJ_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
+ 'GFORTRAN=$$(GFORTRAN_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
+ 'GOC=$$(GOC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
+ 'GOCFLAGS=$$(GOCFLAGS_FOR_TARGET)' \
+ 'LD=$(COMPILER_LD_FOR_TARGET)' \
+ 'LDFLAGS=$$(LDFLAGS_FOR_TARGET)' \
'LIBCFLAGS=$$(LIBCFLAGS_FOR_TARGET)' \
'LIBCXXFLAGS=$$(LIBCXXFLAGS_FOR_TARGET)' \
- 'NM=$$(NM_FOR_TARGET)' \
+ 'NM=$(COMPILER_NM_FOR_TARGET)' \
+ 'OBJDUMP=$$(OBJDUMP_FOR_TARGET)' \
'RANLIB=$$(RANLIB_FOR_TARGET)' \
- 'WINDRES=$$(WINDRES_FOR_TARGET)'
+ 'READELF=$$(READELF_FOR_TARGET)' \
+ 'WINDRES=$$(WINDRES_FOR_TARGET)' \
+ 'WINDMC=$$(WINDMC_FOR_TARGET)' \
+ 'XGCC_FLAGS_FOR_TARGET=$(XGCC_FLAGS_FOR_TARGET)' \
+ "TFLAGS=$$TFLAGS"
TARGET_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_TARGET_FLAGS)
# unfortunately needs the native compiler and the target ar and
# ranlib.
# If any variables are added here, they must be added to do-*, below.
-# The HOST_* variables are a special case, which are used for the gcc
+# The BUILD_* variables are a special case, which are used for the gcc
# cross-building scheme.
EXTRA_GCC_FLAGS = \
- 'AR=$(AR)' \
- 'AS=$(AS)' \
- 'CC=$(CC)' \
- 'CXX=$(CXX)' \
- 'DLLTOOL=$$(DLLTOOL_FOR_TARGET)' \
- 'BUILD_CC=$(CC_FOR_BUILD)' \
- 'BUILD_PREFIX=$(BUILD_PREFIX)' \
- 'BUILD_PREFIX_1=$(BUILD_PREFIX_1)' \
- 'NM=$(NM)' \
- "`echo 'RANLIB=$(RANLIB)' | sed -e s/.*=$$/XFOO=/`" \
- 'WINDRES=$$(WINDRES_FOR_TARGET)' \
"GCC_FOR_TARGET=$(GCC_FOR_TARGET)" \
- "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
- "`echo 'LANGUAGES=$(LANGUAGES)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'STMP_FIXPROTO=$(STMP_FIXPROTO)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'LIMITS_H_TEST=$(LIMITS_H_TEST)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'LIBGCC2_CFLAGS=$(LIBGCC2_CFLAGS)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'LIBGCC2_DEBUG_CFLAGS=$(LIBGCC2_DEBUG_CFLAGS)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'LIBGCC2_INCLUDES=$(LIBGCC2_INCLUDES)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'ENQUIRE=$(ENQUIRE)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'STAGE1_CFLAGS=$(STAGE1_CFLAGS)' | sed -e s/.*=$$/XFOO=/`" \
- "`echo 'BOOT_CFLAGS=$(BOOT_CFLAGS)' | sed -e s/.*=$$/XFOO=/`"
-
-GCC_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS)
-
-configure-host: @configure_host_modules@
-configure-target: @configure_target_modules@
-
-# This is a list of the targets for which we can do a clean-{target}.
-CLEAN_MODULES =[+
- FOR host_modules +][+
- IF (not (or (exist? "no_clean") (exist? "with_x"))) +] \
- clean-[+module+][+
- ENDIF no_clean +][+
- ENDFOR host_modules +]
-
-# All of the target modules that can be cleaned
-CLEAN_TARGET_MODULES =[+
- FOR target_modules +][+
- IF (not (exist? "no_clean")) +] \
- clean-target-[+module+][+
- ENDIF no_clean +][+
- ENDFOR target_modules +]
-
-# All of the x11 modules that can be cleaned
-CLEAN_X11_MODULES = [+ FOR host_modules +][+ IF with_x +]\
- clean-[+module+] [+ ENDIF with_x +][+ ENDFOR host_modules +]
-
-# The target built for a native build.
-# This list only includes modules actually being configured and built.
-.PHONY: all.normal
-all.normal: @all_build_modules@ \
- @all_host_modules@ \
- @all_target_modules@
-
-all-host: @all_host_modules@
-all-target: @all_target_modules@
+ "`echo 'STMP_FIXPROTO=$(STMP_FIXPROTO)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`" \
+ "`echo 'LIMITS_H_TEST=$(LIMITS_H_TEST)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"
+
+GCC_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS)
+
+@if gcc
+BUILD_CONFIG = @BUILD_CONFIG@
+ifneq ($(BUILD_CONFIG),)
+include $(foreach CONFIG, $(BUILD_CONFIG), $(srcdir)/config/$(CONFIG).mk)
+endif
+@endif gcc
+
+.PHONY: configure-host
+configure-host: [+
+ FOR host_modules +] \
+ maybe-configure-[+module+][+
+ ENDFOR host_modules +]
+.PHONY: configure-target
+configure-target: [+
+ FOR target_modules +] \
+ maybe-configure-target-[+module+][+
+ ENDFOR target_modules +]
+
+# The target built for a native non-bootstrap build.
+.PHONY: all
+all:
+@if gcc-bootstrap
+ [ -f stage_final ] || echo stage3 > stage_final
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) `cat stage_final`-bubble
+@endif gcc-bootstrap
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+@if gcc-bootstrap
+ if [ -f stage_last ]; then \
+ TFLAGS="$(STAGE$(shell test ! -f stage_last || sed s,^stage,, stage_last)_TFLAGS)"; \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) all-host all-target; \
+ else \
+@endif gcc-bootstrap
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-host all-target \
+@if gcc-bootstrap
+ ; \
+ fi \
+@endif gcc-bootstrap
+ && :
+
+.PHONY: all-build
+[+ FOR build_modules +]
+all-build: maybe-all-build-[+module+][+ ENDFOR build_modules +]
+
+.PHONY: all-host
+[+ FOR host_modules +][+ IF bootstrap +]
+@if [+module+]-no-bootstrap[+ ENDIF bootstrap +]
+all-host: maybe-all-[+module+][+ IF bootstrap +]
+@endif [+module+]-no-bootstrap[+ ENDIF bootstrap +][+ ENDFOR host_modules +]
+
+.PHONY: all-target
+[+ FOR target_modules +][+ IF bootstrap +]
+@if target-[+module+]-no-bootstrap[+ ENDIF bootstrap +]
+all-target: maybe-all-target-[+module+][+ IF bootstrap +]
+@endif target-[+module+]-no-bootstrap[+
+ ENDIF bootstrap +][+ ENDFOR target_modules +]
# Do a target for all the subdirectories. A ``make do-X'' will do a
# ``make X'' in all subdirectories (because, in general, there is a
# dependency (below) of X upon do-X, a ``make X'' will also do this,
# but it may do additional work as well).
-# This target ensures that $(BASE_FLAGS_TO_PASS) appears only once,
-# because it is so large that it can easily overflow the command line
-# length limit on some systems.
[+ FOR recursive_targets +]
-.PHONY: do-[+target+]
-do-[+target+]:
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- for i in $(SUBDIRS) -dummy-; do \
- if [ -f ./$$i/Makefile ]; then \
- case $$i in \
- gcc) \
- for flag in $(EXTRA_GCC_FLAGS); do \
- eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
- done; \
- ;; \
- *) \
- for flag in $(EXTRA_HOST_FLAGS); do \
- eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
- done; \
- ;; \
- esac ; \
- (cd ./$$i && \
- $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
- "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
- "`echo \"RANLIB=$${RANLIB}\" | sed -e 's/.*=$$/XFOO=/'`" \
- "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" \
- [+target+]) \
- || exit 1; \
- else true; fi; \
- done
- # Break into two pieces
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- for i in $(TARGET_CONFIGDIRS) -dummy-; do \
- if [ -f $(TARGET_SUBDIR)/$$i/Makefile ]; then \
- for flag in $(EXTRA_TARGET_FLAGS); do \
- eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
- done; \
- (cd $(TARGET_SUBDIR)/$$i && \
- $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
- "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
- "`echo \"RANLIB=$${RANLIB}\" | sed -e 's/.*=$$/XFOO=/'`" \
- "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" \
- [+target+]) \
- || exit 1; \
- else true; fi; \
- done
-[+ ENDFOR recursive_targets +]
+.PHONY: do-[+make_target+]
+do-[+make_target+]:
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) [+make_target+]-host \
+ [+make_target+]-target
+.PHONY: [+make_target+]-host
+[+ FOR host_modules +]
+[+make_target+]-host: maybe-[+make_target+]-[+module+][+ ENDFOR host_modules +]
+
+.PHONY: [+make_target+]-target
+[+ FOR target_modules +]
+[+make_target+]-target: maybe-[+make_target+]-target-[+module+][+ ENDFOR target_modules +]
+[+ ENDFOR recursive_targets +]
+
# Here are the targets which correspond to the do-X targets.
-.PHONY: info installcheck dvi install-info
+.PHONY: info installcheck dvi pdf html
+.PHONY: install-info install-pdf install-html
.PHONY: clean distclean mostlyclean maintainer-clean realclean
.PHONY: local-clean local-distclean local-maintainer-clean
info: do-info
installcheck: do-installcheck
dvi: do-dvi
+pdf: do-pdf
+html: do-html
# Make sure makeinfo is built before we do a `make info', if we're
# in fact building texinfo.
do-info: maybe-all-texinfo
install-info: do-install-info dir.info
- s=`cd $(srcdir); ${PWD}`; export s; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
if [ -f dir.info ] ; then \
$(INSTALL_DATA) dir.info $(DESTDIR)$(infodir)/dir.info ; \
else true ; fi
+install-pdf: do-install-pdf
+
+install-html: do-install-html
+
local-clean:
-rm -f *.a TEMP errs core *.o *~ \#* TAGS *.E *.log
local-distclean:
-rm -f Makefile config.status config.cache mh-frag mt-frag
- -rm -f multilib.out multilib.tmp maybedep.tmp serdep.tmp
+ -rm -f maybedep.tmp serdep.tmp
-if [ "$(TARGET_SUBDIR)" != "." ]; then \
rm -rf $(TARGET_SUBDIR); \
else true; fi
+ -rm -rf $(BUILD_SUBDIR)
+ -if [ "$(HOST_SUBDIR)" != "." ]; then \
+ rm -rf $(HOST_SUBDIR); \
+ else true; fi
-rm -f texinfo/po/Makefile texinfo/po/Makefile.in texinfo/info/Makefile
-rm -f texinfo/doc/Makefile texinfo/po/POTFILES
-rmdir texinfo/doc texinfo/info texinfo/intl texinfo/lib 2>/dev/null
-rmdir texinfo/makeinfo texinfo/po texinfo/util 2>/dev/null
-rmdir fastjar gcc libiberty texinfo zlib 2>/dev/null
+ -find . -name config.cache -exec rm -f {} \; \; 2>/dev/null
local-maintainer-clean:
@echo "This command is intended for maintainers to use;"
maintainer-clean: local-distclean
realclean: maintainer-clean
-# This rule is used to clean specific modules.
-.PHONY: $(CLEAN_MODULES) $(CLEAN_X11_MODULES) clean-gcc
-$(CLEAN_MODULES) $(CLEAN_X11_MODULES) clean-gcc:
- @dir=`echo $@ | sed -e 's/clean-//'`; \
- if [ -f ./$${dir}/Makefile ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd $${dir} && $(MAKE) $(FLAGS_TO_PASS) clean); \
- else \
- true; \
- fi
-
-.PHONY: $(CLEAN_TARGET_MODULES)
-$(CLEAN_TARGET_MODULES):
- @dir=`echo $@ | sed -e 's/clean-target-//'`; \
- rm -f $(TARGET_SUBDIR)/$${dir}/multilib.out $(TARGET_SUBDIR)/$${dir}/tmpmulti.out; \
- if [ -f $(TARGET_SUBDIR)/$${dir}/Makefile ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd $(TARGET_SUBDIR)/$${dir} && $(MAKE) $(TARGET_FLAGS_TO_PASS) clean); \
- else \
- true; \
- fi
-
-clean-target: $(CLEAN_TARGET_MODULES) clean-target-libgcc
-clean-target-libgcc:
- test ! -d gcc/libgcc || \
- (cd gcc/libgcc && find . -type d -print) | \
- while read d; do rm -f gcc/$$d/libgcc.a || : ; done
- -rm -rf gcc/libgcc
-
# Check target.
.PHONY: check do-check
-check:
- $(MAKE) do-check NOTPARALLEL=parallel-ok
+check: do-check
# Only include modules actually being configured and built.
-do-check: @check_host_modules@ \
- @check_target_modules@
+.PHONY: check-host
+check-host: [+
+ FOR host_modules +] \
+ maybe-check-[+module+][+
+ ENDFOR host_modules +]
+
+.PHONY: check-target
+check-target: [+
+ FOR target_modules +] \
+ maybe-check-target-[+module+][+
+ ENDFOR target_modules +]
+
+do-check:
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) check-host check-target
# Automated reporting of test results.
# Installation targets.
.PHONY: install uninstall
-install: installdirs @install_host_modules@ @install_target_modules@
-
-install-target: @install_target_modules@
+install:
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) installdirs install-host install-target
+
+.PHONY: install-host-nogcc
+install-host-nogcc: [+
+ FOR host_modules +][+ IF (not (= (get "module") "gcc")) +] \
+ maybe-install-[+module+][+ ENDIF +][+
+ ENDFOR host_modules +]
+
+.PHONY: install-host
+install-host: [+
+ FOR host_modules +] \
+ maybe-install-[+module+][+
+ ENDFOR host_modules +]
+
+.PHONY: install-target
+install-target: [+
+ FOR target_modules +] \
+ maybe-install-target-[+module+][+
+ ENDFOR target_modules +]
uninstall:
@echo "the uninstall target is not supported in this tree"
.PHONY: install.all
install.all: install-no-fixedincludes
@if [ -f ./gcc/Makefile ] ; then \
- r=`${PWD}` ; export r ; \
- $(SET_LIB_PATH) \
+ r=`${PWD_COMMAND}` ; export r ; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
(cd ./gcc && \
$(MAKE) $(FLAGS_TO_PASS) install-headers) ; \
else \
true ; \
fi
-# install-no-fixedincludes is used because Cygnus can not distribute
-# the fixed header files.
+# install-no-fixedincludes is used to allow the elaboration of binary packages
+# suitable for distribution, where we cannot include the fixed system header
+# files.
.PHONY: install-no-fixedincludes
-install-no-fixedincludes: installdirs @install_host_modules_nogcc@ \
- @install_target_modules@ gcc-no-fixedincludes
+install-no-fixedincludes: installdirs install-host-nogcc \
+ install-target gcc-install-no-fixedincludes
+
+.PHONY: install-strip
+install-strip:
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) installdirs install-strip-host install-strip-target
+
+.PHONY: install-strip-host
+install-strip-host: [+
+ FOR host_modules +] \
+ maybe-install-strip-[+module+][+
+ ENDFOR host_modules +]
+
+.PHONY: install-strip-target
+install-strip-target: [+
+ FOR target_modules +] \
+ maybe-install-strip-target-[+module+][+
+ ENDFOR target_modules +]
+
### other supporting targets
# built are.
TAGS: do-TAGS
+# ------------------------------------
+# Macros for configure and all targets
+# ------------------------------------
+
+[+ DEFINE configure +]
+.PHONY: configure-[+prefix+][+module+] maybe-configure-[+prefix+][+module+]
+maybe-configure-[+prefix+][+module+]:
+@if gcc-bootstrap
+configure-[+prefix+][+module+]: stage_current
+@endif gcc-bootstrap
+@if [+prefix+][+module+]
+maybe-configure-[+prefix+][+module+]: configure-[+prefix+][+module+]
+configure-[+prefix+][+module+]: [+ IF bootstrap +][+ ELSE +]
+ @: $(MAKE); $(unstage)[+ ENDIF bootstrap +]
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ [+ IF check_multilibs
+ +]echo "Checking multilib configuration for [+module+]..."; \
+ $(SHELL) $(srcdir)/mkinstalldirs [+subdir+]/[+module+] ; \
+ $(CC_FOR_TARGET) --print-multi-lib > [+subdir+]/[+module+]/multilib.tmp 2> /dev/null ; \
+ if test -r [+subdir+]/[+module+]/multilib.out; then \
+ if cmp -s [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; then \
+ rm -f [+subdir+]/[+module+]/multilib.tmp; \
+ else \
+ rm -f [+subdir+]/[+module+]/Makefile; \
+ mv [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; \
+ fi; \
+ else \
+ mv [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; \
+ fi; \
+ [+ ENDIF check_multilibs +]test ! -f [+subdir+]/[+module+]/Makefile || exit 0; \
+ $(SHELL) $(srcdir)/mkinstalldirs [+subdir+]/[+module+] ; \
+ [+exports+] [+extra_exports+] \
+ echo Configuring in [+subdir+]/[+module+]; \
+ cd "[+subdir+]/[+module+]" || exit 1; \
+ case $(srcdir) in \
+ /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
+ *) topdir=`echo [+subdir+]/[+module+]/ | \
+ sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
+ esac; \
+ srcdiroption="--srcdir=$${topdir}/[+module+]"; \
+ libsrcdir="$$s/[+module+]"; \
+ [+ IF no-config-site +]rm -f no-such-file || : ; \
+ CONFIG_SITE=no-such-file [+ ENDIF +]$(SHELL) $${libsrcdir}/configure \
+ [+args+] --build=${build_alias} --host=[+host_alias+] \
+ --target=[+target_alias+] $${srcdiroption} [+extra_configure_flags+] \
+ || exit 1
+@endif [+prefix+][+module+]
+
+[+ IF bootstrap +]
+[+ FOR bootstrap_stage +]
+.PHONY: configure-stage[+id+]-[+prefix+][+module+] maybe-configure-stage[+id+]-[+prefix+][+module+]
+maybe-configure-stage[+id+]-[+prefix+][+module+]:
+@if [+prefix+][+module+]-bootstrap
+maybe-configure-stage[+id+]-[+prefix+][+module+]: configure-stage[+id+]-[+prefix+][+module+]
+configure-stage[+id+]-[+prefix+][+module+]:
+ @[ $(current_stage) = stage[+id+] ] || $(MAKE) stage[+id+]-start
+ @$(SHELL) $(srcdir)/mkinstalldirs [+subdir+]/[+module+]
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ TFLAGS="$(STAGE[+id+]_TFLAGS)"; \
+ [+ IF check_multilibs
+ +]echo "Checking multilib configuration for [+module+]..."; \
+ $(CC_FOR_TARGET) --print-multi-lib > [+subdir+]/[+module+]/multilib.tmp 2> /dev/null ; \
+ if test -r [+subdir+]/[+module+]/multilib.out; then \
+ if cmp -s [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; then \
+ rm -f [+subdir+]/[+module+]/multilib.tmp; \
+ else \
+ rm -f [+subdir+]/[+module+]/Makefile; \
+ mv [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; \
+ fi; \
+ else \
+ mv [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; \
+ fi; \
+ [+ ENDIF check_multilibs +]test ! -f [+subdir+]/[+module+]/Makefile || exit 0; \
+ [+exports+][+ IF prev +] \
+ [+poststage1_exports+][+ ENDIF prev +][+ IF prefix +] \
+ CFLAGS="$(CFLAGS_FOR_TARGET)"; export CFLAGS; \
+ CXXFLAGS="$(CXXFLAGS_FOR_TARGET)"; export CXXFLAGS; \
+ LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)"; export LIBCFLAGS;[+ ELSE prefix +] \
+ CFLAGS="$(STAGE[+id+]_CFLAGS)"; export CFLAGS; \
+ CXXFLAGS="$(STAGE[+id+]_CXXFLAGS)"; export CXXFLAGS;[+ IF prev +] \
+ LIBCFLAGS="$(STAGE[+id+]_CFLAGS)"[+ ELSE prev +] \
+ LIBCFLAGS="$(LIBCFLAGS)"[+ ENDIF prev +]; export LIBCFLAGS;[+
+ ENDIF prefix +] [+extra_exports+] \
+ echo Configuring stage [+id+] in [+subdir+]/[+module+] ; \
+ $(SHELL) $(srcdir)/mkinstalldirs [+subdir+]/[+module+] ; \
+ cd [+subdir+]/[+module+] || exit 1; \
+ case $(srcdir) in \
+ /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
+ *) topdir=`echo [+subdir+]/[+module+]/ | \
+ sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
+ esac; \
+ srcdiroption="--srcdir=$${topdir}/[+module+]"; \
+ libsrcdir="$$s/[+module+]"; \
+ $(SHELL) $${libsrcdir}/configure \
+ [+args+] --build=${build_alias} --host=[+host_alias+] \
+ --target=[+target_alias+] $${srcdiroption} [+ IF prev +]\
+ --with-build-libsubdir=$(HOST_SUBDIR) [+ ENDIF prev +]\
+ $(STAGE[+id+]_CONFIGURE_FLAGS)[+ IF extra_configure_flags +] \
+ [+extra_configure_flags+][+ ENDIF extra_configure_flags +]
+@endif [+prefix+][+module+]-bootstrap
+[+ ENDFOR bootstrap_stage +]
+[+ ENDIF bootstrap +]
+[+ ENDDEF +]
+
+[+ DEFINE all +]
+.PHONY: all-[+prefix+][+module+] maybe-all-[+prefix+][+module+]
+maybe-all-[+prefix+][+module+]:
+@if gcc-bootstrap
+all-[+prefix+][+module+]: stage_current
+@endif gcc-bootstrap
+@if [+prefix+][+module+]
+TARGET-[+prefix+][+module+]=[+
+ IF all_target +][+all_target+][+ ELSE +]all[+ ENDIF all_target +]
+maybe-all-[+prefix+][+module+]: all-[+prefix+][+module+]
+all-[+prefix+][+module+]: configure-[+prefix+][+module+][+ IF bootstrap +][+ ELSE +]
+ @: $(MAKE); $(unstage)[+ ENDIF bootstrap +]
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ [+exports+] [+extra_exports+] \
+ (cd [+subdir+]/[+module+] && \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) [+args+] [+stage1_args+] [+extra_make_flags+] \
+ $(TARGET-[+prefix+][+module+]))
+@endif [+prefix+][+module+]
+
+[+ IF bootstrap +]
+[+ FOR bootstrap_stage +]
+.PHONY: all-stage[+id+]-[+prefix+][+module+] maybe-all-stage[+id+]-[+prefix+][+module+]
+.PHONY: clean-stage[+id+]-[+prefix+][+module+] maybe-clean-stage[+id+]-[+prefix+][+module+]
+maybe-all-stage[+id+]-[+prefix+][+module+]:
+maybe-clean-stage[+id+]-[+prefix+][+module+]:
+@if [+prefix+][+module+]-bootstrap
+maybe-all-stage[+id+]-[+prefix+][+module+]: all-stage[+id+]-[+prefix+][+module+]
+all-stage[+id+]: all-stage[+id+]-[+prefix+][+module+]
+TARGET-stage[+id+]-[+prefix+][+module+] = $(TARGET-[+prefix+][+module+])
+all-stage[+id+]-[+prefix+][+module+]: configure-stage[+id+]-[+prefix+][+module+]
+ @[ $(current_stage) = stage[+id+] ] || $(MAKE) stage[+id+]-start
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ TFLAGS="$(STAGE[+id+]_TFLAGS)"; \
+ [+exports+][+ IF prev +] \
+ [+poststage1_exports+][+ ENDIF prev +] [+extra_exports+] \
+ cd [+subdir+]/[+module+] && \
+ $(MAKE) $(BASE_FLAGS_TO_PASS)[+ IF prefix +] \
+ CFLAGS="$(CFLAGS_FOR_TARGET)" \
+ CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
+ LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)"[+ ELSE prefix +] \
+ CFLAGS="$(STAGE[+id+]_CFLAGS)" \
+ CXXFLAGS="$(STAGE[+id+]_CXXFLAGS)"[+ IF prev +] \
+ LIBCFLAGS="$(STAGE[+id+]_CFLAGS)"[+ ELSE prev +] \
+ LIBCFLAGS="$(LIBCFLAGS)"[+ ENDIF prev +][+ ENDIF prefix +] \
+ CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
+ CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
+ LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
+ [+args+] [+IF prev +][+poststage1_args+][+ ELSE prev +] \
+ [+stage1_args+][+ ENDIF prev +] [+extra_make_flags+] \
+ TFLAGS="$(STAGE[+id+]_TFLAGS)" \
+ $(TARGET-stage[+id+]-[+prefix+][+module+])
+
+maybe-clean-stage[+id+]-[+prefix+][+module+]: clean-stage[+id+]-[+prefix+][+module+]
+clean-stage[+id+]: clean-stage[+id+]-[+prefix+][+module+]
+clean-stage[+id+]-[+prefix+][+module+]:
+ @if [ $(current_stage) = stage[+id+] ]; then \
+ [ -f [+subdir+]/[+module+]/Makefile ] || exit 0; \
+ else \
+ [ -f [+subdir+]/stage[+id+]-[+module+]/Makefile ] || exit 0; \
+ $(MAKE) stage[+id+]-start; \
+ fi; \
+ cd [+subdir+]/[+module+] && \
+ $(MAKE) [+args+] [+ IF prev +][+poststage1_args+][+ ELSE prev +] \
+ [+stage1_args+][+ ENDIF prev +] [+extra_make_flags+] clean
+@endif [+prefix+][+module+]-bootstrap
+
+[+ ENDFOR bootstrap_stage +]
+[+ ENDIF bootstrap +]
+[+ ENDDEF +]
+
# --------------------------------------
# Modules which run on the build machine
# --------------------------------------
[+ FOR build_modules +]
-.PHONY: configure-build-[+module+] maybe-configure-build-[+module+]
-maybe-configure-build-[+module+]:
-configure-build-[+module+]:
- @test ! -f $(BUILD_SUBDIR)/[+module+]/Makefile || exit 0; \
- [ -d $(BUILD_SUBDIR)/[+module+] ] || \
- mkdir $(BUILD_SUBDIR)/[+module+];\
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- AR="$(AR_FOR_BUILD)"; export AR; \
- AS="$(AS_FOR_BUILD)"; export AS; \
- CC="$(CC_FOR_BUILD)"; export CC; \
- CFLAGS="$(CFLAGS_FOR_BUILD)"; export CFLAGS; \
- CXX="$(CXX_FOR_BUILD)"; export CXX; \
- CXXFLAGS="$(CXXFLAGS_FOR_BUILD)"; export CXXFLAGS; \
- GCJ="$(GCJ_FOR_BUILD)"; export GCJ; \
- 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; \
- echo Configuring in $(BUILD_SUBDIR)/[+module+]; \
- cd "$(BUILD_SUBDIR)/[+module+]" || exit 1; \
- case $(srcdir) in \
- /* | [A-Za-z]:[\\/]*) \
- topdir=$(srcdir) ;; \
- *) \
- case "$(BUILD_SUBDIR)" in \
- .) topdir="../$(srcdir)" ;; \
- *) topdir="../../$(srcdir)" ;; \
- esac ;; \
- esac; \
- if [ "$(srcdir)" = "." ] ; then \
- if [ "$(BUILD_SUBDIR)" != "." ] ; then \
- if $(SHELL) $$s/symlink-tree $${topdir}/[+module+] "no-such-file" ; then \
- if [ -f Makefile ]; then \
- if $(MAKE) distclean; then \
- true; \
- else \
- exit 1; \
- fi; \
- else \
- true; \
- fi; \
- else \
- exit 1; \
- fi; \
- else \
- true; \
- fi; \
- srcdiroption="--srcdir=."; \
- libsrcdir="."; \
- else \
- srcdiroption="--srcdir=$${topdir}/[+module+]"; \
- libsrcdir="$$s/[+module+]"; \
- fi; \
- rm -f no-such-file || : ; \
- CONFIG_SITE=no-such-file $(SHELL) $${libsrcdir}/configure \
- $(BUILD_CONFIGARGS) $${srcdiroption} \
- --with-build-subdir="$(BUILD_SUBDIR)" \
- || exit 1
-
-.PHONY: all-build-[+module+] maybe-all-build-[+module+]
-maybe-all-build-[+module+]:
-all-build-[+module+]: configure-build-[+module+]
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- (cd $(BUILD_SUBDIR)/[+module+] && $(MAKE) all)
-[+ ENDFOR build_modules +]
+[+ configure prefix="build-" subdir="$(BUILD_SUBDIR)" exports="$(BUILD_EXPORTS)"
+ host_alias=(get "host" "${build_alias}")
+ target_alias=(get "target" "${target_alias}")
+ args="$(BUILD_CONFIGARGS)" no-config-site=true +]
+
+[+ all prefix="build-" subdir="$(BUILD_SUBDIR)" exports="$(BUILD_EXPORTS)"
+ args="$(EXTRA_BUILD_FLAGS)" +]
+[+ ENDFOR build_module +]
# --------------------------------------
# Modules which run on the host machine
# --------------------------------------
[+ FOR host_modules +]
-.PHONY: configure-[+module+] maybe-configure-[+module+]
-maybe-configure-[+module+]:
-configure-[+module+]:
- @test ! -f [+module+]/Makefile || exit 0; \
- [ -d [+module+] ] || mkdir [+module+]; \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- CC="$(CC)"; export CC; \
- CFLAGS="$(CFLAGS)"; export CFLAGS; \
- CXX="$(CXX)"; export CXX; \
- CXXFLAGS="$(CXXFLAGS)"; export CXXFLAGS; \
- if [ z$(build_canonical) != z$(host_canoncial) ] ; then \
- AR="$(AR)"; export AR; \
- AS="$(AS)"; export AS; \
- CC_FOR_BUILD="$(CC_FOR_BUILD)"; export CC_FOR_BUILD; \
- DLLTOOL="$(DLLTOOL)"; export DLLTOOL; \
- LD="$(LD)"; export LD; \
- NM="$(NM)"; export NM; \
- RANLIB="$(RANLIB)"; export RANLIB; \
- WINDRES="$(WINDRES)"; export WINDRES; \
- OBJCOPY="$(OBJCOPY)"; export OBJCOPY; \
- OBJDUMP="$(OBJDUMP)"; export OBJDUMP; \
- fi; \
- echo Configuring in [+module+]; \
- cd [+module+] || exit 1; \
- case $(srcdir) in \
- \.) \
- srcdiroption="--srcdir=."; \
- libsrcdir=".";; \
- /* | [A-Za-z]:[\\/]*) \
- srcdiroption="--srcdir=$(srcdir)/[+module+]"; \
- libsrcdir="$$s/[+module+]";; \
- *) \
- srcdiroption="--srcdir=../$(srcdir)/[+module+]"; \
- libsrcdir="$$s/[+module+]";; \
- esac; \
- $(SHELL) $${libsrcdir}/configure \
- $(HOST_CONFIGARGS) $${srcdiroption} \
- || exit 1
-
-.PHONY: all-[+module+] maybe-all-[+module+]
-maybe-all-[+module+]:
-all-[+module+]: configure-[+module+]
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd [+module+] && $(MAKE) $(FLAGS_TO_PASS)[+
- IF with_x
- +] $(X11_FLAGS_TO_PASS)[+
- ENDIF with_x +] all)
-
+[+ configure prefix="" subdir="$(HOST_SUBDIR)"
+ exports="$(HOST_EXPORTS)"
+ poststage1_exports="$(POSTSTAGE1_HOST_EXPORTS)"
+ host_alias=(get "host" "${host_alias}")
+ target_alias=(get "target" "${target_alias}")
+ args="$(HOST_CONFIGARGS)" +]
+
+[+ all prefix="" subdir="$(HOST_SUBDIR)"
+ exports="$(HOST_EXPORTS)"
+ poststage1_exports="$(POSTSTAGE1_HOST_EXPORTS)"
+ args="$(EXTRA_HOST_FLAGS)"
+ stage1_args="$(STAGE1_FLAGS_TO_PASS)"
+ poststage1_args="$(POSTSTAGE1_FLAGS_TO_PASS)" +]
+
+.PHONY: check-[+module+] maybe-check-[+module+]
+maybe-check-[+module+]:
+@if [+module+]
+maybe-check-[+module+]: check-[+module+]
[+ IF no_check +]
-.PHONY: check-[+module+]
check-[+module+]:
[+ ELIF no_check_cross +]
-.PHONY: check-[+module+]
# This module is only tested in a native toolchain.
check-[+module+]:
- @if [ '$(host_canonical)' = '$(target_canonical)' ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd [+module+] && $(MAKE) $(FLAGS_TO_PASS)[+
- IF with_x
- +] $(X11_FLAGS_TO_PASS)[+
- ENDIF with_x +] check); \
+ @: $(MAKE); $(unstage)
+ @if [ '$(host)' = '$(target)' ] ; then \
+ r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ (cd $(HOST_SUBDIR)/[+module+] && \
+ $(MAKE) $(FLAGS_TO_PASS) [+extra_make_flags+] check); \
fi
[+ ELSE check +]
-.PHONY: check-[+module+]
check-[+module+]:
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd [+module+] && $(MAKE) $(FLAGS_TO_PASS)[+
- IF with_x
- +] $(X11_FLAGS_TO_PASS)[+
- ENDIF with_x +] check)
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ (cd $(HOST_SUBDIR)/[+module+] && \
+ $(MAKE) $(FLAGS_TO_PASS) [+extra_make_flags+] check)
[+ ENDIF no_check +]
+@endif [+module+]
-[+ IF no_install +]
.PHONY: install-[+module+] maybe-install-[+module+]
maybe-install-[+module+]:
+@if [+module+]
+maybe-install-[+module+]: install-[+module+]
+[+ IF no_install +]
install-[+module+]:
[+ ELSE install +]
-.PHONY: install-[+module+] maybe-install-[+module+]
-maybe-install-[+module+]:
install-[+module+]: installdirs
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd [+module+] && $(MAKE) $(FLAGS_TO_PASS)[+
- IF with_x
- +] $(X11_FLAGS_TO_PASS)[+
- ENDIF with_x +] install)
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ (cd $(HOST_SUBDIR)/[+module+] && \
+ $(MAKE) $(FLAGS_TO_PASS) [+extra_make_flags+] install)
[+ ENDIF no_install +]
+@endif [+module+]
+
+.PHONY: install-strip-[+module+] maybe-install-strip-[+module+]
+maybe-install-strip-[+module+]:
+@if [+module+]
+maybe-install-strip-[+module+]: install-strip-[+module+]
+[+ IF no_install +]
+install-strip-[+module+]:
+[+ ELSE install +]
+install-strip-[+module+]: installdirs
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ (cd $(HOST_SUBDIR)/[+module+] && \
+ $(MAKE) $(FLAGS_TO_PASS) [+extra_make_flags+] install-strip)
+[+ ENDIF no_install +]
+@endif [+module+]
+
+# Other targets (info, dvi, pdf, etc.)
+[+ FOR recursive_targets +]
+.PHONY: maybe-[+make_target+]-[+module+] [+make_target+]-[+module+]
+maybe-[+make_target+]-[+module+]:
+@if [+module+]
+maybe-[+make_target+]-[+module+]: [+make_target+]-[+module+]
+[+ IF (match-value? = "missing" (get "make_target") ) +]
+# [+module+] doesn't support [+make_target+].
+[+make_target+]-[+module+]:
+[+ ELSE +]
+[+make_target+]-[+module+]: [+
+ FOR depend +]\
+ [+depend+]-[+module+] [+
+ ENDFOR depend +]
+ @[+ IF bootstrap +][+ ELSE +]: $(MAKE); $(unstage)
+ @[+ ENDIF bootstrap +][ -f ./[+module+]/Makefile ] || exit 0; \
+ r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ for flag in $(EXTRA_HOST_FLAGS) [+extra_make_flags+]; do \
+ eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+ done; \
+ echo "Doing [+make_target+] in [+module+]" ; \
+ (cd $(HOST_SUBDIR)/[+module+] && \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+ "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+ "RANLIB=$${RANLIB}" \
+ "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+ [+make_target+]) \
+ || exit 1
+[+ ENDIF +]
+@endif [+module+]
+[+ ENDFOR recursive_targets +]
[+ ENDFOR host_modules +]
# ---------------------------------------
# Modules which run on the target machine
# ---------------------------------------
[+ FOR target_modules +]
-.PHONY: configure-target-[+module+] maybe-configure-target-[+module+]
-maybe-configure-target-[+module+]:
-
-# There's only one multilib.out. Cleverer subdirs shouldn't need it copied.
-$(TARGET_SUBDIR)/[+module+]/multilib.out: multilib.out
- @[ -d $(TARGET_SUBDIR)/[+module+] ] || \
- mkdir $(TARGET_SUBDIR)/[+module+]; \
- rm -f $(TARGET_SUBDIR)/[+module+]/Makefile || : ; \
- cp multilib.out $(TARGET_SUBDIR)/[+module+]/multilib.out
-
-configure-target-[+module+]: $(TARGET_SUBDIR)/[+module+]/multilib.out
- @test ! -f $(TARGET_SUBDIR)/[+module+]/Makefile || exit 0; \
- [ -d $(TARGET_SUBDIR)/[+module+] ] || \
- mkdir $(TARGET_SUBDIR)/[+module+];\
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- AR="$(AR_FOR_TARGET)"; export AR; \
- AS="$(AS_FOR_TARGET)"; export AS; \
- CC="$(CC_FOR_TARGET)"; export CC; \
- CFLAGS="$(CFLAGS_FOR_TARGET)"; export CFLAGS; \[+
- IF raw_cxx +]
- CXX_FOR_TARGET="$(RAW_CXX_FOR_TARGET)"; export CXX_FOR_TARGET; \
- CXX="$(RAW_CXX_FOR_TARGET)"; export CXX; \[+
- ELSE normal_cxx +]
- CXX="$(CXX_FOR_TARGET)"; export CXX; \[+
- ENDIF raw_cxx +]
- CXXFLAGS="$(CXXFLAGS_FOR_TARGET)"; export CXXFLAGS; \
- GCJ="$(GCJ_FOR_TARGET)"; export GCJ; \
- DLLTOOL="$(DLLTOOL_FOR_TARGET)"; export DLLTOOL; \
- LD="$(LD_FOR_TARGET)"; export LD; \
- LDFLAGS="$(LDFLAGS_FOR_TARGET)"; export LDFLAGS; \
- NM="$(NM_FOR_TARGET)"; export NM; \
- RANLIB="$(RANLIB_FOR_TARGET)"; export RANLIB; \
- WINDRES="$(WINDRES_FOR_TARGET)"; export WINDRES; \
- echo Configuring in $(TARGET_SUBDIR)/[+module+]; \
- cd "$(TARGET_SUBDIR)/[+module+]" || exit 1; \
- case $(srcdir) in \
- /* | [A-Za-z]:[\\/]*) \
- topdir=$(srcdir) ;; \
- *) \
- case "$(TARGET_SUBDIR)" in \
- .) topdir="../$(srcdir)" ;; \
- *) topdir="../../$(srcdir)" ;; \
- esac ;; \
- esac; \
- if [ "$(srcdir)" = "." ] ; then \
- if [ "$(TARGET_SUBDIR)" != "." ] ; then \
- if $(SHELL) $$s/symlink-tree $${topdir}/[+module+] "no-such-file" ; then \
- if [ -f Makefile ]; then \
- if $(MAKE) distclean; then \
- true; \
- else \
- exit 1; \
- fi; \
- else \
- true; \
- fi; \
- else \
- exit 1; \
- fi; \
- else \
- true; \
- fi; \
- srcdiroption="--srcdir=."; \
- libsrcdir="."; \
- else \
- srcdiroption="--srcdir=$${topdir}/[+module+]"; \
- libsrcdir="$$s/[+module+]"; \
- fi; \
- rm -f no-such-file || : ; \
- CONFIG_SITE=no-such-file $(SHELL) $${libsrcdir}/configure \
- $(TARGET_CONFIGARGS) $${srcdiroption} \
- --with-target-subdir="$(TARGET_SUBDIR)" \
- || exit 1
-
-.PHONY: all-target-[+module+] maybe-all-target-[+module+]
-maybe-all-target-[+module+]:
-all-target-[+module+]: configure-target-[+module+]
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd $(TARGET_SUBDIR)/[+module+] && \
- $(MAKE) $(TARGET_FLAGS_TO_PASS) [+
- IF raw_cxx
- +] 'CXX=$$(RAW_CXX_FOR_TARGET)' 'CXX_FOR_TARGET=$$(RAW_CXX_FOR_TARGET)' [+
- ENDIF raw_cxx
- +] all)
+
+[+ IF raw_cxx +]
+[+ configure prefix="target-" subdir="$(TARGET_SUBDIR)"
+ check_multilibs=true
+ exports="$(RAW_CXX_TARGET_EXPORTS)"
+ host_alias=(get "host" "${target_alias}")
+ target_alias=(get "target" "${target_alias}")
+ args="$(TARGET_CONFIGARGS)" no-config-site=true +]
+
+[+ all prefix="target-" subdir="$(TARGET_SUBDIR)"
+ exports="$(RAW_CXX_TARGET_EXPORTS)"
+ args="$(EXTRA_TARGET_FLAGS) 'CXX=$$(RAW_CXX_FOR_TARGET)' 'CXX_FOR_TARGET=$$(RAW_CXX_FOR_TARGET)'" +]
+[+ ELSE +]
+[+ configure prefix="target-" subdir="$(TARGET_SUBDIR)"
+ check_multilibs=true
+ exports="$(NORMAL_TARGET_EXPORTS)"
+ host_alias=(get "host" "${target_alias}")
+ target_alias=(get "target" "${target_alias}")
+ args="$(TARGET_CONFIGARGS)" no-config-site=true +]
+
+[+ all prefix="target-" subdir="$(TARGET_SUBDIR)"
+ exports="$(NORMAL_TARGET_EXPORTS)"
+ args="$(EXTRA_TARGET_FLAGS)" +]
+[+ ENDIF +]
+
+.PHONY: check-target-[+module+] maybe-check-target-[+module+]
+maybe-check-target-[+module+]:
+@if target-[+module+]
+maybe-check-target-[+module+]: check-target-[+module+]
[+ IF no_check +]
# Dummy target for uncheckable module.
-.PHONY: check-target-[+module+]
check-target-[+module+]:
[+ ELSE check +]
-.PHONY: check-target-[+module+]
check-target-[+module+]:
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd $(TARGET_SUBDIR)/[+module+] && \
- $(MAKE) $(TARGET_FLAGS_TO_PASS) [+
- IF raw_cxx
- +] 'CXX=$$(RAW_CXX_FOR_TARGET)' 'CXX_FOR_TARGET=$$(RAW_CXX_FOR_TARGET)' [+
- ENDIF raw_cxx
- +] check)
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \[+
+IF raw_cxx +]
+ $(RAW_CXX_TARGET_EXPORTS) \[+
+ELSE normal_cxx +]
+ $(NORMAL_TARGET_EXPORTS) \[+
+ENDIF raw_cxx +]
+ (cd $(TARGET_SUBDIR)/[+module+] && \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) [+
+ IF raw_cxx
+ +] 'CXX=$$(RAW_CXX_FOR_TARGET)' 'CXX_FOR_TARGET=$$(RAW_CXX_FOR_TARGET)' [+
+ ENDIF raw_cxx
+ +] [+extra_make_flags+] check)
[+ ENDIF no_check +]
-[+ IF no_install +]
+@endif target-[+module+]
+
.PHONY: install-target-[+module+] maybe-install-target-[+module+]
maybe-install-target-[+module+]:
+@if target-[+module+]
+maybe-install-target-[+module+]: install-target-[+module+]
+[+ IF no_install +]
# Dummy target for uninstallable.
install-target-[+module+]:
[+ ELSE install +]
-.PHONY: install-target-[+module+] maybe-install-target-[+module+]
-maybe-install-target-[+module+]:
install-target-[+module+]: installdirs
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd $(TARGET_SUBDIR)/[+module+] && \
- $(MAKE) $(TARGET_FLAGS_TO_PASS) install)
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \[+
+IF raw_cxx +]
+ $(RAW_CXX_TARGET_EXPORTS) \[+
+ELSE normal_cxx +]
+ $(NORMAL_TARGET_EXPORTS) \[+
+ENDIF raw_cxx +]
+ (cd $(TARGET_SUBDIR)/[+module+] && \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) [+extra_make_flags+] install)
[+ ENDIF no_install +]
-[+ ENDFOR target_modules +]
+@endif target-[+module+]
-# ----------
-# GCC module
-# ----------
+.PHONY: install-strip-target-[+module+] maybe-install-strip-target-[+module+]
+maybe-install-strip-target-[+module+]:
+@if target-[+module+]
+maybe-install-strip-target-[+module+]: install-strip-target-[+module+]
+[+ IF no_install +]
+# Dummy target for uninstallable.
+install-strip-target-[+module+]:
+[+ ELSE install +]
+install-strip-target-[+module+]: installdirs
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \[+
+IF raw_cxx +]
+ $(RAW_CXX_TARGET_EXPORTS) \[+
+ELSE normal_cxx +]
+ $(NORMAL_TARGET_EXPORTS) \[+
+ENDIF raw_cxx +]
+ (cd $(TARGET_SUBDIR)/[+module+] && \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) [+extra_make_flags+] install-strip)
+[+ ENDIF no_install +]
+@endif target-[+module+]
-# Unfortunately, while gcc _should_ be a host module,
-# libgcc is a target module, and gen* programs are
-# build modules. So GCC is a sort of hybrid.
-
-# gcc is the only module which uses GCC_FLAGS_TO_PASS.
-.PHONY: configure-gcc maybe-configure-gcc
-maybe-configure-gcc:
-configure-gcc:
- @test ! -f gcc/Makefile || exit 0; \
- [ -d gcc ] || mkdir gcc; \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- CC="$(CC)"; export CC; \
- CFLAGS="$(CFLAGS)"; export CFLAGS; \
- CXX="$(CXX)"; export CXX; \
- CXXFLAGS="$(CXXFLAGS)"; export CXXFLAGS; \
- TOPLEVEL_CONFIGURE_ARGUMENTS="$(TOPLEVEL_CONFIGURE_ARGUMENTS)"; export TOPLEVEL_CONFIGURE_ARGUMENTS; \
- if [ z$(build_canonical) != z$(host_canoncial) ] ; then \
- AR="$(AR)"; export AR; \
- AS="$(AS)"; export AS; \
- CC_FOR_BUILD="$(CC_FOR_BUILD)"; export CC_FOR_BUILD; \
- DLLTOOL="$(DLLTOOL)"; export DLLTOOL; \
- LD="$(LD)"; export LD; \
- NM="$(NM)"; export NM; \
- RANLIB="$(RANLIB)"; export RANLIB; \
- WINDRES="$(WINDRES)"; export WINDRES; \
- OBJCOPY="$(OBJCOPY)"; export OBJCOPY; \
- OBJDUMP="$(OBJDUMP)"; export OBJDUMP; \
- fi; \
- echo Configuring in gcc; \
- cd gcc || exit 1; \
- case $(srcdir) in \
- \.) \
- srcdiroption="--srcdir=."; \
- libsrcdir=".";; \
- /* | [A-Za-z]:[\\/]*) \
- srcdiroption="--srcdir=$(srcdir)/gcc"; \
- libsrcdir="$$s/gcc";; \
- *) \
- srcdiroption="--srcdir=../$(srcdir)/gcc"; \
- libsrcdir="$$s/gcc";; \
- esac; \
- $(SHELL) $${libsrcdir}/configure \
- $(HOST_CONFIGARGS) $${srcdiroption} \
+# Other targets (info, dvi, pdf, etc.)
+[+ FOR recursive_targets +]
+.PHONY: maybe-[+make_target+]-target-[+module+] [+make_target+]-target-[+module+]
+maybe-[+make_target+]-target-[+module+]:
+@if target-[+module+]
+maybe-[+make_target+]-target-[+module+]: [+make_target+]-target-[+module+]
+[+ IF (match-value? = "missing" (get "make_target") ) +]
+# [+module+] doesn't support [+make_target+].
+[+make_target+]-target-[+module+]:
+[+ ELSE +]
+[+make_target+]-target-[+module+]: [+
+ FOR depend +]\
+ [+depend+]-target-[+module+] [+
+ ENDFOR depend +]
+ @: $(MAKE); $(unstage)
+ @[ -f $(TARGET_SUBDIR)/[+module+]/Makefile ] || exit 0 ; \
+ r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \[+
+IF raw_cxx +]
+ $(RAW_CXX_TARGET_EXPORTS) \[+
+ELSE normal_cxx +]
+ $(NORMAL_TARGET_EXPORTS) \[+
+ENDIF raw_cxx +]
+ echo "Doing [+make_target+] in $(TARGET_SUBDIR)/[+module+]" ; \
+ for flag in $(EXTRA_TARGET_FLAGS); do \
+ eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+ done; \
+ (cd $(TARGET_SUBDIR)/[+module+] && \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+ "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+ "RANLIB=$${RANLIB}" \
+ "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+ [+extra_make_flags+] [+make_target+]) \
|| exit 1
+[+ ENDIF +]
+@endif target-[+module+]
+[+ ENDFOR recursive_targets +]
+[+ ENDFOR target_modules +]
-# Don't 'make all' in gcc if it's already been made by 'bootstrap'; that
-# causes trouble. This wart will be fixed eventually by moving
-# the bootstrap behavior to this file.
-.PHONY: all-gcc maybe-all-gcc
-maybe-all-gcc:
-all-gcc: configure-gcc
- @if [ -f gcc/stage_last ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) quickstrap); \
- else \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) all); \
- fi
+@if target-libgomp
+.PHONY: check-target-libgomp-c++
+check-target-libgomp-c++:
+ $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) c++.exp" check-target-libgomp
-# Building GCC uses some tools for rebuilding "source" files
-# like texinfo, bison/byacc, etc. So we must depend on those.
-#
-# While building GCC, it may be necessary to run various target
-# programs like the assembler, linker, etc. So we depend on
-# those too.
-#
-# In theory, on an SMP all those dependencies can be resolved
-# in parallel.
-#
-.PHONY: bootstrap bootstrap-lean bootstrap2 bootstrap2-lean bootstrap3 bootstrap3-lean bootstrap4 bootstrap4-lean bubblestrap quickstrap cleanstrap restrap
-bootstrap bootstrap-lean bootstrap2 bootstrap2-lean bootstrap3 bootstrap3-lean bootstrap4 bootstrap4-lean bubblestrap quickstrap cleanstrap restrap: all-bootstrap configure-gcc
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- echo "Bootstrapping the compiler"; \
- cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) $@
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- case "$@" in \
- *bootstrap4-lean ) \
- msg="Comparing stage3 and stage4 of the compiler"; \
- compare=compare3-lean ;; \
- *bootstrap4 ) msg="Comparing stage3 and stage4 of the compiler"; \
- compare=compare3 ;; \
- *-lean ) msg="Comparing stage2 and stage3 of the compiler"; \
- compare=compare-lean ;; \
- * ) msg="Comparing stage2 and stage3 of the compiler"; \
- compare=compare ;; \
- esac; \
- $(SET_LIB_PATH) \
- echo "$$msg"; \
- cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) $$compare
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}` ; export s; \
- $(SET_LIB_PATH) \
- echo "Building runtime libraries"; \
- $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all
+@endif target-libgomp
+
+@if target-libitm
+.PHONY: check-target-libitm-c++
+check-target-libitm-c++:
+ $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) c++.exp" check-target-libitm
+
+@endif target-libitm
+# ----------
+# GCC module
+# ----------
+
+@if gcc-no-bootstrap
.PHONY: cross
-cross: all-texinfo all-bison all-byacc all-binutils all-gas all-ld
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
+cross: all-build all-gas all-ld
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
echo "Building the C and C++ compiler"; \
cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) LANGUAGES="c c++"
- @r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}` ; export s; \
- $(SET_LIB_PATH) \
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}` ; export s; \
echo "Building runtime libraries"; \
- $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) \
- LANGUAGES="c c++" all
-
-.PHONY: check-gcc
-check-gcc:
- @if [ -f ./gcc/Makefile ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) check); \
- else \
- true; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) LANGUAGES="c c++" all
+@endif gcc-no-bootstrap
+
+@if gcc
+[+ FOR languages +]
+.PHONY: check-gcc-[+language+] check-[+language+]
+check-gcc-[+language+]:
+ r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) [+gcc-check-target+]);
+check-[+language+]: check-gcc-[+language+][+ FOR lib-check-target +] [+ lib-check-target +][+ ENDFOR lib-check-target +]
+[+ ENDFOR languages +]
+
+# The gcc part of install-no-fixedincludes, which relies on an intimate
+# knowledge of how a number of gcc internal targets (inter)operate. Delegate.
+.PHONY: gcc-install-no-fixedincludes
+gcc-install-no-fixedincludes:
+ @if [ -f ./gcc/Makefile ]; then \
+ r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(HOST_EXPORTS) \
+ (cd ./gcc \
+ && $(MAKE) $(GCC_FLAGS_TO_PASS) install-no-fixedincludes); \
+ else true; fi
+@endif gcc
+
+# ---------------------
+# GCC bootstrap support
+# ---------------------
+
+# We track the current stage (the one in 'gcc') in the stage_current file.
+# stage_last instead tracks the stage that was built last. These targets
+# are dummy when toplevel bootstrap is not active.
+
+# While making host and target tools, symlinks to the final stage must be
+# there, so $(unstage) should be run at various points. To avoid excessive
+# recursive invocations of make, we "inline" them using a variable. These
+# must be referenced as ": $(MAKE) ; $(unstage)" rather than "$(unstage)"
+# to avoid warnings from the GNU Make job server.
+
+unstage = :
+stage = :
+current_stage = ""
+
+@if gcc-bootstrap
+unstage = if [ -f stage_last ]; then [ -f stage_current ] || $(MAKE) `cat stage_last`-start || exit 1; else :; fi
+stage = if [ -f stage_current ]; then $(MAKE) `cat stage_current`-end || exit 1; else :; fi
+current_stage = "`cat stage_current 2> /dev/null`"
+@endif gcc-bootstrap
+
+.PHONY: unstage stage
+unstage:
+ @: $(MAKE); $(unstage)
+stage:
+ @: $(MAKE); $(stage)
+
+# Disable commands for lean bootstrap.
+LEAN = false
+
+# We name the build directories for the various stages "stage1-gcc",
+# "stage2-gcc","stage3-gcc", etc.
+
+# Since the 'compare' process will fail (on debugging information) if any
+# directory names are different, we need to link the gcc directory for
+# the previous stage to a constant name ('prev-gcc'), and to make the name of
+# the build directories constant as well. For the latter, we use naked names
+# like 'gcc', because the scripts in that directory assume it. We use
+# mv on platforms where symlinks to directories do not work or are not
+# reliable.
+
+# 'touch' doesn't work right on some platforms.
+STAMP = echo timestamp >
+
+# We only want to compare .o files, so set this!
+objext = .o
+
+[+ FOR bootstrap-stage +]
+.PHONY: stage[+id+]-start stage[+id+]-end
+
+stage[+id+]-start::
+ @: $(MAKE); $(stage); \
+ echo stage[+id+] > stage_current ; \
+ echo stage[+id+] > stage_last; \
+ $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)[+
+ FOR host_modules +][+ IF bootstrap +]
+@if [+ module +]
+ @cd $(HOST_SUBDIR); [ -d stage[+id+]-[+module+] ] || \
+ mkdir stage[+id+]-[+module+]; \
+ mv stage[+id+]-[+module+] [+module+] [+ IF prev +] ; \
+ mv stage[+prev+]-[+module+] prev-[+module+] || test -f stage[+prev+]-lean [+ ENDIF prev +]
+@endif [+ module +][+ ENDIF bootstrap +][+ ENDFOR host_modules +]
+ @[ -d stage[+id+]-$(TARGET_SUBDIR) ] || \
+ mkdir stage[+id+]-$(TARGET_SUBDIR); \
+ mv stage[+id+]-$(TARGET_SUBDIR) $(TARGET_SUBDIR) [+ IF prev +] ; \
+ mv stage[+prev+]-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stage[+prev+]-lean [+ ENDIF prev +]
+
+stage[+id+]-end:: [+ FOR host_modules +][+ IF bootstrap +]
+@if [+ module +]
+ @if test -d $(HOST_SUBDIR)/[+module+] ; then \
+ cd $(HOST_SUBDIR); mv [+module+] stage[+id+]-[+module+] [+ IF prev +]; \
+ mv prev-[+module+] stage[+prev+]-[+module+] ; : [+ ENDIF prev +] ; \
fi
-
-.PHONY: check-gcc-c++
-check-gcc-c++:
- @if [ -f ./gcc/Makefile ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) check-c++); \
- else \
- true; \
+@endif [+ module +][+ ENDIF bootstrap +][+ ENDFOR host_modules +]
+ @if test -d $(TARGET_SUBDIR) ; then \
+ mv $(TARGET_SUBDIR) stage[+id+]-$(TARGET_SUBDIR) [+ IF prev +] ; \
+ mv prev-$(TARGET_SUBDIR) stage[+prev+]-$(TARGET_SUBDIR) ; : [+ ENDIF prev +] ; \
fi
-
-.PHONY: check-c++
-check-c++: check-target-libstdc++-v3 check-gcc-c++
-
-.PHONY: install-gcc maybe-install-gcc
-maybe-install-gcc:
-install-gcc:
- @if [ -f ./gcc/Makefile ] ; then \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}`; export s; \
- $(SET_LIB_PATH) \
- (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) install); \
+ rm -f stage_current
+
+# Bubble a bug fix through all the stages up to stage [+id+]. They are
+# remade, but not reconfigured. The next stage (if any) will not be
+# reconfigured either.
+.PHONY: stage[+id+]-bubble
+stage[+id+]-bubble:: [+ IF prev +]stage[+prev+]-bubble[+ ENDIF +]
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ if test -f stage[+id+]-lean [+
+ IF prev +]|| test -f stage[+prev+]-lean [+ ENDIF prev +] ; then \
+ echo Skipping rebuild of stage[+id+] ; \
else \
- true; \
- fi
+ $(MAKE) stage[+id+]-start; \[+IF lean +]
+ if $(LEAN); then \
+ rm -rf stage[+lean+]-* ; \
+ $(STAMP) stage[+lean+]-lean ; \
+ fi; \[+ ENDIF lean +]
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stage[+id+]; \
+ fi[+ IF compare-target +]
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) [+compare-target+][+ ENDIF compare-target +]
+
+.PHONY: all-stage[+id+] clean-stage[+id+]
+do-clean: clean-stage[+id+]
+
+# FIXME: Will not need to be conditional when toplevel bootstrap is the
+# only possibility, but now it conflicts with no-bootstrap rules
+@if gcc-bootstrap
+[+ IF compare-target +]
+[+compare-target+]:
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ if test -f stage[+prev+]-lean; then \
+ echo Cannot compare object files as stage [+prev+] was deleted. ; \
+ exit 0 ; \
+ fi; \
+ : $(MAKE); $(stage); \
+ rm -f .bad_compare ; \
+ echo Comparing stages [+prev+] and [+id+] ; \
+ sed=`echo stage[+id+] | sed 's,^stage,,;s,.,.,g'`; \
+ files=`find stage[+id+]-* -name "*$(objext)" -print | \
+ sed -n s,^stage$$sed-,,p` ; \
+ for file in $${files} ; do \
+ f1=$$r/stage[+prev+]-$$file; f2=$$r/stage[+id+]-$$file; \
+ if test ! -f $$f1; then continue; fi; \
+ $(do-[+compare-target+]) > /dev/null 2>&1; \
+ if test $$? -eq 1; then \
+ case $$file in \
+ @compare_exclusions@) \
+ echo warning: $$file differs ;; \
+ *) \
+ echo $$file differs >> .bad_compare ;; \
+ esac ; \
+ fi ; \
+ done ; \
+ if [ -f .bad_compare ]; then \
+ echo "Bootstrap comparison failure!"; \
+ cat .bad_compare; \
+ exit 1; \
+ else \
+ echo Comparison successful.; \
+ fi ; \
+ $(STAMP) [+compare-target+][+ IF prev +]
+ if $(LEAN); then \
+ rm -rf stage[+prev+]-*; \
+ $(STAMP) stage[+prev+]-lean; \
+ fi[+ ENDIF prev +]
+[+ ENDIF compare-target +]
+
+[+ IF bootstrap-target +]
+.PHONY: [+bootstrap-target+] [+bootstrap-target+]-lean
+[+bootstrap-target+]:
+ echo stage[+id+] > stage_final
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) stage[+id+]-bubble
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ TFLAGS="$(STAGE[+id+]_TFLAGS)"; \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) all-host all-target
+
+[+bootstrap-target+]-lean:
+ echo stage[+id+] > stage_final
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) LEAN=: stage[+id+]-bubble
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ TFLAGS="$(STAGE[+id+]_TFLAGS)"; \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) all-host all-target
+[+ ENDIF bootstrap-target +]
+
+# Rules to wipe a stage and all the following ones, also used for cleanstrap
+[+ IF prev +]distclean-stage[+prev+]:: distclean-stage[+id+] [+ ENDIF prev +]
+.PHONY: distclean-stage[+id+]
+distclean-stage[+id+]::
+ @: $(MAKE); $(stage)
+ @test "`cat stage_last`" != stage[+id+] || rm -f stage_last
+ rm -rf stage[+id+]-* [+
+ IF compare-target +][+compare-target+] [+ ENDIF compare-target +]
+
+[+ IF cleanstrap-target +]
+.PHONY: [+cleanstrap-target+]
+[+cleanstrap-target+]: do-distclean local-clean
+ echo stage[+id+] > stage_final
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) stage[+id+]-bubble
+ @: $(MAKE); $(unstage)
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ TFLAGS="$(STAGE[+id+]_TFLAGS)"; \
+ $(MAKE) $(TARGET_FLAGS_TO_PASS) all-host all-target
+[+ ENDIF cleanstrap-target +]
+@endif gcc-bootstrap
+
+[+ ENDFOR bootstrap-stage +]
+
+stageprofile-end::
+ $(MAKE) distclean-stagefeedback
+
+stagefeedback-start::
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ for i in prev-*; do \
+ j=`echo $$i | sed s/^prev-//` ; \
+ cd $$r/$$i && \
+ { find . -type d | sort | sed 's,.*,$(SHELL) '"$$s"'/mkinstalldirs "../'$$j'/&",' | $(SHELL) ; } && \
+ { find . -name '*.*da' | sed 's,.*,$(LN) -f "&" "../'$$j'/&",' | $(SHELL) ; } ; \
+ done
-# Install the gcc headers files, but not the fixed include files,
-# which Cygnus is not allowed to distribute. This rule is very
-# dependent on the workings of the gcc Makefile.in.
-.PHONY: gcc-no-fixedincludes
-gcc-no-fixedincludes:
- @if [ -f ./gcc/Makefile ]; then \
- rm -rf gcc/tmp-include; \
- mv gcc/include gcc/tmp-include 2>/dev/null; \
- mkdir gcc/include; \
- cp $(srcdir)/gcc/gsyslimits.h gcc/include/syslimits.h; \
- touch gcc/stmp-fixinc gcc/include/fixed; \
- rm -f gcc/stmp-headers gcc/stmp-int-hdrs; \
- r=`${PWD}`; export r; \
- s=`cd $(srcdir); ${PWD}` ; export s; \
- $(SET_LIB_PATH) \
- (cd ./gcc && \
- $(MAKE) $(GCC_FLAGS_TO_PASS) install); \
- rm -rf gcc/include; \
- mv gcc/tmp-include gcc/include 2>/dev/null; \
- else true; fi
+@if gcc-bootstrap
+do-distclean: distclean-stage1
+
+# Provide a GCC build when we're building target libraries. This does
+# not work as a dependency, just as the minimum necessary to avoid errors.
+stage_last:
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(MAKE) $(RECURSE_FLAGS_TO_PASS) stage1-bubble
+
+# Same as unstage, but not phony and defaulting to stage1-start. We place
+# it in the dependency so that for example `make -j3 all-gcc' works.
+stage_current:
+ @if test -f stage_last; then $(unstage); else $(MAKE) stage1-start; fi
+
+.PHONY: restrap
+restrap::
+ @: $(MAKE); $(stage)
+ rm -rf stage1-$(TARGET_SUBDIR)[+ FOR bootstrap-stage +][+ IF prev
+ +] stage[+id+]-*[+ ENDIF prev +][+ ENDFOR bootstrap-stage +]
+restrap:: all
+@endif gcc-bootstrap
# --------------------------------------
# Dependencies between different modules
# --------------------------------------
+# Generic dependencies for target modules on host stuff, especially gcc
+@if gcc-bootstrap[+ FOR target_modules +][+ IF bootstrap
+ +][+ FOR bootstrap_stage +]
+configure-stage[+id+]-target-[+module+]: maybe-all-stage[+id+]-gcc[+
+ ENDFOR +][+ ELSE bootstrap +]
+configure-target-[+module+]: stage_last[+
+ ENDIF bootstrap +][+ ENDFOR target_modules +]
+@endif gcc-bootstrap
+
+@if gcc-no-bootstrap[+ FOR target_modules +]
+configure-target-[+module+]: maybe-all-gcc[+
+ ENDFOR target_modules +]
+@endif gcc-no-bootstrap
+
+
# There are two types of dependencies here: 'hard' dependencies, where one
# module simply won't build without the other; and 'soft' dependencies, where
# if the depended-on module is missing, the depending module will do without
# or find a substitute somewhere (perhaps installed). Soft dependencies
-# are specified by depending on a 'maybe-' target. If you're not sure,
+# are made here to depend on a 'maybe-' target. If you're not sure,
# it's safer to use a soft dependency.
-# Host modules specific to gcc.
-# GCC needs to identify certain tools.
-configure-gcc: maybe-configure-binutils maybe-configure-gas maybe-configure-ld maybe-configure-bison maybe-configure-flex
-all-gcc: maybe-all-libiberty maybe-all-bison maybe-all-byacc maybe-all-binutils maybe-all-gas maybe-all-ld maybe-all-zlib
-# This is a slightly kludgy method of getting dependencies on
-# all-build-libiberty correct; it would be better to build it every time.
-all-gcc: maybe-all-build-libiberty
-all-bootstrap: maybe-all-libiberty maybe-all-texinfo maybe-all-bison maybe-all-byacc maybe-all-binutils maybe-all-gas maybe-all-ld maybe-all-zlib
-
-# Host modules specific to gdb.
-# GDB needs to know that the simulator is being built.
-configure-gdb: maybe-configure-tcl maybe-configure-tk maybe-configure-sim
+[+ ;; These Scheme functions build the bulk of the dependencies.
+ ;; dep-target builds a string like "maybe-all-MODULE_KIND-gcc",
+ ;; where "maybe-" is only included if HARD is not true, and all-gcc
+ ;; is taken from VAR-NAME.
+ (define dep-target (lambda (module-kind var-name hard)
+ (string-append
+ (if hard "" "maybe-")
+ (dep-subtarget var-name)
+ module-kind
+ (dep-module var-name)
+ )))
+
+ ;; make-dep builds a dependency from the MODULE and ON AutoGen vars.
+ (define make-dep (lambda (module-kind on-kind)
+ (string-append
+ (dep-target module-kind "module" #t) ": "
+ (dep-target on-kind "on" (exist? "hard")))))
+
+ ;; dep-subtarget extracts everything up to the first dash in the given
+ ;; AutoGen variable, for example it extracts "all-" out of "all-gcc".
+ (define dep-subtarget (lambda (var-name)
+ (substring (get var-name) 0 (+ 1 (string-index (get var-name) #\-)))))
+
+ ;; dep-module extracts everything up to the first dash in the given
+ ;; AutoGen variable, for example it extracts "gcc" out of "all-gcc".
+ (define dep-module (lambda (var-name)
+ (substring (get var-name) (+ 1 (string-index (get var-name) #\-)))))
+
+ ;; dep-stage builds a string for the prefix of a bootstrap stage.
+ (define dep-stage (lambda ()
+ (string-append
+ "stage"
+ (get "id")
+ "-")))
+
+ ;; dep-maybe is the same as the AutoGen expression "- hard 'maybe-'"
+ ;; but is written in Scheme.
+ (define dep-maybe (lambda ()
+ (if (exist? "hard") "" "maybe-")))
+
+ ;; dep-kind returns "normal" if the dependency is on an "install" target,
+ ;; or if either module is not bootstrapped. It returns "bootstrap" for
+ ;; configure or build dependencies between bootstrapped modules; it returns
+ ;; "prebootstrap" for configure or build dependencies of bootstrapped
+ ;; modules on a build module (e.g. all-gcc on all-build-bison). All this
+ ;; is only necessary for host modules.
+ (define dep-kind (lambda ()
+ (if (and (hash-ref boot-modules (dep-module "module"))
+ (=* (dep-module "on") "build-"))
+ "prebootstrap"
+
+ (if (or (= (dep-subtarget "on") "install-")
+ (not (hash-ref boot-modules (dep-module "module")))
+ (not (hash-ref boot-modules (dep-module "on"))))
+ "normal"
+ "bootstrap"))))
+
+ ;; We now build the hash table that is used by dep-kind.
+ (define boot-modules (make-hash-table 113))
++]
+
+[+ FOR host_modules +][+
+ (if (exist? "bootstrap")
+ (hash-create-handle! boot-modules (get "module") #t))
+ "" +][+ ENDFOR host_modules +]
+[+ FOR target_modules +][+
+ (if (exist? "bootstrap")
+ (hash-create-handle! boot-modules (string-append "target-" (get "module")) #t))
+ "" +][+ ENDFOR target_modules +]
+
+# With all the machinery above in place, it is pretty easy to generate
+# dependencies. Host dependencies are a bit more complex because we have
+# to check for bootstrap/prebootstrap dependencies. To resolve
+# prebootstrap dependencies, prebootstrap modules are gathered in
+# a hash table.
+[+ FOR dependencies +][+ (make-dep "" "") +]
+[+ CASE (dep-kind) +]
+[+ == "prebootstrap"
+ +][+ FOR bootstrap_stage +]
+[+ (make-dep (dep-stage) "") +][+
+ ENDFOR bootstrap_stage +]
+[+ == "bootstrap"
+ +][+ FOR bootstrap_stage +]
+[+ (make-dep (dep-stage) (dep-stage)) +][+
+ ENDFOR bootstrap_stage +]
+[+ ESAC +][+
+ENDFOR dependencies +]
+
+# Dependencies for target modules on other target modules are
+# described by lang_env_dependencies; the defaults apply to anything
+# not mentioned there.
+[+
+ ;; Predicate for whether LANG was specified in lang_env_dependencies.
+ (define lang-dep (lambda (lang)
+ (hash-ref lang-env-deps (string-append (get "module") "-" lang))))
+
+ ;; Build the hash table we will need.
+ (define lang-env-deps (make-hash-table 7))
++][+ FOR lang_env_dependencies +][+
+ (if (exist? "cxx")
+ (hash-create-handle! lang-env-deps
+ (string-append (get "module") "-" "cxx") #t))
+
+ (if (exist? "no_c")
+ (hash-create-handle! lang-env-deps
+ (string-append (get "module") "-" "no_c") #t))
+
+ (if (exist? "no_gcc")
+ (hash-create-handle! lang-env-deps
+ (string-append (get "module") "-" "no_gcc") #t))
+ "" +][+ ENDFOR lang_env_dependencies +]
+
+@if gcc-bootstrap[+ FOR target_modules +][+ IF (not (lang-dep "no_gcc"))
+ +][+ IF bootstrap +][+ FOR bootstrap_stage +]
+configure-stage[+id+]-target-[+module+]: maybe-all-stage[+id+]-target-libgcc[+
+ ENDFOR +][+ ENDIF bootstrap +][+ ENDIF +][+ ENDFOR target_modules +]
+@endif gcc-bootstrap
+
+@if gcc-no-bootstrap[+ FOR target_modules +][+ IF (not (lang-dep "no_gcc")) +]
+configure-target-[+module+]: maybe-all-target-libgcc[+
+ ENDIF +][+ ENDFOR target_modules +]
+@endif gcc-no-bootstrap
+
+[+ FOR target_modules +][+ IF (not (lang-dep "no_c")) +]
+configure-target-[+module+]: maybe-all-target-newlib maybe-all-target-libgloss[+
+ ENDIF +][+ IF (lang-dep "cxx") +]
+configure-target-[+module+]: maybe-all-target-libstdc++-v3[+
+ ENDIF +]
+[+ ENDFOR target_modules +]
+
+CONFIGURE_GDB_TK = @CONFIGURE_GDB_TK@
GDB_TK = @GDB_TK@
-all-gdb: maybe-all-libiberty maybe-all-opcodes maybe-all-bfd maybe-all-mmalloc maybe-all-readline maybe-all-bison maybe-all-byacc maybe-all-sim $(gdbnlmrequirements) $(GDB_TK)
-install-gdb: maybe-install-tcl maybe-install-tk maybe-install-itcl maybe-install-tix maybe-install-libgui
-configure-libgui: maybe-configure-tcl maybe-configure-tk
-all-libgui: maybe-all-tcl maybe-all-tk maybe-all-itcl
-
-# Host modules specific to binutils.
-configure-bfd: configure-libiberty
-all-bfd: maybe-all-libiberty maybe-all-intl
-all-binutils: maybe-all-libiberty maybe-all-opcodes maybe-all-bfd maybe-all-flex maybe-all-bison maybe-all-byacc maybe-all-intl
-# We put install-opcodes before install-binutils because the installed
-# binutils might be on PATH, and they might need the shared opcodes
-# library.
-install-binutils: maybe-install-opcodes
-all-gas: maybe-all-libiberty maybe-all-opcodes maybe-all-bfd maybe-all-intl
-all-gprof: maybe-all-libiberty maybe-all-bfd maybe-all-opcodes maybe-all-intl
-all-ld: maybe-all-libiberty maybe-all-bfd maybe-all-opcodes maybe-all-bison maybe-all-byacc maybe-all-flex maybe-all-intl
-all-opcodes: maybe-all-bfd maybe-all-libiberty
-
-# Other host modules in the 'src' repository.
-all-dejagnu: maybe-all-tcl maybe-all-expect maybe-all-tk
-configure-expect: maybe-configure-tcl maybe-configure-tk
-all-expect: maybe-all-tcl maybe-all-tk
-configure-itcl: maybe-configure-tcl maybe-configure-tk
-all-itcl: maybe-all-tcl maybe-all-tk
-# We put install-tcl before install-itcl because itcl wants to run a
-# program on installation which uses the Tcl libraries.
-install-itcl: maybe-install-tcl
-all-sid: maybe-all-libiberty maybe-all-bfd maybe-all-opcodes maybe-all-tcl maybe-all-tk
-install-sid: maybe-install-tcl maybe-install-tk
-all-sim: maybe-all-libiberty maybe-all-bfd maybe-all-opcodes maybe-all-readline maybe-configure-gdb
-configure-tk: maybe-configure-tcl
-all-tk: maybe-all-tcl
-configure-tix: maybe-configure-tcl maybe-configure-tk
-all-tix: maybe-all-tcl maybe-all-tk
-all-texinfo: maybe-all-libiberty
-
-# Other host modules. Warning, these are not well tested.
-all-autoconf: maybe-all-m4 maybe-all-texinfo
-all-automake: maybe-all-m4 maybe-all-texinfo
-all-bison: maybe-all-texinfo
-all-diff: maybe-all-libiberty
-all-fastjar: maybe-all-zlib maybe-all-libiberty
-all-fileutils: maybe-all-libiberty
-all-flex: maybe-all-libiberty maybe-all-bison maybe-all-byacc
-all-grep: maybe-all-libiberty
-all-gzip: maybe-all-libiberty
-all-hello: maybe-all-libiberty
-all-m4: maybe-all-libiberty maybe-all-texinfo
-all-make: maybe-all-libiberty
-all-patch: maybe-all-libiberty
-all-prms: maybe-all-libiberty
-all-recode: maybe-all-libiberty
-all-sed: maybe-all-libiberty
-all-send-pr: maybe-all-prms
-all-snavigator: maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-tix maybe-all-db maybe-all-grep maybe-all-libgui
-all-tar: maybe-all-libiberty
-all-uudecode: maybe-all-libiberty
-
-ALL_GCC = maybe-all-gcc
-ALL_GCC_C = $(ALL_GCC) maybe-all-target-newlib maybe-all-target-libgloss
-ALL_GCC_CXX = $(ALL_GCC_C) maybe-all-target-libstdc++-v3
-
-# Target modules specific to gcc.
-configure-target-boehm-gc: $(ALL_GCC_C) maybe-configure-target-qthreads
-configure-target-fastjar: maybe-configure-target-zlib
-all-target-fastjar: maybe-all-target-zlib maybe-all-target-libiberty
-configure-target-libf2c: $(ALL_GCC_C)
-all-target-libf2c: maybe-all-target-libiberty
-configure-target-libffi: $(ALL_GCC_C)
-configure-target-libjava: $(ALL_GCC_C) maybe-configure-target-zlib maybe-configure-target-boehm-gc maybe-configure-target-qthreads maybe-configure-target-libffi
-all-target-libjava: maybe-all-fastjar maybe-all-target-zlib maybe-all-target-boehm-gc maybe-all-target-qthreads maybe-all-target-libffi
-configure-target-libobjc: $(ALL_GCC_C)
-all-target-libobjc: maybe-all-target-libiberty
-configure-target-libstdc++-v3: $(ALL_GCC_C)
-all-target-libstdc++-v3: maybe-all-target-libiberty
-configure-target-zlib: $(ALL_GCC_C)
-
-# Target modules in the 'src' repository.
-configure-target-examples: $(ALL_GCC_C)
-configure-target-libgloss: $(ALL_GCC)
-all-target-libgloss: maybe-configure-target-newlib
-configure-target-libiberty: $(ALL_GCC_C)
-configure-target-libtermcap: $(ALL_GCC_C)
-configure-target-newlib: $(ALL_GCC)
-configure-target-rda: $(ALL_GCC_C)
-configure-target-winsup: $(ALL_GCC_C)
-all-target-winsup: maybe-all-target-libiberty maybe-all-target-libtermcap
-
-# Other target modules. Warning, these are not well tested.
-configure-target-gperf: $(ALL_GCC_CXX)
-all-target-gperf: maybe-all-target-libiberty maybe-all-target-libstdc++-v3
-configure-target-qthreads: $(ALL_GCC_C)
-
-# Dependencies of maybe-foo on foo. These are used because, for example,
-# all-gcc only depends on all-gas if gas is present and being configured.
-@maybe_dependencies@
+INSTALL_GDB_TK = @INSTALL_GDB_TK@
+configure-gdb: $(CONFIGURE_GDB_TK)
+all-gdb: $(gdbnlmrequirements) $(GDB_TK)
+install-gdb: $(INSTALL_GDB_TK)
# Serialization dependencies. Host configures don't work well in parallel to
# each other, due to contention over config.cache. Target configures and
# Regenerating top level configury
# --------------------------------
-# Multilib.out tells target dirs what multilibs they should build.
-# There is really only one copy. We use the 'timestamp' method to
-# work around various timestamp bugs on some systems.
-# We use move-if-change so that it's only considered updated when it
-# actually changes, because it has to depend on a phony target.
-multilib.out: maybe-all-gcc
- @r=`${PWD}`; export r; \
- echo "Checking multilib configuration..."; \
- $(CC_FOR_TARGET) --print-multi-lib > multilib.tmp 2> /dev/null ; \
- $(SHELL) $(srcdir)/move-if-change multilib.tmp multilib.out ; \
-
# Rebuilding Makefile.in, using autogen.
AUTOGEN = autogen
-$(srcdir)/Makefile.in: # $(srcdir)/Makefile.tpl $(srcdir)/Makefile.def
+$(srcdir)/Makefile.in: @MAINT@ $(srcdir)/Makefile.tpl $(srcdir)/Makefile.def
cd $(srcdir) && $(AUTOGEN) Makefile.def
# Rebuilding Makefile.
Makefile: $(srcdir)/Makefile.in config.status
CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
-config.status: configure $(gcc_version_trigger)
- $(SHELL) ./config.status --recheck
+config.status: configure
+ CONFIG_SHELL="$(SHELL)" $(SHELL) ./config.status --recheck
# Rebuilding configure.
AUTOCONF = autoconf
-$(srcdir)/configure: $(srcdir)/configure.in $(srcdir)/config/acx.m4
+$(srcdir)/configure: @MAINT@ $(srcdir)/configure.ac $(srcdir)/config/acx.m4 \
+ $(srcdir)/config/override.m4 $(srcdir)/config/proginstall.m4
cd $(srcdir) && $(AUTOCONF)
-#
+# ------------------------------
+# Special directives to GNU Make
+# ------------------------------
+
+# Don't pass command-line variables to submakes.
.NOEXPORT:
MAKEOVERRIDES=
-# Tell GNU make 3.79 not to run the top level in parallel. This
-# prevents contention for $builddir/$target/config.cache, as well
-# as minimizing scatter in file system caches.
-NOTPARALLEL = .NOTPARALLEL
-$(NOTPARALLEL):
-
# end of Makefile.in