doit

#!/usr/bin/env bash

OS="$(uname)"
HOSTARCH="$(uname -m)"
PARALLEL=
FETCH=0
QUIET=0
STRIP=0
TRIPLET=
BINUTILSARGS=
GCCARGS=
GDBARGS=
GDB=1
GNU_MIRROR=https://mirrors.kernel.org/gnu
# Get absolute path, will spawn a subshell then exit so our pwd is retained
SCRIPTROOT=$(cd "$(dirname $0)" && pwd)
PATCHES=$SCRIPTROOT/patches/

# Cause errors in pipes to return failure when necessary
set -o pipefail

function err() {
    echo "doit: error during build"
    if [ "$QUIET" = "1" ]; then
        echo "doit: dumping last 50 lines of build log..."
        echo "doit: see $OUTDIR/build.log for the full details"
        tail -50 $OUTDIR/build.log
    fi
    exit 1
}

trap err ERR

function help()
{
    echo "Options"
    echo " -a <arch list>               architectures to build"
    echo "    example: -a 'arm' or -a 'arm i386 x86_64' for multiple"
    echo " -c                           use compilation cache (ccache must be installed)"
    echo " -f                           fetch source releases from upstream"
    echo " -g                           do not build GDB (not supported on some architectures)"
    echo " -h|-?                        display this help message"
    echo " -j<#>                        use <#> parallel workers to build"
    echo " -o <dir>                     output directory"
    echo " -q                           make the build quieter"
    echo " -s                           strip the binaries"
    echo " -T                           custom triple suffix to add to the architecture"
    echo " -B                           pass custom flags to binutils configure script"
    echo " -G                           pass custom flags to GCC configure script"
    echo " -D                           pass custom flags to GDB configure script"
    exit 1
}

function log()
{
    if [ "$QUIET" = "1" ]; then
        "$@" >> $OUTDIR/build.log 2>&1
    else
        "$@" 2>&1 | tee -a $OUTDIR/build.log
    fi
}

function download-archive()
{
    local name="$1"
    local ver="$2"
    local ext="$3"
    local subdir="$4"

    local filename="$name-$ver.tar.$ext"

    if [ ! -f "$ARCHIVES/$filename" ]; then
       echo "fetching $name-$ver"
       log wget -P "$ARCHIVES" -N "$GNU_MIRROR/$name/$subdir$filename"
    else
       log echo "$filename already downloaded, skipping"
    fi
}

function full-path {
    case "$1" in
        [!/]*) echo "$PWD/$1" ;;
        *) echo "$1" ;;
    esac
}

function extract-tool()
{
    #echo "extract-tool" $1 $2 $3 $4 $5

    local TARFILE=${1}-${2}.tar$3
    local TARGETDIR=${1}-${2}
    local HASH="$4"

    if [ -z ${TARGETDIR} ]; then
        log echo "error, targetdir is empty"
        exit 1
    fi

    if [ -f ${TARGETDIR}/.extracted ]; then
        log echo "$TARFILE already extracted into $TARGETDIR, skipping"
        return 0
    fi
    if [ ! -f $ARCHIVES/$TARFILE ]; then
        log echo "error, missing $TARFILE"
        exit 1
    fi

    echo "checking $TARFILE integrity"
    if [ "$(shasum -a 256 -b "$ARCHIVES/$TARFILE" | cut -f1 -d' ')" != "$HASH" ]; then
      log echo "$TARFILE failed integrity check"
      exit 1
    fi

    echo extracting $TARFILE
    pushd $OUTDIR > /dev/null
    rm -rf -- "$TARGETDIR"
    tar xf $ARCHIVES/$TARFILE || exit 1

    if [ ! -z "$5" ]; then
        local PATCHES=$(echo $5-* | sort)
        for i in $PATCHES; do
            echo patching $1 with $i
            log echo patching $1 with $i
            log patch -d "$TARGETDIR" -p1 < "$i" || exit 1
        done

    fi

    touch $TARGETDIR/.extracted || exit 1
    popd > /dev/null
}

MAKE=make
if [ "$OS" = "Linux" ]; then
    COUNT=`grep processor /proc/cpuinfo | wc -l`
    PARALLEL=-j`expr $COUNT + $COUNT`
