build.sh

#!/bin/bash -e
###############################################################################
#
# Development installation script for Patmos compiler+tools
#
# The builds performed by this script are out-of-source builds.
#
# Benedikt Huber <benedikt@vmars.tuwien.ac.at>
# Daniel Prokesch <daniel@vmars.tuwien.ac.at>
# Stefan Hepp <hepp@complang.tuwien.ac.at>
#
# Usage of paths and functions in this script:
#
# - build_* functions are top-level build scripts. Must handle cleaning, 
#   configuring, building, installing and testing.
#
# - make_* functions are used by the generic build_cmake or build_autoconf
#   build functions to make, install and run tests. Make functions are executed
#   in the build directory.
#
# Paths generated by get_repo_dir, get_build_dir, and paths passed to build_* 
# functions are always relative to ROOT_DIR. ROOT_DIR itself may be relative 
# to some dir (i.e., this directory), use $(abspath ) to make it absolute.
#
#
# TODO find out whether all variables are quoted where necessary
# NB: CMake does not want it's program path quoted.
#
###############################################################################

# 
# Note: This function is only safe to use when the path exists.
# When using for build paths, make sure it has been created first.
#
function abspath() {
    local path=$1
    local pwd_restore="$(pwd)"

    # readlink -f does not work on OSX, so we do this manually
    local dir=$(dirname "$path")
    if [ -d "$dir" ]; then
	cd "$dir" > /dev/null
	path=$(basename "$path")
	# follow chain of symlinks
	while [ -L "$path" ]; do
	    path=$(readlink "$path")
	    cd $(dirname "$path") > /dev/null
	    path=$(basename "$path")
	done
	echo "$(pwd -P)/$path"
	cd "$pwd_restore" > /dev/null
    elif [[ "$BUILDDIR_SUFFIX" =~ ^/ ]]; then
	echo $path
    else
	echo "Trying to resolve non-existent relative path $path, don't want to use PWD."
	exit 1
    fi
}


OS_NAME=$(uname -s)
ARCH_NAME=$(uname -m)
# avoid changing into CDPATH directories
unset CDPATH

# Prevent custom GREP options from breaking the build
unset GREP_OPTIONS

# physical location of this script, and the config
self=$(abspath $0)
CFGFILE=$(dirname $self)/build.cfg

# location of the patmos-chrpath script
CHRPATH=$(dirname $self)/patmos-chrpath

# location of the custom install script
INSTALL_SH=$(dirname $self)/scripts/install.sh

# List of available targets
ALLTARGETS="simulator gold llvm1 newlib compiler-rt argo soc-comm poseidon patmos bench otawa"

########### Start of user configs, overwrite in build.cfg ##############

# List of targets to build by default when running toolchain1 (using the new version of the compiler 'llvm2'), 
# developers may set this to $ALLTARGETS or a subset of interesting tools
TOOLCHAIN1_TARGETS="simulator gold llvm1 platin newlib compiler-rt argo soc-comm poseidon patmos"
# List of targets to build for toolchain2 (using the new version of the compiler 'llvm2')
# Should be kept up to date with 'TOOLCHAIN1_TARGETS'
TOOLCHAIN2_TARGETS="simulator llvm2 platin argo soc-comm poseidon patmos"

# Root directory for all repositories
ROOT_DIR=$(pwd)

# Set to 'short' for llvm/clang/... directory names, 'long' for
# patmos-llvm/patmos-clang/.. or 'prefix' to use $(REPO_PREFIX)llvm/..
REPO_NAMES=short
REPO_PREFIX=

# Installation directory prefix
INSTALL_DIR="$ROOT_DIR/local"
# Directory suffix for directory containing generated files
BUILDDIR_SUFFIX="/build"

# Whether to download pre-built binaries where available.
PREFER_DOWNLAOD=false

# RTEMS subdirectory prefix. Set to empty to checkout without subdirectories.
RTEMS_SUBDIR_PREFIX="rtems-4.10.2"

# Targets to support with patmos-clang
#LLVM_TARGETS=all
#LLVM_TARGETS="ARM;Mips;Patmos;X86"
LLVM_TARGETS=Patmos
ECLIPSE_LLVM_TARGETS=Patmos

# build LLVM using configure instead of cmake
LLVM_USE_CONFIGURE=false
# Set the build type for LLVM (currently only for cmake builds)
LLVM_BUILD_TYPE=Release
# build LLVM using shared libraries instead of static libs
LLVM_BUILD_SHARED=true
# skip checking out clang
LLVM_OMIT_CLANG=false

# Set to the name of the clang binary to use for compiling LLVM itself.
# Leave empty to use cmake defaults, set to "clang" to use clang
CLANG_COMPILER=

# Build gold binutils and LLVM LTO plugin
BUILD_LTO=true

# Build newlib, compiler-rt and benchmarks with softfloats
BUILD_SOFTFLOAT=true

# Build the Patmos Chisel emulator
BUILD_EMULATOR=true

# Create symlinks instead of copying files where applicable
# (llvm, clang, gold)
INSTALL_SYMLINKS=false

# Update rpath of binaries during installation:
# - 'remove'  Remove rpath
# - 'build'   Set install rpath at build time
# - 'true'    Update rpath to the install dir on installation
# - 'false'   Do not change rpath on installation
INSTALL_RPATH=true

# Base URL for checking out new repositories. 'auto' tries to use
# the same base-url as the patmos-misc repository. Defaults to
# 'https://github.com/t-crest'
GITHUB_BASEURL="auto"

# URL for the repository containing the benchmarks
BENCH_REPO_URL="https://github.com/t-crest/patmos-benchmarks.git"
# URL for repository containing additional non-free benchmarks
BENCH_NONFREE_REPO_URL=

# Optional path to use for the gcc.c_torture/execute checkout.
# Set this to somewhere outside the build directory to avoid checking the
# sources out on clean benchmark builds.
#BENCH_GCC_C_TORTURE_PATH=

# Set the target architecture for gold
# auto      use HOST on Linux, 'patmos-unknown-unknown-elf' otherwise
# none      do not set --target
# <target>  use <target> as target architecture
GOLD_TARGET_ARCH=auto

# Target triple for Patmos libraries and benchmarks:
# patmos-unknown-unknown-elf	Default
# patmos-unknown-rtems		Used with RTEMS
TARGET="patmos-unknown-unknown-elf"

# Additional arguments for cmake / configure
LLVM_CMAKE_ARGS=
# e.g., use ninja for building instead of make
#LLVM_CMAKE_ARGS="-G Ninja"
LLVM_CONFIGURE_ARGS=
GOLD_ARGS=
NEWLIB_ARGS=

# Additional RTEMS configure options
RTEMS_ARGS=

# Select BSP for RTEMS build
RTEMS_BSP=pasim

# Whether to use simulator (pasim) of FPGA (patex) for RTEMS tests
RTEMS_SIM=pasim

# Build simulator in Debug mode (default: RelWithDebInfo)
#PASIM_ARGS="-DCMAKE_BUILD_TYPE=Debug"
# Use a custom installation of Boost libraries
#PASIM_ARGS="-DBOOST_ROOT=$HOME/local/ -DBoost_NO_BOOST_CMAKE=TRUE"

# Patmos C-tools cmake options
CTOOLS_ARGS=

