path: root/build.sh

#!/bin/bash
set -e

[[ -n ${ARCH} ]] && export ARCH

ROOT_DIR=$(readlink -f $(dirname $0))

source ${ROOT_DIR}/helper/generic
source ${ROOT_DIR}/helper/toolchain
source ${ROOT_DIR}/helper/openssl
source ${ROOT_DIR}/helper/cunit
source ${ROOT_DIR}/helper/coverity

# CROSS_HOST need to be exported
# CONFIGURE_FLAGS need to be exported

#Environment vars that affect the build
export success=0
export GIT_BRANCH="${GIT_BRANCH:-master}"
export CLEANUP="${CLEANUP:-1}"
export LCOV="${LCOV:-0}"
export UNTESTED="${UNTESTED:-0}"
export NUM_CPUS=${NUM_CPUS:-"$(getconf _NPROCESSORS_ONLN)"}
export TEST_LIST="${TEST_LIST:-""}"
export M32_ON_64="${M32_ON_64:-0}"
export DOXYGEN_HTML="${DOXYGEN_HTML:-0}"
export USER_HTML="${USER_HTML:-0}"
export SCAN_BUILD="${SCAN_BUILD:-0}"
export CLANG="${CLANG:-0}"
export SPARSE="${SPARSE:-0}"
export QUIET="${QUIET:-0}"
export EXIT_ON_ERROR="${EXIT_ON_ERROR:-1}"
export CPP_TEST="${CPP_TEST:-0}"
export DISTCHECK="${DISTCHECK:-0}"
export INSTALLCHECK="${INSTALLCHECK:-0}"
export DRYRUN="${DRYRUN:-0}"
export BUILD_DEPS="${BUILD_DEPS:-1}"
export RELOCATE_TEST="${RELOCATE_TEST:-1}"
export MAKE_CHECK_TEST="${MAKE_CHECK_TEST:-1}"
export ENABLE_NETMAP_PKTIO="${ENABLE_NETMAP_PKTIO:-0}"
E_VALGRIND="${E_VALGRIND:-0}"
RUN_VALID_FROM_INSTALL="${RUN_VALID_FROM_INSTALL:-0}"
if [[ ! -z ${TEST_LIST} ]]; then
    export TESTS="${TEST_LIST}"
fi

export GENERIC_SRCDIR="${GENERIC_SRCDIR:-${SRCDIR}/odp}"
export GENERIC_BUILDDIR="${GENERIC_BUILDDIR:-${BUILDDIR}/odp}"
PLATFORM=${PLATFORM:-linux-generic}
GPLATFORM="--with-platform=${PLATFORM}"

GLOBAL_DSTDIRPATH="$ROOT_DIR/new-build"
DSTDIR="--prefix=${GLOBAL_DSTDIRPATH}"
GENERIC_PUBLISHING="${ROOT_DIR}/publishing/${GIT_BRANCH}"
mkdir -p ${GENERIC_PUBLISHING}
GENERIC_LOGDIR="${LOGDIR}/odp-build"
LOGFILE_BASENAME="${LOGFILE_BASENAME:-default}"
LOGFILE="${GENERIC_LOGDIR}/${LOGFILE_BASENAME}-$(date "+%Y%m%d_%H%M")"
mkdir -p ${GENERIC_LOGDIR}


quiet(){
    if [[ ${QUIET} -eq 1 ]]; then
        $* >> ${LOGFILE}-build.log
        retcode=$?
    else
        $*
        retcode=$?
    fi
    return ${retcode}
}

exit_on_error(){
    quiet $*
    retcode=$?
    if [[ ${retcode} -ne 0 ]]; then
        CLEANUP=0
        if [[ ${EXIT_ON_ERROR} -eq 1 ]]; then
            cat ${LOGFILE}-build.log
            exit 1
        fi
    fi
    return ${retcode}
}

