sdcc/support/cpp/Makefile.in

   1
   2 # Makefile.in is generated from Makefile.tpl by 'autogen Makefile.def'.
   3 #
   4 # Makefile for directory with subdirs to build.
   5 #   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   6 #   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   7 #   Free Software Foundation
   8 #
   9 # This file is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 3 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # This program is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with this program; see the file COPYING3.  If not see
  21 # <http://www.gnu.org/licenses/>.
  22 #
  23
  24 # First, test for a proper version of make, but only where one is required.
  25
  26 ifeq (,$(.VARIABLES)) # The variable .VARIABLES, new with 3.80, is never empty.
  27 $(error GNU make version 3.80 or newer is required.)
  28 endif
  29
  30 # -------------------------------
  31 # Standard Autoconf-set variables
  32 # -------------------------------
  33 VPATH=@srcdir@
  34
  35 build_alias=@build_noncanonical@
  36 build_vendor=@build_vendor@
  37 build_os=@build_os@
  38 build=@build@
  39 host_alias=@host_noncanonical@
  40 host_vendor=@host_vendor@
  41 host_os=@host_os@
  42 host=@host@
  43 target_alias=@target_noncanonical@
  44 target_vendor=@target_vendor@
  45 target_os=@target_os@
  46 target=@target@
  47
  48 program_transform_name = @program_transform_name@
  49
  50 prefix = @prefix@
  51 exec_prefix = @exec_prefix@
  52
  53 srcdir = @srcdir@
  54
  55 bindir = @bindir@
  56 sbindir = @sbindir@
  57 libexecdir = @libexecdir@
  58 datadir = @datadir@
  59 sysconfdir = @sysconfdir@
  60 sharedstatedir = @sharedstatedir@
  61 localstatedir = @localstatedir@
  62 libdir = @libdir@
  63 includedir = @includedir@
  64 oldincludedir = @oldincludedir@
  65 infodir = @infodir@
  66 datarootdir = @datarootdir@
  67 docdir = @docdir@
  68 pdfdir = @pdfdir@
  69 htmldir = @htmldir@
  70 mandir = @mandir@
  71 man1dir = $(mandir)/man1
  72 man2dir = $(mandir)/man2
  73 man3dir = $(mandir)/man3
  74 man4dir = $(mandir)/man4
  75 man5dir = $(mandir)/man5
  76 man6dir = $(mandir)/man6
  77 man7dir = $(mandir)/man7
  78 man8dir = $(mandir)/man8
  79 man9dir = $(mandir)/man9
  80
  81 INSTALL = @INSTALL@
  82 INSTALL_PROGRAM = @INSTALL_PROGRAM@
  83 INSTALL_SCRIPT = @INSTALL_SCRIPT@
  84 INSTALL_DATA = @INSTALL_DATA@
  85 LN = @LN@
  86 LN_S = @LN_S@
  87 MAINT = @MAINT@
  88 MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
  89 MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
  90
  91 # -------------------------------------------------
  92 # Miscellaneous non-standard autoconf-set variables
  93 # -------------------------------------------------
  94
  95 # The gcc driver likes to know the arguments it was configured with.
  96 TOPLEVEL_CONFIGURE_ARGUMENTS=@TOPLEVEL_CONFIGURE_ARGUMENTS@
  97
  98 tooldir = @tooldir@
  99 build_tooldir = @build_tooldir@
 100
 101 # This is the name of the environment variable used for the path to
 102 # the libraries.
 103 RPATH_ENVVAR = @RPATH_ENVVAR@
 104
 105 # On targets where RPATH_ENVVAR is PATH, a subdirectory of the GCC build path
 106 # is used instead of the directory itself to avoid including built
 107 # executables in PATH.
 108 GCC_SHLIB_SUBDIR = @GCC_SHLIB_SUBDIR@
 109
 110 # If the build should make suitable code for shared host resources.
 111 host_shared = @host_shared@
 112
 113 # Build programs are put under this directory.
 114 BUILD_SUBDIR = @build_subdir@
 115 # This is set by the configure script to the arguments to use when configuring
 116 # directories built for the build system.
 117 BUILD_CONFIGARGS = @build_configargs@ --with-build-subdir="$(BUILD_SUBDIR)"
 118
 119 # Linker flags to use on the host, for stage1 or when not
 120 # bootstrapping.
 121 STAGE1_LDFLAGS = @stage1_ldflags@
 122
 123 # Libraries to use on the host, for stage1 or when not bootstrapping.
 124 STAGE1_LIBS = @stage1_libs@
 125
 126 # Linker flags to use for stage2 and later.
 127 POSTSTAGE1_LDFLAGS = @poststage1_ldflags@
 128
 129 # Libraries to use for stage2 and later.
 130 POSTSTAGE1_LIBS = @poststage1_libs@
 131
 132 # This is the list of variables to export in the environment when
 133 # configuring any subdirectory.  It must also be exported whenever
 134 # recursing into a build directory in case that directory's Makefile
 135 # re-runs configure.
 136 BASE_EXPORTS = \
 137         FLEX="$(FLEX)"; export FLEX; \
 138         LEX="$(LEX)"; export LEX; \
 139         BISON="$(BISON)"; export BISON; \
 140         YACC="$(YACC)"; export YACC; \
 141         M4="$(M4)"; export M4; \
 142         SED="$(SED)"; export SED; \
 143         AWK="$(AWK)"; export AWK; \
 144         MAKEINFO="$(MAKEINFO)"; export MAKEINFO;
 145
 146 # This is the list of variables to export in the environment when
 147 # configuring subdirectories for the build system.
 148 BUILD_EXPORTS = \
 149         $(BASE_EXPORTS) \
 150         AR="$(AR_FOR_BUILD)"; export AR; \
 151         AS="$(AS_FOR_BUILD)"; export AS; \
 152         CC="$(CC_FOR_BUILD)"; export CC; \
 153         CFLAGS="$(CFLAGS_FOR_BUILD)"; export CFLAGS; \
 154         CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
 155         CPP="$(CPP_FOR_BUILD)"; export CPP; \
 156         CPPFLAGS="$(CPPFLAGS_FOR_BUILD)"; export CPPFLAGS; \
 157         CXX="$(CXX_FOR_BUILD)"; export CXX; \
 158         CXXFLAGS="$(CXXFLAGS_FOR_BUILD)"; export CXXFLAGS; \
 159         GFORTRAN="$(GFORTRAN_FOR_BUILD)"; export GFORTRAN; \
 160         GOC="$(GOC_FOR_BUILD)"; export GOC; \
 161         GOCFLAGS="$(GOCFLAGS_FOR_BUILD)"; export GOCFLAGS; \
 162         GDC="$(GDC_FOR_BUILD)"; export GDC; \
 163         GDCFLAGS="$(GDCFLAGS_FOR_BUILD)"; export GDCFLAGS; \
 164         DLLTOOL="$(DLLTOOL_FOR_BUILD)"; export DLLTOOL; \
 165         DSYMUTIL="$(DSYMUTIL_FOR_BUILD)"; export DSYMUTIL; \
 166         LD="$(LD_FOR_BUILD)"; export LD; \
 167         LDFLAGS="$(LDFLAGS_FOR_BUILD)"; export LDFLAGS; \
 168         NM="$(NM_FOR_BUILD)"; export NM; \
 169         RANLIB="$(RANLIB_FOR_BUILD)"; export RANLIB; \
 170         WINDRES="$(WINDRES_FOR_BUILD)"; export WINDRES; \
 171         WINDMC="$(WINDMC_FOR_BUILD)"; export WINDMC;
 172
 173 # These variables must be set on the make command line for directories
 174 # built for the build system to override those in BASE_FLAGS_TO_PASS.
 175 EXTRA_BUILD_FLAGS = \
 176         CFLAGS="$(CFLAGS_FOR_BUILD)" \
 177         LDFLAGS="$(LDFLAGS_FOR_BUILD)"
 178
 179 # This is the list of directories to built for the host system.
 180 SUBDIRS = @configdirs@
 181 TARGET_CONFIGDIRS = @target_configdirs@
 182 # This is set by the configure script to the arguments to use when configuring
 183 # directories built for the host system.
 184 HOST_CONFIGARGS = @host_configargs@
 185 # Host programs are put under this directory, which is . except if building
 186 # with srcdir=..
 187 HOST_SUBDIR = @host_subdir@
 188 # This is the list of variables to export in the environment when
 189 # configuring subdirectories for the host system.  We need to pass
 190 # some to the GCC configure because of its hybrid host/target nature.
 191 HOST_EXPORTS = \
 192         $(BASE_EXPORTS) \
 193         CC="$(CC)"; export CC; \
 194         ADA_CFLAGS="$(ADA_CFLAGS)"; export ADA_CFLAGS; \
 195         CFLAGS="$(CFLAGS)"; export CFLAGS; \
 196         CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
 197         CXX="$(CXX)"; export CXX; \
 198         CXXFLAGS="$(CXXFLAGS)"; export CXXFLAGS; \
 199         GFORTRAN="$(GFORTRAN)"; export GFORTRAN; \
 200         GOC="$(GOC)"; export GOC; \
 201         GDC="$(GDC)"; export GDC; \
 202         AR="$(AR)"; export AR; \
 203         AS="$(AS)"; export AS; \
 204         CC_FOR_BUILD="$(CC_FOR_BUILD)"; export CC_FOR_BUILD; \
 205         CPP_FOR_BUILD="$(CPP_FOR_BUILD)"; export CPP_FOR_BUILD; \
 206         CPPFLAGS_FOR_BUILD="$(CPPFLAGS_FOR_BUILD)"; export CPPFLAGS_FOR_BUILD; \
 207         CXX_FOR_BUILD="$(CXX_FOR_BUILD)"; export CXX_FOR_BUILD; \
 208         DLLTOOL="$(DLLTOOL)"; export DLLTOOL; \
 209         DSYMUTIL="$(DSYMUTIL)"; export DSYMUTIL; \
 210         LD="$(LD)"; export LD; \
 211         LDFLAGS="$(STAGE1_LDFLAGS) $(LDFLAGS)"; export LDFLAGS; \
 212         NM="$(NM)"; export NM; \
 213         RANLIB="$(RANLIB)"; export RANLIB; \
 214         WINDRES="$(WINDRES)"; export WINDRES; \
 215         WINDMC="$(WINDMC)"; export WINDMC; \
 216         OBJCOPY="$(OBJCOPY)"; export OBJCOPY; \
 217         OBJDUMP="$(OBJDUMP)"; export OBJDUMP; \
 218         OTOOL="$(OTOOL)"; export OTOOL; \
 219         READELF="$(READELF)"; export READELF; \
 220         AR_FOR_TARGET="$(AR_FOR_TARGET)"; export AR_FOR_TARGET; \
 221         AS_FOR_TARGET="$(AS_FOR_TARGET)"; export AS_FOR_TARGET; \
 222         DSYMUTIL_FOR_TARGET="$(DSYMUTIL_FOR_TARGET)"; export DSYMUTIL_FOR_TARGET; \
 223         GCC_FOR_TARGET="$(GCC_FOR_TARGET)"; export GCC_FOR_TARGET; \
 224         LD_FOR_TARGET="$(LD_FOR_TARGET)"; export LD_FOR_TARGET; \
 225         NM_FOR_TARGET="$(NM_FOR_TARGET)"; export NM_FOR_TARGET; \
 226         OBJDUMP_FOR_TARGET="$(OBJDUMP_FOR_TARGET)"; export OBJDUMP_FOR_TARGET; \
 227         OBJCOPY_FOR_TARGET="$(OBJCOPY_FOR_TARGET)"; export OBJCOPY_FOR_TARGET; \
 228         OTOOL_FOR_TARGET="$(OTOOL_FOR_TARGET)"; export OTOOL_FOR_TARGET; \
 229         RANLIB_FOR_TARGET="$(RANLIB_FOR_TARGET)"; export RANLIB_FOR_TARGET; \
 230         READELF_FOR_TARGET="$(READELF_FOR_TARGET)"; export READELF_FOR_TARGET; \
 231         TOPLEVEL_CONFIGURE_ARGUMENTS="$(TOPLEVEL_CONFIGURE_ARGUMENTS)"; export TOPLEVEL_CONFIGURE_ARGUMENTS; \
 232         HOST_LIBS="$(STAGE1_LIBS)"; export HOST_LIBS; \
 233         GMPLIBS="$(HOST_GMPLIBS)"; export GMPLIBS; \
 234         GMPINC="$(HOST_GMPINC)"; export GMPINC; \
 235         ISLLIBS="$(HOST_ISLLIBS)"; export ISLLIBS; \
 236         ISLINC="$(HOST_ISLINC)"; export ISLINC; \
 237         LIBELFLIBS="$(HOST_LIBELFLIBS)"; export LIBELFLIBS; \
 238         LIBELFINC="$(HOST_LIBELFINC)"; export LIBELFINC; \
 239         XGCC_FLAGS_FOR_TARGET="$(XGCC_FLAGS_FOR_TARGET)"; export XGCC_FLAGS_FOR_TARGET; \
 240         $(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR);
 241
 242 POSTSTAGE1_CXX_EXPORT = \
 243         CXX='$(CXX)'; export CXX; \
 244         CXX_FOR_BUILD='$(CXX_FOR_BUILD)'; export CXX_FOR_BUILD;
 245
 246 # Similar, for later GCC stages.
 247 POSTSTAGE1_HOST_EXPORTS = \
 248         $(HOST_EXPORTS) \
 249         CC="$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/prev-gcc/xgcc$(exeext) \
 250           -B$$r/$(HOST_SUBDIR)/prev-gcc/ -B$(build_tooldir)/bin/ \
 251           $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \
 252         CC_FOR_BUILD="$$CC"; export CC_FOR_BUILD; \
 253         $(POSTSTAGE1_CXX_EXPORT) \
 254         $(LTO_EXPORTS) \
 255         GDC="$$r/$(HOST_SUBDIR)/prev-gcc/gdc$(exeext) -B$$r/$(HOST_SUBDIR)/prev-gcc/ \
 256           -B$(build_tooldir)/bin/ $(GDCFLAGS_FOR_TARGET) \
 257           -B$$r/prev-$(TARGET_SUBDIR)/libphobos/libdruntime/gcc \
 258           -B$$r/prev-$(TARGET_SUBDIR)/libphobos/src \
 259           -B$$r/prev-$(TARGET_SUBDIR)/libphobos/src/.libs \
 260           -I$$r/prev-$(TARGET_SUBDIR)/libphobos/libdruntime -I$$s/libphobos/libdruntime \
 261           -L$$r/prev-$(TARGET_SUBDIR)/libphobos/src/.libs \
 262           -B$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \
 263           -L$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/src/.libs"; \
 264         export GDC; \
 265         GDC_FOR_BUILD="$$GDC"; export GDC_FOR_BUILD; \
 266         GNATBIND="$$r/$(HOST_SUBDIR)/prev-gcc/gnatbind"; export GNATBIND; \
 267         LDFLAGS="$(POSTSTAGE1_LDFLAGS) $(BOOT_LDFLAGS)"; export LDFLAGS; \
 268         HOST_LIBS="$(POSTSTAGE1_LIBS)"; export HOST_LIBS;
 269
 270 # Target libraries are put under this directory:
 271 TARGET_SUBDIR = @target_subdir@
 272 # This is set by the configure script to the arguments to use when configuring
 273 # directories built for the target.
 274 TARGET_CONFIGARGS = @target_configargs@ --with-target-subdir="$(TARGET_SUBDIR)"
 275 # This is the list of variables to export in the environment when
 276 # configuring subdirectories for the target system.
 277 BASE_TARGET_EXPORTS = \
 278         $(BASE_EXPORTS) \
 279         AR="$(AR_FOR_TARGET)"; export AR; \
 280         AS="$(COMPILER_AS_FOR_TARGET)"; export AS; \
 281         CC="$(CC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \
 282         CFLAGS="$(CFLAGS_FOR_TARGET)"; export CFLAGS; \
 283         CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
 284         CPPFLAGS="$(CPPFLAGS_FOR_TARGET)"; export CPPFLAGS; \
 285         CXXFLAGS="$(CXXFLAGS_FOR_TARGET)"; export CXXFLAGS; \
 286         GFORTRAN="$(GFORTRAN_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GFORTRAN; \
 287         GOC="$(GOC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GOC; \
 288         GDC="$(GDC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GDC; \
 289         DLLTOOL="$(DLLTOOL_FOR_TARGET)"; export DLLTOOL; \
 290         DSYMUTIL="$(DSYMUTIL_FOR_TARGET)"; export DSYMUTIL; \
 291         LD="$(COMPILER_LD_FOR_TARGET)"; export LD; \
 292         LDFLAGS="$(LDFLAGS_FOR_TARGET)"; export LDFLAGS; \
 293         LIPO="$(LIPO_FOR_TARGET)"; export LIPO; \
 294         NM="$(COMPILER_NM_FOR_TARGET)"; export NM; \
 295         OBJDUMP="$(OBJDUMP_FOR_TARGET)"; export OBJDUMP; \
 296         OBJCOPY="$(OBJCOPY_FOR_TARGET)"; export OBJCOPY; \
 297         OTOOL="$(OTOOL_FOR_TARGET)"; export OTOOL; \
 298         RANLIB="$(RANLIB_FOR_TARGET)"; export RANLIB; \
 299         READELF="$(READELF_FOR_TARGET)"; export READELF; \
 300         STRIP="$(STRIP_FOR_TARGET)"; export STRIP; \
 301         WINDRES="$(WINDRES_FOR_TARGET)"; export WINDRES; \
 302         WINDMC="$(WINDMC_FOR_TARGET)"; export WINDMC; \
 303         $(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \
 304         TARGET_CONFIGDIRS="$(TARGET_CONFIGDIRS)"; export TARGET_CONFIGDIRS;
 305
 306 RAW_CXX_TARGET_EXPORTS = \
 307         $(BASE_TARGET_EXPORTS) \
 308         CXX_FOR_TARGET="$(RAW_CXX_FOR_TARGET)"; export CXX_FOR_TARGET; \
 309         CXX="$(RAW_CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;
 310
 311 NORMAL_TARGET_EXPORTS = \
 312         $(BASE_TARGET_EXPORTS) \
 313         CXX="$(CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;
 314
 315 # Where to find GMP
 316 HOST_GMPLIBS = # @gmplibs@
 317 HOST_GMPINC = @gmpinc@
 318
 319 # Where to find isl
 320 HOST_ISLLIBS = @isllibs@
 321 HOST_ISLINC = @islinc@
 322
 323 # Where to find libelf
 324 HOST_LIBELFLIBS = @libelflibs@
 325 HOST_LIBELFINC = @libelfinc@
 326
 327 # ----------------------------------------------
 328 # Programs producing files for the BUILD machine
 329 # ----------------------------------------------
 330
 331 SHELL = @SHELL@
 332
 333 # pwd command to use.  Allow user to override default by setting PWDCMD in
 334 # the environment to account for automounters.  The make variable must not
 335 # be called PWDCMD, otherwise the value set here is passed to make
 336 # subprocesses and overrides the setting from the user's environment.
 337 # Don't use PWD since it is a common shell environment variable and we
 338 # don't want to corrupt it.
 339 PWD_COMMAND = $${PWDCMD-pwd}
 340
 341 # compilers to use to create programs which must be run in the build
 342 # environment.
 343 AR_FOR_BUILD = @AR_FOR_BUILD@
 344 AS_FOR_BUILD = @AS_FOR_BUILD@
 345 CC_FOR_BUILD = @CC_FOR_BUILD@
 346 CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
 347 CPP_FOR_BUILD = @CPP_FOR_BUILD@
 348 CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@
 349 CXXFLAGS_FOR_BUILD = @CXXFLAGS_FOR_BUILD@
 350 CXX_FOR_BUILD = @CXX_FOR_BUILD@
 351 DLLTOOL_FOR_BUILD = @DLLTOOL_FOR_BUILD@
 352 DSYMUTIL_FOR_BUILD = @DSYMUTIL_FOR_BUILD@
 353 GFORTRAN_FOR_BUILD = @GFORTRAN_FOR_BUILD@
 354 GOC_FOR_BUILD = @GOC_FOR_BUILD@
 355 GDC_FOR_BUILD = @GDC_FOR_BUILD@
 356 LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@
 357 LD_FOR_BUILD = @LD_FOR_BUILD@
 358 NM_FOR_BUILD = @NM_FOR_BUILD@
 359 RANLIB_FOR_BUILD = @RANLIB_FOR_BUILD@
 360 WINDMC_FOR_BUILD = @WINDMC_FOR_BUILD@
 361 WINDRES_FOR_BUILD = @WINDRES_FOR_BUILD@
 362
 363 # Special variables passed down in EXTRA_GCC_FLAGS.  They are defined
 364 # here so that they can be overridden by Makefile fragments.
 365 BUILD_PREFIX = @BUILD_PREFIX@
 366 BUILD_PREFIX_1 = @BUILD_PREFIX_1@
 367
 368 # Flags to pass to stage2 and later makes.  They are defined
 369 # here so that they can be overridden by Makefile fragments.
 370 BOOT_CFLAGS= -g -O2
 371 BOOT_LDFLAGS=
 372 BOOT_ADAFLAGS= -gnatpg
 373
 374 AWK = @AWK@
 375 SED = @SED@
 376 BISON = @BISON@
 377 YACC = @YACC@
 378 FLEX = @FLEX@
 379 LEX = @LEX@
 380 M4 = @M4@
 381 MAKEINFO = @MAKEINFO@
 382 EXPECT = @EXPECT@
 383 RUNTEST = @RUNTEST@
 384
 385 AUTO_PROFILE = gcc-auto-profile -c 10000000
 386
 387 # This just becomes part of the MAKEINFO definition passed down to
 388 # sub-makes.  It lets flags be given on the command line while still
 389 # using the makeinfo from the object tree.
 390 # (Default to avoid splitting info files by setting the threshold high.)
 391 MAKEINFOFLAGS = --split-size=5000000
 392
 393 # ---------------------------------------------
 394 # Programs producing files for the HOST machine
 395 # ---------------------------------------------
 396
 397 AS = @AS@
 398 AR = @AR@
 399 AR_FLAGS = rc
 400 CC = @CC@
 401 CXX = @CXX@
 402 DLLTOOL = @DLLTOOL@
 403 DSYMUTIL = @DSYMUTIL@
 404 LD = @LD@
 405 LIPO = @LIPO@
 406 NM = @NM@
 407 OBJDUMP = @OBJDUMP@
 408 OTOOL = @OTOOL@
 409 RANLIB = @RANLIB@
 410 READELF = @READELF@
 411 STRIP = @STRIP@
 412 WINDRES = @WINDRES@
 413 WINDMC = @WINDMC@
 414
 415 GDC = @GDC@
 416 GNATBIND = @GNATBIND@
 417 GNATMAKE = @GNATMAKE@
 418
 419 CFLAGS = @CFLAGS@
 420 LDFLAGS = @LDFLAGS@
 421 LIBCFLAGS = $(CFLAGS)
 422 CXXFLAGS = @CXXFLAGS@
 423 LIBCXXFLAGS = $(CXXFLAGS) -fno-implicit-templates
 424 GOCFLAGS = $(CFLAGS)
 425 GDCFLAGS = $(CFLAGS)
 426
 427 # Pass additional PGO and LTO compiler options to the PGO build.
 428 BUILD_CFLAGS = $(PGO_BUILD_CFLAGS) $(PGO_BUILD_LTO_CFLAGS)
 429 override CFLAGS += $(BUILD_CFLAGS)
 430 override CXXFLAGS += $(BUILD_CFLAGS)
 431
 432 # NB: Filter out any compiler options which may fail PGO training runs.
 433 PGO_BUILD_TRAINING_CFLAGS:= \
 434         $(filter-out -Werror=%,$(CFLAGS))
 435 PGO_BUILD_TRAINING_CXXFLAGS:=\
 436         $(filter-out -Werror=%,$(CXXFLAGS))
 437 PGO_BUILD_TRAINING_CFLAGS:= \
 438         $(filter-out -Wall,$(PGO_BUILD_TRAINING_CFLAGS))
 439 PGO_BUILD_TRAINING_CXXFLAGS:= \
 440         $(filter-out -Wall,$(PGO_BUILD_TRAINING_CXXFLAGS))
 441 PGO_BUILD_TRAINING_CFLAGS:= \
 442         $(filter-out -specs=%,$(PGO_BUILD_TRAINING_CFLAGS))
 443 PGO_BUILD_TRAINING_CXXFLAGS:= \
 444         $(filter-out -specs=%,$(PGO_BUILD_TRAINING_CXXFLAGS))
 445 PGO_BUILD_TRAINING_FLAGS_TO_PASS = \
 446         PGO_BUILD_TRAINING=yes \
 447         CFLAGS_FOR_TARGET="$(PGO_BUILD_TRAINING_CFLAGS)" \
 448         CXXFLAGS_FOR_TARGET="$(PGO_BUILD_TRAINING_CXXFLAGS)"
 449
 450 # Ignore "make check" errors in PGO training runs.
 451 PGO_BUILD_TRAINING_MFLAGS = -i
 452
 453 # Additional PGO and LTO compiler options to use profiling data for the
 454 # PGO build.
 455 PGO_BUILD_USE_FLAGS_TO_PASS = \
 456         PGO_BUILD_CFLAGS="@PGO_BUILD_USE_CFLAGS@" \
 457         PGO_BUILD_LTO_CFLAGS="@PGO_BUILD_LTO_CFLAGS@"
 458
 459 CREATE_GCOV = create_gcov
 460
 461 TFLAGS =
 462
 463 # Defaults for all stages; some are overridden below.
 464
 465 STAGE_CFLAGS = $(BOOT_CFLAGS)
 466 STAGE_TFLAGS = $(TFLAGS)
 467 STAGE_CONFIGURE_FLAGS=@stage2_werror_flag@
 468
 469
 470 # Defaults for stage 1; some are overridden below.
 471 STAGE1_CFLAGS = $(STAGE_CFLAGS)
 472 STAGE1_CXXFLAGS = $(CXXFLAGS)
 473 STAGE1_TFLAGS = $(STAGE_TFLAGS)
 474 STAGE1_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 475
 476 # Defaults for stage 2; some are overridden below.
 477 STAGE2_CFLAGS = $(STAGE_CFLAGS)
 478 STAGE2_CXXFLAGS = $(CXXFLAGS)
 479 STAGE2_TFLAGS = $(STAGE_TFLAGS)
 480 STAGE2_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 481
 482 # Defaults for stage 3; some are overridden below.
 483 STAGE3_CFLAGS = $(STAGE_CFLAGS)
 484 STAGE3_CXXFLAGS = $(CXXFLAGS)
 485 STAGE3_TFLAGS = $(STAGE_TFLAGS)
 486 STAGE3_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 487
 488 # Defaults for stage 4; some are overridden below.
 489 STAGE4_CFLAGS = $(STAGE_CFLAGS)
 490 STAGE4_CXXFLAGS = $(CXXFLAGS)
 491 STAGE4_TFLAGS = $(STAGE_TFLAGS)
 492 STAGE4_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 493
 494 # Defaults for stage profile; some are overridden below.
 495 STAGEprofile_CFLAGS = $(STAGE_CFLAGS)
 496 STAGEprofile_CXXFLAGS = $(CXXFLAGS)
 497 STAGEprofile_TFLAGS = $(STAGE_TFLAGS)
 498 STAGEprofile_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 499
 500 # Defaults for stage train; some are overridden below.
 501 STAGEtrain_CFLAGS = $(STAGE_CFLAGS)
 502 STAGEtrain_CXXFLAGS = $(CXXFLAGS)
 503 STAGEtrain_TFLAGS = $(STAGE_TFLAGS)
 504 STAGEtrain_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 505
 506 # Defaults for stage feedback; some are overridden below.
 507 STAGEfeedback_CFLAGS = $(STAGE_CFLAGS)
 508 STAGEfeedback_CXXFLAGS = $(CXXFLAGS)
 509 STAGEfeedback_TFLAGS = $(STAGE_TFLAGS)
 510 STAGEfeedback_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 511
 512 # Defaults for stage autoprofile; some are overridden below.
 513 STAGEautoprofile_CFLAGS = $(STAGE_CFLAGS)
 514 STAGEautoprofile_CXXFLAGS = $(CXXFLAGS)
 515 STAGEautoprofile_TFLAGS = $(STAGE_TFLAGS)
 516 STAGEautoprofile_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 517
 518 # Defaults for stage autofeedback; some are overridden below.
 519 STAGEautofeedback_CFLAGS = $(STAGE_CFLAGS)
 520 STAGEautofeedback_CXXFLAGS = $(CXXFLAGS)
 521 STAGEautofeedback_TFLAGS = $(STAGE_TFLAGS)
 522 STAGEautofeedback_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)
 523
 524
 525 # By default, C and C++ are the only stage1 languages, because they are the
 526 # only ones we require to build with the bootstrap compiler, and also the
 527 # only ones useful for building stage2.
 528
 529 STAGE1_CFLAGS = @stage1_cflags@
 530 STAGE1_CHECKING = @stage1_checking@
 531 STAGE1_LANGUAGES = @stage1_languages@
 532 # * We force-disable intermodule optimizations, even if
 533 #   --enable-intermodule was passed, since the installed compiler
 534 #   probably can't handle them.  Luckily, autoconf always respects
 535 #   the last argument when conflicting --enable arguments are passed.
 536 # * Likewise, we force-disable coverage flags, since the installed
 537 #   compiler probably has never heard of them.
 538 # * We also disable -Wformat, since older GCCs don't understand newer %s.
 539 STAGE1_CONFIGURE_FLAGS = --disable-intermodule $(STAGE1_CHECKING) \
 540           --disable-coverage --enable-languages="$(STAGE1_LANGUAGES)" \
 541           --disable-build-format-warnings
 542
 543 # When using the slow stage1 compiler disable IL verification and forcefully
 544 # enable it when using the stage2 compiler instead.  As we later compare
 545 # stage2 and stage3 we are merely avoid doing redundant work, plus we apply
 546 # checking when building all target libraries for release builds.
 547 STAGE1_TFLAGS += -fno-checking
 548 STAGE2_CFLAGS += -fno-checking
 549 STAGE2_TFLAGS += -fno-checking
 550 STAGE3_CFLAGS += -fchecking=1
 551 STAGE3_TFLAGS += -fchecking=1
 552
 553 STAGEprofile_CFLAGS = $(STAGE2_CFLAGS) -fprofile-generate
 554 STAGEprofile_TFLAGS = $(STAGE2_TFLAGS)
 555
 556 STAGEtrain_CFLAGS = $(filter-out -fchecking=1,$(STAGE3_CFLAGS))
 557 STAGEtrain_TFLAGS = $(filter-out -fchecking=1,$(STAGE3_TFLAGS))
 558
 559 STAGEfeedback_CFLAGS = $(STAGE4_CFLAGS) -fprofile-use -fprofile-reproducible=parallel-runs
 560 STAGEfeedback_TFLAGS = $(STAGE4_TFLAGS)
 561
 562 STAGEautoprofile_CFLAGS = $(STAGE2_CFLAGS) -g
 563 STAGEautoprofile_TFLAGS = $(STAGE2_TFLAGS)
 564
 565 STAGEautofeedback_CFLAGS = $(STAGE3_CFLAGS)
 566 STAGEautofeedback_TFLAGS = $(STAGE3_TFLAGS)
 567
 568 do-compare = @do_compare@
 569 do-compare3 = $(do-compare)
 570
 571 # -----------------------------------------------
 572 # Programs producing files for the TARGET machine
 573 # -----------------------------------------------
 574
 575 AR_FOR_TARGET=@AR_FOR_TARGET@
 576 AS_FOR_TARGET=@AS_FOR_TARGET@
 577 CC_FOR_TARGET=$(STAGE_CC_WRAPPER) @CC_FOR_TARGET@
 578
 579 # If GCC_FOR_TARGET is not overriden on the command line, then this
 580 # variable is passed down to the gcc Makefile, where it is used to
 581 # build libgcc2.a.  We define it here so that it can itself be
 582 # overridden on the command line.
 583 GCC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GCC_FOR_TARGET@
 584 CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @CXX_FOR_TARGET@
 585 RAW_CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @RAW_CXX_FOR_TARGET@
 586 GFORTRAN_FOR_TARGET=$(STAGE_CC_WRAPPER) @GFORTRAN_FOR_TARGET@
 587 GOC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GOC_FOR_TARGET@
 588 GDC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GDC_FOR_TARGET@
 589 DLLTOOL_FOR_TARGET=@DLLTOOL_FOR_TARGET@
 590 DSYMUTIL_FOR_TARGET=@DSYMUTIL_FOR_TARGET@
 591 LD_FOR_TARGET=@LD_FOR_TARGET@
 592
 593 LIPO_FOR_TARGET=@LIPO_FOR_TARGET@
 594 NM_FOR_TARGET=@NM_FOR_TARGET@
 595 OBJDUMP_FOR_TARGET=@OBJDUMP_FOR_TARGET@
 596 OBJCOPY_FOR_TARGET=@OBJCOPY_FOR_TARGET@
 597 OTOOL_FOR_TARGET=@OTOOL_FOR_TARGET@
 598 RANLIB_FOR_TARGET=@RANLIB_FOR_TARGET@
 599 READELF_FOR_TARGET=@READELF_FOR_TARGET@
 600 STRIP_FOR_TARGET=@STRIP_FOR_TARGET@
 601 WINDRES_FOR_TARGET=@WINDRES_FOR_TARGET@
 602 WINDMC_FOR_TARGET=@WINDMC_FOR_TARGET@
 603
 604 COMPILER_AS_FOR_TARGET=@COMPILER_AS_FOR_TARGET@
 605 COMPILER_LD_FOR_TARGET=@COMPILER_LD_FOR_TARGET@
 606 COMPILER_NM_FOR_TARGET=@COMPILER_NM_FOR_TARGET@
 607
 608 CFLAGS_FOR_TARGET = @CFLAGS_FOR_TARGET@
 609 CXXFLAGS_FOR_TARGET = @CXXFLAGS_FOR_TARGET@
 610
 611 LIBCFLAGS_FOR_TARGET = $(CFLAGS_FOR_TARGET)
 612 LIBCXXFLAGS_FOR_TARGET = $(CXXFLAGS_FOR_TARGET) -fno-implicit-templates
 613 LDFLAGS_FOR_TARGET = @LDFLAGS_FOR_TARGET@
 614 GOCFLAGS_FOR_TARGET = -O2 -g
 615 GDCFLAGS_FOR_TARGET = -O2 -g
 616
 617 FLAGS_FOR_TARGET = @FLAGS_FOR_TARGET@
 618 SYSROOT_CFLAGS_FOR_TARGET = @SYSROOT_CFLAGS_FOR_TARGET@
 619 DEBUG_PREFIX_CFLAGS_FOR_TARGET = @DEBUG_PREFIX_CFLAGS_FOR_TARGET@
 620
 621 XGCC_FLAGS_FOR_TARGET = $(FLAGS_FOR_TARGET) $(SYSROOT_CFLAGS_FOR_TARGET) $(DEBUG_PREFIX_CFLAGS_FOR_TARGET)
 622
 623 # ------------------------------------
 624 # Miscellaneous targets and flag lists
 625 # ------------------------------------
 626
 627 # The first rule in the file had better be this one.  Don't put any above it.
 628 # This lives here to allow makefile fragments to contain dependencies.
 629 all:
 630
 631 #### host and target specific makefile fragments come in here.
 632 ### @target_makefile_frag@
 633 ### @alphaieee_frag@
 634 ### @ospace_frag@
 635 ### @host_makefile_frag@
 636 ###
 637
 638 # This is the list of directories that may be needed in RPATH_ENVVAR
 639 # so that programs built for the target machine work.
 640 TARGET_LIB_PATH = $(HOST_LIB_PATH_gcc)
 641
 642
 643
 644 # This is the list of directories that may be needed in RPATH_ENVVAR
 645 # so that programs built for the host machine work.
 646 HOST_LIB_PATH =
 647
 648 # Define HOST_LIB_PATH_gcc here, for the sake of TARGET_LIB_PATH, ouch
 649 HOST_LIB_PATH_gcc = $$r/$(HOST_SUBDIR)/gcc$(GCC_SHLIB_SUBDIR):$$r/$(HOST_SUBDIR)/prev-gcc$(GCC_SHLIB_SUBDIR):
 650
 651
 652
 653 CXX_FOR_TARGET_FLAG_TO_PASS = \
 654         "CXX_FOR_TARGET=$(CXX_FOR_TARGET)"
 655
 656 # Flags to pass down to all sub-makes. STAGE*FLAGS,
 657 # MAKEINFO and MAKEINFOFLAGS are explicitly passed here to make them
 658 # overrideable (for a bootstrap build stage1 also builds gcc.info).
 659 BASE_FLAGS_TO_PASS = \
 660         "DESTDIR=$(DESTDIR)" \
 661         "RPATH_ENVVAR=$(RPATH_ENVVAR)" \
 662         "TARGET_SUBDIR=$(TARGET_SUBDIR)" \
 663         "bindir=$(bindir)" \
 664         "datadir=$(datadir)" \
 665         "exec_prefix=$(exec_prefix)" \
 666         "includedir=$(includedir)" \
 667         "datarootdir=$(datarootdir)" \
 668         "docdir=$(docdir)" \
 669         "infodir=$(infodir)" \
 670         "pdfdir=$(pdfdir)" \
 671         "htmldir=$(htmldir)" \
 672         "libdir=$(libdir)" \
 673         "libexecdir=$(libexecdir)" \
 674         "lispdir=$(lispdir)" \
 675         "localstatedir=$(localstatedir)" \
 676         "mandir=$(mandir)" \
 677         "oldincludedir=$(oldincludedir)" \
 678         "prefix=$(prefix)" \
 679         "sbindir=$(sbindir)" \
 680         "sharedstatedir=$(sharedstatedir)" \
 681         "sysconfdir=$(sysconfdir)" \
 682         "tooldir=$(tooldir)" \
 683         "build_tooldir=$(build_tooldir)" \
 684         "target_alias=$(target_alias)" \
 685         "AWK=$(AWK)" \
 686         "BISON=$(BISON)" \
 687         "CC_FOR_BUILD=$(CC_FOR_BUILD)" \
 688         "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
 689         "CXX_FOR_BUILD=$(CXX_FOR_BUILD)" \
 690         "EXPECT=$(EXPECT)" \
 691         "FLEX=$(FLEX)" \
 692         "INSTALL=$(INSTALL)" \
 693         "INSTALL_DATA=$(INSTALL_DATA)" \
 694         "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
 695         "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
 696         "LDFLAGS_FOR_BUILD=$(LDFLAGS_FOR_BUILD)" \
 697         "LEX=$(LEX)" \
 698         "M4=$(M4)" \
 699         "MAKE=$(MAKE)" \
 700         "RUNTEST=$(RUNTEST)" \
 701         "RUNTESTFLAGS=$(RUNTESTFLAGS)" \
 702         "SED=$(SED)" \
 703         "SHELL=$(SHELL)" \
 704         "YACC=$(YACC)" \
 705         "`echo 'ADAFLAGS=$(ADAFLAGS)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`" \
 706         "ADA_CFLAGS=$(ADA_CFLAGS)" \
 707         "AR_FLAGS=$(AR_FLAGS)" \
 708         "`echo 'BOOT_ADAFLAGS=$(BOOT_ADAFLAGS)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`" \
 709         "BOOT_CFLAGS=$(BOOT_CFLAGS)" \
 710         "BOOT_LDFLAGS=$(BOOT_LDFLAGS)" \
 711         "CFLAGS=$(CFLAGS)" \
 712         "CXXFLAGS=$(CXXFLAGS)" \
 713         "LDFLAGS=$(LDFLAGS)" \
 714         "LIBCFLAGS=$(LIBCFLAGS)" \
 715         "LIBCXXFLAGS=$(LIBCXXFLAGS)" \
 716         "STAGE1_CHECKING=$(STAGE1_CHECKING)" \
 717         "STAGE1_LANGUAGES=$(STAGE1_LANGUAGES)" \
 718         "GNATBIND=$(GNATBIND)" \
 719         "GNATMAKE=$(GNATMAKE)" \
 720         "GDC=$(GDC)" \
 721         "GDCFLAGS=$(GDCFLAGS)" \
 722         "AR_FOR_TARGET=$(AR_FOR_TARGET)" \
 723         "AS_FOR_TARGET=$(AS_FOR_TARGET)" \
 724         "CC_FOR_TARGET=$(CC_FOR_TARGET)" \
 725         "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
 726         "CPPFLAGS_FOR_TARGET=$(CPPFLAGS_FOR_TARGET)" \
 727         "CXXFLAGS_FOR_TARGET=$(CXXFLAGS_FOR_TARGET)" \
 728         "DLLTOOL_FOR_TARGET=$(DLLTOOL_FOR_TARGET)" \
 729         "DSYMUTIL_FOR_TARGET=$(DSYMUTIL_FOR_TARGET)" \
 730         "FLAGS_FOR_TARGET=$(FLAGS_FOR_TARGET)" \
 731         "GFORTRAN_FOR_TARGET=$(GFORTRAN_FOR_TARGET)" \
 732         "GOC_FOR_TARGET=$(GOC_FOR_TARGET)" \
 733         "GOCFLAGS_FOR_TARGET=$(GOCFLAGS_FOR_TARGET)" \
 734         "GDC_FOR_TARGET=$(GDC_FOR_TARGET)" \
 735         "GDCFLAGS_FOR_TARGET=$(GDCFLAGS_FOR_TARGET)" \
 736         "LD_FOR_TARGET=$(LD_FOR_TARGET)" \
 737         "LIPO_FOR_TARGET=$(LIPO_FOR_TARGET)" \
 738         "LDFLAGS_FOR_TARGET=$(LDFLAGS_FOR_TARGET)" \
 739         "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
 740         "LIBCXXFLAGS_FOR_TARGET=$(LIBCXXFLAGS_FOR_TARGET)" \
 741         "NM_FOR_TARGET=$(NM_FOR_TARGET)" \
 742         "OBJDUMP_FOR_TARGET=$(OBJDUMP_FOR_TARGET)" \
 743         "OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET)" \
 744         "RANLIB_FOR_TARGET=$(RANLIB_FOR_TARGET)" \
 745         "READELF_FOR_TARGET=$(READELF_FOR_TARGET)" \
 746         "STRIP_FOR_TARGET=$(STRIP_FOR_TARGET)" \
 747         "WINDRES_FOR_TARGET=$(WINDRES_FOR_TARGET)" \
 748         "WINDMC_FOR_TARGET=$(WINDMC_FOR_TARGET)" \
 749         "BUILD_CONFIG=$(BUILD_CONFIG)" \
 750         "`echo 'LANGUAGES=$(LANGUAGES)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`" \
 751         "LEAN=$(LEAN)" \
 752         "STAGE1_CFLAGS=$(STAGE1_CFLAGS)" \
 753         "STAGE1_CXXFLAGS=$(STAGE1_CXXFLAGS)" \
 754         "STAGE1_GENERATOR_CFLAGS=$(STAGE1_GENERATOR_CFLAGS)" \
 755         "STAGE1_TFLAGS=$(STAGE1_TFLAGS)" \
 756         "STAGE2_CFLAGS=$(STAGE2_CFLAGS)" \
 757         "STAGE2_CXXFLAGS=$(STAGE2_CXXFLAGS)" \
 758         "STAGE2_GENERATOR_CFLAGS=$(STAGE2_GENERATOR_CFLAGS)" \
 759         "STAGE2_TFLAGS=$(STAGE2_TFLAGS)" \
 760         "STAGE3_CFLAGS=$(STAGE3_CFLAGS)" \
 761         "STAGE3_CXXFLAGS=$(STAGE3_CXXFLAGS)" \
 762         "STAGE3_GENERATOR_CFLAGS=$(STAGE3_GENERATOR_CFLAGS)" \
 763         "STAGE3_TFLAGS=$(STAGE3_TFLAGS)" \
 764         "STAGE4_CFLAGS=$(STAGE4_CFLAGS)" \
 765         "STAGE4_CXXFLAGS=$(STAGE4_CXXFLAGS)" \
 766         "STAGE4_GENERATOR_CFLAGS=$(STAGE4_GENERATOR_CFLAGS)" \
 767         "STAGE4_TFLAGS=$(STAGE4_TFLAGS)" \
 768         "STAGEprofile_CFLAGS=$(STAGEprofile_CFLAGS)" \
 769         "STAGEprofile_CXXFLAGS=$(STAGEprofile_CXXFLAGS)" \
 770         "STAGEprofile_GENERATOR_CFLAGS=$(STAGEprofile_GENERATOR_CFLAGS)" \
 771         "STAGEprofile_TFLAGS=$(STAGEprofile_TFLAGS)" \
 772         "STAGEtrain_CFLAGS=$(STAGEtrain_CFLAGS)" \
 773         "STAGEtrain_CXXFLAGS=$(STAGEtrain_CXXFLAGS)" \
 774         "STAGEtrain_GENERATOR_CFLAGS=$(STAGEtrain_GENERATOR_CFLAGS)" \
 775         "STAGEtrain_TFLAGS=$(STAGEtrain_TFLAGS)" \
 776         "STAGEfeedback_CFLAGS=$(STAGEfeedback_CFLAGS)" \
 777         "STAGEfeedback_CXXFLAGS=$(STAGEfeedback_CXXFLAGS)" \
 778         "STAGEfeedback_GENERATOR_CFLAGS=$(STAGEfeedback_GENERATOR_CFLAGS)" \
 779         "STAGEfeedback_TFLAGS=$(STAGEfeedback_TFLAGS)" \
 780         "STAGEautoprofile_CFLAGS=$(STAGEautoprofile_CFLAGS)" \
 781         "STAGEautoprofile_CXXFLAGS=$(STAGEautoprofile_CXXFLAGS)" \
 782         "STAGEautoprofile_GENERATOR_CFLAGS=$(STAGEautoprofile_GENERATOR_CFLAGS)" \
 783         "STAGEautoprofile_TFLAGS=$(STAGEautoprofile_TFLAGS)" \
 784         "STAGEautofeedback_CFLAGS=$(STAGEautofeedback_CFLAGS)" \
 785         "STAGEautofeedback_CXXFLAGS=$(STAGEautofeedback_CXXFLAGS)" \
 786         "STAGEautofeedback_GENERATOR_CFLAGS=$(STAGEautofeedback_GENERATOR_CFLAGS)" \
 787         "STAGEautofeedback_TFLAGS=$(STAGEautofeedback_TFLAGS)" \
 788         $(CXX_FOR_TARGET_FLAG_TO_PASS) \
 789         "TFLAGS=$(TFLAGS)" \
 790         "CONFIG_SHELL=$(SHELL)" \
 791         "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
 792         $(if $(LSAN_OPTIONS),"LSAN_OPTIONS=$(LSAN_OPTIONS)")
 793
 794 # We leave this in just in case, but it is not needed anymore.
 795 RECURSE_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS)
 796
 797 # Flags to pass down to most sub-makes, in which we're building with
 798 # the host environment.
 799 EXTRA_HOST_FLAGS = \
 800         'AR=$(AR)' \
 801         'AS=$(AS)' \
 802         'CC=$(CC)' \
 803         'CXX=$(CXX)' \
 804         'DLLTOOL=$(DLLTOOL)' \
 805         'DSYMUTIL=$(DSYMUTIL)' \
 806         'GFORTRAN=$(GFORTRAN)' \
 807         'GOC=$(GOC)' \
 808         'GDC=$(GDC)' \
 809         'LD=$(LD)' \
 810         'LIPO=$(LIPO)' \
 811         'NM=$(NM)' \
 812         'OBJDUMP=$(OBJDUMP)' \
 813         'OTOOL=$(OTOOL)' \
 814         'RANLIB=$(RANLIB)' \
 815         'READELF=$(READELF)' \
 816         'STRIP=$(STRIP)' \
 817         'WINDRES=$(WINDRES)' \
 818         'WINDMC=$(WINDMC)' \
 819         'CREATE_GCOV=$(CREATE_GCOV)'
 820
 821 FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS)
 822
 823 # Flags to pass to stage1 or when not bootstrapping.
 824
 825 STAGE1_FLAGS_TO_PASS = \
 826         LDFLAGS="$${LDFLAGS}" \
 827         HOST_LIBS="$${HOST_LIBS}"
 828
 829 # Flags to pass to stage2 and later makes.
 830
 831 POSTSTAGE1_FLAGS_TO_PASS = \
 832         CC="$${CC}" CC_FOR_BUILD="$${CC_FOR_BUILD}" \
 833         CXX="$${CXX}" CXX_FOR_BUILD="$${CXX_FOR_BUILD}" \
 834         GDC="$${GDC}" GDC_FOR_BUILD="$${GDC_FOR_BUILD}" \
 835         GNATBIND="$${GNATBIND}" \
 836         LDFLAGS="$${LDFLAGS}" \
 837         HOST_LIBS="$${HOST_LIBS}" \
 838         $(LTO_FLAGS_TO_PASS) \
 839         "`echo 'ADAFLAGS=$(BOOT_ADAFLAGS)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"
 840
 841 # Flags to pass down to makes which are built with the target environment.
 842 # The double $ decreases the length of the command line; those variables
 843 # are set in BASE_FLAGS_TO_PASS, and the sub-make will expand them.  The
 844 # *_CFLAGS_FOR_TARGET variables are not passed down and most often empty,
 845 # so we expand them here.
 846 EXTRA_TARGET_FLAGS = \
 847         'AR=$$(AR_FOR_TARGET)' \
 848         'AS=$(COMPILER_AS_FOR_TARGET)' \
 849         'CC=$$(CC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
 850         'CFLAGS=$$(CFLAGS_FOR_TARGET)' \
 851         'CXX=$$(CXX_FOR_TARGET) -B$$r/$$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \
 852          -B$$r/$$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs \
 853          $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
 854         'CXXFLAGS=$$(CXXFLAGS_FOR_TARGET)' \
 855         'DLLTOOL=$$(DLLTOOL_FOR_TARGET)' \
 856         'DSYMUTIL=$$(DSYMUTIL_FOR_TARGET)' \
 857         'GFORTRAN=$$(GFORTRAN_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
 858         'GOC=$$(GOC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
 859         'GOCFLAGS=$$(GOCFLAGS_FOR_TARGET)' \
 860         'GDC=$$(GDC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \
 861         'GDCFLAGS=$$(GDCFLAGS_FOR_TARGET)' \
 862         'LD=$(COMPILER_LD_FOR_TARGET)' \
 863         'LDFLAGS=$$(LDFLAGS_FOR_TARGET)' \
 864         'LIBCFLAGS=$$(LIBCFLAGS_FOR_TARGET)' \
 865         'LIBCXXFLAGS=$$(LIBCXXFLAGS_FOR_TARGET)' \
 866         'NM=$(COMPILER_NM_FOR_TARGET)' \
 867         'OBJDUMP=$$(OBJDUMP_FOR_TARGET)' \
 868         'OBJCOPY=$$(OBJCOPY_FOR_TARGET)' \
 869         'RANLIB=$$(RANLIB_FOR_TARGET)' \
 870         'READELF=$$(READELF_FOR_TARGET)' \
 871         'WINDRES=$$(WINDRES_FOR_TARGET)' \
 872         'WINDMC=$$(WINDMC_FOR_TARGET)' \
 873         'XGCC_FLAGS_FOR_TARGET=$(XGCC_FLAGS_FOR_TARGET)' \
 874         'STAGE1_LDFLAGS=$$(POSTSTAGE1_LDFLAGS)' \
 875         'STAGE1_LIBS=$$(POSTSTAGE1_LIBS)' \
 876         "TFLAGS=$$TFLAGS"
 877
 878 TARGET_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_TARGET_FLAGS)
 879
 880 # Flags to pass down to gcc.  gcc builds a library, libgcc.a, so it
 881 # unfortunately needs the native compiler and the target ar and
 882 # ranlib.
 883 # If any variables are added here, they must be added to do-*, below.
 884 # The BUILD_* variables are a special case, which are used for the gcc
 885 # cross-building scheme.
 886 EXTRA_GCC_FLAGS = \
 887         "GCC_FOR_TARGET=$(GCC_FOR_TARGET)" \
 888         "`echo 'STMP_FIXPROTO=$(STMP_FIXPROTO)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`" \
 889         "`echo 'LIMITS_H_TEST=$(LIMITS_H_TEST)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"
 890
 891 GCC_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS)
 892
 893 BUILD_CONFIG = @BUILD_CONFIG@
 894 ifneq ($(BUILD_CONFIG),)
 895 include $(foreach CONFIG, $(BUILD_CONFIG), $(srcdir)/config/$(CONFIG).mk)
 896 endif
 897
 898 .PHONY: configure-host
 899 configure-host:  \
 900     maybe-configure-gcc \
 901     maybe-configure-libbacktrace \
 902     maybe-configure-libcpp
 903 .PHONY: configure-target
 904 configure-target:  \
 905     maybe-configure-target-libbacktrace
 906
 907 # The target built for a native non-bootstrap build.
 908 .PHONY: all
 909
 910 # --enable-pgo-build enables the PGO build.
 911 # 1. First build with -fprofile-generate.
 912 # 2. Use "make maybe-check-*" to generate profiling data.
 913 # 3. Use "make clean" to remove the previous build.
 914 # 4. Rebuild with -fprofile-use.
 915 all:
 916         @: $(MAKE); $(unstage)
 917         +@r=`${PWD_COMMAND}`; export r; \
 918         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
 919           $(MAKE) $(RECURSE_FLAGS_TO_PASS) \
 920                 $(PGO_BUILD_GEN_FLAGS_TO_PASS) all-host all-target \
 921         && :
 922
 923 .PHONY: all-build
 924
 925 all-build: maybe-all-build-libcpp
 926
 927 .PHONY: all-host
 928
 929 #@if gcc-no-bootstrap
 930 all-host: maybe-all-gcc
 931 #@endif gcc-no-bootstrap
 932 #@if libbacktrace-no-bootstrap
 933 all-host: maybe-all-libbacktrace
 934 #@endif libbacktrace-no-bootstrap
 935 #@if libcpp-no-bootstrap
 936 all-host: maybe-all-libcpp
 937 #@endif libcpp-no-bootstrap
 938
 939 .PHONY: all-target
 940
 941 #@if target-libbacktrace-no-bootstrap
 942 all-target: maybe-all-target-libbacktrace
 943 #@endif target-libbacktrace-no-bootstrap
 944
 945 # Do a target for all the subdirectories.  A ``make do-X'' will do a
 946 # ``make X'' in all subdirectories (because, in general, there is a
 947 # dependency (below) of X upon do-X, a ``make X'' will also do this,
 948 # but it may do additional work as well).
 949
 950 .PHONY: do-info
 951 do-info:
 952         @: $(MAKE); $(unstage)
 953         @r=`${PWD_COMMAND}`; export r; \
 954         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
 955         $(MAKE) $(RECURSE_FLAGS_TO_PASS) info-host \
 956           info-target
 957
 958
 959 .PHONY: info-host
 960
 961 info-host: maybe-info-gcc
 962 info-host: maybe-info-libbacktrace
 963 info-host: maybe-info-libcpp
 964
 965 .PHONY: info-target
 966
 967 info-target: maybe-info-target-libbacktrace
 968
 969 .PHONY: do-dvi
 970 do-dvi:
 971         @: $(MAKE); $(unstage)
 972         @r=`${PWD_COMMAND}`; export r; \
 973         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
 974         $(MAKE) $(RECURSE_FLAGS_TO_PASS) dvi-host \
 975           dvi-target
 976
 977
 978 .PHONY: dvi-host
 979
 980 dvi-host: maybe-dvi-gcc
 981 dvi-host: maybe-dvi-libbacktrace
 982 dvi-host: maybe-dvi-libcpp
 983
 984 .PHONY: dvi-target
 985
 986 dvi-target: maybe-dvi-target-libbacktrace
 987
 988 .PHONY: do-pdf
 989 do-pdf:
 990         @: $(MAKE); $(unstage)
 991         @r=`${PWD_COMMAND}`; export r; \
 992         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
 993         $(MAKE) $(RECURSE_FLAGS_TO_PASS) pdf-host \
 994           pdf-target
 995
 996
 997 .PHONY: pdf-host
 998
 999 pdf-host: maybe-pdf-gcc
