[+ AutoGen5 template -*- Mode: Makefile -*-

in

+]

# Makefile.in is generated from Makefile.tpl by 'autogen Makefile.def'.

#

# Makefile for directory with subdirs to build.

#   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

#   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

#   2011, 2012, 2013, 2014, 2015, 2016, 2017

#   Free Software Foundation

#

# This file is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 3 of the License, or

# (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; see the file COPYING3.  If not see

# <http://www.gnu.org/licenses/>.

#

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

@if gcc

ifeq (,$(.VARIABLES)) # The variable .VARIABLES, new with 3.80, is never empty.

$(error GNU make version 3.80 or newer is required.)

endif

@endif gcc

# -------------------------------

# Standard Autoconf-set variables

# -------------------------------

VPATH=@srcdir@

build_alias=@build_noncanonical@

build_vendor=@build_vendor@

build_os=@build_os@

build=@build@

host_alias=@host_noncanonical@

host_vendor=@host_vendor@

host_os=@host_os@

host=@host@

target_alias=@target_noncanonical@

target_vendor=@target_vendor@

target_os=@target_os@

target=@target@

program_transform_name = @program_transform_name@

prefix = @prefix@

exec_prefix = @exec_prefix@

srcdir = @srcdir@

bindir = @bindir@

sbindir = @sbindir@

libexecdir = @libexecdir@

datadir = @datadir@

sysconfdir = @sysconfdir@

sharedstatedir = @sharedstatedir@

localstatedir = @localstatedir@

libdir = @libdir@

includedir = @includedir@

oldincludedir = @oldincludedir@

infodir = @infodir@

datarootdir = @datarootdir@

docdir = @docdir@

pdfdir = @pdfdir@

htmldir = @htmldir@

mandir = @mandir@

man1dir = $(mandir)/man1

man2dir = $(mandir)/man2

man3dir = $(mandir)/man3

man4dir = $(mandir)/man4

man5dir = $(mandir)/man5

man6dir = $(mandir)/man6

man7dir = $(mandir)/man7

man8dir = $(mandir)/man8

man9dir = $(mandir)/man9

INSTALL = @INSTALL@

INSTALL_PROGRAM = @INSTALL_PROGRAM@

INSTALL_SCRIPT = @INSTALL_SCRIPT@

INSTALL_DATA = @INSTALL_DATA@

LN = @LN@

LN_S = @LN_S@

MAINT = @MAINT@

MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@

MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@

# -------------------------------------------------

# Miscellaneous non-standard autoconf-set variables

# -------------------------------------------------

# The gcc driver likes to know the arguments it was configured with.

TOPLEVEL_CONFIGURE_ARGUMENTS=@TOPLEVEL_CONFIGURE_ARGUMENTS@

tooldir = @tooldir@

build_tooldir = @build_tooldir@

# This is the name of the environment variable used for the path to

# the libraries.

RPATH_ENVVAR = @RPATH_ENVVAR@

# On targets where RPATH_ENVVAR is PATH, a subdirectory of the GCC build path

# is used instead of the directory itself to avoid including built

# executables in PATH.

GCC_SHLIB_SUBDIR = @GCC_SHLIB_SUBDIR@

# Build programs are put under this directory.

BUILD_SUBDIR = @build_subdir@

# This is set by the configure script to the arguments to use when configuring

# directories built for the build system.

BUILD_CONFIGARGS = @build_configargs@ --with-build-subdir="$(BUILD_SUBDIR)"

# Linker flags to use on the host, for stage1 or when not

# bootstrapping.

STAGE1_LDFLAGS = @stage1_ldflags@

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

STAGE1_LIBS = @stage1_libs@

# Linker flags to use for stage2 and later.

POSTSTAGE1_LDFLAGS = @poststage1_ldflags@

# Libraries to use for stage2 and later.

POSTSTAGE1_LIBS = @poststage1_libs@

# This is the list of variables to export in the environment when

# configuring any subdirectory.  It must also be exported whenever

# recursing into a build directory in case that directory's Makefile

# re-runs configure.

BASE_EXPORTS = \

	FLEX="$(FLEX)"; export FLEX; \

	LEX="$(LEX)"; export LEX; \

	BISON="$(BISON)"; export BISON; \

	YACC="$(YACC)"; export YACC; \

	M4="$(M4)"; export M4; \

	SED="$(SED)"; export SED; \

	AWK="$(AWK)"; export AWK; \

	MAKEINFO="$(MAKEINFO)"; export MAKEINFO;

# This is the list of variables to export in the environment when

# configuring subdirectories for the build system.

BUILD_EXPORTS = \

	$(BASE_EXPORTS) \

	AR="$(AR_FOR_BUILD)"; export AR; \

	AS="$(AS_FOR_BUILD)"; export AS; \

	CC="$(CC_FOR_BUILD)"; export CC; \

	CFLAGS="$(CFLAGS_FOR_BUILD)"; export CFLAGS; \

	CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \

	CXX="$(CXX_FOR_BUILD)"; export CXX; \

	CXXFLAGS="$(CXXFLAGS_FOR_BUILD)"; export CXXFLAGS; \

	GFORTRAN="$(GFORTRAN_FOR_BUILD)"; export GFORTRAN; \

	GOC="$(GOC_FOR_BUILD)"; export GOC; \

	GOCFLAGS="$(GOCFLAGS_FOR_BUILD)"; export GOCFLAGS; \

	DLLTOOL="$(DLLTOOL_FOR_BUILD)"; export DLLTOOL; \

	LD="$(LD_FOR_BUILD)"; export LD; \

	LDFLAGS="$(LDFLAGS_FOR_BUILD)"; export LDFLAGS; \

	NM="$(NM_FOR_BUILD)"; export NM; \

	RANLIB="$(RANLIB_FOR_BUILD)"; export RANLIB; \

	WINDRES="$(WINDRES_FOR_BUILD)"; export WINDRES; \

	WINDMC="$(WINDMC_FOR_BUILD)"; export WINDMC;

