# Copyright (C) 2012 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

# A set of function shared by the 'build-host-xxxx.sh' scripts.
# They are mostly related to building host libraries.
#
# NOTE: This script uses various prefixes:
#
#    BH_       Used for public macros
#    bh_       Use for public functions
#
#    _BH_      Used for private macros
#    _bh_      Used for private functions
#
# Callers should only rely on the public macros and functions defined here.
#

# List of macros defined by the functions here:
#
#   defined by 'bh_set_build_tag'
#
#   BH_BUILD_CONFIG     Generic GNU config triplet for build system
#   BH_BUILD_OS         NDK system name
#   BH_BUILD_ARCH       NDK arch name
#   BH_BUILD_TAG        NDK system tag ($OS-$ARCH)
#   BH_BUILD_BITS       build system bitness (32 or 64)
#
#   defined by 'bh_set_host_tag'
#                          7
#   BH_HOST_CONFIG
#   BH_HOST_OS
#   BH_HOST_ARCH
#   BH_HOST_TAG
#   BH_HOST_BITS
#
#   defined by 'bh_set_target_tag'
#
#   BH_TARGET_CONFIG
#   BH_TARGET_OS
#   BH_TARGET_ARCH
#   BH_TARGET_TAG
#   BH_TARGET_BITS
#
#


# The values of HOST_OS/ARCH/TAG will be redefined during the build to
# match those of the system the generated compiler binaries will run on.
#
# Save the original ones into BUILD_XXX variants, corresponding to the
# machine where the build happens.
#
BH_BUILD_OS=$HOST_OS
BH_BUILD_ARCH=$HOST_ARCH
BH_BUILD_TAG=$HOST_TAG

# Map an NDK system tag to an OS name
# $1: system tag (e.g. linux-x86)
# Out: system name (e.g. linux)
bh_tag_to_os ()
{
    local RET
    case $1 in
        android-*) RET="android";;
        linux-*) RET="linux";;
        darwin-*) RET="darwin";;
        windows|windows-*) RET="windows";;
        *) echo "ERROR: Unknown tag $1" >&2; echo "INVALID"; exit 1;;
    esac
    echo $RET
}

# Map an NDK system tag to an architecture name
# $1: system tag (e.g. linux-x86)
# Out: arch name (e.g. x86)
bh_tag_to_arch ()
{
    local RET
    case $1 in
        *-arm) RET=arm;;
        *-arm64) RET=arm64;;
        *-mips) RET=mips;;
        *-mips64) RET=mips64;;
        windows|*-x86) RET=x86;;
        *-x86_64) RET=x86_64;;
        *) echo "ERROR: Unknown tag $1" >&2; echo "INVALID"; exit 1;;
    esac
    echo $RET
}

# Map an NDK system tag to a bit number
# $1: system tag (e.g. linux-x86)
# Out: bit number (32 or 64)
bh_tag_to_bits ()
{
    local RET
    case $1 in
        windows|*-x86|*-arm|*-mips) RET=32;;
        *-x86_64|*-arm64|*-mips64) RET=64;;
        *) echo "ERROR: Unknown tag $1" >&2; echo "INVALID"; exit 1;;
    esac
    echo $RET
}

# Map an NDK system tag to the corresponding GNU configuration triplet.
# $1: NDK system tag
# Out: GNU configuration triplet
bh_tag_to_config_triplet ()
{
    local RET
    case $1 in
        linux-x86) RET=i686-linux-gnu;;
        linux-x86_64) RET=x86_64-linux-gnu;;
        darwin-x86) RET=i686-apple-darwin;;
        darwin-x86_64) RET=x86_64-apple-darwin;;
        windows|windows-x86) RET=i686-w64-mingw32;;
        windows-x86_64) RET=x86_64-w64-mingw32;;
        android-arm) RET=arm-linux-androideabi;;
        android-arm64) RET=aarch64-linux-android;;
        android-x86) RET=i686-linux-android;;
        android-x86_64) RET=x86_64-linux-android;;
        android-mips) RET=mipsel-linux-android;;
        android-mips64) RET=mips64el-linux-android;;
        *) echo "ERROR: Unknown tag $1" >&2; echo "INVALID"; exit 1;;
    esac
    echo "$RET"
}


