OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [gdb_mbuild.sh] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827 Rev 840
#!/bin/sh
#!/bin/sh
 
 
#  Multi-build script for testing compilation of all maintained
#  Multi-build script for testing compilation of all maintained
#  configs of GDB.
#  configs of GDB.
 
 
#  Copyright (C) 2002, 2003, 2007, 2008 Free Software Foundation, Inc.
#  Copyright (C) 2002, 2003, 2007, 2008 Free Software Foundation, Inc.
 
 
#  Contributed by Richard Earnshaw  (rearnsha@arm.com)
#  Contributed by Richard Earnshaw  (rearnsha@arm.com)
 
 
#  This program is free software; you can redistribute it and/or modify
#  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
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 3 of the License, or
#  the Free Software Foundation; either version 3 of the License, or
#  (at your option) any later version.
#  (at your option) any later version.
#
#
#  This program is distributed in the hope that it will be useful,
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#  GNU General Public License for more details.
#
#
#  You should have received a copy of the GNU General Public License
#  You should have received a copy of the GNU General Public License
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
# Make certain that the script is not running in an internationalized
# Make certain that the script is not running in an internationalized
# environment.
# environment.
LANG=c ; export LANG
LANG=c ; export LANG
LC_ALL=c ; export LC_ALL
LC_ALL=c ; export LC_ALL
 
 
usage()
usage()
{
{
    cat <<EOF
    cat <<EOF
Usage: gdb_mbuild.sh [ <options> ... ] <srcdir> <builddir>
Usage: gdb_mbuild.sh [ <options> ... ] <srcdir> <builddir>
 Options:
 Options:
   -j <makejobs>  Run <makejobs> in parallel.  Passed to make.
   -j <makejobs>  Run <makejobs> in parallel.  Passed to make.
                  On a single cpu machine, 2 is recommended.
                  On a single cpu machine, 2 is recommended.
   -k             Keep going.  Do not stop after the first build fails.
   -k             Keep going.  Do not stop after the first build fails.
   --keep         Keep builds.  Do not remove each build when finished.
   --keep         Keep builds.  Do not remove each build when finished.
   -e <regexp>    Regular expression for selecting the targets to build.
   -e <regexp>    Regular expression for selecting the targets to build.
   -f             Force rebuild.  Even rebuild previously built directories.
   -f             Force rebuild.  Even rebuild previously built directories.
   -v             Be more (and more, and more) verbose.
   -v             Be more (and more, and more) verbose.
 Arguments:
 Arguments:
   <srcdir>       Source code directory.
   <srcdir>       Source code directory.
   <builddir>     Build directory.
   <builddir>     Build directory.
 Environment variables examined (with default if not defined):
 Environment variables examined (with default if not defined):
   MAKE (make)"
   MAKE (make)"
EOF
EOF
    exit 1;
    exit 1;
cat <<NOTYET
cat <<NOTYET
  -b <maxbuilds> Run <maxbuild> builds in parallel.
  -b <maxbuilds> Run <maxbuild> builds in parallel.
                 On a single cpu machine, 1 is recommended.
                 On a single cpu machine, 1 is recommended.
NOTYET
NOTYET
}
}
 
 
### COMMAND LINE OPTIONS
### COMMAND LINE OPTIONS
 
 
makejobs=
makejobs=
maxbuilds=1
maxbuilds=1
keepgoing=
keepgoing=
force=false
force=false
targexp=""
targexp=""
verbose=0
verbose=0
keep=false
keep=false
while test $# -gt 0
while test $# -gt 0
do
do
    case "$1" in
    case "$1" in
    -j )
    -j )
        # Number of parallel make jobs.
        # Number of parallel make jobs.
        shift
        shift
        test $# -ge 1 || usage
        test $# -ge 1 || usage
        makejobs="-j $1"
        makejobs="-j $1"
        ;;
        ;;
    -b | -c )
    -b | -c )
        # Number of builds to fire off in parallel.
        # Number of builds to fire off in parallel.
        shift
        shift
        test $# -ge 1 || usage
        test $# -ge 1 || usage
        maxbuilds=$1
        maxbuilds=$1
        ;;
        ;;
    -k )
    -k )
        # Should we soldier on after the first build fails?
        # Should we soldier on after the first build fails?
        keepgoing=-k
        keepgoing=-k
        ;;
        ;;
    --keep )
    --keep )
        keep=true
        keep=true
        ;;
        ;;
    -e )
    -e )
        # A regular expression for selecting targets
        # A regular expression for selecting targets
        shift
        shift
        test $# -ge 1 || usage
        test $# -ge 1 || usage
        targexp="${targexp} -e ${1}"
        targexp="${targexp} -e ${1}"
        ;;
        ;;
    -f )
    -f )
        # Force a rebuild
        # Force a rebuild
        force=true ;
        force=true ;
        ;;
        ;;
    -v )
    -v )
        # Be more, and more, and more, verbose
        # Be more, and more, and more, verbose
        verbose=`expr ${verbose} + 1`
        verbose=`expr ${verbose} + 1`
        ;;
        ;;
    -* ) usage ;;
    -* ) usage ;;
    *) break ;;
    *) break ;;
    esac
    esac
    shift
    shift