## Options for the patmos-bench test environment
# PML architecture files configure clang/llvm, pasim, and platin:
# PML_CONFIG and PML_CONFIG_LARGERAM (for benchmarks requiring >2Mb RAM)
#BENCH_ARGS="-DCONFIG_PML=scripts/patmos-config.pml"
# Add extra options for pasim when executing tests
#BENCH_ARGS="${BENCH_ARGS} -DPASIM_EXTRA_OPTIONS='--maxc 1000'"
# Disable gcc torture tests
#BENCH_ARGS="${BENCH_ARGS} -DENABLE_CTORTURE=false"
# Set path to a3, or set to empty string to disable a3
#BENCH_ARGS="${BENCH_ARGS} -DA3_EXECUTABLE="

# Additional CFLAGS, LDFLAGS
GOLD_CFLAGS=
# Use this flag if gcc throws errors about narrowing conversions
#GOLD_CXXFLAGS="-Wno-narrowing"
GOLD_CXXFLAGS=

# Disable inline-assembly implementations in compiler-rt
COMPILER_RT_CFLAGS="-DCRT_NO_INLINE_ASM"
BENCH_LDFLAGS=

# CFLAGS for host compiler
NEWLIB_CFLAGS=
# CFLAGS for target compiler (patmos-clang)
NEWLIB_TARGET_CFLAGS=

# Use the following FLAGS to link runtime libraries as binaries
#NEWLIB_TARGET_CFLAGS="-fpatmos-emit-obj"
#COMPILER_RT_CFLAGS="-fpatmos-emit-obj"
#BENCH_LDFLAGS="-fpatmos-lto-defaultlibs"

# If 'y' the 'patmos' target will automatically switch to the llvm1 branch as part of the build
AUTO_PATMOS_LLVM1=n

# Commandline option to pass to make/ctest for parallel builds
MAKEJ=-j2

# Arguments to pass to ctest
# Use "-jN" to enable parallel benchmark testing
if [ "$OS_NAME" == "Darwin" ]; then
	CORE_COUNT=$(sysctl -n hw.ncpu)
else 
	CORE_COUNT=$(grep -c ^processor /proc/cpuinfo)
fi
CTEST_ARGS=-j$CORE_COUNT

# Set nice level for the whole build.sh run. No renice happens if undefined.
#NICENESS=10
#################### End of user configs #####################

# Internal options, set by command line
MAKE_VERBOSE=
DO_CLEAN=false
DO_RECONFIGURE=false
DO_UPDATE=false
DO_SHOW_CONFIGURE=false
DO_RUN_TESTS=false
DRYRUN=false
VERBOSE=false
DO_RUN_ALL=false

# user config
if [ -f $CFGFILE ]; then
  source $CFGFILE
fi

# renice if niceness has been set
if [ -n "$NICENESS" ]; then
  renice -n $NICENESS $$
fi

##################### Helper Functions ######################

function info() {
    echo -e "\033[32m ===== $1 ===== \033[0m" >&2
}

run() {
    if [ "$VERBOSE" == "true" ]; then
	echo "$@"
    fi
    if [ "$DRYRUN" != "true" ]; then
	eval $@
	ret=$?
	if [ $ret != 0 ]; then
	    echo "$@ failed ($ret)!"
	    return $ret
	fi
    fi
}

function install() {
    # if $src is a directory, $dst must be the target directory, not the parent directory!
    local src=$1
    local dst=$2

    if [ -f $src -a -d $dst ]; then
	dst=$dst/$(basename $src)
    fi

    run mkdir -p $(dirname $dst)

    if [ "$INSTALL_SYMLINKS" == "true" ]; then
	echo "Symlinking $src -> $dst"

	if [ -d $src ]; then
	    run rm -rf $dst
	fi
	run ln -sf $src $dst
    else
	echo "Installing $src -> $dst"

	if [ -L $dst ]; then
	    rm -f $dst
	fi
	# TODO option to use hardlinking instead
	# Maybe, if $src is a directory, make sure we remove any trash in $dst (use rsync??) .. should be optional, off by default!
	if [ "$OS_NAME" == "Linux" ]; then
	    run cp -fauT $src $dst
	else
	    if [ -e $dst ]; then
		run rm -rf $dst
	    fi
	    run cp -fR $src $dst
	fi
    fi
}

function update_rpath() {
    local repo=$1

    if [ "$INSTALL_RPATH" == "true" ]; then
	if [ -x $CHRPATH ]; then
	    echo "Setting rpath of binaries to install dir .. "
	    run $CHRPATH -w -p $repo -i $INSTALL_DIR
	else
	    echo "** Warning: patmos-chrpath script not found, skipping setting rpath."
	fi
    fi
    if [ "$INSTALL_RPATH" == "remove" ]; then
	if [ -x $CHRPATH ]; then
	    echo "Removing rpath from installed binaries .. "
	    run $CHRPATH -w -d -p $repo -i $INSTALL_DIR
	else
	    echo "** Warning: patmos-chrpath script not found, skipping removing rpath."
	fi
    fi
}

