2003-01-02 Andrew Cagney <ac131313@redhat.com>

	* MAINTAINERS: Mention gdb_mbuild.sh.
	* gdb_mbuild.sh: Rewrite.

1 files changed, 243 insertions, 100 deletions

diff --git a/gdb/gdb_mbuild.sh b/gdb/gdb_mbuild.sh
index ae40b02c69a..a1077401a2e 100755
--- a/gdb/gdb_mbuild.sh
+++ b/gdb/gdb_mbuild.sh
@@ -1,7 +1,10 @@
 #!/bin/sh
 
-#  Multi-build script for testing compilation of all maintained configs of GDB.
-#  Copyright (C) 2002  Free Software Foundation, Inc.
+#  Multi-build script for testing compilation of all maintained
+#  configs of GDB.
+
+#  Copyright 2002 Free Software Foundation, Inc.
+
 #  Contributed by Richard Earnshaw  (rearnsha@arm.com)
 
 #  This program is free software; you can redistribute it and/or modify
@@ -18,136 +21,276 @@
 #  along with this program; if not, write to the Free Software
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-usage() {
-    echo "Usage: gdb_mbuild.sh <srcdir> <builddir> [<parjobs>]"
-    echo " Environment variables examined (with default if not defined):"
-    echo "  AWK (awk) -- must be GNU awk"
-    echo "  MAKE (make)"
-    echo
-    echo " Note: Everything in <builddir>/gdb-allcross will be blown away."
+usage()
+{
+    cat <<EOF
+Usage: gdb_mbuild.sh [ <options> ... ] <srcdir> <builddir>
+ Options:
+   -j <makejobs>  Run <makejobs> in parallel.  Passed to make.
+	          On a single cpu machine, 2 is recommended.
+   -k             Keep going.  Do not stop after the first build fails.
+   -e <regexp>    Regular expression for selecting the targets to build.
+   -f             Force rebuild.  Even rebuild previously built directories.
+   -v             Be more (and more, and more) verbose.
+ Arguments:
+   <srcdir>       Source code directory.
+   <builddir>     Build directory.
+ Environment variables examined (with default if not defined):
+   MAKE (make)"
+EOF
     exit 1;
+cat <<NOTYET
+  -b <maxbuilds> Run <maxbuild> builds in parallel.
+		 On a single cpu machine, 1 is recommended.
+NOTYET
 }
 
-if [ $# -ne 2 -a $# -ne 3 ] ; then
+### COMMAND LINE OPTIONS
+
+makejobs=
+maxbuilds=1
+keepgoing=
+force=false
+targexp=""
+verbose=0
+while test $# -gt 0
+do
+    case "$1" in
+    -j )
+	# Number of parallel make jobs.
+	shift
+	test $# -ge 1 || usage
+	makejobs="-j $1"
+	;;
+    -b | -c )
+	# Number of builds to fire off in parallel.
+	shift
+	test $# -ge 1 || usage
+	maxbuilds=$1
+	;;
+    -k )
+	# Should we soldier on after the first build fails?
+	keepgoing=-k
+	;;
+    -e )
+	# A regular expression for selecting targets
+	shift
+	test $# -ge 1 || usage
+	targexp="${targexp} -e ${1}"
+	;;
+    -f )
+	# Force a rebuild
+	force=true ; shift ;;
+    -v )
+	# Be more, and more, and more, verbose
+	verbose=`expr ${verbose} + 1`
+	;;
+    -* ) usage ;;
+    *) break ;;
+    esac
+    shift
+done
+
+
+### COMMAND LINE PARAMETERS
+
+if test $# -ne 2
+then
     usage
 fi
 
-### COMMAND LINE PARAMETERS
+# Convert these to absolute directory paths.
 
 # Where the sources live
-srcdir=$1
+srcdir=`cd $1 && /bin/pwd` || exit 1
 
 # Where the builds occur