# These variables must be set on the make command line for directories

# built for the build system to override those in BASE_FLAGS_TO_PASS.

EXTRA_BUILD_FLAGS = \

	CFLAGS="$(CFLAGS_FOR_BUILD)" \

	LDFLAGS="$(LDFLAGS_FOR_BUILD)"

# This is the list of directories to built for the host system.

SUBDIRS = @configdirs@

TARGET_CONFIGDIRS = @target_configdirs@

# This is set by the configure script to the arguments to use when configuring

# directories built for the host system.

HOST_CONFIGARGS = @host_configargs@

# Host programs are put under this directory, which is . except if building

# with srcdir=..

HOST_SUBDIR = @host_subdir@

# This is the list of variables to export in the environment when

# configuring subdirectories for the host system.  We need to pass

# some to the GCC configure because of its hybrid host/target nature.

HOST_EXPORTS = \

	$(BASE_EXPORTS) \

	CC="$(CC)"; export CC; \

	ADA_CFLAGS="$(ADA_CFLAGS)"; export ADA_CFLAGS; \

	CFLAGS="$(CFLAGS)"; export CFLAGS; \

	CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \

	CXX="$(CXX)"; export CXX; \

	CXXFLAGS="$(CXXFLAGS)"; export CXXFLAGS; \

	GFORTRAN="$(GFORTRAN)"; export GFORTRAN; \

	GOC="$(GOC)"; export GOC; \

	AR="$(AR)"; export AR; \

	AS="$(AS)"; export AS; \

	CC_FOR_BUILD="$(CC_FOR_BUILD)"; export CC_FOR_BUILD; \

	DLLTOOL="$(DLLTOOL)"; export DLLTOOL; \

	LD="$(LD)"; export LD; \

	LDFLAGS="$(STAGE1_LDFLAGS) $(LDFLAGS)"; export LDFLAGS; \

	NM="$(NM)"; export NM; \

	RANLIB="$(RANLIB)"; export RANLIB; \

	WINDRES="$(WINDRES)"; export WINDRES; \

	WINDMC="$(WINDMC)"; export WINDMC; \

	OBJCOPY="$(OBJCOPY)"; export OBJCOPY; \

	OBJDUMP="$(OBJDUMP)"; export OBJDUMP; \

	READELF="$(READELF)"; export READELF; \

	AR_FOR_TARGET="$(AR_FOR_TARGET)"; export AR_FOR_TARGET; \

	AS_FOR_TARGET="$(AS_FOR_TARGET)"; export AS_FOR_TARGET; \

	GCC_FOR_TARGET="$(GCC_FOR_TARGET)"; export GCC_FOR_TARGET; \

	LD_FOR_TARGET="$(LD_FOR_TARGET)"; export LD_FOR_TARGET; \

	NM_FOR_TARGET="$(NM_FOR_TARGET)"; export NM_FOR_TARGET; \

	OBJDUMP_FOR_TARGET="$(OBJDUMP_FOR_TARGET)"; export OBJDUMP_FOR_TARGET; \

	OBJCOPY_FOR_TARGET="$(OBJCOPY_FOR_TARGET)"; export OBJCOPY_FOR_TARGET; \

	RANLIB_FOR_TARGET="$(RANLIB_FOR_TARGET)"; export RANLIB_FOR_TARGET; \

	READELF_FOR_TARGET="$(READELF_FOR_TARGET)"; export READELF_FOR_TARGET; \

	TOPLEVEL_CONFIGURE_ARGUMENTS="$(TOPLEVEL_CONFIGURE_ARGUMENTS)"; export TOPLEVEL_CONFIGURE_ARGUMENTS; \

	HOST_LIBS="$(STAGE1_LIBS)"; export HOST_LIBS; \

	GMPLIBS="$(HOST_GMPLIBS)"; export GMPLIBS; \

	GMPINC="$(HOST_GMPINC)"; export GMPINC; \

	ISLLIBS="$(HOST_ISLLIBS)"; export ISLLIBS; \

	ISLINC="$(HOST_ISLINC)"; export ISLINC; \

	ISLVER="$(HOST_ISLVER)"; export ISLVER; \

	LIBELFLIBS="$(HOST_LIBELFLIBS)"; export LIBELFLIBS; \

	LIBELFINC="$(HOST_LIBELFINC)"; export LIBELFINC; \

	XGCC_FLAGS_FOR_TARGET="$(XGCC_FLAGS_FOR_TARGET)"; export XGCC_FLAGS_FOR_TARGET; \