# 
# Get the source directory name for a repository, relative to the rootdir.
#
# This function expects the same arguments as get_build_dir, just that subdirectories
# are separeted by '/' instead of being passed as separate directory.
#
function get_repo_dir() {
    # name of the repository (not a directory name)
    local repo=$1

    # TODO if subdir is set to empty, we could instead make a flat hierarchy,
    #      i.e., check out patmos-rtems, patmos-rtems-examples, patmos-rtems-compiler-rt, ..
    #      Needs to be consistent with get_build_dir.
    if [ ! -z "$RTEMS_SUBDIR_PREFIX" ]; then
        case $repo in
        rtems/rtems)
	    repo=rtems/${RTEMS_SUBDIR_PREFIX}
	    ;;
        rtems/examples)
	    repo=rtems/${RTEMS_SUBDIR_PREFIX}-examples
	    ;;
        *) ;;
        esac
    fi

    case $REPO_NAMES in
    short)
	echo $repo
	;;
    long)
	case $repo in
	patmos)	  echo "patmos" ;;
	patmos/*) echo $repo ;;
	bench)    echo "patmos-benchmarks" ;;
	*)	  echo "patmos-"$repo ;;
	esac
	;;
    prefix)
	echo $REPO_PREFIX$repo
	;;
    *)
	# TODO uhm.. make sure that this never happens by checking earlier
	echo $repo
	;;
    esac
}

# 
# Get the build directory name for a repository or a subdirectory of a repository.
#
# The build directory is relative to the root directory.
#
function get_build_dir() {
    # name of the repository (not a path), excluding subdirs
    local repo=$1
    # subdirectory inside the repository, can be omitted
    local subdir=$2

    local repodir=$(get_repo_dir $1)

    if [ "$repo" == "patmos" ]; then
	if [[ "$BUILDDIR_SUFFIX" =~ ^/ ]]; then
	    builddir=$repodir/$subdir$BUILDDIR_SUFFIX
	else
	    builddir=$repodir$BUILDDIR_SUFFIX/$subdir
	fi
    elif [ "$repo" == "rtems" ]; then
	# For RTEMS, we always subdir the build directory, not the other way round
	builddir=$repodir$BUILDDIR_SUFFIX/$subdir
    else
	builddir=$repodir$BUILDDIR_SUFFIX
    fi
    echo $builddir
}

function clone_update() {
    local srcurl=$1
    local target=$ROOT_DIR/$2
    local branch=$3
    if [ "$branch" == "" ]; then
        branch="master"
    fi

    if [ "$DO_SHOW_CONFIGURE" == "true" ]; then
	return
    fi
    if [ ! -d "$target" ] ; then
	info "Cloning from $srcurl"
	run git clone "$srcurl" "$target" --branch "$branch"
    elif [ ${DO_UPDATE} != false ] ; then
        #TODO find a better way (e.g. stash away only on demand)
	info "Updating $1"
        run pushd "$target" ">/dev/null"
        if [ "$DRYRUN" == "true" ]; then
	    echo git stash
	else
	    ret=$(git stash)
	    # TODO is there a better way of doing this?
	    local skip_stash=false
	    if [ "$ret" == "No local changes to save" ]; then
		skip_stash=true
	    fi
	fi
        run git pull --rebase
        if [ "$DRYRUN" == "true" ]; then
	    echo git stash pop
	else
	    if [ "$skip_stash" != "true" ]; then
		git stash pop
	    fi
	fi
        run popd ">/dev/null"
    fi
}

#
# Get all build flags for a given repository from the configuration.
#
function get_build_flags() {
    # name of the repository, may include subdirs (subdirs will be added to the config-variable name).
    local repo=$1


    local cflagsname=$(echo "${repo}_CFLAGS" | tr '[a-z-/]' '[A-Z__]')
    local cppflagsname=$(echo "${repo}_CPPFLAGS" | tr '[a-z-/]' '[A-Z__]')
    local cxxflagsname=$(echo "${repo}_CXXFLAGS" | tr '[a-z-/]' '[A-Z__]')
    local ldflagsname=$(echo "${repo}_LDFLAGS" | tr '[a-z-/]' '[A-Z__]')
    local envvarsname=$(echo "${repo}_ENVVARS" | tr '[a-z-/]' '[A-Z__]')

    if [ ! -z "${!cflagsname}$CFLAGS" ]; then
	echo -n "CFLAGS='${!cflagsname} $CFLAGS'"
    fi
    if [ ! -z "${!cppflagsname}$CPPFLAGS" ]; then
	echo -n " CPPFLAGS='${!cppflagsname} $CPPFLAGS'"
    fi
    if [ ! -z "${!cxxflagsname}$CXXFLAGS" ]; then
	echo -n " CXXFLAGS='${!cxxflagsname} $CXXFLAGS'"
    fi
    if [ ! -z "${!ldflagsname}$LDFLAGS" ]; then
	echo -n " LDFLAGS='${!ldflagsname} $LDFLAGS'"
    fi
    if [ ! -z "${!envvarsname}" ]; then
	echo -n " ${!envvarsname}"
    fi
}

function build_cmake() {
    # name of the repository
    local repo=$1
    # path of the repository (might be relative)
    local root=$ROOT_DIR/$(get_repo_dir $repo)
    # function to use for building
    local make_function=$2
    # path to the build directory (might be relative)
    local builddir=$ROOT_DIR/$3
    # absolute path to sources
    local rootdir=$(abspath $root)
    shift 3

    # TODO pass get_build_flags result to cmake
    local flags=$(get_build_flags $repo)

    if [ "$DO_SHOW_CONFIGURE" == "true" ]; then
	echo cd $builddir
	echo "$flags" cmake $@ -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} $rootdir
	return
    fi
    if [ -e $builddir -a ! -e $builddir/Makefile -a ! -e $builddir/build.ninja  ]; then
	echo "Recreating builddir after unfinished configure"
	run rm -rf $builddir
    fi
    if [ $DO_CLEAN == true -o ! -e "$builddir" ] ; then
        run rm -rf $builddir
        run mkdir -p $builddir
        run pushd $builddir ">/dev/null"
        run "$flags" cmake $@ -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} $rootdir
    elif [ $DO_RECONFIGURE == true ] ; then
        run pushd $builddir ">/dev/null"
        run rm -f CMakeCache.txt
        run "$flags" cmake --no-warn-unused-cli $@ -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} $rootdir
    else
        run pushd $builddir ">/dev/null"
    fi
    $make_function $rootdir $(abspath $builddir)
    run popd ">/dev/null"
}

function build_autoconf() {
    # name of the repository
    local repo=$1
    # path of the repository (might be relative)
    local root=$ROOT_DIR/$(get_repo_dir $repo)
    # function to use for building
    local make_function=$2
    # path to the build directory (might be relative)
    local builddir=$ROOT_DIR/$3
    # absolute path to sources
    local rootdir=$(abspath $root)
    # configure script to use (absolute path)
    local configscript=$rootdir/configure
    shift 3

    # Read out GOLD_CPPFLAGS, NEWLIB_CPPFLAGS, ..
    local flags=$(get_build_flags $repo)

    if [ "$DO_SHOW_CONFIGURE" == "true" ]; then
	echo cd $builddir
	echo "$flags" $configscript "$@" --prefix=${INSTALL_DIR}
	return
    fi
    if [ -e $builddir -a ! -e $builddir/Makefile ]; then
	echo "Recreating builddir after unfinished configure"
	run rm -rf $builddir
    fi
    if [ $DO_CLEAN == true -o ! -e "$builddir" ] ; then
        run rm -rf $builddir
        run mkdir -p $builddir
        run pushd $builddir ">/dev/null"
	run "$flags" $configscript "$@" --prefix=${INSTALL_DIR}
    elif [ $DO_RECONFIGURE == true ] ; then
        run pushd $builddir ">/dev/null"
	run "$flags" $configscript "$@" --prefix=${INSTALL_DIR}
    else
        run pushd $builddir ">/dev/null"
    fi
    $make_function $rootdir $(abspath $builddir)
    run popd ">/dev/null"
}

function usage() {
  cat <<EOT
  Usage: $0 [-c] [-j<n>] [-p] [-i <install_dir>] [-h] [-a|-o|<targets>]

    -a		Build all targets
    -c		Cleanup builds and rerun configure
    -r		Rerun configure (resetting CMake cache where applicable)
    -j <n> 	Pass -j<n> to make
    -i <dir>	Set the install dir
    -h		Show this help
    -p		Create builddirs outside the source dirs
    -u		Update repositories
    -d		Dryrun, just show what would be executed
    -s		Show configure commands for all given targets
    -v		Show command that are executed
    -V		Make make verbosive
    -t		Run tests
    -o		Build toolchain (simulator, gold, llvm, patmos, newlib, compiler-rt) and do clean build of bench with tests.
    -q		Download and install from pre-built binaries where available, instead of building from source. Disables testing of downloaded targets (with -t)
  Available targets:
    simulator gold llvm newlib compiler-rt patmos otawa bench rtems rtems-test rtems-examples eclipse poseidon soc-comm

  The command-line options override the user-config read from '$CFGFILE'.
EOT
}

function make_simulator() {
    # absolute source dir
    local rootdir=$1
    # absolute build dir
    local builddir=$2

    # Build binaries
    make $MAKEJ $MAKE_VERBOSE

    # Package binaries
    make Package

	if $DO_RUN_TESTS; then
		make test
	fi

    # Install
    echo "Installing files ..."

    mkdir -p $INSTALL_DIR
    cp $builddir/patmos-simulator*.tar.gz $INSTALL_DIR/
    tar -xvf $INSTALL_DIR/patmos-simulator*.tar.gz --directory=$INSTALL_DIR

    rm -rf $INSTALL_DIR/patmos-simulator*.tar.gz
}

function make_llvm-project() {
	# First, Ensure that GNU tar is installed as 'tar'
	# This is usually not the case on MacOS (usually uses bsdtar)
	TAR_VERSION=$(tar --version)
	if [[ $TAR_VERSION != "tar (GNU tar)"* ]]; then
		echo "Error: Must have GNU Tar installed as 'tar'."
		echo "Error: Your installed 'tar':"
		echo "Error: $TAR_VERSION"
		echo "Error: Hint: if you are using macos, bsdtar is the default 'tar' installed. You can use brew to get GNU tar instead"
		exit 1
	fi	
	mkdir -p $1
	cd $1
    # Build binaries
	cmake ../llvm \
          -DCMAKE_CXX_STANDARD=14 \
          -DCMAKE_BUILD_TYPE=Release \
          -DLLVM_TARGETS_TO_BUILD="Patmos" \
          -DLLVM_DEFAULT_TARGET_TRIPLE=patmos-unknown-unknown-elf  \
          -DLLVM_ENABLE_PROJECTS="clang;lld" \
          -DCLANG_ENABLE_ARCMT=false \
          -DCLANG_ENABLE_STATIC_ANALYZER=false \
          -DCLANG_BUILD_EXAMPLES=false \
          -DLLVM_ENABLE_BINDINGS=false \
          -DLLVM_INSTALL_BINUTILS_SYMLINKS=false \
          -DLLVM_INSTALL_CCTOOLS_SYMLINKS=false \
          -DLLVM_INCLUDE_EXAMPLES=false \
          -DLLVM_INCLUDE_BENCHMARKS=false \
          -DLLVM_APPEND_VC_REV=false \
          -DLLVM_ENABLE_WARNINGS=false \
          -DLLVM_ENABLE_PEDANTIC=false \
          -DLLVM_ENABLE_LIBPFM=false \
          -DLLVM_BUILD_INSTRUMENTED_COVERAGE=false \
          -DLLVM_INSTALL_UTILS=false \
          -DLLVM_ENABLE_ASSERTIONS=true
		  # Compiler currently doesn't work without assertions enabled
		  
    make $MAKEJ $MAKE_VERBOSE

	# Build Compiler-RT
	cd ..
	mkdir -p build-compiler-rt
	cd build-compiler-rt
	cmake ../compiler-rt/ -DCMAKE_TOOLCHAIN_FILE=../compiler-rt/cmake/patmos-clang-toolchain.cmake -DCMAKE_PROGRAM_PATH="$(pwd)/../build/bin" -DCOMPILER_RT_INCLUDE_TESTS=OFF
	make $MAKEJ $MAKE_VERBOSE
	cd ..
	
	# Build Newlib
	cd patmos-newlib
	cd ..
	mkdir -p build-newlib
	cd build-newlib
	../patmos-newlib/configure --target=patmos-unknown-unknown-elf AR_FOR_TARGET=ar CC_FOR_TARGET="$(pwd)/../build/bin/clang" CFLAGS_FOR_TARGET="-target patmos-unknown-unknown-elf -O2 -emit-llvm -D__GLIBC_USE\(...\)=0" RANLIB_FOR_TARGET=ranlib LD_FOR_TARGET="$(pwd)/../build/bin/clang"
	make $MAKEJ $MAKE_VERBOSE
	cd ../build
	
	if $DO_RUN_TESTS; then
		make $MAKEJ llc && ./bin/llvm-lit ../llvm/test -v --filter=Patmos
		make $MAKEJ ClangPatmosTestDeps && ./bin/llvm-lit ../clang/test -v --filter=Patmos
		cd ../build-compiler-rt
		./bin/llvm-lit -v test/builtins/Unit/patmos
		cd ../build
	fi

    # Package Everything
    make PatmosPackage

    # Install
    echo "Installing files ..."

    mkdir -p $INSTALL_DIR
    cp patmos-unknown-unknown-elf/package-temp/patmos-llvm*.tar.gz $INSTALL_DIR/patmos-llvm.tar.gz
    tar -xvf $INSTALL_DIR/patmos-llvm.tar.gz --directory=$INSTALL_DIR

    rm -rf $INSTALL_DIR/patmos-llvm.tar.gz
}

function make_gold() {
    # absolute source dir
    local rootdir=$1
    # absolute build dir
    local builddir=$2

    if [ "$BUILD_LTO" == "true" ]; then
	run make $MAKEJ $MAKE_VERBOSE all-gold all-binutils
	local install_target="install-gold install-binutils"
    else
	run make $MAKEJ $MAKE_VERBOSE all-gold
	local install_target=install-gold
    fi

    if [ "$INSTALL_SYMLINKS" == "true" ]; then
	run mkdir -p $INSTALL_DIR/bin
	run ln -sf $builddir/gold/ld-new $INSTALL_DIR/bin/patmos-ld

	if [ "$BUILD_LTO" == "true" ]; then
	    run ln -sf $builddir/binutils/ar $INSTALL_DIR/bin/patmos-ar
	    run ln -sf $builddir/binutils/nm-new $INSTALL_DIR/bin/patmos-nm
	    run ln -sf $builddir/binutils/ranlib $INSTALL_DIR/bin/patmos-ranlib
	    run ln -sf $builddir/binutils/strip-new $INSTALL_DIR/bin/patmos-strip

	    # bin is required, otherwise auto-loading of plugins does not work!
	    run mkdir -p $builddir/bin
	    run mkdir -p $builddir/lib/bfd-plugins

	    run ln -sf $INSTALL_DIR/lib/LLVMgold.$LIBEXT $builddir/lib/bfd-plugins/
	    run ln -sf $INSTALL_DIR/lib/libLTO.$LIBEXT   $builddir/lib/bfd-plugins/
	fi
    else
	run make $MAKE_VERBOSE $install_target
    fi
}

function install_platin() {
    # absolute source dir
    local rootdir=$1
    # absolute build dir
    local builddir=$2
    
    echo "Installing platin toolkit .. "
    chmod u+x $rootdir/install.sh
    run $rootdir/install.sh -i $INSTALL_DIR -b $builddir
}

function install_prebuilt() {

	local tool_name=$1
	local tool_link=$2
	local tar_name="$1.tar.gz"		
	
    local tar_link="${tool_link}/releases/latest/download/${tool_name}-"
    if [ "$OS_NAME" == "Darwin" ]; then
        echo "Detected MacOS"
        #if [ "$ARCH_NAME" == "arm64" ]; then
        #    echo "Detected ARM"
        #    local tar_link="${tar_link}arm64-apple-darwin"
        #else
        #    echo "Detected x86_64"
            local tar_link="${tar_link}x86_64-apple-darwin"
        #fi
	else
		echo "Detected Ubuntu"
		local tar_link="${tar_link}x86_64-linux-gnu"
    fi
	local tar_link="${tar_link}.tar.gz"
	echo "Downloading prebuild from: $tar_link"

    local tar_path=$INSTALL_DIR/$tar_name

    # Download tar
    curl -L $tar_link -o $tar_path

    echo "Installed files:"
    # Extract tar
    tar -xvf $tar_path --directory=$INSTALL_DIR
}

function install_simulator() {
    echo "Installing Patmos Simulator from Pre-Built Binaries"

    install_prebuilt "patmos-simulator" "https://github.com/t-crest/patmos-simulator"
}

function make_llvm1() {
    # absolute source dir
    local rootdir=$1
    # absolute build dir
    local builddir=$2

    if [ -e build.ninja ] ; then
        run ninja $MAKEJ
    else
        run make $MAKEJ $MAKE_VERBOSE all
    fi

    echo "Installing files .. "

    if [ "$LLVM_USE_CONFIGURE" == "true" ]; then
	builddir=$builddir/Debug+Asserts
    fi

    run mkdir -p $INSTALL_DIR/bin
    run mkdir -p $INSTALL_DIR/lib

    for file in `find $builddir/bin -type f`; do
	filename=`basename $file`

	# Not sure how to add a program prefix for cmake install.. so just copy what we need
	install $file $INSTALL_DIR/bin/patmos-$filename
    done
    # symlinks have to be recreated anyway
    for file in `find $builddir/bin -type l`; do
	filename=`basename $file`
	src=$(readlink $file)
	run ln -sf patmos-$(basename $src) $INSTALL_DIR/bin/patmos-$filename
    done

    # install all shared libraries
    for file in `find $builddir/lib -name "*.$LIBEXT"`; do
	install $file $INSTALL_DIR/lib/
    done

    # Install system headers
    install $builddir/lib/clang $INSTALL_DIR/lib/clang

    if [ "$BUILD_LTO" == "true" ]; then

	# bin is required, otherwise auto-loading of plugins does not work!
	run mkdir -p $INSTALL_DIR/bin
	run mkdir -p $INSTALL_DIR/lib/bfd-plugins

	run ln -sf ../LLVMgold.$LIBEXT $INSTALL_DIR/lib/bfd-plugins/
	run ln -sf ../libLTO.$LIBEXT   $INSTALL_DIR/lib/bfd-plugins/
    fi

    # Update rpaths, since we are not using cmake install
    update_rpath llvm

    if [ "$DO_RUN_TESTS" == "true" ]; then
	echo "Running tests.."
        if [ -e build.ninja ] ; then
            run ninja check-all
        else
            run make check-all
        fi
    fi
}

function install_llvm2() {
    echo "Installing Patmos LLVM from Pre-Built Binaries"

    install_prebuilt "patmos-llvm" "https://github.com/t-crest/patmos-llvm-project"
}

function make_bench() {
    # TODO if we do not have BUILD_SOFTFLOAT=true, then do not build softfloat benchmarks!

    run make $MAKEJ $MAKE_VERBOSE all

    if [ "$DO_RUN_TESTS" == "true" ]; then
        run make test "ARGS='${CTEST_ARGS}'"
    fi
}


function make_default() {
    run make $MAKEJ $MAKE_VERBOSE all
    run make $MAKE_VERBOSE install
}

function make_and_test_default() {
    run make $MAKEJ $MAKE_VERBOSE all
    run make $MAKE_VERBOSE install

    if [ "$DO_RUN_TESTS" == "true" ]; then
        run make test "ARGS='${CTEST_ARGS}'"
    fi
}

function build_simulator() {
    build_cmake simulator make_simulator $(get_build_dir simulator)
}

function build_llvm-project() {
    make_llvm-project $(get_build_dir llvm-project)
}

function build_compiler_rt() {
    # build dir (relative to root)
    local builddir=$1
    # target triple to build for
    local target=$2
    # source repository dir (relative path, always to same compiler-rt checkout, independent of build-dir)
    local repo=$(get_repo_dir compiler-rt)

    clone_update ${GITHUB_BASEURL}/patmos-compiler-rt.git $repo
    build_cmake compiler-rt make_default $builddir \
        "-DTRIPLE=${target} -DCMAKE_TOOLCHAIN_FILE=$ROOT_DIR/$repo/cmake/patmos-clang-toolchain.cmake -DCMAKE_PROGRAM_PATH=${INSTALL_DIR}/bin"
}

function build_newlib() {
    # build dir (relative to root)
    local builddir=$1
    # target triple to build for
    local target=$2
    # source repository dir (relative path, always to same newlib ckeckout, independent of build-dir)
    local repo=$(get_repo_dir newlib)
    clone_update ${GITHUB_BASEURL}/patmos-newlib.git $repo llvm1 
	echo "WARNING: Explicitly building newlib will assume the use of the llvm1 compiler (old compiler)."
	echo "WARNING: If you do not want to explicitly use the old compiler, do not build newlib manually."
	echo "WARNING: The newlib repository will automatically be switched to the old compiler commit (tagged as llvm1)."	

    # Use a different install script for newlib that does not change the modification time if
    # the files did not change.
    NEWLIB_ENVVARS="INSTALL='$INSTALL_SH' $NEWLIB_ENVVARS"
    build_autoconf newlib make_default $builddir --target=$target AR_FOR_TARGET=${INSTALL_DIR}/bin/$NEWLIB_AR \
        RANLIB_FOR_TARGET=${INSTALL_DIR}/bin/$NEWLIB_RANLIB LD_FOR_TARGET=${INSTALL_DIR}/bin/patmos-clang \
	READELF_FOR_TARGET=${INSTALL_DIR}/bin/patmos-readelf \
        CC_FOR_TARGET=${INSTALL_DIR}/bin/patmos-clang  "CFLAGS_FOR_TARGET='-target ${target} -O2 ${NEWLIB_TARGET_CFLAGS}'" "$NEWLIB_ARGS"
}

function build_otawa() {
    # build dir (relative to root)
    local builddir=$1

    # source repository dir (relative path, always do same otawa ckeckout, independent of build-dir)
    local repo=$(get_repo_dir otawa)
    clone_update  ${GITHUB_BASEURL}/otawa.git $repo

    # options that need to be passed to otawa build script
    local buildopt="-i ${INSTALL_DIR}"
    if [ $DO_RECONFIGURE == true ] ; then
      buildopt+=" -r";
    fi
    if [ "$DRYRUN" == "true" ] ; then
      buildopt+=" -d";
    fi
    if [ "$VERBOSE" == "true" ] ; then
      buildopt+=" -v";
    fi
    if [ "$DO_CLEAN" == "true" ] ; then
      buildopt+=" -c";
    fi



    # set repository up and build
    run pushd "${repo}" > /dev/null
    run git submodule update --init

    # do not use run here, since the otawa build script offers similar functions
    run misc/build.sh $MAKEJ ${buildopt}

    run popd > /dev/null
}

function build_javatools() {
    # build directory (might be relative)
    local builddir=$ROOT_DIR/$1

    # source directory of the main makefile (relative to ROOT_DIR)
    local root=$(get_repo_dir patmos)
    # absolute path to the java tools source dir
    local rootdir=$(abspath $ROOT_DIR/$root)

    if [ $DO_CLEAN == true -o ! -e "$builddir" ] ; then
        run rm -rf $builddir
        run mkdir -p $builddir
    fi

    # We can only safely use abspath once the path has been created.
    buildpath=$(abspath $builddir)

    run pushd "${rootdir}" > /dev/null
    run make $MAKEJ $MAKE_VERBOSE "JAVATOOLSBUILDDIR='${buildpath}'" "INSTALLDIR='${INSTALL_DIR}'" javatools
    run popd > /dev/null
}

function build_scripttools() {
    # build directory (might be relative)
    local builddir=$ROOT_DIR/$1

    # source directory of the main makefile (relative to ROOT_DIR)
    local root=$(get_repo_dir patmos)
    # absolute path to the script tools source dir
    local rootdir=$(abspath $ROOT_DIR/$root)

    if [ $DO_CLEAN == true -o ! -e "$builddir" ] ; then
        run rm -rf $builddir
        run mkdir -p $builddir
    fi

    # We can only safely use abspath once the path has been created.
    buildpath=$(abspath $builddir)

    run pushd "${rootdir}" > /dev/null
    run make $MAKEJ $MAKE_VERBOSE "SCRIPTSBUILDDIR='${buildpath}'" "INSTALLDIR='${INSTALL_DIR}'" scripttools
    run popd > /dev/null
}

# MS: why do we have two ways to build stuff? in the patmos Makefile and here again
function build_tools() {
    # We need a separate build call per build directory, as the build paths may not have a common prefix!
    # Therefore, for every 'build' directory there must be one build target here, either telling
    # the patmos Makefile where to build or calling the build scripts directly.

    # info "Building tools/c in patmos .. "
    # It is built as part of patmos
    # build_cmake patmos/tools/c   make_default $(get_build_dir patmos "tools/c") "$CTOOLS_ARGS"
    info "Building tools/java in patmos .. "
    build_javatools $(get_build_dir patmos "tools/java")
    info "Building tools/scripts in patmos .. "
    build_scripttools $(get_build_dir patmos "tools/scripts")
}

function build_emulator() {
    # source path, relative to ROOT_DIR
    local root=$(get_repo_dir patmos)
    # temp installation path (relative to ROOT_DIR)
    # TODO can we move this into a build dir, i.e., $(get_build_dir patmos)/tmp ??
    local tmp=$1

    # paths to build dirs of other tools (relative to ROOT_DIR)
    local ctoolsbuild=$(get_build_dir patmos "tools/c")
    local hwbuild=$(get_build_dir patmos hardware)

    # absolute path to sources
    local rootdir=$(abspath $ROOT_DIR/$root)

    # absolute paths to build dirs
    local ctoolsbuilddir=$ROOT_DIR/$ctoolsbuild
    local hwbuilddir=$ROOT_DIR/$hwbuild
    local tmpdir=$ROOT_DIR/$tmp

    if [ $DO_CLEAN == true -o ! -e "$hwbuilddir" ] ; then
        run rm -rf $hwbuilddir
        run mkdir -p $hwbuilddir
    fi
    if [ $DO_CLEAN == true -o ! -e "$tmpdir" ] ; then
        run rm -rf $tmpdir
        run mkdir -p $tmpdir
    fi

    # absolute paths to build dirs for the makefile
    ctoolsbuilddir=$(abspath $ctoolsbuilddir)
    hwbuilddir=$(abspath $hwbuilddir)
    tmpdir=$(abspath $tmpdir)

    run pushd "${rootdir}" > /dev/null
    run env PATH="'${PATH}:${INSTALL_DIR}/bin/'" make $MAKEJ $MAKE_VERBOSE "BUILDDIR='${tmpdir}'" "CTOOLSBUILDDIR='${ctoolsbuilddir}'" "HWBUILDDIR='${hwbuilddir}'" "HWINSTALLDIR='${tmpdir}'" "INSTALLDIR='${INSTALL_DIR}'" emulator
    install "${hwbuilddir}/emulator" "${INSTALL_DIR}/bin/patemu"
    run popd > /dev/null
}

function build_poseidon() {
    # source path, relative to ROOT_DIR
    local root=$(get_repo_dir poseidon)
    # build path (absolute path)
    # build path currently unused for Poseidon
    #local buildpath=$ROOT_DIR/$1

    # absolute source path
    local rootdir=$(abspath $ROOT_DIR/$root)

    run pushd "${rootdir}"
    if [ $DO_CLEAN == true ] ; then
        run make $MAKEJ $MAKE_VERBOSE clean
    fi
    run make $MAKEJ $MAKE_VERBOSE all
    install "${rootdir}/build/poseidon" $INSTALL_DIR/bin/poseidon
    install "${rootdir}/Converter/converter.jar" $INSTALL_DIR/lib/converter.jar
    install "${rootdir}/Converter/script/poseidon-conv" $INSTALL_DIR/bin/poseidon-conv
    run popd
}

function build_llvm1() {
    local eclipse_args=
    local config_args="--with-bug-report-url='https://github.com/t-crest/patmos-llvm/issues'"
    local cmake_args="-DBUG_REPORT_URL='https://github.com/t-crest/patmos-llvm/issues'"
    if [ "$1"  == "eclipse" ]; then
	local cmake_args="$cmake_args -G 'Eclipse CDT4 - Unix Makefiles' -DCMAKE_ECLIPSE_MAKE_ARGUMENTS=$MAKEJ -DCMAKE_ECLIPSE_VERSION='3.7 (Indigo)'"
    fi
    if [ "$LLVM_BUILD_SHARED" == "true" ]; then
	local config_args="$config_args --enable-shared"
	local cmake_args="$cmake_args -DBUILD_SHARED_LIBS=ON"
    fi

    if [ "$LLVM_USE_CONFIGURE" == "true" -a "$1" != "eclipse" ]; then
	local targets=$(echo $LLVM_TARGETS | tr '[A-Z;]' '[a-z,]')
	build_autoconf llvm make_llvm1 $(get_build_dir llvm) "--disable-optimized --enable-assertions --enable-targets=$targets $config_args $LLVM_CONFIGURE_ARGS"
    else
	build_cmake llvm make_llvm1 $(get_build_dir llvm) "-DCMAKE_BUILD_TYPE=$LLVM_BUILD_TYPE -DCMAKE_CXX_STANDARD=14 -DLLVM_TARGETS_TO_BUILD='$LLVM_TARGETS' $cmake_args $LLVM_CMAKE_ARGS"
    fi
}

function build_platin() {
  # Just install platin. This is mainly for development purposes.
  install_platin $ROOT_DIR/$(get_repo_dir platin) $ROOT_DIR/$(get_build_dir platin)
}

function build_rtems() {
    # source directory (relative to ROOT_DIR)
    local repodir=$(get_repo_dir rtems/rtems)
    # absolute source directory
    local srcdir=$(abspath "$ROOT_DIR/${repodir}")

    # TODO: check we have *all* necessary binaries
    local required="clang ld"
    for bin in ${required} ; do
	if [ ! -e "${INSTALL_DIR}/bin/patmos-${bin}" ] ; then
	    echo "[rtems] Error: missing binary ${INSTALL_DIR}/bin/patmos-${bin}"
	    echo "[rtems] Error: Need to build and install compiler toolchain before building RTEMS" >&2
	    if [ "$DRYRUN" != "true" ]; then
		exit
	    fi
	fi
    done

    # symbolic link from all bin/patmos-* binaries to patmos-unknown-rtems-*
    if [ "$DRYRUN" == "true" ]; then
        echo "# would symlink ${INSTALL_DIR}/bin/patmos-(.*) to ${INSTALL_DIR}/bin/patmos-unknown-rtems-\$1"
    fi
    for f in $(find "${INSTALL_DIR}/bin" -name 'patmos-*' | grep -v unknown-rtems) ; do
        local target="${f/bin\/patmos-/bin/patmos-unknown-rtems-}"
        if [ ! -e "${target}" ] ; then
            run ln -s "${f}" "${target}"
        fi
    done

    # build newlib and compiler-rt for target patmos-unknown-rtems
    build_compiler_rt $(get_build_dir rtems compiler-rt) patmos-unknown-rtems
    build_newlib $(get_build_dir rtems newlib) patmos-unknown-rtems

    # bootstrap; bit of a hack, we rerun it on clean builds
    # TODO this should be rerun if any new files are added
    run pushd "${srcdir}"
    if [ "$DO_CLEAN" == "true" -o ! -f ./configure ]; then
	run ./bootstrap -p
	run ./bootstrap
    fi
    run popd

    # build with tests disabled here, testing is done using a separate build
    build_autoconf rtems/rtems make_default $(get_build_dir rtems rtems) --target=patmos-unknown-rtems --enable-posix \
         --disable-networking --disable-cxx --enable-rtemsbsp="${RTEMS_BSP}" --disable-tests "${RTEMS_ARGS}"


    echo
    echo "##### Add the following environment variable #####"
    echo "export RTEMS_MAKEFILE_PATH=${INSTALL_DIR}/patmos-unknown-rtems/${RTEMS_BSP}"
    echo
}

function build_rtems_test() {
    # source dir (relative to ROOT_DIR)
    local repodir=$(get_repo_dir rtems/rtems)
    # build dir for tests (relative to ROOT_DIR)
    local builddir=$(get_build_dir rtems rtems-test)
    # absolute source path
    local srcdir=$(abspath "$ROOT_DIR/${repodir}")

    local rtems_testscript=$ROOT_DIR/$repodir/run-testsuite.sh

    build_autoconf rtems/rtems make_default $builddir --target=patmos-unknown-rtems --enable-posix \
         --disable-networking --disable-cxx --enable-rtemsbsp="${RTEMS_BSP}" --enable-tests "${RTEMS_ARGS}"

    if [ "$DO_RUN_TESTS" == "true" ]; then
	echo "Running tests.."
	run $rtems_testscript -s $ROOT_DIR/$repodir/testsuites -b $ROOT_DIR/$builddir -o $ROOT_DIR/$builddir/results -m $RTEMS_SIM -x $RTEMS_BSP
    fi
}

function build_rtems_examples() {
    # directory of example sources, relative to ROOT_DIR
    local exampledir="$(get_repo_dir rtems/examples)"

    #TODO build all examples (but do not install)

    echo
    echo "##### Add the following environment variable #####"
    echo "export RTEMS_MAKEFILE_PATH=${INSTALL_DIR}/patmos-unknown-rtems/pasim"
    echo "##### To run an example, try: #####"
    echo "cd $ROOT_DIR/${exampledir}/classic_api/triple_period"
    echo "make"
    echo "pasim --interrupt 1 o-optimize/triple_period.exe"
    echo
}

build_target() {
  local target=$1

  if [ "$DO_SHOW_CONFIGURE" == "true" ]; then
    info "Configure for '$target'"
  else
    info "Processing '"$target"'"
  fi
  case $target in
  'llvm1')
	AUTO_PATMOS_LLVM1=y
    clone_update ${GITHUB_BASEURL}/patmos-llvm.git $(get_repo_dir llvm)
    if [ "$LLVM_OMIT_CLANG" != "true" ]; then
        clone_update ${GITHUB_BASEURL}/patmos-clang.git $(get_repo_dir llvm)/tools/clang
    fi
    build_llvm1
    ;;
  'platin')
    clone_update ${GITHUB_BASEURL}/patmos-platin.git $(get_repo_dir platin)
    build_platin
    ;;
  'eclipse')
    build_llvm1 eclipse
    ;;
  'gold')
    clone_update ${GITHUB_BASEURL}/patmos-gold.git $(get_repo_dir gold)
    build_autoconf gold make_gold $(get_build_dir gold) --program-prefix=patmos- --enable-gold=yes --enable-ld=no --disable-werror "$GOLD_ARGS"
    ;;
  'newlib')
    build_newlib $(get_build_dir newlib) $TARGET
    ;;
  'compiler-rt')
    build_compiler_rt $(get_build_dir compiler-rt) $TARGET
    ;;
  'otawa')
    build_otawa $(get_build_dir otawa)
    ;;
  'patmos')
    clone_update ${GITHUB_BASEURL}/patmos.git $(get_repo_dir patmos)	
	# Check if LLVM2 is installed, if not, switch to llvm1 branch
	IS_LLVM2="false"
	FOUND_INFO_YML=$(find "${INSTALL_DIR}" -type f -name "patmos-llvm-info.yml")
	if [ ! -z  "$FOUND_INFO_YML" ]; then
		IS_LLVM2="true"
		YML_CONTENT=$(cat ${INSTALL_DIR}/patmos-llvm-info.yml) 
		# Might still be version 1, check version is 1
		if [[ "$YML_CONTENT" == *"version: 1"* ]]; then
			IS_LLVM2="false"
		fi
	fi
	if [ "$IS_LLVM2" == "false" ]; then
		PATMOS_DIR=$(get_repo_dir patmos)
		BRANCHES=$(cd $ROOT_DIR/$PATMOS_DIR; git branch)
		if [[ ! "$BRANCHES" == *"* llvm"* ]]; then
			if [[ "$AUTO_PATMOS_LLVM1" == "y" ]]; then
				cd "$ROOT_DIR/$PATMOS_DIR"; git checkout llvm1
			else
				echo "'patmos' repository is not on 'llvm1' branch, would you like me to switch to it [y/N]: "
				read  -t 300 SWITCH_TO_LLVM1
				
				if [ "$SWITCH_TO_LLVM1" == "y" ]; then
					cd "$ROOT_DIR/$PATMOS_DIR"; git checkout llvm1
				else
					echo "WARNING: The 'patmos' repository's 'master' branch (and derived branches) doesn't work with the llvm1 compiler (old compiler). "
					echo "WARNING: Make sure the current branch is compatible with the old compiler to avoid spurious errors."
				fi
			fi				
		fi 
	fi
    build_tools
    if [ "$BUILD_EMULATOR" == "false" ]; then
	info "Skipping patmos emulator in patmos."
    else
	info "Building patmos emulator in patmos .."
	build_emulator $(get_repo_dir patmos)/tmp
    fi
    ;;
  'argo')
    clone_update ${GITHUB_BASEURL}/argo.git $(get_repo_dir argo)
    ;;
 'poseidon')
    clone_update ${GITHUB_BASEURL}/poseidon.git $(get_repo_dir poseidon)
    build_poseidon $(get_build_dir poseidon)
    ;;
  'bench')
    local repo=$(get_repo_dir bench)
    if [ -z "$BENCH_REPO_URL" ]; then
      if [ -d $ROOT_DIR/$repo ]; then
	echo "Skipped updating of benchmark repository, BENCH_REPO_URL is not set."
      else
        echo "Benchmark repository URL is not configured, skipped. Set BENCH_REPO_URL to enable."
      fi
    else
      clone_update $BENCH_REPO_URL $(get_repo_dir bench)
      if [ -n "$BENCH_NONFREE_REPO_URL" ]; then
        clone_update $BENCH_NONFREE_REPO_URL $(get_repo_dir bench)/nonfree
      fi
    fi
    if [ -d $ROOT_DIR/$repo ]; then
      build_cmake bench make_bench $(get_build_dir bench) "-DTRIPLE=${TARGET} -DENABLE_EMULATOR=true -DCMAKE_TOOLCHAIN_FILE=$ROOT_DIR/$repo/cmake/patmos-clang-toolchain.cmake -DCMAKE_PROGRAM_PATH=${INSTALL_DIR}/bin" "$BENCH_ARGS"
    fi
    ;;
  'rtems')
    # following the readme instructions in rtems.git/readme.txt
    clone_update ${GITHUB_BASEURL}/rtems.git $(get_repo_dir rtems/rtems)
    build_rtems
    ;;
  'simulator')
    if $PREFER_DOWNLAOD ; then
        install_simulator
    else 
        clone_update ${GITHUB_BASEURL}/patmos-simulator.git $(get_repo_dir simulator)
        build_simulator
    fi
    ;;
  'llvm2')
    if $PREFER_DOWNLAOD ; then
        install_llvm2
    else 
        clone_update ${GITHUB_BASEURL}/patmos-llvm-project.git $(get_repo_dir llvm-project)
        clone_update ${GITHUB_BASEURL}/patmos-newlib.git $(get_repo_dir llvm-project)/patmos-newlib
        build_llvm-project
    fi
    ;;
  'toolchain1')
	AUTO_PATMOS_LLVM1=y
    for target in $TOOLCHAIN1_TARGETS; do
	  build_target $target
    done
    ;;
  'toolchain2')
    for target in $TOOLCHAIN2_TARGETS; do
	  build_target $target
    done
    ;;
  "rtems-test")
    # This requires rtems target to be built already
    build_rtems_test
    ;;
  "rtems-examples")
    clone_update ' https://github.com/RTEMS/examples-v2' "$(get_repo_dir rtems/examples)"
    build_rtems_examples
    ;;
  "soc-comm")
    clone_update ${GITHUB_BASEURL}/soc-comm.git $(get_repo_dir soc-comm)
    ;;
  *) echo "Don't know about $target." ;;
  esac
}



# one-shot config
while getopts ":crhi:j:pudsvxVtoeaq" opt; do
  case $opt in
    a) DO_RUN_ALL=true ;;
    c) DO_CLEAN=true ;;
    r) DO_RECONFIGURE=true ;;
    h) usage; exit 0 ;;
    i) INSTALL_DIR="$(abspath $OPTARG)" ;;
    j) MAKEJ="-j$OPTARG" ;;
    p) BUILDDIR_SUBDIR=false ;;
    u) DO_UPDATE=true ;;
    d) DRYRUN=true; VERBOSE=true ;;
    s) DO_SHOW_CONFIGURE=true ;;
    v) VERBOSE=true ;;
    V) MAKE_VERBOSE="VERBOSE=1" ;;
    t) DO_RUN_TESTS=true ;;
    x) set -x ;;
    e) # recreate build.cfg.dist
       cat build.sh | sed -n '/##* Start of user configs/,/##* End of user configs/p' | sed "$ d" | sed "/Start of user configs/d" > build.cfg.dist
       exit
       ;;
    q) PREFER_DOWNLAOD=true ;;
    \?)
      echo "Invalid option: -$OPTARG" >&2
      usage >&2
      exit 1
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      usage >&2
      exit 1
      ;;
  esac
done
shift $((OPTIND-1))


if [ "$GITHUB_BASEURL" == "auto" ]; then
  GITHUB_BASEURL=$(cd $(dirname $self) && git remote -v  | grep -e "^origin.*/patmos-misc.git (push)" | sed "s/origin\s*\(.*\)\/patmos-misc.git .*/\1/")