done
done
 
 
 
 
### COMMAND LINE PARAMETERS
### COMMAND LINE PARAMETERS
 
 
if test $# -ne 2
if test $# -ne 2
then
then
    usage
    usage
fi
fi
 
 
# Convert these to absolute directory paths.
# Convert these to absolute directory paths.
 
 
# Where the sources live
# Where the sources live
srcdir=`cd $1 && /bin/pwd` || exit 1
srcdir=`cd $1 && /bin/pwd` || exit 1
 
 
# Where the builds occur
# Where the builds occur
builddir=`cd $2 && /bin/pwd` || exit 1
builddir=`cd $2 && /bin/pwd` || exit 1
 
 
### ENVIRONMENT PARAMETERS
### ENVIRONMENT PARAMETERS
 
 
# Version of make to use
# Version of make to use
make=${MAKE:-make}
make=${MAKE:-make}
MAKE=${make}
MAKE=${make}
export MAKE
export MAKE
 
 
 
 
# Where to look for the list of targets to test
# Where to look for the list of targets to test
maintainers=${srcdir}/gdb/MAINTAINERS
maintainers=${srcdir}/gdb/MAINTAINERS
if [ ! -r ${maintainers} ]
if [ ! -r ${maintainers} ]
then
then
    echo Maintainers file ${maintainers} not found
    echo Maintainers file ${maintainers} not found
    exit 1
    exit 1
fi
fi
 
 
# Get the list of targets and the build options
# Get the list of targets and the build options
alltarg=`cat ${maintainers} | tr -s '[\t]' '[ ]' | sed -n '
alltarg=`cat ${maintainers} | tr -s '[\t]' '[ ]' | sed -n '
/^[ ]*[-a-z0-9\.]*[ ]*[(]*--target=.*/ !d
/^[ ]*[-a-z0-9\.]*[ ]*[(]*--target=.*/ !d
s/^.*--target=//
s/^.*--target=//
s/).*$//
s/).*$//
h
h
:loop
:loop
  g
  g
  /^[^ ]*,/ !b end
  /^[^ ]*,/ !b end
  s/,[^ ]*//
  s/,[^ ]*//
  p
  p
  g
  g
  s/^[^,]*,//
  s/^[^,]*,//
  h
  h
b loop
b loop
:end
:end
p
p
' | if test "${targexp}" = ""
' | if test "${targexp}" = ""
then
then
    grep -v -e broken -e OBSOLETE
    grep -v -e broken -e OBSOLETE
else
else
    grep ${targexp}
    grep ${targexp}