fi
if [ "$OS" = "Darwin" ]; then
    PARALLEL=-j`sysctl -n hw.ncpu`
    export CXXFLAGS="-fbracket-depth=1024 -O2"
fi
if [ "$OS" = "FreeBSD" ]; then
    PARALLEL=-j`sysctl -n hw.ncpu`
    export CXXFLAGS="-fbracket-depth=1024 -O2"
    MAKE=gmake
fi

if [ "$HOSTARCH" = "amd64" ]; then
    HOSTARCH=x86_64
fi

if [ $# == "0" ]; then
    help
fi

while getopts a:cfghj:o:qsT:B:G:D:? arg
do
    case $arg in
        a ) ARCHES=$OPTARG ;;
        c ) CCACHE=1 ;;
        f ) FETCH=1 ;;
        g ) GDB=0 ;;
        j ) PARALLEL="-j$OPTARG" ;;
        o ) OUTDIR="$OPTARG" ;;
        q ) QUIET=1 ;;
        s ) STRIP=1 ;;
        T ) TRIPLET="$OPTARG" ;;
        B ) BINUTILSARGS="$OPTARG" ;;
        G ) GCCARGS="$OPTARG" ;;
        D ) GDBARGS="$OPTARG" ;;
        h ) help ;;
        ? ) help ;;
        * ) echo "unrecognized option '$arg'" ; exit 1 ;;
    esac
done


if [ -z "$ARCHES" ]; then
    echo need to specify architectures to build
    echo ie -a "arm sh"
    exit 1
fi

if [ -z "$OUTDIR" ]; then
    OUTDIR=`pwd`
else
    if ! mkdir -p -- "$OUTDIR"; then
        log echo Unable to create output directory "$OUTDIR"
        exit 1
    fi
    OUTDIR="$(full-path "$OUTDIR")"
fi
ARCHIVES=$OUTDIR/archives

if [ -z $(which makeinfo) ]; then
    echo makeinfo not found. On debian/ubuntu this is provided by the texinfo package.
    exit 1
fi

export CC="cc"
export CXX="c++"

if [ "$CCACHE" = "1" ]; then
export CC="ccache $CC"
export CXX="ccache $CXX"
fi

log date
log echo "ARCHES='$ARCHES' PARALLEL='$PARALLEL' FETCH='$FETCH' CCACHE='$CCACHE'"
# load GCCVER and BINVER
. toolvers

if [ "$FETCH" = "1" ]; then
    download-archive binutils $BINVER xz
    download-archive gcc $GCCVER xz "gcc-$GCCVER/"
    download-archive gdb $GDBVER xz
    download-archive gmp $GMPVER xz
    download-archive mpc $MPCVER gz
    download-archive mpfr $MPFRVER xz
fi

if [ ! -f $OUTDIR/.extracted-stamp ]; then
    extract-tool binutils $BINVER .xz $BINHASH $PATCHES/binutils-patch
    extract-tool gcc $GCCVER .xz $GCCHASH $PATCHES/gcc-patch
    extract-tool gdb $GDBVER .xz $GDBHASH $PATCHES/gdb-patch
    extract-tool gmp $GMPVER .xz $GMPHASH
    extract-tool mpc $MPCVER .gz $MPCHASH
    extract-tool mpfr $MPFRVER .xz $MPFRHASH

    # link the last three libs into gcc
    pushd $OUTDIR/gcc-$GCCVER > /dev/null
    ln -sf ../gmp-$GMPVER gmp
    ln -sf ../mpc-$MPCVER mpc
    ln -sf ../mpfr-$MPFRVER mpfr
    popd > /dev/null

    # link the last three libs into gdb
    pushd $OUTDIR/gdb-$GDBVER > /dev/null
    ln -sf ../gmp-$GMPVER gmp
    ln -sf ../mpfr-$MPFRVER mpfr
    popd > /dev/null

    touch $OUTDIR/.extracted-stamp
fi

# switch to the outdir to root all further activities
pushd $OUTDIR > /dev/null

