#!/bin/bash

SCRIPT_NAME="$(basename "$0")"
SCRIPT_DIR="$(cd $(dirname "$0"); pwd)"
INVOCATION_DIR="$(pwd)"

# Things we want to build
HOST_LIBS="gmp mpfr mpc"
TOOLS="binutils gcc"

ALL_GNU_TOOLS="ar as gcc ld nm objcopy objdump ranlib readelf"

# Extra tools to build when targeting "*-none" platforms
TOOLS_none="gdb"
SUPPORTED_OSES="none linux fuchsia darwin"
SUPPORTED_ARCHES="arm aarch64 x86_64"

### Start of configuration options
## In the configuration options below, all arch/os suffixes relate to the
## target. e.g., "CONFIG_GCC_fuchsia" provides options that should be
## used when building executables that will run on fuchsia, regardless
## of the architecture. "CONFIG_GCC_aarch64_fuchsia" would give options that
## should be used when building executables that will run on aarch64-fuchsia.
## Uses ':' as an option delimiter, to facilitate the use of spaces inside
## some options (e.g., CFLAGS).
# GMP
CONFIG_GMP_fuchsia="--with-pic=yes"

# MPFR
CONFIG_MPFR="--with-pic=yes: \
             --with-gmp="

# MPC
CONFIG_MPC="--with-gmp=: \
            --with-mpfr="

# BINUTILS
CONFIG_BINUTILS="--with-included-gettext: \
                 --disable-werror: \
                 --enable-initfini-array"
CONFIG_BINUTILS_none="--enable-gold"
CONFIG_BINUTILS_x86_64_fuchsia="--enable-gold=default"
CONFIG_BINUTILS_aarch64_fuchsia="--enable-gold"
CONFIG_BINUTILS_fuchsia="--enable-plugins: \
                         --enable-relro"
CONFIG_BINUTILS_x86_64_none="--enable-targets=x86_64-pep"

# GDB
CONFIG_GDB="--with-included-gettext:--disable-werror"
CONFIG_GDB_aarch64_none="--enable-targets=arm-eabi"

# GCC
CONFIG_GCC="--with-included-gettext: \
            --disable-werror: \
            --enable-languages=c,c++:\
            --with-gmp=: \
            --with-mpfr=: \
            --with-mpc="
CONFIG_GCC_none="--disable-libstdcxx: \
                 --disable-libssp: \
                 --disable-libquadmath"
CONFIG_GCC_fuchsia="--enable-default-pie: \
                    --disable-multilib"
CONFIG_GCC_arm="--with-cpu=arm926ej-s: \
                --with-fpu=vfp"
CONFIG_GCC_TOOLS_llvm="CXXFLAGS=-fbracket-depth=1024 -g -O2"
### End of configuration options


usage()
{
  echo "Usage: $SCRIPT_NAME [OPTION]..."
  echo "Build a set of compiler tools."
  echo "Options:"
  echo "  --force             Build even if configuration is not supported."
  echo "  --help              Produce this message"
  echo "  --host <ARCH-OS>    Specify type of host where the tools will run."
  echo "                      (default is to use the current build machine)"
  echo "  -j <#>              Specify number of parallel build instances"
  echo "  --list-supported    List all supported configurations and exit"
  echo "  --make-link <LINK>  Create a link in the current directory to the"
  echo "                      installation directory"
  echo "  --outdir <DIR>      Generate output in specified directory"
  echo "  --strip             Strip all binaries"
  echo "  --sysroot <DIR>     Specify the location of the sysroot to be"
  echo "                      used for non-native builds" 
  echo "  --target <ARCH-OS>  Specify type of target the tools will generate"
  echo "                      code for"
}

die()
{
  echo "$SCRIPT_NAME: $1" >&2
  shift
  while [ ! -z "$1" ]
  do
    echo "$1" >&2
    shift
  done
  exit 1
}