@if gcc-bootstrap

	$(RPATH_ENVVAR)=`echo "$(TARGET_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \

@endif gcc-bootstrap

	$(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR);

POSTSTAGE1_CXX_EXPORT = \

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

	CXX_FOR_BUILD='$(CXX_FOR_BUILD)'; export CXX_FOR_BUILD;

@if target-libstdc++-v3-bootstrap

# Override the above if we're bootstrapping C++.

POSTSTAGE1_CXX_EXPORT = \

	CXX="$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/prev-gcc/xg++$(exeext) \

	  -B$$r/$(HOST_SUBDIR)/prev-gcc/ -B$(build_tooldir)/bin/ -nostdinc++ \

	  -B$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \

	  -B$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs \

	  `if $(LEAN); then echo ' -isystem '; else echo ' -I'; fi`$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/include/$(TARGET_SUBDIR) \

	  `if $(LEAN); then echo ' -isystem '; else echo ' -I'; fi`$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/include \

	  `if $(LEAN); then echo ' -isystem '; else echo ' -I'; fi`$$s/libstdc++-v3/libsupc++ \

	  -L$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \

	  -L$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs"; \

	  export CXX; \

	CXX_FOR_BUILD="$$CXX"; export CXX_FOR_BUILD;

@endif target-libstdc++-v3-bootstrap

# Similar, for later GCC stages.

POSTSTAGE1_HOST_EXPORTS = \

	$(HOST_EXPORTS) \

	CC="$(STAGE_CC_WRAPPER) $$r/$(HOST_SUBDIR)/prev-gcc/xgcc$(exeext) \

	  -B$$r/$(HOST_SUBDIR)/prev-gcc/ -B$(build_tooldir)/bin/ \

	  $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \

	CC_FOR_BUILD="$$CC"; export CC_FOR_BUILD; \

	$(POSTSTAGE1_CXX_EXPORT) \

	$(LTO_EXPORTS) \

	GNATBIND="$$r/$(HOST_SUBDIR)/prev-gcc/gnatbind"; export GNATBIND; \

	LDFLAGS="$(POSTSTAGE1_LDFLAGS) $(BOOT_LDFLAGS)"; export LDFLAGS; \

	HOST_LIBS="$(POSTSTAGE1_LIBS)"; export HOST_LIBS;

# Target libraries are put under this directory:

TARGET_SUBDIR = @target_subdir@

# This is set by the configure script to the arguments to use when configuring

# directories built for the target.

TARGET_CONFIGARGS = @target_configargs@ --with-target-subdir="$(TARGET_SUBDIR)"

# This is the list of variables to export in the environment when

# configuring subdirectories for the target system.

BASE_TARGET_EXPORTS = \

	$(BASE_EXPORTS) \

	AR="$(AR_FOR_TARGET)"; export AR; \

	AS="$(COMPILER_AS_FOR_TARGET)"; export AS; \

	CC="$(CC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \

	CFLAGS="$(CFLAGS_FOR_TARGET)"; export CFLAGS; \

	CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \

	CPPFLAGS="$(CPPFLAGS_FOR_TARGET)"; export CPPFLAGS; \

	CXXFLAGS="$(CXXFLAGS_FOR_TARGET)"; export CXXFLAGS; \

	GFORTRAN="$(GFORTRAN_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GFORTRAN; \

	GOC="$(GOC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GOC; \

	DLLTOOL="$(DLLTOOL_FOR_TARGET)"; export DLLTOOL; \

	LD="$(COMPILER_LD_FOR_TARGET)"; export LD; \

	LDFLAGS="$(LDFLAGS_FOR_TARGET)"; export LDFLAGS; \

	LIPO="$(LIPO_FOR_TARGET)"; export LIPO; \

	NM="$(COMPILER_NM_FOR_TARGET)"; export NM; \

	OBJDUMP="$(OBJDUMP_FOR_TARGET)"; export OBJDUMP; \

	OBJCOPY="$(OBJCOPY_FOR_TARGET)"; export OBJCOPY; \

	RANLIB="$(RANLIB_FOR_TARGET)"; export RANLIB; \

	READELF="$(READELF_FOR_TARGET)"; export READELF; \

	STRIP="$(STRIP_FOR_TARGET)"; export STRIP; \

	WINDRES="$(WINDRES_FOR_TARGET)"; export WINDRES; \

	WINDMC="$(WINDMC_FOR_TARGET)"; export WINDMC; \

@if gcc-bootstrap

	$(RPATH_ENVVAR)=`echo "$(TARGET_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \

@endif gcc-bootstrap

	$(RPATH_ENVVAR)=`echo "$(HOST_LIB_PATH)$$$(RPATH_ENVVAR)" | sed 's,::*,:,g;s,^:*,,;s,:*$$,,'`; export $(RPATH_ENVVAR); \

	TARGET_CONFIGDIRS="$(TARGET_CONFIGDIRS)"; export TARGET_CONFIGDIRS;

RAW_CXX_TARGET_EXPORTS = \

	$(BASE_TARGET_EXPORTS) \

	CXX_FOR_TARGET="$(RAW_CXX_FOR_TARGET)"; export CXX_FOR_TARGET; \

	CXX="$(RAW_CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;

NORMAL_TARGET_EXPORTS = \

	$(BASE_TARGET_EXPORTS) \

	CXX="$(CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;

# Where to find GMP

HOST_GMPLIBS = @gmplibs@

HOST_GMPINC = @gmpinc@

# Where to find isl

