path: root/simple-build-script/build_tools

#! /bin/sh
#
#  This script is a simple script to build and install rtems toolset
#  for the target you specify on the command line.  It should be of
#  the form <CPU>-rtems<VERSION>.  For example, sparc-rtems4.11
#
#  This can be used to build versions from CVS/SVN or released versions.
#  Please be sure to apply appropriate patches from
#  rtems/contrib/crossrpms/patches.
#
#  Currently only testing of non-RTEMS targets is supported.
#

### EDIT THESE AS NEEDED
AUTOCONF=autoconf-2.69
AUTOMAKE=automake-1.12.6
BINUTILS=binutils-cvs/src
GDB=gdb-cvs/src
GCC=gcc-svn
NEWLIB=newlib-cvs/src
LANGUAGES="c,c++"
### END OF EDIT THESE

BASE=`pwd`

#   log an error to stderr
prerr()
{
    echo "$*" >&2
}

fatal() {
    prerr "$USAGE"
    [ "$1" ] && (prerr ; prerr $*);
    exit 1
}

check_status()
{
  if [ $1 -ne 0 ] ; then
    shift
    echo "FAILED: " "$*" >&2
    exit 1
  fi
}

toggle()
{
  case $1 in
    no)  echo "yes" ;;
    yes) echo "no" ;;
    *)   fatal "Unknown value to toggle ($1)" ;;
  esac
}

usage()
{
cat <<EOF
  -v             verbose (default=no)
  -c             clean after building if OK (default=yes)
  -A             toggle building binutils, gcc, newlib, and gdb
  -a             toggle building autoconf (default=no)
  -m             toggle building automake (default=no)
  -b             toggle building binutils (default=no)
  -g             toggle building gcc/newlib (default=no)
  -d             toggle building gdb (default=no)
  -i INSTALL     specify install directory (required)
  -t TARGET      specify target (required)
  -B DIRECTORY   specify directory for build tree (default=pwd)
  -T             toggle running test (default=no)
  -M             toggle sending test results email (default=no)

EOF
exit 1
}

sourcedir=`pwd`
buildroot=`pwd`
do_clean=yes
do_autoconf=no
do_automake=no
do_binutils=no
do_gdb=no
do_gcc_newlib=no
verbose=no
TARGET=NOT_SET
INSTALL=NOT_SET
jobs=NOT_SET
do_tests=no
do_mail=no

while getopts cj:B:vTMAambgdi:t: OPT
do
  case "$OPT" in
    A) do_binutils=`toggle ${do_binutils}`
       do_gdb=`toggle ${do_gdb}`
       do_gcc_newlib=`toggle ${do_gcc_newlib}`
       ;;
    a) do_autoconf=`toggle ${do_autoconf}` ;;
    m) do_automake=`toggle ${do_automake}` ;;
    b) do_binutils=`toggle ${do_binutils}` ;;
    g) do_gcc_newlib=`toggle ${do_gcc_newlib}` ;;
    d) do_gdb=`toggle ${do_gdb}` ;;
    i) INSTALL="${OPTARG}" ;;
    t) TARGET="${OPTARG}" ;;
    j) jobs="${OPTARG}" ;;
    B) buildroot="${OPTARG}" ;;
    c) do_clean=`toggle ${do_clean}` ;;
    T) do_tests=`toggle ${do_tests}` ;;
    M) do_mail=`toggle ${do_mail}` ;;
    v) verbose=`toggle ${verbose}` ;;
    *) echo "Error ${OPT} is not a valid option" ; usage ; exit 1 ;;
  esac
done

# Specify the desired parallelism
if [ ${jobs} != "NOT_SET" ] ; then
  case ${jobs} in
    NOT_SET)
      JOBS=""
      ;;
    ''|*[!0-9]*)
      check_fatal 1 "Number of jobs (${jobs}) specified is not a number"
      ;;
    *)
      JOBS="-j ${jobs}"
      ;;
  esac
