# The first rule in the file had better be this one. Don't put any above it.
# This lives here to allow makefile fragments to contain dependencies.
-all: all.normal
-.PHONY: all
+@default_target@:
#### host and target specific makefile fragments come in here.
@target_makefile_frag@
maybe-configure-target-rda \
maybe-configure-target-libada
-# The target built for a native build.
-.PHONY: all.normal
-all.normal: @all_build_modules@ all-host all-target
+# The target built for a native non-bootstrap build.
+.PHONY: all
+all: @all_build_modules@ all-host all-target
.PHONY: all-host
all-host: maybe-all-gcc \
@if gcc
maybe-configure-gcc: configure-gcc
configure-gcc:
+@endif gcc
+@if gcc-no-bootstrap
@test ! -f gcc/Makefile || exit 0; \
- [ -f stage_last ] && exit 0; \
[ -d gcc ] || mkdir gcc; \
r=`${PWD_COMMAND}`; export r; \
s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
$(SHELL) $${libsrcdir}/configure \
$(HOST_CONFIGARGS) $${srcdiroption} \
|| exit 1
-@endif gcc
+@endif gcc-no-bootstrap
# Don't 'make all' in gcc if it's already been made by 'bootstrap'; that
# causes trouble. This wart will be fixed eventually by moving
@if gcc
maybe-all-gcc: all-gcc
all-gcc: configure-gcc
+@endif gcc
+@if gcc-no-bootstrap
r=`${PWD_COMMAND}`; export r; \
s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(SET_LIB_PATH) \
$(GCC_HOST_EXPORTS) \
- if [ -f stage_last ] ; then \
- true ; \
- elif [ -f gcc/stage_last ] ; then \
- $(SET_LIB_PATH) \
+ if [ -f gcc/stage_last ] ; then \
(cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) quickstrap); \
else \
- $(SET_LIB_PATH) \
(cd gcc && $(MAKE) $(GCC_FLAGS_TO_PASS) all); \
fi
-@endif gcc
# Building GCC uses some tools for rebuilding "source" files
# like texinfo, bison/byacc, etc. So we must depend on those.
$(SET_LIB_PATH) \
echo "Building runtime libraries"; \
$(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) \
- LANGUAGES="c c++" all
+ LANGUAGES="c c++" all
+@endif gcc-no-bootstrap
.PHONY: check-gcc maybe-check-gcc
maybe-check-gcc:
+@if gcc-bootstrap
# ---------------------
# GCC bootstrap support
# ---------------------
# Real targets act phony if they depend on phony targets; this hack
# prevents gratuitous rebuilding of stage 1.
prebootstrap:
- $(MAKE) all-bootstrap
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-bootstrap
$(STAMP) prebootstrap
# Flags to pass to stage2 and later makes.
# * We build only C (and possibly Ada).
-.PHONY: new-stage1-start new-stage1-end
+.PHONY: stage1-start stage1-end
-new-stage1-start:
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+stage1-start:
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
echo stage1 > stage_last ; \
[ -d stage1-gcc ] || mkdir stage1-gcc; \
set stage1-gcc gcc ; @CREATE_LINK_TO_DIR@
-new-stage1-end:
+stage1-end:
rm -f stage_last ; \
set gcc stage1-gcc ; @UNDO_LINK_TO_DIR@
# Bubble a bugfix through all the stages up to stage 1. They
# are remade, but not reconfigured. The next stage (if any) will not
# be reconfigured as well.
-.PHONY: new-stage1-bubble
-new-stage1-bubble:
+.PHONY: stage1-bubble
+stage1-bubble:
@if [ -f all-stage1-gcc ] ; then \
echo Remaking stage 1 ; \
rm -f all-stage1-gcc ; \
- $(MAKE) all-stage1-gcc && \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) \
+ all-stage1-gcc && \
if [ -f configure-stage2-gcc ] ; then \
$(STAMP) configure-stage2-gcc ; \
fi ; \
else \
- $(MAKE) all-stage1-gcc ; \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-stage1-gcc ; \
fi
configure-stage1-gcc: prebootstrap
- $(MAKE) new-stage1-start
+ $(MAKE) stage1-start
@if [ -f stage1-gcc/Makefile ] ; then \
$(STAMP) configure-stage1-gcc ; \
exit 0; \
$(STAMP) ../configure-stage1-gcc
all-stage1-gcc: configure-stage1-gcc
- $(MAKE) new-stage1-start
+ $(MAKE) stage1-start
@r=`${PWD_COMMAND}`; export r; \
s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
$(GCC_HOST_EXPORTS) \
-.PHONY: new-restage1 distclean-stage1
+.PHONY: restage1 distclean-stage1
distclean-stage1: distclean-stage2
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
rm -rf configure-stage1-gcc all-stage1-gcc stage1-gcc
-new-restage1: distclean-stage2
+restage1: distclean-stage2
rm -rf all-stage1-gcc
- $(MAKE) all-stage1-gcc
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-stage1-gcc
-.PHONY: new-stage2-start new-stage2-end
+.PHONY: stage2-start stage2-end
-new-stage2-start:
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+stage2-start:
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
echo stage2 > stage_last ; \
[ -d stage2-gcc ] || mkdir stage2-gcc; \
set stage2-gcc gcc ; @CREATE_LINK_TO_DIR@ ; \
set stage1-gcc prev-gcc ; @CREATE_LINK_TO_DIR@
-new-stage2-end:
+stage2-end:
rm -f stage_last ; \
set gcc stage2-gcc ; @UNDO_LINK_TO_DIR@ ; \
set prev-gcc stage1-gcc ; @UNDO_LINK_TO_DIR@
# Bubble a bugfix through all the stages up to stage 2. They
# are remade, but not reconfigured. The next stage (if any) will not
# be reconfigured as well.
-.PHONY: new-stage2-bubble
-new-stage2-bubble: new-stage1-bubble
+.PHONY: stage2-bubble
+stage2-bubble: stage1-bubble
@if [ -f all-stage2-gcc ] ; then \
echo Remaking stage 2 ; \
rm -f all-stage2-gcc ; \
- $(MAKE) all-stage2-gcc && \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) \
+ all-stage2-gcc && \
if [ -f configure-stage3-gcc ] ; then \
$(STAMP) configure-stage3-gcc ; \
fi ; \
else \
- $(MAKE) all-stage2-gcc ; \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-stage2-gcc ; \
fi
configure-stage2-gcc: all-stage1-gcc
- $(MAKE) new-stage2-start
+ $(MAKE) stage2-start
@if [ -f stage2-gcc/Makefile ] ; then \
$(STAMP) configure-stage2-gcc ; \
exit 0; \
$(STAMP) ../configure-stage2-gcc
all-stage2-gcc: configure-stage2-gcc
- $(MAKE) new-stage2-start
+ $(MAKE) stage2-start
@r=`${PWD_COMMAND}`; export r; \
s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
$(STAGE_HOST_EXPORTS) \
cd gcc && \
$(MAKE) $(GCC_FLAGS_TO_PASS) \
- CC="$${CC}" CC_FOR_BUILD="${CC_FOR_BUILD}" \
+ CC="$${CC}" CC_FOR_BUILD="$${CC_FOR_BUILD}" \
STAGE_PREFIX=$$r/stage1-gcc/ \
$(POSTSTAGE1_FLAGS_TO_PASS) && $(STAMP) ../all-stage2-gcc
+.PHONY: bootstrap2
+bootstrap2:
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) stage2-bubble \
+ stage2-start all stage2-end
-.PHONY: new-restage2 distclean-stage2
+
+.PHONY: restage2 distclean-stage2
distclean-stage2: distclean-stage3
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
rm -rf configure-stage2-gcc all-stage2-gcc stage2-gcc
-new-restage2: distclean-stage3
+restage2: distclean-stage3
rm -rf all-stage2-gcc
- $(MAKE) all-stage2-gcc
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-stage2-gcc
-.PHONY: new-stage3-start new-stage3-end
+.PHONY: stage3-start stage3-end
-new-stage3-start:
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+stage3-start:
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
echo stage3 > stage_last ; \
[ -d stage3-gcc ] || mkdir stage3-gcc; \
set stage3-gcc gcc ; @CREATE_LINK_TO_DIR@ ; \
set stage2-gcc prev-gcc ; @CREATE_LINK_TO_DIR@
-new-stage3-end:
+stage3-end:
rm -f stage_last ; \
set gcc stage3-gcc ; @UNDO_LINK_TO_DIR@ ; \
set prev-gcc stage2-gcc ; @UNDO_LINK_TO_DIR@
# Bubble a bugfix through all the stages up to stage 3. They
# are remade, but not reconfigured. The next stage (if any) will not
# be reconfigured as well.
-.PHONY: new-stage3-bubble
-new-stage3-bubble: new-stage2-bubble
+.PHONY: stage3-bubble
+stage3-bubble: stage2-bubble
@if [ -f all-stage3-gcc ] ; then \
echo Remaking stage 3 ; \
rm -f all-stage3-gcc ; \
- $(MAKE) all-stage3-gcc ; \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) \
+ all-stage3-gcc && \
+ if [ -f configure-stage4-gcc ] ; then \
+ $(STAMP) configure-stage4-gcc ; \
+ fi ; \
else \
- $(MAKE) all-stage3-gcc ; \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-stage3-gcc ; \
fi
configure-stage3-gcc: all-stage2-gcc
- $(MAKE) new-stage3-start
+ $(MAKE) stage3-start
@if [ -f stage3-gcc/Makefile ] ; then \
$(STAMP) configure-stage3-gcc ; \
exit 0; \
$(STAMP) ../configure-stage3-gcc
all-stage3-gcc: configure-stage3-gcc
- $(MAKE) new-stage3-start
+ $(MAKE) stage3-start
@r=`${PWD_COMMAND}`; export r; \
s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
$(STAGE_HOST_EXPORTS) \
cd gcc && \
$(MAKE) $(GCC_FLAGS_TO_PASS) \
- CC="$${CC}" CC_FOR_BUILD="${CC_FOR_BUILD}" \
+ CC="$${CC}" CC_FOR_BUILD="$${CC_FOR_BUILD}" \
STAGE_PREFIX=$$r/stage2-gcc/ \
$(POSTSTAGE1_FLAGS_TO_PASS) && $(STAMP) ../all-stage3-gcc
compare: all-stage3-gcc
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
@r=`${PWD_COMMAND}`; export r; \
s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
rm -f .bad_compare ; \
-.PHONY: new-bootstrap
-new-bootstrap:
- $(MAKE) new-stage3-bubble compare \
- new-stage3-start all new-stage3-end
+.PHONY: bootstrap
+bootstrap:
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) stage3-bubble compare \
+ stage3-start all stage3-end
-.PHONY: new-restage3 distclean-stage3
+.PHONY: restage3 distclean-stage3
-distclean-stage3:
- [ -f stage_last ] && $(MAKE) new-`cat stage_last`-end || :
+distclean-stage3: distclean-stage4
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
rm -rf configure-stage3-gcc all-stage3-gcc stage3-gcc compare
-new-restage3:
+restage3: distclean-stage4
rm -rf all-stage3-gcc compare
- $(MAKE) compare
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) compare
+
+
+.PHONY: cleanstrap
+cleanstrap: distclean-stage1 bootstrap
+
+
+
+.PHONY: stage4-start stage4-end
+
+stage4-start:
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
+ echo stage4 > stage_last ; \
+ [ -d stage4-gcc ] || mkdir stage4-gcc; \
+ set stage4-gcc gcc ; @CREATE_LINK_TO_DIR@ ; \
+ set stage3-gcc prev-gcc ; @CREATE_LINK_TO_DIR@
+
+stage4-end:
+ rm -f stage_last ; \
+ set gcc stage4-gcc ; @UNDO_LINK_TO_DIR@ ; \
+ set prev-gcc stage3-gcc ; @UNDO_LINK_TO_DIR@
+
+# Bubble a bugfix through all the stages up to stage 4. They
+# are remade, but not reconfigured. The next stage (if any) will not
+# be reconfigured as well.
+.PHONY: stage4-bubble
+stage4-bubble: stage3-bubble
+ @if [ -f all-stage4-gcc ] ; then \
+ echo Remaking stage 4 ; \
+ rm -f all-stage4-gcc ; \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) \
+ all-stage4-gcc ; \
+ else \
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) all-stage4-gcc ; \
+ fi
+
+configure-stage4-gcc: all-stage3-gcc
+ $(MAKE) stage4-start
+ @if [ -f stage4-gcc/Makefile ] ; then \
+ $(STAMP) configure-stage4-gcc ; \
+ exit 0; \
+ else \
+ true ; \
+ fi ; \
+ r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(STAGE_HOST_EXPORTS) \
+ echo Configuring stage 4 in gcc ; \
+ cd gcc || exit 1; \
+ case $(srcdir) in \
+ \.) \
+ srcdiroption="--srcdir=."; \
+ libsrcdir=".";; \
+ /* | [A-Za-z]:[\\/]*) \
+ srcdiroption="--srcdir=$(srcdir)/gcc"; \
+ libsrcdir="$$s/gcc";; \
+ *) \
+ srcdiroption="--srcdir=../$(srcdir)/gcc"; \
+ libsrcdir="$$s/gcc";; \
+ esac; \
+ $(SHELL) $${libsrcdir}/configure \
+ $(HOST_CONFIGARGS) $${srcdiroption} \
+ @stage2_werror_flag@ && \
+ $(STAMP) ../configure-stage4-gcc
+
+all-stage4-gcc: configure-stage4-gcc
+ $(MAKE) stage4-start
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ $(STAGE_HOST_EXPORTS) \
+ cd gcc && \
+ $(MAKE) $(GCC_FLAGS_TO_PASS) \
+ CC="$${CC}" CC_FOR_BUILD="$${CC_FOR_BUILD}" \
+ STAGE_PREFIX=$$r/stage3-gcc/ \
+ $(POSTSTAGE1_FLAGS_TO_PASS) && $(STAMP) ../all-stage4-gcc
+
+
+compare3: all-stage4-gcc
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
+ @r=`${PWD_COMMAND}`; export r; \
+ s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+ rm -f .bad_compare ; \
+ cd stage4-gcc; \
+ files=`find . -name "*$(objext)" -print` ; \
+ cd .. ; \
+ for file in $${files} ; do \
+ f1=$$r/stage3-gcc/$$file; f2=$$r/stage4-gcc/$$file; \
+ @do_compare@ > /dev/null 2>&1; \
+ test $$? -eq 1 && echo $$file differs >> .bad_compare || true; \
+ done ; \
+ if [ -f .bad_compare ]; then \
+ echo "Bootstrap comparison failure!"; \
+ cat .bad_compare; \
+ exit 1; \
+ else \
+ true; \
+ fi ; \
+ $(STAMP) compare3
+
+
+
+.PHONY: bootstrap4
+bootstrap4:
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) stage4-bubble compare3 \
+ stage4-start all stage4-end
+
+
+.PHONY: restage4 distclean-stage4
+
+distclean-stage4:
+ [ -f stage_last ] && $(MAKE) `cat stage_last`-end || :
+ rm -rf configure-stage4-gcc all-stage4-gcc stage4-gcc compare3
+restage4:
+ rm -rf all-stage4-gcc compare3
+ $(MAKE) $(BASE_FLAGS_TO_PASS) $(RECURSE_FLAGS) compare3
-.PHONY: new-cleanstrap
-new-cleanstrap: distclean-stage1 new-bootstrap
+@endif gcc-bootstrap
# --------------------------------------
# Dependencies between different modules
projects / deliverable / binutils-gdb.git / blobdiff