HOST_ISLLIBS = @isllibs@

HOST_ISLINC = @islinc@

HOST_ISLVER = @islver@

# Where to find libelf

HOST_LIBELFLIBS = @libelflibs@

HOST_LIBELFINC = @libelfinc@

# ----------------------------------------------

# Programs producing files for the BUILD machine

# ----------------------------------------------

SHELL = @SHELL@

# pwd command to use.  Allow user to override default by setting PWDCMD in

# the environment to account for automounters.  The make variable must not

# be called PWDCMD, otherwise the value set here is passed to make

# subprocesses and overrides the setting from the user's environment.

# Don't use PWD since it is a common shell environment variable and we

# don't want to corrupt it.

PWD_COMMAND = $${PWDCMD-pwd}

# compilers to use to create programs which must be run in the build

# environment.

AR_FOR_BUILD = @AR_FOR_BUILD@

AS_FOR_BUILD = @AS_FOR_BUILD@

CC_FOR_BUILD = @CC_FOR_BUILD@

CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@

CXXFLAGS_FOR_BUILD = @CXXFLAGS_FOR_BUILD@

CXX_FOR_BUILD = @CXX_FOR_BUILD@

DLLTOOL_FOR_BUILD = @DLLTOOL_FOR_BUILD@

GFORTRAN_FOR_BUILD = @GFORTRAN_FOR_BUILD@

GOC_FOR_BUILD = @GOC_FOR_BUILD@

LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@

LD_FOR_BUILD = @LD_FOR_BUILD@

NM_FOR_BUILD = @NM_FOR_BUILD@

RANLIB_FOR_BUILD = @RANLIB_FOR_BUILD@

WINDMC_FOR_BUILD = @WINDMC_FOR_BUILD@

WINDRES_FOR_BUILD = @WINDRES_FOR_BUILD@

# Special variables passed down in EXTRA_GCC_FLAGS.  They are defined

# here so that they can be overridden by Makefile fragments.

BUILD_PREFIX = @BUILD_PREFIX@

BUILD_PREFIX_1 = @BUILD_PREFIX_1@

# Flags to pass to stage2 and later makes.  They are defined

# here so that they can be overridden by Makefile fragments.

BOOT_CFLAGS= -g -O2

BOOT_LDFLAGS=

BOOT_ADAFLAGS= -gnatpg

AWK = @AWK@

SED = @SED@

BISON = @BISON@

YACC = @YACC@

FLEX = @FLEX@

LEX = @LEX@

M4 = @M4@

MAKEINFO = @MAKEINFO@

EXPECT = @EXPECT@

RUNTEST = @RUNTEST@

AUTO_PROFILE = gcc-auto-profile -c 1000000

# This just becomes part of the MAKEINFO definition passed down to

# sub-makes.  It lets flags be given on the command line while still

# using the makeinfo from the object tree.

# (Default to avoid splitting info files by setting the threshold high.)

MAKEINFOFLAGS = --split-size=5000000

# ---------------------------------------------

# Programs producing files for the HOST machine

# ---------------------------------------------

AS = @AS@

AR = @AR@

AR_FLAGS = rc

CC = @CC@

CXX = @CXX@

DLLTOOL = @DLLTOOL@

LD = @LD@

LIPO = @LIPO@

NM = @NM@

OBJDUMP = @OBJDUMP@

RANLIB = @RANLIB@

READELF = @READELF@

STRIP = @STRIP@

WINDRES = @WINDRES@

WINDMC = @WINDMC@

GNATBIND = @GNATBIND@

GNATMAKE = @GNATMAKE@

CFLAGS = @CFLAGS@

LDFLAGS = @LDFLAGS@

LIBCFLAGS = $(CFLAGS)

CXXFLAGS = @CXXFLAGS@

LIBCXXFLAGS = $(CXXFLAGS) -fno-implicit-templates

GOCFLAGS = $(CFLAGS)

CREATE_GCOV = create_gcov

TFLAGS =

# Defaults for all stages; some are overridden below.

STAGE_CFLAGS = $(BOOT_CFLAGS)

STAGE_TFLAGS = $(TFLAGS)

STAGE_CONFIGURE_FLAGS=@stage2_werror_flag@

[+ FOR bootstrap-stage +]

# Defaults for stage [+id+]; some are overridden below.

STAGE[+id+]_CFLAGS = $(STAGE_CFLAGS)

STAGE[+id+]_CXXFLAGS = $(CXXFLAGS)

@if target-libstdc++-v3-bootstrap

# Override the above if we're bootstrapping C++.

STAGE[+id+]_CXXFLAGS = $(STAGE[+id+]_CFLAGS)

@endif target-libstdc++-v3-bootstrap

STAGE[+id+]_TFLAGS = $(STAGE_TFLAGS)

STAGE[+id+]_CONFIGURE_FLAGS = $(STAGE_CONFIGURE_FLAGS)

[+ ENDFOR bootstrap-stage +]

# By default, C and C++ are the only stage1 languages, because they are the

# only ones we require to build with the bootstrap compiler, and also the

# only ones useful for building stage2.

STAGE1_CFLAGS = @stage1_cflags@

STAGE1_CHECKING = @stage1_checking@

STAGE1_LANGUAGES = @stage1_languages@

# * We force-disable intermodule optimizations, even if

#   --enable-intermodule was passed, since the installed compiler