usage() {
    common_usage
    tc_usage
    cunit_usage
    openssl_usage
    coverity_usage
    echo -e "\tARCH:\t\t which arch to build (arm, armeb, arm64, arm64be), default: not set"
    echo -e "\tLCOV:\t\t to genrate lcov set LCOV=1, default: ${LCOV}"
    echo -e "\tUNTESTED:\t\t to generate an untested api list UNTESTED=1, default: 0"
    echo -e "\tTEST_LIST:\t Overides the test list for 'make check' TEST_LIST=\"<your list>\""
    echo -e "\tNUM_CPUS:\t add parallel make, default: _NPROCESSORS_ONLN"
    echo -e "\tCLEANUP:\t to save workspace set CLEANUP=0, default: ${CLEANUP}"
    echo -e "\tBUILD_DEPS:\t build dependencies, 0: no, 1: yes, 2: yes and exit afterwards, default: ${BUILD_DEPS}"
    echo -e "\tRELOCATE_TEST:\t build ODP in relocated directory, default: ${RELOCATE_TEST}"
    echo -e "\tM32_ON_64:\t enable 32 bit builds on a 64 bit host, default: 0"
    echo -e "\tUSER_HTML:\t build user html, default: 0"
    echo -e "\tSCAN_BUILD:\t build with scan-build, default: 0"
    echo -e "\tCLANG:\t\t build and run with clang, default: 0"
    echo -e "\tSPARSE:\t\t build with sparse, default: 0"
    echo -e "\tEXIT_ON_ERROR:\t bail out on error, default: 1"
    echo -e "\tE_VALGRIND:\t run Valgrind, default: 0"
    echo -e "\tDOXYGEN_HTML:\t build doxygen-html, default: 0"
    echo -e "\tRUN_VALID_FROM_INSTALL: run the validation test suite from the "
    echo -e "\tMAKE_CHECK_TEST:\t make install, default: 1"
    echo -e "\t\t\t\t installed directory, default: 0"
    ${PLATFORM_SHORT}_usage
}

trap cleanup_exit INT TERM EXIT

cleanup_exit()
{
    if [[ ${success} -eq 1 && ${CLEANUP} -eq 1 ]]; then
        rm -rf ${GENERIC_BUILDDIR}
        rm -rf $ROOT_DIR/new-build
        rm -rf $ROOT_DIR/gcc-linaro-arm*
        rm -f ${LOGFILE}
        if [ "$LCOV" == "1" ]; then
            rm -rf ${ROOT_DIR}/${PLATFORM}-coverage.info
        fi
        cunit_cleanup
        tc_cleanup
        openssl_cleanup
        coverity_cleanup
        ${PLATFORM_SHORT}_cleanup
    fi
}

######
# Main execution

display_os

prepare_platform

if [[ "x$1" = "x-h" || "x$1" = "x--help" ]]; then
    usage
    exit 0
fi

while getopts "hcq" opt; do
    case $opt in
        c)
            export EXIT_ON_ERROR=0
            ;;
        q)
            export QUIET=1
            ;;
        h)
            usage
            exit 0
            ;;
    esac
done

if [[ ${M32_ON_64} -eq 1 ]]; then
    M32_CC="CFLAGS=-m32"
    M32_LD="LDFLAGS=-m32"
    export BASE_ARCH="$(uname -m)-i386"
    OPENSSL_BUILD=1
    CUNIT_BUILD=1
fi

if [[ ${E_VALGRIND} -eq 1 ]]; then
    CONFIGURE_FLAGS="${CONFIGURE_FLAGS} --enable-valgrind"
fi

if [[ ${USER_HTML} -eq 1 ]]; then
    CONFIGURE_FLAGS="${CONFIGURE_FLAGS} --enable-user-guides"
fi

if [[ ${BUILD_DEPS} -ge 1 ]]; then
    build_deps
    if [[ ${BUILD_DEPS} -eq 2 ]]; then
        exit 0
    fi
fi

if [[ ${LCOV} -eq 1 ]]; then
    #coverage matters only for the validation tests
    CONFIGURE_FLAGS="${CONFIGURE_FLAGS} --disable-test-perf"
fi