fi

if [ ${verbose} = "yes" ] ; then
  echo "Build autoconf:    " ${do_autoconf}
  echo "Build automake:    " ${do_automake}
  echo "Build binutils:    " ${do_binutils}
  echo "Build gdb:         " ${do_gdb}
  echo "Build gcc/newlib:  " ${do_gcc_newlib}
  echo "Clean as building: " ${do_clean}
  echo "Running Tests:     " ${do_tests}
  echo "  Mailing Results: " ${do_mail}
  echo "Parallel Jobs:     " ${jobs}
  echo "Install point:     " ${INSTALL}
  echo "Build root:        " ${buildroot}
  echo "Target:            " ${TARGET}
  echo
fi

### Validate arguments
test ${TARGET} != NOT_SET
check_status $? "TARGET not specified"

test ${INSTALL} != NOT_SET
check_status $? "INSTALL not specified"
  
if [ ! -d ${INSTALL} ] ; then
  mkdir ${INSTALL}
  check_status $? "failed to make ${INSTALL}"
fi

if [ ${do_autoconf} = yes ] ; then
  test -d ${AUTOCONF}
  check_status $? "No ${AUTOCONF} - You do not appear to be in src directory"
  TOBUILD="${TOBUILD} ${AUTOCONF}"
fi

if [ ${do_automake} = yes ] ; then
  test -d ${AUTOMAKE}
  check_status $? "No ${AUTOMAKE} - You do not appear to be in src directory"
  TOBUILD="${TOBUILD} ${AUTOMAKE}"
fi

if [ ${do_binutils} = yes ] ; then
  test -d ${BINUTILS}
  check_status $? "No ${BINUTILS} - You do not appear to be in src directory"
  TOBUILD="${TOBUILD} ${BINUTILS}"
fi

if [ ${do_gdb} = yes ] ; then
  test -d ${GDB}
  check_status $? "No ${GDB} - You do not appear to be in src directory"
  TOBUILD="${TOBUILD} ${GDB}"
fi

if [ ${do_gcc_newlib} = yes ] ; then
  test -d ${GCC}
  check_status $? "No ${GCC} - You do not appear to be in src directory"

  test -d ${NEWLIB}
  check_status $? "No ${NEWLIB} - You do not appear to be in src directory"

  if [ ! -d ${GCC}/newlib -o ! -d ${GCC}/libgloss ] ; then
    echo "Please ensure that ${GCC}/newlib and ${GCC}/libgloss are symbolic"
    echo "links into the newlib tree.  Use commands simiilar to the following:"
    echo ""
    echo "ln -s ${BASE}/${NEWLIB}/newlib ${BASE}/${GCC}/newlib"
    echo "ln -s ${BASE}/${NEWLIB}/libgloss ${BASE}/${GCC}/libgloss"
    exit 1
  fi

  TOBUILD="${TOBUILD} ${GCC}"
fi

test -d ${buildroot}
check_status $? "${buildroot} does not exist"