fi`
fi`
 
 
 
 
# Usage: fail <message> <test-that-should-succeed>.  Should the build
# 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
# 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.
# the message and shoot everything in sight and abort the build.
 
 
fail ()
fail ()
{
{
    msg="$1" ; shift
    msg="$1" ; shift
    if test "$@"
    if test "$@"
    then
    then
        echo "${target}: ${msg}"
        echo "${target}: ${msg}"
        if test "${keepgoing}" != ""
        if test "${keepgoing}" != ""
        then
        then
            #exit 1
            #exit 1
            continue
            continue
        else
        else
            kill $$
            kill $$
            exit 1
            exit 1
        fi
        fi
    fi
    fi
}
}
 
 
 
 
# Usage: log <level> <logfile>.  Write standard input to <logfile> and
# Usage: log <level> <logfile>.  Write standard input to <logfile> and
# stdout (if verbose >= level).
# stdout (if verbose >= level).
 
 
log ()
log ()
{
{
    if test ${verbose} -ge $1
    if test ${verbose} -ge $1
    then
    then
        tee $2
        tee $2
    else
    else
        cat > $2
        cat > $2
    fi
    fi
}
}
 
 
 
 
 
 
# Warn the user of what is comming, print the list of targets
# Warn the user of what is comming, print the list of targets
 
 
echo "$alltarg"
echo "$alltarg"
echo ""
echo ""
 
 
 
 
# For each target, configure, build and test it.
# For each target, configure, build and test it.
 
 
echo "$alltarg" | while read target gdbopts simopts
echo "$alltarg" | while read target gdbopts simopts
do
do
 
 
    trap "exit 1"  1 2 15
    trap "exit 1"  1 2 15
    dir=${builddir}/${target}
    dir=${builddir}/${target}
 
 
    # Should a scratch rebuild be forced, for perhaps the entire
    # Should a scratch rebuild be forced, for perhaps the entire
    # build be skipped?
    # build be skipped?
 
 
    if ${force}
    if ${force}
    then
    then
        echo forcing ${target} ...
        echo forcing ${target} ...
        rm -rf ${dir}
        rm -rf ${dir}
    elif test -f ${dir}
    elif test -f ${dir}
    then
    then
        echo "${target}"
        echo "${target}"
        continue
        continue
    else
    else
        echo ${target} ...
        echo ${target} ...
    fi
    fi
 
 
    # Did the previous configure attempt fail?  If it did
    # Did the previous configure attempt fail?  If it did
    # restart from scratch.
    # restart from scratch.
 
 
    if test -d ${dir} -a ! -r ${dir}/Makefile
    if test -d ${dir} -a ! -r ${dir}/Makefile
    then
    then
        echo ... removing partially configured ${target}
        echo ... removing partially configured ${target}
        rm -rf ${dir}
        rm -rf ${dir}
        if test -d ${dir}
        if test -d ${dir}
        then
        then
            echo "${target}: unable to remove directory ${dir}"
            echo "${target}: unable to remove directory ${dir}"
            exit 1
            exit 1
        fi
        fi
    fi
    fi
 
 
    # From now on, we're in this target's build directory
    # From now on, we're in this target's build directory
 
 
    mkdir -p ${dir}
    mkdir -p ${dir}
    cd ${dir} || exit 1
    cd ${dir} || exit 1
 
 
    # Configure, if not already.  Should this go back to being
    # Configure, if not already.  Should this go back to being
    # separate and done in parallel?
    # separate and done in parallel?
 
 
    if test ! -r Makefile
    if test ! -r Makefile
    then
    then
        # Default SIMOPTS to GDBOPTS.
        # Default SIMOPTS to GDBOPTS.
        test -z "${simopts}" && simopts="${gdbopts}"
        test -z "${simopts}" && simopts="${gdbopts}"
        # The config options
        # The config options
        __target="--target=${target}"
        __target="--target=${target}"
        __enable_gdb_build_warnings=`test -z "${gdbopts}" \
        __enable_gdb_build_warnings=`test -z "${gdbopts}" \
            || echo "--enable-gdb-build-warnings=${gdbopts}"`
            || echo "--enable-gdb-build-warnings=${gdbopts}"`
        __enable_sim_build_warnings=`test -z "${simopts}" \
        __enable_sim_build_warnings=`test -z "${simopts}" \
            || echo "--enable-sim-build-warnings=${simopts}"`
            || echo "--enable-sim-build-warnings=${simopts}"`
        __configure="${srcdir}/configure \
        __configure="${srcdir}/configure \
            ${__target} \
            ${__target} \
            ${__enable_gdb_build_warnings} \
            ${__enable_gdb_build_warnings} \
            ${__enable_sim_build_warnings}"
            ${__enable_sim_build_warnings}"
        echo ... ${__configure}
        echo ... ${__configure}
        trap "echo Removing partially configured ${dir} directory ...; rm -rf ${dir}; exit 1" 1 2 15
        trap "echo Removing partially configured ${dir} directory ...; rm -rf ${dir}; exit 1" 1 2 15
        ${__configure} 2>&1 | log 2 Config.log
        ${__configure} 2>&1 | log 2 Config.log
        trap "exit 1"  1 2 15
        trap "exit 1"  1 2 15
    fi
    fi
    fail "configure failed" ! -r Makefile
    fail "configure failed" ! -r Makefile
 
 
    # Build, if not built.
    # Build, if not built.
 
 
    if test ! -x gdb/gdb -a ! -x gdb/gdb.exe
    if test ! -x gdb/gdb -a ! -x gdb/gdb.exe
    then
    then
        # Iff the build fails remove the final build target so that
        # Iff the build fails remove the final build target so that
        # the follow-on code knows things failed.  Stops the follow-on
        # the follow-on code knows things failed.  Stops the follow-on
        # code thinking that a failed rebuild succedded (executable
        # code thinking that a failed rebuild succedded (executable
        # left around from previous build).
        # left around from previous build).
        echo ... ${make} ${keepgoing} ${makejobs} ${target}
        echo ... ${make} ${keepgoing} ${makejobs} ${target}
        ( ${make} ${keepgoing} ${makejobs} all-gdb || rm -f gdb/gdb gdb/gdb.exe
        ( ${make} ${keepgoing} ${makejobs} all-gdb || rm -f gdb/gdb gdb/gdb.exe
        ) 2>&1 | log 1 Build.log
        ) 2>&1 | log 1 Build.log
    fi
    fi
    fail "compile failed" ! -x gdb/gdb -a ! -x gdb/gdb.exe
    fail "compile failed" ! -x gdb/gdb -a ! -x gdb/gdb.exe
 
 
    # Check that the built GDB can at least print it's architecture.
    # Check that the built GDB can at least print it's architecture.
 
 
    echo ... run ${target}
    echo ... run ${target}
    rm -f core gdb.core ${dir}/gdb/x
    rm -f core gdb.core ${dir}/gdb/x
    cat <<EOF > x
    cat <<EOF > x