1000 pdf-host: maybe-pdf-libbacktrace
1001 pdf-host: maybe-pdf-libcpp
1002
1003 .PHONY: pdf-target
1004
1005 pdf-target: maybe-pdf-target-libbacktrace
1006
1007 .PHONY: do-html
1008 do-html:
1009         @: $(MAKE); $(unstage)
1010         @r=`${PWD_COMMAND}`; export r; \
1011         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1012         $(MAKE) $(RECURSE_FLAGS_TO_PASS) html-host \
1013           html-target
1014
1015
1016 .PHONY: html-host
1017
1018 html-host: maybe-html-gcc
1019 html-host: maybe-html-libbacktrace
1020 html-host: maybe-html-libcpp
1021
1022 .PHONY: html-target
1023
1024 html-target: maybe-html-target-libbacktrace
1025
1026 .PHONY: do-TAGS
1027 do-TAGS:
1028         @: $(MAKE); $(unstage)
1029         @r=`${PWD_COMMAND}`; export r; \
1030         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1031         $(MAKE) $(RECURSE_FLAGS_TO_PASS) TAGS-host \
1032           TAGS-target
1033
1034
1035 .PHONY: TAGS-host
1036
1037 TAGS-host: maybe-TAGS-gcc
1038 TAGS-host: maybe-TAGS-libbacktrace
1039 TAGS-host: maybe-TAGS-libcpp
1040
1041 .PHONY: TAGS-target
1042
1043 TAGS-target: maybe-TAGS-target-libbacktrace
1044
1045 .PHONY: do-install-info
1046 do-install-info:
1047         @: $(MAKE); $(unstage)
1048         @r=`${PWD_COMMAND}`; export r; \
1049         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1050         $(MAKE) $(RECURSE_FLAGS_TO_PASS) install-info-host \
1051           install-info-target
1052
1053
1054 .PHONY: install-info-host
1055
1056 install-info-host: maybe-install-info-gcc
1057 install-info-host: maybe-install-info-libbacktrace
1058 install-info-host: maybe-install-info-libcpp
1059
1060 .PHONY: install-info-target
1061
1062 install-info-target: maybe-install-info-target-libbacktrace
1063
1064 .PHONY: do-install-dvi
1065 do-install-dvi:
1066         @: $(MAKE); $(unstage)
1067         @r=`${PWD_COMMAND}`; export r; \
1068         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1069         $(MAKE) $(RECURSE_FLAGS_TO_PASS) install-dvi-host \
1070           install-dvi-target
1071
1072
1073 .PHONY: install-dvi-host
1074
1075 install-dvi-host: maybe-install-dvi-gcc
1076 install-dvi-host: maybe-install-dvi-libbacktrace
1077 install-dvi-host: maybe-install-dvi-libcpp
1078
1079 .PHONY: install-dvi-target
1080
1081 install-dvi-target: maybe-install-dvi-target-libbacktrace
1082
1083 .PHONY: do-install-pdf
1084 do-install-pdf:
1085         @: $(MAKE); $(unstage)
1086         @r=`${PWD_COMMAND}`; export r; \
1087         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1088         $(MAKE) $(RECURSE_FLAGS_TO_PASS) install-pdf-host \
1089           install-pdf-target
1090
1091
1092 .PHONY: install-pdf-host
1093
1094 install-pdf-host: maybe-install-pdf-gcc
1095 install-pdf-host: maybe-install-pdf-libbacktrace
1096 install-pdf-host: maybe-install-pdf-libcpp
1097
1098 .PHONY: install-pdf-target
1099
1100 install-pdf-target: maybe-install-pdf-target-libbacktrace
1101
1102 .PHONY: do-install-html
1103 do-install-html:
1104         @: $(MAKE); $(unstage)
1105         @r=`${PWD_COMMAND}`; export r; \
1106         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1107         $(MAKE) $(RECURSE_FLAGS_TO_PASS) install-html-host \
1108           install-html-target
1109
1110
1111 .PHONY: install-html-host
1112
1113 install-html-host: maybe-install-html-gcc
1114 install-html-host: maybe-install-html-libbacktrace
1115 install-html-host: maybe-install-html-libcpp
1116
1117 .PHONY: install-html-target
1118
1119 install-html-target: maybe-install-html-target-libbacktrace
1120
1121 .PHONY: do-installcheck
1122 do-installcheck:
1123         @: $(MAKE); $(unstage)
1124         @r=`${PWD_COMMAND}`; export r; \
1125         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1126         $(MAKE) $(RECURSE_FLAGS_TO_PASS) installcheck-host \
1127           installcheck-target
1128
1129
1130 .PHONY: installcheck-host
1131
1132 installcheck-host: maybe-installcheck-gcc
1133 installcheck-host: maybe-installcheck-libbacktrace
1134 installcheck-host: maybe-installcheck-libcpp
1135
1136 .PHONY: installcheck-target
1137
1138 installcheck-target: maybe-installcheck-target-libbacktrace
1139
1140 .PHONY: do-mostlyclean
1141 do-mostlyclean:
1142         @: $(MAKE); $(unstage)
1143         @r=`${PWD_COMMAND}`; export r; \
1144         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1145         $(MAKE) $(RECURSE_FLAGS_TO_PASS) mostlyclean-host \
1146           mostlyclean-target
1147
1148
1149 .PHONY: mostlyclean-host
1150
1151 mostlyclean-host: maybe-mostlyclean-gcc
1152 mostlyclean-host: maybe-mostlyclean-libbacktrace
1153 mostlyclean-host: maybe-mostlyclean-libcpp
1154
1155 .PHONY: mostlyclean-target
1156
1157 mostlyclean-target: maybe-mostlyclean-target-libbacktrace
1158
1159 .PHONY: do-clean
1160 do-clean:
1161         @: $(MAKE); $(unstage)
1162         @r=`${PWD_COMMAND}`; export r; \
1163         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1164         $(MAKE) $(RECURSE_FLAGS_TO_PASS) clean-host \
1165           clean-target
1166
1167
1168 .PHONY: clean-host
1169
1170 clean-host: maybe-clean-gcc
1171 clean-host: maybe-clean-libbacktrace
1172 clean-host: maybe-clean-libcpp
1173
1174 .PHONY: clean-target
1175
1176 clean-target: maybe-clean-target-libbacktrace
1177
1178 .PHONY: do-distclean
1179 do-distclean:
1180         @: $(MAKE); $(unstage)
1181         @r=`${PWD_COMMAND}`; export r; \
1182         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1183         $(MAKE) $(RECURSE_FLAGS_TO_PASS) distclean-host \
1184           distclean-target
1185
1186
1187 .PHONY: distclean-host
1188
1189 distclean-host: maybe-distclean-gcc
1190 distclean-host: maybe-distclean-libbacktrace
1191 distclean-host: maybe-distclean-libcpp
1192
1193 .PHONY: distclean-target
1194
1195 distclean-target: maybe-distclean-target-libbacktrace
1196
1197 .PHONY: do-maintainer-clean
1198 do-maintainer-clean:
1199         @: $(MAKE); $(unstage)
1200         @r=`${PWD_COMMAND}`; export r; \
1201         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1202         $(MAKE) $(RECURSE_FLAGS_TO_PASS) maintainer-clean-host \
1203           maintainer-clean-target
1204
1205
1206 .PHONY: maintainer-clean-host
1207
1208 maintainer-clean-host: maybe-maintainer-clean-gcc
1209 maintainer-clean-host: maybe-maintainer-clean-libbacktrace
1210 maintainer-clean-host: maybe-maintainer-clean-libcpp
1211
1212 .PHONY: maintainer-clean-target
1213
1214 maintainer-clean-target: maybe-maintainer-clean-target-libbacktrace
1215
1216
1217 # Here are the targets which correspond to the do-X targets.
1218
1219 .PHONY: info installcheck dvi pdf html
1220 .PHONY: install-info install-dvi install-pdf install-html
1221 .PHONY: clean distclean mostlyclean maintainer-clean realclean
1222 .PHONY: local-clean local-distclean local-maintainer-clean
1223 info: do-info
1224 installcheck: do-installcheck
1225 dvi: do-dvi
1226 pdf: do-pdf
1227 html: do-html
1228
1229 # Make sure makeinfo is built before we do a `make info', if we're
1230 # in fact building texinfo.
1231 do-info: maybe-all-texinfo
1232
1233 install-info: do-install-info dir.info
1234         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1235         if [ -f dir.info ]; then \
1236           $(INSTALL_DATA) dir.info $(DESTDIR)$(infodir)/dir.info; \
1237         else true; fi
1238
1239 install-dvi: do-install-dvi
1240
1241 install-pdf: do-install-pdf
1242
1243 install-html: do-install-html
1244
1245 local-clean:
1246         -rm -f *.a TEMP errs core *.o *~ \#* TAGS *.E *.log
1247
1248 local-distclean:
1249         -rm -f Makefile config.status config.cache mh-frag mt-frag
1250         -rm -f maybedep.tmp serdep.tmp stage_final
1251         -if [ "$(TARGET_SUBDIR)" != "." ]; then \
1252           rm -rf $(TARGET_SUBDIR); \
1253         else true; fi
1254         -rm -rf $(BUILD_SUBDIR)
1255         -if [ "$(HOST_SUBDIR)" != "." ]; then \
1256           rm -rf $(HOST_SUBDIR); \
1257         else true; fi
1258         -rm -f texinfo/po/Makefile texinfo/po/Makefile.in texinfo/info/Makefile
1259         -rm -f texinfo/doc/Makefile texinfo/po/POTFILES
1260         -rmdir texinfo/doc texinfo/info texinfo/intl texinfo/lib 2>/dev/null
1261         -rmdir texinfo/makeinfo texinfo/po texinfo/util 2>/dev/null
1262         -rmdir c++tools fastjar gcc gnattools gotools 2>/dev/null
1263         -rmdir libcc1 libiberty texinfo zlib 2>/dev/null
1264         -find . -name config.cache -exec rm -f {} \; \; 2>/dev/null
1265
1266 local-maintainer-clean:
1267         @echo "This command is intended for maintainers to use;"
1268         @echo "it deletes files that may require special tools to rebuild."
1269
1270 clean: do-clean local-clean
1271 mostlyclean: do-mostlyclean local-clean
1272 distclean: do-distclean local-clean local-distclean
1273 maintainer-clean: local-maintainer-clean do-maintainer-clean local-clean
1274 maintainer-clean: local-distclean
1275 realclean: maintainer-clean
1276
1277 # Check target.
1278
1279 .PHONY: check do-check
1280 check: do-check
1281
1282 # Only include modules actually being configured and built.
1283 .PHONY: check-host
1284 check-host:  \
1285     maybe-check-gcc \
1286     maybe-check-libbacktrace \
1287     maybe-check-libcpp
1288
1289 .PHONY: check-target
1290 check-target:  \
1291     maybe-check-target-libbacktrace
1292
1293 do-check:
1294         @: $(MAKE); $(unstage)
1295         @r=`${PWD_COMMAND}`; export r; \
1296         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1297         $(MAKE) $(RECURSE_FLAGS_TO_PASS) check-host check-target
1298
1299 # Automated reporting of test results.
1300
1301 warning.log: build.log
1302         $(srcdir)/contrib/warn_summary build.log > $@
1303
1304 mail-report.log:
1305         if test x'$(BOOT_CFLAGS)' != x''; then \
1306             BOOT_CFLAGS='$(BOOT_CFLAGS)'; export BOOT_CFLAGS; \
1307         fi; \
1308         $(srcdir)/contrib/test_summary -t >$@
1309         chmod +x $@
1310         echo If you really want to send e-mail, run ./$@ now
1311
1312 mail-report-with-warnings.log: warning.log
1313         if test x'$(BOOT_CFLAGS)' != x''; then \
1314             BOOT_CFLAGS='$(BOOT_CFLAGS)'; export BOOT_CFLAGS; \
1315         fi; \
1316         $(srcdir)/contrib/test_summary -t -i warning.log >$@
1317         chmod +x $@
1318         echo If you really want to send e-mail, run ./$@ now
1319
1320 # Local Vim config
1321
1322 $(srcdir)/.local.vimrc:
1323         $(LN_S) contrib/vimrc $@
1324
1325 $(srcdir)/.lvimrc:
1326         $(LN_S) contrib/vimrc $@
1327
1328 vimrc: $(srcdir)/.local.vimrc $(srcdir)/.lvimrc
1329
1330 .PHONY: vimrc
1331
1332 # clang-format config
1333
1334 $(srcdir)/.clang-format:
1335         $(LN_S) contrib/clang-format $@
1336
1337 clang-format: $(srcdir)/.clang-format
1338
1339 .PHONY: clang-format
1340
1341 # Installation targets.
1342
1343 .PHONY: install uninstall
1344 install:
1345         @: $(MAKE); $(unstage)
1346         @r=`${PWD_COMMAND}`; export r; \
1347         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1348         $(MAKE) $(RECURSE_FLAGS_TO_PASS) installdirs install-host install-target
1349
1350 .PHONY: install-host-nogcc
1351 install-host-nogcc:  \
1352     maybe-install-libbacktrace \
1353     maybe-install-libcpp
1354
1355 .PHONY: install-host
1356 install-host:  \
1357     maybe-install-gcc \
1358     maybe-install-libbacktrace \
1359     maybe-install-libcpp
1360
1361 .PHONY: install-target
1362 install-target:  \
1363     maybe-install-target-libbacktrace
1364
1365 uninstall:
1366         @echo "the uninstall target is not supported in this tree"
1367
1368 .PHONY: install.all
1369 install.all: install-no-fixedincludes
1370         @if [ -f ./gcc/Makefile ]; then \
1371                 r=`${PWD_COMMAND}`; export r; \
1372                 s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1373                 $(HOST_EXPORTS) \
1374                 (cd ./gcc && \
1375                 $(MAKE) $(FLAGS_TO_PASS) install-headers); \
1376         else \
1377                 true; \
1378         fi
1379
1380 # install-no-fixedincludes is used to allow the elaboration of binary packages
1381 # suitable for distribution, where we cannot include the fixed system header
1382 # files.
1383 .PHONY: install-no-fixedincludes
1384 install-no-fixedincludes: installdirs install-host-nogcc \
1385         install-target gcc-install-no-fixedincludes
1386
1387 .PHONY: install-strip
1388 install-strip:
1389         @: $(MAKE); $(unstage)
1390         @r=`${PWD_COMMAND}`; export r; \
1391         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1392         $(MAKE) $(RECURSE_FLAGS_TO_PASS) installdirs install-strip-host install-strip-target
1393
1394 .PHONY: install-strip-host
1395 install-strip-host:  \
1396     maybe-install-strip-gcc \
1397     maybe-install-strip-libbacktrace \
1398     maybe-install-strip-libcpp
1399
1400 .PHONY: install-strip-target
1401 install-strip-target:  \
1402     maybe-install-strip-target-libbacktrace
1403
1404
1405 ### other supporting targets
1406
1407 MAKEDIRS= \
1408         $(DESTDIR)$(prefix) \
1409         $(DESTDIR)$(exec_prefix)
1410 .PHONY: installdirs
1411 installdirs: mkinstalldirs
1412         $(SHELL) $(srcdir)/mkinstalldirs $(MAKEDIRS)
1413
1414 dir.info: do-install-info
1415         if [ -f $(srcdir)/texinfo/gen-info-dir ]; then \
1416           $(srcdir)/texinfo/gen-info-dir $(DESTDIR)$(infodir) $(srcdir)/texinfo/dir.info-template > dir.info.new; \
1417           mv -f dir.info.new dir.info; \
1418         else true; \
1419         fi
1420
1421 dist:
1422         @echo "Building a full distribution of this tree isn't done"
1423         @echo "via 'make dist'.  Check out the etc/ subdirectory"
1424
1425 etags tags: TAGS
1426
1427 # Right now this just builds TAGS in each subdirectory.  emacs19 has the
1428 # ability to use several tags files at once, so there is probably no need
1429 # to combine them into one big TAGS file (like CVS 1.3 does).  We could
1430 # (if we felt like it) have this Makefile write a piece of elisp which
1431 # the user could load to tell emacs19 where all the TAGS files we just
1432 # built are.
1433 TAGS: do-TAGS
1434
1435 # ------------------------------------
1436 # Macros for configure and all targets
1437 # ------------------------------------
1438
1439
1440
1441
1442
1443 # --------------------------------------
1444 # Modules which run on the build machine
1445 # --------------------------------------
1446
1447
1448 .PHONY: configure-build-libcpp maybe-configure-build-libcpp
1449 maybe-configure-build-libcpp:
1450 @if build-libcpp
1451 maybe-configure-build-libcpp: configure-build-libcpp
1452 configure-build-libcpp:
1453         @: $(MAKE); $(unstage)
1454         @r=`${PWD_COMMAND}`; export r; \
1455         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1456         test ! -f $(BUILD_SUBDIR)/libcpp/Makefile || exit 0; \
1457         $(SHELL) $(srcdir)/mkinstalldirs $(BUILD_SUBDIR)/libcpp; \
1458         $(BUILD_EXPORTS)  \
1459         echo Configuring in $(BUILD_SUBDIR)/libcpp; \
1460         cd "$(BUILD_SUBDIR)/libcpp" || exit 1; \
1461         case $(srcdir) in \
1462           /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
1463           *) topdir=`echo $(BUILD_SUBDIR)/libcpp/ | \
1464                 sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
1465         esac; \
1466         module_srcdir=libcpp; \
1467         rm -f no-such-file || : ; \
1468         CONFIG_SITE=no-such-file $(SHELL) \
1469           $$s/$$module_srcdir/configure \
1470           --srcdir=$${topdir}/$$module_srcdir \
1471           $(BUILD_CONFIGARGS) --build=${build_alias} --host=${build_alias} \
1472           --target=${target_alias} --disable-nls am_cv_func_iconv=no \
1473           || exit 1
1474 @endif build-libcpp
1475
1476
1477
1478
1479 .PHONY: all-build-libcpp maybe-all-build-libcpp
1480 maybe-all-build-libcpp:
1481 @if build-libcpp
1482 TARGET-build-libcpp=all
1483 maybe-all-build-libcpp: all-build-libcpp
1484 all-build-libcpp: configure-build-libcpp
1485         @: $(MAKE); $(unstage)
1486         @r=`${PWD_COMMAND}`; export r; \
1487         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1488         $(BUILD_EXPORTS)  \
1489         (cd $(BUILD_SUBDIR)/libcpp && \
1490           $(MAKE) $(BASE_FLAGS_TO_PASS) $(EXTRA_BUILD_FLAGS)   \
1491                 $(TARGET-build-libcpp))
1492 @endif build-libcpp
1493
1494
1495
1496
1497
1498 # --------------------------------------
1499 # Modules which run on the host machine
1500 # --------------------------------------
1501
1502
1503 .PHONY: configure-gcc maybe-configure-gcc
1504 maybe-configure-gcc:
1505 @if gcc
1506 maybe-configure-gcc: configure-gcc
1507 configure-gcc:
1508         @r=`${PWD_COMMAND}`; export r; \
1509         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1510         test ! -f $(HOST_SUBDIR)/gcc/Makefile || exit 0; \
1511         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)/gcc; \
1512         $(HOST_EXPORTS)  \
1513         echo Configuring in $(HOST_SUBDIR)/gcc; \
1514         cd "$(HOST_SUBDIR)/gcc" || exit 1; \
1515         case $(srcdir) in \
1516           /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
1517           *) topdir=`echo $(HOST_SUBDIR)/gcc/ | \
1518                 sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
1519         esac; \
1520         module_srcdir=gcc; \
1521         $(SHELL) \
1522           $$s/$$module_srcdir/configure \
1523           --srcdir=$${topdir}/$$module_srcdir \
1524           $(HOST_CONFIGARGS) --build=${build_alias} --host=${host_alias} \
1525           --target=${target_alias}  \
1526           || exit 1
1527 @endif gcc
1528
1529
1530
1531
1532 .PHONY: all-gcc maybe-all-gcc
1533 maybe-all-gcc:
1534 @if gcc
1535 TARGET-gcc=all
1536 maybe-all-gcc: all-gcc
1537 all-gcc: configure-gcc
1538         @r=`${PWD_COMMAND}`; export r; \
1539         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1540         $(HOST_EXPORTS)  \
1541         (cd $(HOST_SUBDIR)/gcc && \
1542           $(MAKE) $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) $(STAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1543                 $(TARGET-gcc))
1544 @endif gcc
1545
1546
1547
1548 .PHONY: all-stage1-gcc maybe-all-stage1-gcc
1549 .PHONY: clean-stage1-gcc maybe-clean-stage1-gcc
1550 maybe-all-stage1-gcc:
1551 maybe-clean-stage1-gcc:
1552 @if gcc-bootstrap
1553 maybe-all-stage1-gcc: all-stage1-gcc
1554 all-stage1: all-stage1-gcc
1555 TARGET-stage1-gcc = $(TARGET-gcc)
1556 all-stage1-gcc: configure-stage1-gcc
1557         @[ $(current_stage) = stage1 ] || $(MAKE) stage1-start
1558         @r=`${PWD_COMMAND}`; export r; \
1559         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1560         TFLAGS="$(STAGE1_TFLAGS)"; \
1561         $(HOST_EXPORTS)  \
1562         cd $(HOST_SUBDIR)/gcc && \
1563          \
1564         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1565                 CFLAGS="$(STAGE1_CFLAGS)" \
1566                 GENERATOR_CFLAGS="$(STAGE1_GENERATOR_CFLAGS)" \
1567                 CXXFLAGS="$(STAGE1_CXXFLAGS)" \
1568                 LIBCFLAGS="$(LIBCFLAGS)" \
1569                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1570                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1571                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1572                 $(EXTRA_HOST_FLAGS)  \
1573                 $(STAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1574                 TFLAGS="$(STAGE1_TFLAGS)"  \
1575                 $(TARGET-stage1-gcc)
1576
1577 maybe-clean-stage1-gcc: clean-stage1-gcc
1578 clean-stage1: clean-stage1-gcc
1579 clean-stage1-gcc:
1580         @if [ $(current_stage) = stage1 ]; then \
1581           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1582         else \
1583           [ -f $(HOST_SUBDIR)/stage1-gcc/Makefile ] || exit 0; \
1584           $(MAKE) stage1-start; \
1585         fi; \
1586         cd $(HOST_SUBDIR)/gcc && \
1587         $(MAKE) $(EXTRA_HOST_FLAGS)  \
1588         $(STAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1589 @endif gcc-bootstrap
1590
1591
1592 .PHONY: all-stage2-gcc maybe-all-stage2-gcc
1593 .PHONY: clean-stage2-gcc maybe-clean-stage2-gcc
1594 maybe-all-stage2-gcc:
1595 maybe-clean-stage2-gcc:
1596 @if gcc-bootstrap
1597 maybe-all-stage2-gcc: all-stage2-gcc
1598 all-stage2: all-stage2-gcc
1599 TARGET-stage2-gcc = $(TARGET-gcc)
1600 all-stage2-gcc: configure-stage2-gcc
1601         @[ $(current_stage) = stage2 ] || $(MAKE) stage2-start
1602         @r=`${PWD_COMMAND}`; export r; \
1603         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1604         TFLAGS="$(STAGE2_TFLAGS)"; \
1605         $(HOST_EXPORTS) \
1606         $(POSTSTAGE1_HOST_EXPORTS)  \
1607         cd $(HOST_SUBDIR)/gcc && \
1608          \
1609         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1610                 CFLAGS="$(STAGE2_CFLAGS)" \
1611                 GENERATOR_CFLAGS="$(STAGE2_GENERATOR_CFLAGS)" \
1612                 CXXFLAGS="$(STAGE2_CXXFLAGS)" \
1613                 LIBCFLAGS="$(STAGE2_CFLAGS)" \
1614                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1615                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1616                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1617                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1618                 TFLAGS="$(STAGE2_TFLAGS)"  \
1619                 $(TARGET-stage2-gcc)
1620
1621 maybe-clean-stage2-gcc: clean-stage2-gcc
1622 clean-stage2: clean-stage2-gcc
1623 clean-stage2-gcc:
1624         @if [ $(current_stage) = stage2 ]; then \
1625           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1626         else \
1627           [ -f $(HOST_SUBDIR)/stage2-gcc/Makefile ] || exit 0; \
1628           $(MAKE) stage2-start; \
1629         fi; \
1630         cd $(HOST_SUBDIR)/gcc && \
1631         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1632 @endif gcc-bootstrap
1633
1634
1635 .PHONY: all-stage3-gcc maybe-all-stage3-gcc
1636 .PHONY: clean-stage3-gcc maybe-clean-stage3-gcc
1637 maybe-all-stage3-gcc:
1638 maybe-clean-stage3-gcc:
1639 @if gcc-bootstrap
1640 maybe-all-stage3-gcc: all-stage3-gcc
1641 all-stage3: all-stage3-gcc
1642 TARGET-stage3-gcc = $(TARGET-gcc)
1643 all-stage3-gcc: configure-stage3-gcc
1644         @[ $(current_stage) = stage3 ] || $(MAKE) stage3-start
1645         @r=`${PWD_COMMAND}`; export r; \
1646         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1647         TFLAGS="$(STAGE3_TFLAGS)"; \
1648         $(HOST_EXPORTS) \
1649         $(POSTSTAGE1_HOST_EXPORTS)  \
1650         cd $(HOST_SUBDIR)/gcc && \
1651          \
1652         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1653                 CFLAGS="$(STAGE3_CFLAGS)" \
1654                 GENERATOR_CFLAGS="$(STAGE3_GENERATOR_CFLAGS)" \
1655                 CXXFLAGS="$(STAGE3_CXXFLAGS)" \
1656                 LIBCFLAGS="$(STAGE3_CFLAGS)" \
1657                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1658                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1659                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1660                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1661                 TFLAGS="$(STAGE3_TFLAGS)"  \
1662                 $(TARGET-stage3-gcc)
1663
1664 maybe-clean-stage3-gcc: clean-stage3-gcc
1665 clean-stage3: clean-stage3-gcc
1666 clean-stage3-gcc:
1667         @if [ $(current_stage) = stage3 ]; then \
1668           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1669         else \
1670           [ -f $(HOST_SUBDIR)/stage3-gcc/Makefile ] || exit 0; \
1671           $(MAKE) stage3-start; \
1672         fi; \
1673         cd $(HOST_SUBDIR)/gcc && \
1674         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1675 @endif gcc-bootstrap
1676
1677
1678 .PHONY: all-stage4-gcc maybe-all-stage4-gcc
1679 .PHONY: clean-stage4-gcc maybe-clean-stage4-gcc
1680 maybe-all-stage4-gcc:
1681 maybe-clean-stage4-gcc:
1682 @if gcc-bootstrap
1683 maybe-all-stage4-gcc: all-stage4-gcc
1684 all-stage4: all-stage4-gcc
1685 TARGET-stage4-gcc = $(TARGET-gcc)
1686 all-stage4-gcc: configure-stage4-gcc
1687         @[ $(current_stage) = stage4 ] || $(MAKE) stage4-start
1688         @r=`${PWD_COMMAND}`; export r; \
1689         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1690         TFLAGS="$(STAGE4_TFLAGS)"; \
1691         $(HOST_EXPORTS) \
1692         $(POSTSTAGE1_HOST_EXPORTS)  \
1693         cd $(HOST_SUBDIR)/gcc && \
1694          \
1695         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1696                 CFLAGS="$(STAGE4_CFLAGS)" \
1697                 GENERATOR_CFLAGS="$(STAGE4_GENERATOR_CFLAGS)" \
1698                 CXXFLAGS="$(STAGE4_CXXFLAGS)" \
1699                 LIBCFLAGS="$(STAGE4_CFLAGS)" \
1700                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1701                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1702                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1703                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1704                 TFLAGS="$(STAGE4_TFLAGS)"  \
1705                 $(TARGET-stage4-gcc)
1706
1707 maybe-clean-stage4-gcc: clean-stage4-gcc
1708 clean-stage4: clean-stage4-gcc
1709 clean-stage4-gcc:
1710         @if [ $(current_stage) = stage4 ]; then \
1711           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1712         else \
1713           [ -f $(HOST_SUBDIR)/stage4-gcc/Makefile ] || exit 0; \
1714           $(MAKE) stage4-start; \
1715         fi; \
1716         cd $(HOST_SUBDIR)/gcc && \
1717         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1718 @endif gcc-bootstrap
1719
1720
1721 .PHONY: all-stageprofile-gcc maybe-all-stageprofile-gcc
1722 .PHONY: clean-stageprofile-gcc maybe-clean-stageprofile-gcc
1723 maybe-all-stageprofile-gcc:
1724 maybe-clean-stageprofile-gcc:
1725 @if gcc-bootstrap
1726 maybe-all-stageprofile-gcc: all-stageprofile-gcc
1727 all-stageprofile: all-stageprofile-gcc
1728 TARGET-stageprofile-gcc = $(TARGET-gcc)
1729 all-stageprofile-gcc: configure-stageprofile-gcc
1730         @[ $(current_stage) = stageprofile ] || $(MAKE) stageprofile-start
1731         @r=`${PWD_COMMAND}`; export r; \
1732         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1733         TFLAGS="$(STAGEprofile_TFLAGS)"; \
1734         $(HOST_EXPORTS) \
1735         $(POSTSTAGE1_HOST_EXPORTS)  \
1736         cd $(HOST_SUBDIR)/gcc && \
1737          \
1738         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1739                 CFLAGS="$(STAGEprofile_CFLAGS)" \
1740                 GENERATOR_CFLAGS="$(STAGEprofile_GENERATOR_CFLAGS)" \
1741                 CXXFLAGS="$(STAGEprofile_CXXFLAGS)" \
1742                 LIBCFLAGS="$(STAGEprofile_CFLAGS)" \
1743                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1744                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1745                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1746                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1747                 TFLAGS="$(STAGEprofile_TFLAGS)"  \
1748                 $(TARGET-stageprofile-gcc)
1749
1750 maybe-clean-stageprofile-gcc: clean-stageprofile-gcc
1751 clean-stageprofile: clean-stageprofile-gcc
1752 clean-stageprofile-gcc:
1753         @if [ $(current_stage) = stageprofile ]; then \
1754           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1755         else \
1756           [ -f $(HOST_SUBDIR)/stageprofile-gcc/Makefile ] || exit 0; \
1757           $(MAKE) stageprofile-start; \
1758         fi; \
1759         cd $(HOST_SUBDIR)/gcc && \
1760         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1761 @endif gcc-bootstrap
1762
1763
1764 .PHONY: all-stagetrain-gcc maybe-all-stagetrain-gcc
1765 .PHONY: clean-stagetrain-gcc maybe-clean-stagetrain-gcc
1766 maybe-all-stagetrain-gcc:
1767 maybe-clean-stagetrain-gcc:
1768 @if gcc-bootstrap
1769 maybe-all-stagetrain-gcc: all-stagetrain-gcc
1770 all-stagetrain: all-stagetrain-gcc
1771 TARGET-stagetrain-gcc = $(TARGET-gcc)
1772 all-stagetrain-gcc: configure-stagetrain-gcc
1773         @[ $(current_stage) = stagetrain ] || $(MAKE) stagetrain-start
1774         @r=`${PWD_COMMAND}`; export r; \
1775         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1776         TFLAGS="$(STAGEtrain_TFLAGS)"; \
1777         $(HOST_EXPORTS) \
1778         $(POSTSTAGE1_HOST_EXPORTS)  \
1779         cd $(HOST_SUBDIR)/gcc && \
1780          \
1781         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1782                 CFLAGS="$(STAGEtrain_CFLAGS)" \
1783                 GENERATOR_CFLAGS="$(STAGEtrain_GENERATOR_CFLAGS)" \
1784                 CXXFLAGS="$(STAGEtrain_CXXFLAGS)" \
1785                 LIBCFLAGS="$(STAGEtrain_CFLAGS)" \
1786                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1787                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1788                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1789                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1790                 TFLAGS="$(STAGEtrain_TFLAGS)"  \
1791                 $(TARGET-stagetrain-gcc)
1792
1793 maybe-clean-stagetrain-gcc: clean-stagetrain-gcc
1794 clean-stagetrain: clean-stagetrain-gcc
1795 clean-stagetrain-gcc:
1796         @if [ $(current_stage) = stagetrain ]; then \
1797           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1798         else \
1799           [ -f $(HOST_SUBDIR)/stagetrain-gcc/Makefile ] || exit 0; \
1800           $(MAKE) stagetrain-start; \
1801         fi; \
1802         cd $(HOST_SUBDIR)/gcc && \
1803         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1804 @endif gcc-bootstrap
1805
1806
1807 .PHONY: all-stagefeedback-gcc maybe-all-stagefeedback-gcc
1808 .PHONY: clean-stagefeedback-gcc maybe-clean-stagefeedback-gcc
1809 maybe-all-stagefeedback-gcc:
1810 maybe-clean-stagefeedback-gcc:
1811 @if gcc-bootstrap
1812 maybe-all-stagefeedback-gcc: all-stagefeedback-gcc
1813 all-stagefeedback: all-stagefeedback-gcc
1814 TARGET-stagefeedback-gcc = $(TARGET-gcc)
1815 all-stagefeedback-gcc: configure-stagefeedback-gcc
1816         @[ $(current_stage) = stagefeedback ] || $(MAKE) stagefeedback-start
1817         @r=`${PWD_COMMAND}`; export r; \
1818         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1819         TFLAGS="$(STAGEfeedback_TFLAGS)"; \
1820         $(HOST_EXPORTS) \
1821         $(POSTSTAGE1_HOST_EXPORTS)  \
1822         cd $(HOST_SUBDIR)/gcc && \
1823          \
1824         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1825                 CFLAGS="$(STAGEfeedback_CFLAGS)" \
1826                 GENERATOR_CFLAGS="$(STAGEfeedback_GENERATOR_CFLAGS)" \
1827                 CXXFLAGS="$(STAGEfeedback_CXXFLAGS)" \
1828                 LIBCFLAGS="$(STAGEfeedback_CFLAGS)" \
1829                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1830                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1831                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1832                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1833                 TFLAGS="$(STAGEfeedback_TFLAGS)"  \
1834                 $(TARGET-stagefeedback-gcc)
1835
1836 maybe-clean-stagefeedback-gcc: clean-stagefeedback-gcc
1837 clean-stagefeedback: clean-stagefeedback-gcc
1838 clean-stagefeedback-gcc:
1839         @if [ $(current_stage) = stagefeedback ]; then \
1840           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1841         else \
1842           [ -f $(HOST_SUBDIR)/stagefeedback-gcc/Makefile ] || exit 0; \
1843           $(MAKE) stagefeedback-start; \
1844         fi; \
1845         cd $(HOST_SUBDIR)/gcc && \
1846         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1847 @endif gcc-bootstrap
1848
1849
1850 .PHONY: all-stageautoprofile-gcc maybe-all-stageautoprofile-gcc
1851 .PHONY: clean-stageautoprofile-gcc maybe-clean-stageautoprofile-gcc
1852 maybe-all-stageautoprofile-gcc:
1853 maybe-clean-stageautoprofile-gcc:
1854 @if gcc-bootstrap
1855 maybe-all-stageautoprofile-gcc: all-stageautoprofile-gcc
1856 all-stageautoprofile: all-stageautoprofile-gcc
1857 TARGET-stageautoprofile-gcc = $(TARGET-gcc)
1858 all-stageautoprofile-gcc: configure-stageautoprofile-gcc
1859         @[ $(current_stage) = stageautoprofile ] || $(MAKE) stageautoprofile-start
1860         @r=`${PWD_COMMAND}`; export r; \
1861         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1862         TFLAGS="$(STAGEautoprofile_TFLAGS)"; \
1863         $(HOST_EXPORTS) \
1864         $(POSTSTAGE1_HOST_EXPORTS)  \
1865         cd $(HOST_SUBDIR)/gcc && \
1866         $$s/gcc/config/i386/$(AUTO_PROFILE) \
1867         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1868                 CFLAGS="$(STAGEautoprofile_CFLAGS)" \
1869                 GENERATOR_CFLAGS="$(STAGEautoprofile_GENERATOR_CFLAGS)" \
1870                 CXXFLAGS="$(STAGEautoprofile_CXXFLAGS)" \
1871                 LIBCFLAGS="$(STAGEautoprofile_CFLAGS)" \
1872                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1873                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1874                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1875                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1876                 TFLAGS="$(STAGEautoprofile_TFLAGS)"  \
1877                 $(TARGET-stageautoprofile-gcc)
1878
1879 maybe-clean-stageautoprofile-gcc: clean-stageautoprofile-gcc
1880 clean-stageautoprofile: clean-stageautoprofile-gcc
1881 clean-stageautoprofile-gcc:
1882         @if [ $(current_stage) = stageautoprofile ]; then \
1883           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1884         else \
1885           [ -f $(HOST_SUBDIR)/stageautoprofile-gcc/Makefile ] || exit 0; \
1886           $(MAKE) stageautoprofile-start; \
1887         fi; \
1888         cd $(HOST_SUBDIR)/gcc && \
1889         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1890 @endif gcc-bootstrap
1891
1892
1893 .PHONY: all-stageautofeedback-gcc maybe-all-stageautofeedback-gcc
1894 .PHONY: clean-stageautofeedback-gcc maybe-clean-stageautofeedback-gcc
1895 maybe-all-stageautofeedback-gcc:
1896 maybe-clean-stageautofeedback-gcc:
1897 @if gcc-bootstrap
1898 maybe-all-stageautofeedback-gcc: all-stageautofeedback-gcc
1899 all-stageautofeedback: all-stageautofeedback-gcc
1900 TARGET-stageautofeedback-gcc = $(TARGET-gcc)
1901 all-stageautofeedback-gcc: configure-stageautofeedback-gcc
1902         @[ $(current_stage) = stageautofeedback ] || $(MAKE) stageautofeedback-start
1903         @r=`${PWD_COMMAND}`; export r; \
1904         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1905         TFLAGS="$(STAGEautofeedback_TFLAGS)"; \
1906         $(HOST_EXPORTS) \
1907         $(POSTSTAGE1_HOST_EXPORTS)  \
1908         cd $(HOST_SUBDIR)/gcc && \
1909          \
1910         $(MAKE) $(BASE_FLAGS_TO_PASS) \
1911                 CFLAGS="$(STAGEautofeedback_CFLAGS)" \
1912                 GENERATOR_CFLAGS="$(STAGEautofeedback_GENERATOR_CFLAGS)" \
1913                 CXXFLAGS="$(STAGEautofeedback_CXXFLAGS)" \
1914                 LIBCFLAGS="$(STAGEautofeedback_CFLAGS)" \
1915                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
1916                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
1917                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
1918                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) \
1919                 TFLAGS="$(STAGEautofeedback_TFLAGS)" PERF_DATA=perf.data \
1920                 $(TARGET-stageautofeedback-gcc)
1921
1922 maybe-clean-stageautofeedback-gcc: clean-stageautofeedback-gcc
1923 clean-stageautofeedback: clean-stageautofeedback-gcc
1924 clean-stageautofeedback-gcc:
1925         @if [ $(current_stage) = stageautofeedback ]; then \
1926           [ -f $(HOST_SUBDIR)/gcc/Makefile ] || exit 0; \
1927         else \
1928           [ -f $(HOST_SUBDIR)/stageautofeedback-gcc/Makefile ] || exit 0; \
1929           $(MAKE) stageautofeedback-start; \
1930         fi; \
1931         cd $(HOST_SUBDIR)/gcc && \
1932         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) clean
1933 @endif gcc-bootstrap
1934
1935
1936
1937
1938
1939 .PHONY: check-gcc maybe-check-gcc
1940 maybe-check-gcc:
1941 @if gcc
1942 maybe-check-gcc: check-gcc
1943
1944 check-gcc:
1945         @: $(MAKE); $(unstage)
1946         @r=`${PWD_COMMAND}`; export r; \
1947         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1948         $(HOST_EXPORTS) $(EXTRA_HOST_EXPORTS) \
1949         (cd $(HOST_SUBDIR)/gcc && \
1950           $(MAKE) $(FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) $(EXTRA_BOOTSTRAP_FLAGS) check)
1951
1952 @endif gcc
1953
1954 .PHONY: install-gcc maybe-install-gcc
1955 maybe-install-gcc:
1956 @if gcc
1957 maybe-install-gcc: install-gcc
1958
1959 install-gcc: installdirs
1960         @: $(MAKE); $(unstage)
1961         @r=`${PWD_COMMAND}`; export r; \
1962         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1963         $(HOST_EXPORTS) \
1964         (cd $(HOST_SUBDIR)/gcc && \
1965           $(MAKE) $(FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) install)
1966
1967 @endif gcc
1968
1969 .PHONY: install-strip-gcc maybe-install-strip-gcc
1970 maybe-install-strip-gcc:
1971 @if gcc
1972 maybe-install-strip-gcc: install-strip-gcc
1973
1974 install-strip-gcc: installdirs
1975         @: $(MAKE); $(unstage)
1976         @r=`${PWD_COMMAND}`; export r; \
1977         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1978         $(HOST_EXPORTS) \
1979         (cd $(HOST_SUBDIR)/gcc && \
1980           $(MAKE) $(FLAGS_TO_PASS) $(EXTRA_GCC_FLAGS) install-strip)
1981
1982 @endif gcc
1983
1984 # Other targets (info, dvi, pdf, etc.)
1985
1986 .PHONY: maybe-info-gcc info-gcc
1987 maybe-info-gcc:
1988 @if gcc
1989 maybe-info-gcc: info-gcc
1990
1991 info-gcc: \
1992     configure-gcc
1993         @[ -f ./gcc/Makefile ] || exit 0; \
1994         r=`${PWD_COMMAND}`; export r; \
1995         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
1996         $(HOST_EXPORTS) \
1997         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
1998           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
1999         done; \
2000         echo "Doing info in gcc"; \
2001         (cd $(HOST_SUBDIR)/gcc && \
2002           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2003                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2004                   "RANLIB=$${RANLIB}" \
2005                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2006                   info) \
2007           || exit 1
2008
2009 @endif gcc
2010
2011 .PHONY: maybe-dvi-gcc dvi-gcc
2012 maybe-dvi-gcc:
2013 @if gcc
2014 maybe-dvi-gcc: dvi-gcc
2015
2016 dvi-gcc: \
2017     configure-gcc
2018         @[ -f ./gcc/Makefile ] || exit 0; \
2019         r=`${PWD_COMMAND}`; export r; \
2020         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2021         $(HOST_EXPORTS) \
2022         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2023           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2024         done; \
2025         echo "Doing dvi in gcc"; \
2026         (cd $(HOST_SUBDIR)/gcc && \
2027           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2028                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2029                   "RANLIB=$${RANLIB}" \
2030                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2031                   dvi) \
2032           || exit 1
2033
2034 @endif gcc
2035
2036 .PHONY: maybe-pdf-gcc pdf-gcc
2037 maybe-pdf-gcc:
2038 @if gcc
2039 maybe-pdf-gcc: pdf-gcc
2040
2041 pdf-gcc: \
2042     configure-gcc
2043         @[ -f ./gcc/Makefile ] || exit 0; \
2044         r=`${PWD_COMMAND}`; export r; \
2045         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2046         $(HOST_EXPORTS) \
2047         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2048           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2049         done; \
2050         echo "Doing pdf in gcc"; \
2051         (cd $(HOST_SUBDIR)/gcc && \
2052           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2053                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2054                   "RANLIB=$${RANLIB}" \
2055                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2056                   pdf) \
2057           || exit 1
2058
2059 @endif gcc
2060
2061 .PHONY: maybe-html-gcc html-gcc
2062 maybe-html-gcc:
2063 @if gcc
2064 maybe-html-gcc: html-gcc
2065
2066 html-gcc: \
2067     configure-gcc
2068         @[ -f ./gcc/Makefile ] || exit 0; \
2069         r=`${PWD_COMMAND}`; export r; \
2070         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2071         $(HOST_EXPORTS) \
2072         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2073           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2074         done; \
2075         echo "Doing html in gcc"; \
2076         (cd $(HOST_SUBDIR)/gcc && \
2077           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2078                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2079                   "RANLIB=$${RANLIB}" \
2080                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2081                   html) \
2082           || exit 1
2083
2084 @endif gcc
2085
2086 .PHONY: maybe-TAGS-gcc TAGS-gcc
2087 maybe-TAGS-gcc:
2088 @if gcc
2089 maybe-TAGS-gcc: TAGS-gcc
2090
2091 TAGS-gcc: \
2092     configure-gcc
2093         @[ -f ./gcc/Makefile ] || exit 0; \
2094         r=`${PWD_COMMAND}`; export r; \
2095         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2096         $(HOST_EXPORTS) \
2097         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2098           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2099         done; \
2100         echo "Doing TAGS in gcc"; \
2101         (cd $(HOST_SUBDIR)/gcc && \
2102           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2103                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2104                   "RANLIB=$${RANLIB}" \
2105                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2106                   TAGS) \
2107           || exit 1
2108
2109 @endif gcc
2110
2111 .PHONY: maybe-install-info-gcc install-info-gcc
2112 maybe-install-info-gcc:
2113 @if gcc
2114 maybe-install-info-gcc: install-info-gcc
2115
2116 install-info-gcc: \
2117     configure-gcc \
2118     info-gcc
2119         @[ -f ./gcc/Makefile ] || exit 0; \
2120         r=`${PWD_COMMAND}`; export r; \
2121         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2122         $(HOST_EXPORTS) \
2123         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2124           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2125         done; \
2126         echo "Doing install-info in gcc"; \
2127         (cd $(HOST_SUBDIR)/gcc && \
2128           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2129                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2130                   "RANLIB=$${RANLIB}" \
2131                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2132                   install-info) \
2133           || exit 1
2134
2135 @endif gcc
2136
2137 .PHONY: maybe-install-dvi-gcc install-dvi-gcc
2138 maybe-install-dvi-gcc:
2139 @if gcc
2140 maybe-install-dvi-gcc: install-dvi-gcc
2141
2142 install-dvi-gcc: \
2143     configure-gcc \
2144     dvi-gcc
2145         @[ -f ./gcc/Makefile ] || exit 0; \
2146         r=`${PWD_COMMAND}`; export r; \
2147         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2148         $(HOST_EXPORTS) \
2149         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2150           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2151         done; \
2152         echo "Doing install-dvi in gcc"; \
2153         (cd $(HOST_SUBDIR)/gcc && \
2154           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2155                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2156                   "RANLIB=$${RANLIB}" \
2157                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2158                   install-dvi) \
2159           || exit 1
2160
2161 @endif gcc
2162
2163 .PHONY: maybe-install-pdf-gcc install-pdf-gcc
2164 maybe-install-pdf-gcc:
2165 @if gcc
2166 maybe-install-pdf-gcc: install-pdf-gcc
2167
2168 install-pdf-gcc: \
2169     configure-gcc \
2170     pdf-gcc
2171         @[ -f ./gcc/Makefile ] || exit 0; \
2172         r=`${PWD_COMMAND}`; export r; \
2173         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2174         $(HOST_EXPORTS) \
2175         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2176           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2177         done; \
2178         echo "Doing install-pdf in gcc"; \
2179         (cd $(HOST_SUBDIR)/gcc && \
2180           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2181                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2182                   "RANLIB=$${RANLIB}" \
2183                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2184                   install-pdf) \
2185           || exit 1
2186
2187 @endif gcc
2188
2189 .PHONY: maybe-install-html-gcc install-html-gcc
2190 maybe-install-html-gcc:
2191 @if gcc
2192 maybe-install-html-gcc: install-html-gcc
2193
2194 install-html-gcc: \
2195     configure-gcc \
2196     html-gcc
2197         @[ -f ./gcc/Makefile ] || exit 0; \
2198         r=`${PWD_COMMAND}`; export r; \
2199         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2200         $(HOST_EXPORTS) \
2201         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2202           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2203         done; \
2204         echo "Doing install-html in gcc"; \
2205         (cd $(HOST_SUBDIR)/gcc && \
2206           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2207                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2208                   "RANLIB=$${RANLIB}" \
2209                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2210                   install-html) \
2211           || exit 1
2212
2213 @endif gcc
2214
2215 .PHONY: maybe-installcheck-gcc installcheck-gcc
2216 maybe-installcheck-gcc:
2217 @if gcc
2218 maybe-installcheck-gcc: installcheck-gcc
2219
2220 installcheck-gcc: \
2221     configure-gcc
2222         @[ -f ./gcc/Makefile ] || exit 0; \
2223         r=`${PWD_COMMAND}`; export r; \
2224         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2225         $(HOST_EXPORTS) \
2226         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2227           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2228         done; \
2229         echo "Doing installcheck in gcc"; \
2230         (cd $(HOST_SUBDIR)/gcc && \
2231           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2232                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2233                   "RANLIB=$${RANLIB}" \
2234                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2235                   installcheck) \
2236           || exit 1
2237
2238 @endif gcc
2239
2240 .PHONY: maybe-mostlyclean-gcc mostlyclean-gcc
2241 maybe-mostlyclean-gcc:
2242 @if gcc
2243 maybe-mostlyclean-gcc: mostlyclean-gcc
2244
2245 mostlyclean-gcc:
2246         @[ -f ./gcc/Makefile ] || exit 0; \
2247         r=`${PWD_COMMAND}`; export r; \
2248         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2249         $(HOST_EXPORTS) \
2250         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2251           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2252         done; \
2253         echo "Doing mostlyclean in gcc"; \
2254         (cd $(HOST_SUBDIR)/gcc && \
2255           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2256                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2257                   "RANLIB=$${RANLIB}" \
2258                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2259                   mostlyclean) \
2260           || exit 1
2261
2262 @endif gcc
2263
2264 .PHONY: maybe-clean-gcc clean-gcc
2265 maybe-clean-gcc:
2266 @if gcc
2267 maybe-clean-gcc: clean-gcc
2268
2269 clean-gcc:
2270         @[ -f ./gcc/Makefile ] || exit 0; \
2271         r=`${PWD_COMMAND}`; export r; \
2272         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2273         $(HOST_EXPORTS) \
2274         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2275           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2276         done; \
2277         echo "Doing clean in gcc"; \
2278         (cd $(HOST_SUBDIR)/gcc && \
2279           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2280                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2281                   "RANLIB=$${RANLIB}" \
2282                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2283                   clean) \
2284           || exit 1
2285
2286 @endif gcc
2287
2288 .PHONY: maybe-distclean-gcc distclean-gcc
2289 maybe-distclean-gcc:
2290 @if gcc
2291 maybe-distclean-gcc: distclean-gcc
2292
2293 distclean-gcc:
2294         @[ -f ./gcc/Makefile ] || exit 0; \
2295         r=`${PWD_COMMAND}`; export r; \
2296         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2297         $(HOST_EXPORTS) \
2298         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2299           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2300         done; \
2301         echo "Doing distclean in gcc"; \
2302         (cd $(HOST_SUBDIR)/gcc && \
2303           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2304                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2305                   "RANLIB=$${RANLIB}" \
2306                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2307                   distclean) \
2308           || exit 1
2309
2310 @endif gcc
2311
2312 .PHONY: maybe-maintainer-clean-gcc maintainer-clean-gcc
2313 maybe-maintainer-clean-gcc:
2314 @if gcc
2315 maybe-maintainer-clean-gcc: maintainer-clean-gcc
2316
2317 maintainer-clean-gcc:
2318         @[ -f ./gcc/Makefile ] || exit 0; \
2319         r=`${PWD_COMMAND}`; export r; \
2320         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2321         $(HOST_EXPORTS) \
2322         for flag in $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS); do \
2323           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2324         done; \
2325         echo "Doing maintainer-clean in gcc"; \
2326         (cd $(HOST_SUBDIR)/gcc && \
2327           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2328                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2329                   "RANLIB=$${RANLIB}" \
2330                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2331                   maintainer-clean) \
2332           || exit 1
2333
2334 @endif gcc
2335
2336
2337
2338 .PHONY: configure-libbacktrace maybe-configure-libbacktrace
2339 maybe-configure-libbacktrace:
2340 @if libbacktrace
2341 maybe-configure-libbacktrace: configure-libbacktrace
2342 configure-libbacktrace:
2343         @r=`${PWD_COMMAND}`; export r; \
2344         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2345         test ! -f $(HOST_SUBDIR)/libbacktrace/Makefile || exit 0; \
2346         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)/libbacktrace; \
2347         $(HOST_EXPORTS)  \
2348         echo Configuring in $(HOST_SUBDIR)/libbacktrace; \
2349         cd "$(HOST_SUBDIR)/libbacktrace" || exit 1; \
2350         case $(srcdir) in \
2351           /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
2352           *) topdir=`echo $(HOST_SUBDIR)/libbacktrace/ | \
2353                 sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
2354         esac; \
2355         module_srcdir=libbacktrace; \
2356         $(SHELL) \
2357           $$s/$$module_srcdir/configure \
2358           --srcdir=$${topdir}/$$module_srcdir \
2359           $(HOST_CONFIGARGS) --build=${build_alias} --host=${host_alias} \
2360           --target=${target_alias}  \
2361           || exit 1
2362 @endif libbacktrace
2363
2364
2365
2366
2367 .PHONY: all-libbacktrace maybe-all-libbacktrace
2368 maybe-all-libbacktrace:
2369 @if libbacktrace
2370 TARGET-libbacktrace=all
2371 maybe-all-libbacktrace: all-libbacktrace
2372 all-libbacktrace: configure-libbacktrace
2373         @r=`${PWD_COMMAND}`; export r; \
2374         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2375         $(HOST_EXPORTS)  \
2376         (cd $(HOST_SUBDIR)/libbacktrace && \
2377           $(MAKE) $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) $(STAGE1_FLAGS_TO_PASS)  \
2378                 $(TARGET-libbacktrace))
2379 @endif libbacktrace
2380
2381
2382
2383 .PHONY: all-stage1-libbacktrace maybe-all-stage1-libbacktrace
2384 .PHONY: clean-stage1-libbacktrace maybe-clean-stage1-libbacktrace
2385 maybe-all-stage1-libbacktrace:
2386 maybe-clean-stage1-libbacktrace:
2387 @if libbacktrace-bootstrap
2388 maybe-all-stage1-libbacktrace: all-stage1-libbacktrace
2389 all-stage1: all-stage1-libbacktrace
2390 TARGET-stage1-libbacktrace = $(TARGET-libbacktrace)
2391 all-stage1-libbacktrace: configure-stage1-libbacktrace
2392         @[ $(current_stage) = stage1 ] || $(MAKE) stage1-start
2393         @r=`${PWD_COMMAND}`; export r; \
2394         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2395         TFLAGS="$(STAGE1_TFLAGS)"; \
2396         $(HOST_EXPORTS)  \
2397         cd $(HOST_SUBDIR)/libbacktrace && \
2398          \
2399         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2400                 CFLAGS="$(STAGE1_CFLAGS)" \
2401                 GENERATOR_CFLAGS="$(STAGE1_GENERATOR_CFLAGS)" \
2402                 CXXFLAGS="$(STAGE1_CXXFLAGS)" \
2403                 LIBCFLAGS="$(LIBCFLAGS)" \
2404                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2405                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2406                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2407                 $(EXTRA_HOST_FLAGS)  \
2408                 $(STAGE1_FLAGS_TO_PASS)  \
2409                 TFLAGS="$(STAGE1_TFLAGS)"  \
2410                 $(TARGET-stage1-libbacktrace)
2411
2412 maybe-clean-stage1-libbacktrace: clean-stage1-libbacktrace
2413 clean-stage1: clean-stage1-libbacktrace
2414 clean-stage1-libbacktrace:
2415         @if [ $(current_stage) = stage1 ]; then \
2416           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2417         else \
2418           [ -f $(HOST_SUBDIR)/stage1-libbacktrace/Makefile ] || exit 0; \
2419           $(MAKE) stage1-start; \
2420         fi; \
2421         cd $(HOST_SUBDIR)/libbacktrace && \
2422         $(MAKE) $(EXTRA_HOST_FLAGS)  \
2423         $(STAGE1_FLAGS_TO_PASS)  clean
2424 @endif libbacktrace-bootstrap
2425
2426
2427 .PHONY: all-stage2-libbacktrace maybe-all-stage2-libbacktrace
2428 .PHONY: clean-stage2-libbacktrace maybe-clean-stage2-libbacktrace
2429 maybe-all-stage2-libbacktrace:
2430 maybe-clean-stage2-libbacktrace:
2431 @if libbacktrace-bootstrap
2432 maybe-all-stage2-libbacktrace: all-stage2-libbacktrace
2433 all-stage2: all-stage2-libbacktrace
2434 TARGET-stage2-libbacktrace = $(TARGET-libbacktrace)
2435 all-stage2-libbacktrace: configure-stage2-libbacktrace
2436         @[ $(current_stage) = stage2 ] || $(MAKE) stage2-start
2437         @r=`${PWD_COMMAND}`; export r; \
2438         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2439         TFLAGS="$(STAGE2_TFLAGS)"; \
2440         $(HOST_EXPORTS) \
2441         $(POSTSTAGE1_HOST_EXPORTS)  \
2442         cd $(HOST_SUBDIR)/libbacktrace && \
2443          \
2444         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2445                 CFLAGS="$(STAGE2_CFLAGS)" \
2446                 GENERATOR_CFLAGS="$(STAGE2_GENERATOR_CFLAGS)" \
2447                 CXXFLAGS="$(STAGE2_CXXFLAGS)" \
2448                 LIBCFLAGS="$(STAGE2_CFLAGS)" \
2449                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2450                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2451                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2452                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2453                 TFLAGS="$(STAGE2_TFLAGS)"  \
2454                 $(TARGET-stage2-libbacktrace)
2455
2456 maybe-clean-stage2-libbacktrace: clean-stage2-libbacktrace
2457 clean-stage2: clean-stage2-libbacktrace
2458 clean-stage2-libbacktrace:
2459         @if [ $(current_stage) = stage2 ]; then \
2460           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2461         else \
2462           [ -f $(HOST_SUBDIR)/stage2-libbacktrace/Makefile ] || exit 0; \
2463           $(MAKE) stage2-start; \
2464         fi; \
2465         cd $(HOST_SUBDIR)/libbacktrace && \
2466         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2467 @endif libbacktrace-bootstrap
2468
2469
2470 .PHONY: all-stage3-libbacktrace maybe-all-stage3-libbacktrace
2471 .PHONY: clean-stage3-libbacktrace maybe-clean-stage3-libbacktrace
2472 maybe-all-stage3-libbacktrace:
2473 maybe-clean-stage3-libbacktrace:
2474 @if libbacktrace-bootstrap
2475 maybe-all-stage3-libbacktrace: all-stage3-libbacktrace
2476 all-stage3: all-stage3-libbacktrace
2477 TARGET-stage3-libbacktrace = $(TARGET-libbacktrace)
2478 all-stage3-libbacktrace: configure-stage3-libbacktrace
2479         @[ $(current_stage) = stage3 ] || $(MAKE) stage3-start
2480         @r=`${PWD_COMMAND}`; export r; \
2481         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2482         TFLAGS="$(STAGE3_TFLAGS)"; \
2483         $(HOST_EXPORTS) \
2484         $(POSTSTAGE1_HOST_EXPORTS)  \
2485         cd $(HOST_SUBDIR)/libbacktrace && \
2486          \
2487         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2488                 CFLAGS="$(STAGE3_CFLAGS)" \
2489                 GENERATOR_CFLAGS="$(STAGE3_GENERATOR_CFLAGS)" \
2490                 CXXFLAGS="$(STAGE3_CXXFLAGS)" \
2491                 LIBCFLAGS="$(STAGE3_CFLAGS)" \
2492                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2493                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2494                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2495                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2496                 TFLAGS="$(STAGE3_TFLAGS)"  \
2497                 $(TARGET-stage3-libbacktrace)
2498
2499 maybe-clean-stage3-libbacktrace: clean-stage3-libbacktrace
2500 clean-stage3: clean-stage3-libbacktrace
2501 clean-stage3-libbacktrace:
2502         @if [ $(current_stage) = stage3 ]; then \
2503           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2504         else \
2505           [ -f $(HOST_SUBDIR)/stage3-libbacktrace/Makefile ] || exit 0; \
2506           $(MAKE) stage3-start; \
2507         fi; \
2508         cd $(HOST_SUBDIR)/libbacktrace && \
2509         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2510 @endif libbacktrace-bootstrap
2511
2512
2513 .PHONY: all-stage4-libbacktrace maybe-all-stage4-libbacktrace
2514 .PHONY: clean-stage4-libbacktrace maybe-clean-stage4-libbacktrace
2515 maybe-all-stage4-libbacktrace:
2516 maybe-clean-stage4-libbacktrace:
2517 @if libbacktrace-bootstrap
2518 maybe-all-stage4-libbacktrace: all-stage4-libbacktrace
2519 all-stage4: all-stage4-libbacktrace
2520 TARGET-stage4-libbacktrace = $(TARGET-libbacktrace)
2521 all-stage4-libbacktrace: configure-stage4-libbacktrace
2522         @[ $(current_stage) = stage4 ] || $(MAKE) stage4-start
2523         @r=`${PWD_COMMAND}`; export r; \
2524         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2525         TFLAGS="$(STAGE4_TFLAGS)"; \
2526         $(HOST_EXPORTS) \
2527         $(POSTSTAGE1_HOST_EXPORTS)  \
2528         cd $(HOST_SUBDIR)/libbacktrace && \
2529          \
2530         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2531                 CFLAGS="$(STAGE4_CFLAGS)" \
2532                 GENERATOR_CFLAGS="$(STAGE4_GENERATOR_CFLAGS)" \
2533                 CXXFLAGS="$(STAGE4_CXXFLAGS)" \
2534                 LIBCFLAGS="$(STAGE4_CFLAGS)" \
2535                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2536                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2537                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2538                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2539                 TFLAGS="$(STAGE4_TFLAGS)"  \
2540                 $(TARGET-stage4-libbacktrace)
2541
2542 maybe-clean-stage4-libbacktrace: clean-stage4-libbacktrace
2543 clean-stage4: clean-stage4-libbacktrace
2544 clean-stage4-libbacktrace:
2545         @if [ $(current_stage) = stage4 ]; then \
2546           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2547         else \
2548           [ -f $(HOST_SUBDIR)/stage4-libbacktrace/Makefile ] || exit 0; \
2549           $(MAKE) stage4-start; \
2550         fi; \
2551         cd $(HOST_SUBDIR)/libbacktrace && \
2552         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2553 @endif libbacktrace-bootstrap
2554
2555
2556 .PHONY: all-stageprofile-libbacktrace maybe-all-stageprofile-libbacktrace
2557 .PHONY: clean-stageprofile-libbacktrace maybe-clean-stageprofile-libbacktrace
2558 maybe-all-stageprofile-libbacktrace:
2559 maybe-clean-stageprofile-libbacktrace:
2560 @if libbacktrace-bootstrap
2561 maybe-all-stageprofile-libbacktrace: all-stageprofile-libbacktrace
2562 all-stageprofile: all-stageprofile-libbacktrace
2563 TARGET-stageprofile-libbacktrace = $(TARGET-libbacktrace)
2564 all-stageprofile-libbacktrace: configure-stageprofile-libbacktrace
2565         @[ $(current_stage) = stageprofile ] || $(MAKE) stageprofile-start
2566         @r=`${PWD_COMMAND}`; export r; \
2567         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2568         TFLAGS="$(STAGEprofile_TFLAGS)"; \
2569         $(HOST_EXPORTS) \
2570         $(POSTSTAGE1_HOST_EXPORTS)  \
2571         cd $(HOST_SUBDIR)/libbacktrace && \
2572          \
2573         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2574                 CFLAGS="$(STAGEprofile_CFLAGS)" \
2575                 GENERATOR_CFLAGS="$(STAGEprofile_GENERATOR_CFLAGS)" \
2576                 CXXFLAGS="$(STAGEprofile_CXXFLAGS)" \
2577                 LIBCFLAGS="$(STAGEprofile_CFLAGS)" \
2578                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2579                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2580                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2581                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2582                 TFLAGS="$(STAGEprofile_TFLAGS)"  \
2583                 $(TARGET-stageprofile-libbacktrace)
2584
2585 maybe-clean-stageprofile-libbacktrace: clean-stageprofile-libbacktrace
2586 clean-stageprofile: clean-stageprofile-libbacktrace
2587 clean-stageprofile-libbacktrace:
2588         @if [ $(current_stage) = stageprofile ]; then \
2589           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2590         else \
2591           [ -f $(HOST_SUBDIR)/stageprofile-libbacktrace/Makefile ] || exit 0; \
2592           $(MAKE) stageprofile-start; \
2593         fi; \
2594         cd $(HOST_SUBDIR)/libbacktrace && \
2595         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2596 @endif libbacktrace-bootstrap
2597
2598
2599 .PHONY: all-stagetrain-libbacktrace maybe-all-stagetrain-libbacktrace
2600 .PHONY: clean-stagetrain-libbacktrace maybe-clean-stagetrain-libbacktrace
2601 maybe-all-stagetrain-libbacktrace:
2602 maybe-clean-stagetrain-libbacktrace:
2603 @if libbacktrace-bootstrap
2604 maybe-all-stagetrain-libbacktrace: all-stagetrain-libbacktrace
2605 all-stagetrain: all-stagetrain-libbacktrace
2606 TARGET-stagetrain-libbacktrace = $(TARGET-libbacktrace)
2607 all-stagetrain-libbacktrace: configure-stagetrain-libbacktrace
2608         @[ $(current_stage) = stagetrain ] || $(MAKE) stagetrain-start
2609         @r=`${PWD_COMMAND}`; export r; \
2610         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2611         TFLAGS="$(STAGEtrain_TFLAGS)"; \
2612         $(HOST_EXPORTS) \
2613         $(POSTSTAGE1_HOST_EXPORTS)  \
2614         cd $(HOST_SUBDIR)/libbacktrace && \
2615          \
2616         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2617                 CFLAGS="$(STAGEtrain_CFLAGS)" \
2618                 GENERATOR_CFLAGS="$(STAGEtrain_GENERATOR_CFLAGS)" \
2619                 CXXFLAGS="$(STAGEtrain_CXXFLAGS)" \
2620                 LIBCFLAGS="$(STAGEtrain_CFLAGS)" \
2621                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2622                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2623                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2624                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2625                 TFLAGS="$(STAGEtrain_TFLAGS)"  \
2626                 $(TARGET-stagetrain-libbacktrace)
2627
2628 maybe-clean-stagetrain-libbacktrace: clean-stagetrain-libbacktrace
2629 clean-stagetrain: clean-stagetrain-libbacktrace
2630 clean-stagetrain-libbacktrace:
2631         @if [ $(current_stage) = stagetrain ]; then \
2632           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2633         else \
2634           [ -f $(HOST_SUBDIR)/stagetrain-libbacktrace/Makefile ] || exit 0; \
2635           $(MAKE) stagetrain-start; \
2636         fi; \
2637         cd $(HOST_SUBDIR)/libbacktrace && \
2638         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2639 @endif libbacktrace-bootstrap
2640
2641
2642 .PHONY: all-stagefeedback-libbacktrace maybe-all-stagefeedback-libbacktrace
2643 .PHONY: clean-stagefeedback-libbacktrace maybe-clean-stagefeedback-libbacktrace
2644 maybe-all-stagefeedback-libbacktrace:
2645 maybe-clean-stagefeedback-libbacktrace:
2646 @if libbacktrace-bootstrap
2647 maybe-all-stagefeedback-libbacktrace: all-stagefeedback-libbacktrace
2648 all-stagefeedback: all-stagefeedback-libbacktrace
2649 TARGET-stagefeedback-libbacktrace = $(TARGET-libbacktrace)
2650 all-stagefeedback-libbacktrace: configure-stagefeedback-libbacktrace
2651         @[ $(current_stage) = stagefeedback ] || $(MAKE) stagefeedback-start
2652         @r=`${PWD_COMMAND}`; export r; \
2653         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2654         TFLAGS="$(STAGEfeedback_TFLAGS)"; \
2655         $(HOST_EXPORTS) \
2656         $(POSTSTAGE1_HOST_EXPORTS)  \
2657         cd $(HOST_SUBDIR)/libbacktrace && \
2658          \
2659         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2660                 CFLAGS="$(STAGEfeedback_CFLAGS)" \
2661                 GENERATOR_CFLAGS="$(STAGEfeedback_GENERATOR_CFLAGS)" \
2662                 CXXFLAGS="$(STAGEfeedback_CXXFLAGS)" \
2663                 LIBCFLAGS="$(STAGEfeedback_CFLAGS)" \
2664                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2665                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2666                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2667                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2668                 TFLAGS="$(STAGEfeedback_TFLAGS)"  \
2669                 $(TARGET-stagefeedback-libbacktrace)
2670
2671 maybe-clean-stagefeedback-libbacktrace: clean-stagefeedback-libbacktrace
2672 clean-stagefeedback: clean-stagefeedback-libbacktrace
2673 clean-stagefeedback-libbacktrace:
2674         @if [ $(current_stage) = stagefeedback ]; then \
2675           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2676         else \
2677           [ -f $(HOST_SUBDIR)/stagefeedback-libbacktrace/Makefile ] || exit 0; \
2678           $(MAKE) stagefeedback-start; \
2679         fi; \
2680         cd $(HOST_SUBDIR)/libbacktrace && \
2681         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2682 @endif libbacktrace-bootstrap
2683
2684
2685 .PHONY: all-stageautoprofile-libbacktrace maybe-all-stageautoprofile-libbacktrace
2686 .PHONY: clean-stageautoprofile-libbacktrace maybe-clean-stageautoprofile-libbacktrace
2687 maybe-all-stageautoprofile-libbacktrace:
2688 maybe-clean-stageautoprofile-libbacktrace:
2689 @if libbacktrace-bootstrap
2690 maybe-all-stageautoprofile-libbacktrace: all-stageautoprofile-libbacktrace
2691 all-stageautoprofile: all-stageautoprofile-libbacktrace
2692 TARGET-stageautoprofile-libbacktrace = $(TARGET-libbacktrace)
2693 all-stageautoprofile-libbacktrace: configure-stageautoprofile-libbacktrace
2694         @[ $(current_stage) = stageautoprofile ] || $(MAKE) stageautoprofile-start
2695         @r=`${PWD_COMMAND}`; export r; \
2696         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2697         TFLAGS="$(STAGEautoprofile_TFLAGS)"; \
2698         $(HOST_EXPORTS) \
2699         $(POSTSTAGE1_HOST_EXPORTS)  \
2700         cd $(HOST_SUBDIR)/libbacktrace && \
2701         $$s/gcc/config/i386/$(AUTO_PROFILE) \
2702         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2703                 CFLAGS="$(STAGEautoprofile_CFLAGS)" \
2704                 GENERATOR_CFLAGS="$(STAGEautoprofile_GENERATOR_CFLAGS)" \
2705                 CXXFLAGS="$(STAGEautoprofile_CXXFLAGS)" \
2706                 LIBCFLAGS="$(STAGEautoprofile_CFLAGS)" \
2707                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2708                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2709                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2710                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2711                 TFLAGS="$(STAGEautoprofile_TFLAGS)"  \
2712                 $(TARGET-stageautoprofile-libbacktrace)
2713
2714 maybe-clean-stageautoprofile-libbacktrace: clean-stageautoprofile-libbacktrace
2715 clean-stageautoprofile: clean-stageautoprofile-libbacktrace
2716 clean-stageautoprofile-libbacktrace:
2717         @if [ $(current_stage) = stageautoprofile ]; then \
2718           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2719         else \
2720           [ -f $(HOST_SUBDIR)/stageautoprofile-libbacktrace/Makefile ] || exit 0; \
2721           $(MAKE) stageautoprofile-start; \
2722         fi; \
2723         cd $(HOST_SUBDIR)/libbacktrace && \
2724         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2725 @endif libbacktrace-bootstrap
2726
2727
2728 .PHONY: all-stageautofeedback-libbacktrace maybe-all-stageautofeedback-libbacktrace
2729 .PHONY: clean-stageautofeedback-libbacktrace maybe-clean-stageautofeedback-libbacktrace
2730 maybe-all-stageautofeedback-libbacktrace:
2731 maybe-clean-stageautofeedback-libbacktrace:
2732 @if libbacktrace-bootstrap
2733 maybe-all-stageautofeedback-libbacktrace: all-stageautofeedback-libbacktrace
2734 all-stageautofeedback: all-stageautofeedback-libbacktrace
2735 TARGET-stageautofeedback-libbacktrace = $(TARGET-libbacktrace)
2736 all-stageautofeedback-libbacktrace: configure-stageautofeedback-libbacktrace
2737         @[ $(current_stage) = stageautofeedback ] || $(MAKE) stageautofeedback-start
2738         @r=`${PWD_COMMAND}`; export r; \
2739         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2740         TFLAGS="$(STAGEautofeedback_TFLAGS)"; \
2741         $(HOST_EXPORTS) \
2742         $(POSTSTAGE1_HOST_EXPORTS)  \
2743         cd $(HOST_SUBDIR)/libbacktrace && \
2744          \
2745         $(MAKE) $(BASE_FLAGS_TO_PASS) \
2746                 CFLAGS="$(STAGEautofeedback_CFLAGS)" \
2747                 GENERATOR_CFLAGS="$(STAGEautofeedback_GENERATOR_CFLAGS)" \
2748                 CXXFLAGS="$(STAGEautofeedback_CXXFLAGS)" \
2749                 LIBCFLAGS="$(STAGEautofeedback_CFLAGS)" \
2750                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
2751                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
2752                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
2753                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
2754                 TFLAGS="$(STAGEautofeedback_TFLAGS)" PERF_DATA=perf.data \
2755                 $(TARGET-stageautofeedback-libbacktrace)
2756
2757 maybe-clean-stageautofeedback-libbacktrace: clean-stageautofeedback-libbacktrace
2758 clean-stageautofeedback: clean-stageautofeedback-libbacktrace
2759 clean-stageautofeedback-libbacktrace:
2760         @if [ $(current_stage) = stageautofeedback ]; then \
2761           [ -f $(HOST_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
2762         else \
2763           [ -f $(HOST_SUBDIR)/stageautofeedback-libbacktrace/Makefile ] || exit 0; \
2764           $(MAKE) stageautofeedback-start; \
2765         fi; \
2766         cd $(HOST_SUBDIR)/libbacktrace && \
2767         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
2768 @endif libbacktrace-bootstrap
2769
2770
2771
2772
2773
2774 .PHONY: check-libbacktrace maybe-check-libbacktrace
2775 maybe-check-libbacktrace:
2776 @if libbacktrace
2777 maybe-check-libbacktrace: check-libbacktrace
2778
2779 check-libbacktrace:
2780         @: $(MAKE); $(unstage)
2781         @r=`${PWD_COMMAND}`; export r; \
2782         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2783         $(HOST_EXPORTS) $(EXTRA_HOST_EXPORTS) \
2784         (cd $(HOST_SUBDIR)/libbacktrace && \
2785           $(MAKE) $(FLAGS_TO_PASS)  $(EXTRA_BOOTSTRAP_FLAGS) check)
2786
2787 @endif libbacktrace
2788
2789 .PHONY: install-libbacktrace maybe-install-libbacktrace
2790 maybe-install-libbacktrace:
2791 @if libbacktrace
2792 maybe-install-libbacktrace: install-libbacktrace
2793
2794 install-libbacktrace: installdirs
2795         @: $(MAKE); $(unstage)
2796         @r=`${PWD_COMMAND}`; export r; \
2797         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2798         $(HOST_EXPORTS) \
2799         (cd $(HOST_SUBDIR)/libbacktrace && \
2800           $(MAKE) $(FLAGS_TO_PASS)  install)
2801
2802 @endif libbacktrace
2803
2804 .PHONY: install-strip-libbacktrace maybe-install-strip-libbacktrace
2805 maybe-install-strip-libbacktrace:
2806 @if libbacktrace
2807 maybe-install-strip-libbacktrace: install-strip-libbacktrace
2808
2809 install-strip-libbacktrace: installdirs
2810         @: $(MAKE); $(unstage)
2811         @r=`${PWD_COMMAND}`; export r; \
2812         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2813         $(HOST_EXPORTS) \
2814         (cd $(HOST_SUBDIR)/libbacktrace && \
2815           $(MAKE) $(FLAGS_TO_PASS)  install-strip)
2816
2817 @endif libbacktrace
2818
2819 # Other targets (info, dvi, pdf, etc.)
2820
2821 .PHONY: maybe-info-libbacktrace info-libbacktrace
2822 maybe-info-libbacktrace:
2823 @if libbacktrace
2824 maybe-info-libbacktrace: info-libbacktrace
2825
2826 info-libbacktrace: \
2827     configure-libbacktrace
2828         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2829         r=`${PWD_COMMAND}`; export r; \
2830         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2831         $(HOST_EXPORTS) \
2832         for flag in $(EXTRA_HOST_FLAGS) ; do \
2833           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2834         done; \
2835         echo "Doing info in libbacktrace"; \
2836         (cd $(HOST_SUBDIR)/libbacktrace && \
2837           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2838                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2839                   "RANLIB=$${RANLIB}" \
2840                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2841                   info) \
2842           || exit 1
2843
2844 @endif libbacktrace
2845
2846 .PHONY: maybe-dvi-libbacktrace dvi-libbacktrace
2847 maybe-dvi-libbacktrace:
2848 @if libbacktrace
2849 maybe-dvi-libbacktrace: dvi-libbacktrace
2850
2851 dvi-libbacktrace: \
2852     configure-libbacktrace
2853         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2854         r=`${PWD_COMMAND}`; export r; \
2855         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2856         $(HOST_EXPORTS) \
2857         for flag in $(EXTRA_HOST_FLAGS) ; do \
2858           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2859         done; \
2860         echo "Doing dvi in libbacktrace"; \
2861         (cd $(HOST_SUBDIR)/libbacktrace && \
2862           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2863                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2864                   "RANLIB=$${RANLIB}" \
2865                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2866                   dvi) \
2867           || exit 1
2868
2869 @endif libbacktrace
2870
2871 .PHONY: maybe-pdf-libbacktrace pdf-libbacktrace
2872 maybe-pdf-libbacktrace:
2873 @if libbacktrace
2874 maybe-pdf-libbacktrace: pdf-libbacktrace
2875
2876 pdf-libbacktrace: \
2877     configure-libbacktrace
2878         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2879         r=`${PWD_COMMAND}`; export r; \
2880         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2881         $(HOST_EXPORTS) \
2882         for flag in $(EXTRA_HOST_FLAGS) ; do \
2883           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2884         done; \
2885         echo "Doing pdf in libbacktrace"; \
2886         (cd $(HOST_SUBDIR)/libbacktrace && \
2887           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2888                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2889                   "RANLIB=$${RANLIB}" \
2890                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2891                   pdf) \
2892           || exit 1
2893
2894 @endif libbacktrace
2895
2896 .PHONY: maybe-html-libbacktrace html-libbacktrace
2897 maybe-html-libbacktrace:
2898 @if libbacktrace
2899 maybe-html-libbacktrace: html-libbacktrace
2900
2901 html-libbacktrace: \
2902     configure-libbacktrace
2903         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2904         r=`${PWD_COMMAND}`; export r; \
2905         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2906         $(HOST_EXPORTS) \
2907         for flag in $(EXTRA_HOST_FLAGS) ; do \
2908           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2909         done; \
2910         echo "Doing html in libbacktrace"; \
2911         (cd $(HOST_SUBDIR)/libbacktrace && \
2912           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2913                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2914                   "RANLIB=$${RANLIB}" \
2915                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2916                   html) \
2917           || exit 1
2918
2919 @endif libbacktrace
2920
2921 .PHONY: maybe-TAGS-libbacktrace TAGS-libbacktrace
2922 maybe-TAGS-libbacktrace:
2923 @if libbacktrace
2924 maybe-TAGS-libbacktrace: TAGS-libbacktrace
2925
2926 TAGS-libbacktrace: \
2927     configure-libbacktrace
2928         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2929         r=`${PWD_COMMAND}`; export r; \
2930         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2931         $(HOST_EXPORTS) \
2932         for flag in $(EXTRA_HOST_FLAGS) ; do \
2933           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2934         done; \
2935         echo "Doing TAGS in libbacktrace"; \
2936         (cd $(HOST_SUBDIR)/libbacktrace && \
2937           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2938                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2939                   "RANLIB=$${RANLIB}" \
2940                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2941                   TAGS) \
2942           || exit 1
2943
2944 @endif libbacktrace
2945
2946 .PHONY: maybe-install-info-libbacktrace install-info-libbacktrace
2947 maybe-install-info-libbacktrace:
2948 @if libbacktrace
2949 maybe-install-info-libbacktrace: install-info-libbacktrace
2950
2951 install-info-libbacktrace: \
2952     configure-libbacktrace \
2953     info-libbacktrace
2954         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2955         r=`${PWD_COMMAND}`; export r; \
2956         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2957         $(HOST_EXPORTS) \
2958         for flag in $(EXTRA_HOST_FLAGS) ; do \
2959           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2960         done; \
2961         echo "Doing install-info in libbacktrace"; \
2962         (cd $(HOST_SUBDIR)/libbacktrace && \
2963           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2964                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2965                   "RANLIB=$${RANLIB}" \
2966                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2967                   install-info) \
2968           || exit 1
2969
2970 @endif libbacktrace
2971
2972 .PHONY: maybe-install-dvi-libbacktrace install-dvi-libbacktrace
2973 maybe-install-dvi-libbacktrace:
2974 @if libbacktrace
2975 maybe-install-dvi-libbacktrace: install-dvi-libbacktrace
2976
2977 install-dvi-libbacktrace: \
2978     configure-libbacktrace \
2979     dvi-libbacktrace
2980         @[ -f ./libbacktrace/Makefile ] || exit 0; \
2981         r=`${PWD_COMMAND}`; export r; \
2982         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
2983         $(HOST_EXPORTS) \
2984         for flag in $(EXTRA_HOST_FLAGS) ; do \
2985           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
2986         done; \
2987         echo "Doing install-dvi in libbacktrace"; \
2988         (cd $(HOST_SUBDIR)/libbacktrace && \
2989           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
2990                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
2991                   "RANLIB=$${RANLIB}" \
2992                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
2993                   install-dvi) \
2994           || exit 1
2995
2996 @endif libbacktrace
2997
2998 .PHONY: maybe-install-pdf-libbacktrace install-pdf-libbacktrace
2999 maybe-install-pdf-libbacktrace:
3000 @if libbacktrace
3001 maybe-install-pdf-libbacktrace: install-pdf-libbacktrace
3002
3003 install-pdf-libbacktrace: \
3004     configure-libbacktrace \
3005     pdf-libbacktrace
3006         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3007         r=`${PWD_COMMAND}`; export r; \
3008         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3009         $(HOST_EXPORTS) \
3010         for flag in $(EXTRA_HOST_FLAGS) ; do \
3011           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3012         done; \
3013         echo "Doing install-pdf in libbacktrace"; \
3014         (cd $(HOST_SUBDIR)/libbacktrace && \
3015           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3016                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3017                   "RANLIB=$${RANLIB}" \
3018                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3019                   install-pdf) \
3020           || exit 1
3021
3022 @endif libbacktrace
3023
3024 .PHONY: maybe-install-html-libbacktrace install-html-libbacktrace
3025 maybe-install-html-libbacktrace:
3026 @if libbacktrace
3027 maybe-install-html-libbacktrace: install-html-libbacktrace
3028
3029 install-html-libbacktrace: \
3030     configure-libbacktrace \
3031     html-libbacktrace
3032         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3033         r=`${PWD_COMMAND}`; export r; \
3034         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3035         $(HOST_EXPORTS) \
3036         for flag in $(EXTRA_HOST_FLAGS) ; do \
3037           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3038         done; \
3039         echo "Doing install-html in libbacktrace"; \
3040         (cd $(HOST_SUBDIR)/libbacktrace && \
3041           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3042                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3043                   "RANLIB=$${RANLIB}" \
3044                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3045                   install-html) \
3046           || exit 1
3047
3048 @endif libbacktrace
3049
3050 .PHONY: maybe-installcheck-libbacktrace installcheck-libbacktrace
3051 maybe-installcheck-libbacktrace:
3052 @if libbacktrace
3053 maybe-installcheck-libbacktrace: installcheck-libbacktrace
3054
3055 installcheck-libbacktrace: \
3056     configure-libbacktrace
3057         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3058         r=`${PWD_COMMAND}`; export r; \
3059         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3060         $(HOST_EXPORTS) \
3061         for flag in $(EXTRA_HOST_FLAGS) ; do \
3062           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3063         done; \
3064         echo "Doing installcheck in libbacktrace"; \
3065         (cd $(HOST_SUBDIR)/libbacktrace && \
3066           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3067                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3068                   "RANLIB=$${RANLIB}" \
3069                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3070                   installcheck) \
3071           || exit 1
3072
3073 @endif libbacktrace
3074
3075 .PHONY: maybe-mostlyclean-libbacktrace mostlyclean-libbacktrace
3076 maybe-mostlyclean-libbacktrace:
3077 @if libbacktrace
3078 maybe-mostlyclean-libbacktrace: mostlyclean-libbacktrace
3079
3080 mostlyclean-libbacktrace:
3081         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3082         r=`${PWD_COMMAND}`; export r; \
3083         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3084         $(HOST_EXPORTS) \
3085         for flag in $(EXTRA_HOST_FLAGS) ; do \
3086           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3087         done; \
3088         echo "Doing mostlyclean in libbacktrace"; \
3089         (cd $(HOST_SUBDIR)/libbacktrace && \
3090           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3091                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3092                   "RANLIB=$${RANLIB}" \
3093                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3094                   mostlyclean) \
3095           || exit 1
3096
3097 @endif libbacktrace
3098
3099 .PHONY: maybe-clean-libbacktrace clean-libbacktrace
3100 maybe-clean-libbacktrace:
3101 @if libbacktrace
3102 maybe-clean-libbacktrace: clean-libbacktrace
3103
3104 clean-libbacktrace:
3105         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3106         r=`${PWD_COMMAND}`; export r; \
3107         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3108         $(HOST_EXPORTS) \
3109         for flag in $(EXTRA_HOST_FLAGS) ; do \
3110           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3111         done; \
3112         echo "Doing clean in libbacktrace"; \
3113         (cd $(HOST_SUBDIR)/libbacktrace && \
3114           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3115                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3116                   "RANLIB=$${RANLIB}" \
3117                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3118                   clean) \
3119           || exit 1
3120
3121 @endif libbacktrace
3122
3123 .PHONY: maybe-distclean-libbacktrace distclean-libbacktrace
3124 maybe-distclean-libbacktrace:
3125 @if libbacktrace
3126 maybe-distclean-libbacktrace: distclean-libbacktrace
3127
3128 distclean-libbacktrace:
3129         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3130         r=`${PWD_COMMAND}`; export r; \
3131         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3132         $(HOST_EXPORTS) \
3133         for flag in $(EXTRA_HOST_FLAGS) ; do \
3134           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3135         done; \
3136         echo "Doing distclean in libbacktrace"; \
3137         (cd $(HOST_SUBDIR)/libbacktrace && \
3138           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3139                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3140                   "RANLIB=$${RANLIB}" \
3141                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3142                   distclean) \
3143           || exit 1
3144
3145 @endif libbacktrace
3146
3147 .PHONY: maybe-maintainer-clean-libbacktrace maintainer-clean-libbacktrace
3148 maybe-maintainer-clean-libbacktrace:
3149 @if libbacktrace
3150 maybe-maintainer-clean-libbacktrace: maintainer-clean-libbacktrace
3151
3152 maintainer-clean-libbacktrace:
3153         @[ -f ./libbacktrace/Makefile ] || exit 0; \
3154         r=`${PWD_COMMAND}`; export r; \
3155         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3156         $(HOST_EXPORTS) \
3157         for flag in $(EXTRA_HOST_FLAGS) ; do \
3158           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3159         done; \
3160         echo "Doing maintainer-clean in libbacktrace"; \
3161         (cd $(HOST_SUBDIR)/libbacktrace && \
3162           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3163                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3164                   "RANLIB=$${RANLIB}" \
3165                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3166                   maintainer-clean) \
3167           || exit 1
3168
3169 @endif libbacktrace
3170
3171
3172
3173 .PHONY: configure-libcpp maybe-configure-libcpp
3174 maybe-configure-libcpp:
3175 @if libcpp
3176 maybe-configure-libcpp: configure-libcpp
3177 configure-libcpp:
3178         @r=`${PWD_COMMAND}`; export r; \
3179         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3180         test ! -f $(HOST_SUBDIR)/libcpp/Makefile || exit 0; \
3181         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)/libcpp; \
3182         $(HOST_EXPORTS)  \
3183         echo Configuring in $(HOST_SUBDIR)/libcpp; \
3184         cd "$(HOST_SUBDIR)/libcpp" || exit 1; \
3185         case $(srcdir) in \
3186           /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
3187           *) topdir=`echo $(HOST_SUBDIR)/libcpp/ | \
3188                 sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
3189         esac; \
3190         module_srcdir=libcpp; \
3191         $(SHELL) \
3192           $$s/$$module_srcdir/configure \
3193           --srcdir=$${topdir}/$$module_srcdir \
3194           $(HOST_CONFIGARGS) --build=${build_alias} --host=${host_alias} \
3195           --target=${target_alias}  \
3196           || exit 1
3197 @endif libcpp
3198
3199
3200
3201
3202 .PHONY: all-libcpp maybe-all-libcpp
3203 maybe-all-libcpp:
3204 @if libcpp
3205 TARGET-libcpp=all
3206 maybe-all-libcpp: all-libcpp
3207 all-libcpp: configure-libcpp
3208         @r=`${PWD_COMMAND}`; export r; \
3209         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3210         $(HOST_EXPORTS)  \
3211         (cd $(HOST_SUBDIR)/libcpp && \
3212           $(MAKE) $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) $(STAGE1_FLAGS_TO_PASS)  \
3213                 $(TARGET-libcpp))
3214 @endif libcpp
3215
3216
3217
3218 .PHONY: all-stage1-libcpp maybe-all-stage1-libcpp
3219 .PHONY: clean-stage1-libcpp maybe-clean-stage1-libcpp
3220 maybe-all-stage1-libcpp:
3221 maybe-clean-stage1-libcpp:
3222 @if libcpp-bootstrap
3223 maybe-all-stage1-libcpp: all-stage1-libcpp
3224 all-stage1: all-stage1-libcpp
3225 TARGET-stage1-libcpp = $(TARGET-libcpp)
3226 all-stage1-libcpp: configure-stage1-libcpp
3227         @[ $(current_stage) = stage1 ] || $(MAKE) stage1-start
3228         @r=`${PWD_COMMAND}`; export r; \
3229         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3230         TFLAGS="$(STAGE1_TFLAGS)"; \
3231         $(HOST_EXPORTS)  \
3232         cd $(HOST_SUBDIR)/libcpp && \
3233          \
3234         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3235                 CFLAGS="$(STAGE1_CFLAGS)" \
3236                 GENERATOR_CFLAGS="$(STAGE1_GENERATOR_CFLAGS)" \
3237                 CXXFLAGS="$(STAGE1_CXXFLAGS)" \
3238                 LIBCFLAGS="$(LIBCFLAGS)" \
3239                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3240                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3241                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3242                 $(EXTRA_HOST_FLAGS)  \
3243                 $(STAGE1_FLAGS_TO_PASS)  \
3244                 TFLAGS="$(STAGE1_TFLAGS)"  \
3245                 $(TARGET-stage1-libcpp)
3246
3247 maybe-clean-stage1-libcpp: clean-stage1-libcpp
3248 clean-stage1: clean-stage1-libcpp
3249 clean-stage1-libcpp:
3250         @if [ $(current_stage) = stage1 ]; then \
3251           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3252         else \
3253           [ -f $(HOST_SUBDIR)/stage1-libcpp/Makefile ] || exit 0; \
3254           $(MAKE) stage1-start; \
3255         fi; \
3256         cd $(HOST_SUBDIR)/libcpp && \
3257         $(MAKE) $(EXTRA_HOST_FLAGS)  \
3258         $(STAGE1_FLAGS_TO_PASS)  clean
3259 @endif libcpp-bootstrap
3260
3261
3262 .PHONY: all-stage2-libcpp maybe-all-stage2-libcpp
3263 .PHONY: clean-stage2-libcpp maybe-clean-stage2-libcpp
3264 maybe-all-stage2-libcpp:
3265 maybe-clean-stage2-libcpp:
3266 @if libcpp-bootstrap
3267 maybe-all-stage2-libcpp: all-stage2-libcpp
3268 all-stage2: all-stage2-libcpp
3269 TARGET-stage2-libcpp = $(TARGET-libcpp)
3270 all-stage2-libcpp: configure-stage2-libcpp
3271         @[ $(current_stage) = stage2 ] || $(MAKE) stage2-start
3272         @r=`${PWD_COMMAND}`; export r; \
3273         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3274         TFLAGS="$(STAGE2_TFLAGS)"; \
3275         $(HOST_EXPORTS) \
3276         $(POSTSTAGE1_HOST_EXPORTS)  \
3277         cd $(HOST_SUBDIR)/libcpp && \
3278          \
3279         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3280                 CFLAGS="$(STAGE2_CFLAGS)" \
3281                 GENERATOR_CFLAGS="$(STAGE2_GENERATOR_CFLAGS)" \
3282                 CXXFLAGS="$(STAGE2_CXXFLAGS)" \
3283                 LIBCFLAGS="$(STAGE2_CFLAGS)" \
3284                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3285                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3286                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3287                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3288                 TFLAGS="$(STAGE2_TFLAGS)"  \
3289                 $(TARGET-stage2-libcpp)
3290
3291 maybe-clean-stage2-libcpp: clean-stage2-libcpp
3292 clean-stage2: clean-stage2-libcpp
3293 clean-stage2-libcpp:
3294         @if [ $(current_stage) = stage2 ]; then \
3295           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3296         else \
3297           [ -f $(HOST_SUBDIR)/stage2-libcpp/Makefile ] || exit 0; \
3298           $(MAKE) stage2-start; \
3299         fi; \
3300         cd $(HOST_SUBDIR)/libcpp && \
3301         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3302 @endif libcpp-bootstrap
3303
3304
3305 .PHONY: all-stage3-libcpp maybe-all-stage3-libcpp
3306 .PHONY: clean-stage3-libcpp maybe-clean-stage3-libcpp
3307 maybe-all-stage3-libcpp:
3308 maybe-clean-stage3-libcpp:
3309 @if libcpp-bootstrap
3310 maybe-all-stage3-libcpp: all-stage3-libcpp
3311 all-stage3: all-stage3-libcpp
3312 TARGET-stage3-libcpp = $(TARGET-libcpp)
3313 all-stage3-libcpp: configure-stage3-libcpp
3314         @[ $(current_stage) = stage3 ] || $(MAKE) stage3-start
3315         @r=`${PWD_COMMAND}`; export r; \
3316         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3317         TFLAGS="$(STAGE3_TFLAGS)"; \
3318         $(HOST_EXPORTS) \
3319         $(POSTSTAGE1_HOST_EXPORTS)  \
3320         cd $(HOST_SUBDIR)/libcpp && \
3321          \
3322         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3323                 CFLAGS="$(STAGE3_CFLAGS)" \
3324                 GENERATOR_CFLAGS="$(STAGE3_GENERATOR_CFLAGS)" \
3325                 CXXFLAGS="$(STAGE3_CXXFLAGS)" \
3326                 LIBCFLAGS="$(STAGE3_CFLAGS)" \
3327                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3328                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3329                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3330                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3331                 TFLAGS="$(STAGE3_TFLAGS)"  \
3332                 $(TARGET-stage3-libcpp)
3333
3334 maybe-clean-stage3-libcpp: clean-stage3-libcpp
3335 clean-stage3: clean-stage3-libcpp
3336 clean-stage3-libcpp:
3337         @if [ $(current_stage) = stage3 ]; then \
3338           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3339         else \
3340           [ -f $(HOST_SUBDIR)/stage3-libcpp/Makefile ] || exit 0; \
3341           $(MAKE) stage3-start; \
3342         fi; \
3343         cd $(HOST_SUBDIR)/libcpp && \
3344         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3345 @endif libcpp-bootstrap
3346
3347
3348 .PHONY: all-stage4-libcpp maybe-all-stage4-libcpp
3349 .PHONY: clean-stage4-libcpp maybe-clean-stage4-libcpp
3350 maybe-all-stage4-libcpp:
3351 maybe-clean-stage4-libcpp:
3352 @if libcpp-bootstrap
3353 maybe-all-stage4-libcpp: all-stage4-libcpp
3354 all-stage4: all-stage4-libcpp
3355 TARGET-stage4-libcpp = $(TARGET-libcpp)
3356 all-stage4-libcpp: configure-stage4-libcpp
3357         @[ $(current_stage) = stage4 ] || $(MAKE) stage4-start
3358         @r=`${PWD_COMMAND}`; export r; \
3359         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3360         TFLAGS="$(STAGE4_TFLAGS)"; \
3361         $(HOST_EXPORTS) \
3362         $(POSTSTAGE1_HOST_EXPORTS)  \
3363         cd $(HOST_SUBDIR)/libcpp && \
3364          \
3365         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3366                 CFLAGS="$(STAGE4_CFLAGS)" \
3367                 GENERATOR_CFLAGS="$(STAGE4_GENERATOR_CFLAGS)" \
3368                 CXXFLAGS="$(STAGE4_CXXFLAGS)" \
3369                 LIBCFLAGS="$(STAGE4_CFLAGS)" \
3370                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3371                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3372                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3373                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3374                 TFLAGS="$(STAGE4_TFLAGS)"  \
3375                 $(TARGET-stage4-libcpp)
3376
3377 maybe-clean-stage4-libcpp: clean-stage4-libcpp
3378 clean-stage4: clean-stage4-libcpp
3379 clean-stage4-libcpp:
3380         @if [ $(current_stage) = stage4 ]; then \
3381           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3382         else \
3383           [ -f $(HOST_SUBDIR)/stage4-libcpp/Makefile ] || exit 0; \
3384           $(MAKE) stage4-start; \
3385         fi; \
3386         cd $(HOST_SUBDIR)/libcpp && \
3387         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3388 @endif libcpp-bootstrap
3389
3390
3391 .PHONY: all-stageprofile-libcpp maybe-all-stageprofile-libcpp
3392 .PHONY: clean-stageprofile-libcpp maybe-clean-stageprofile-libcpp
3393 maybe-all-stageprofile-libcpp:
3394 maybe-clean-stageprofile-libcpp:
3395 @if libcpp-bootstrap
3396 maybe-all-stageprofile-libcpp: all-stageprofile-libcpp
3397 all-stageprofile: all-stageprofile-libcpp
3398 TARGET-stageprofile-libcpp = $(TARGET-libcpp)
3399 all-stageprofile-libcpp: configure-stageprofile-libcpp
3400         @[ $(current_stage) = stageprofile ] || $(MAKE) stageprofile-start
3401         @r=`${PWD_COMMAND}`; export r; \
3402         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3403         TFLAGS="$(STAGEprofile_TFLAGS)"; \
3404         $(HOST_EXPORTS) \
3405         $(POSTSTAGE1_HOST_EXPORTS)  \
3406         cd $(HOST_SUBDIR)/libcpp && \
3407          \
3408         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3409                 CFLAGS="$(STAGEprofile_CFLAGS)" \
3410                 GENERATOR_CFLAGS="$(STAGEprofile_GENERATOR_CFLAGS)" \
3411                 CXXFLAGS="$(STAGEprofile_CXXFLAGS)" \
3412                 LIBCFLAGS="$(STAGEprofile_CFLAGS)" \
3413                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3414                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3415                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3416                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3417                 TFLAGS="$(STAGEprofile_TFLAGS)"  \
3418                 $(TARGET-stageprofile-libcpp)
3419
3420 maybe-clean-stageprofile-libcpp: clean-stageprofile-libcpp
3421 clean-stageprofile: clean-stageprofile-libcpp
3422 clean-stageprofile-libcpp:
3423         @if [ $(current_stage) = stageprofile ]; then \
3424           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3425         else \
3426           [ -f $(HOST_SUBDIR)/stageprofile-libcpp/Makefile ] || exit 0; \
3427           $(MAKE) stageprofile-start; \
3428         fi; \
3429         cd $(HOST_SUBDIR)/libcpp && \
3430         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3431 @endif libcpp-bootstrap
3432
3433
3434 .PHONY: all-stagetrain-libcpp maybe-all-stagetrain-libcpp
3435 .PHONY: clean-stagetrain-libcpp maybe-clean-stagetrain-libcpp
3436 maybe-all-stagetrain-libcpp:
3437 maybe-clean-stagetrain-libcpp:
3438 @if libcpp-bootstrap
3439 maybe-all-stagetrain-libcpp: all-stagetrain-libcpp
3440 all-stagetrain: all-stagetrain-libcpp
3441 TARGET-stagetrain-libcpp = $(TARGET-libcpp)
3442 all-stagetrain-libcpp: configure-stagetrain-libcpp
3443         @[ $(current_stage) = stagetrain ] || $(MAKE) stagetrain-start
3444         @r=`${PWD_COMMAND}`; export r; \
3445         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3446         TFLAGS="$(STAGEtrain_TFLAGS)"; \
3447         $(HOST_EXPORTS) \
3448         $(POSTSTAGE1_HOST_EXPORTS)  \
3449         cd $(HOST_SUBDIR)/libcpp && \
3450          \
3451         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3452                 CFLAGS="$(STAGEtrain_CFLAGS)" \
3453                 GENERATOR_CFLAGS="$(STAGEtrain_GENERATOR_CFLAGS)" \
3454                 CXXFLAGS="$(STAGEtrain_CXXFLAGS)" \
3455                 LIBCFLAGS="$(STAGEtrain_CFLAGS)" \
3456                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3457                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3458                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3459                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3460                 TFLAGS="$(STAGEtrain_TFLAGS)"  \
3461                 $(TARGET-stagetrain-libcpp)
3462
3463 maybe-clean-stagetrain-libcpp: clean-stagetrain-libcpp
3464 clean-stagetrain: clean-stagetrain-libcpp
3465 clean-stagetrain-libcpp:
3466         @if [ $(current_stage) = stagetrain ]; then \
3467           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3468         else \
3469           [ -f $(HOST_SUBDIR)/stagetrain-libcpp/Makefile ] || exit 0; \
3470           $(MAKE) stagetrain-start; \
3471         fi; \
3472         cd $(HOST_SUBDIR)/libcpp && \
3473         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3474 @endif libcpp-bootstrap
3475
3476
3477 .PHONY: all-stagefeedback-libcpp maybe-all-stagefeedback-libcpp
3478 .PHONY: clean-stagefeedback-libcpp maybe-clean-stagefeedback-libcpp
3479 maybe-all-stagefeedback-libcpp:
3480 maybe-clean-stagefeedback-libcpp:
3481 @if libcpp-bootstrap
3482 maybe-all-stagefeedback-libcpp: all-stagefeedback-libcpp
3483 all-stagefeedback: all-stagefeedback-libcpp
3484 TARGET-stagefeedback-libcpp = $(TARGET-libcpp)
3485 all-stagefeedback-libcpp: configure-stagefeedback-libcpp
3486         @[ $(current_stage) = stagefeedback ] || $(MAKE) stagefeedback-start
3487         @r=`${PWD_COMMAND}`; export r; \
3488         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3489         TFLAGS="$(STAGEfeedback_TFLAGS)"; \
3490         $(HOST_EXPORTS) \
3491         $(POSTSTAGE1_HOST_EXPORTS)  \
3492         cd $(HOST_SUBDIR)/libcpp && \
3493          \
3494         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3495                 CFLAGS="$(STAGEfeedback_CFLAGS)" \
3496                 GENERATOR_CFLAGS="$(STAGEfeedback_GENERATOR_CFLAGS)" \
3497                 CXXFLAGS="$(STAGEfeedback_CXXFLAGS)" \
3498                 LIBCFLAGS="$(STAGEfeedback_CFLAGS)" \
3499                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3500                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3501                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3502                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3503                 TFLAGS="$(STAGEfeedback_TFLAGS)"  \
3504                 $(TARGET-stagefeedback-libcpp)
3505
3506 maybe-clean-stagefeedback-libcpp: clean-stagefeedback-libcpp
3507 clean-stagefeedback: clean-stagefeedback-libcpp
3508 clean-stagefeedback-libcpp:
3509         @if [ $(current_stage) = stagefeedback ]; then \
3510           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3511         else \
3512           [ -f $(HOST_SUBDIR)/stagefeedback-libcpp/Makefile ] || exit 0; \
3513           $(MAKE) stagefeedback-start; \
3514         fi; \
3515         cd $(HOST_SUBDIR)/libcpp && \
3516         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3517 @endif libcpp-bootstrap
3518
3519
3520 .PHONY: all-stageautoprofile-libcpp maybe-all-stageautoprofile-libcpp
3521 .PHONY: clean-stageautoprofile-libcpp maybe-clean-stageautoprofile-libcpp
3522 maybe-all-stageautoprofile-libcpp:
3523 maybe-clean-stageautoprofile-libcpp:
3524 @if libcpp-bootstrap
3525 maybe-all-stageautoprofile-libcpp: all-stageautoprofile-libcpp
3526 all-stageautoprofile: all-stageautoprofile-libcpp
3527 TARGET-stageautoprofile-libcpp = $(TARGET-libcpp)
3528 all-stageautoprofile-libcpp: configure-stageautoprofile-libcpp
3529         @[ $(current_stage) = stageautoprofile ] || $(MAKE) stageautoprofile-start
3530         @r=`${PWD_COMMAND}`; export r; \
3531         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3532         TFLAGS="$(STAGEautoprofile_TFLAGS)"; \
3533         $(HOST_EXPORTS) \
3534         $(POSTSTAGE1_HOST_EXPORTS)  \
3535         cd $(HOST_SUBDIR)/libcpp && \
3536         $$s/gcc/config/i386/$(AUTO_PROFILE) \
3537         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3538                 CFLAGS="$(STAGEautoprofile_CFLAGS)" \
3539                 GENERATOR_CFLAGS="$(STAGEautoprofile_GENERATOR_CFLAGS)" \
3540                 CXXFLAGS="$(STAGEautoprofile_CXXFLAGS)" \
3541                 LIBCFLAGS="$(STAGEautoprofile_CFLAGS)" \
3542                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3543                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3544                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3545                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3546                 TFLAGS="$(STAGEautoprofile_TFLAGS)"  \
3547                 $(TARGET-stageautoprofile-libcpp)
3548
3549 maybe-clean-stageautoprofile-libcpp: clean-stageautoprofile-libcpp
3550 clean-stageautoprofile: clean-stageautoprofile-libcpp
3551 clean-stageautoprofile-libcpp:
3552         @if [ $(current_stage) = stageautoprofile ]; then \
3553           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3554         else \
3555           [ -f $(HOST_SUBDIR)/stageautoprofile-libcpp/Makefile ] || exit 0; \
3556           $(MAKE) stageautoprofile-start; \
3557         fi; \
3558         cd $(HOST_SUBDIR)/libcpp && \
3559         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3560 @endif libcpp-bootstrap
3561
3562
3563 .PHONY: all-stageautofeedback-libcpp maybe-all-stageautofeedback-libcpp
3564 .PHONY: clean-stageautofeedback-libcpp maybe-clean-stageautofeedback-libcpp
3565 maybe-all-stageautofeedback-libcpp:
3566 maybe-clean-stageautofeedback-libcpp:
3567 @if libcpp-bootstrap
3568 maybe-all-stageautofeedback-libcpp: all-stageautofeedback-libcpp
3569 all-stageautofeedback: all-stageautofeedback-libcpp
3570 TARGET-stageautofeedback-libcpp = $(TARGET-libcpp)
3571 all-stageautofeedback-libcpp: configure-stageautofeedback-libcpp
3572         @[ $(current_stage) = stageautofeedback ] || $(MAKE) stageautofeedback-start
3573         @r=`${PWD_COMMAND}`; export r; \
3574         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3575         TFLAGS="$(STAGEautofeedback_TFLAGS)"; \
3576         $(HOST_EXPORTS) \
3577         $(POSTSTAGE1_HOST_EXPORTS)  \
3578         cd $(HOST_SUBDIR)/libcpp && \
3579          \
3580         $(MAKE) $(BASE_FLAGS_TO_PASS) \
3581                 CFLAGS="$(STAGEautofeedback_CFLAGS)" \
3582                 GENERATOR_CFLAGS="$(STAGEautofeedback_GENERATOR_CFLAGS)" \
3583                 CXXFLAGS="$(STAGEautofeedback_CXXFLAGS)" \
3584                 LIBCFLAGS="$(STAGEautofeedback_CFLAGS)" \
3585                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
3586                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
3587                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
3588                 $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  \
3589                 TFLAGS="$(STAGEautofeedback_TFLAGS)" PERF_DATA=perf.data \
3590                 $(TARGET-stageautofeedback-libcpp)
3591
3592 maybe-clean-stageautofeedback-libcpp: clean-stageautofeedback-libcpp
3593 clean-stageautofeedback: clean-stageautofeedback-libcpp
3594 clean-stageautofeedback-libcpp:
3595         @if [ $(current_stage) = stageautofeedback ]; then \
3596           [ -f $(HOST_SUBDIR)/libcpp/Makefile ] || exit 0; \
3597         else \
3598           [ -f $(HOST_SUBDIR)/stageautofeedback-libcpp/Makefile ] || exit 0; \
3599           $(MAKE) stageautofeedback-start; \
3600         fi; \
3601         cd $(HOST_SUBDIR)/libcpp && \
3602         $(MAKE) $(EXTRA_HOST_FLAGS) $(POSTSTAGE1_FLAGS_TO_PASS)  clean
3603 @endif libcpp-bootstrap
3604
3605
3606
3607
3608
3609 .PHONY: check-libcpp maybe-check-libcpp
3610 maybe-check-libcpp:
3611 @if libcpp
3612 maybe-check-libcpp: check-libcpp
3613
3614 check-libcpp:
3615         @: $(MAKE); $(unstage)
3616         @r=`${PWD_COMMAND}`; export r; \
3617         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3618         $(HOST_EXPORTS) $(EXTRA_HOST_EXPORTS) \
3619         (cd $(HOST_SUBDIR)/libcpp && \
3620           $(MAKE) $(FLAGS_TO_PASS)  $(EXTRA_BOOTSTRAP_FLAGS) check)
3621
3622 @endif libcpp
3623
3624 .PHONY: install-libcpp maybe-install-libcpp
3625 maybe-install-libcpp:
3626 @if libcpp
3627 maybe-install-libcpp: install-libcpp
3628
3629 install-libcpp: installdirs
3630         @: $(MAKE); $(unstage)
3631         @r=`${PWD_COMMAND}`; export r; \
3632         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3633         $(HOST_EXPORTS) \
3634         (cd $(HOST_SUBDIR)/libcpp && \
3635           $(MAKE) $(FLAGS_TO_PASS)  install)
3636
3637 @endif libcpp
3638
3639 .PHONY: install-strip-libcpp maybe-install-strip-libcpp
3640 maybe-install-strip-libcpp:
3641 @if libcpp
3642 maybe-install-strip-libcpp: install-strip-libcpp
3643
3644 install-strip-libcpp: installdirs
3645         @: $(MAKE); $(unstage)
3646         @r=`${PWD_COMMAND}`; export r; \
3647         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3648         $(HOST_EXPORTS) \
3649         (cd $(HOST_SUBDIR)/libcpp && \
3650           $(MAKE) $(FLAGS_TO_PASS)  install-strip)
3651
3652 @endif libcpp
3653
3654 # Other targets (info, dvi, pdf, etc.)
3655
3656 .PHONY: maybe-info-libcpp info-libcpp
3657 maybe-info-libcpp:
3658 @if libcpp
3659 maybe-info-libcpp: info-libcpp
3660
3661 info-libcpp: \
3662     configure-libcpp
3663         @[ -f ./libcpp/Makefile ] || exit 0; \
3664         r=`${PWD_COMMAND}`; export r; \
3665         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3666         $(HOST_EXPORTS) \
3667         for flag in $(EXTRA_HOST_FLAGS) ; do \
3668           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3669         done; \
3670         echo "Doing info in libcpp"; \
3671         (cd $(HOST_SUBDIR)/libcpp && \
3672           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3673                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3674                   "RANLIB=$${RANLIB}" \
3675                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3676                   info) \
3677           || exit 1
3678
3679 @endif libcpp
3680
3681 .PHONY: maybe-dvi-libcpp dvi-libcpp
3682 maybe-dvi-libcpp:
3683 @if libcpp
3684 maybe-dvi-libcpp: dvi-libcpp
3685
3686 dvi-libcpp: \
3687     configure-libcpp
3688         @[ -f ./libcpp/Makefile ] || exit 0; \
3689         r=`${PWD_COMMAND}`; export r; \
3690         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3691         $(HOST_EXPORTS) \
3692         for flag in $(EXTRA_HOST_FLAGS) ; do \
3693           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3694         done; \
3695         echo "Doing dvi in libcpp"; \
3696         (cd $(HOST_SUBDIR)/libcpp && \
3697           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3698                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3699                   "RANLIB=$${RANLIB}" \
3700                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3701                   dvi) \
3702           || exit 1
3703
3704 @endif libcpp
3705
3706 .PHONY: maybe-pdf-libcpp pdf-libcpp
3707 maybe-pdf-libcpp:
3708 @if libcpp
3709 maybe-pdf-libcpp: pdf-libcpp
3710
3711 pdf-libcpp: \
3712     configure-libcpp
3713         @[ -f ./libcpp/Makefile ] || exit 0; \
3714         r=`${PWD_COMMAND}`; export r; \
3715         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3716         $(HOST_EXPORTS) \
3717         for flag in $(EXTRA_HOST_FLAGS) ; do \
3718           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3719         done; \
3720         echo "Doing pdf in libcpp"; \
3721         (cd $(HOST_SUBDIR)/libcpp && \
3722           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3723                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3724                   "RANLIB=$${RANLIB}" \
3725                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3726                   pdf) \
3727           || exit 1
3728
3729 @endif libcpp
3730
3731 .PHONY: maybe-html-libcpp html-libcpp
3732 maybe-html-libcpp:
3733 @if libcpp
3734 maybe-html-libcpp: html-libcpp
3735
3736 html-libcpp: \
3737     configure-libcpp
3738         @[ -f ./libcpp/Makefile ] || exit 0; \
3739         r=`${PWD_COMMAND}`; export r; \
3740         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3741         $(HOST_EXPORTS) \
3742         for flag in $(EXTRA_HOST_FLAGS) ; do \
3743           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3744         done; \
3745         echo "Doing html in libcpp"; \
3746         (cd $(HOST_SUBDIR)/libcpp && \
3747           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3748                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3749                   "RANLIB=$${RANLIB}" \
3750                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3751                   html) \
3752           || exit 1
3753
3754 @endif libcpp
3755
3756 .PHONY: maybe-TAGS-libcpp TAGS-libcpp
3757 maybe-TAGS-libcpp:
3758 @if libcpp
3759 maybe-TAGS-libcpp: TAGS-libcpp
3760
3761 TAGS-libcpp: \
3762     configure-libcpp
3763         @[ -f ./libcpp/Makefile ] || exit 0; \
3764         r=`${PWD_COMMAND}`; export r; \
3765         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3766         $(HOST_EXPORTS) \
3767         for flag in $(EXTRA_HOST_FLAGS) ; do \
3768           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3769         done; \
3770         echo "Doing TAGS in libcpp"; \
3771         (cd $(HOST_SUBDIR)/libcpp && \
3772           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3773                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3774                   "RANLIB=$${RANLIB}" \
3775                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3776                   TAGS) \
3777           || exit 1
3778
3779 @endif libcpp
3780
3781 .PHONY: maybe-install-info-libcpp install-info-libcpp
3782 maybe-install-info-libcpp:
3783 @if libcpp
3784 maybe-install-info-libcpp: install-info-libcpp
3785
3786 install-info-libcpp: \
3787     configure-libcpp \
3788     info-libcpp
3789         @[ -f ./libcpp/Makefile ] || exit 0; \
3790         r=`${PWD_COMMAND}`; export r; \
3791         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3792         $(HOST_EXPORTS) \
3793         for flag in $(EXTRA_HOST_FLAGS) ; do \
3794           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3795         done; \
3796         echo "Doing install-info in libcpp"; \
3797         (cd $(HOST_SUBDIR)/libcpp && \
3798           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3799                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3800                   "RANLIB=$${RANLIB}" \
3801                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3802                   install-info) \
3803           || exit 1
3804
3805 @endif libcpp
3806
3807 .PHONY: maybe-install-dvi-libcpp install-dvi-libcpp
3808 maybe-install-dvi-libcpp:
3809 @if libcpp
3810 maybe-install-dvi-libcpp: install-dvi-libcpp
3811
3812 install-dvi-libcpp: \
3813     configure-libcpp \
3814     dvi-libcpp
3815         @[ -f ./libcpp/Makefile ] || exit 0; \
3816         r=`${PWD_COMMAND}`; export r; \
3817         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3818         $(HOST_EXPORTS) \
3819         for flag in $(EXTRA_HOST_FLAGS) ; do \
3820           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3821         done; \
3822         echo "Doing install-dvi in libcpp"; \
3823         (cd $(HOST_SUBDIR)/libcpp && \
3824           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3825                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3826                   "RANLIB=$${RANLIB}" \
3827                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3828                   install-dvi) \
3829           || exit 1
3830
3831 @endif libcpp
3832
3833 .PHONY: maybe-install-pdf-libcpp install-pdf-libcpp
3834 maybe-install-pdf-libcpp:
3835 @if libcpp
3836 maybe-install-pdf-libcpp: install-pdf-libcpp
3837
3838 install-pdf-libcpp: \
3839     configure-libcpp \
3840     pdf-libcpp
3841         @[ -f ./libcpp/Makefile ] || exit 0; \
3842         r=`${PWD_COMMAND}`; export r; \
3843         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3844         $(HOST_EXPORTS) \
3845         for flag in $(EXTRA_HOST_FLAGS) ; do \
3846           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3847         done; \
3848         echo "Doing install-pdf in libcpp"; \
3849         (cd $(HOST_SUBDIR)/libcpp && \
3850           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3851                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3852                   "RANLIB=$${RANLIB}" \
3853                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3854                   install-pdf) \
3855           || exit 1
3856
3857 @endif libcpp
3858
3859 .PHONY: maybe-install-html-libcpp install-html-libcpp
3860 maybe-install-html-libcpp:
3861 @if libcpp
3862 maybe-install-html-libcpp: install-html-libcpp
3863
3864 install-html-libcpp: \
3865     configure-libcpp \
3866     html-libcpp
3867         @[ -f ./libcpp/Makefile ] || exit 0; \
3868         r=`${PWD_COMMAND}`; export r; \
3869         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3870         $(HOST_EXPORTS) \
3871         for flag in $(EXTRA_HOST_FLAGS) ; do \
3872           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3873         done; \
3874         echo "Doing install-html in libcpp"; \
3875         (cd $(HOST_SUBDIR)/libcpp && \
3876           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3877                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3878                   "RANLIB=$${RANLIB}" \
3879                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3880                   install-html) \
3881           || exit 1
3882
3883 @endif libcpp
3884
3885 .PHONY: maybe-installcheck-libcpp installcheck-libcpp
3886 maybe-installcheck-libcpp:
3887 @if libcpp
3888 maybe-installcheck-libcpp: installcheck-libcpp
3889
3890 installcheck-libcpp: \
3891     configure-libcpp
3892         @[ -f ./libcpp/Makefile ] || exit 0; \
3893         r=`${PWD_COMMAND}`; export r; \
3894         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3895         $(HOST_EXPORTS) \
3896         for flag in $(EXTRA_HOST_FLAGS) ; do \
3897           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3898         done; \
3899         echo "Doing installcheck in libcpp"; \
3900         (cd $(HOST_SUBDIR)/libcpp && \
3901           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3902                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3903                   "RANLIB=$${RANLIB}" \
3904                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3905                   installcheck) \
3906           || exit 1
3907
3908 @endif libcpp
3909
3910 .PHONY: maybe-mostlyclean-libcpp mostlyclean-libcpp
3911 maybe-mostlyclean-libcpp:
3912 @if libcpp
3913 maybe-mostlyclean-libcpp: mostlyclean-libcpp
3914
3915 mostlyclean-libcpp:
3916         @[ -f ./libcpp/Makefile ] || exit 0; \
3917         r=`${PWD_COMMAND}`; export r; \
3918         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3919         $(HOST_EXPORTS) \
3920         for flag in $(EXTRA_HOST_FLAGS) ; do \
3921           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3922         done; \
3923         echo "Doing mostlyclean in libcpp"; \
3924         (cd $(HOST_SUBDIR)/libcpp && \
3925           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3926                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3927                   "RANLIB=$${RANLIB}" \
3928                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3929                   mostlyclean) \
3930           || exit 1
3931
3932 @endif libcpp
3933
3934 .PHONY: maybe-clean-libcpp clean-libcpp
3935 maybe-clean-libcpp:
3936 @if libcpp
3937 maybe-clean-libcpp: clean-libcpp
3938
3939 clean-libcpp:
3940         @[ -f ./libcpp/Makefile ] || exit 0; \
3941         r=`${PWD_COMMAND}`; export r; \
3942         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3943         $(HOST_EXPORTS) \
3944         for flag in $(EXTRA_HOST_FLAGS) ; do \
3945           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3946         done; \
3947         echo "Doing clean in libcpp"; \
3948         (cd $(HOST_SUBDIR)/libcpp && \
3949           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3950                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3951                   "RANLIB=$${RANLIB}" \
3952                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3953                   clean) \
3954           || exit 1
3955
3956 @endif libcpp
3957
3958 .PHONY: maybe-distclean-libcpp distclean-libcpp
3959 maybe-distclean-libcpp:
3960 @if libcpp
3961 maybe-distclean-libcpp: distclean-libcpp
3962
3963 distclean-libcpp:
3964         @[ -f ./libcpp/Makefile ] || exit 0; \
3965         r=`${PWD_COMMAND}`; export r; \
3966         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3967         $(HOST_EXPORTS) \
3968         for flag in $(EXTRA_HOST_FLAGS) ; do \
3969           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3970         done; \
3971         echo "Doing distclean in libcpp"; \
3972         (cd $(HOST_SUBDIR)/libcpp && \
3973           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3974                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3975                   "RANLIB=$${RANLIB}" \
3976                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
3977                   distclean) \
3978           || exit 1
3979
3980 @endif libcpp
3981
3982 .PHONY: maybe-maintainer-clean-libcpp maintainer-clean-libcpp
3983 maybe-maintainer-clean-libcpp:
3984 @if libcpp
3985 maybe-maintainer-clean-libcpp: maintainer-clean-libcpp
3986
3987 maintainer-clean-libcpp:
3988         @[ -f ./libcpp/Makefile ] || exit 0; \
3989         r=`${PWD_COMMAND}`; export r; \
3990         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
3991         $(HOST_EXPORTS) \
3992         for flag in $(EXTRA_HOST_FLAGS) ; do \
3993           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
3994         done; \
3995         echo "Doing maintainer-clean in libcpp"; \
3996         (cd $(HOST_SUBDIR)/libcpp && \
3997           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
3998                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
3999                   "RANLIB=$${RANLIB}" \
4000                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4001                   maintainer-clean) \
4002           || exit 1
4003
4004 @endif libcpp
4005
4006
4007
4008 # ---------------------------------------
4009 # Modules which run on the target machine
4010 # ---------------------------------------
4011
4012
4013
4014
4015 .PHONY: configure-target-libbacktrace maybe-configure-target-libbacktrace
4016 maybe-configure-target-libbacktrace:
4017 @if target-libbacktrace
4018 maybe-configure-target-libbacktrace: configure-target-libbacktrace
4019 configure-target-libbacktrace:
4020         @r=`${PWD_COMMAND}`; export r; \
4021         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4022         echo "Checking multilib configuration for libbacktrace..."; \
4023         $(SHELL) $(srcdir)/mkinstalldirs $(TARGET_SUBDIR)/libbacktrace; \
4024         $(CC_FOR_TARGET) --print-multi-lib > $(TARGET_SUBDIR)/libbacktrace/multilib.tmp 2> /dev/null; \
4025         if test -r $(TARGET_SUBDIR)/libbacktrace/multilib.out; then \
4026           if cmp -s $(TARGET_SUBDIR)/libbacktrace/multilib.tmp $(TARGET_SUBDIR)/libbacktrace/multilib.out; then \
4027             rm -f $(TARGET_SUBDIR)/libbacktrace/multilib.tmp; \
4028           else \
4029             rm -f $(TARGET_SUBDIR)/libbacktrace/Makefile; \
4030             mv $(TARGET_SUBDIR)/libbacktrace/multilib.tmp $(TARGET_SUBDIR)/libbacktrace/multilib.out; \
4031           fi; \
4032         else \
4033           mv $(TARGET_SUBDIR)/libbacktrace/multilib.tmp $(TARGET_SUBDIR)/libbacktrace/multilib.out; \
4034         fi; \
4035         test ! -f $(TARGET_SUBDIR)/libbacktrace/Makefile || exit 0; \
4036         $(SHELL) $(srcdir)/mkinstalldirs $(TARGET_SUBDIR)/libbacktrace; \
4037         $(NORMAL_TARGET_EXPORTS)  \
4038         echo Configuring in $(TARGET_SUBDIR)/libbacktrace; \
4039         cd "$(TARGET_SUBDIR)/libbacktrace" || exit 1; \
4040         case $(srcdir) in \
4041           /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
4042           *) topdir=`echo $(TARGET_SUBDIR)/libbacktrace/ | \
4043                 sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
4044         esac; \
4045         module_srcdir=libbacktrace; \
4046         rm -f no-such-file || : ; \
4047         CONFIG_SITE=no-such-file $(SHELL) \
4048           $$s/$$module_srcdir/configure \
4049           --srcdir=$${topdir}/$$module_srcdir \
4050           $(TARGET_CONFIGARGS) --build=${build_alias} --host=${target_alias} \
4051           --target=${target_alias}  \
4052           || exit 1
4053 @endif target-libbacktrace
4054
4055
4056
4057
4058 .PHONY: all-target-libbacktrace maybe-all-target-libbacktrace
4059 maybe-all-target-libbacktrace:
4060 @if target-libbacktrace
4061 TARGET-target-libbacktrace=all
4062 maybe-all-target-libbacktrace: all-target-libbacktrace
4063 all-target-libbacktrace: configure-target-libbacktrace
4064         @r=`${PWD_COMMAND}`; export r; \
4065         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4066         $(NORMAL_TARGET_EXPORTS)  \
4067         (cd $(TARGET_SUBDIR)/libbacktrace && \
4068           $(MAKE) $(BASE_FLAGS_TO_PASS) $(EXTRA_TARGET_FLAGS)   \
4069                 $(TARGET-target-libbacktrace))
4070 @endif target-libbacktrace
4071
4072
4073
4074 .PHONY: all-stage1-target-libbacktrace maybe-all-stage1-target-libbacktrace
4075 .PHONY: clean-stage1-target-libbacktrace maybe-clean-stage1-target-libbacktrace
4076 maybe-all-stage1-target-libbacktrace:
4077 maybe-clean-stage1-target-libbacktrace:
4078 @if target-libbacktrace-bootstrap
4079 maybe-all-stage1-target-libbacktrace: all-stage1-target-libbacktrace
4080 all-stage1: all-stage1-target-libbacktrace
4081 TARGET-stage1-target-libbacktrace = $(TARGET-target-libbacktrace)
4082 all-stage1-target-libbacktrace: configure-stage1-target-libbacktrace
4083         @[ $(current_stage) = stage1 ] || $(MAKE) stage1-start
4084         @r=`${PWD_COMMAND}`; export r; \
4085         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4086         TFLAGS="$(STAGE1_TFLAGS)"; \
4087         $(NORMAL_TARGET_EXPORTS)  \
4088         cd $(TARGET_SUBDIR)/libbacktrace && \
4089          \
4090         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4091                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4092                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4093                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4094                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4095                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4096                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4097                 $(EXTRA_TARGET_FLAGS)  \
4098                   \
4099                 TFLAGS="$(STAGE1_TFLAGS)"  \
4100                 $(TARGET-stage1-target-libbacktrace)
4101
4102 maybe-clean-stage1-target-libbacktrace: clean-stage1-target-libbacktrace
4103 clean-stage1: clean-stage1-target-libbacktrace
4104 clean-stage1-target-libbacktrace:
4105         @if [ $(current_stage) = stage1 ]; then \
4106           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4107         else \
4108           [ -f $(TARGET_SUBDIR)/stage1-libbacktrace/Makefile ] || exit 0; \
4109           $(MAKE) stage1-start; \
4110         fi; \
4111         cd $(TARGET_SUBDIR)/libbacktrace && \
4112         $(MAKE) $(EXTRA_TARGET_FLAGS)  \
4113           clean
4114 @endif target-libbacktrace-bootstrap
4115
4116
4117 .PHONY: all-stage2-target-libbacktrace maybe-all-stage2-target-libbacktrace
4118 .PHONY: clean-stage2-target-libbacktrace maybe-clean-stage2-target-libbacktrace
4119 maybe-all-stage2-target-libbacktrace:
4120 maybe-clean-stage2-target-libbacktrace:
4121 @if target-libbacktrace-bootstrap
4122 maybe-all-stage2-target-libbacktrace: all-stage2-target-libbacktrace
4123 all-stage2: all-stage2-target-libbacktrace
4124 TARGET-stage2-target-libbacktrace = $(TARGET-target-libbacktrace)
4125 all-stage2-target-libbacktrace: configure-stage2-target-libbacktrace
4126         @[ $(current_stage) = stage2 ] || $(MAKE) stage2-start
4127         @r=`${PWD_COMMAND}`; export r; \
4128         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4129         TFLAGS="$(STAGE2_TFLAGS)"; \
4130         $(NORMAL_TARGET_EXPORTS) \
4131           \
4132         cd $(TARGET_SUBDIR)/libbacktrace && \
4133          \
4134         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4135                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4136                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4137                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4138                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4139                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4140                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4141                 $(EXTRA_TARGET_FLAGS)   \
4142                 TFLAGS="$(STAGE2_TFLAGS)"  \
4143                 $(TARGET-stage2-target-libbacktrace)
4144
4145 maybe-clean-stage2-target-libbacktrace: clean-stage2-target-libbacktrace
4146 clean-stage2: clean-stage2-target-libbacktrace
4147 clean-stage2-target-libbacktrace:
4148         @if [ $(current_stage) = stage2 ]; then \
4149           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4150         else \
4151           [ -f $(TARGET_SUBDIR)/stage2-libbacktrace/Makefile ] || exit 0; \
4152           $(MAKE) stage2-start; \
4153         fi; \
4154         cd $(TARGET_SUBDIR)/libbacktrace && \
4155         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4156 @endif target-libbacktrace-bootstrap
4157
4158
4159 .PHONY: all-stage3-target-libbacktrace maybe-all-stage3-target-libbacktrace
4160 .PHONY: clean-stage3-target-libbacktrace maybe-clean-stage3-target-libbacktrace
4161 maybe-all-stage3-target-libbacktrace:
4162 maybe-clean-stage3-target-libbacktrace:
4163 @if target-libbacktrace-bootstrap
4164 maybe-all-stage3-target-libbacktrace: all-stage3-target-libbacktrace
4165 all-stage3: all-stage3-target-libbacktrace
4166 TARGET-stage3-target-libbacktrace = $(TARGET-target-libbacktrace)
4167 all-stage3-target-libbacktrace: configure-stage3-target-libbacktrace
4168         @[ $(current_stage) = stage3 ] || $(MAKE) stage3-start
4169         @r=`${PWD_COMMAND}`; export r; \
4170         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4171         TFLAGS="$(STAGE3_TFLAGS)"; \
4172         $(NORMAL_TARGET_EXPORTS) \
4173           \
4174         cd $(TARGET_SUBDIR)/libbacktrace && \
4175          \
4176         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4177                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4178                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4179                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4180                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4181                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4182                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4183                 $(EXTRA_TARGET_FLAGS)   \
4184                 TFLAGS="$(STAGE3_TFLAGS)"  \
4185                 $(TARGET-stage3-target-libbacktrace)
4186
4187 maybe-clean-stage3-target-libbacktrace: clean-stage3-target-libbacktrace
4188 clean-stage3: clean-stage3-target-libbacktrace
4189 clean-stage3-target-libbacktrace:
4190         @if [ $(current_stage) = stage3 ]; then \
4191           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4192         else \
4193           [ -f $(TARGET_SUBDIR)/stage3-libbacktrace/Makefile ] || exit 0; \
4194           $(MAKE) stage3-start; \
4195         fi; \
4196         cd $(TARGET_SUBDIR)/libbacktrace && \
4197         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4198 @endif target-libbacktrace-bootstrap
4199
4200
4201 .PHONY: all-stage4-target-libbacktrace maybe-all-stage4-target-libbacktrace
4202 .PHONY: clean-stage4-target-libbacktrace maybe-clean-stage4-target-libbacktrace
4203 maybe-all-stage4-target-libbacktrace:
4204 maybe-clean-stage4-target-libbacktrace:
4205 @if target-libbacktrace-bootstrap
4206 maybe-all-stage4-target-libbacktrace: all-stage4-target-libbacktrace
4207 all-stage4: all-stage4-target-libbacktrace
4208 TARGET-stage4-target-libbacktrace = $(TARGET-target-libbacktrace)
4209 all-stage4-target-libbacktrace: configure-stage4-target-libbacktrace
4210         @[ $(current_stage) = stage4 ] || $(MAKE) stage4-start
4211         @r=`${PWD_COMMAND}`; export r; \
4212         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4213         TFLAGS="$(STAGE4_TFLAGS)"; \
4214         $(NORMAL_TARGET_EXPORTS) \
4215           \
4216         cd $(TARGET_SUBDIR)/libbacktrace && \
4217          \
4218         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4219                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4220                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4221                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4222                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4223                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4224                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4225                 $(EXTRA_TARGET_FLAGS)   \
4226                 TFLAGS="$(STAGE4_TFLAGS)"  \
4227                 $(TARGET-stage4-target-libbacktrace)
4228
4229 maybe-clean-stage4-target-libbacktrace: clean-stage4-target-libbacktrace
4230 clean-stage4: clean-stage4-target-libbacktrace
4231 clean-stage4-target-libbacktrace:
4232         @if [ $(current_stage) = stage4 ]; then \
4233           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4234         else \
4235           [ -f $(TARGET_SUBDIR)/stage4-libbacktrace/Makefile ] || exit 0; \
4236           $(MAKE) stage4-start; \
4237         fi; \
4238         cd $(TARGET_SUBDIR)/libbacktrace && \
4239         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4240 @endif target-libbacktrace-bootstrap
4241
4242
4243 .PHONY: all-stageprofile-target-libbacktrace maybe-all-stageprofile-target-libbacktrace
4244 .PHONY: clean-stageprofile-target-libbacktrace maybe-clean-stageprofile-target-libbacktrace
4245 maybe-all-stageprofile-target-libbacktrace:
4246 maybe-clean-stageprofile-target-libbacktrace:
4247 @if target-libbacktrace-bootstrap
4248 maybe-all-stageprofile-target-libbacktrace: all-stageprofile-target-libbacktrace
4249 all-stageprofile: all-stageprofile-target-libbacktrace
4250 TARGET-stageprofile-target-libbacktrace = $(TARGET-target-libbacktrace)
4251 all-stageprofile-target-libbacktrace: configure-stageprofile-target-libbacktrace
4252         @[ $(current_stage) = stageprofile ] || $(MAKE) stageprofile-start
4253         @r=`${PWD_COMMAND}`; export r; \
4254         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4255         TFLAGS="$(STAGEprofile_TFLAGS)"; \
4256         $(NORMAL_TARGET_EXPORTS) \
4257           \
4258         cd $(TARGET_SUBDIR)/libbacktrace && \
4259          \
4260         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4261                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4262                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4263                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4264                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4265                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4266                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4267                 $(EXTRA_TARGET_FLAGS)   \
4268                 TFLAGS="$(STAGEprofile_TFLAGS)"  \
4269                 $(TARGET-stageprofile-target-libbacktrace)
4270
4271 maybe-clean-stageprofile-target-libbacktrace: clean-stageprofile-target-libbacktrace
4272 clean-stageprofile: clean-stageprofile-target-libbacktrace
4273 clean-stageprofile-target-libbacktrace:
4274         @if [ $(current_stage) = stageprofile ]; then \
4275           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4276         else \
4277           [ -f $(TARGET_SUBDIR)/stageprofile-libbacktrace/Makefile ] || exit 0; \
4278           $(MAKE) stageprofile-start; \
4279         fi; \
4280         cd $(TARGET_SUBDIR)/libbacktrace && \
4281         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4282 @endif target-libbacktrace-bootstrap
4283
4284
4285 .PHONY: all-stagetrain-target-libbacktrace maybe-all-stagetrain-target-libbacktrace
4286 .PHONY: clean-stagetrain-target-libbacktrace maybe-clean-stagetrain-target-libbacktrace
4287 maybe-all-stagetrain-target-libbacktrace:
4288 maybe-clean-stagetrain-target-libbacktrace:
4289 @if target-libbacktrace-bootstrap
4290 maybe-all-stagetrain-target-libbacktrace: all-stagetrain-target-libbacktrace
4291 all-stagetrain: all-stagetrain-target-libbacktrace
4292 TARGET-stagetrain-target-libbacktrace = $(TARGET-target-libbacktrace)
4293 all-stagetrain-target-libbacktrace: configure-stagetrain-target-libbacktrace
4294         @[ $(current_stage) = stagetrain ] || $(MAKE) stagetrain-start
4295         @r=`${PWD_COMMAND}`; export r; \
4296         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4297         TFLAGS="$(STAGEtrain_TFLAGS)"; \
4298         $(NORMAL_TARGET_EXPORTS) \
4299           \
4300         cd $(TARGET_SUBDIR)/libbacktrace && \
4301          \
4302         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4303                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4304                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4305                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4306                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4307                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4308                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4309                 $(EXTRA_TARGET_FLAGS)   \
4310                 TFLAGS="$(STAGEtrain_TFLAGS)"  \
4311                 $(TARGET-stagetrain-target-libbacktrace)
4312
4313 maybe-clean-stagetrain-target-libbacktrace: clean-stagetrain-target-libbacktrace
4314 clean-stagetrain: clean-stagetrain-target-libbacktrace
4315 clean-stagetrain-target-libbacktrace:
4316         @if [ $(current_stage) = stagetrain ]; then \
4317           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4318         else \
4319           [ -f $(TARGET_SUBDIR)/stagetrain-libbacktrace/Makefile ] || exit 0; \
4320           $(MAKE) stagetrain-start; \
4321         fi; \
4322         cd $(TARGET_SUBDIR)/libbacktrace && \
4323         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4324 @endif target-libbacktrace-bootstrap
4325
4326
4327 .PHONY: all-stagefeedback-target-libbacktrace maybe-all-stagefeedback-target-libbacktrace
4328 .PHONY: clean-stagefeedback-target-libbacktrace maybe-clean-stagefeedback-target-libbacktrace
4329 maybe-all-stagefeedback-target-libbacktrace:
4330 maybe-clean-stagefeedback-target-libbacktrace:
4331 @if target-libbacktrace-bootstrap
4332 maybe-all-stagefeedback-target-libbacktrace: all-stagefeedback-target-libbacktrace
4333 all-stagefeedback: all-stagefeedback-target-libbacktrace
4334 TARGET-stagefeedback-target-libbacktrace = $(TARGET-target-libbacktrace)
4335 all-stagefeedback-target-libbacktrace: configure-stagefeedback-target-libbacktrace
4336         @[ $(current_stage) = stagefeedback ] || $(MAKE) stagefeedback-start
4337         @r=`${PWD_COMMAND}`; export r; \
4338         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4339         TFLAGS="$(STAGEfeedback_TFLAGS)"; \
4340         $(NORMAL_TARGET_EXPORTS) \
4341           \
4342         cd $(TARGET_SUBDIR)/libbacktrace && \
4343          \
4344         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4345                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4346                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4347                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4348                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4349                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4350                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4351                 $(EXTRA_TARGET_FLAGS)   \
4352                 TFLAGS="$(STAGEfeedback_TFLAGS)"  \
4353                 $(TARGET-stagefeedback-target-libbacktrace)
4354
4355 maybe-clean-stagefeedback-target-libbacktrace: clean-stagefeedback-target-libbacktrace
4356 clean-stagefeedback: clean-stagefeedback-target-libbacktrace
4357 clean-stagefeedback-target-libbacktrace:
4358         @if [ $(current_stage) = stagefeedback ]; then \
4359           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4360         else \
4361           [ -f $(TARGET_SUBDIR)/stagefeedback-libbacktrace/Makefile ] || exit 0; \
4362           $(MAKE) stagefeedback-start; \
4363         fi; \
4364         cd $(TARGET_SUBDIR)/libbacktrace && \
4365         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4366 @endif target-libbacktrace-bootstrap
4367
4368
4369 .PHONY: all-stageautoprofile-target-libbacktrace maybe-all-stageautoprofile-target-libbacktrace
4370 .PHONY: clean-stageautoprofile-target-libbacktrace maybe-clean-stageautoprofile-target-libbacktrace
4371 maybe-all-stageautoprofile-target-libbacktrace:
4372 maybe-clean-stageautoprofile-target-libbacktrace:
4373 @if target-libbacktrace-bootstrap
4374 maybe-all-stageautoprofile-target-libbacktrace: all-stageautoprofile-target-libbacktrace
4375 all-stageautoprofile: all-stageautoprofile-target-libbacktrace
4376 TARGET-stageautoprofile-target-libbacktrace = $(TARGET-target-libbacktrace)
4377 all-stageautoprofile-target-libbacktrace: configure-stageautoprofile-target-libbacktrace
4378         @[ $(current_stage) = stageautoprofile ] || $(MAKE) stageautoprofile-start
4379         @r=`${PWD_COMMAND}`; export r; \
4380         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4381         TFLAGS="$(STAGEautoprofile_TFLAGS)"; \
4382         $(NORMAL_TARGET_EXPORTS) \
4383           \
4384         cd $(TARGET_SUBDIR)/libbacktrace && \
4385         $$s/gcc/config/i386/$(AUTO_PROFILE) \
4386         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4387                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4388                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4389                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4390                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4391                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4392                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4393                 $(EXTRA_TARGET_FLAGS)   \
4394                 TFLAGS="$(STAGEautoprofile_TFLAGS)"  \
4395                 $(TARGET-stageautoprofile-target-libbacktrace)
4396
4397 maybe-clean-stageautoprofile-target-libbacktrace: clean-stageautoprofile-target-libbacktrace
4398 clean-stageautoprofile: clean-stageautoprofile-target-libbacktrace
4399 clean-stageautoprofile-target-libbacktrace:
4400         @if [ $(current_stage) = stageautoprofile ]; then \
4401           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4402         else \
4403           [ -f $(TARGET_SUBDIR)/stageautoprofile-libbacktrace/Makefile ] || exit 0; \
4404           $(MAKE) stageautoprofile-start; \
4405         fi; \
4406         cd $(TARGET_SUBDIR)/libbacktrace && \
4407         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4408 @endif target-libbacktrace-bootstrap
4409
4410
4411 .PHONY: all-stageautofeedback-target-libbacktrace maybe-all-stageautofeedback-target-libbacktrace
4412 .PHONY: clean-stageautofeedback-target-libbacktrace maybe-clean-stageautofeedback-target-libbacktrace
4413 maybe-all-stageautofeedback-target-libbacktrace:
4414 maybe-clean-stageautofeedback-target-libbacktrace:
4415 @if target-libbacktrace-bootstrap
4416 maybe-all-stageautofeedback-target-libbacktrace: all-stageautofeedback-target-libbacktrace
4417 all-stageautofeedback: all-stageautofeedback-target-libbacktrace
4418 TARGET-stageautofeedback-target-libbacktrace = $(TARGET-target-libbacktrace)
4419 all-stageautofeedback-target-libbacktrace: configure-stageautofeedback-target-libbacktrace
4420         @[ $(current_stage) = stageautofeedback ] || $(MAKE) stageautofeedback-start
4421         @r=`${PWD_COMMAND}`; export r; \
4422         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4423         TFLAGS="$(STAGEautofeedback_TFLAGS)"; \
4424         $(NORMAL_TARGET_EXPORTS) \
4425           \
4426         cd $(TARGET_SUBDIR)/libbacktrace && \
4427          \
4428         $(MAKE) $(BASE_FLAGS_TO_PASS) \
4429                 CFLAGS="$(CFLAGS_FOR_TARGET)" \
4430                 CXXFLAGS="$(CXXFLAGS_FOR_TARGET)" \
4431                 LIBCFLAGS="$(LIBCFLAGS_FOR_TARGET)" \
4432                 CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" \
4433                 CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" \
4434                 LIBCFLAGS_FOR_TARGET="$(LIBCFLAGS_FOR_TARGET)" \
4435                 $(EXTRA_TARGET_FLAGS)   \
4436                 TFLAGS="$(STAGEautofeedback_TFLAGS)" PERF_DATA=perf.data \
4437                 $(TARGET-stageautofeedback-target-libbacktrace)
4438
4439 maybe-clean-stageautofeedback-target-libbacktrace: clean-stageautofeedback-target-libbacktrace
4440 clean-stageautofeedback: clean-stageautofeedback-target-libbacktrace
4441 clean-stageautofeedback-target-libbacktrace:
4442         @if [ $(current_stage) = stageautofeedback ]; then \
4443           [ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4444         else \
4445           [ -f $(TARGET_SUBDIR)/stageautofeedback-libbacktrace/Makefile ] || exit 0; \
4446           $(MAKE) stageautofeedback-start; \
4447         fi; \
4448         cd $(TARGET_SUBDIR)/libbacktrace && \
4449         $(MAKE) $(EXTRA_TARGET_FLAGS)   clean
4450 @endif target-libbacktrace-bootstrap
4451
4452
4453
4454
4455
4456
4457 .PHONY: check-target-libbacktrace maybe-check-target-libbacktrace
4458 maybe-check-target-libbacktrace:
4459 @if target-libbacktrace
4460 maybe-check-target-libbacktrace: check-target-libbacktrace
4461
4462 check-target-libbacktrace:
4463         @: $(MAKE); $(unstage)
4464         @r=`${PWD_COMMAND}`; export r; \
4465         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4466         $(NORMAL_TARGET_EXPORTS) \
4467         (cd $(TARGET_SUBDIR)/libbacktrace && \
4468           $(MAKE) $(TARGET_FLAGS_TO_PASS)   check)
4469
4470 @endif target-libbacktrace
4471
4472 .PHONY: install-target-libbacktrace maybe-install-target-libbacktrace
4473 maybe-install-target-libbacktrace:
4474 @if target-libbacktrace
4475 maybe-install-target-libbacktrace: install-target-libbacktrace
4476
4477 install-target-libbacktrace: installdirs
4478         @: $(MAKE); $(unstage)
4479         @r=`${PWD_COMMAND}`; export r; \
4480         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4481         $(NORMAL_TARGET_EXPORTS) \
4482         (cd $(TARGET_SUBDIR)/libbacktrace && \
4483           $(MAKE) $(TARGET_FLAGS_TO_PASS)  install)
4484
4485 @endif target-libbacktrace
4486
4487 .PHONY: install-strip-target-libbacktrace maybe-install-strip-target-libbacktrace
4488 maybe-install-strip-target-libbacktrace:
4489 @if target-libbacktrace
4490 maybe-install-strip-target-libbacktrace: install-strip-target-libbacktrace
4491
4492 install-strip-target-libbacktrace: installdirs
4493         @: $(MAKE); $(unstage)
4494         @r=`${PWD_COMMAND}`; export r; \
4495         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4496         $(NORMAL_TARGET_EXPORTS) \
4497         (cd $(TARGET_SUBDIR)/libbacktrace && \
4498           $(MAKE) $(TARGET_FLAGS_TO_PASS)  install-strip)
4499
4500 @endif target-libbacktrace
4501
4502 # Other targets (info, dvi, pdf, etc.)
4503
4504 .PHONY: maybe-info-target-libbacktrace info-target-libbacktrace
4505 maybe-info-target-libbacktrace:
4506 @if target-libbacktrace
4507 maybe-info-target-libbacktrace: info-target-libbacktrace
4508
4509 info-target-libbacktrace: \
4510     configure-target-libbacktrace
4511         @: $(MAKE); $(unstage)
4512         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4513         r=`${PWD_COMMAND}`; export r; \
4514         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4515         $(NORMAL_TARGET_EXPORTS) \
4516         echo "Doing info in $(TARGET_SUBDIR)/libbacktrace"; \
4517         for flag in $(EXTRA_TARGET_FLAGS); do \
4518           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4519         done; \
4520         (cd $(TARGET_SUBDIR)/libbacktrace && \
4521           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4522                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4523                   "RANLIB=$${RANLIB}" \
4524                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4525                    info) \
4526           || exit 1
4527
4528 @endif target-libbacktrace
4529
4530 .PHONY: maybe-dvi-target-libbacktrace dvi-target-libbacktrace
4531 maybe-dvi-target-libbacktrace:
4532 @if target-libbacktrace
4533 maybe-dvi-target-libbacktrace: dvi-target-libbacktrace
4534
4535 dvi-target-libbacktrace: \
4536     configure-target-libbacktrace
4537         @: $(MAKE); $(unstage)
4538         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4539         r=`${PWD_COMMAND}`; export r; \
4540         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4541         $(NORMAL_TARGET_EXPORTS) \
4542         echo "Doing dvi in $(TARGET_SUBDIR)/libbacktrace"; \
4543         for flag in $(EXTRA_TARGET_FLAGS); do \
4544           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4545         done; \
4546         (cd $(TARGET_SUBDIR)/libbacktrace && \
4547           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4548                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4549                   "RANLIB=$${RANLIB}" \
4550                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4551                    dvi) \
4552           || exit 1
4553
4554 @endif target-libbacktrace
4555
4556 .PHONY: maybe-pdf-target-libbacktrace pdf-target-libbacktrace
4557 maybe-pdf-target-libbacktrace:
4558 @if target-libbacktrace
4559 maybe-pdf-target-libbacktrace: pdf-target-libbacktrace
4560
4561 pdf-target-libbacktrace: \
4562     configure-target-libbacktrace
4563         @: $(MAKE); $(unstage)
4564         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4565         r=`${PWD_COMMAND}`; export r; \
4566         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4567         $(NORMAL_TARGET_EXPORTS) \
4568         echo "Doing pdf in $(TARGET_SUBDIR)/libbacktrace"; \
4569         for flag in $(EXTRA_TARGET_FLAGS); do \
4570           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4571         done; \
4572         (cd $(TARGET_SUBDIR)/libbacktrace && \
4573           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4574                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4575                   "RANLIB=$${RANLIB}" \
4576                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4577                    pdf) \
4578           || exit 1
4579
4580 @endif target-libbacktrace
4581
4582 .PHONY: maybe-html-target-libbacktrace html-target-libbacktrace
4583 maybe-html-target-libbacktrace:
4584 @if target-libbacktrace
4585 maybe-html-target-libbacktrace: html-target-libbacktrace
4586
4587 html-target-libbacktrace: \
4588     configure-target-libbacktrace
4589         @: $(MAKE); $(unstage)
4590         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4591         r=`${PWD_COMMAND}`; export r; \
4592         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4593         $(NORMAL_TARGET_EXPORTS) \
4594         echo "Doing html in $(TARGET_SUBDIR)/libbacktrace"; \
4595         for flag in $(EXTRA_TARGET_FLAGS); do \
4596           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4597         done; \
4598         (cd $(TARGET_SUBDIR)/libbacktrace && \
4599           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4600                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4601                   "RANLIB=$${RANLIB}" \
4602                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4603                    html) \
4604           || exit 1
4605
4606 @endif target-libbacktrace
4607
4608 .PHONY: maybe-TAGS-target-libbacktrace TAGS-target-libbacktrace
4609 maybe-TAGS-target-libbacktrace:
4610 @if target-libbacktrace
4611 maybe-TAGS-target-libbacktrace: TAGS-target-libbacktrace
4612
4613 TAGS-target-libbacktrace: \
4614     configure-target-libbacktrace
4615         @: $(MAKE); $(unstage)
4616         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4617         r=`${PWD_COMMAND}`; export r; \
4618         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4619         $(NORMAL_TARGET_EXPORTS) \
4620         echo "Doing TAGS in $(TARGET_SUBDIR)/libbacktrace"; \
4621         for flag in $(EXTRA_TARGET_FLAGS); do \
4622           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4623         done; \
4624         (cd $(TARGET_SUBDIR)/libbacktrace && \
4625           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4626                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4627                   "RANLIB=$${RANLIB}" \
4628                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4629                    TAGS) \
4630           || exit 1
4631
4632 @endif target-libbacktrace
4633
4634 .PHONY: maybe-install-info-target-libbacktrace install-info-target-libbacktrace
4635 maybe-install-info-target-libbacktrace:
4636 @if target-libbacktrace
4637 maybe-install-info-target-libbacktrace: install-info-target-libbacktrace
4638
4639 install-info-target-libbacktrace: \
4640     configure-target-libbacktrace \
4641     info-target-libbacktrace
4642         @: $(MAKE); $(unstage)
4643         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4644         r=`${PWD_COMMAND}`; export r; \
4645         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4646         $(NORMAL_TARGET_EXPORTS) \
4647         echo "Doing install-info in $(TARGET_SUBDIR)/libbacktrace"; \
4648         for flag in $(EXTRA_TARGET_FLAGS); do \
4649           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4650         done; \
4651         (cd $(TARGET_SUBDIR)/libbacktrace && \
4652           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4653                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4654                   "RANLIB=$${RANLIB}" \
4655                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4656                    install-info) \
4657           || exit 1
4658
4659 @endif target-libbacktrace
4660
4661 .PHONY: maybe-install-dvi-target-libbacktrace install-dvi-target-libbacktrace
4662 maybe-install-dvi-target-libbacktrace:
4663 @if target-libbacktrace
4664 maybe-install-dvi-target-libbacktrace: install-dvi-target-libbacktrace
4665
4666 install-dvi-target-libbacktrace: \
4667     configure-target-libbacktrace \
4668     dvi-target-libbacktrace
4669         @: $(MAKE); $(unstage)
4670         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4671         r=`${PWD_COMMAND}`; export r; \
4672         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4673         $(NORMAL_TARGET_EXPORTS) \
4674         echo "Doing install-dvi in $(TARGET_SUBDIR)/libbacktrace"; \
4675         for flag in $(EXTRA_TARGET_FLAGS); do \
4676           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4677         done; \
4678         (cd $(TARGET_SUBDIR)/libbacktrace && \
4679           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4680                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4681                   "RANLIB=$${RANLIB}" \
4682                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4683                    install-dvi) \
4684           || exit 1
4685
4686 @endif target-libbacktrace
4687
4688 .PHONY: maybe-install-pdf-target-libbacktrace install-pdf-target-libbacktrace
4689 maybe-install-pdf-target-libbacktrace:
4690 @if target-libbacktrace
4691 maybe-install-pdf-target-libbacktrace: install-pdf-target-libbacktrace
4692
4693 install-pdf-target-libbacktrace: \
4694     configure-target-libbacktrace \
4695     pdf-target-libbacktrace
4696         @: $(MAKE); $(unstage)
4697         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4698         r=`${PWD_COMMAND}`; export r; \
4699         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4700         $(NORMAL_TARGET_EXPORTS) \
4701         echo "Doing install-pdf in $(TARGET_SUBDIR)/libbacktrace"; \
4702         for flag in $(EXTRA_TARGET_FLAGS); do \
4703           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4704         done; \
4705         (cd $(TARGET_SUBDIR)/libbacktrace && \
4706           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4707                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4708                   "RANLIB=$${RANLIB}" \
4709                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4710                    install-pdf) \
4711           || exit 1
4712
4713 @endif target-libbacktrace
4714
4715 .PHONY: maybe-install-html-target-libbacktrace install-html-target-libbacktrace
4716 maybe-install-html-target-libbacktrace:
4717 @if target-libbacktrace
4718 maybe-install-html-target-libbacktrace: install-html-target-libbacktrace
4719
4720 install-html-target-libbacktrace: \
4721     configure-target-libbacktrace \
4722     html-target-libbacktrace
4723         @: $(MAKE); $(unstage)
4724         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4725         r=`${PWD_COMMAND}`; export r; \
4726         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4727         $(NORMAL_TARGET_EXPORTS) \
4728         echo "Doing install-html in $(TARGET_SUBDIR)/libbacktrace"; \
4729         for flag in $(EXTRA_TARGET_FLAGS); do \
4730           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4731         done; \
4732         (cd $(TARGET_SUBDIR)/libbacktrace && \
4733           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4734                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4735                   "RANLIB=$${RANLIB}" \
4736                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4737                    install-html) \
4738           || exit 1
4739
4740 @endif target-libbacktrace
4741
4742 .PHONY: maybe-installcheck-target-libbacktrace installcheck-target-libbacktrace
4743 maybe-installcheck-target-libbacktrace:
4744 @if target-libbacktrace
4745 maybe-installcheck-target-libbacktrace: installcheck-target-libbacktrace
4746
4747 installcheck-target-libbacktrace: \
4748     configure-target-libbacktrace
4749         @: $(MAKE); $(unstage)
4750         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4751         r=`${PWD_COMMAND}`; export r; \
4752         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4753         $(NORMAL_TARGET_EXPORTS) \
4754         echo "Doing installcheck in $(TARGET_SUBDIR)/libbacktrace"; \
4755         for flag in $(EXTRA_TARGET_FLAGS); do \
4756           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4757         done; \
4758         (cd $(TARGET_SUBDIR)/libbacktrace && \
4759           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4760                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4761                   "RANLIB=$${RANLIB}" \
4762                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4763                    installcheck) \
4764           || exit 1
4765
4766 @endif target-libbacktrace
4767
4768 .PHONY: maybe-mostlyclean-target-libbacktrace mostlyclean-target-libbacktrace
4769 maybe-mostlyclean-target-libbacktrace:
4770 @if target-libbacktrace
4771 maybe-mostlyclean-target-libbacktrace: mostlyclean-target-libbacktrace
4772
4773 mostlyclean-target-libbacktrace:
4774         @: $(MAKE); $(unstage)
4775         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4776         r=`${PWD_COMMAND}`; export r; \
4777         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4778         $(NORMAL_TARGET_EXPORTS) \
4779         echo "Doing mostlyclean in $(TARGET_SUBDIR)/libbacktrace"; \
4780         for flag in $(EXTRA_TARGET_FLAGS); do \
4781           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4782         done; \
4783         (cd $(TARGET_SUBDIR)/libbacktrace && \
4784           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4785                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4786                   "RANLIB=$${RANLIB}" \
4787                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4788                    mostlyclean) \
4789           || exit 1
4790
4791 @endif target-libbacktrace
4792
4793 .PHONY: maybe-clean-target-libbacktrace clean-target-libbacktrace
4794 maybe-clean-target-libbacktrace:
4795 @if target-libbacktrace
4796 maybe-clean-target-libbacktrace: clean-target-libbacktrace
4797
4798 clean-target-libbacktrace:
4799         @: $(MAKE); $(unstage)
4800         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4801         r=`${PWD_COMMAND}`; export r; \
4802         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4803         $(NORMAL_TARGET_EXPORTS) \
4804         echo "Doing clean in $(TARGET_SUBDIR)/libbacktrace"; \
4805         for flag in $(EXTRA_TARGET_FLAGS); do \
4806           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4807         done; \
4808         (cd $(TARGET_SUBDIR)/libbacktrace && \
4809           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4810                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4811                   "RANLIB=$${RANLIB}" \
4812                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4813                    clean) \
4814           || exit 1
4815
4816 @endif target-libbacktrace
4817
4818 .PHONY: maybe-distclean-target-libbacktrace distclean-target-libbacktrace
4819 maybe-distclean-target-libbacktrace:
4820 @if target-libbacktrace
4821 maybe-distclean-target-libbacktrace: distclean-target-libbacktrace
4822
4823 distclean-target-libbacktrace:
4824         @: $(MAKE); $(unstage)
4825         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4826         r=`${PWD_COMMAND}`; export r; \
4827         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4828         $(NORMAL_TARGET_EXPORTS) \
4829         echo "Doing distclean in $(TARGET_SUBDIR)/libbacktrace"; \
4830         for flag in $(EXTRA_TARGET_FLAGS); do \
4831           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4832         done; \
4833         (cd $(TARGET_SUBDIR)/libbacktrace && \
4834           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4835                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4836                   "RANLIB=$${RANLIB}" \
4837                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4838                    distclean) \
4839           || exit 1
4840
4841 @endif target-libbacktrace
4842
4843 .PHONY: maybe-maintainer-clean-target-libbacktrace maintainer-clean-target-libbacktrace
4844 maybe-maintainer-clean-target-libbacktrace:
4845 @if target-libbacktrace
4846 maybe-maintainer-clean-target-libbacktrace: maintainer-clean-target-libbacktrace
4847
4848 maintainer-clean-target-libbacktrace:
4849         @: $(MAKE); $(unstage)
4850         @[ -f $(TARGET_SUBDIR)/libbacktrace/Makefile ] || exit 0; \
4851         r=`${PWD_COMMAND}`; export r; \
4852         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4853         $(NORMAL_TARGET_EXPORTS) \
4854         echo "Doing maintainer-clean in $(TARGET_SUBDIR)/libbacktrace"; \
4855         for flag in $(EXTRA_TARGET_FLAGS); do \
4856           eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
4857         done; \
4858         (cd $(TARGET_SUBDIR)/libbacktrace && \
4859           $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
4860                   "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
4861                   "RANLIB=$${RANLIB}" \
4862                   "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
4863                    maintainer-clean) \
4864           || exit 1
4865
4866 @endif target-libbacktrace
4867
4868
4869
4870 @if target-libgomp
4871 .PHONY: check-target-libgomp-c++
4872 check-target-libgomp-c++:
4873         $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) c++.exp" check-target-libgomp
4874
4875 .PHONY: check-target-libgomp-fortran
4876 check-target-libgomp-fortran:
4877         $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) fortran.exp" check-target-libgomp
4878
4879 @endif target-libgomp
4880
4881 @if target-libitm
4882 .PHONY: check-target-libitm-c++
4883 check-target-libitm-c++:
4884         $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) c++.exp" check-target-libitm
4885
4886 @endif target-libitm
4887
4888 # ----------
4889 # GCC module
4890 # ----------
4891
4892 .PHONY: cross
4893 cross: all-build all-gas all-ld
4894         @r=`${PWD_COMMAND}`; export r; \
4895         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4896         $(HOST_EXPORTS) \
4897         echo "Building the C and C++ compiler"; \
4898         cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) LANGUAGES="c c++"
4899         @r=`${PWD_COMMAND}`; export r; \
4900         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4901         echo "Building runtime libraries"; \
4902         $(MAKE) $(RECURSE_FLAGS_TO_PASS) LANGUAGES="c c++" all
4903
4904
4905 .PHONY: check-gcc-c check-c
4906 check-gcc-c:
4907         r=`${PWD_COMMAND}`; export r; \
4908         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4909         $(HOST_EXPORTS) \
4910         (cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) check-gcc);
4911 check-c: check-gcc-c
4912
4913
4914 # The gcc part of install-no-fixedincludes, which relies on an intimate
4915 # knowledge of how a number of gcc internal targets (inter)operate.  Delegate.
4916 .PHONY: gcc-install-no-fixedincludes
4917 gcc-install-no-fixedincludes:
4918         @if [ -f ./gcc/Makefile ]; then \
4919           r=`${PWD_COMMAND}`; export r; \
4920           s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
4921           $(HOST_EXPORTS) \
4922           (cd ./gcc \
4923            && $(MAKE) $(GCC_FLAGS_TO_PASS) install-no-fixedincludes); \
4924         else true; fi
4925
4926 # ---------------------
4927 # GCC bootstrap support
4928 # ---------------------
4929
4930 # We track the current stage (the one in 'gcc') in the stage_current file.
4931 # stage_last instead tracks the stage that was built last.  These targets
4932 # are dummy when toplevel bootstrap is not active.
4933
4934 # While making host and target tools, symlinks to the final stage must be
4935 # there, so $(unstage) should be run at various points.  To avoid excessive
4936 # recursive invocations of make, we "inline" them using a variable.  These
4937 # must be referenced as ": $(MAKE) ; $(unstage)" rather than "$(unstage)"
4938 # to avoid warnings from the GNU Make job server.
4939
4940 unstage = :
4941 stage = :
4942 current_stage = ""
4943
4944 .PHONY: unstage stage
4945 unstage:
4946         @: $(MAKE); $(unstage)
4947 stage:
4948         @: $(MAKE); $(stage)
4949
4950 # Disable commands for lean bootstrap.
4951 LEAN = false
4952
4953 # We name the build directories for the various stages "stage1-gcc",
4954 # "stage2-gcc","stage3-gcc", etc.
4955
4956 # Since the 'compare' process will fail (on debugging information) if any
4957 # directory names are different, we need to link the gcc directory for
4958 # the previous stage to a constant name ('prev-gcc'), and to make the name of
4959 # the build directories constant as well. For the latter, we use naked names
4960 # like 'gcc', because the scripts in that directory assume it.  We use
4961 # mv on platforms where symlinks to directories do not work or are not
4962 # reliable.
4963
4964 # 'touch' doesn't work right on some platforms.
4965 STAMP = echo timestamp >
4966
4967 # We only want to compare .o files, so set this!
4968 objext = .o
4969
4970
4971 .PHONY: stage1-start stage1-end
4972
4973 stage1-start::
4974         @: $(MAKE); $(stage); \
4975         echo stage1 > stage_current; \
4976         echo stage1 > stage_last; \
4977         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
4978 @if gcc
4979         @cd $(HOST_SUBDIR); [ -d stage1-gcc ] || \
4980           mkdir stage1-gcc; \
4981         mv stage1-gcc gcc
4982 @endif gcc
4983 @if libbacktrace
4984         @cd $(HOST_SUBDIR); [ -d stage1-libbacktrace ] || \
4985           mkdir stage1-libbacktrace; \
4986         mv stage1-libbacktrace libbacktrace
4987 @endif libbacktrace
4988 @if libcpp
4989         @cd $(HOST_SUBDIR); [ -d stage1-libcpp ] || \
4990           mkdir stage1-libcpp; \
4991         mv stage1-libcpp libcpp
4992 @endif libcpp
4993         @[ -d stage1-$(TARGET_SUBDIR) ] || \
4994           mkdir stage1-$(TARGET_SUBDIR); \
4995         mv stage1-$(TARGET_SUBDIR) $(TARGET_SUBDIR)
4996
4997 stage1-end::
4998 @if gcc
4999         @if test -d $(HOST_SUBDIR)/gcc; then \
5000           cd $(HOST_SUBDIR); mv gcc stage1-gcc; \
5001         fi
5002 @endif gcc
5003 @if libbacktrace
5004         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5005           cd $(HOST_SUBDIR); mv libbacktrace stage1-libbacktrace; \
5006         fi
5007 @endif libbacktrace
5008 @if libcpp
5009         @if test -d $(HOST_SUBDIR)/libcpp; then \
5010           cd $(HOST_SUBDIR); mv libcpp stage1-libcpp; \
5011         fi
5012 @endif libcpp
5013         @if test -d $(TARGET_SUBDIR); then \
5014           mv $(TARGET_SUBDIR) stage1-$(TARGET_SUBDIR); \
5015         fi
5016         rm -f stage_current
5017
5018 # Bubble a bug fix through all the stages up to stage 1.  They are
5019 # remade, but not reconfigured.  The next stage (if any) will not be
5020 # reconfigured either.
5021 .PHONY: stage1-bubble
5022 stage1-bubble::
5023         @r=`${PWD_COMMAND}`; export r; \
5024         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5025         if test -f stage1-lean ; then \
5026           echo Skipping rebuild of stage1; \
5027         else \
5028           $(MAKE) stage1-start; \
5029           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stage1; \
5030         fi
5031
5032 .PHONY: all-stage1 clean-stage1
5033 do-clean: clean-stage1
5034
5035 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5036 # only possibility, but now it conflicts with no-bootstrap rules
5037
5038
5039 .PHONY: stage2-start stage2-end
5040
5041 stage2-start::
5042         @: $(MAKE); $(stage); \
5043         echo stage2 > stage_current; \
5044         echo stage2 > stage_last; \
5045         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5046 @if gcc
5047         @cd $(HOST_SUBDIR); [ -d stage2-gcc ] || \
5048           mkdir stage2-gcc; \
5049         mv stage2-gcc gcc; \
5050         mv stage1-gcc prev-gcc || test -f stage1-lean
5051 @endif gcc
5052 @if libbacktrace
5053         @cd $(HOST_SUBDIR); [ -d stage2-libbacktrace ] || \
5054           mkdir stage2-libbacktrace; \
5055         mv stage2-libbacktrace libbacktrace; \
5056         mv stage1-libbacktrace prev-libbacktrace || test -f stage1-lean
5057 @endif libbacktrace
5058 @if libcpp
5059         @cd $(HOST_SUBDIR); [ -d stage2-libcpp ] || \
5060           mkdir stage2-libcpp; \
5061         mv stage2-libcpp libcpp; \
5062         mv stage1-libcpp prev-libcpp || test -f stage1-lean
5063 @endif libcpp
5064         @[ -d stage2-$(TARGET_SUBDIR) ] || \
5065           mkdir stage2-$(TARGET_SUBDIR); \
5066         mv stage2-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5067         mv stage1-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stage1-lean
5068
5069 stage2-end::
5070 @if gcc
5071         @if test -d $(HOST_SUBDIR)/gcc; then \
5072           cd $(HOST_SUBDIR); mv gcc stage2-gcc; \
5073           mv prev-gcc stage1-gcc; : ; \
5074         fi
5075 @endif gcc
5076 @if libbacktrace
5077         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5078           cd $(HOST_SUBDIR); mv libbacktrace stage2-libbacktrace; \
5079           mv prev-libbacktrace stage1-libbacktrace; : ; \
5080         fi
5081 @endif libbacktrace
5082 @if libcpp
5083         @if test -d $(HOST_SUBDIR)/libcpp; then \
5084           cd $(HOST_SUBDIR); mv libcpp stage2-libcpp; \
5085           mv prev-libcpp stage1-libcpp; : ; \
5086         fi
5087 @endif libcpp
5088         @if test -d $(TARGET_SUBDIR); then \
5089           mv $(TARGET_SUBDIR) stage2-$(TARGET_SUBDIR); \
5090           mv prev-$(TARGET_SUBDIR) stage1-$(TARGET_SUBDIR); : ; \
5091         fi
5092         rm -f stage_current
5093
5094 # Bubble a bug fix through all the stages up to stage 2.  They are
5095 # remade, but not reconfigured.  The next stage (if any) will not be
5096 # reconfigured either.
5097 .PHONY: stage2-bubble
5098 stage2-bubble:: stage1-bubble
5099         @r=`${PWD_COMMAND}`; export r; \
5100         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5101         if test -f stage2-lean || test -f stage1-lean ; then \
5102           echo Skipping rebuild of stage2; \
5103         else \
5104           $(MAKE) stage2-start; \
5105           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stage2; \
5106         fi
5107
5108 .PHONY: all-stage2 clean-stage2
5109 do-clean: clean-stage2
5110
5111 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5112 # only possibility, but now it conflicts with no-bootstrap rules
5113
5114
5115 .PHONY: stage3-start stage3-end
5116
5117 stage3-start::
5118         @: $(MAKE); $(stage); \
5119         echo stage3 > stage_current; \
5120         echo stage3 > stage_last; \
5121         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5122 @if gcc
5123         @cd $(HOST_SUBDIR); [ -d stage3-gcc ] || \
5124           mkdir stage3-gcc; \
5125         mv stage3-gcc gcc; \
5126         mv stage2-gcc prev-gcc || test -f stage2-lean
5127 @endif gcc
5128 @if libbacktrace
5129         @cd $(HOST_SUBDIR); [ -d stage3-libbacktrace ] || \
5130           mkdir stage3-libbacktrace; \
5131         mv stage3-libbacktrace libbacktrace; \
5132         mv stage2-libbacktrace prev-libbacktrace || test -f stage2-lean
5133 @endif libbacktrace
5134 @if libcpp
5135         @cd $(HOST_SUBDIR); [ -d stage3-libcpp ] || \
5136           mkdir stage3-libcpp; \
5137         mv stage3-libcpp libcpp; \
5138         mv stage2-libcpp prev-libcpp || test -f stage2-lean
5139 @endif libcpp
5140         @[ -d stage3-$(TARGET_SUBDIR) ] || \
5141           mkdir stage3-$(TARGET_SUBDIR); \
5142         mv stage3-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5143         mv stage2-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stage2-lean
5144
5145 stage3-end::
5146 @if gcc
5147         @if test -d $(HOST_SUBDIR)/gcc; then \
5148           cd $(HOST_SUBDIR); mv gcc stage3-gcc; \
5149           mv prev-gcc stage2-gcc; : ; \
5150         fi
5151 @endif gcc
5152 @if libbacktrace
5153         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5154           cd $(HOST_SUBDIR); mv libbacktrace stage3-libbacktrace; \
5155           mv prev-libbacktrace stage2-libbacktrace; : ; \
5156         fi
5157 @endif libbacktrace
5158 @if libcpp
5159         @if test -d $(HOST_SUBDIR)/libcpp; then \
5160           cd $(HOST_SUBDIR); mv libcpp stage3-libcpp; \
5161           mv prev-libcpp stage2-libcpp; : ; \
5162         fi
5163 @endif libcpp
5164         @if test -d $(TARGET_SUBDIR); then \
5165           mv $(TARGET_SUBDIR) stage3-$(TARGET_SUBDIR); \
5166           mv prev-$(TARGET_SUBDIR) stage2-$(TARGET_SUBDIR); : ; \
5167         fi
5168         rm -f stage_current
5169
5170 # Bubble a bug fix through all the stages up to stage 3.  They are
5171 # remade, but not reconfigured.  The next stage (if any) will not be
5172 # reconfigured either.
5173 .PHONY: stage3-bubble
5174 stage3-bubble:: stage2-bubble
5175         @r=`${PWD_COMMAND}`; export r; \
5176         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5177         if test -f stage3-lean || test -f stage2-lean ; then \
5178           echo Skipping rebuild of stage3; \
5179         else \
5180           $(MAKE) stage3-start; \
5181           if $(LEAN); then \
5182             rm -rf stage1-*; \
5183             $(STAMP) stage1-lean; \
5184           fi; \
5185           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stage3; \
5186         fi
5187         $(MAKE) $(RECURSE_FLAGS_TO_PASS) compare
5188
5189 .PHONY: all-stage3 clean-stage3
5190 do-clean: clean-stage3
5191
5192 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5193 # only possibility, but now it conflicts with no-bootstrap rules
5194
5195
5196 .PHONY: stage4-start stage4-end
5197
5198 stage4-start::
5199         @: $(MAKE); $(stage); \
5200         echo stage4 > stage_current; \
5201         echo stage4 > stage_last; \
5202         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5203 @if gcc
5204         @cd $(HOST_SUBDIR); [ -d stage4-gcc ] || \
5205           mkdir stage4-gcc; \
5206         mv stage4-gcc gcc; \
5207         mv stage3-gcc prev-gcc || test -f stage3-lean
5208 @endif gcc
5209 @if libbacktrace
5210         @cd $(HOST_SUBDIR); [ -d stage4-libbacktrace ] || \
5211           mkdir stage4-libbacktrace; \
5212         mv stage4-libbacktrace libbacktrace; \
5213         mv stage3-libbacktrace prev-libbacktrace || test -f stage3-lean
5214 @endif libbacktrace
5215 @if libcpp
5216         @cd $(HOST_SUBDIR); [ -d stage4-libcpp ] || \
5217           mkdir stage4-libcpp; \
5218         mv stage4-libcpp libcpp; \
5219         mv stage3-libcpp prev-libcpp || test -f stage3-lean
5220 @endif libcpp
5221         @[ -d stage4-$(TARGET_SUBDIR) ] || \
5222           mkdir stage4-$(TARGET_SUBDIR); \
5223         mv stage4-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5224         mv stage3-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stage3-lean
5225
5226 stage4-end::
5227 @if gcc
5228         @if test -d $(HOST_SUBDIR)/gcc; then \
5229           cd $(HOST_SUBDIR); mv gcc stage4-gcc; \
5230           mv prev-gcc stage3-gcc; : ; \
5231         fi
5232 @endif gcc
5233 @if libbacktrace
5234         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5235           cd $(HOST_SUBDIR); mv libbacktrace stage4-libbacktrace; \
5236           mv prev-libbacktrace stage3-libbacktrace; : ; \
5237         fi
5238 @endif libbacktrace
5239 @if libcpp
5240         @if test -d $(HOST_SUBDIR)/libcpp; then \
5241           cd $(HOST_SUBDIR); mv libcpp stage4-libcpp; \
5242           mv prev-libcpp stage3-libcpp; : ; \
5243         fi
5244 @endif libcpp
5245         @if test -d $(TARGET_SUBDIR); then \
5246           mv $(TARGET_SUBDIR) stage4-$(TARGET_SUBDIR); \
5247           mv prev-$(TARGET_SUBDIR) stage3-$(TARGET_SUBDIR); : ; \
5248         fi
5249         rm -f stage_current
5250
5251 # Bubble a bug fix through all the stages up to stage 4.  They are
5252 # remade, but not reconfigured.  The next stage (if any) will not be
5253 # reconfigured either.
5254 .PHONY: stage4-bubble
5255 stage4-bubble:: stage3-bubble
5256         @r=`${PWD_COMMAND}`; export r; \
5257         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5258         if test -f stage4-lean || test -f stage3-lean ; then \
5259           echo Skipping rebuild of stage4; \
5260         else \
5261           $(MAKE) stage4-start; \
5262           if $(LEAN); then \
5263             rm -rf stage2-*; \
5264             $(STAMP) stage2-lean; \
5265           fi; \
5266           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stage4; \
5267         fi
5268         $(MAKE) $(RECURSE_FLAGS_TO_PASS) compare3
5269
5270 .PHONY: all-stage4 clean-stage4
5271 do-clean: clean-stage4
5272
5273 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5274 # only possibility, but now it conflicts with no-bootstrap rules
5275
5276
5277 .PHONY: stageprofile-start stageprofile-end
5278
5279 stageprofile-start::
5280         @: $(MAKE); $(stage); \
5281         echo stageprofile > stage_current; \
5282         echo stageprofile > stage_last; \
5283         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5284 @if gcc
5285         @cd $(HOST_SUBDIR); [ -d stageprofile-gcc ] || \
5286           mkdir stageprofile-gcc; \
5287         mv stageprofile-gcc gcc; \
5288         mv stage1-gcc prev-gcc || test -f stage1-lean
5289 @endif gcc
5290 @if libbacktrace
5291         @cd $(HOST_SUBDIR); [ -d stageprofile-libbacktrace ] || \
5292           mkdir stageprofile-libbacktrace; \
5293         mv stageprofile-libbacktrace libbacktrace; \
5294         mv stage1-libbacktrace prev-libbacktrace || test -f stage1-lean
5295 @endif libbacktrace
5296 @if libcpp
5297         @cd $(HOST_SUBDIR); [ -d stageprofile-libcpp ] || \
5298           mkdir stageprofile-libcpp; \
5299         mv stageprofile-libcpp libcpp; \
5300         mv stage1-libcpp prev-libcpp || test -f stage1-lean
5301 @endif libcpp
5302         @[ -d stageprofile-$(TARGET_SUBDIR) ] || \
5303           mkdir stageprofile-$(TARGET_SUBDIR); \
5304         mv stageprofile-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5305         mv stage1-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stage1-lean
5306
5307 stageprofile-end::
5308 @if gcc
5309         @if test -d $(HOST_SUBDIR)/gcc; then \
5310           cd $(HOST_SUBDIR); mv gcc stageprofile-gcc; \
5311           mv prev-gcc stage1-gcc; : ; \
5312         fi
5313 @endif gcc
5314 @if libbacktrace
5315         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5316           cd $(HOST_SUBDIR); mv libbacktrace stageprofile-libbacktrace; \
5317           mv prev-libbacktrace stage1-libbacktrace; : ; \
5318         fi
5319 @endif libbacktrace
5320 @if libcpp
5321         @if test -d $(HOST_SUBDIR)/libcpp; then \
5322           cd $(HOST_SUBDIR); mv libcpp stageprofile-libcpp; \
5323           mv prev-libcpp stage1-libcpp; : ; \
5324         fi
5325 @endif libcpp
5326         @if test -d $(TARGET_SUBDIR); then \
5327           mv $(TARGET_SUBDIR) stageprofile-$(TARGET_SUBDIR); \
5328           mv prev-$(TARGET_SUBDIR) stage1-$(TARGET_SUBDIR); : ; \
5329         fi
5330         rm -f stage_current
5331
5332 # Bubble a bug fix through all the stages up to stage profile.  They are
5333 # remade, but not reconfigured.  The next stage (if any) will not be
5334 # reconfigured either.
5335 .PHONY: stageprofile-bubble
5336 stageprofile-bubble:: stage1-bubble
5337         @r=`${PWD_COMMAND}`; export r; \
5338         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5339         if test -f stageprofile-lean || test -f stage1-lean ; then \
5340           echo Skipping rebuild of stageprofile; \
5341         else \
5342           $(MAKE) stageprofile-start; \
5343           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stageprofile; \
5344         fi
5345
5346 .PHONY: all-stageprofile clean-stageprofile
5347 do-clean: clean-stageprofile
5348
5349 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5350 # only possibility, but now it conflicts with no-bootstrap rules
5351
5352
5353 .PHONY: stagetrain-start stagetrain-end
5354
5355 stagetrain-start::
5356         @: $(MAKE); $(stage); \
5357         echo stagetrain > stage_current; \
5358         echo stagetrain > stage_last; \
5359         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5360 @if gcc
5361         @cd $(HOST_SUBDIR); [ -d stagetrain-gcc ] || \
5362           mkdir stagetrain-gcc; \
5363         mv stagetrain-gcc gcc; \
5364         mv stageprofile-gcc prev-gcc || test -f stageprofile-lean
5365 @endif gcc
5366 @if libbacktrace
5367         @cd $(HOST_SUBDIR); [ -d stagetrain-libbacktrace ] || \
5368           mkdir stagetrain-libbacktrace; \
5369         mv stagetrain-libbacktrace libbacktrace; \
5370         mv stageprofile-libbacktrace prev-libbacktrace || test -f stageprofile-lean
5371 @endif libbacktrace
5372 @if libcpp
5373         @cd $(HOST_SUBDIR); [ -d stagetrain-libcpp ] || \
5374           mkdir stagetrain-libcpp; \
5375         mv stagetrain-libcpp libcpp; \
5376         mv stageprofile-libcpp prev-libcpp || test -f stageprofile-lean
5377 @endif libcpp
5378         @[ -d stagetrain-$(TARGET_SUBDIR) ] || \
5379           mkdir stagetrain-$(TARGET_SUBDIR); \
5380         mv stagetrain-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5381         mv stageprofile-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stageprofile-lean
5382
5383 stagetrain-end::
5384 @if gcc
5385         @if test -d $(HOST_SUBDIR)/gcc; then \
5386           cd $(HOST_SUBDIR); mv gcc stagetrain-gcc; \
5387           mv prev-gcc stageprofile-gcc; : ; \
5388         fi
5389 @endif gcc
5390 @if libbacktrace
5391         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5392           cd $(HOST_SUBDIR); mv libbacktrace stagetrain-libbacktrace; \
5393           mv prev-libbacktrace stageprofile-libbacktrace; : ; \
5394         fi
5395 @endif libbacktrace
5396 @if libcpp
5397         @if test -d $(HOST_SUBDIR)/libcpp; then \
5398           cd $(HOST_SUBDIR); mv libcpp stagetrain-libcpp; \
5399           mv prev-libcpp stageprofile-libcpp; : ; \
5400         fi
5401 @endif libcpp
5402         @if test -d $(TARGET_SUBDIR); then \
5403           mv $(TARGET_SUBDIR) stagetrain-$(TARGET_SUBDIR); \
5404           mv prev-$(TARGET_SUBDIR) stageprofile-$(TARGET_SUBDIR); : ; \
5405         fi
5406         rm -f stage_current
5407
5408 # Bubble a bug fix through all the stages up to stage train.  They are
5409 # remade, but not reconfigured.  The next stage (if any) will not be
5410 # reconfigured either.
5411 .PHONY: stagetrain-bubble
5412 stagetrain-bubble:: stageprofile-bubble
5413         @r=`${PWD_COMMAND}`; export r; \
5414         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5415         if test -f stagetrain-lean || test -f stageprofile-lean ; then \
5416           echo Skipping rebuild of stagetrain; \
5417         else \
5418           $(MAKE) stagetrain-start; \
5419           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stagetrain; \
5420         fi
5421
5422 .PHONY: all-stagetrain clean-stagetrain
5423 do-clean: clean-stagetrain
5424
5425 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5426 # only possibility, but now it conflicts with no-bootstrap rules
5427
5428
5429 .PHONY: stagefeedback-start stagefeedback-end
5430
5431 stagefeedback-start::
5432         @: $(MAKE); $(stage); \
5433         echo stagefeedback > stage_current; \
5434         echo stagefeedback > stage_last; \
5435         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5436 @if gcc
5437         @cd $(HOST_SUBDIR); [ -d stagefeedback-gcc ] || \
5438           mkdir stagefeedback-gcc; \
5439         mv stagefeedback-gcc gcc; \
5440         mv stagetrain-gcc prev-gcc || test -f stagetrain-lean
5441 @endif gcc
5442 @if libbacktrace
5443         @cd $(HOST_SUBDIR); [ -d stagefeedback-libbacktrace ] || \
5444           mkdir stagefeedback-libbacktrace; \
5445         mv stagefeedback-libbacktrace libbacktrace; \
5446         mv stagetrain-libbacktrace prev-libbacktrace || test -f stagetrain-lean
5447 @endif libbacktrace
5448 @if libcpp
5449         @cd $(HOST_SUBDIR); [ -d stagefeedback-libcpp ] || \
5450           mkdir stagefeedback-libcpp; \
5451         mv stagefeedback-libcpp libcpp; \
5452         mv stagetrain-libcpp prev-libcpp || test -f stagetrain-lean
5453 @endif libcpp
5454         @[ -d stagefeedback-$(TARGET_SUBDIR) ] || \
5455           mkdir stagefeedback-$(TARGET_SUBDIR); \
5456         mv stagefeedback-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5457         mv stagetrain-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stagetrain-lean
5458
5459 stagefeedback-end::
5460 @if gcc
5461         @if test -d $(HOST_SUBDIR)/gcc; then \
5462           cd $(HOST_SUBDIR); mv gcc stagefeedback-gcc; \
5463           mv prev-gcc stagetrain-gcc; : ; \
5464         fi
5465 @endif gcc
5466 @if libbacktrace
5467         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5468           cd $(HOST_SUBDIR); mv libbacktrace stagefeedback-libbacktrace; \
5469           mv prev-libbacktrace stagetrain-libbacktrace; : ; \
5470         fi
5471 @endif libbacktrace
5472 @if libcpp
5473         @if test -d $(HOST_SUBDIR)/libcpp; then \
5474           cd $(HOST_SUBDIR); mv libcpp stagefeedback-libcpp; \
5475           mv prev-libcpp stagetrain-libcpp; : ; \
5476         fi
5477 @endif libcpp
5478         @if test -d $(TARGET_SUBDIR); then \
5479           mv $(TARGET_SUBDIR) stagefeedback-$(TARGET_SUBDIR); \
5480           mv prev-$(TARGET_SUBDIR) stagetrain-$(TARGET_SUBDIR); : ; \
5481         fi
5482         rm -f stage_current
5483
5484 # Bubble a bug fix through all the stages up to stage feedback.  They are
5485 # remade, but not reconfigured.  The next stage (if any) will not be
5486 # reconfigured either.
5487 .PHONY: stagefeedback-bubble
5488 stagefeedback-bubble:: stagetrain-bubble
5489         @r=`${PWD_COMMAND}`; export r; \
5490         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5491         if test -f stagefeedback-lean || test -f stagetrain-lean ; then \
5492           echo Skipping rebuild of stagefeedback; \
5493         else \
5494           $(MAKE) stagefeedback-start; \
5495           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stagefeedback; \
5496         fi
5497
5498 .PHONY: all-stagefeedback clean-stagefeedback
5499 do-clean: clean-stagefeedback
5500
5501 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5502 # only possibility, but now it conflicts with no-bootstrap rules
5503
5504
5505 .PHONY: stageautoprofile-start stageautoprofile-end
5506
5507 stageautoprofile-start::
5508         @: $(MAKE); $(stage); \
5509         echo stageautoprofile > stage_current; \
5510         echo stageautoprofile > stage_last; \
5511         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5512 @if gcc
5513         @cd $(HOST_SUBDIR); [ -d stageautoprofile-gcc ] || \
5514           mkdir stageautoprofile-gcc; \
5515         mv stageautoprofile-gcc gcc; \
5516         mv stage1-gcc prev-gcc || test -f stage1-lean
5517 @endif gcc
5518 @if libbacktrace
5519         @cd $(HOST_SUBDIR); [ -d stageautoprofile-libbacktrace ] || \
5520           mkdir stageautoprofile-libbacktrace; \
5521         mv stageautoprofile-libbacktrace libbacktrace; \
5522         mv stage1-libbacktrace prev-libbacktrace || test -f stage1-lean
5523 @endif libbacktrace
5524 @if libcpp
5525         @cd $(HOST_SUBDIR); [ -d stageautoprofile-libcpp ] || \
5526           mkdir stageautoprofile-libcpp; \
5527         mv stageautoprofile-libcpp libcpp; \
5528         mv stage1-libcpp prev-libcpp || test -f stage1-lean
5529 @endif libcpp
5530         @[ -d stageautoprofile-$(TARGET_SUBDIR) ] || \
5531           mkdir stageautoprofile-$(TARGET_SUBDIR); \
5532         mv stageautoprofile-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5533         mv stage1-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stage1-lean
5534
5535 stageautoprofile-end::
5536 @if gcc
5537         @if test -d $(HOST_SUBDIR)/gcc; then \
5538           cd $(HOST_SUBDIR); mv gcc stageautoprofile-gcc; \
5539           mv prev-gcc stage1-gcc; : ; \
5540         fi
5541 @endif gcc
5542 @if libbacktrace
5543         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5544           cd $(HOST_SUBDIR); mv libbacktrace stageautoprofile-libbacktrace; \
5545           mv prev-libbacktrace stage1-libbacktrace; : ; \
5546         fi
5547 @endif libbacktrace
5548 @if libcpp
5549         @if test -d $(HOST_SUBDIR)/libcpp; then \
5550           cd $(HOST_SUBDIR); mv libcpp stageautoprofile-libcpp; \
5551           mv prev-libcpp stage1-libcpp; : ; \
5552         fi
5553 @endif libcpp
5554         @if test -d $(TARGET_SUBDIR); then \
5555           mv $(TARGET_SUBDIR) stageautoprofile-$(TARGET_SUBDIR); \
5556           mv prev-$(TARGET_SUBDIR) stage1-$(TARGET_SUBDIR); : ; \
5557         fi
5558         rm -f stage_current
5559
5560 # Bubble a bug fix through all the stages up to stage autoprofile.  They are
5561 # remade, but not reconfigured.  The next stage (if any) will not be
5562 # reconfigured either.
5563 .PHONY: stageautoprofile-bubble
5564 stageautoprofile-bubble:: stage1-bubble
5565         @r=`${PWD_COMMAND}`; export r; \
5566         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5567         if test -f stageautoprofile-lean || test -f stage1-lean ; then \
5568           echo Skipping rebuild of stageautoprofile; \
5569         else \
5570           $(MAKE) stageautoprofile-start; \
5571           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stageautoprofile; \
5572         fi
5573
5574 .PHONY: all-stageautoprofile clean-stageautoprofile
5575 do-clean: clean-stageautoprofile
5576
5577 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5578 # only possibility, but now it conflicts with no-bootstrap rules
5579
5580
5581 .PHONY: stageautofeedback-start stageautofeedback-end
5582
5583 stageautofeedback-start::
5584         @: $(MAKE); $(stage); \
5585         echo stageautofeedback > stage_current; \
5586         echo stageautofeedback > stage_last; \
5587         $(SHELL) $(srcdir)/mkinstalldirs $(HOST_SUBDIR)
5588 @if gcc
5589         @cd $(HOST_SUBDIR); [ -d stageautofeedback-gcc ] || \
5590           mkdir stageautofeedback-gcc; \
5591         mv stageautofeedback-gcc gcc; \
5592         mv stageautoprofile-gcc prev-gcc || test -f stageautoprofile-lean
5593 @endif gcc
5594 @if libbacktrace
5595         @cd $(HOST_SUBDIR); [ -d stageautofeedback-libbacktrace ] || \
5596           mkdir stageautofeedback-libbacktrace; \
5597         mv stageautofeedback-libbacktrace libbacktrace; \
5598         mv stageautoprofile-libbacktrace prev-libbacktrace || test -f stageautoprofile-lean
5599 @endif libbacktrace
5600 @if libcpp
5601         @cd $(HOST_SUBDIR); [ -d stageautofeedback-libcpp ] || \
5602           mkdir stageautofeedback-libcpp; \
5603         mv stageautofeedback-libcpp libcpp; \
5604         mv stageautoprofile-libcpp prev-libcpp || test -f stageautoprofile-lean
5605 @endif libcpp
5606         @[ -d stageautofeedback-$(TARGET_SUBDIR) ] || \
5607           mkdir stageautofeedback-$(TARGET_SUBDIR); \
5608         mv stageautofeedback-$(TARGET_SUBDIR) $(TARGET_SUBDIR); \
5609         mv stageautoprofile-$(TARGET_SUBDIR) prev-$(TARGET_SUBDIR) || test -f stageautoprofile-lean
5610
5611 stageautofeedback-end::
5612 @if gcc
5613         @if test -d $(HOST_SUBDIR)/gcc; then \
5614           cd $(HOST_SUBDIR); mv gcc stageautofeedback-gcc; \
5615           mv prev-gcc stageautoprofile-gcc; : ; \
5616         fi
5617 @endif gcc
5618 @if libbacktrace
5619         @if test -d $(HOST_SUBDIR)/libbacktrace; then \
5620           cd $(HOST_SUBDIR); mv libbacktrace stageautofeedback-libbacktrace; \
5621           mv prev-libbacktrace stageautoprofile-libbacktrace; : ; \
5622         fi
5623 @endif libbacktrace
5624 @if libcpp
5625         @if test -d $(HOST_SUBDIR)/libcpp; then \
5626           cd $(HOST_SUBDIR); mv libcpp stageautofeedback-libcpp; \
5627           mv prev-libcpp stageautoprofile-libcpp; : ; \
5628         fi
5629 @endif libcpp
5630         @if test -d $(TARGET_SUBDIR); then \
5631           mv $(TARGET_SUBDIR) stageautofeedback-$(TARGET_SUBDIR); \
5632           mv prev-$(TARGET_SUBDIR) stageautoprofile-$(TARGET_SUBDIR); : ; \
5633         fi
5634         rm -f stage_current
5635
5636 # Bubble a bug fix through all the stages up to stage autofeedback.  They are
5637 # remade, but not reconfigured.  The next stage (if any) will not be
5638 # reconfigured either.
5639 .PHONY: stageautofeedback-bubble
5640 stageautofeedback-bubble:: stageautoprofile-bubble
5641         @r=`${PWD_COMMAND}`; export r; \
5642         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5643         if test -f stageautofeedback-lean || test -f stageautoprofile-lean ; then \
5644           echo Skipping rebuild of stageautofeedback; \
5645         else \
5646           $(MAKE) stageautofeedback-start; \
5647           $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-stageautofeedback; \
5648         fi
5649
5650 .PHONY: all-stageautofeedback clean-stageautofeedback
5651 do-clean: clean-stageautofeedback
5652
5653 # FIXME: Will not need to be conditional when toplevel bootstrap is the
5654 # only possibility, but now it conflicts with no-bootstrap rules
5655
5656
5657
5658 stageprofile-end::
5659         $(MAKE) distclean-stagefeedback
5660
5661 stagefeedback-start::
5662         @r=`${PWD_COMMAND}`; export r; \
5663         s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
5664         for i in prev-*; do \
5665           j=`echo $$i | sed s/^prev-//`; \
5666           cd $$r/$$i && \
5667           { find . -type d | sort | sed 's,.*,$(SHELL) '"$$s"'/mkinstalldirs "../'$$j'/&",' | $(SHELL); } && \
5668           { find . -name '*.*da' | sed 's,.*,$(LN) -f "&" "../'$$j'/&",' | $(SHELL); }; \
5669         done
5670
5671
5672 # --------------------------------------
5673 # Dependencies between different modules
5674 # --------------------------------------
5675
5676
5677 configure-target-libbacktrace: maybe-all-gcc
5678
5679
5680 # There are two types of dependencies here: 'hard' dependencies, where one
5681 # module simply won't build without the other; and 'soft' dependencies, where
5682 # if the depended-on module is missing, the depending module will do without
5683 # or find a substitute somewhere (perhaps installed).  Soft dependencies
5684 # are made here to depend on a 'maybe-' target.  If you're not sure,
5685 # it's safer to use a soft dependency.
5686
5687
5688
5689
5690
5691
5692 # With all the machinery above in place, it is pretty easy to generate
5693 # dependencies.  Host dependencies are a bit more complex because we have
5694 # to check for bootstrap/prebootstrap dependencies.  To resolve
5695 # prebootstrap dependencies, prebootstrap modules are gathered in
5696 # a hash table.
5697 all-build-bison: maybe-all-build-texinfo
5698 all-build-flex: maybe-all-build-texinfo
5699 all-build-flex: maybe-all-build-bison
5700 all-build-flex: maybe-all-build-m4
5701 all-build-m4: maybe-all-build-texinfo
5702 all-gcc: all-libcpp
5703 all-stage1-gcc: all-stage1-libcpp
5704 all-stage2-gcc: all-stage2-libcpp
5705 all-stage3-gcc: all-stage3-libcpp
5706 all-stage4-gcc: all-stage4-libcpp
5707 all-stageprofile-gcc: all-stageprofile-libcpp
5708 all-stagetrain-gcc: all-stagetrain-libcpp
5709 all-stagefeedback-gcc: all-stagefeedback-libcpp
5710 all-stageautoprofile-gcc: all-stageautoprofile-libcpp
5711 all-stageautofeedback-gcc: all-stageautofeedback-libcpp
5712 all-gcc: all-libbacktrace
5713 all-stage1-gcc: all-stage1-libbacktrace
5714 all-stage2-gcc: all-stage2-libbacktrace
5715 all-stage3-gcc: all-stage3-libbacktrace
5716 all-stage4-gcc: all-stage4-libbacktrace
5717 all-stageprofile-gcc: all-stageprofile-libbacktrace
5718 all-stagetrain-gcc: all-stagetrain-libbacktrace
5719 all-stagefeedback-gcc: all-stagefeedback-libbacktrace
5720 all-stageautoprofile-gcc: all-stageautoprofile-libbacktrace
5721 all-stageautofeedback-gcc: all-stageautofeedback-libbacktrace
5722
5723
5724 @endunless gcc-bootstrap
5725
5726 # Dependencies for target modules on other target modules are
5727 # described by lang_env_dependencies; the defaults apply to anything
5728 # not mentioned there.
5729
5730
5731
5732 configure-target-libbacktrace: maybe-all-target-libgcc
5733
5734
5735 configure-target-libbacktrace: maybe-all-target-newlib maybe-all-target-libgloss
5736
5737
5738 CONFIGURE_GDB_TK = @CONFIGURE_GDB_TK@
5739 GDB_TK = @GDB_TK@
5740 INSTALL_GDB_TK = @INSTALL_GDB_TK@
5741 configure-gdb: $(CONFIGURE_GDB_TK)
5742 all-gdb: $(gdbnlmrequirements) $(GDB_TK)
5743 install-gdb: $(INSTALL_GDB_TK)
5744
5745 # Serialization dependencies.  Host configures don't work well in parallel to
5746 # each other, due to contention over config.cache.  Target configures and
5747 # build configures are similar.
5748 @serialization_dependencies@
5749
5750 # --------------------------------
5751 # Regenerating top level configury
5752 # --------------------------------
5753
5754 # Rebuilding Makefile.in, using autogen.
5755 AUTOGEN = autogen
5756 $(srcdir)/Makefile.in: @MAINT@ $(srcdir)/Makefile.tpl $(srcdir)/Makefile.def
5757         cd $(srcdir) && $(AUTOGEN) Makefile.def
5758
5759 # Rebuilding Makefile.
5760 Makefile: $(srcdir)/Makefile.in config.status
5761         CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
5762
5763 config.status: configure
5764         CONFIG_SHELL="$(SHELL)" $(SHELL) ./config.status --recheck
5765
5766 # Rebuilding configure.
5767 AUTOCONF = autoconf
5768 $(srcdir)/configure: @MAINT@ $(srcdir)/configure.ac $(srcdir)/config/acx.m4 \
5769         $(srcdir)/config/override.m4 $(srcdir)/config/proginstall.m4 \
5770         $(srcdir)/config/elf.m4 $(srcdir)/config/isl.m4 \
5771         $(srcdir)/libtool.m4 $(srcdir)/ltoptions.m4 $(srcdir)/ltsugar.m4 \
5772         $(srcdir)/ltversion.m4 $(srcdir)/lt~obsolete.m4
5773         cd $(srcdir) && $(AUTOCONF)
5774
5775 # ------------------------------
5776 # Special directives to GNU Make
5777 # ------------------------------
5778
5779 # Don't pass command-line variables to submakes.
5780 .NOEXPORT:
5781 MAKEOVERRIDES=
5782
5783 # end of Makefile.in