fi
if [ -z "$GITHUB_BASEURL" ]; then
  GITHUB_BASEURL="https://github.com/t-crest"
fi

LIBEXT=so
if [ "$OS_NAME" == "Darwin" ]; then
    LIBEXT=dylib
fi

if [ "$GOLD_TARGET_ARCH" == "auto" ]; then
    if [ "$OS_NAME" != "Linux" ]; then
	GOLD_ARGS="$GOLD_ARGS --target=$TARGET"
    fi
elif [ "$GOLD_TARGET_ARCH" != "none" ]; then
    GOLD_ARGS="$GOLD_ARGS --target='$GOLD_TARGET_ARCH'"
fi

if [ "$BUILD_LTO" == "true" ]; then
    golddir=$(get_repo_dir gold)
    LLVM_CMAKE_ARGS="$LLVM_CMAKE_ARGS -DLLVM_BINUTILS_INCDIR=$ROOT_DIR/$golddir/include"
    LLVM_CONFIGURE_ARGS="$LLVM_CONFIGURE_ARGS --with-binutils-include=$ROOT_DIR/$golddir/include"
    GOLD_ARGS="$GOLD_ARGS --enable-plugins"
    NEWLIB_AR=patmos-ar
    NEWLIB_RANLIB=patmos-ranlib
