* Makefile.in (bootstrap): rename stages to be mnemonic. Add

restageN, unstageN, bubblestrap, quickstrap, and cleanstrap
targets.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@38959 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1de53d4..9afec5b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2001-01-12  DJ Delorie  <dj@redhat.com>
+
+       * Makefile.in (bootstrap): rename stages to be mnemonic.  Add
+       restageN, unstageN, bubblestrap, quickstrap, and cleanstrap
+       targets.
+
 2001-01-12  Joseph S. Myers  <jsm28@cam.ac.uk>
 
        * cpp.texi, extend.texi, gcc.texi, install.texi, invoke.texi,

diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index fc12879..aa9c2e2 100644 (file)
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -2295,8 +2295,9 @@ clean: mostlyclean $(INTL_CLEAN) lang.clean
        fi ; fi
        -rm -fr stage1 stage2 stage3 stage4
 # Delete stamps of bootstrap stages
-       -rm -f stage_*
-       -rm -f clean_*
+       -rm -f stage?_*
+       -rm -f clean?_*
+       -rm -f stage_last
 
 # Delete all files that users would normally create
 # while building and installing GCC.
@@ -2827,84 +2828,133 @@ STAGE2_FLAGS_TO_PASS = \
 # 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.
-stage_a: 
+stage1_build:
        +$(MAKE) CC="$(CC)" libdir=$(libdir) LANGUAGES="$(BOOT_LANGUAGES)"
-       touch stage_a
+       touch stage1_build
+       echo stage1_build > stage_last
 
-stage_b: stage_a
+stage1_copy: stage1_build
        $(MAKE) stage1
-       touch stage_b
+       touch stage1_copy
+       echo stage2_build > stage_last
 
 # This used to define ALLOCA as empty, but that would lead to bad results
 # for a subsequent `make install' since that would not have ALLOCA empty.
 # To prevent `make install' from compiling alloca.o and then relinking cc1
 # because alloca.o is newer, we permit these recursive makes to compile
 # alloca.o.  Then cc1 is newer, so it won't have to be relinked.
-stage_c: stage_b
+stage2_build: stage1_copy
        +$(MAKE) CC="stage1/xgcc$(exeext) -Bstage1/ -B$(build_tooldir)/bin/" \
                 STAGE_PREFIX=stage1/ \
                 $(STAGE2_FLAGS_TO_PASS)
-       touch stage_c
+       touch stage2_build
+       echo stage2_build > stage_last
 
-stage_d: stage_c
+stage2_copy: stage2_build
        +$(MAKE) stage2
-       touch stage_d
+       touch stage2_copy
+       echo stage3_build > stage_last
 
-stage_e: stage_d
+stage3_build: stage2_copy
        +$(MAKE) CC="stage2/xgcc$(exeext) -Bstage2/ -B$(build_tooldir)/bin/" \
                 STAGE_PREFIX=stage2/ \
                 $(STAGE2_FLAGS_TO_PASS)
-       touch stage_e
+       touch stage3_build
+       echo stage3_build > stage_last
 
 # For bootstrap4:
-stage_f: stage_e
+stage3_copy: stage3_build
+       +$(MAKE) stage3
+       touch stage3_copy
+       echo stage4_build > stage_last
+
+stage4_build: stage3_copy
        +$(MAKE) CC="stage3/xgcc$(exeext) -B$(build_tooldir)/bin/ -Bstage3/" \
                 STAGE_PREFIX=stage3/ \
                 $(STAGE2_FLAGS_TO_PASS)
-       touch stage_f
+       touch stage4_build
+       echo stage4_build > stage_last
 
 # Additional steps for *-lean targets:
-clean_s1: stage_b
+clean_s1: stage1_copy
        -(cd stage1 && rm -f $(VOL_FILES))
        touch clean_s1
 
-clean_s2: stage_d
+clean_s2: stage2_copy
        -rm -rf stage1
        touch clean_s2
 
