# ============ Tools =====================================================

COUNT_FAILURES = /home/nickc/bin/scripts/count-failures
CHECK_FOR_REGRESSIONS = /home/nickc/bin/scripts/check-for-regressions
# TIMELIMIT      = /home/nickc/bin/scripts/timelimit

XTERM_MAKE    = xterm -sl 20000 -e make 
SIMPLE_MAKE   = nice -3 make -s 
PARALLEL_MAKE = nice -3 make -s -j4
NOSTOP_MAKE   = make -s -k

BIN_DIRS      = $(BIN1) $(BIN2) $(BIN3) $(BIN4)
GCC_AND_LIBGCC_DIRS = $(GCC1) $(GCC2) $(GCC3) $(GCC4)
ALL_DIRS      = $(ALL1) $(ALL2) $(ALL3) $(ALL4)
TEST_DIRS     = $(TEST1) $(TEST2) $(TEST3) $(TEST4)
MAINT_DIRS    = $(MAINT1) $(MAINT2) $(MAINT3) $(MAINT4)

ALL_GCC_DIRS = $(ALL_DIRS) $(LIB_DIRS) $(GCC_DIRS) $(GCC_AND_LIBGCC_DIRS) $(TEST_DIRS)
EVERY_DIR = $(ALL_GCC_DIRS) $(BIN_DIRS)

# ============ Build Rules ================================================

INFOS = info-gas info-ld info-binutils info-bfd

BIN_CLEAN_RULES = echo -n "Cleaning all of binutils in:" `basename $$PWD` "... " ; \
		  $(NOSTOP_MAKE) clean-gold &> /dev/null ; \
		  $(NOSTOP_MAKE) clean-gas clean-ld clean-binutils &> /dev/null \
		   && echo "success" || echo "FAILURE"

BIN_BUILD_NO_RETRY_RULES = echo -n "Building Binutils in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-binutils all-gas all-ld all-gold $(INFOS) &> ./make.out \
		   && echo "success" || echo "FAILURE"

BIN_BUILD_RULES = echo -n "Building Binutils in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-binutils all-gas all-ld all-gold $(INFOS) &> ./make.out \
		   && echo "success" \
		   || (echo -n "fail ... " ; \
		       cd bfd ; ./config.status > /dev/null ; cd .. ; \
		       rm -f ld/e*.c `basename $$PWD`/newlib/config.cache ld/config.cache libiberty/config.cache bfd/config.cache gas/config.cache opcodes/config.cache; \
		       cd libiberty ; $(SIMPLE_MAKE) clean > /dev/null ; ./config.status > /dev/null ; cd .. \
		       test -d ld && ( cd ld ; ./config.status > /dev/null ; cd .. ) ; \
		       rm -fr bfd ; \
		       $(SIMPLE_MAKE) clean > /dev/null ; \
		       echo -n "retry ... " ; \
		       $(SIMPLE_MAKE) all-binutils all-gas all-ld all-gold $(INFOS) &> ./make.out \
		       && echo "success" || echo "FAILURE")

OPCODES_BUILD_RULES = echo -n "Building opcodes in:" `basename $$PWD` "... " ; \
		      rm -f opcodes/stamp* ; \
		      $(SIMPLE_MAKE) all-opcodes &> ./make.out && echo "success" || echo "FAILURE"

SIM_BUILD_RULES = echo -n "Building Simulator in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-sim &> ./make.out \
		   && echo "success" || echo "FAILURE"

GCC_CLEAN_RULES = echo -n "Cleaning gcc in:" `basename $$PWD` "... " ; \
		  $(NOSTOP_MAKE) clean-gcc &> /dev/null \
		   && echo "success" || echo "FAILURE"

GCC_BUILD_NO_RETRY_RULES = echo -n "Building GCC in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-gcc &>  ./make.out \
		   && echo "success" || echo "FAILURE"

GCC_BUILD_RULES = echo -n "Building GCC in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-gcc &>  ./make.out \
		   && echo "success" \
		   || (echo -n "fail ... " ; \
		       rm -f gcc/config.cache libiberty/config.cache build-*/config.cache ; \
		       make clean-gcc &> ./make.out ; \
		       echo -n "retry ... " ; \
		       $(SIMPLE_MAKE) all-binutils all-gcc &> ./make.out \
		       && echo "success" || echo "FAILURE")

LIBGCC_BUILD_RULES = echo -n "Building LIBGCC in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-target-libgcc &>  ./make.out \
		   && echo "success" \
		   || (echo -n "fail ... " ; \
		       cp -r tests/* gcc ; \
		       echo -n "retry ... " ; \
		       $(SIMPLE_MAKE) all-target-libgcc &> ./make.out \
		       && echo "success" || echo "FAILURE")

MULTI_BUILD_GDB_RULES = \
		echo -n "Building in:" `basename $$PWD` "... " ; \
		$(SIMPLE_MAKE) -f ../makefile multi-build-stage1

multi-build-stage1:					       
		$(PARALLEL_MAKE) all-binutils >>  ./make.out 2>&1 \
		  && $(SIMPLE_MAKE) -f ../makefile multi-build-stage4  || echo "BINUTILS build failed"
multi-build-stage2:					       
		$(PARALLEL_MAKE) all-ld all-gold >> ./make.out 2>&1 \
		  && $(SIMPLE_MAKE) -f ../makefile multi-build-stage3  || echo "LD build failed"
multi-build-stage3:
		$(PARALLEL_MAKE) all-gas &>  ./make.out \
		  && $(SIMPLE_MAKE) -f ../makefile multi-build-stage2  || echo "GAS build failed"
multi-build-stage4:					       
		$(PARALLEL_MAKE) all-gcc >>  ./make.out 2>&1 \
		  && $(SIMPLE_MAKE) -f ../makefile multi-build-stage5  || echo "GCC build failed"
multi-build-stage5:
		$(PARALLEL_MAKE) all-gdb >>  ./make.out 2>&1 \
		  && echo "GCC & GDB built OK" || echo "GDB build failed"


GCC_REBUILD_RULES = echo -n "Rebuilding GCC in:" `basename $$PWD` "... " ; \
		    cd bfd ; ./config.status &> /dev/null ; cd .. ; \
		    cd gcc ; ./config.status --recheck &> /dev/null ; cd .. ; \
		    $(PARALLEL_MAKE) all-gcc &>  ./make.out \
		      && echo "success" || echo "FAILURE"

