Subversion Repositories openrisc_2011-10-31

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

#   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

# .

#

# 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@

GDB_NLM_DEPS =

# 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; \

        GCJ="$(GCJ_FOR_BUILD)"; export GCJ; \

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

        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_PASSS.

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@

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

# directories built for the host system.

HOST_CONFIGARGS = @host_configargs@

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

# with srcdir=..

HOST_SUBDIR = @host_subdir@

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

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

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

HOST_EXPORTS = \

        $(BASE_EXPORTS) \

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

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

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

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

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

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

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

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

        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; \

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

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

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

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

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

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

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

        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; \

        PPLLIBS="$(HOST_PPLLIBS)"; export PPLLIBS; \

        PPLINC="$(HOST_PPLINC)"; export PPLINC; \

        CLOOGLIBS="$(HOST_CLOOGLIBS)"; export CLOOGLIBS; \

        CLOOGINC="$(HOST_CLOOGINC)"; export CLOOGINC; \

@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);

# 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; \

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

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

          -I$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/include/$(TARGET_SUBDIR) \

          -I$$r/prev-$(TARGET_SUBDIR)/libstdc++-v3/include \

          -I$$r/$(srcdir)/libstdc++-v3/libsupc++ \

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

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

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

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

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

# Target libraries are put under this directory:

TARGET_SUBDIR = @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 host system.

BASE_TARGET_EXPORTS = \

        $(BASE_EXPORTS) \

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

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

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

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

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

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

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

        GCJ="$(GCJ_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export GCJ; \

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

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

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

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

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

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

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

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

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

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

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

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

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 PPL

HOST_PPLLIBS = @ppllibs@

HOST_PPLINC = @pplinc@

# Where to find CLOOG

HOST_CLOOGLIBS = @clooglibs@

HOST_CLOOGINC = @clooginc@

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

# Programs producing files for the BUILD machine

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

SHELL = @config_shell@

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

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

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

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

# 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@

GCJ_FOR_BUILD = @GCJ_FOR_BUILD@

GFORTRAN_FOR_BUILD = @GFORTRAN_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 -gnata

AWK = @AWK@

SED = @SED@

BISON = @BISON@

YACC = @YACC@

FLEX = @FLEX@

LEX = @LEX@

M4 = @M4@

MAKEINFO = @MAKEINFO@

EXPECT = @EXPECT@

RUNTEST = @RUNTEST@

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

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

# using the makeinfo from the object tree.

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

MAKEINFOFLAGS = --split-size=5000000

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

# 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@

STRIP = @STRIP@

WINDRES = @WINDRES@

WINDMC = @WINDMC@

GNATBIND = @GNATBIND@

GNATMAKE = @GNATMAKE@

CFLAGS = @CFLAGS@

LDFLAGS = @LDFLAGS@

LIBCFLAGS = $(CFLAGS)

CXXFLAGS = @CXXFLAGS@

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

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+]_TFLAGS = $(STAGE_TFLAGS)

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

[+ ENDFOR bootstrap-stage +]

# Only build the C compiler for stage1, because that is the only one that

# we can guarantee will build with the native compiler, and also it is the

# only thing useful for building stage2. STAGE1_CFLAGS (via CFLAGS),

# MAKEINFO and MAKEINFOFLAGS are explicitly passed here to make them

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

STAGE1_CFLAGS = @stage1_cflags@

STAGE1_CHECKING=@stage1_checking@

STAGE1_LANGUAGES=@stage1_languages@

# * We force-disable intermodule optimizations, even if

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

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

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

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

#   compiler probably has never heard of them.

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

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

STAGEprofile_CFLAGS = $(STAGE2_CFLAGS) -fprofile-generate

STAGEprofile_TFLAGS = $(STAGE2_TFLAGS)

STAGEfeedback_CFLAGS = $(STAGE3_CFLAGS) -fprofile-use

STAGEfeedback_TFLAGS = $(STAGE3_TFLAGS)

do-compare = @do_compare@

do-compare3 = $(do-compare)

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

# Programs producing files for the TARGET machine

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

AR_FOR_TARGET=@AR_FOR_TARGET@

AS_FOR_TARGET=@AS_FOR_TARGET@

CC_FOR_TARGET=$(STAGE_CC_WRAPPER) @CC_FOR_TARGET@

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

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

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

# overridden on the command line.