gather_host_info()
{
  # Determine build machine attributes
  BUILD_ARCH="$(uname -m)"
  BUILD_OS="$(uname | tr '[:upper:]' '[:lower:]')"
  BUILD="$BUILD_ARCH-$BUILD_OS"

  case "$BUILD_OS" in
    linux)
      PARALLEL_BUILDS="$(grep processor /proc/cpuinfo | wc -l)"
      ;;
    darwin)
      PARALLEL_BUILDS="$(sysctl -n hw.ncpu)"
      ;;
    # No fallback case needed - we'll just build with "-j".
  esac

  if cc --version | grep -q "LLVM"
  then
    HOST_TOOLS="llvm"
  fi
}

verify_arch_os_tuple()
{
  tuple_to_check="$1"

  for arch in $SUPPORTED_ARCHES
  do
    for os in $SUPPORTED_OSES
    do
      if [ "$arch-$os" == "$tuple_to_check" ]
      then
        return
      fi
    done
  done

  die "Unrecognized arch-os pair '$tuple_to_check'" \
      "Use --list-supported to show all supported configurations"
}

split_arch_os()
{
  local tuple="$1"

  RESULT_ARCH="$(echo "$tuple" | sed -E -e 's/([^-]+)-[^-]+$/\1/')"
  RESULT_OS="$(echo "$tuple" | sed -E -e 's/[^-]+-([^-]+)$/\1/')"
}

is_configuration_supported()
{
  split_arch_os "$TARGET"
  local target_arch="$RESULT_ARCH"
  local target_os="$RESULT_OS"

  if [ "$BUILD" == "$HOST" ]
  then
    # Simple (not Canadian) cross-compiler
    if [ "$target_os" == "none" ] || [ "$target_os" == "fuchsia" ]
    then
      return 0
    fi
  elif [ "$HOST" == "$TARGET" ] && [ "$target_os" == "fuchsia" ]
  then
    # Build a natively-running fuchsia compiler
    if [ "$target_arch" == "arm" ]
    then
      # ARM native builds don't work at the moment -- we need
      # synchronization primitive support for pre-v6 architectures.
      return 1
    fi
    return 0
  fi
  return 1
}

list_all_supported()
{
  local host_arch
  local host_os
  local target_arch
  local target_os

  for host_arch in $SUPPORTED_ARCHES
  do
    for host_os in $SUPPORTED_OSES
    do
      for target_arch in $SUPPORTED_ARCHES
      do
        for target_os in $SUPPORTED_OSES
        do
          HOST="$host_arch-$host_os"
          TARGET="$target_arch-$target_os"
          if is_configuration_supported
          then
            echo "  $HOST -> $TARGET"
          fi
        done
      done
    done
  done
}

get_argument()
{
  if echo "$1" | grep -q "="
  then
    RESULT=$(echo "$1" | sed -E -e 's/^[^=]+.*=//')
  else
    if [ -z "$2" ]
    then
      die "Argument required for option '$1'"
    fi
    SKIP_EXTRA_ARG="yes"
    RESULT="$2"
  fi
}