LIB_BUILD_RULES = echo -n "Building target LIBRARIES in:" `basename $$PWD` "... " ; \
		   $(PARALLEL_MAKE) all-target-libgcc &> ./make.out && ( echo -n "libgcc..." ; \
                   $(PARALLEL_MAKE) all-target-newlib &> ./make.out && ( echo -n "newlib..." ; \
                   $(PARALLEL_MAKE) all-target-libgloss &> ./make.out && ( echo -n "libgloss..." ; \
		   $(PARALLEL_MAKE) all-target-libstdc++-v3 &> ./make.out && echo "libstdc++-v3...success" \
		   || echo "FAILURE (libstdc++-v3)" ) \
		   || echo "FAILURE (libgloss)" ) \
		   || echo "FAILURE (newlib)" ) \
                   || echo "FAILURE (libgcc)"

LIB_CLEAN_RULES = echo -n "Cleaning target LIBRARIES in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) clean-target &> ./make.out \
		   && echo "success" || echo "FAILURE"

NEWLIB_BUILD_RULES = echo -n "Building NEWLIB in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-target-newlib &>  ./make.out \
		   && echo "success" \
		   || (echo -n "fail ... " ; \
		       find `basename $$PWD` -name config.cache -exec rm {} \; ; \
		       echo -n "retry ... " ; \
		       $(SIMPLE_MAKE) all-target-newlib &> ./make.out \
		       && echo "success" || echo "FAILURE")

LIBGLOSS_BUILD_RULES = echo -n "Building LIBGLOSS in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-target-libgloss &>  ./make.out \
		   && echo "success" || echo "FAILURE"

# find . -name config.cache -exec rm \{\} \\;
LIBSTDCXX_V3_BUILD_RULES = echo -n "Building LIBSTDC++-v3 in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-target-libstdc++-v3 &>  ./make.out \
		   && echo "success" || echo "FAILURE"

LIBSSP_BUILD_RULES = echo -n "Building LIBSSP in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-target-libssp &> ./make.out \
		   && echo "success" \
		   || (echo -n "fail ... " ; \
		       find . -name config.cache -exec rm \{\} \; ; \
		       echo -n "retry ... " ; \
		       $(SIMPLE_MAKE) all-target-libssp &> ./make.out \
		       && echo "success" || echo "FAILURE")

GDB_BUILD_RULES = echo -n "Building GDB in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-gdb &> ./make.out \
		   && echo "success" \
		   || (echo -n "fail ... " ; \
		       rm -f gdb/ada-lex.c ; \
		       echo -n "retry ... " ; \
		       $(SIMPLE_MAKE) -C gdb &> ../make.out \
		       && echo "success" || echo "FAILURE")

GDB_CLEAN_RULES = echo -n "Cleaning GDB in:" `basename $$PWD` "... " ; \
		  $(NOSTOP_MAKE) clean-gdb clean-sim clean-readline &> /dev/null \
		   && echo "success" || echo "FAILURE"

ALL_BUILD_RULES = echo -n "Building ALL in:" `basename $$PWD` ": " ; \
		  echo -n "gcc ... " ; \
		   $(PARALLEL_MAKE) all-gcc &> ./make.out || { echo "FAIL" ; continue ; } ; \
		  echo -n "libgcc ... " ; \
		   $(PARALLEL_MAKE) all-target-libgcc >> ./make.out 2>&1 || { echo "FAIL" ; continue ; } ; \
		  echo -n "libgloss ... " ; \
		   $(PARALLEL_MAKE) all-target-libgloss >> ./make.out 2>&1 || { echo "FAIL" ; continue ; } ; \
		  echo -n "libstdc++-v3 ... " ; \
		   $(PARALLEL_MAKE) all-target-libstdc++-v3 >> ./make.out 2>&1 || { echo "FAIL" ; } ; \
		  echo -n "gdb ... " ; \
		   $(PARALLEL_MAKE) all-gdb >> ./make.out 2>&1 \
		   && echo "success" || echo "FAIL"

MUDFLAP_BUILD_RULES = echo -n "Building MUDFLAP in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-target-libmudflap &>  ./make.out \
		   && echo "success" || echo "FAILURE"

GPROF_BUILD_RULES = echo -n "Building GPROF in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-gprof &>  ./make.out \
		   && echo "success" || echo "FAILURE"

INSTALL_INFO_RULES = echo -n "Installing Info files from:" `basename $$PWD` "... " ; \
		  $(SIMPLE_MAKE) prefix=/dev/shm/installs install-info &>  ./make.out \
		   && echo "success" || echo "FAILURE"

SIM_BUILD_RULES = echo -n "Building sim in:" `basename $$PWD` "... " ; \
		  $(PARALLEL_MAKE) all-sim &> ./make.out \
		      && echo "success" || echo "FAILURE"

GAS_CLEAN_RULES = echo -n "Cleaning gas in:" `basename $$PWD` "... " ; \
		  $(NOSTOP_MAKE) clean-gas &> /dev/null \
		   && echo "success" || echo "FAILURE"

SIM_CLEAN_RULES = echo -n "Cleaning sim in:" `basename $$PWD` "... " ; \
		  $(NOSTOP_MAKE) clean-sim &> /dev/null \
		   && echo "success" || echo "FAILURE"

# ============ Check Rules ================================================
BIN_CHECK_REGRESSIONS_3 = \
		  test -f ./checks/check-gas.out3 && \
		  test -f ./checks/check-gas.out0 && \
		    (diff  ./checks/check-gas.out3 ./checks/check-gas.out0 > /dev/shm/.gas.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GAS /dev/shm/.gas.diff.out) ; \
		  \
		  test -f ./checks/check-ld.out3 && \
		  test -f ./checks/check-ld.out0 && \
		    (diff  ./checks/check-ld.out3 ./checks/check-ld.out0 > /dev/shm/.ld.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=LD /dev/shm/.ld.diff.out) ; \
		  \
		  test -f ./checks/check-gold.out3 && \
		  test -f ./checks/check-gold.out0 && \
		    (diff  ./checks/check-gold.out3 ./checks/check-gold.out0 > /dev/shm/.gold.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GOLD /dev/shm/.gold.diff.out) ; \
		  \
		  test -f ./checks/check-bin.out3 && \
		  test -f ./checks/check-bin.out0 && \
		    (diff  ./checks/check-bin.out3 ./checks/check-bin.out0 > /dev/shm/.bin.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=BIN /dev/shm/.bin.diff.out)