export PATH=${INSTALL}/bin:$PATH
### Build everything
for pkg in ${TOBUILD}
do
  cd ${buildroot}
  check_status $? "failed to cd ${buildroot}"

  BUILDDIR=`echo b-${TARGET}-${pkg} | sed -e 's/\//-/g'`

  rm -rf ${BUILDDIR}
  check_status $? "failed to rm ${BUILDDIR}"

  mkdir ${BUILDDIR}
  check_status $? "failed to make ${BUILDDIR}"

  cd ${BUILDDIR}
  check_status $? "failed to cd ${BUILDDIR}"

  echo "Configuring ${pkg} in ${BUILDDIR}..."
  case $pkg in
    auto*)                               # autotools are native
      ${sourcedir}/${pkg}/configure --prefix=${INSTALL} >c.log 2>&1
      check_status $? "failed to configure ${pkg}"
      ;;
    binutils*)
      ${sourcedir}/${pkg}/configure --target=${TARGET} \
        --prefix=${INSTALL} >c.log 2>&1
      check_status $? "failed to configure ${pkg}"
      ;;
    gdb*)
      ${sourcedir}/${pkg}/configure --target=${TARGET} \
        --prefix=${INSTALL} \
        --enable-sim --enable-sim-hardware \
        --enable-timebase --enable-sim-trace >c.log 2>&1
      check_status $? "failed to configure ${pkg}"
      ;;
    gcc*)
      ${sourcedir}/${GCC}/configure \
       --enable-threads=rtems  --with-gnu-as --enable-multilib \
       --enable-newlib-mb --enable-newlib-iconv \
       --with-gnu-ld --with-newlib  --verbose --with-system-zlib --disable-nls \
        --enable-version-specific-runtime-libs \
        --enable-languages=${LANGUAGES} --target=${TARGET} --prefix=${INSTALL} \
      >c.log 2>&1
      check_status $? "failed to configure ${pkg}"
      ;;
    *)
      prerr "UNKNOWN PACKAGE ${pkg}"
      exit 1
      ;;
  esac

  echo "Building ${pkg}..."
  make ${JOBS} >b.log 2>&1
  check_status $? "failed to make ${pkg}"

  echo "Installing ${pkg}..."
  make install >i.log 2>&1
  check_status $? "failed to install ${pkg}"

  # If testing the package, fall into this if
  if [ ${do_tests} = "yes" ] ; then
    echo "Testing ${pkg}..."
    case $pkg in
      auto*)
        # currently do not run test suite on autoconf and automake
        ;;
      binutils*)
        echo "Testing binutils for ${TARGET}"
        make check >check.log 2>&1
        ;;
      gdb*)
        # currently do not run test suite on gdb
        ;;
      gcc*)
        baseboard=NOT_SET
        case ${TARGET} in
          *-rtems*)
            echo "*** Currently do not support testing GCC with this script"
            ;;
          *-elf*|*-eabi*)
            cpu=`echo ${TARGET} | cut -d'-' -f1`
            case ${cpu} in
              arc*|arm*|basic*|cris*|d10v*|d30v*|fr30*|frv*|h8300*|i960*|iq2000*|jmr3904|\
              m32r*|m68hc11*|mcore*|mips*|mips64*|mips64vr4100*|mmixware*|mn10200|\
              mn10300*|powerpc*|powerpcle*|sh*|sparc*|sparc64*|sparclite*|tic80*|tx39|\
              v850*|vr4100*|vr4111*|vr4300*|xtensa*)
                baseboard=${cpu}-sim
                ;;
              *)
                ;;
            esac
            ;;
          *)
            ;;
          
        esac

        # now see if we found a configuration to test with
        if [ ${baseboard} = "NOT_SET" ] ; then
          echo "*** Do not know how to test gcc on ${target}"
          continue
        fi

        echo "Testing gcc for ${TARGET} on ${baseboard}"
        make check RUNTESTFLAGS="--target_board=${baseboard}" >check.log 2>&1

        if [ ${do_mail} = "yes" ] ; then
          echo "Sending ${language} test results to GCC community.."
          ${sourcedir}/${GCC}/contrib/test_summary -m gcc-testresults@gcc.gnu.org | sh
          check_status $? "Failed to email ${language} Test Results to GCC Community .. bailing"

          echo "Sending ${language} test results to RTEMS community.."
          ${sourcedir}/${GCC}/contrib/test_summary -o -m rtems-tooltestresults@rtems.org | sh
          check_status $? "Failed to email ${language} Test Results to RTEMS Community .. bailing"
        fi
        ;;
      *)
        prerr "UNKNOWN PACKAGE ${pkg}"
        exit 1
        ;;
    esac

  fi
  # END of if testing the package

  cd ..
  if [ ${do_clean} = "yes" ] ; then
    rm -rf ${BUILD}
  fi
done

exit 0