bh_set_build_tag ()
{
  SAVED_OPTIONS=$(set +o)
  set -e
  BH_BUILD_OS=$(bh_tag_to_os $1)
  BH_BUILD_ARCH=$(bh_tag_to_arch $1)
  BH_BUILD_BITS=$(bh_tag_to_bits $1)
  BH_BUILD_TAG=$BH_BUILD_OS-$BH_BUILD_ARCH
  BH_BUILD_CONFIG=$(bh_tag_to_config_triplet $1)
  eval "$SAVED_OPTIONS"
}

# Set default BH_BUILD macros.
bh_set_build_tag $HOST_TAG

bh_set_host_tag ()
{
  SAVED_OPTIONS=$(set +o)
  set -e
  BH_HOST_OS=$(bh_tag_to_os $1)
  BH_HOST_ARCH=$(bh_tag_to_arch $1)
  BH_HOST_BITS=$(bh_tag_to_bits $1)
  BH_HOST_TAG=$BH_HOST_OS-$BH_HOST_ARCH
  BH_HOST_CONFIG=$(bh_tag_to_config_triplet $1)
  eval "$SAVED_OPTIONS"
}

bh_set_target_tag ()
{
  SAVED_OPTIONS=$(set +o)
  set -e
  BH_TARGET_OS=$(bh_tag_to_os $1)
  BH_TARGET_ARCH=$(bh_tag_to_arch $1)
  BH_TARGET_BITS=$(bh_tag_to_bits $1)
  BH_TARGET_TAG=$BH_TARGET_OS-$BH_TARGET_ARCH
  BH_TARGET_CONFIG=$(bh_tag_to_config_triplet $1)
  eval "$SAVED_OPTIONS"
}

bh_sort_systems_build_first ()
{
  local IN_SYSTEMS="$1"
  local OUT_SYSTEMS
  # Pull out the host if there
  for IN_SYSTEM in $IN_SYSTEMS; do
    if [ "$IN_SYSTEM" = "$BH_BUILD_TAG" ]; then
        OUT_SYSTEMS=$IN_SYSTEM
    fi
  done
  # Append the rest
  for IN_SYSTEM in $IN_SYSTEMS; do
    if [ ! "$IN_SYSTEM" = "$BH_BUILD_TAG" ]; then
        OUT_SYSTEMS=$OUT_SYSTEMS" $IN_SYSTEM"
    fi
  done
  echo $OUT_SYSTEMS
}

# $1 is the string to search for
# $2... is the list to search in
# Returns first, yes or no.
bh_list_contains ()
{
  local SEARCH="$1"
  shift
  # For dash, this has to be split over 2 lines.
  # Seems to be a bug with dash itself:
  # https://bugs.launchpad.net/ubuntu/+source/dash/+bug/141481
  local LIST
  LIST=$@
  local RESULT=first
  # Pull out the host if there
  for ELEMENT in $LIST; do
    if [ "$ELEMENT" = "$SEARCH" ]; then
      echo $RESULT
      return 0
    fi
    RESULT=yes
  done
  echo no
  return 1
}


# Use this function to enable/disable colored output
# $1: 'true' or 'false'
bh_set_color_mode ()
{
  local DO_COLOR=
  case $1 in
    on|enable|true) DO_COLOR=true
    ;;
  esac
  if [ "$DO_COLOR" ]; then
    _BH_COLOR_GREEN="\033[32m"
    _BH_COLOR_PURPLE="\033[35m"
    _BH_COLOR_CYAN="\033[36m"
    _BH_COLOR_END="\033[0m"
  else
    _BH_COLOR_GREEN=
    _BH_COLOR_PURPLE=
    _BH_COLOR_CYAN=
    _BH_COLOR_END=
  fi
}

# By default, enable color mode
bh_set_color_mode true

# Pretty printing with colors!
bh_host_text ()
{
    printf "[${_BH_COLOR_GREEN}${BH_HOST_TAG}${_BH_COLOR_END}]"
}

bh_toolchain_text ()
{
    printf "[${_BH_COLOR_PURPLE}${BH_TOOLCHAIN}${_BH_COLOR_END}]"
}

bh_target_text ()
{
    printf "[${_BH_COLOR_CYAN}${BH_TARGET_TAG}${_BH_COLOR_END}]"
}

bh_arch_text ()
{
    # Print arch name in cyan
    printf "[${_BH_COLOR_CYAN}${BH_TARGET_ARCH}${_BH_COLOR_END}]"
}