-buildbase=$2
-
-# Number of parallel make jobs (you probably want about 2 jobs per cpu for
-# maximum throughput)
-if [ $# -eq 3 ]; then
-    par=$3
-else
-    par="1"
-fi
+builddir=`cd $2 && /bin/pwd` || exit 1
 
 ### ENVIRONMENT PARAMETERS
-# Must be GNU awk
-awk=${AWK:-awk}
 
 # Version of make to use
 make=${MAKE:-make}
+MAKE=${make}
+export MAKE
 
 
-# Where builds will live
-builddir=${buildbase}/gdb-allcross
-
-# Where logs will go.  NB. Must not be a sub-dir of builddir or you will loose
-# them.
-logdir=${buildbase}/gdb-logdir
-
 # Where to look for the list of targets to test
 maintainers=${srcdir}/gdb/MAINTAINERS
-
-# Get the list of targets and the build options
-alltarg=`${awk} < "${maintainers}" '
-  $2 ~ /--target=.*/ {
-    targets = gensub (/^.*--target=/, "", 1, $2)
-    warnings = gensub (/[)]*$/, "", 1, $3)
-    split (targets, targ, /,/)
-    for (i in targ) {
-        print targ[i], warnings
-    }
-  }'`
-
-# Back up the log files
-cd ${logdir}
-
-if [ -f build.out ]
-then
-	mv build.out build.old
-fi
-if [ -f config.out ]
+if [ ! -r ${maintainers} ]
 then
-	mv config.out config.old
-fi
-if [ -f fail.sum ]
-then
-	mv fail.sum fail.old
+    echo Maintainers file ${maintainers} not found
+    exit 1
 fi
 
-if [ ! -d ${builddir} ]
+# Get the list of targets and the build options
+alltarg=`cat ${maintainers} | tr -s '[\t]' '[ ]' | sed -n '
+/^[ ]*[-a-z0-9\.]*[ ]*[(]*--target=.*/ !d
+s/^.*--target=//
+s/).*$//
+h
+:loop
+  g
+  /^[^ ]*,/ !b end
+  s/,[^ ]*//
+  p
+  g
+  s/^[^,]*,//
+  h
+b loop
+:end
+p
+' | if test "${targexp}" = ""
 then
-	echo ${builddir} does not exist
-	exit 1
-fi
+    grep -v -e broken -e OBSOLETE
+else
+    grep ${targexp}
+fi`
 
-cd ${builddir}
-rm -rf *
 
-MAKE=${make}
-export MAKE
+# Usage: fail <message> <test-that-should-succeed>.  Should the build
+# fail?  If the test is true, and we don't want to keep going, print
+# the message and shoot everything in sight and abort the build.
 
-jobs=1
-# For each target, configure and build it.
-while read targ opts
-do
-	if [ ${opts} != "broken" ]
+fail ()
+{
+    msg="$1" ; shift
+    if test "$@"
+    then
+	echo "${target}: ${msg}"
+	if test "${keepgoing}" != ""
 	then
-		trap 'echo cleaning up ...; rm -rf ${builddir}/*; exit 1' 1 2 15
-		echo ${targ}
-		mkdir ${targ}
-		cd ${targ}
-		${srcdir}/configure --target=$targ \
-		  --enable-gdb-build-warnings=$opts \
-		  >> ${logdir}/config.tout.$targ 2>&1 &
-		cd ..
-		jobs=`expr ${jobs} + 1`
-		if [ ${jobs} -gt ${par} ]
-		then
-			wait
-			jobs=1
-		fi
+	    #exit 1
+	    continue
+	else
+	    kill $$
+	    exit 1
 	fi
-done << EOF
-$alltarg
-EOF
+    fi
+}
+
+
+# Usage: log <level> <logfile>.  Write standard input to <logfile> and
+# stdout (if verbose >= level).
+
+log ()
+{
+    if test ${verbose} -ge $1
+    then
+	tee $2
+    else
+	cat > $2
+    fi
+}
 
-wait
 
-cat ${logdir}/config.tout.* > ${logdir}/config.out
-rm -f ${logdir}/config.tout.*
 
-for targ in *
+# Warn the user of what is comming, print the list of targets
+
+echo "$alltarg"
+echo ""
+
+
+# For each target, configure, build and test it.
+
+echo "$alltarg" | while read target gdbopts simopts
 do
-	cd $targ
-	if  ${make} -j ${par} all-gdb >> ${logdir}/build.out 2>&1
+
+    trap "exit 1"  1 2 15
+    dir=${builddir}/${target}
+
+    # Should a scratch rebuild be forced, for perhaphs the entire
+    # build be skipped?
+
+    if ${force}
+    then
+	echo forcing ${target} ...
+	rm -rf ${dir}
+    elif test -f ${dir}
+    then
+	echo "${target}"
+	continue
+    else
+	echo ${target} ...
+    fi
+
+    # Did the previous configure attempt fail?  If it did
+    # restart from scratch.
+
+    if test -d ${dir} -a ! -r ${dir}/Makefile
+    then
+	echo ... removing partially configured ${target}
+	rm -rf ${dir}
+	if test -d ${dir}
 	then
-		true
-	else
-		echo ">>>>>>>>>>>>>" >> ${logdir}/fail.sum
-		echo "$targ (${opts})" >> ${logdir}/fail.sum 
-		tail -20 ${logdir}/build.out >> ${logdir}/fail.sum
-		echo >> ${logdir}/fail.sum
-		echo $targ build failed
+	    echo "${target}: unable to remove directory ${dir}"
+	    exit 1
 	fi
-	rm -rf *
-	cd ..
+    fi
+
+    # From now on, we're in this target's build directory
+
+    mkdir -p ${dir}
+    cd ${dir} || exit 1
+
+    # Configure, if not already.  Should this go back to being
+    # separate and done in parallel?
+
+    if test ! -r Makefile
+    then
+	# Default SIMOPTS to GDBOPTS.
+	test -z "${simopts}" && simopts="${gdbopts}"
+	# The config options
+	__target="--target=${target}"
+	__enable_gdb_build_warnings=`test -z "${gdbopts}" \
+	    || echo "--enable-gdb-build-warnings=${gdbopts}"`
+	__enable_sim_build_warnings=`test -z "${simopts}" \
+	    || echo "--enable-sim-build-warnings=${simopts}"`
+	__configure="${srcdir}/configure \
+	    ${__target} \
+	    ${__enable_gdb_build_warnings} \
+	    ${__enable_sim_build_warnings}"
+	echo ... ${__configure}
+	trap "echo Removing partially configured ${dir} directory ...; rm -rf ${dir}; exit 1" 1 2 15
+	${__configure} 2>&1 | log 2 Config.log
+	trap "exit 1"  1 2 15
+    fi
+    fail "configure failed" ! -r Makefile
+ 
+    # Build, if not built.
+
+    if test ! -x gdb/gdb -a ! -x gdb/gdb.exe
+    then
+	echo ... ${make} ${keepgoing} ${makejobs} ${target}
+	${make} ${keepgoing} ${makejobs} all-gdb 2>&1 | log 1 Build.log
+    fi
+    fail "compile failed" ! -x gdb/gdb -a ! -x gdb/gdb.exe
+ 
+    # Check that the built GDB can at least print it's architecture.
+
+    echo ... run ${target}
+    rm -f core gdb.core ${dir}/gdb/x
+    cat <<EOF > x
+maint print architecture
+quit
+EOF
+    ./gdb/gdb -batch -nx -x x 2>&1 | log 1 Gdb.log
+    fail "gdb dumped core" -r core -o -r gdb.core
+    fail "gdb printed no output" ! -s Gdb.log
+    grep -e internal-error Gdb.log && fail "gdb panic" 1
+
+    # Replace the build directory with a file as semaphore that stops
+    # a rebuild. (should the logs be saved?)
+
+    cd ${builddir}
+    rm -f ${target}.tmp
+    mv ${target}/Gdb.log ${target}.tmp
+    rm -rf ${target}
+    mv ${target}.tmp ${target}
+
+    # Success!
+    echo ... ${target} built
+
 done
+
+exit 0