maint print architecture
maint print architecture
quit
quit
EOF
EOF
    ./gdb/gdb -batch -nx -x x 2>&1 | log 1 Gdb.log
    ./gdb/gdb -batch -nx -x x 2>&1 | log 1 Gdb.log
    fail "gdb dumped core" -r core -o -r gdb.core
    fail "gdb dumped core" -r core -o -r gdb.core
    fail "gdb printed no output" ! -s Gdb.log
    fail "gdb printed no output" ! -s Gdb.log
    grep -e internal-error Gdb.log && fail "gdb panic" 1
    grep -e internal-error Gdb.log && fail "gdb panic" 1
 
 
    echo ... cleanup ${target}
    echo ... cleanup ${target}
 
 
    # Create a sed script that cleans up the output from GDB.
    # Create a sed script that cleans up the output from GDB.
    rm -f mbuild.sed
    rm -f mbuild.sed
    touch mbuild.sed || exit 1
    touch mbuild.sed || exit 1
    # Rules to replace <0xNNNN> with the corresponding function's
    # Rules to replace <0xNNNN> with the corresponding function's
    # name.
    # name.
    sed -n -e '/<0x0*>/d' -e 's/^.*<0x\([0-9a-f]*\)>.*$/0x\1/p' Gdb.log \
    sed -n -e '/<0x0*>/d' -e 's/^.*<0x\([0-9a-f]*\)>.*$/0x\1/p' Gdb.log \
    | sort -u \
    | sort -u \
    | while read addr
    | while read addr
    do
    do
        func="`addr2line -f -e ./gdb/gdb -s ${addr} | sed -n -e 1p`"
        func="`addr2line -f -e ./gdb/gdb -s ${addr} | sed -n -e 1p`"
        test ${verbose} -gt 0 && echo "${addr} ${func}" 1>&2
        test ${verbose} -gt 0 && echo "${addr} ${func}" 1>&2
        echo "s/<${addr}>/<${func}>/g"
        echo "s/<${addr}>/<${func}>/g"
    done >> mbuild.sed
    done >> mbuild.sed
    # Rules to strip the leading paths off of file names.
    # Rules to strip the leading paths off of file names.
    echo 's/"\/.*\/gdb\//"gdb\//g' >> mbuild.sed
    echo 's/"\/.*\/gdb\//"gdb\//g' >> mbuild.sed
    # Run the script
    # Run the script
    sed -f mbuild.sed Gdb.log > Mbuild.log
    sed -f mbuild.sed Gdb.log > Mbuild.log
 
 
    # Replace the build directory with a file as semaphore that stops
    # Replace the build directory with a file as semaphore that stops
    # a rebuild. (should the logs be saved?)
    # a rebuild. (should the logs be saved?)
 
 
    cd ${builddir}
    cd ${builddir}
 
 
    if ${keep}
    if ${keep}
    then
    then
        :
        :
    else
    else
        rm -f ${target}.tmp
        rm -f ${target}.tmp
        mv ${target}/Mbuild.log ${target}.tmp
        mv ${target}/Mbuild.log ${target}.tmp
        rm -rf ${target}
        rm -rf ${target}
        mv ${target}.tmp ${target}
        mv ${target}.tmp ${target}
    fi
    fi
 
 
    # Success!
    # Success!
    echo ... ${target} built
    echo ... ${target} built
 
 
done
done
 
 
exit 0
exit 0
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.