# Check that a given compiler generates code correctly
#
# This is to detect bad/broken toolchains, e.g. amd64-mingw32msvc
# is totally broken on Ubuntu 10.10 and 11.04
#
# $1: compiler
# $2: optional extra flags
#
bh_check_compiler ()
{
    local CC="$1"
    local TMPC=$TMPDIR/build-host-$USER-$$.c
    local TMPE=${TMPC%%.c}
    local TMPL=$TMPC.log
    local RET
    shift
    cat > $TMPC <<EOF
int main(void) { return 0; }
EOF
    log_n "Checking compiler code generation ($CC)... "
    $CC -o $TMPE $TMPC "$@" >$TMPL 2>&1
    RET=$?
    rm -f $TMPC $TMPE $TMPL
    if [ "$RET" = 0 ]; then
        log "yes"
    else
        log "no"
    fi
    return $RET
}


# $1: toolchain install dir
# $2: toolchain prefix, no trailing dash (e.g. arm-linux-androideabi)
# $3: optional -m32 or -m64.
_bh_try_host_fullprefix ()
{
    local PREFIX="$1/bin/$2"
    shift; shift;
    if [ -z "$HOST_FULLPREFIX" ]; then
        local GCC="$PREFIX-gcc"
        if [ -f "$GCC" ]; then
            if bh_check_compiler "$GCC" "$@"; then
                HOST_FULLPREFIX="${GCC%%gcc}"
                dump "$(bh_host_text) Using host gcc: $GCC $@"
            else
                dump "$(bh_host_text) Ignoring broken host gcc: $GCC $@"
            fi
        fi
    fi
}

# $1: host prefix, no trailing slash (e.g. i686-linux-android)
# $2: optional compiler args (should be empty, -m32 or -m64)
_bh_try_host_prefix ()
{
    local PREFIX="$1"
    shift
    if [ -z "$HOST_FULLPREFIX" ]; then
        local GCC="$(which $PREFIX-gcc 2>/dev/null)"
        if [ "$GCC" -a -e "$GCC" ]; then
            if bh_check_compiler "$GCC" "$@"; then
                HOST_FULLPREFIX=${GCC%%gcc}
                dump "$(bh_host_text) Using host gcc: ${HOST_FULLPREFIX}gcc $@"
            else
                dump "$(bh_host_text) Ignoring broken host gcc: $GCC $@"
            fi
        fi
    fi
}

# Used to determine the minimum possible Darwin version that a Darwin SDK
# can target. This actually depends from the host architecture.
# $1: Host architecture name
# out: SDK version number (e.g. 10.4 or 10.5)
_bh_darwin_arch_to_min_version ()
{
  if [ "$1" = "x86" ]; then
    echo "10.4"
  else
    echo "10.5"
  fi
}

# Use the check for the availability of a compatibility SDK in Darwin
# this can be used to generate binaries compatible with either Tiger or
# Leopard.
#
# $1: SDK root path
# $2: Darwin compatibility minimum version
_bh_check_darwin_sdk ()
{
    if [ -d "$1" -a -z "$HOST_CFLAGS" ] ; then
        HOST_CFLAGS="-isysroot $1 -mmacosx-version-min=$2 -DMAXOSX_DEPLOYEMENT_TARGET=$2"
        HOST_CXXFLAGS=$HOST_CFLAGS
        HOST_LDFLAGS="-syslibroot $1 -mmacosx-version-min=$2"
        dump "Generating $2-compatible binaries."
        return 0  # success
    fi
    return 1
}

# Check that a given compiler generates 32 or 64 bit code.
# $1: compiler full path (.e.g  /path/to/fullprefix-gcc)
# $2: 32 or 64
# $3: extract compiler flags
# Return: success iff the compiler generates $2-bits code
_bh_check_compiler_bitness ()
{
    local CC="$1"
    local BITS="$2"
    local TMPC=$TMPDIR/build-host-gcc-bits-$USER-$$.c
    local TMPL=$TMPC.log
    local RET
    shift; shift;
    cat > $TMPC <<EOF
/* this program will fail to compile if the compiler doesn't generate BITS-bits code */
int tab[1-2*(sizeof(void*)*8 != BITS)];
EOF
    dump_n "$(bh_host_text) Checking that the compiler generates $BITS-bits code ($@)... "
    $CC -c -DBITS=$BITS -o /dev/null $TMPC $HOST_CFLAGS "$@" > $TMPL 2>&1
    RET=$?
    rm -f $TMPC $TMPL
    if [ "$RET" = 0 ]; then
        dump "yes"
    else
        dump "no"
    fi
    return $RET
}