-# This next little bit is the way it is for parallel builds.  It's simply
-# a chain of stages which DO have to be done sequentially.
-
-bootstrap_a:              stage_a
-bootstrap_b:  bootstrap_a stage_b
-bootstrap_c:  bootstrap_b stage_c
-bootstrap_d:  bootstrap_c stage_d
-bootstrap_e:  bootstrap_d stage_e
-bootstrap: force bootstrap_e
-
-bootstrap-lean_a:                   stage_a
-bootstrap-lean_b:  bootstrap-lean_a stage_b
-bootstrap-lean_c:  bootstrap-lean_b clean_s1 
-bootstrap-lean_d:  bootstrap-lean_c stage_c
-bootstrap-lean_e:  bootstrap-lean_d stage_d
-bootstrap-lean_f:  bootstrap-lean_e clean_s2
-bootstrap-lean_g:  bootstrap-lean_f stage_e
-bootstrap-lean: force bootstrap-lean_g
-
-bootstrap2_c:               stage_c
-bootstrap2_d:  bootstrap2_c stage_d
-bootstrap2_e:  bootstrap2_d stage_e
-bootstrap2: force bootstrap2_e
-
-bootstrap2-lean_c:                    stage_c
-bootstrap2-lean_d:  bootstrap2-lean_c stage_d
-bootstrap2-lean_e:  bootstrap2-lean_d clean_s2
-bootstrap2-lean_f:  bootstrap2-lean_e stage_e
-bootstrap2-lean: force bootstrap2-lean_f
-
-bootstrap3 bootstrap3-lean: force stage_e
+# The various entry points for bootstrapping.
+
+bootstrap: stage3_build
+       @echo
+       @echo Bootstrap complete - make \"quickstrap\" to redo last build,
+       @echo \"restage1\" through \"restage3\" to rebuild specific stages,
+       @echo or \"cleanstrap\" to redo the bootstrap from scratch.
+
+bootstrap-lean : clean_s1 clean_s2 stage3_build
+       @echo
+       @echo Bootstrap complete - make \"quickstrap\" to redo last build,
+       @echo or \"cleanstrap\" to redo the bootstrap from scratch.
+
+bootstrap2: bootstrap
+
+bootstrap2-lean : bootstrap_lean
+
+bootstrap3 bootstrap3-lean: bootstrap
  
-bootstrap4 bootstrap4-lean: force stage_f
+bootstrap4 bootstrap4-lean: stage4_build
+
+unstage1 unstage2 unstage3 unstage4:
+       -set -vx; stage=`echo $@ | sed -e 's/un//'`; \
+       if test -d $$stage; then \
+         mv $$stage/* . 2>/dev/null; \
+         for i in `cd $$stage; echo *` ; do \
+           if test -d $$stage/$$i; then \
+             mv $$stage/$$i/* $$i/. 2>/dev/null; \
+           else \
+             mv $$stage/$$i .; \
+           fi \
+         done \
+       fi ; \
+       rm -f $${stage}_build $${stage}_copy ;\
+       echo $${stage}_build > stage_last
+
+restage1: unstage1
+       $(MAKE) stage1_build
+
+restage2: unstage2
+       $(MAKE) LANGUAGES="$(LANGUAGES)" stage2_build
+
+restage3: unstage3
+       $(MAKE) LANGUAGES="$(LANGUAGES)" stage3_build
+
+restage4: unstage4
+       $(MAKE) LANGUAGES="$(LANGUAGES)" stage4_build
+
+bubblestrap:
+       if test -f stage3_build; then true; else \
+         echo; echo You must \"make bootstrap\" first.; \
+         exit 1; \
+       fi
+       for i in stage3 \
+               unstage1 stage1_build stage1_copy \
+               unstage2 stage2_build stage2_copy \
+               unstage3 stage3_build ; \
+       do \
+         $(MAKE) LANGUAGES="$(LANGUAGES)" $$i || exit 1 ; \
+       done
+
+quickstrap:
+       if test -f stage_last ; then \
+         LAST=`cat stage_last`; rm $$LAST; $(MAKE) LANGUAGES="$(LANGUAGES)" $$LAST; \
+       else \
+         $(MAKE) stage1_build; \
+       fi
+
+cleanstrap:
+       -$(MAKE) clean
+       $(MAKE) LANGUAGES="$(LANGUAGES)" bootstrap
 
 # Compare the object files in the current directory with those in the
 # stage2 directory.