if [ ! -d "$GENERIC_BUILDDIR" ]; then
    echo "Pulling from ${GIT_URL}, branch ${GIT_BRANCH}"
    remote_name="$(remote_name ${GIT_URL})"
    generic_fetch "${GIT_URL}" "${GENERIC_SRCDIR}" "${remote_name}"
    generic_new_workdir "${GENERIC_SRCDIR}" "${remote_name}/${GIT_BRANCH}" "${GENERIC_BUILDDIR}"
fi

# Run cross compile coverty
coverity_prepare

if [[ ${CPP_TEST} -eq 1 ]]; then
    which ${CROSS_COMPILE}g++
    if [[ $? -eq 0 ]]; then
        CONFIGURE_FLAGS="${CONFIGURE_FLAGS} --enable-test-cpp"
    fi
fi

if [[ ${CLANG} -eq 1 ]]; then
    export CC=clang
fi

pushd ${GENERIC_BUILDDIR} > /dev/null
exit_on_error git clean -xdf || exit 1
exit_on_error ./bootstrap
echo ./configure ${GPLATFORM} ${DSTDIR} ${CROSS_HOST} ${CONFIGURE_FLAGS} ${M32_CC} ${M32_LD}
exit_on_error ./configure ${GPLATFORM} ${DSTDIR} ${CROSS_HOST} ${CONFIGURE_FLAGS} ${M32_CC} ${M32_LD}

git log -1 --oneline > ${ROOT_DIR}/${PLATFORM}-git-describe

if [[ -n ${COV_DIR} ]]; then
    coverity_build