BIN_CHECK_REGRESSIONS_2 = \
		  test -f ./checks/check-gas.out2 && \
		  test -f ./checks/check-gas.out0 && \
		    (diff  ./checks/check-gas.out2 ./checks/check-gas.out0 > /dev/shm/.gas.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GAS /dev/shm/.gas.diff.out) ; \
		  \
		  test -f ./checks/check-ld.out2 && \
		  test -f ./checks/check-ld.out0 && \
		    (diff  ./checks/check-ld.out2 ./checks/check-ld.out0 > /dev/shm/.ld.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=LD /dev/shm/.ld.diff.out) ; \
		  \
		  test -f ./checks/check-gold.out2 && \
		  test -f ./checks/check-gold.out0 && \
		    (diff  ./checks/check-gold.out2 ./checks/check-gold.out0 > /dev/shm/.gold.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GOLD /dev/shm/.gold.diff.out) ; \
		  \
		  test -f ./checks/check-bin.out2 && \
		  test -f ./checks/check-bin.out0 && \
		    (diff  ./checks/check-bin.out2 ./checks/check-bin.out0 > /dev/shm/.bin.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=BIN /dev/shm/.bin.diff.out)

BIN_CHECK_REGRESSIONS = \
		  test -f ./checks/check-gas.out1 && \
		  test -f ./checks/check-gas.out0 && \
		    (diff  ./checks/check-gas.out1 ./checks/check-gas.out0 > /dev/shm/.gas.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GAS /dev/shm/.gas.diff.out) ; \
		  \
		  test -f ./checks/check-ld.out1 && \
		  test -f ./checks/check-ld.out0 && \
		    (diff  ./checks/check-ld.out1 ./checks/check-ld.out0 > /dev/shm/.ld.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=LD /dev/shm/.ld.diff.out) ; \
		  \
		  test -f ./checks/check-gold.out1 && \
		  test -f ./checks/check-gold.out0 && \
		    (diff  ./checks/check-gold.out1 ./checks/check-gold.out0 > /dev/shm/.gold.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GOLD /dev/shm/.gold.diff.out) ; \
		  \
		  test -f ./checks/check-bin.out1 && \
		  test -f ./checks/check-bin.out0 && \
		    (diff  ./checks/check-bin.out1 ./checks/check-bin.out0 > /dev/shm/.bin.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=BIN /dev/shm/.bin.diff.out)

BIN_CYCLE_OLD_RESULTS = \
		mkdir -p checks ; \
		xx=9 ; \
		for x in 8 7 6 5 4 3 2 1 0 ; \
		do \
		  test -f ./checks/check-gas.out$$x && mv -f ./checks/check-gas.out$$x ./checks/check-gas.out$$xx ; \
		  test -f ./checks/check-ld.out$$x  && mv -f ./checks/check-ld.out$$x  ./checks/check-ld.out$$xx ; \
		  test -f ./checks/check-gold.out$$x  && mv -f ./checks/check-gold.out$$x  ./checks/check-gold.out$$xx ; \
		  test -f ./checks/check-bin.out$$x && mv -f ./checks/check-bin.out$$x ./checks/check-bin.out$$xx ; \
		  xx=$$x ; \
		done 

BIN_GENERATE_NEW_RESULTS = \
		echo -n "Checking Binutils in:" `basename $$PWD` "..."; \
		\
	        test -d gas && ( cd gas ; $(NOSTOP_MAKE) check NO_EXPENSIVE_GAS_TESTS=1 &> ../checks/check-gas.out0 ; cd .. ) ; \
		test -d ld && ( cd ld ; $(NOSTOP_MAKE) check NO_EXPENSIVE_LD_TESTS=1 &> ../checks/check-ld.out0 ; cd .. ) ; \
		test -d gold && ( cd gold ; $(NOSTOP_MAKE) check NO_EXPENSIVE_LD_TESTS=1 &> ../checks/check-gold.out0 ; cd .. ) ; \
		test -d binutils && ( cd binutils ; $(NOSTOP_MAKE) check &> ../checks/check-bin.out0 ; cd .. ) ; \
		\
		test -d gas && ( x=`gawk -f $(COUNT_FAILURES) ./checks/check-gas.out0` ; \
				if test $$x != "0" ; then echo -n " GAS:" $$x ; fi ; ) ; \
		test -d ld && ( x=`gawk -f $(COUNT_FAILURES) ./checks/check-ld.out0` ; \
		                if test $$x != "0" ; then echo -n " LD:" $$x ; fi ; ) ; \
		test -d gold && ( x=`gawk -f $(COUNT_FAILURES) ./checks/check-gold.out0` ; \
		                if test $$x != "0" ; then echo -n " GOLD:" $$x ; fi ; ) ; \
		test -d binutils && ( x=`gawk -f $(COUNT_FAILURES) ./checks/check-bin.out0` ; \
				if test $$x != "0" ; then echo -n " BIN:" $$x ; fi ; ) ; \
		\
		echo " done"

BIN_SHOW_RESULTS = \
		echo "Showing Binutils results for:" `basename $$PWD`; \
		grep -e FAIL ./checks/check-gas.out0 | grep -v XFAIL -H --label=" GAS "; \
		grep -e FAIL ./checks/check-ld.out0  | grep -v XFAIL -H --label=" LD "; \
		grep -e FAIL ./checks/check-gold.out0  | grep -v XFAIL -H --label=" GOLD "; \
		grep -e FAIL ./checks/check-bin.out0 | grep -v XFAIL -H --label=" BIN  "


SIM_CHECK_REGRESSIONS = \
		  test -f ./checks/check-sim.out1 && \
		  test -f ./checks/check-sim.out0 && \
		    (diff  ./checks/check-sim.out1 ./checks/check-sim.out0 > /dev/shm/.sim.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=SIM /dev/shm/.sim.diff.out)

SIM_CHECK_RULES = echo -n "Checking SIM in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-sim.out$$x && mv -f ./checks/check-sim.out$$x ./checks/check-sim.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd sim ; $(SIMPLE_MAKE) check &> ../checks/check-sim.out0 ; cd .. ; \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-sim.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(SIM_CHECK_REGRESSIONS) ; \
		  \
		  echo " done"

GCC_CHECK_REGRESSIONS = \
		  touch ./checks/check-gcc.out1 ; \
		  touch ./checks/check-gcc.out0 ; \
		  (diff  ./checks/check-gcc.out1 ./checks/check-gcc.out0 > /dev/shm/gcc.diff.out || \
		   gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GCC /dev/shm/gcc.diff.out)

GCC_CHECK_RULES = echo -n "Checking GCC (execute) in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-gcc.out$$x && mv -f ./checks/check-gcc.out$$x ./checks/check-gcc.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd gcc; $(SIMPLE_MAKE) check-gcc RUNTESTFLAGS="gcc.c-torture/execute/execute.exp" &> ../checks/check-gcc.out0 ; \
		  cd .. ; \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-gcc.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(GCC_CHECK_REGRESSIONS) ; \
		  \
		  echo " done"