#   probably can't handle them.  Luckily, autoconf always respects

#   the last argument when conflicting --enable arguments are passed.

# * Likewise, we force-disable coverage flags, since the installed

#   compiler probably has never heard of them.

# * We also disable -Wformat, since older GCCs don't understand newer %s.

STAGE1_CONFIGURE_FLAGS = --disable-intermodule $(STAGE1_CHECKING) \

	  --disable-coverage --enable-languages="$(STAGE1_LANGUAGES)" \

	  --disable-build-format-warnings

STAGEprofile_CFLAGS = $(STAGE2_CFLAGS) -fprofile-generate

STAGEprofile_TFLAGS = $(STAGE2_TFLAGS)

STAGEfeedback_CFLAGS = $(STAGE3_CFLAGS) -fprofile-use

STAGEfeedback_TFLAGS = $(STAGE3_TFLAGS)

STAGEautoprofile_CFLAGS = $(STAGE2_CFLAGS) -g

STAGEautoprofile_TFLAGS = $(STAGE2_TFLAGS)

STAGEautofeedback_CFLAGS = $(STAGE3_CFLAGS)

STAGEautofeedback_TFLAGS = $(STAGE3_TFLAGS)

do-compare = @do_compare@

do-compare3 = $(do-compare)

# -----------------------------------------------

# Programs producing files for the TARGET machine

# -----------------------------------------------

AR_FOR_TARGET=@AR_FOR_TARGET@

AS_FOR_TARGET=@AS_FOR_TARGET@

CC_FOR_TARGET=$(STAGE_CC_WRAPPER) @CC_FOR_TARGET@

# If GCC_FOR_TARGET is not overriden on the command line, then this

# variable is passed down to the gcc Makefile, where it is used to

# build libgcc2.a.  We define it here so that it can itself be

# overridden on the command line.

GCC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GCC_FOR_TARGET@

CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @CXX_FOR_TARGET@

RAW_CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @RAW_CXX_FOR_TARGET@

GFORTRAN_FOR_TARGET=$(STAGE_CC_WRAPPER) @GFORTRAN_FOR_TARGET@

GOC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GOC_FOR_TARGET@

DLLTOOL_FOR_TARGET=@DLLTOOL_FOR_TARGET@

LD_FOR_TARGET=@LD_FOR_TARGET@

LIPO_FOR_TARGET=@LIPO_FOR_TARGET@

NM_FOR_TARGET=@NM_FOR_TARGET@

OBJDUMP_FOR_TARGET=@OBJDUMP_FOR_TARGET@

OBJCOPY_FOR_TARGET=@OBJCOPY_FOR_TARGET@

RANLIB_FOR_TARGET=@RANLIB_FOR_TARGET@

READELF_FOR_TARGET=@READELF_FOR_TARGET@

STRIP_FOR_TARGET=@STRIP_FOR_TARGET@

WINDRES_FOR_TARGET=@WINDRES_FOR_TARGET@

WINDMC_FOR_TARGET=@WINDMC_FOR_TARGET@

COMPILER_AS_FOR_TARGET=@COMPILER_AS_FOR_TARGET@

COMPILER_LD_FOR_TARGET=@COMPILER_LD_FOR_TARGET@

COMPILER_NM_FOR_TARGET=@COMPILER_NM_FOR_TARGET@

CFLAGS_FOR_TARGET = @CFLAGS_FOR_TARGET@

CXXFLAGS_FOR_TARGET = @CXXFLAGS_FOR_TARGET@

LIBCFLAGS_FOR_TARGET = $(CFLAGS_FOR_TARGET)

LIBCXXFLAGS_FOR_TARGET = $(CXXFLAGS_FOR_TARGET) -fno-implicit-templates

LDFLAGS_FOR_TARGET = @LDFLAGS_FOR_TARGET@

GOCFLAGS_FOR_TARGET = -O2 -g

FLAGS_FOR_TARGET = @FLAGS_FOR_TARGET@

SYSROOT_CFLAGS_FOR_TARGET = @SYSROOT_CFLAGS_FOR_TARGET@

DEBUG_PREFIX_CFLAGS_FOR_TARGET = @DEBUG_PREFIX_CFLAGS_FOR_TARGET@

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

# ------------------------------------

# Miscellaneous targets and flag lists

# ------------------------------------

# The first rule in the file had better be this one.  Don't put any above it.

# This lives here to allow makefile fragments to contain dependencies.

all:

#### host and target specific makefile fragments come in here.

@target_makefile_frag@

@alphaieee_frag@

@ospace_frag@

@host_makefile_frag@

###

# This is the list of directories that may be needed in RPATH_ENVVAR

# so that programs built for the target machine work.

TARGET_LIB_PATH = [+ FOR target_modules +][+

  IF lib_path +]$(TARGET_LIB_PATH_[+module+])[+ ENDIF lib_path +][+

  ENDFOR target_modules +]$(HOST_LIB_PATH_gcc)

[+ FOR target_modules +][+ IF lib_path +]

@if target-[+module+]

TARGET_LIB_PATH_[+module+] = $$r/$(TARGET_SUBDIR)/[+module+]/[+lib_path+]:

@endif target-[+module+]

[+ ENDIF lib_path +][+ ENDFOR target_modules +]

# This is the list of directories that may be needed in RPATH_ENVVAR