process_opts()
{
  local force=""

  # Set defaults
  OUT_DIR="$INVOCATION_DIR"
  HOST="$BUILD"
  MAKE_LINK=""
  STRIP=""

  while [ ! -z "$1" ]
  do
    SKIP_EXTRA_ARG=""
    case "$1" in
      --force)
        force="yes"
        ;;
      --help)
        usage
        exit 0
        ;;
      --host | --host=*)
        get_argument $*
        HOST="$RESULT"
        verify_arch_os_tuple "$HOST"
        ;;
      -j | -j=*)
        get_argument $*
        NUM_PARALLEL_BUILDS="$RESULT"
        ;;
      --list-supported)
        echo "All supported configurations are (host -> target):"
        list_all_supported
        exit 0
        ;;
      --make-link | --make-link=*)
        get_argument $*
        MAKE_LINK="$RESULT"
        ;;
      --outdir | --outdir=*)
        get_argument $*
        OUT_DIR="$RESULT"
        ;;
      --strip)
        STRIP="yes"
        ;;
      --sysroot | --sysroot=*)
        get_argument $*
        SYSROOT="$RESULT"
        [ -d "$SYSROOT" ] || \
          die "Sysroot directory $SYSROOT does not appear to exist"
        ;;
      --target | --target=*)
        get_argument $*
        TARGET="$RESULT"
        verify_arch_os_tuple "$TARGET"
        ;;
      *)
        die "Unrecognized option '$1'. Use '--help' for usage."
        ;;
    esac
    shift
    if [ -n "$SKIP_EXTRA_ARG" ]
    then
      shift
    fi
  done

  # Post-processing
  if [ -z "$TARGET" ]
  then
    die "--target required"
  fi

  if ! is_configuration_supported && [ -z "$force" ]
  then
    die "Configuration not supported. Use --force to try anyway."
  fi

  if [ -z "$SYSROOT" ] && [ -z "$force" ]
  then
    if [ "$BUILD" != "$HOST" ]
    then
      die "Sysroot expected when host differs from build system. Use --force to try anyway."
    fi

    split_arch_os "$TARGET"
    local target_os="$RESULT_OS"
    if [ "$BUILD" != "$TARGET" ] && [ "$target_os" != "none" ]
    then
      die "Sysroot expected when target OS differs build OS. Use --force to try anyway."
    fi
  fi

  mkdir -p "$OUT_DIR" || die "Unable to create directory $OUT_DIR"
  ARCHIVE_DIR="$OUT_DIR/archives"
  mkdir -p "$ARCHIVE_DIR" || die "Unable to create directory $ARCHIVE_DIR"
}

get_tool_verinfo()
{
  . ${SCRIPT_DIR}/toolvers
  GNU_MIRROR="https://mirrors.kernel.org/gnu"
  BINUTILS_REPO="$GNU_MIRROR/binutils/binutils-$BINUTILS_VER.tar.bz2"
  GCC_REPO="$GNU_MIRROR/gcc/gcc-$GCC_VER/gcc-$GCC_VER.tar.bz2"
  GDB_REPO="$GNU_MIRROR/gdb/gdb-$GDB_VER.tar.xz"
  GMP_REPO="$GNU_MIRROR/gmp/gmp-$GMP_VER.tar.bz2"
  MPC_REPO="$GNU_MIRROR/mpc/mpc-$MPC_VER.tar.gz"
  MPFR_REPO="$GNU_MIRROR/mpfr/mpfr-$MPFR_VER.tar.bz2"
}

get_component_attribute()
{
  local component="$1"
  local suffix="$2"
  local component_uppercase="$(echo "$component" \
                             | tr '[:lower:]' '[:upper:]')"
  local var_name="${component_uppercase}_${suffix}"

  RESULT="${!var_name}"
}

# See if there are any additional tools specified with TOOLS_<arch> or
# TOOLS_<os>
build_tool_list()
{
  split_arch_os "$TARGET"
  local target_arch="$RESULT_ARCH"
  local target_os="$RESULT_OS"

  RESULT="$TOOLS"
  local arch_specific_var_name="TOOLS_${target_arch}"
  if [ ! -z "${!arch_specific_var_name}" ]
  then
    RESULT="$RESULT ${!arch_specific_var_name}"
  fi
  local os_specific_var_name="TOOLS_${target_os}"
  if [ ! -z "${!os_specific_var_name}" ]
  then
    RESULT="$RESULT ${!os_specific_var_name}"
  fi
}