GCC_CHECK_DG_REGRESSIONS = \
		  test -f ./checks/check-dg-gcc.out1 && \
		  test -f ./checks/check-dg-gcc.out0 && \
		    (diff  ./checks/check-dg-gcc.out1 ./checks/check-dg-gcc.out0 > /dev/shm/.gcc.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GCC_DG /dev/shm/.gcc.diff.out)

GCC_DG_CHECK_RULES = echo -n "Checking GCC (dg) in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-dg-gcc.out$$x && mv -f ./checks/check-dg-gcc.out$$x ./checks/check-dg-gcc.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd gcc ; $(SIMPLE_MAKE) check-gcc RUNTESTFLAGS="gcc.dg/dg.exp" &> ../checks/check-dg-gcc.out0 ; \
		  cd .. ; \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-dg-gcc.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(GCC_CHECK_DG_REGRESSIONS) ; \
		  \
		  echo " done"

GCC_CHECK_COMPILE_REGRESSIONS = \
		  test -f ./checks/check-compile-gcc.out1 && \
		  test -f ./checks/check-compile-gcc.out0 && \
		    (diff  ./checks/check-compile-gcc.out1 ./checks/check-compile-gcc.out0 > /dev/shm/.gcc.comp.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GCC_DG /dev/shm/.gcc.comp.out)

GCC_COMPILE_CHECK_RULES = echo -n "Checking GCC (compile) in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-compile-gcc.out$$x && mv -f ./checks/check-compile-gcc.out$$x ./checks/check-compile-gcc.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd gcc ; $(SIMPLE_MAKE) check-gcc RUNTESTFLAGS="gcc.c-torture/compile/compile.exp" &> ../checks/check-compile-gcc.out0 ; \
		  cd .. ; \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-compile-gcc.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(GCC_CHECK_COMPILE_REGRESSIONS) ; \
		  \
		  echo " done"

GXX_CHECK_REGRESSIONS = \
		  test -f ./checks/check-g++.out1 && \
		  test -f ./checks/check-g++.out0 && \
		    (diff  ./checks/check-g++.out1 ./checks/check-g++.out0 > /dev/shm/g++.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GXX /dev/shm/g++.diff.out)

GXX_CHECK_RULES = echo -n "Checking G++ in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-g++.out$$x && mv -f ./checks/check-g++.out$$x ./checks/check-g++.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd gcc ; $(SIMPLE_MAKE) check-g++ &> ../checks/check-g++.out0 ; cd .. \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-g++.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(GXX_CHECK_REGRESSIONS) ; \
		  \
		  echo " done"

GDB_CHECK_REGRESSIONS = \
		  test -f ./checks/check-gdb.out1 && \
		  test -f ./checks/check-gdb.out0 && \
		    (diff  ./checks/check-gdb.out1 ./checks/check-gdb.out0 > /dev/shm/.gdb.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GDB /dev/shm/.gdb.diff.out)

GDB_CHECK_RULES = echo -n "Checking GDB in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-gdb.out$$x && mv -f ./checks/check-gdb.out$$x ./checks/check-gdb.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd gdb ; $(SIMPLE_MAKE) check &> ../checks/check-gdb.out0 ; cd .. ; \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-gdb.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(GDB_CHECK_REGRESSIONS) ; \
		  \
		  echo " done"

GXX_CHECK_DG_REGRESSIONS = \
		  test -f ./checks/check-dg-gxx.out1 && \
		  test -f ./checks/check-dg-gxx.out0 && \
		    (diff  ./checks/check-dg-gxx.out1 ./checks/check-dg-gxx.out0 > /dev/shm/.gxx.diff.out || \
		    gawk -f $(CHECK_FOR_REGRESSIONS) TEST=GXX_DG /dev/shm/.gxx.diff.out)

GXX_DG_CHECK_RULES = echo -n "Checking G++ (dg) in:" `basename $$PWD` "... " ; \
		  \
		  mkdir -p checks ; \
		  xx=9 ; \
		  for x in 8 7 6 5 4 3 2 1 0 ; \
		  do \
		    test -f ./checks/check-dg-gxx.out$$x && mv -f ./checks/check-dg-gxx.out$$x ./checks/check-dg-gxx.out$$xx ; \
		    xx=$$x ; \
		  done ; \
		  \
	          cd gcc ; $(SIMPLE_MAKE) check-g++ RUNTESTFLAGS="g++.dg/dg.exp" &> ../checks/check-dg-gxx.out0 ; \
		  cd .. ; \
		  \
		  x=`gawk -f $(COUNT_FAILURES) ./checks/check-dg-gxx.out0` ; \
		  if test $$x != "0" ; then echo -n " FAILURES:" $$x ; fi ; \
		  \
		  $(GXX_CHECK_DG_REGRESSIONS) ; \
		  \
		  echo " done"

# ============ Clean Targets ================================================

clean-and-build-gcc:
	@ for A in $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GCC_CLEAN_RULES) ; \
		  $(GCC_BUILD_RULES) ; \
		popd > /dev/null ; \
	done	

clean-and-build-bin:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(BIN_CLEAN_RULES) ; \
		  $(BIN_BUILD_RULES) ; \
		popd > /dev/null ; \
	done	

force-clean:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null && \
		  (echo "Removing *everything* in:" `basename $$PWD` "... " ; \
		  test -d tests && mv tests .. ; \
		  test -d checks && mv checks .. ; \
		  rm -fr * ; \
		  test -d ../checks && mv ../checks . ; \
		  test -d ../tests && mv ../tests . ) ; \
		popd > /dev/null ; \
	done