GCC_FOR_TARGET=$(STAGE_CC_WRAPPER) @GCC_FOR_TARGET@

CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @CXX_FOR_TARGET@

RAW_CXX_FOR_TARGET=$(STAGE_CC_WRAPPER) @RAW_CXX_FOR_TARGET@

GCJ_FOR_TARGET=$(STAGE_CC_WRAPPER) @GCJ_FOR_TARGET@

GFORTRAN_FOR_TARGET=$(STAGE_CC_WRAPPER) @GFORTRAN_FOR_TARGET@

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@

RANLIB_FOR_TARGET=@RANLIB_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 =

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 prorgams 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 +]

# Flags to pass down to all sub-makes.

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+]_TFLAGS=$(STAGE[+id+]_TFLAGS)"[+ ENDFOR bootstrap-stage +] \

        "TFLAGS=$(TFLAGS)" \

        "CONFIG_SHELL=$(SHELL)" \

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

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

RECURSE_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS)

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

# the host environment.

EXTRA_HOST_FLAGS = \

        'AR=$(AR)' \

        'AS=$(AS)' \

        'CC=$(CC)' \

        'CXX=$(CXX)' \

        'DLLTOOL=$(DLLTOOL)' \

        'GCJ=$(GCJ)' \

        'GFORTRAN=$(GFORTRAN)' \

        'LD=$(LD)' \

        'LIPO=$(LIPO)' \

        'NM=$(NM)' \

        'OBJDUMP=$(OBJDUMP)' \

        'RANLIB=$(RANLIB)' \

        'STRIP=$(STRIP)' \

        'WINDRES=$(WINDRES)' \

        'WINDMC=$(WINDMC)'

FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS)

# Flags that are concerned with the location of the X11 include files

# and library files

#

# NOTE: until the top-level is getting the values via autoconf, it only

# causes problems to have this top-level Makefile overriding the autoconf-set

# values in child directories.  Only variables that don't conflict with

# autoconf'ed ones should be passed by X11_FLAGS_TO_PASS for now.

#

X11_FLAGS_TO_PASS = \

        'X11_EXTRA_CFLAGS=$(X11_EXTRA_CFLAGS)' \

        'X11_EXTRA_LIBS=$(X11_EXTRA_LIBS)'

# Flags to pass to 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="$(POSTSTAGE1_LDFLAGS) $(BOOT_LDFLAGS)" \

        HOST_LIBS="$(POSTSTAGE1_LIBS)" \

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

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

# The double $ decreases the length of the command line; 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) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \

        'CXXFLAGS=$$(CXXFLAGS_FOR_TARGET)' \

        'DLLTOOL=$$(DLLTOOL_FOR_TARGET)' \

        'GCJ=$$(GCJ_FOR_TARGET) $$(XGCC_FLAGS_FOR_TARGET) $$(TFLAGS)' \

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

        '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)' \

        'RANLIB=$$(RANLIB_FOR_TARGET)' \

        'WINDRES=$$(WINDRES_FOR_TARGET)' \

        'WINDMC=$$(WINDMC_FOR_TARGET)' \

        'XGCC_FLAGS_FOR_TARGET=$(XGCC_FLAGS_FOR_TARGET)' \

        "TFLAGS=$$TFLAGS"

TARGET_FLAGS_TO_PASS = $(BASE_FLAGS_TO_PASS) $(EXTRA_TARGET_FLAGS)

# 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=/'`" \

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

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

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

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

@if gcc

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

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

          rm -rf $(TARGET_SUBDIR); \

        else true; fi

        -rm -rf $(BUILD_SUBDIR)

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

          rm -rf $(HOST_SUBDIR); \

        else true; fi

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

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

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

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

        -rmdir fastjar gcc libiberty texinfo zlib 2>/dev/null

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

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

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

        fi; \

        $(srcdir)/contrib/test_summary -t -i warning.log >$@

        chmod +x $@

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

# Installation targets.

.PHONY: install uninstall

install:

        @: $(MAKE); $(unstage)

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

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

        $(MAKE) $(RECURSE_FLAGS_TO_PASS) installdirs install-host install-target

.PHONY: install-host-nogcc

install-host-nogcc: [+

  FOR host_modules +][+ IF (not (= (get "module") "gcc")) +] \

    maybe-install-[+module+][+ ENDIF +][+

  ENDFOR host_modules +]

.PHONY: install-host