maybe_download_sources()
{
  build_tool_list
  local all_tools="$RESULT"
  local component
  for component in $all_tools $HOST_LIBS
  do
    get_component_attribute "$component" "REPO"
    local component_repo="$RESULT"
    local component_tarfile="$(basename "$component_repo")"
    get_component_attribute "$component" "VER"
    local component_ver="$RESULT"
    local component_source_dir="$OUT_DIR/$component-$component_ver"
    if [ ! -f "$component_source_dir/.extracted" ]
    then
      # Download tarfile
      if [ ! -f "$ARCHIVE_DIR/$component_tarfile" ]
      then
        echo "Fetching $component-$component_ver"
        wget -P "$ARCHIVE_DIR" -N "$component_repo" \
          || die "Failed to retrieve from $component_repo"
      fi

      echo "Checking $component_tarfile integrity"
      get_component_attribute "$component" "HASH"
      local component_hash="$RESULT"
      [ "$(shasum -a 256 -b "$ARCHIVE_DIR/$component_tarfile" \
           | cut -f1 -d' ')" \
        == "$component_hash" ] || \
        die "$component_tarfile failed integrity check"

      echo "Extracting $component_tarfile"
      pushd "$OUT_DIR" > /dev/null || die "Unable to change to $OUT_DIR"
      rm -rf "$component_source_dir" \
        || die "Failed removing $component_source_dir"
      tar xf "$ARCHIVE_DIR/$component_tarfile" \
        || die "Failed extracting $component_tarfile"

      local patch_filename="$SCRIPT_DIR/patches/${component}-patch.txt"
      if [ -f "$patch_filename" ]
      then
        echo "Patching $component"
        local src_dir="${component}-${component_ver}"
        patch -d "${src_dir}" -p1 < "$patch_filename" \
          || die "Failed to patch '${src_dir}'"
      fi

      touch "${component_source_dir}/.extracted" \
        || die "Failed to create ${component_source_dir}/.extracted"
      popd > /dev/null || die "popd failed"
    fi
  done
}

get_build_dir()
{
  local component="$1"

  get_component_attribute "$component" "VER"
  local component_ver="$RESULT"
  if [ "$HOST" == "$TARGET" ]
  then
    RESULT="$OUT_DIR/build/${component}-${component_ver}_${HOST}"
  else
    RESULT="$OUT_DIR/build/${component}-${component_ver}_${HOST}_to_${TARGET}"
  fi
}

# Determine where the tools will be installed.
get_install_dir()
{
  canonicalize_target_name "$TARGET"
  local normalized_target="$RESULT"

  get_component_attribute "gcc" "VER"
  local gcc_ver="$RESULT"

  if [ "$HOST" == "$TARGET" ]
  then
    RESULT="$OUT_DIR/$normalized_target-$gcc_ver-native"
  else
    canonicalize_target_name "$HOST"
    local normalized_host="$RESULT"
    split_arch_os "$normalized_host"
    local normalized_host_arch="$RESULT_ARCH"
    # The output dir has an uppercase OS name.
    local normalized_host_os="$(echo ${RESULT_OS:0:1} | tr '[:lower:]' '[:upper:]')${RESULT_OS:1}"
    RESULT="$OUT_DIR/$normalized_target-$gcc_ver-$normalized_host_os-$normalized_host_arch"
  fi
}

get_host_lib_install_dir()
{
  local lib_name="$1"

  get_component_attribute "$lib_name" "VER"
  local lib_ver="$RESULT"
  RESULT="$OUT_DIR/host_libs/${HOST}/${lib_name}-${lib_ver}"
}

init_config_options()
{
  CONFIG_OPTIONS="$(echo "$*" | sed -E -e 's/ +/ /g')"
}

add_config_options()
{
  local config_var_name="CONFIG_$1"
  if [ ! -z "${!config_var_name}" ]
  then
    if [ -z "$CONFIG_OPTIONS" ]
    then
      CONFIG_OPTIONS="${!config_var_name}"
    else
      CONFIG_OPTIONS="${CONFIG_OPTIONS}:${!config_var_name}"
    fi
    CONFIG_OPTIONS=$(echo "${CONFIG_OPTIONS}" \
                     | sed -E -e "s/[ \t\n]*:[ \t\n]*/:/g")
  fi
}