# This function probes the system to find the best toolchain or cross-toolchain
# to build binaries that run on a given host system. After that, it generates
# a wrapper toolchain under $2 with a prefix of ${BH_HOST_CONFIG}-
# where $BH_HOST_CONFIG is a GNU configuration name.
#
# Important: this script might redefine $BH_HOST_CONFIG to a different value!
# (This behavior previously happened with MinGW, but doesn't anymore.)
#
# $1: NDK system tag (e.g. linux-x86)
#
# The following can be defined, otherwise they'll be auto-detected and set.
#
#  DARWIN_MIN_VERSION   -> Darwmin minimum compatibility version
#  DARWIN_SDK_VERSION   -> Darwin SDK version
#
# The following can be defined for extra features:
#
#  DARWIN_TOOLCHAIN     -> Path to Darwin cross-toolchain (cross-compile only).
#  DARWIN_SYSROOT       -> Path to Darwin SDK sysroot (cross-compile only).
#  ANDROID_NDK_ROOT     -> Top-level NDK directory, for automatic probing
#                          of prebuilt platform toolchains.
#
_bh_select_toolchain_for_host ()
{
    local HOST_CFLAGS HOST_CXXFLAGS HOST_LDFLAGS
    local HOST_ASFLAGS HOST_WINDRES_FLAGS
    local HOST_FULLPREFIX
    local DARWIN_ARCH DARWIN_SDK_SUBDIR

    # We do all the complex auto-detection magic in the setup phase,
    # then save the result in host-specific global variables.
    #
    # In the build phase, we will simply restore the values into the
    # global HOST_FULLPREFIX / HOST_BUILD_DIR
    # variables.
    #

    # Try to find the best toolchain to do that job, assuming we are in
    # a full Android platform source checkout, we can look at the prebuilts/
    # directory.
    case $1 in
        linux-x86)
            panic "Sorry, this script does not support building 32-bit Linux binaries."
            ;;

        linux-x86_64)
            local LINUX_GLIBC_PREBUILT=x86_64-linux-glibc2.15-4.8
            _bh_try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/$LINUX_GLIBC_PREBUILT" x86_64-linux
            if [ -z "$HOST_FULLPREFIX" ]; then
                dump "Cannot find the x86_64 Linux-targeting compiler. Make sure the"
                dump "$LINUX_GLIBC_PREBUILT prebuilt is checked out."
                exit 1
            fi
            ;;

        darwin-*)
            DARWIN_ARCH=$(bh_tag_to_arch $1)
            if [ -z "$DARWIN_MIN_VERSION" ]; then
                DARWIN_MIN_VERSION=$(_bh_darwin_arch_to_min_version $DARWIN_ARCH)
            fi
            case $BH_BUILD_OS in
                darwin)
                    if [ "$DARWIN_SDK_VERSION" ]; then
                        # Compute SDK subdirectory name
                        case $DARWIN_SDK_VERSION in
                            10.4) DARWIN_SDK_SUBDIR=$DARWIN_SDK.sdku;;
                            *) DARWIN_SDK_SUBDIR=$DARWIN_SDK.sdk;;
                        esac
                        # Since xCode moved to the App Store the SDKs have been 'sandboxed' into the Xcode.app folder.
                        _bh_check_darwin_sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX$DARWIN_SDK_SUBDIR $DARWIN_MIN_VERSION
                        _bh_check_darwin_sdk /Developer/SDKs/MacOSX$DARWIN_SDK_SUBDIR $DARWIN_MIN_VERSION
                    else
                        # Since xCode moved to the App Store the SDKs have been 'sandboxed' into the Xcode.app folder.
                        _bh_check_darwin_sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk $DARWIN_MIN_VERSION
                        _bh_check_darwin_sdk /Developer/SDKs/MacOSX10.7.sdk  $DARWIN_MIN_VERSION
                        _bh_check_darwin_sdk /Developer/SDKs/MacOSX10.6.sdk  $DARWIN_MIN_VERSION
                        # NOTE: The 10.5.sdk on Lion is buggy and cannot build basic C++ programs
                        #_bh_check_darwin_sdk /Developer/SDKs/MacOSX10.5.sdk  $DARWIN_ARCH
                        # NOTE: The 10.4.sdku is not available anymore and could not be tested.
                        #_bh_check_darwin_sdk /Developer/SDKs/MacOSX10.4.sdku $DARWIN_ARCH
                    fi
                    if [ -z "$HOST_CFLAGS" ]; then
                        local version="$(sw_vers -productVersion)"
                        log "Generating $version-compatible binaries!"
                    fi
                    ;;
                *)
                    if [ -z "$DARWIN_TOOLCHAIN" -o -z "$DARWIN_SYSROOT" ]; then
                        dump "If you want to build Darwin binaries on a non-Darwin machine,"
                        dump "Please define DARWIN_TOOLCHAIN to name it, and DARWIN_SYSROOT to point"
                        dump "to the SDK. For example:"
                        dump ""
                        dump "   DARWIN_TOOLCHAIN=\"i686-apple-darwin11\""
                        dump "   DARWIN_SYSROOT=\"~/darwin-cross/MacOSX10.7.sdk\""
                        dump "   export DARWIN_TOOLCHAIN DARWIN_SYSROOT"
                        dump ""
                        exit 1
                    fi
                    _bh_check_darwin_sdk $DARWIN_SYSROOT $DARWIN_MIN_VERSION
                    _bh_try_host_prefix "$DARWIN_TOOLCHAIN" -m$(bh_tag_to_bits $1) --sysroot "$DARWIN_SYSROOT"
                    if [ -z "$HOST_FULLPREFIX" ]; then
                        dump "It looks like $DARWIN_TOOLCHAIN-gcc is not in your path, or does not work correctly!"
                        exit 1
                    fi
                    dump "Using darwin cross-toolchain: ${HOST_FULLPREFIX}gcc"
                    ;;
            esac
            ;;

        windows|windows-x86)
            case $BH_BUILD_OS in
                linux)
                    # Prefer the prebuilt cross-compiler.
                    _bh_try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8" x86_64-w64-mingw32 -m32
                    # We favor these because they are more recent, and because
                    # we have a script to rebuild them from scratch. See
                    # build-mingw64-toolchain.sh. Typically provided by the
                    # 'mingw-w64' package on Debian and Ubuntu systems.
                    _bh_try_host_prefix i686-w64-mingw32
                    _bh_try_host_prefix x86_64-w64-mingw32 -m32
                    # Special note for Fedora: this distribution used
                    # to have a mingw32-gcc package that provided a 32-bit
                    # only cross-toolchain named i686-pc-mingw32.
                    # Later versions of the distro now provide a new package
                    # named mingw-gcc which provides i686-w64-mingw32 and
                    # x86_64-w64-mingw32 instead.
                    if [ -z "$HOST_FULLPREFIX" ]; then
                        dump "There is no Windows cross-compiler. Ensure that you"
                        dump "have one of these installed and in your path:"
                        dump "   i686-w64-mingw32-gcc    (see build-mingw64-toolchain.sh)"
                        dump "   x86_64-w64-mingw32-gcc  (see build-mingw64-toolchain.sh)"
                        dump ""
                        exit 1
                    fi
                    if [ "$BH_HOST_CONFIG" != i686-w64-mingw32 ]; then
                        panic "Unexpected value of BH_HOST_CONFIG: $BH_HOST_CONFIG"
                    fi
                    # If the 32-bit wrappers call a 64-bit toolchain, add flags
                    # to default ld/as/windres to 32 bits.
                    case "$HOST_FULLPREFIX" in
                        *x86_64-w64-mingw32-)
                            HOST_LDFLAGS="-m i386pe"
                            HOST_ASFLAGS="--32"
                            HOST_WINDRES_FLAGS="-F pe-i386"
                            ;;
                        *)
                            ;;
                    esac
                    ;;
                *) panic "Sorry, this script only supports building windows binaries on Linux."
                ;;
            esac
            HOST_CFLAGS=$HOST_CFLAGS" -D__USE_MINGW_ANSI_STDIO=1"
            HOST_CXXFLAGS=$HOST_CXXFLAGS" -D__USE_MINGW_ANSI_STDIO=1"
            ;;

        windows-x86_64)
            case $BH_BUILD_OS in
                linux)
                    # Prefer the prebuilt cross-compiler.
                    # See comments above for windows-x86.
                    _bh_try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8" x86_64-w64-mingw32
                    _bh_try_host_prefix x86_64-w64-mingw32
                    if [ -z "$HOST_FULLPREFIX" ]; then
                        dump "There is no Windows cross-compiler in your path. Ensure you"
                        dump "have one of these installed and in your path:"
                        dump "   x86_64-w64-mingw32-gcc  (see build-mingw64-toolchain.sh)"
                        dump ""
                        exit 1
                    fi
                    if [ "$BH_HOST_CONFIG" != x86_64-w64-mingw32 ]; then
                        panic "Unexpected value of BH_HOST_CONFIG: $BH_HOST_CONFIG"
                    fi
                    ;;

                *) panic "Sorry, this script only supports building windows binaries on Linux."
                ;;
            esac
            HOST_CFLAGS=$HOST_CFLAGS" -D__USE_MINGW_ANSI_STDIO=1"
            HOST_CXXFLAGS=$HOST_CXXFLAGS" -D__USE_MINGW_ANSI_STDIO=1"
            ;;
    esac

    # Determine the default bitness of our compiler. It it doesn't match
    # HOST_BITS, tries to see if it supports -m32 or -m64 to change it.
    if ! _bh_check_compiler_bitness ${HOST_FULLPREFIX}gcc $BH_HOST_BITS; then
        local TRY_CFLAGS
        case $BH_HOST_BITS in
            32) TRY_CFLAGS=-m32;;
            64) TRY_CFLAGS=-m64;;
        esac
        if ! _bh_check_compiler_bitness ${HOST_FULLPREFIX}gcc $BH_HOST_BITS $TRY_CFLAGS; then
            panic "Can't find a way to generate $BH_HOST_BITS binaries with this compiler: ${HOST_FULLPREFIX}gcc"
        fi
        HOST_CFLAGS=$HOST_CFLAGS" "$TRY_CFLAGS
        HOST_CXXFLAGS=$HOST_CXXFLAGS" "$TRY_CFLAGS
    fi

    # We're going to generate a wrapper toolchain with the $HOST prefix
    # i.e. if $HOST is 'i686-linux-gnu', then we're going to generate a
    # wrapper toolchain named 'i686-linux-gnu-gcc' that will redirect
    # to whatever HOST_FULLPREFIX points to, with appropriate modifier
    # compiler/linker flags.
    #
    # This helps tremendously getting stuff to compile with the GCC
    # configure scripts.
    #
    run mkdir -p "$BH_WRAPPERS_DIR" &&
    run $NDK_BUILDTOOLS_PATH/gen-toolchain-wrapper.sh "$BH_WRAPPERS_DIR" \
        --src-prefix="$BH_HOST_CONFIG-" \
        --dst-prefix="$HOST_FULLPREFIX" \
        --cflags="$HOST_CFLAGS" \
        --cxxflags="$HOST_CXXFLAGS" \
        --ldflags="$HOST_LDFLAGS" \
        --asflags="$HOST_ASFLAGS" \
        --windres-flags="$HOST_WINDRES_FLAGS"
}