install-host: [+

  FOR host_modules +] \

    maybe-install-[+module+][+

  ENDFOR host_modules +]

.PHONY: install-target

install-target: [+

  FOR target_modules +] \

    maybe-install-target-[+module+][+

  ENDFOR target_modules +]

uninstall:

        @echo "the uninstall target is not supported in this tree"

.PHONY: install.all

install.all: install-no-fixedincludes

        @if [ -f ./gcc/Makefile ] ; then \

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

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

                $(HOST_EXPORTS) \

                (cd ./gcc && \

                $(MAKE) $(FLAGS_TO_PASS) install-headers) ; \

        else \

                true ; \

        fi

# install-no-fixedincludes is used because Cygnus can not distribute

# the fixed header files.

.PHONY: install-no-fixedincludes

install-no-fixedincludes: installdirs install-host-nogcc \

        install-target gcc-no-fixedincludes

### other supporting targets

MAKEDIRS= \

        $(DESTDIR)$(prefix) \

        $(DESTDIR)$(exec_prefix)

.PHONY: installdirs

installdirs: mkinstalldirs

        $(SHELL) $(srcdir)/mkinstalldirs $(MAKEDIRS)

dir.info: do-install-info

        if [ -f $(srcdir)/texinfo/gen-info-dir ] ; then \

          $(srcdir)/texinfo/gen-info-dir $(DESTDIR)$(infodir) $(srcdir)/texinfo/dir.info-template > dir.info.new ; \

          mv -f dir.info.new dir.info ; \

        else true ; \

        fi

dist:

        @echo "Building a full distribution of this tree isn't done"

        @echo "via 'make dist'.  Check out the etc/ subdirectory"

etags tags: TAGS

# Right now this just builds TAGS in each subdirectory.  emacs19 has the

# ability to use several tags files at once, so there is probably no need

# to combine them into one big TAGS file (like CVS 1.3 does).  We could

# (if we felt like it) have this Makefile write a piece of elisp which

# the user could load to tell emacs19 where all the TAGS files we just

# built are.

TAGS: do-TAGS

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

# Macros for configure and all targets

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

[+ DEFINE configure +]

.PHONY: configure-[+prefix+][+module+] maybe-configure-[+prefix+][+module+]

maybe-configure-[+prefix+][+module+]:

@if gcc-bootstrap

configure-[+prefix+][+module+]: stage_current

@endif gcc-bootstrap

@if [+prefix+][+module+]

maybe-configure-[+prefix+][+module+]: configure-[+prefix+][+module+]

configure-[+prefix+][+module+]: [+ IF bootstrap +][+ ELSE +]

        @: $(MAKE); $(unstage)[+ ENDIF bootstrap +]

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

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

        [+ IF check_multilibs

        +]echo "Checking multilib configuration for [+module+]..."; \

        $(SHELL) $(srcdir)/mkinstalldirs [+subdir+]/[+module+] ; \

        $(CC_FOR_TARGET) --print-multi-lib > [+subdir+]/[+module+]/multilib.tmp 2> /dev/null ; \

        if test -r [+subdir+]/[+module+]/multilib.out; then \

          if cmp -s [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; then \

            rm -f [+subdir+]/[+module+]/multilib.tmp; \

          else \

            rm -f [+subdir+]/[+module+]/Makefile; \

            mv [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; \

          fi; \

        else \

          mv [+subdir+]/[+module+]/multilib.tmp [+subdir+]/[+module+]/multilib.out; \

        fi; \

        [+ ENDIF check_multilibs +]test ! -f [+subdir+]/[+module+]/Makefile || exit 0; \

        $(SHELL) $(srcdir)/mkinstalldirs [+subdir+]/[+module+] ; \

        [+exports+] \

        echo Configuring in [+subdir+]/[+module+]; \

        cd "[+subdir+]/[+module+]" || exit 1; \

        case $(srcdir) in \

          /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \

          *) topdir=`echo [+subdir+]/[+module+]/ | \

                sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \

        esac; \

        srcdiroption="--srcdir=$${topdir}/[+module+]"; \

        libsrcdir="$$s/[+module+]"; \

        [+ IF no-config-site +]rm -f no-such-file || : ; \

        CONFIG_SITE=no-such-file [+ ENDIF +]$(SHELL) $${libsrcdir}/configure \

          [+args+] --build=${build_alias} --host=[+host_alias+] \