fix_lib_configs()
{
  for host_lib in $HOST_LIBS
  do
    get_host_lib_install_dir "$host_lib"
    local install_dir="$RESULT"
    local escaped_dir="$(echo "$install_dir" | sed -E -e 's/\//\\\//g')"
    CONFIG_OPTIONS="$(echo $CONFIG_OPTIONS \
                    | sed -E -e "s/(--with-${host_lib}=)/\1${escaped_dir}/g")"
  done
}

# Add a flag into the configuration options. If the flag is already present
# in the configuration option string, inserts the value into the 
add_to_flags()
{
  local flagname="$1"
  local flagvalue="$2"

  # This test assumes that the configuration option will not be at the start
  # of the string.
  if $(echo $CONFIG_OPTIONS | grep -q ":${flagname}=")
  then
    CONFIG_OPTIONS=$(echo $CONFIG_OPTIONS \
                     | sed -E -e "s/${flagname}=/${flagname}=${flagvalue} /")
  else
    CONFIG_OPTIONS="$CONFIG_OPTIONS:${flagname}=${flagvalue}"
  fi
}

# Add extra flags needed to build as needed for the build/host/target
# combo (e.g., CFLAGS, CFLAGS_FOR_TARGET...)
add_cross_build_options()
{
  local tool
  local uppercase_tool
  if [ "$BUILD" != "$HOST" ]
  then
    add_to_flags "CC_FOR_BUILD" "gcc"
  fi

  if [ "$BUILD" != "$TARGET" ]
  then
    if ! [ -z "$SYSROOT" ]
    then
      CONFIG_OPTIONS="$CONFIG_OPTIONS:--with-sysroot=${SYSROOT}"
    fi
    # Specify target-specific tools. Surprisingly, when gcc builds
    # libgcc if these aren't specified it will use the unprefixed
    # tools even if the prefixed tools are in the PATH.
    local tool
    for tool in $ALL_GNU_TOOLS
    do
      uppercase_tool="$(echo "$tool" | tr '[:lower:]' '[:upper:]')"
      add_to_flags "${uppercase_tool}_FOR_TARGET" "${TARGET}-${tool}"
    done
    add_to_flags "CC_FOR_TARGET" "${TARGET}-gcc"
    add_to_flags "CXX_FOR_TARGET" "${TARGET}-g++"
  fi
}

# Build the configuration options for a specific module, including relevant
# environment variables of the forms:
#   CONFIG_<module>
#   CONFIG_<module>_<arch>
#   CONFIG_<module>_<os>
#   CONFIG_<module>_<arch>_<os>
#   CONFIG_<module>_TOOLS_<host-tools>
build_config_options()
{
  local component="$1"
  local is_host_lib="$2"
  local install_dir="$3"

  local uppercase_component="$(echo "$component" \
                               | tr '[:lower:]' '[:upper:]')"

  split_arch_os "$TARGET"
  local target_arch="$RESULT_ARCH"
  local target_os="$RESULT_OS"

  init_config_options "--prefix=$install_dir"
  if [ "$HOST" != "$BUILD" ]
  then
    canonicalize_target_name "$HOST"
    CONFIG_OPTIONS="$CONFIG_OPTIONS:--host=${RESULT}"
  fi
  if [ "$TARGET" != "$HOST" ] && [ "$is_host_lib" == '0' ]
  then
    canonicalize_target_name "$TARGET"
    CONFIG_OPTIONS="$CONFIG_OPTIONS:--target=${RESULT}"
  fi
  add_config_options "$uppercase_component"
  add_config_options "${uppercase_component}_${target_arch}"
  add_config_options "${uppercase_component}_${target_os}"
  add_config_options "${uppercase_component}_${target_arch}_${target_os}"

  # Apply options that are specific to the host compiler, if we will
  # be using it (if we're doing a cross-compilation then we are
  # using a compiler that we built, and these options aren't relevant).
  if [ "$HOST" == "$BUILD" ] && [ ! -z "$HOST_TOOLS" ]
  then
    add_config_options "${uppercase_component}_TOOLS_${HOST_TOOLS}"
  fi

  # Fix references to libraries (gmp, etc.)
  fix_lib_configs

  # Indicate location of sysroot
  if [ "$is_host_lib" == "0" ] # || [ "$BUILD" != "$HOST" ]
  then
    add_cross_build_options
  fi
}

