X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdb_mbuild.sh;h=496218642df43ff98df6d246748b82805e4984cb;hb=17fde6d091a9a661119d152e2304012de5fce056;hp=ae40b02c69aa34054fbaf3f9661b590ee3df311e;hpb=036243d826704e1e70fda5eaf68c60a1618ce9a0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdb_mbuild.sh b/gdb/gdb_mbuild.sh index ae40b02c69..496218642d 100755 --- a/gdb/gdb_mbuild.sh +++ b/gdb/gdb_mbuild.sh @@ -1,153 +1,337 @@ #!/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 (C) 2002-2014 Free Software Foundation, Inc. + # Contributed by Richard Earnshaw (rearnsha@arm.com) # This program 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 2 of the License, or +# 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; 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 []" - echo " Environment variables examined (with default if not defined):" - echo " AWK (awk) -- must be GNU awk" - echo " MAKE (make)" - echo - echo " Note: Everything in /gdb-allcross will be blown away." +# along with this program. If not, see . + +# Make certain that the script is not running in an internationalized +# environment. +LANG=c ; export LANG +LC_ALL=c ; export LC_ALL + +usage() +{ + cat < ... ] + Options: + -j Run in parallel. Passed to make. + On a single cpu machine, 2 is recommended. + -k Keep going. Do not stop after the first build fails. + --keep Keep builds. Do not remove each build when finished. + -e 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: + Source code directory. + Build directory. + Environment variables examined (with default if not defined): + MAKE (make)" +EOF exit 1; +cat < Run 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 +keep=false +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 + ;; + --keep ) + keep=true + ;; + -e ) + # A regular expression for selecting targets + shift + test $# -ge 1 || usage + targexp="${targexp} -e ${1}" + ;; + -f ) + # Force a rebuild + force=true ; + ;; + -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 ] +if [ ! -r ${maintainers} ] then - mv build.out build.old -fi -if [ -f config.out ] -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 . 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 . Write standard input to 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.* +# Warn the user of what is comming, print the list of targets -for targ in * +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 perhaps 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 + # Iff the build fails remove the final build target so that + # the follow-on code knows things failed. Stops the follow-on + # code thinking that a failed rebuild succedded (executable + # left around from previous build). + echo ... ${make} ${keepgoing} ${makejobs} ${target} + ( ${make} ${keepgoing} ${makejobs} all-gdb || rm -f gdb/gdb gdb/gdb.exe + ) 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 < 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 + + echo ... cleanup ${target} + + # Create a sed script that cleans up the output from GDB. + rm -f mbuild.sed + touch mbuild.sed || exit 1 + # Rules to replace <0xNNNN> with the corresponding function's + # name. + sed -n -e '/<0x0*>/d' -e 's/^.*<0x\([0-9a-f]*\)>.*$/0x\1/p' Gdb.log \ + | sort -u \ + | while read addr + do + func="`addr2line -f -e ./gdb/gdb -s ${addr} | sed -n -e 1p`" + test ${verbose} -gt 0 && echo "${addr} ${func}" 1>&2 + echo "s/<${addr}>/<${func}>/g" + done >> mbuild.sed + # Rules to strip the leading paths off of file names. + echo 's/"\/.*\/gdb\//"gdb\//g' >> mbuild.sed + # Run the script + sed -f mbuild.sed Gdb.log > Mbuild.log + + # Replace the build directory with a file as semaphore that stops + # a rebuild. (should the logs be saved?) + + cd ${builddir} + + if ${keep} + then + : + else + rm -f ${target}.tmp + mv ${target}/Mbuild.log ${target}.tmp + rm -rf ${target} + mv ${target}.tmp ${target} + fi + + # Success! + echo ... ${target} built + done + +exit 0