else
    NEWLIB_AR=patmos-llvm-ar
    NEWLIB_RANLIB=patmos-llvm-ranlib
fi

if [ ! -z "$CLANG_COMPILER" ]; then
    clang=$(which $CLANG_COMPILER 2>/dev/null || echo -n "")
    if [ -x "$clang" ]; then
	if $clang -v 2>&1 | grep 'clang version 3.0' > /dev/null; then
	    echo "Clang version >= 3.1 required!"
	else
	    LLVM_CMAKE_ARGS="$LLVM_CMAKE_ARGS -DCMAKE_C_COMPILER=$CLANG_COMPILER -DCMAKE_CXX_COMPILER=$CLANG_COMPILER++"
	    PASIM_ARGS="$PASIM_ARGS -DCMAKE_C_COMPILER=$CLANG_COMPILER -DCMAKE_CXX_COMPILER=$CLANG_COMPILER++"
	fi
    else
	echo "Clang $clang is not executable, igored!"
    fi
fi

if [ ! -z "$BENCH_GCC_C_TORTURE_PATH" ]; then
  BENCH_ARGS="-DGCC_C_TORTURE_EXECUTE_PATH='$BENCH_GCC_C_TORTURE_PATH' $BENCH_ARGS"
fi

if [ "$INSTALL_RPATH" == "build" ]; then
    LLVM_LDFLAGS="$LLVM_LDFLAGS -Wl,-R${INSTALL_DIR}/lib"
fi

if [ "$BUILD_SOFTFLOAT" != "true" ]; then
    NEWLIB_ARGS="--disable-newlib-io-float $NEWLIB_ARGS"
fi

mkdir -p "${INSTALL_DIR}"

if [ "$DO_RUN_ALL" == "true" ]; then
	TARGETS=$ALLTARGETS
	echo "** Building all targets (-a): $TARGETS"
else
	TARGETS=${@-$TOOLCHAIN2_TARGETS}
	echo "** Building targets: $TARGETS"
fi
for target in $TARGETS; do
build_target $target
done