# so that programs built for the host machine work.

HOST_LIB_PATH = [+ FOR host_modules +][+

  IF lib_path +]$(HOST_LIB_PATH_[+module+])[+ ENDIF lib_path +][+

  ENDFOR host_modules +]

# Define HOST_LIB_PATH_gcc here, for the sake of TARGET_LIB_PATH, ouch

@if gcc

HOST_LIB_PATH_gcc = $$r/$(HOST_SUBDIR)/gcc$(GCC_SHLIB_SUBDIR):$$r/$(HOST_SUBDIR)/prev-gcc$(GCC_SHLIB_SUBDIR):

@endif gcc

[+ FOR host_modules +][+ IF lib_path +]

@if [+module+]

HOST_LIB_PATH_[+module+] = \

  $$r/$(HOST_SUBDIR)/[+module+]/[+lib_path+]:[+ IF bootstrap

  +]$$r/$(HOST_SUBDIR)/prev-[+module+]/[+lib_path+]:[+ ENDIF bootstrap +]

@endif [+module+]

[+ ENDIF lib_path +][+ ENDFOR host_modules +]

CXX_FOR_TARGET_FLAG_TO_PASS = \

	"CXX_FOR_TARGET=$(CXX_FOR_TARGET)"

@if target-libstdc++-v3

# CXX_FOR_TARGET is tricky to get right for target libs that require a

# functional C++ compiler.  When we recurse, if we expand

# CXX_FOR_TARGET before configuring libstdc++-v3, we won't get

# libstdc++ include flags from the script.  Instead, we get an

# -funconfigured-* word, so that we'll get errors if this invalid C++

# command line is used for anything, but also so that we can use the

# word to decide whether or not to pass on this CXX_FOR_TARGET.  If we

# don't pass it on, sub-make will use the default definition, that

# re-expands it at the time of use, so we'll get it right when we need

# it.  One potential exception is the expansion of CXX_FOR_TARGET

# passed down as part of CXX within TARGET_FLAGS, but this wouldn't

# really work, for C++ host programs can't depend on the current-stage

# C++ target library.

CXX_FOR_TARGET_FLAG_TO_PASS = \

	$(shell if echo "$(CXX_FOR_TARGET)" | grep " -funconfigured-" > /dev/null; then :; else echo '"CXX_FOR_TARGET=$(CXX_FOR_TARGET)"'; fi)

@endif target-libstdc++-v3

# Flags to pass down to all sub-makes. STAGE*FLAGS,

# MAKEINFO and MAKEINFOFLAGS are explicitly passed here to make them

# overrideable (for a bootstrap build stage1 also builds gcc.info).

BASE_FLAGS_TO_PASS =[+ FOR flags_to_pass +][+ IF optional +] \

	"`echo '[+flag+]=$([+flag+])' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"[+ ELSE optional +] \

	"[+flag+]=$([+flag+])"[+ ENDIF optional+][+ ENDFOR flags_to_pass +][+ FOR bootstrap-stage +] \

	"STAGE[+id+]_CFLAGS=$(STAGE[+id+]_CFLAGS)" \

	"STAGE[+id+]_CXXFLAGS=$(STAGE[+id+]_CXXFLAGS)" \

	"STAGE[+id+]_TFLAGS=$(STAGE[+id+]_TFLAGS)"[+ ENDFOR bootstrap-stage +] \

	$(CXX_FOR_TARGET_FLAG_TO_PASS) \

	"TFLAGS=$(TFLAGS)" \

	"CONFIG_SHELL=$(SHELL)" \

	"MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \

	$(if $(LSAN_OPTIONS),"LSAN_OPTIONS=$(LSAN_OPTIONS)")

# We leave this in just in case, but it is not needed anymore.

RECURSE_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS)

# Flags to pass down to most sub-makes, in which we're building with

# the host environment.

EXTRA_HOST_FLAGS = \

	'AR=$(AR)' \

	'AS=$(AS)' \

	'CC=$(CC)' \

	'CXX=$(CXX)' \

	'DLLTOOL=$(DLLTOOL)' \

	'GFORTRAN=$(GFORTRAN)' \

	'GOC=$(GOC)' \

	'LD=$(LD)' \

	'LIPO=$(LIPO)' \

	'NM=$(NM)' \

	'OBJDUMP=$(OBJDUMP)' \

	'RANLIB=$(RANLIB)' \

	'READELF=$(READELF)' \

	'STRIP=$(STRIP)' \

	'WINDRES=$(WINDRES)' \

	'WINDMC=$(WINDMC)' \

	'CREATE_GCOV=$(CREATE_GCOV)'

FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS)

# Flags to pass to stage1 or when not bootstrapping.

STAGE1_FLAGS_TO_PASS = \

	LDFLAGS="$${LDFLAGS}" \

	HOST_LIBS="$${HOST_LIBS}"

# Flags to pass to stage2 and later makes.

POSTSTAGE1_FLAGS_TO_PASS = \

	CC="$${CC}" CC_FOR_BUILD="$${CC_FOR_BUILD}" \

	CXX="$${CXX}" CXX_FOR_BUILD="$${CXX_FOR_BUILD}" \

	GNATBIND="$${GNATBIND}" \

	LDFLAGS="$${LDFLAGS}" \

	HOST_LIBS="$${HOST_LIBS}" \

	$(LTO_FLAGS_TO_PASS) \

	"`echo 'ADAFLAGS=$(BOOT_ADAFLAGS)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"

