#!/bin/bash

set -e

function usage() {
    echo "usage: configure [ <option> ... ]"
    echo "Configure Circle with newlib standard C library"
    echo "Optional: libc++ 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 "  -k, --kasan                    build with Kernel Address Sanitizer support"
    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 "  --kernel-max-size <megabytes>"
    echo "                                 Set maximum size of the kernel image (default: 4)"
    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 configure cannot determine it automatically)"
    echo "  --libcxx                       build with LLVM libc++ (fetched automatically)"
    echo "  --libcxx-repo                  build with LLVM libc++ using a manually checked-out"
    echo "                                 llvm-project repository at libs/llvm-project"
    echo "  --clang                        build with LLVM clang/clang++ instead of GCC"
    echo "                                 (requires --libcxx or --libcxx-repo)"
    echo "  --aarch64                      target AArch64 (required with --clang for 64-bit builds)"
}

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

TEMP=$(getopt -o dhkno:p:r:s: --long debug,help,kasan,no-circle-build,no-cpp,option:,opt-tls,qemu,prefix:,raspberrypi:,script-debug,softfp,stddefpath:,libcxx,libcxx-repo,kernel-max-size:,clang,aarch64 \
     -n 'configure' -- "$@")

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=""
CIRCLE_DEFINES=""
KASAN_ENABLED=0
TOOLPREFIX=arm-none-eabi-
STDDEF_INCPATH=""
CXX_INCPATHS=()
STDLIB_SUPPORT=3
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"
LIBCXX_ENABLED=0
LIBCXX_BUILDMODE=Release
LIBCXX_REPO=0
KERNEL_MAX_SIZE_MB=4
CLANG=0

while true ; do
    case "$1" in
	-d|--debug) DEBUG=1 ; LIBCXX_BUILDMODE=Debug ; shift;;
	-h|--help) usage ; exit 0;;
	-k|--kasan) KASAN_ENABLED=1 ; shift;;
	-n|--no-cpp) STDLIB_SUPPORT=2 ; shift;;
	-o|--option) CIRCLE_DEFINES="$CIRCLE_DEFINES -D$2" ; shift 2;;
	--opt-tls) OPTTLS=1 ; shift;;
	--qemu) CIRCLE_QEMU=1 ; shift;;
	--kernel-max-size) KERNEL_MAX_SIZE_MB="$2"; shift 2;;
	-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;;
	--libcxx) LIBCXX_ENABLED=1 ; STDLIB_SUPPORT=4 ; shift;;
	--libcxx-repo) LIBCXX_ENABLED=1 ; STDLIB_SUPPORT=4 ; LIBCXX_REPO=1 ; shift;;
	--clang) CLANG=1 ; shift;;
	--aarch64) SIXTY_FOUR_BIT=1 ; NEWLIB_ARCH="aarch64-none-circle" ; shift;;
	--) 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 "RASPBERRYPI=$RASPBERRYPI"
echo "STDLIB_SUPPORT=$STDLIB_SUPPORT"
echo "CIRCLE_DEFINES=$CIRCLE_DEFINES"
echo "NEWLIB_INSTALL_DIR=$NEWLIB_INSTALL_DIR"
echo "NEWLIB_BUILD_DIR=$NEWLIB_BUILD_DIR"
echo "DEBUG=$DEBUG"
echo "KASAN_ENABLED=$KASAN_ENABLED"
echo "LIBCXX_ENABLED=$LIBCXX_ENABLED"
echo "LIBCXX_REPO=$LIBCXX_REPO"

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

if [ $CLANG -eq 1 ]
then
    : ${CC:="clang"}
    : ${CXX:="clang++"}
else
    : ${CC:="${TOOLPREFIX}gcc"}
    : ${CXX:="${TOOLPREFIX}g++"}
fi

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.
# For clang, the target is determined by --aarch64 / --clang because clang -v
# without an explicit --target shows the host triple, not the cross target.
if [ $CLANG -eq 0 ]
then
    if [ "$($CC -v 2>&1 | grep '^Target:.*64')" != "" ]
    then
        echo "64-bit compiler detected"
        SIXTY_FOUR_BIT=1
        NEWLIB_ARCH="aarch64-none-circle"
    fi
fi

if [ $CLANG -eq 1 ] && [ "$RASPBERRYPI" -eq 5 ] && [ $SIXTY_FOUR_BIT -eq 0 ]
then
    echo "Error: Raspberry Pi 5 requires a 64-bit build. Add --aarch64 when using --clang." >&2
    exit 1
fi

if [ $CLANG -eq 1 ] && [ $LIBCXX_ENABLED -eq 0 ]
then
    echo "Error: --clang requires --libcxx or --libcxx-repo for C++ standard library headers." >&2
    exit 1