clean-binutils:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(BIN_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	

clean:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(BIN_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	
	@ for A in $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GCC_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	
	@ for A in $(LIB_DIRS) $(ALL_DIRS) $(TEST_DIRS); do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(LIB_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	
	@ for A in $(GDB_DIRS) $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GDB_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	

clean-gdb:
	@ for A in $(GDB_DIRS) $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GDB_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	

clean-gas:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GAS_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	

clean-sim:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(SIM_CLEAN_RULES) ; \
		popd > /dev/null ; \
	done	

# ============ Build Targets ================================================

GCC_BUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(GCC_BUILD_RULES) ; \
		popd > /dev/null ; \
	done

gcc-build gcc-builds build-gcc all-gcc: $(ALL_GCC_DIRS)
	$(GCC_BUILD)


GCC_REBUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(GCC_REBUILD_RULES) ; \
		popd > /dev/null ; \
	done

gcc-rebuild gcc-rebuilds rebuild-gcc: $(ALL_GCC_DIRS)
	$(GCC_REBUILD)


gcc-build-noretry gcc-builds-noretry build-gcc-noretry gcc-build-no-retry gcc-builds-no-retry build-gcc-no-retry all-gcc-noretry all-gcc-no-retry:
	@ for A in $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(GCC_BUILD_NO_RETRY_RULES) ; \
		popd > /dev/null ; \
	done


LIBGCC_BUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(LIBGCC_BUILD_RULES) ; \
		popd > /dev/null ; \
	done

libgcc-build libgcc-builds build-libgcc all-libgcc all-target-libgcc all-target-libgcc-no-retry all-target-libgcc-noretry: $(ALL_GCC_DIRS)
	$(LIBGCC_BUILD)


lib-build lib-builds build-libs lib libs all-target:
	@ for A in $(LIB_DIRS) $(ALL_DIRS) $(TEST_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(LIB_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


NEWLIB_BUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(NEWLIB_BUILD_RULES) ; \
		popd > /dev/null ; \
	done

newlib-build newlib-builds build-newlib all-target-newlib: $(ALL_DIRS) $(LIB_DIRS) $(TEST_DIRS)
	$(NEWLIB_BUILD)


LIBGLOSS_BUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(LIBGLOSS_BUILD_RULES) ; \
		popd > /dev/null ; \
	done

libgloss-build libgloss-builds build-libgloss all-target-libgloss: $(ALL_DIRS) $(LIB_DIRS) $(TEST_DIRS)
	$(LIBGLOSS_BUILD)


LIBSTDCXX_BUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(LIBSTDCXX_V3_BUILD_RULES) ; \
		popd > /dev/null ; \
	done

libstdc++-v3-build libstdc++-v3-builds build-libstdc++-v3 all-target-libstdc++-v3: $(ALL_DIRS) $(LIB_DIRS) $(TEST_DIRS)
	$(LIBSTDCXX_BUILD)


libssp-build libssp-builds build-libssp all-target-libssp:
	@ for A in $(LIB_DIRS) $(ALL_DIRS) $(TEST_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(LIBSSP_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


bin-build-noretry bin-builds-noretry build-bin-noretry all-binutils bin-builds-no-retry:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(BIN_BUILD_NO_RETRY_RULES) ; \
		popd > /dev/null ; \
	done


BIN_BUILD = \
	@ for A in $^ ; do \
		if pushd $(BUILD_DIR)/$$A > /dev/null ; \
		then \
		      $(BIN_BUILD_RULES) ; \
		      popd > /dev/null ; \
		else \
		     echo "BIN DIR $A does not exist!" ; \
		fi ; \
	done ; \

bin-build bin-builds build-bin all-bin-builds: $(EVERY_DIR)
	$(BIN_BUILD)


sim all-sim sim-build sim-builds build-sim build-sims:
	@ for A in $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(SIM_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


GDB_BUILD = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(GDB_BUILD_RULES) ; \
		popd > /dev/null ; \
	done

gdb-build gdb-builds build-gdb all-gdb: $(GDB_DIRS) $(ALL_GCC_DIRS) $(GCC_AND_LIBGCC_DIRS)
	$(GDB_BUILD)


# Builds GCC then LIBGCC then ... for the first target, before proceeding to the next.
all-builds:
	@ for A in $(ALL_DIRS) $(TEST_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(ALL_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


maint-all-builds:
	@ for A in $(MAINT_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(ALL_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


mudflap-builds build-mudflap mudflap:
	@ for A in $(ALL_DIRS) $(TEST_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		      $(MUDFLAP_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


opcodes all-opcodes opcodes-build opcodes-builds build-opcodes:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			$(OPCODES_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


gprof all-gprof gprof-build build-gprof:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			$(GPROF_BUILD_RULES) ; \
		popd > /dev/null ; \
	done


install-info all-install-info:
	@ for A in $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			$(INSTALL_INFO_RULES) ; \
		popd > /dev/null ; \
	done

# ============ Check Targets ================================================

show-bin-check show-bin-checks check-bin-show check-ld-show check-gas-show:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(BIN_SHOW_RESULTS); \
		popd > /dev/null ; \
	done

BIN_CHECKS = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(BIN_CYCLE_OLD_RESULTS); \
		  $(BIN_GENERATE_NEW_RESULTS); \
		  $(BIN_CHECK_REGRESSIONS); \
		popd > /dev/null ; \
	done

bin-check bin-checks check-bin check-ld check-gas: $(EVERY_DIR)
	$(BIN_CHECKS)

BIN_CHECK_LAST_BUT_ONE = \
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(BIN_CYCLE_OLD_RESULTS); \
		  $(BIN_GENERATE_NEW_RESULTS); \
		  $(BIN_CHECK_REGRESSIONS_2); \
		popd > /dev/null ; \
	done

bin-check-last-but-one:
	$(BIN_CHECK_LAST_BUT_ONE)

check-bin-regressions bin-check-regressions:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  echo -n "Checking for binutils (v1 vs v0) regressions in:" `basename $$PWD` "..."; \
		  $(BIN_CHECK_REGRESSIONS) ; \
		  echo " done" ; \
		popd > /dev/null ; \
	done

check-bin-regressions-2 bin-check-regressions2 bin-check-regressions-2:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  echo -n "Checking for binutils (v2 vs v0) regressions in:" `basename $$PWD` "..."; \
		  $(BIN_CHECK_REGRESSIONS_2) ; \
		  echo " done" ; \
		popd > /dev/null ; \
	done

check-bin-regressions-3 bin-check-regressions3 bin-check-regressions-3:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  echo -n "Checking for binutils (v3 vs v0) regressions in:" `basename $$PWD` "..."; \
		  $(BIN_CHECK_REGRESSIONS_3) ; \
		  echo " done" ; \
		popd > /dev/null ; \
	done

sim-check sim-checks check-sim:
	@ for A in $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(SIM_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

GCC_COMPILE_CHECK = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GCC_COMPILE_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

gcc-compile-check: $(ALL_GCC_DIRS)
	$(GCC_COMPILE_CHECK)

GCC_EXECUTE_CHECK = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GCC_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

gcc-check gcc-checks check-gcc: $(TEST_DIRS)
	$(GCC_EXECUTE_CHECK)

DG_CHECK = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GCC_DG_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

gcc-dg-check gcc-check-dg check-dg: $(TEST_DIRS)
	$(DG_CHECK)

maint-gcc-dg-check maint-gcc-check-dg maint-check-dg: $(MAINT_DIRS)
	$(DG_CHECK)

GXX_CHECK = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GXX_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

g++-check g++-checks check-g++: $(TEST_DIRS)
	$(GXX_CHECK)

GXX_DG_CHECK = \
	@ for A in $^ ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GXX_DG_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

gxx-dg-check gxx-check-dg check-gxx-dg: $(TEST_DIRS)
	$(GXX_DG_CHECK)

maint-gxx-dg-check maint-gxx-check-dg maint-check-gxx-dg: $(MAINT_DIRS)
	$(GXX_DG_CHECK)

gdb-check gdb-checks check-gdb:
	@ for A in $(GDB_DIRS) $(ALL_GCC_DIRS) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
		  $(GDB_CHECK_RULES) ; \
		popd > /dev/null ; \
	done

# ============ Configure Targets ================================================

build-dirs dirs:
	@ for A in $(EVERY_DIR) ; do \
		mkdir -p $(BUILD_DIR)/$$A ; \
	done

re-config reconfig:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			echo "Running config.status in $$A" ; \
			./config.status > /dev/null; \
		popd > /dev/null ; \
	done

re-check recheck:
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			echo "Running config.status --recheck in $$A" ; \
			./config.status --recheck > /dev/null; \
			./config.status > /dev/null; \
		popd > /dev/null ; \
	done

CONFIG_ARGS =	--quiet \
		--disable-bootstrap \
	    	--disable-gdbtk \
		--with-x=no \
		--with-newlib \
		--enable-languages=c,c++ \
		--enable-plugins \
		--cache-file=/dev/null \
		--prefix=`pwd`/install \
		$(CONFIG_EXTRA)

#		--with-mpfr-include=$(SOURCE_DIR)/mpfr/src \
#		--with-mpfr-lib=`pwd`/mpfr/src/.libs \
#		 CFLAGS="-fsanitize=address -g"


config configure: $(SOURCE_DIR)
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			echo "Configuring in:" `basename $$PWD` "..." ; \
			$(SOURCE_DIR)/configure \
				$(CONFIG_ARGS) \
				--target=$$A > config.out 2>&1; \
			rm -f ld/configdoc.texi ; \
			mkdir -p tests checks install ; \
		popd > /dev/null ; \
	done 
	@ mkdir -p $(BUILD_DIR)/i686-pc-linux-gnu; \
	pushd  $(BUILD_DIR)/i686-pc-linux-gnu > /dev/null ; \
		echo "(re) Configuring in: i686-pc-linux-gnu ... " ; \
		mv tests checks .. ; \
		rm -fr * ; \
		$(SOURCE_DIR)/configure \
			$(CONFIG_ARGS) \
			--enable-languages=c,c++,java \
			--target=i686-pc-linux-gnu \
		> /dev/null 2>&1; \
		rm -f ld/configdoc.texi ; \
		mv ../tests ../checks . ; \
	popd > /dev/null
	@ mkdir -p $(BUILD_DIR)/x86_64-pc-linux-gnu; \
	pushd  $(BUILD_DIR)/x86_64-pc-linux-gnu > /dev/null ; \
		echo "(re) Configuring in: x86_64-pc-linux-gnu ... " ; \
		mv tests checks .. ; \
		rm -fr * ; \
		$(SOURCE_DIR)/configure \
			$(CONFIG_ARGS) \
			--enable-multilib=no \
			--disable-shared \
		> /dev/null 2>&1; \
		rm -f ld/configdoc.texi ; \
		mv ../tests ../checks . ; \
	popd > /dev/null
	@ mkdir -p $(BUILD_DIR)/all-64; \
	pushd  $(BUILD_DIR)/all-64 > /dev/null ; \
		echo "(re) Configuring in: all-64 ... " ; \
		rm -f * ; \
		$(SOURCE_DIR)/configure \
			$(CONFIG_ARGS) \
			--enable-targets=all \
			--enable-64-bit-bfd \
		> /dev/null 2>&1; \
		rm -f ld/configdoc.texi ; \
	popd > /dev/null
	@ mkdir -p $(BUILD_DIR)/x86_64-pc-linux-gnu-gold; \
	pushd  $(BUILD_DIR)/x86_64-pc-linux-gnu-gold > /dev/null ; \
		echo "(re) Configuring in: x86_64-pc-linux-gnu-gold ... " ; \
		rm -fr * ; \
		$(SOURCE_DIR)/configure \
			$(CONFIG_ARGS) \
			--enable-gold
		> /dev/null 2>&1; \
		mkdir -p tests checks install ; \
	popd > /dev/null
	@ mkdir -p $(BUILD_DIR)/all-64_32-ubsan; \
	pushd  $(BUILD_DIR)/all-64_32-ubsan > /dev/null ; \
		echo "(re) Configuring in: all-64_32-ubsan ... " ; \
		rm -fr * ; \
		$(SOURCE_DIR)/configure \
			$(CONFIG_ARGS) \
			--enable-targets=all \
			--enable-64-bit-bfd \
			CFLAGS='-m32 -g -O3 -fstack-protector-all -Wformat -Werror=format-security -fsanitize=undefined' \
			CXXFLAGS='-m32 -g -O3 -fstack-protector-all -Wformat -Werror=format-security -fsanitize=undefined' \
			CPPFLAGS='-D_FORTIFY_SOURCE=2' \
			LDFLAGS='-Wl,-z,relro'
		> /dev/null 2>&1; \
		mkdir -p tests checks install ; \
	popd > /dev/null


re-lib: $(SOURCE_DIR)
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A/libiberty > /dev/null ; \
			echo "rebuild libiberty in:" `basename $$PWD` "... " ; \
			$(SIMPLE_MAKE) clean all > /dev/null \
			|| ./config.status > /dev/null \
			|| $(SIMPLE_MAKE) > /dev/null ; \
		popd > /dev/null ; \
	done 


32-bit-configure: $(SOURCE_DIR)
	@ for A in $(EVERY_DIR) ; do \
		pushd $(BUILD_DIR)/$$A > /dev/null ; \
			echo "Configuring in:" `basename $$PWD` "..." ; \
			CC="gcc -m32" CXX="g++ -m32" ABI="32" setarch i686 \
			$(SOURCE_DIR)/configure \
				$(CONFIG_ARGS) \
				--disable-shared \
				--disable-symvers \
				--target=$$A > config.out 2>&1; \
			rm -f ld/configdoc.texi ; \
			mkdir -p tests checks install ; \
		popd > /dev/null ; \
	done 
	@ mkdir -p $(BUILD_DIR)/all; \
	pushd  $(BUILD_DIR)/all > /dev/null ; \
		echo "(re) Configuring in: all ... " ; \
		rm -f * ; \
		CC="gcc -m32" CXX="g++ -m32" ABI="32" setarch i686 \
		$(SOURCE_DIR)/configure \
			--quiet --enable-targets=all --with-x=no \
		> /dev/null ; \
		rm -f ld/configdoc.texi ; \
	popd > /dev/null
	@ mkdir -p $(BUILD_DIR)/all-64; \
	pushd  $(BUILD_DIR)/all-64 > /dev/null ; \
		echo "(re) Configuring in: all-64 ... " ; \
		rm -f * ; \
		CC="gcc -m32" CXX="g++ -m32" ABI="32" setarch i686 \
		$(SOURCE_DIR)/configure \
			--quiet --enable-targets=all --enable-64-bit-bfd --with-x=no \
		> /dev/null ; \
		rm -f ld/configdoc.texi ; \
	popd > /dev/null
	@ mkdir -p $(BUILD_DIR)/i686-pc-linux-gnu-gold; \
	pushd  $(BUILD_DIR)/i686-pc-linux-gnu-gold > /dev/null ; \
		echo "(re) Configuring in: i686-pc-linux-gnu-gold ... " ; \
		rm -fr * ; \
		CC="gcc -m32" CXX="g++ -m32" ABI="32" setarch i686 \
		$(SOURCE_DIR)/configure \
			--quiet \
			--enable-gold \
			--cache-file=/dev/null \
			--prefix=`pwd`/install \
			--target=i686-pc-linux-gnu \
		> /dev/null 2>&1; \
		mkdir -p tests checks install ; \
	popd > /dev/null


cpp-check cpp-checks cppcheck cppchecks: $(SOURCE_DIR)
	  pushd $(SOURCE_DIR) > /dev/null ; \
	  echo "Running cppcheck on sources..." ; \
	  cppcheck -q . ; \
	  popd > /dev/null

# ==================== PARALLEL BUILD RULES ====================================

PAR_END = \
	@ echo " " ; \
	echo "FINISHED at `date`" ; \
	sleep 5d

par-end:
	$(PAR_END)

build-bin1: $(BIN1) $(GCC1) $(ALL1) $(TEST1)
	$(BIN_BUILD)
	$(PAR_END)

build-bin2: $(BIN2) $(GCC2) $(ALL2) $(TEST2)
	$(BIN_BUILD)
	$(PAR_END)

build-bin3: $(BIN3) $(GCC3) $(ALL3) $(TEST3)
	$(BIN_BUILD)
	$(PAR_END)

build-bin4: $(BIN4) $(GCC4) $(ALL4) $(TEST4)
	$(BIN_BUILD)
	$(PAR_END)

par-bin par-build-bin par-bin-build par-bin-builds:
	$(XTERM_MAKE) build-bin1 &
	$(XTERM_MAKE) build-bin2 &
	$(XTERM_MAKE) build-bin3 &
	$(XTERM_MAKE) build-bin4 &

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

build-check-bin1: $(BIN1) $(GCC1) $(ALL1) $(TEST1)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECKS)
	$(PAR_END)

build-check-bin2: $(BIN2) $(GCC2) $(ALL2) $(TEST2)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECKS)
	$(PAR_END)

build-check-bin3: $(BIN3) $(GCC3) $(ALL3) $(TEST3)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECKS)
	$(PAR_END)

build-check-bin4: $(BIN4) $(GCC4) $(ALL4) $(TEST4)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECKS)
	$(PAR_END)

par-bin-build-checks:
	$(XTERM_MAKE) build-check-bin1 &
	$(XTERM_MAKE) build-check-bin2 &
	$(XTERM_MAKE) build-check-bin3 &
	$(XTERM_MAKE) build-check-bin4 &

build-check-lb1-bin1: $(BIN1) $(GCC1) $(ALL1) $(TEST1)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECK_LAST_BUT_ONE)
	$(PAR_END)

build-check-lb1-bin2: $(BIN2) $(GCC2) $(ALL2) $(TEST2)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECK_LAST_BUT_ONE)
	$(PAR_END)

build-check-lb1-bin3: $(BIN3) $(GCC3) $(ALL3) $(TEST3)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECK_LAST_BUT_ONE)
	$(PAR_END)

build-check-lb1-bin4: $(BIN4) $(GCC4) $(ALL4) $(TEST4)
	$(BIN_BUILD)
	@ echo " "
	$(BIN_CHECK_LAST_BUT_ONE)
	$(PAR_END)

par-bin-build-checks-last-but-one par-last-but-one:
	$(XTERM_MAKE) build-check-lb1-bin1 &
	$(XTERM_MAKE) build-check-lb1-bin2 &
	$(XTERM_MAKE) build-check-lb1-bin3 &
	$(XTERM_MAKE) build-check-lb1-bin4 &

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

check-bin1: $(BIN1) $(GCC1) $(ALL1) $(TEST1)
	$(BIN_CHECKS)
	$(PAR_END)

check-bin2: $(BIN2) $(GCC2) $(ALL2) $(TEST2)
	$(BIN_CHECKS)
	$(PAR_END)

check-bin3: $(BIN3) $(GCC3) $(ALL3) $(TEST3)
	$(BIN_CHECKS)
	$(PAR_END)

check-bin4: $(BIN4) $(GCC4) $(ALL4) $(TEST4)
	$(BIN_CHECKS)
	$(PAR_END)

par-bin-checks:
	$(XTERM_MAKE) check-bin1 &
	$(XTERM_MAKE) check-bin2 &
	$(XTERM_MAKE) check-bin3 &
	$(XTERM_MAKE) check-bin4 &

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

.PHONY : build-gcc1 build-gcc2 build-gcc3 build-gcc4 par-gcc

# Note - these rules do not include (PAR_END) because they
#        are used as part of a longer sequence by build-all<N>

build-gcc1: $(GCC1) $(ALL1) $(TEST1)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

build-gcc2: $(GCC2) $(ALL2) $(TEST2)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

build-gcc3: $(GCC3) $(ALL3) $(TEST3)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

build-gcc4: $(GCC4) $(ALL4) $(TEST4)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

par-gcc par-build-gcc par-gcc-builds par-all-gcc:
	$(XTERM_MAKE) build-gcc1 par-end &
	$(XTERM_MAKE) build-gcc2 par-end &
	$(XTERM_MAKE) build-gcc3 par-end &
	$(XTERM_MAKE) build-gcc4 par-end &

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

build-all1:: build-gcc1
build-all2:: build-gcc2
build-all3:: build-gcc3
build-all4:: build-gcc4

build-all1:: $(ALL1) $(TEST1)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

build-all2:: $(ALL2) $(TEST2)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

build-all3:: $(ALL3) $(TEST3)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

build-all4:: $(ALL4) $(TEST4)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

par-all par-build:
	$(XTERM_MAKE) build-all1 &
	$(XTERM_MAKE) build-all2 &
	$(XTERM_MAKE) build-all3 &
	$(XTERM_MAKE) build-all4 &

# -----------------------------------------------
.PHONY : maint-build-gcc1 maint-build-gcc2 maint-build-gcc3 maint-build-gcc4 maint-par-gcc

# Note - these rules do not include (PAR_END) because they
#        are used as part of a longer sequence by build-all<N>

maint-build-gcc1: $(MAINT1)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

maint-build-gcc2: $(MAINT2)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

maint-build-gcc3: $(MAINT3)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

maint-build-gcc4: $(MAINT4)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)

maint-par-gcc maint-par-build-gcc maint-par-gcc-builds maint-par-all-gcc:
	$(XTERM_MAKE) maint-build-gcc1 par-end &
	$(XTERM_MAKE) maint-build-gcc2 par-end &
	$(XTERM_MAKE) maint-build-gcc3 par-end &
	$(XTERM_MAKE) maint-build-gcc4 par-end &

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

maint-build-all1:: maint-build-gcc1
maint-build-all2:: maint-build-gcc2
maint-build-all3:: maint-build-gcc3
maint-build-all4:: maint-build-gcc4

maint-build-all1:: $(MAINT1)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

maint-build-all2:: $(MAINT2)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

maint-build-all3:: $(MAINT3)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

maint-build-all4:: $(MAINT4)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)
	$(PAR_END)

maint-par-all:
	$(XTERM_MAKE) maint-build-all1 &
	$(XTERM_MAKE) maint-build-all2 &
	$(XTERM_MAKE) maint-build-all3 &
	$(XTERM_MAKE) maint-build-all4 &

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

gcc-compile-check1: $(ALL1) $(GCC1) $(TEST1)
	$(GCC_COMPILE_CHECK)
	$(PAR_END)

gcc-compile-check2: $(ALL2) $(GCC2) $(TEST2)
	$(GCC_COMPILE_CHECK)
	$(PAR_END)

gcc-compile-check3: $(ALL3) $(GCC3) $(TEST3)
	$(GCC_COMPILE_CHECK)
	$(PAR_END)

gcc-compile-check4: $(ALL4) $(GCC4) $(TEST4)
	$(GCC_COMPILE_CHECK)
	$(PAR_END)

par-gcc-compile-check:
	$(XTERM_MAKE) gcc-compile-check1 &
	$(XTERM_MAKE) gcc-compile-check2 &
	$(XTERM_MAKE) gcc-compile-check3 &
	$(XTERM_MAKE) gcc-compile-check4 &

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

gcc-execute-check1: $(TEST1)
	$(GCC_EXECUTE_CHECK)
	$(PAR_END)

gcc-execute-check2: $(TEST2)
	$(GCC_EXECUTE_CHECK)
	$(PAR_END)

gcc-execute-check3: $(TEST3)
	$(GCC_EXECUTE_CHECK)
	$(PAR_END)

gcc-execute-check4: $(TEST4)
	$(GCC_EXECUTE_CHECK)
	$(PAR_END)

par-gcc-execute-check:
	$(XTERM_MAKE) gcc-execute-check1 &
	$(XTERM_MAKE) gcc-execute-check2 &
	$(XTERM_MAKE) gcc-execute-check3 &
	$(XTERM_MAKE) gcc-execute-check4 &

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

gxx-dg-check1: $(TEST1)
	$(GXX_DG_CHECK)
	$(PAR_END)

gxx-dg-check2: $(TEST2)
	$(GXX_DG_CHECK)
	$(PAR_END)

gxx-dg-check3: $(TEST3)
	$(GXX_DG_CHECK)
	$(PAR_END)

gxx-dg-check4: $(TEST4)
	$(GXX_DG_CHECK)
	$(PAR_END)

par-gxx-dg-check par-gxx-dg-checks:
	$(XTERM_MAKE) gxx-dg-check1 &
	$(XTERM_MAKE) gxx-dg-check2 &
	$(XTERM_MAKE) gxx-dg-check3 &
	$(XTERM_MAKE) gxx-dg-check4 &

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

gcc-dg-check1: $(TEST1)
	$(DG_CHECK)
	$(PAR_END)

gcc-dg-check2: $(TEST2)
	$(DG_CHECK)
	$(PAR_END)

gcc-dg-check3: $(TEST3)
	$(DG_CHECK)
	$(PAR_END)

gcc-dg-check4: $(TEST4)
	$(DG_CHECK)
	$(PAR_END)

par-gcc-dg-check par-gcc-dg-checks:
	$(XTERM_MAKE) gcc-dg-check1 &
	$(XTERM_MAKE) gcc-dg-check2 &
	$(XTERM_MAKE) gcc-dg-check3 &
	$(XTERM_MAKE) gcc-dg-check4 &

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

build-check-all1:: build-gcc1

build-check-all1:: $(ALL1) $(TEST1)
	$(GDB_BUILD)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(DG_CHECK)
	$(PAR_END)

build-check-all2:: build-gcc2

build-check-all2:: $(ALL2) $(TEST2)
	$(GDB_BUILD)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(DG_CHECK)
	$(PAR_END)

build-check-all3:: build-gcc3

build-check-all3:: $(ALL3) $(TEST3)
	$(GDB_BUILD)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(DG_CHECK)
	$(PAR_END)

build-check-all4:: build-gcc4

build-check-all4:: $(ALL4) $(TEST4)
	$(GDB_BUILD)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(DG_CHECK)
	$(PAR_END)

par-all-and-check:
	$(XTERM_MAKE) build-check-all1 &
	$(XTERM_MAKE) build-check-all2 &
	$(XTERM_MAKE) build-check-all3 &
	$(XTERM_MAKE) build-check-all4 &

all-and-check: build-all check-all

# Builds GCC for all targets, then builds LIBGCC for all targets, and so on.
build-all: $(ALL1) $(ALL2) $(ALL3) $(ALL4)
	$(GCC_BUILD)
	$(LIBGCC_BUILD)
	$(NEWLIB_BUILD)
	$(LIBGLOSS_BUILD)
	$(LIBSTDCXX_BUILD)
	$(GDB_BUILD)

check-all: $(TEST1) $(TEST2) $(TEST3) $(TEST4)
	$(DG_CHECK)
