configure

#!/bin/bash

set -e

function usage() {
    echo "usage: configure [ <option> ... ]"
    echo "Configure Circle with newlib standard C library and mbed TLS library."
    echo
    echo "Options:"
    echo "  -d, --debug                    build with debug information, without optimizer"
    echo "  -h, --help                     show usage message"
    echo "  -n, --no-cpp                   do not support C++ standard library"
    echo "  -o, --option <name>[=<value>]  additional preprocessor define (optionally with value)"
    echo "                                 can be repeated"
    echo "  --opt-tls                      build with mbed TLS support"
    echo "  -p <string>, --prefix <string> prefix of the toolchain commands (default: arm-none-eabi-)"
    echo "  --qemu                         build for running under QEMU in semihosting mode"
    echo "  -r <number>, --raspberrypi <number>"
    echo "                                 Circle Raspberry Pi model number (1, 2, 3, 4, 5, default: 1)"
    echo "  --softfp                       use float ABI setting \"softfp\" instead of \"hard\""
    echo "  -s <path>, --stddefpath <path>"
    echo "                                 path where stddef.h header is located (only necessary"
    echo "                                 if script cannot determine it automatically)"
}

# From the bash FAQ: How to use pathnames relative to the script
cd "${BASH_SOURCE%/*}" || exit 1
TOPDIR="$PWD"

TEMP=$(getopt -o dhno:p:r:s: --long debug,help,no-circle-build,no-cpp,option:,opt-tls,qemu,prefix:,raspberrypi:,script-debug,softfp,stddefpath: \
     -n 'build.bash' -- "$@")

if [ $? != 0 ] ; then echo usage; exit 1 ; fi

# Note the quotes around `$TEMP': they are essential!
eval set -- "$TEMP"

DEBUG=0
RASPBERRYPI=1
CIRCLE_BUILD=1
CIRCLE_QEMU=0
CIRCLE_CFLAGS=""
NEWLIB_BUILD=1
TOOLPREFIX=arm-none-eabi-
STDDEF_INCPATH=""
STDLIB_SUPPORT=3
OPTIONS=""
FLOAT_ABI=hard
OPTTLS=0
SIXTY_FOUR_BIT=0
NEWLIB_ARCH="arm-none-circle"
NEWLIB_INSTALL_DIR="$TOPDIR/install"
NEWLIB_BUILD_DIR="$TOPDIR/build/circle-newlib"
CIRCLEHOME="$TOPDIR/libs/circle"

while true ; do
    case "$1" in
	-d|--debug) DEBUG=1 ; shift;;
	-h|--help) usage ; exit 0;;
	-n|--no-cpp) STDLIB_SUPPORT=2 ; shift;;
	-o|--option) OPTIONS="$OPTIONS -D$2" ; shift 2;;
	--opt-tls) OPTTLS=1 ; shift;;
	--qemu) CIRCLE_QEMU=1 ; shift;;
	-p|--prefix) TOOLPREFIX="$2" ; shift 2;;
	-r|--raspberrypi) RASPBERRYPI="$2" ; shift 2;;
	--script-debug) set -x ; shift;;
	--softfp) FLOAT_ABI=softfp ; shift;;
	-s|--stddefpath) STDDEF_INCPATH="$2" ; shift 2;;
	--) shift ; break ;;
	*) echo "Internal error!" ; exit 1;;
    esac
done

echo "RASPBERRYPI=$RASPBERRYPI"
echo "TOOLPREFIX=$TOOLPREFIX"
echo "CIRCLE_BUILD=$CIRCLE_BUILD"
echo "CIRCLE_QEMU=$CIRCLE_QEMU"
echo "FLOAT_ABI=$FLOAT_ABI"
echo "NEWLIB_BUILD=$NEWLIB_BUILD"
echo "RASPBERRYPI=$RASPBERRYPI"
echo "STDLIB_SUPPORT=$STDLIB_SUPPORT"
echo "OPTIONS=$OPTIONS"
echo "NEWLIB_INSTALL_DIR=$NEWLIB_INSTALL_DIR"
echo "NEWLIB_BUILD_DIR=$NEWLIB_BUILD_DIR"
echo "DEBUG=$DEBUG"

echo "Remaining arguments:"
for arg do echo '--> '"\`$arg'" ; done

: ${CC:="$TOOLPREFIX"gcc}

if [ ! -x "`which $CC 2> /dev/null`" ]
then
    echo "Error: Invalid toolchain prefix, exiting" >&2
    echo "TOOLPREFIX is \"$TOOLPREFIX\"" >&2
    exit 1
fi

# Try to determine 64-bit build from Target: output of gcc
if [ "$($CC -v 2>&1 | grep '^Target:.*64')" != "" ]
then
    echo "64-bit compiler detected"
    SIXTY_FOUR_BIT=1
    NEWLIB_ARCH="aarch64-none-circle"
fi

if [ "$STDDEF_INCPATH" = "" ]
then
    # TODO this is probably very GCC-specific
    STDDEF_INCPATH=$(echo | "$CC" -v -x c -E - 2>&1 | grep "^ /.*include$" | head -1 | sed -e "s/ //")
fi

if [ ! -f "$STDDEF_INCPATH/stddef.h" ]
then
    echo "Error: Unable to determine include path for stddef.h, exiting" >&2
    echo "STDDEF_INCPATH is \"$STDDEF_INCPATH\"" >&2
    exit 1
fi

echo "STDDEF_INCPATH=$STDDEF_INCPATH"

case "$RASPBERRYPI" in
    1|2|3|4|5) ;;
    *) echo "Unknown Raspberry Pi target" >&2; exit 1;;
esac

# Sanity checks that sub-modules are checked out
if [ ! -f "libs/circle/Rules.mk" ]
then
    echo "Circle sub-module not found" >&2
    exit 1