@if gcc-bootstrap

EXTRA_HOST_EXPORTS = if [ $(current_stage) != stage1 ]; then \

		       $(POSTSTAGE1_HOST_EXPORTS) \

		     fi;

EXTRA_BOOTSTRAP_FLAGS = CC="$$CC" CXX="$$CXX" LDFLAGS="$$LDFLAGS"

@endif gcc-bootstrap

# Flags to pass down to makes which are built with the target environment.

# The double $ decreases the length of the command line; those variables

# are set in BASE_FLAGS_TO_PASS, and the sub-make will expand them.  The

# *_CFLAGS_FOR_TARGET variables are not passed down and most often empty,

# so we expand them here.

EXTRA_TARGET_FLAGS = \

	'AR=$$(AR_FOR_TARGET)' \

	'AS=$(COMPILER_AS_FOR_TARGET)' \

	'CC=$$(CC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \

	'CFLAGS=$$(CFLAGS_FOR_TARGET)' \

	'CXX=$$(CXX_FOR_TARGET) -B$$r/$$(TARGET_SUBDIR)/libstdc++-v3/src/.libs \

	 -B$$r/$$(TARGET_SUBDIR)/libstdc++-v3/libsupc++/.libs \

	 $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \

	'CXXFLAGS=$$(CXXFLAGS_FOR_TARGET)' \

	'DLLTOOL=$$(DLLTOOL_FOR_TARGET)' \

	'GFORTRAN=$$(GFORTRAN_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \

	'GOC=$$(GOC_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \

	'GOCFLAGS=$$(GOCFLAGS_FOR_TARGET)' \

	'LD=$(COMPILER_LD_FOR_TARGET)' \

	'LDFLAGS=$$(LDFLAGS_FOR_TARGET)' \

	'LIBCFLAGS=$$(LIBCFLAGS_FOR_TARGET)' \

	'LIBCXXFLAGS=$$(LIBCXXFLAGS_FOR_TARGET)' \

	'NM=$(COMPILER_NM_FOR_TARGET)' \

	'OBJDUMP=$$(OBJDUMP_FOR_TARGET)' \

	'OBJCOPY=$$(OBJCOPY_FOR_TARGET)' \

	'RANLIB=$$(RANLIB_FOR_TARGET)' \

	'READELF=$$(READELF_FOR_TARGET)' \

	'WINDRES=$$(WINDRES_FOR_TARGET)' \

	'WINDMC=$$(WINDMC_FOR_TARGET)' \

	'XGCC_FLAGS_FOR_TARGET=$(XGCC_FLAGS_FOR_TARGET)' \

	'STAGE1_LDFLAGS=$$(POSTSTAGE1_LDFLAGS)' \

	'STAGE1_LIBS=$$(POSTSTAGE1_LIBS)' \

	"TFLAGS=$$TFLAGS"

TARGET_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_TARGET_FLAGS)

# Flags to pass down to gcc.  gcc builds a library, libgcc.a, so it

# unfortunately needs the native compiler and the target ar and

# ranlib.

# If any variables are added here, they must be added to do-*, below.

# The BUILD_* variables are a special case, which are used for the gcc

# cross-building scheme.

EXTRA_GCC_FLAGS = \

	"GCC_FOR_TARGET=$(GCC_FOR_TARGET)" \

	"`echo 'STMP_FIXPROTO=$(STMP_FIXPROTO)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`" \

	"`echo 'LIMITS_H_TEST=$(LIMITS_H_TEST)' | sed -e s'/[^=][^=]*=$$/XFOO=/'`"

GCC_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) $(EXTRA_GCC_FLAGS)

@if gcc

BUILD_CONFIG = @BUILD_CONFIG@

ifneq ($(BUILD_CONFIG),)

include $(foreach CONFIG, $(BUILD_CONFIG), $(srcdir)/config/$(CONFIG).mk)

endif

@endif gcc

.PHONY: configure-host

configure-host: [+

  FOR host_modules +] \

    maybe-configure-[+module+][+

  ENDFOR host_modules +]

.PHONY: configure-target

configure-target: [+

  FOR target_modules +] \

    maybe-configure-target-[+module+][+

  ENDFOR target_modules +]

# The target built for a native non-bootstrap build.

.PHONY: all

all:

@if gcc-bootstrap

	[ -f stage_final ] || echo stage3 > stage_final

	@r=`${PWD_COMMAND}`; export r; \

	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \

	$(MAKE) $(RECURSE_FLAGS_TO_PASS) `cat stage_final`-bubble

@endif gcc-bootstrap

	@: $(MAKE); $(unstage)

	@r=`${PWD_COMMAND}`; export r; \

	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \

@if gcc-bootstrap

	if [ -f stage_last ]; then \

	  TFLAGS="$(STAGE$(shell test ! -f stage_last || sed s,^stage,, stage_last)_TFLAGS)"; \

	  $(MAKE) $(TARGET_FLAGS_TO_PASS) all-host all-target; \

	else \

@endif gcc-bootstrap

	  $(MAKE) $(RECURSE_FLAGS_TO_PASS) all-host all-target \

@if gcc-bootstrap

	    ; \

	fi \

@endif gcc-bootstrap

	&& :

.PHONY: all-build