# Setup the build directory, i.e. a directory where all intermediate
# files will be placed.
#
# $1: Build directory. Required.
#
# $2: Either 'preserve' or 'remove'. Indicates what to do of
#     existing files in the build directory, if any.
#
# $3: Either 'release' or 'debug'. Compilation mode.
#
bh_setup_build_dir ()
{
    BH_BUILD_DIR="$1"
    if [ -z "$BH_BUILD_DIR" ]; then
        panic "bh_setup_build_dir received no build directory"
    fi
    mkdir -p "$BH_BUILD_DIR"
    fail_panic "Could not create build directory: $BH_BUILD_DIR"

    if [ "$_BH_OPTION_FORCE" ]; then
        rm -rf "$BH_BUILD_DIR"/*
    fi

    if [ "$_BH_OPTION_NO_STRIP" ]; then
        BH_BUILD_MODE=debug
    else
        BH_BUILD_MODE=release
    fi

    # The directory that will contain our toolchain wrappers
    BH_WRAPPERS_DIR=$BH_BUILD_DIR/toolchain-wrappers
    rm -rf "$BH_WRAPPERS_DIR" && mkdir "$BH_WRAPPERS_DIR"
    fail_panic "Could not create wrappers dir: $BH_WRAPPERS_DIR"

    # The directory that will contain our timestamps
    BH_STAMPS_DIR=$BH_BUILD_DIR/timestamps
    mkdir -p "$BH_STAMPS_DIR"
    fail_panic "Could not create timestamps dir"
}

# Call this before anything else to setup a few important variables that are
# used consistently to build any host-specific binaries.
#
# $1: Host system name (e.g. linux-x86), this is the name of the host system
#     where the generated GCC binaries will run, not the current machine's
#     type (this one is in $ORIGINAL_HOST_TAG instead).
#
bh_setup_build_for_host ()
{
    local HOST_VARNAME=$(dashes_to_underscores $1)
    local HOST_VAR=_BH_HOST_${HOST_VARNAME}

    # Determine the host configuration triplet in $HOST
    bh_set_host_tag $1

    # Note: since _bh_select_toolchain_for_host can change the value of
    # $BH_HOST_CONFIG, we need to save it in a variable to later get the
    # correct one when this function is called again.
    if [ -z "$(var_value ${HOST_VAR}_SETUP)" ]; then
        _bh_select_toolchain_for_host $1
        var_assign ${HOST_VAR}_CONFIG $BH_HOST_CONFIG
        var_assign ${HOST_VAR}_SETUP true
    else
        BH_HOST_CONFIG=$(var_value ${HOST_VAR}_CONFIG)
    fi
}

# This function is used to setup the build environment whenever we
# generate host-specific binaries. You should call it before invoking
# a configure script or make.
#
# It assume sthat bh_setup_build_for_host was called with the right
# host system tag and wrappers directory.
#
bh_setup_host_env ()
{
    CC=$BH_HOST_CONFIG-gcc
    CXX=$BH_HOST_CONFIG-g++
    LD=$BH_HOST_CONFIG-ld
    AR=$BH_HOST_CONFIG-ar
    AS=$BH_HOST_CONFIG-as
    RANLIB=$BH_HOST_CONFIG-ranlib
    NM=$BH_HOST_CONFIG-nm
    STRIP=$BH_HOST_CONFIG-strip
    STRINGS=$BH_HOST_CONFIG-strings
    export CC CXX LD AR AS RANLIB NM STRIP STRINGS

    CFLAGS=
    CXXFLAGS=
    LDFLAGS=
    case $BH_BUILD_MODE in
        release)
            CFLAGS="-O2 -Os -fomit-frame-pointer -s"
            CXXFLAGS=$CFLAGS
            ;;
        debug)
            CFLAGS="-O0 -g"
            CXXFLAGS=$CFLAGS
            ;;
    esac
    export CFLAGS CXXFLAGS LDFLAGS

    export PATH=$BH_WRAPPERS_DIR:$PATH
}

_bh_option_no_color ()
{
    bh_set_color_mode off
}

# This function is used to register a few command-line options that
# impact the build of host binaries. Call it before invoking
# extract_parameters to add them automatically.
#
bh_register_options ()
{
    BH_HOST_SYSTEMS="$BH_BUILD_TAG"
    register_var_option "--systems=<list>" BH_HOST_SYSTEMS "Build binaries that run on these systems."

    _BH_OPTION_FORCE=
    register_var_option "--force" _BH_OPTION_FORCE "Force rebuild."

    _BH_OPTION_NO_STRIP=
    register_var_option "--no-strip" _BH_OPTION_NO_STRIP "Don't strip generated binaries."

    register_option "--no-color" _bh_option_no_color "Don't output colored text."

    if [ "$HOST_OS" = darwin ]; then
        DARWIN_SDK_VERSION=
        register_var_option "--darwin-sdk-version=<version>" DARWIN_SDK "Select Darwin SDK version."

        DARWIN_MIN_VERSION=
        register_var_option "--darwin-min-version=<version>" DARWIN_MIN_VERSION "Select minimum OS X version of generated host toolchains."
    fi
}

# Execute a given command.
#
# NOTE: The command is run in its own sub-shell to avoid environment
#        contamination.
#
# $@: command
bh_do ()
{
    ("$@")
    fail_panic
}

# Return the build install directory of a given Python version
#
# $1: host system tag
# $2: python version
# The suffix of this has to match python_ndk_install_dir
#  as I package them from the build folder, substituting
#  the end part of python_build_install_dir matching
#  python_ndk_install_dir with nothing.
python_build_install_dir ()
{
    echo "$BH_BUILD_DIR/$1/install/host-tools"
}

# Same as python_build_install_dir, but for the final NDK installation
# directory. Relative to $NDK_DIR.
#
# $1: host system tag
python_ndk_install_dir ()
{
    echo "host-tools"
}