fi

if [ "$STDDEF_INCPATH" = "" ]
then
    STDDEF_INCPATH=$("$CC" -print-file-name=include)
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"

if [ ${#CXX_INCPATHS[@]} -eq 0 ]
then
    mapfile -t CXX_INCPATHS < <(echo | "$CXX" -v -E -x c++ - 2>&1 | grep "^ /.*include/c++" | sed -e "s/^ //")
fi

if [ ${#CXX_INCPATHS[@]} -eq 0 ] && [ $CLANG -eq 0 ]
then
    echo "Error: Unable to determine include paths for C++, exiting" >&2
    exit 1
fi

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

if [ $LIBCXX_REPO -eq 1 ]
then
    if [ ! -f "libs/llvm-project/runtimes/CMakeLists.txt" ]
    then
        echo "llvm-project not found at libs/llvm-project" >&2
        echo "Please check out the llvm-project repository there first." >&2
        exit 1
    fi
fi

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

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


KERNEL_MAX_SIZE=$(printf "0x%X" $(( KERNEL_MAX_SIZE_MB * 0x100000 )))

if [ "${KERNEL_MAX_SIZE_MB}" -lt 8 ] && [ "${LIBCXX_REPO}${LIBCXX_ENABLED}${KASAN_ENABLED}" != "000" ]
then
    echo "Warning: KERNEL_MAX_SIZE is ${KERNEL_MAX_SIZE_MB} MB, but LIBCXX or KASan support is enabled." >&2
    echo "         Consider using --kernel-max-size 8 or larger." >&2
fi

KASAN_SHADOW_MAPPING_OFFSET=$(printf "0x%X" $(( KERNEL_MAX_SIZE + 0x700000 )))
CIRCLE_DEFINES="$CIRCLE_DEFINES -DKERNEL_MAX_SIZE=${KERNEL_MAX_SIZE}"

# Create Circle's Config.mk file
(
    echo "RASPPI = $RASPBERRYPI"
    echo "PREFIX = $TOOLPREFIX"
    echo "FLOAT_ABI = $FLOAT_ABI"
    echo "KASAN_ENABLED = $KASAN_ENABLED"
    echo "STDLIB_SUPPORT = $STDLIB_SUPPORT"
    if [ "$CIRCLE_DEFINES" != "" ]
    then
        echo "DEFINE += $CIRCLE_DEFINES"
    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

    if [ $KASAN_ENABLED -eq 1 ]
    then
        # See Circle's doc/kasan.txt for details.
        echo "KASAN_SHADOW_MAPPING_OFFSET = $KASAN_SHADOW_MAPPING_OFFSET"
    fi
    if [ $CLANG -eq 1 ]
    then
        echo "CLANG = 1"
        echo "WARNINGS += -Wno-gnu-designator -Wno-main -Wno-extern-c-compat"
    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 = //')

if [ $KASAN_ENABLED -eq 1 ]
then
    KASAN_SHADOW_MAPPING_OFFSET=$(make -n -p -f libs/circle/Rules.mk CIRCLEHOME=libs/circle | \
        grep '^KASAN_SHADOW_MAPPING_OFFSET =' | sed -e 's/KASAN_SHADOW_MAPPING_OFFSET = //')
    KASAN_SANITIZE_STACK=$(make -n -p -f libs/circle/Rules.mk CIRCLEHOME=libs/circle | \
        grep '^KASAN_SANITIZE_STACK =' | sed -e 's/KASAN_SANITIZE_STACK = //')
    KASAN_SANITIZE_GLOBALS=$(make -n -p -f libs/circle/Rules.mk CIRCLEHOME=libs/circle | \
        grep '^KASAN_SANITIZE_GLOBALS =' | sed -e 's/KASAN_SANITIZE_GLOBALS = //')
fi

KASAN_CFLAGS=""
if [ $KASAN_ENABLED -eq 1 ]
then
    # PREFER_SIZE_OVER_SPEED prevents newlib from performing optimized memory
    # access (e.g. whole-integer access) that would be flagged out-of-bounds
    # by the address sanitizer.
    KASAN_BASE="-fsanitize=kernel-address -fno-builtin -fno-omit-frame-pointer -DPREFER_SIZE_OVER_SPEED"
    if [ $CLANG -eq 1 ]
    then
        KASAN_CFLAGS="${KASAN_BASE} \
            -mllvm -asan-mapping-offset=$KASAN_SHADOW_MAPPING_OFFSET \
            -mllvm -asan-instrumentation-with-call-threshold=0 \
            -mllvm -asan-stack=$KASAN_SANITIZE_STACK \
            -mllvm -asan-globals=$KASAN_SANITIZE_GLOBALS"
    else
        KASAN_CFLAGS="${KASAN_BASE} \
            -fasan-shadow-offset=$KASAN_SHADOW_MAPPING_OFFSET \
            --param asan-globals=$KASAN_SANITIZE_GLOBALS \
            --param asan-stack=$KASAN_SANITIZE_STACK \
            --param asan-instrumentation-with-call-threshold=0"
    fi
fi


if [ $CLANG -eq 1 ]
then
    if [ $SIXTY_FOUR_BIT -eq 1 ]
    then
        CLANG_TARGET="--target=aarch64-none-elf"
    else
        CLANG_TARGET="--target=arm-none-eabi"
    fi
    # Derive the compiler-rt builtins filename for this target.
    # With COMPILER_RT_INSTALL_LIBRARY_DIR=lib, cmake installs to
    # $(LIBCXX_INSTALL_DIR)/lib/libclang_rt.builtins-<arch>.a (flat, arch-suffixed).
    if [ $SIXTY_FOUR_BIT -eq 1 ]
    then
        COMPILER_RT_BUILTINS_FILE="libclang_rt.builtins-aarch64.a"
    else
        COMPILER_RT_BUILTINS_FILE="libclang_rt.builtins-arm.a"
    fi
    export \
        CPPFLAGS_FOR_TARGET="-isystem \"$CIRCLEHOME/include\" -isystem \"$CIRCLEHOME/addon\" -isystem \"$TOPDIR/include\"" \
        CC_FOR_TARGET="clang ${CLANG_TARGET}" \
        CXX_FOR_TARGET="clang++ ${CLANG_TARGET}" \
        GCC_FOR_TARGET="clang ${CLANG_TARGET}" \
        AR_FOR_TARGET="llvm-ar" \
        AS_FOR_TARGET="clang ${CLANG_TARGET}" \
        LD_FOR_TARGET="clang ${CLANG_TARGET}" \
        RANLIB_FOR_TARGET="llvm-ranlib" \
        OBJCOPY_FOR_TARGET="llvm-objcopy" \
        OBJDUMP_FOR_TARGET="llvm-objdump"
else
    export \
        CPPFLAGS_FOR_TARGET="-isystem \"$CIRCLEHOME/include\" -isystem \"$CIRCLEHOME/addon\" -isystem \"$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
fi

if [ $DEBUG -eq 1 ]
then
    CFLAGS_FOR_TARGET="$ARCH -D__circle__ -DRASPPI=$RASPBERRYPI $CIRCLE_DEFINES -O0 -g -Wno-parentheses $KASAN_CFLAGS"
else
    CFLAGS_FOR_TARGET="$ARCH -D__circle__ -DRASPPI=$RASPBERRYPI $CIRCLE_DEFINES -g -Wno-parentheses $KASAN_CFLAGS"
fi
if [ $CLANG -eq 1 ]
then
    # Suppress warnings when building newlib with LLVM
    CFLAGS_FOR_TARGET="$CFLAGS_FOR_TARGET -Wno-unused-command-line-argument -Wno-deprecated-non-prototype -Wno-duplicate-decl-specifier -Wno-unknown-pragmas"
    CFLAGS_FOR_TARGET="$CFLAGS_FOR_TARGET -Wno-shift-negative-value -Wno-empty-body"
    export CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET="$CFLAGS_FOR_TARGET -nostdinc++"
else
    export CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET="$CFLAGS_FOR_TARGET"
fi

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

# Rebuild the original order of include paths. This is important
# because otherwise #include_next in the C++ standard library headers
# will not find the correct headers.
if [ ${LIBCXX_ENABLED} -eq 1 ]
then
    SYSTEM_INCPATHS=('$(LIBCXX_INSTALL_DIR)/include'
        '$(LIBCXX_INSTALL_DIR)/include/c++/v1'
        '$(LIBCXX_THREADING_INSTALL_DIR)/include'
        '$(CIRCLE_STDLIB_INSTALL_DIR)/include' "${STDDEF_INCPATH}")
else
    SYSTEM_INCPATHS=("${CXX_INCPATHS[@]}" '$(CIRCLE_STDLIB_INSTALL_DIR)/include' "${STDDEF_INCPATH}")
fi

CFLAGS_ISYSTEM=""
for INCPATH in "${SYSTEM_INCPATHS[@]}"; do
    CFLAGS_ISYSTEM="$CFLAGS_ISYSTEM -isystem \"$INCPATH\""
done

echo "CFLAGS_ISYSTEM='$CFLAGS_ISYSTEM'"

# create circle-stdlib's configuration file
(
    echo "CC = ${CC}"
    echo "CXX = ${CXX}"
    echo "ARCH = ${ARCH}"
    echo "ARCHCPU = ${ARCHCPU}"
    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 "CXXFLAGS_FOR_TARGET = ${CXXFLAGS_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}"
    echo "CLANG = ${CLANG}"
    if [ $CLANG -eq 1 ]
    then
        echo "CPP = clang++"
        echo "AR = llvm-ar"
        echo "OBJCOPY = llvm-objcopy"
        echo "OBJDUMP = llvm-objdump"
        echo "CPPFILT = llvm-cxxfilt"
    fi
    echo "CFLAGS += -nostdinc ${CFLAGS_ISYSTEM}"
    echo "DEFINE += -D_GNU_SOURCE -D_POSIX_C_SOURCE=200809L"
    echo 'CIRCLE_STDLIB_CIRCLE_LIBS = \'
    echo '    $(CIRCLEHOME)/addon/SDCard/libsdcard.a \'
    echo '    $(CIRCLEHOME)/lib/usb/libusb.a \'
    echo '    $(CIRCLEHOME)/lib/input/libinput.a \'
    echo '    $(CIRCLEHOME)/addon/fatfs/libfatfs.a \'
    echo '    $(CIRCLEHOME)/lib/fs/libfs.a \'
    echo '    $(CIRCLEHOME)/lib/net/libnet.a \'
    echo '    $(CIRCLEHOME)/lib/sched/libsched.a \'
    echo '    $(CIRCLEHOME)/addon/qemu/libqemusupport.a \'
    echo '    $(CIRCLEHOME)/lib/libcircle.a'
    echo 'CIRCLE_STDLIB_INSTALL_DIR = $(NEWLIB_INSTALL_DIR)/$(NEWLIB_ARCH)'
    if [ ${LIBCXX_ENABLED} -eq 1 ]
    then
        echo 'LIBCXX_INSTALL_DIR = $(CIRCLE_STDLIB_INSTALL_DIR)-libc++'
        echo 'LIBCXX_THREADING_INSTALL_DIR = $(CIRCLE_STDLIB_INSTALL_DIR)-libc++-threading'
        echo "LIBCXX_BUILDMODE = ${LIBCXX_BUILDMODE}"
        if [ $LIBCXX_REPO -eq 1 ]
        then
            echo "LIBCXX_REPO = 1"
        fi
        if [ $CLANG -eq 1 ]
        then
            echo "LDFLAGS += -fuse-ld=lld"
            echo "LDFLAGS += -Wl,--eh-frame-hdr"
            echo "LDFLAGS += -Wl,--no-dependent-libraries"
        else
            echo "LDFLAGS += --eh-frame-hdr"
        fi
        echo "DEFINE += -D_GNU_SOURCE -D_POSIX_C_SOURCE=200809L"
        echo 'CIRCLE_STDLIB_LIBS = \'
        echo '    $(LIBCXX_INSTALL_DIR)/lib/liblibcxx-support.a \'
        echo '    $(LIBCXX_INSTALL_DIR)/lib/libc++.a \'
        echo '    $(LIBCXX_INSTALL_DIR)/lib/libc++abi.a \'
        echo '    $(LIBCXX_INSTALL_DIR)/lib/libunwind.a \'
        echo '    $(LIBCXX_THREADING_INSTALL_DIR)/lib/liblibcxx-threading.a \'
        echo '    $(CIRCLE_STDLIB_INSTALL_DIR)/lib/libm.a \'
        echo '    $(CIRCLE_STDLIB_INSTALL_DIR)/lib/libc.a \'
        echo '    $(CIRCLE_STDLIB_INSTALL_DIR)/lib/libcirclenewlib.a \'
        if [ $CLANG -eq 1 ]
        then
            echo "    \$(LIBCXX_INSTALL_DIR)/lib/${COMPILER_RT_BUILTINS_FILE} \\"
        fi
        echo '    $(CIRCLE_STDLIB_CIRCLE_LIBS)'
    else
        echo 'CIRCLE_STDLIB_LIBS = \'
        echo '    $(CIRCLE_STDLIB_INSTALL_DIR)/lib/libm.a \'
        echo '    $(CIRCLE_STDLIB_INSTALL_DIR)/lib/libc.a \'
        echo '    $(CIRCLE_STDLIB_INSTALL_DIR)/lib/libcirclenewlib.a \'
        echo '    $(CIRCLE_STDLIB_CIRCLE_LIBS)'
    fi
    echo "STDDEF_INCPATH = \"$STDDEF_INCPATH\""
    echo "CIRCLEHOME = ${CIRCLEHOME}"
    echo "CIRCLE_STDLIB_INCLUDES = -I${TOPDIR}/include"


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