[+ FOR build_modules +]

all-build: maybe-all-build-[+module+][+ ENDFOR build_modules +]

.PHONY: all-host

[+ FOR host_modules +][+ IF bootstrap +]

@if [+module+]-no-bootstrap[+ ENDIF bootstrap +]

all-host: maybe-all-[+module+][+ IF bootstrap +]

@endif [+module+]-no-bootstrap[+ ENDIF bootstrap +][+ ENDFOR host_modules +]

.PHONY: all-target

[+ FOR target_modules +][+ IF bootstrap +]

@if target-[+module+]-no-bootstrap[+ ENDIF bootstrap +]

all-target: maybe-all-target-[+module+][+ IF bootstrap +]

@endif target-[+module+]-no-bootstrap[+

  ENDIF bootstrap +][+ ENDFOR target_modules +]

# Do a target for all the subdirectories.  A ``make do-X'' will do a

# ``make X'' in all subdirectories (because, in general, there is a

# dependency (below) of X upon do-X, a ``make X'' will also do this,

# but it may do additional work as well).

[+ FOR recursive_targets +]

.PHONY: do-[+make_target+]

do-[+make_target+]:

	@: $(MAKE); $(unstage)

	@r=`${PWD_COMMAND}`; export r; \

	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \

	$(MAKE) $(RECURSE_FLAGS_TO_PASS) [+make_target+]-host \

	  [+make_target+]-target

.PHONY: [+make_target+]-host

[+ FOR host_modules +]

[+make_target+]-host: maybe-[+make_target+]-[+module+][+ ENDFOR host_modules +]

.PHONY: [+make_target+]-target

[+ FOR target_modules +]

[+make_target+]-target: maybe-[+make_target+]-target-[+module+][+ ENDFOR target_modules +]

[+ ENDFOR recursive_targets +]

# Here are the targets which correspond to the do-X targets.

.PHONY: info installcheck dvi pdf html

.PHONY: install-info install-pdf install-html

.PHONY: clean distclean mostlyclean maintainer-clean realclean

.PHONY: local-clean local-distclean local-maintainer-clean

info: do-info

installcheck: do-installcheck

dvi: do-dvi

pdf: do-pdf

html: do-html

# Make sure makeinfo is built before we do a `make info', if we're

# in fact building texinfo.

do-info: maybe-all-texinfo

install-info: do-install-info dir.info

	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \

	if [ -f dir.info ]; then \

	  $(INSTALL_DATA) dir.info $(DESTDIR)$(infodir)/dir.info; \

	else true; fi

install-pdf: do-install-pdf

install-html: do-install-html

local-clean:

	-rm -f *.a TEMP errs core *.o *~ \#* TAGS *.E *.log

local-distclean:

	-rm -f Makefile config.status config.cache mh-frag mt-frag

	-rm -f maybedep.tmp serdep.tmp stage_final

	-if [ "$(TARGET_SUBDIR)" != "." ]; then \

	  rm -rf $(TARGET_SUBDIR); \

	else true; fi

	-rm -rf $(BUILD_SUBDIR)

	-if [ "$(HOST_SUBDIR)" != "." ]; then \

	  rm -rf $(HOST_SUBDIR); \

	else true; fi

	-rm -f texinfo/po/Makefile texinfo/po/Makefile.in texinfo/info/Makefile

	-rm -f texinfo/doc/Makefile texinfo/po/POTFILES

	-rmdir texinfo/doc texinfo/info texinfo/intl texinfo/lib 2>/dev/null

	-rmdir texinfo/makeinfo texinfo/po texinfo/util 2>/dev/null

	-rmdir fastjar gcc gnattools gotools libcc1 libiberty 2>/dev/null

	-rmdir texinfo zlib 2>/dev/null

	-find . -name config.cache -exec rm -f {} \; \; 2>/dev/null

local-maintainer-clean:

	@echo "This command is intended for maintainers to use;"

	@echo "it deletes files that may require special tools to rebuild."

clean: do-clean local-clean

mostlyclean: do-mostlyclean local-clean

distclean: do-distclean local-clean local-distclean

maintainer-clean: local-maintainer-clean do-maintainer-clean local-clean 

maintainer-clean: local-distclean

realclean: maintainer-clean

# Check target.

.PHONY: check do-check

check: do-check

# Only include modules actually being configured and built.

.PHONY: check-host

check-host: [+

  FOR host_modules +] \

    maybe-check-[+module+][+

  ENDFOR host_modules +]

.PHONY: check-target

check-target: [+

  FOR target_modules +] \

    maybe-check-target-[+module+][+

  ENDFOR target_modules +]

do-check:

	@: $(MAKE); $(unstage)

	@r=`${PWD_COMMAND}`; export r; \

	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \

	$(MAKE) $(RECURSE_FLAGS_TO_PASS) check-host check-target

# Automated reporting of test results.

warning.log: build.log

	$(srcdir)/contrib/warn_summary build.log > $@

mail-report.log:

	if test x'$(BOOT_CFLAGS)' != x''; then \

	    BOOT_CFLAGS='$(BOOT_CFLAGS)'; export BOOT_CFLAGS; \

	fi; \

	$(srcdir)/contrib/test_summary -t >$@

	chmod +x $@

	echo If you really want to send e-mail, run ./$@ now

mail-report-with-warnings.log: warning.log