for ARCH in $ARCHES; do
    echo building for arch $ARCH
    if [ -n "$TRIPLET" ]
    then
        TARGET="$ARCH-$TRIPLET"
    else
        case $ARCH in
            arm) TARGET=arm-eabi;;
            pdp11) TARGET=pdp11-aout;;
            vax) TARGET=vax--netbsdelf;;
            *) TARGET=$ARCH-elf;;
        esac
    fi
    echo target triple is $TARGET

    INSTALLPATH=$OUTDIR/$TARGET-$GCCVER-$OS-$HOSTARCH
    BINBUILDPATH=$OUTDIR/build-binutils-$BINVER-$ARCH-$OS-$HOSTARCH
    GCCBUILDPATH=$OUTDIR/build-gcc-$GCCVER-$ARCH-$OS-$HOSTARCH
    GDBBUILDPATH=$OUTDIR/build-gdb-$GDBVER-$ARCH-$OS-$HOSTARCH
    export PATH=$INSTALLPATH/bin:$PATH

    # Building Binutils
    if [ ! -f $BINBUILDPATH/built.txt ]; then
        echo building binutils
        mkdir -p $BINBUILDPATH
        pushd $BINBUILDPATH > /dev/null
        log ../binutils-$BINVER/configure --target=$TARGET --prefix=$INSTALLPATH --disable-werror $BINUTILSARGS
        log $MAKE $PARALLEL
        log $MAKE install
        touch built.txt
        popd > /dev/null
    fi

    # Building GCC
    if [ ! -f $GCCBUILDPATH/built.txt ]; then
        echo building gcc
        ARCH_OPTIONS=
        case "$TARGET" in
            arm-eabi)
                # build a very aggressive set of multi libs
                ARCH_OPTIONS="--with-multilib-list=aprofile,rmprofile"
                ;;
            vax--netbsdelf)
                ARCH_OPTIONS="--disable-multilib --disable-nls --without-isl --enable-long-long"
                ;;
        esac

        mkdir -p $GCCBUILDPATH
        pushd $GCCBUILDPATH > /dev/null
        log ../gcc-$GCCVER/configure --target=$TARGET --prefix=$INSTALLPATH --enable-languages=c,c++ $ARCH_OPTIONS --disable-werror $GCCARGS
        log $MAKE all-gcc $PARALLEL
        log $MAKE all-target-libgcc $PARALLEL
        log $MAKE install-gcc
        log $MAKE install-target-libgcc
        touch built.txt
        popd > /dev/null
    fi

    if (( $GDB )); then
        if [ ! -f $GDBBUILDPATH/built.txt ]; then
            case "$TARGET" in
                aarch64-elf) ARCH_OPTIONS="--enable-targets=arm-eabi --disable-sim" ;;
                sparc-elf) ARCH_OPTIONS="--disable-sim" ;;
                *) ARCH_OPTIONS="" ;;
            esac
            if [ "$OS" = "Darwin" ]; then
                # a hack to work around gdb not wanting to find libgmp
                export LDFLAGS="-L/usr/lib -L/opt/local/lib"
                export CPPFLAGS="-I/usr/include -I/opt/local/include"
            fi
            if [ "$OS" = "FreeBSD" ]; then
                # a hack to work around gdb not wanting to find libgmp
                export LDFLAGS="-L/usr/lib -L/usr/local/lib"
                export CPPFLAGS="-I/usr/include -I/usr/local/include"
            fi

            echo building gdb
            mkdir -p $GDBBUILDPATH
            pushd $GDBBUILDPATH > /dev/null
            log ../gdb-$GDBVER/configure --target=$TARGET --prefix=$INSTALLPATH $ARCH_OPTIONS --disable-werror $GDBARGS
            log $MAKE $PARALLEL
            log $MAKE install
            touch built.txt
            popd > /dev/null

            export -n LDFLAGS
            export -n CPPFLAGS
        fi
    fi

    # Optionally strip the binaries
    if [ "${STRIP}" = "1" ]; then
      find "${INSTALLPATH}/bin" -type f -exec strip {} \;
      for filename in $(find "${INSTALLPATH}/libexec" -type f); do
        (file "${filename}" | grep -q ELF) && strip "${filename}"
      done
    fi
done

echo all done

# vim: ts=4 sw=4 expandtab