elif [[ ${UNTESTED} -eq 1 ]]; then

    if [[ -z ${ARCH} ]]; then
        #dont optimise it will make coverage hard to track
        make -j ${NUM_CPUS} CFLAGS="-fprofile-arcs -ftest-coverage -O0 --no-inline -g "
        run_with_sudo make -e check
    fi

    FILES=${GENERIC_BUILDDIR}/platform/${PLATFORM}/*.gcda
    for f in $FILES
        do
          gcov -f -r -i $f > /dev/null
        done
    set +e
    NO_TEST_COVERAGE=$(grep function:[0-9]*,0 *.gcda.gcov | awk -F',' '{print $NF}')
    echo -e "\nUntested Public API"
    grep "\<odp_" <<< "${NO_TEST_COVERAGE}" | sort
    echo -e "\nUntested Internal"
    grep -v "\<odp_" <<< "${NO_TEST_COVERAGE}" | sort

    #now look in the validation dir for untested APIs, maybe optimisation removed them ?
    echo -e "\nFound in validation but flagged not tested"
    for f in $NO_TEST_COVERAGE
    do
        pushd ${GENERIC_BUILDDIR}/test/validation > /dev/null
        git grep --line-number "\<$f\>"
        popd > /dev/null
    done
    set -e
elif [[ ${LCOV} -eq 1 ]]; then
    if [[ ${M32_ON_64} -eq 1 ]]; then
        make
        file test/performance/odp_scheduling
    else
        if [[ -z ${ARCH} ]]; then
            #dont optimise it will make coverage hard to track
            make -j ${NUM_CPUS} CFLAGS="-fprofile-arcs -ftest-coverage -O0 --no-inline -g "
            run_with_sudo make -e check
        fi
    fi
    #coverage of the libary
    lcov --no-external -c -d ${GENERIC_BUILDDIR}/platform/${PLATFORM} --output-file ${ROOT_DIR}/${PLATFORM}-coverage.info
    genhtml ${ROOT_DIR}/${PLATFORM}-coverage.info --output-directory ${GENERIC_PUBLISHING}/${PLATFORM}-lcov-html
    #coverage for the helpers
    lcov -c -d ${GENERIC_BUILDDIR}/helper --output-file ${ROOT_DIR}/${PLATFORM}-helper-coverage.info
    genhtml ${ROOT_DIR}/${PLATFORM}-helper-coverage.info --output-directory ${GENERIC_PUBLISHING}/${PLATFORM}-helper-lcov-html
    #coverage for the tests themsleves
    lcov -c -d ${GENERIC_BUILDDIR}/test/validation --output-file ${ROOT_DIR}/${PLATFORM}-validation-coverage.info
    genhtml ${ROOT_DIR}/${PLATFORM}-validation-coverage.info --output-directory ${GENERIC_PUBLISHING}/${PLATFORM}-validation-lcov-html
elif [[ ${DOXYGEN_HTML} -eq 1 ]]; then
    make doxygen-doc
    mv ${GENERIC_BUILDDIR}/doc/application-api-guide/output/html ${GENERIC_PUBLISHING}/${PLATFORM}-doxygen-html
elif [[ ${USER_HTML} -eq 1 ]]; then
    make -C doc
    mkdir -p ${GENERIC_PUBLISHING}/${PLATFORM}/images
    mkdir -p ${GENERIC_PUBLISHING}/${PLATFORM}/output
    cp ${GENERIC_BUILDDIR}/doc/images/*.svg  ${GENERIC_PUBLISHING}/${PLATFORM}/images
    cp ${GENERIC_BUILDDIR}/doc/implementers-guide/*.html ${GENERIC_PUBLISHING}/${PLATFORM}/output
    cp ${GENERIC_BUILDDIR}/doc/process-guide/*.html ${GENERIC_PUBLISHING}/${PLATFORM}/output
    cp ${GENERIC_BUILDDIR}/doc/users-guide/*.html ${GENERIC_PUBLISHING}/${PLATFORM}/output

elif [[ ${SCAN_BUILD} -eq 1 ]]; then
    scan-build -o ${GENERIC_BUILDDIR}/scan-build-tmp make 2>&1 | tee make-clang.log
    mv ${GENERIC_BUILDDIR}/scan-build-tmp/20* ${GENERIC_PUBLISHING}/${PLATFORM}-scan-build

    make clean
    make CC=clang
elif [[ ${SPARSE} -eq 1 ]]; then
    make clean
    make CC=cgcc -Wattributes -Wno-error -Wdefault-bitfield-sign -Wparen-string -Wshadow -Wbitwise -Wcast-to-as -Wdo-while -Wnon-pointer-null -Wptr-subtraction-blows
elif [[ ${DISTCHECK} -eq 1 ]]; then
    make distcheck
elif [[ ${E_VALGRIND} -eq 1 ]]; then
    exit_on_error make -j ${NUM_CPUS}
    if [[ -z ${ARCH} ]]; then
        pushd test/validation > /dev/null
        make check-valgrind
        popd > /dev/null
    else
        echo "Can't run valgrind on build for ${ARCH} on this machine!"
    fi
else
    exit_on_error make -j ${NUM_CPUS}
    exit_on_error make install
    if [[ ${RELOCATE_TEST} -eq 1 ]]; then
        exit_on_error git clean -xdf || exit 1
        exit_on_error ./bootstrap
        mkdir ${GENERIC_BUILDDIR}/testdir
        pushd ${GENERIC_BUILDDIR}/testdir > /dev/null
        exit_on_error ../configure ${GPLATFORM} ${DSTDIR} ${CROSS_HOST} ${CONFIGURE_FLAGS} ${M32_CC} ${M32_LD}
        exit_on_error make -j ${NUM_CPUS}
        #this can only work if you have not cross compiled
        if [[ ${INSTALLCHECK} -eq 1 ]]; then
                exit_on_error make installcheck
        else
                exit_on_error make install
        fi

    fi
    if [[ ${M32_ON_64} -eq 1 ]]; then
        file test/performance/odp_scheduling
    else
        if [[ -z ${ARCH} ]]; then
            if [[ ${MAKE_CHECK_TEST}  -eq 1 ]]; then
                if [[ ${RUN_VALID_FROM_INSTALL} -eq 0 ]]; then
                    exit_on_error run_with_sudo make check -e
                else
                    export V=0
                    exit_on_error run_with_sudo ${GLOBAL_DSTDIRPATH}/lib/odp/tests/run-test
                fi
            fi
        fi
    fi
    if [[ ${RELOCATE_TEST} -eq 1 ]]; then
        popd > /dev/null
    fi
fi

popd > /dev/null
export success=1
## vim: set sw=4 sts=4 et foldmethod=syntax : ##