fi

if [ ! -f "libs/circle-newlib/README.md" ]
then
    echo "newlib sub-module not found" >&2
    exit 1
fi

if [ $OPTTLS -eq 1 ]
then
    if [ ! -f "libs/mbedtls/README.md" ]
    then
        echo "mbedtls sub-module not found" >&2
        exit 1
    fi
fi

# Special compiler flags for running under QEMU
if [ $CIRCLE_QEMU -eq 1 ]
then
    CIRCLE_CFLAGS="$CIRCLE_CFLAGS -DLEAVE_QEMU_ON_HALT -DNO_SDHOST"

    if [ $SIXTY_FOUR_BIT -eq 0 ]
    then
        CIRCLE_CFLAGS="$CIRCLE_CFLAGS -DNO_PHYSICAL_COUNTER -DUSE_QEMU_USB_FIX"
    fi
fi

# Create Circle's Config.mk file
(
    echo "RASPPI = $RASPBERRYPI"
    echo "PREFIX = $TOOLPREFIX"
    echo "FLOAT_ABI = $FLOAT_ABI"
    echo "STDLIB_SUPPORT = $STDLIB_SUPPORT"
    echo "STDDEF_INCPATH = \"$STDDEF_INCPATH\""
    echo "CFLAGS = -Wno-parentheses $CIRCLE_CFLAGS"
    if [ "$OPTIONS" != "" ]
    then
        echo "DEFINE += $OPTIONS"
    fi
    if [ $DEBUG -eq 1 ]
    then
        echo "OPTIMIZE = -O0 -g"
    fi
    if [ $SIXTY_FOUR_BIT -eq 1 ]
    then
        echo "AARCH = 64"
        echo "PREFIX64 = $TOOLPREFIX"
    fi
) > libs/circle/Config.mk

# Retrieve the resulting compiler flags from Circle's top-level Makefile rules
ARCHCPU=$(make -n -p -f libs/circle/Rules.mk CIRCLEHOME=libs/circle | grep '^ARCHCPU =' | \
            sed -e "s/\$(FLOAT_ABI)/$FLOAT_ABI/" -e 's/ARCHCPU = //')
ARCH=$(make -n -p -f libs/circle/Rules.mk CIRCLEHOME=libs/circle | grep '^ARCH ='| \
    sed -e "s/\$(ARCHCPU)/$ARCHCPU/" -e 's/ARCH = //')

export \
    CPPFLAGS_FOR_TARGET="-I\"$CIRCLEHOME/include\" -I\"$CIRCLEHOME/addon\" -I\"$TOPDIR/include\"" \
    CC_FOR_TARGET=${TOOLPREFIX}gcc \
    CXX_FOR_TARGET=${TOOLPREFIX}g++ \
    GCC_FOR_TARGET=${TOOLPREFIX}gcc \
    AR_FOR_TARGET=${TOOLPREFIX}gcc-ar \
    AS_FOR_TARGET=${TOOLPREFIX}gcc-as \
    LD_FOR_TARGET=${TOOLPREFIX}gcc-ld \
    RANLIB_FOR_TARGET=${TOOLPREFIX}gcc-ranlib \
    OBJCOPY_FOR_TARGET=${TOOLPREFIX}gcc-objcopy \
    OBJDUMP_FOR_TARGET=${TOOLPREFIX}gcc-objdump

if [ $DEBUG -eq 1 ]
then
    CFLAGS_FOR_TARGET="$ARCH -DRASPPI=$RASPBERRYPI $OPTIONS -O0 -g -Wno-parentheses"
else
    CFLAGS_FOR_TARGET="$ARCH -DRASPPI=$RASPBERRYPI $OPTIONS -Wno-parentheses"
fi
export CFLAGS_FOR_TARGET

(
    cd $NEWLIB_BUILD_DIR
    "$TOPDIR/libs/circle-newlib/configure" --target "${NEWLIB_ARCH}" --disable-multilib \
        --prefix "$NEWLIB_INSTALL_DIR" --enable-newlib-long-time_t
)

# create circle-stdlib's configuration file
(
    echo "CC = ${CC}"
    echo "ARCH = ${ARCH}"
    echo "TOOLPREFIX = ${TOOLPREFIX}"
    echo "NEWLIB_BUILD_DIR = ${NEWLIB_BUILD_DIR}"
    echo "NEWLIB_INSTALL_DIR = ${NEWLIB_INSTALL_DIR}"
    echo "CFLAGS_FOR_TARGET = ${CFLAGS_FOR_TARGET}"
    echo "CPPFLAGS_FOR_TARGET = ${CPPFLAGS_FOR_TARGET}"
    echo "CC_FOR_TARGET = ${CC_FOR_TARGET}"
    echo "CXX_FOR_TARGET = ${CXX_FOR_TARGET}"
    echo "GCC_FOR_TARGET = ${GCC_FOR_TARGET}"
    echo "AR_FOR_TARGET = ${AR_FOR_TARGET}"
    echo "AS_FOR_TARGET = ${AS_FOR_TARGET}"
    echo "LD_FOR_TARGET = ${LD_FOR_TARGET}"
    echo "RANLIB_FOR_TARGET = ${RANLIB_FOR_TARGET}"
    echo "OBJCOPY_FOR_TARGET = ${OBJCOPY_FOR_TARGET}"
    echo "OBJDUMP_FOR_TARGET = ${OBJDUMP_FOR_TARGET}"
    echo "NEWLIB_ARCH = ${NEWLIB_ARCH}"

    if [ $OPTTLS -eq 1 ]
    then
        echo "MBEDTLS = mbedtls"
        echo "MBEDTLS_SAMPLES = build-mbedtls-samples"
    fi
) >Config.mk