canonicalize_target_name()
{
  RESULT="$(echo "$1" \
            | sed -E -e 's/arm-none/arm-eabi/' \
            | sed -E -e 's/([a-zA-Z0-9_]+)-none/\1-elf/')"
}

do_configure()
{
  local install_dir="$1"

  build_config_options "$component" "$is_host_lib" "$install_dir"
  (IFS=':' && "$OUT_DIR/${component}-${component_ver}/configure" \
              $CONFIG_OPTIONS)
  if [ "$?" != '0' ]
  then
    die "Failed to configure $component"
  fi
}

build_component()
{
  local component="$1"
  local is_host_lib="$2"

  get_component_attribute "$component" "VER"
  local component_ver="$RESULT"
  get_build_dir "$component"
  local build_dir="$RESULT"
  if [ "$is_host_lib" == "0" ]
  then
    get_install_dir
  else
    get_host_lib_install_dir "$component"
  fi
  local install_dir="$RESULT"
  if [ ! -f $build_dir/built.txt ]
  then
    mkdir -p "$build_dir" || die "Unable to create directory $build_dir"
    pushd "$build_dir" > /dev/null || die "Unable to pushd $build_dir"
    echo "Configuring $component"
    do_configure "$install_dir"
    echo "Building $component"
    make -j ${NUM_PARALLEL_BUILDS} || die "Failed to build $component"
    echo "Installing $component"
    make -j ${NUM_PARALLEL_BUILDS} install || die "Failed to install $component"
    touch built.txt || die "Failed to create $build_dir/built.txt"
    popd > /dev/null || die "Unable to popd"
  fi
}

build_components()
{
  maybe_download_sources
  get_install_dir
  local install_dir="$RESULT"

  # Mucking with the path makes configuration significantly easier.
  if [ "$BUILD" == "$HOST" ]
  then
    export PATH="$PATH:${install_dir}/bin"
  fi

  local lib
  for lib in $HOST_LIBS
  do
    build_component $lib 1
  done
  build_tool_list
  local all_tools="$RESULT"
  for tool in $all_tools
  do
    build_component $tool 0
  done

  if [ -n "$STRIP" ]
  then
    if [ "$BUILD" == "$HOST" ]
    then
      local strip_util="strip"
    else
      local strip_util="${HOST}-strip"
    fi
    local filename
    for filename in $(find "${install_dir}/bin" -type f) \
                    $(find "${install_dir}/libexec" -type f)
    do
      (file "${filename}" | grep -q ELF) && ${strip_util} "${filename}"
    done
  fi
}

gather_host_info
process_opts $*
get_tool_verinfo
if [ "$BUILD" != "$HOST" ]
then
  # First, build a BUILD->HOST cross-compiler
  ORIG_TARGET="$TARGET"
  TARGET="$HOST"
  HOST="$BUILD"
  build_components
  HOST="$TARGET"
  TARGET="$ORIG_TARGET"
fi
build_components
# In certain unnamed environments, we may need an architecture-
# independent way to find the results of a build. To help, we
# optionally create a link to the installation in the cwd.
if [ -n "$MAKE_LINK" ]
then
  get_install_dir
  ln -fns "$RESULT" "$MAKE_LINK" || die "Failed to make '$MAKE_LINK' link"
fi
exit 0