#!/bin/sh
#
# 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.
#
# Rebuild the host GCC toolchain binaries from sources.
#
# NOTE: this script does not rebuild gdb, see build-host-gdb.sh for this.
#

# include common function and variable definitions
. `dirname $0`/prebuilt-common.sh

PROGRAM_PARAMETERS="[<toolchain-name>+]"
PROGRAM_DESCRIPTION="\
This program is used to rebuild one or more NDK cross-toolchains from scratch.
To use it, you will first need to call download-toolchain-sources.sh to download
the toolchain sources, then pass the corresponding directory with the
--toolchain-src-dir=<path> option.

If you don't pass any parameter, the script will rebuild all NDK toolchains
for the current host system [$HOST_TAG]. You can otherwise give a list of
toolchains among the following names:

  arm-linux-androideabi-4.4.3
  arm-linux-androideabi-4.6
  x64-4.4.3
  x86-4.6
  mipsel-linux-android-4.4.3
  mipsel-linux-android-4.6

By default, the script rebuilds the toolchain(s) for you host system [$HOST_TAG],
but you can use --systems=<tag1>,<tag2>,.. to ask binaries that can run on
several distinct systems. Each <tag> value in the list can be one of the
following:

   linux-x86
   linux-x86_64
   windows
   windows-x86  (equivalent to 'windows')
   windows-x86_64
   darwin-x86
   darwin-x86_64

For example, here's how to rebuild the ARM toolchains on Linux
for four different systems:

  $PROGNAME --toolchain-src-dir=/path/to/toolchain/src \
    --systems=linux-x86,linux-x86_64,windows,windows-x86_64 \
    arm-linux-androideabi-4.4.3 \
    arm-linux-androideabi-4.6

You can build Windows binaries on Linux if you have a Windows-targetting
cross-toolchain installed and in your path. Note that the script named
'build-mingw64-toolchain.sh' can be used to rebuild such a toolchain
(x86_64-w64-mingw32) from sources if you don't have one available.

Building the toolchains directly under Cygwin/MSys has not be tested and
is not recommended (it will be *extremely* slow, if it ever works).

On Darwin, the script will try to probe any compatibility SDK installed
on your development machine and will use the first it finds among a list
of well-known names. You can however force a specific usage with the
--darwin-sdk-version=<version> name, where <version> can be one of 10.4, 10.5,
10.6, 10.7, etc.

The generated binaries should run on 10.5 or higher. You can force a
different compatibility minimum with --darwin-min-version.

If you want to build Darwin binaries on a non-Darwin machine, you will
have to define DARWIN_TOOLCHAIN / DARWIN_SYSROOT in your environment first
(note: this feature is highly experimental).

The script is sufficiently clever to minimize all build steps, especially
if you try to build several toolchains for several distinct host systems. Note
however that generating a canadian-cross toolchain (e.g. building on Linux a
Windows toolchain that targets Android ARM binaries) will force the generation
of a host toolchain as well, in case it is not listed in your --systems list.
This is required to generate proper target GCC libraries.

The toolchain binaries are installed under \$NDK_DIR/toolchains by default,
but you can use --ndk-dir=<path> to specify a different NDK installation path.
The script will try to build the Gold linker for host/target combination that
are well supported (Gold doesn't build / is buggy for some of them). However,
the BFD linker is still the default used by the generated toolchain. You can
change this behaviour with two options:

   --default-ld=<name>  Changes the default toolchain linker.
                        <name> can be one of 'default', 'bfd' and 'gold'.

                        For now, 'default' is an alias for 'bfd', but we plan
                        to map it to 'gold' for some combos in the future, once
                        we're confident it works reliably

   --force-gold-build   Force the build of the Gold linker, even if it is known
                        to fail or generate a buggy linker. Only use this for
                        experimentation (e.g. with your own patched toolchain
                        sources).
"

BINUTILS_VERSION=$DEFAULT_BINUTILS_VERSION
register_var_option "--binutils-version=<version>" BINUTILS_VERSION "Select binutils version"

GMP_VERSION=$DEFAULT_GMP_VERSION
register_var_option "--gmp-version=<version>" GMP_VERSION "Select gmp version"

MPFR_VERSION=$DEFAULT_MPFR_VERSION
register_var_option "--mpfr-version=<version>" MPFR_VERSION "Select mpfr version"

MPC_VERSION=$DEFAULT_MPC_VERSION
register_var_option "--mpc-version=<version>" MPC_VERSION "Select mpc version"

TOOLCHAIN_SRC_DIR=
register_var_option "--toolchain-src-dir=<path>" TOOLCHAIN_SRC_DIR "Select toolchain source directory"

NDK_DIR=$ANDROID_NDK_ROOT
register_var_option "--ndk-dir=<path>" NDK_DIR "Select NDK install directory"

BUILD_DIR=
register_var_option "--build-dir=<path>" BUILD_DIR "Build GCC into directory"

PACKAGE_DIR=
register_var_option "--package-dir=<path>" PACKAGE_DIR "Package prebuilt tarballs into directory"

HOST_SYSTEMS="$HOST_TAG"
register_var_option "--systems=<list>" HOST_SYSTEMS "Build binaries for these host systems"

FORCE=
register_var_option "--force" FORCE "Force full rebuild"

NO_TARGET_LIBS=
register_var_option "--no-target-libs" NO_TARGET_LIBS "Don't build gcc target libs."

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

NO_COLOR=
register_var_option "--no-color" 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

DEFAULT_LD=
register_var_option "--default-ld=<name>" DEFAULT_LD "Select default linker ('bfd' or 'gold')."

FORCE_GOLD_BUILD=
register_var_option "--force-gold-build" FORCE_GOLD_BUILD "Always try to build Gold (experimental)."

register_jobs_option


extract_parameters "$@"

TOOLCHAINS=$PARAMETERS
if [ -z "$TOOLCHAINS" ]; then
    TOOLCHAINS="arm-linux-androideabi-4.6,x86-4.6,mipsel-linux-android-4.6"
    dump "Auto-config: $TOOLCHAINS"
fi

if [ -z "$TOOLCHAIN_SRC_DIR" ]; then
    panic "Please use --toolchain-src-dir=<path> to select toolchain source directory."
fi

if [ -z "$BUILD_DIR" ]; then
    BUILD_DIR=/tmp/ndk-$USER/build/host-gcc
fi

case $DEFAULT_LD in
    gold|bfd)
      ;;
    "")
      # We always use the default gold linker.
      # bfd is used for some of the older toolchains or archs not supported by gold.
      DEFAULT_LD=gold
      ;;
    *)
      panic "Invalid --default-ld name '$DEFAULT_LD', valid values are: bfd gold"
      ;;
esac

HOST_SYSTEMS=$(commas_to_spaces $HOST_SYSTEMS)
TOOLCHAINS=$(commas_to_spaces $TOOLCHAINS)

# 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.
#
BUILD_OS=$HOST_OS
BUILD_ARCH=$HOST_ARCH
BUILD_TAG=$HOST_TAG

# Important note: When identifying a build or host system, there is
# a difference between 'NDK system tags' and "GNU configuration triplet'.
#
# A "system tag" is specific to the NDK and identifies a given host
# system for the toolchain binaries, valid values:
#
#  linux-x86
#  linux-x86_64
#  windows        (historical alias to windows-x86)
#  windows-x86
#  windows-x86_64
#  darwin-x86
#  darwin-x86_64
#
# A GNU configuration triplet identifies a system too, but it used by
# configure scripts, not the NDK. They vary a lot too and some of the
# scripts are *very* picky about the exact values being used.
#
# Typical values that are known to work properly:
#
#    i686-linux-gnu       (Linux x86 system, with GNU libc)
#    x86_64-linux-gnu     (Same, with x86_64 CPU)
#    i586-mingw32msvc     (Windows 32-bits, MSVCRT.DLL)
#    i586-pc-mingw32msvc  (same)
#    i686-w64-mingw32     (same, slightly different sources)
#    x86_64-w64-mingw32   (Windows 64-bits, MSVCRT.DLL)
#    i686-apple-darwin    (OS X / Darwin, x86 CPU)
#    x86_64-apple-darwin  (OS X / Darwin, x86_64 CPU)
#
# A cross-toolchain will typically use the GNU configuration triplet as
# a prefix for all its binaries, but not always. For example, the 'mingw32'
# package on Ubuntu provides a Windows cross-toolchain that uses the
# i586-mingw32msvc prefix, but if you try to use it as a configuration
# triplet when configuring binutils-2.21, the build will fail. You need to
# pass i586-pc-mingw32msvc instead (binutils-2.19 accepts both).
#
# Another issue is that some toolchains need to use additional compiler
# flags to deal with backwards-compatibility SDKs (Darwin) or 32/64 bit
# code generation. Note all build scripts accept the same mix of
# '--with-cflags=...' or 'export CFLAGS' configuration, which makes
# things pretty difficult to manage.
#
# To work-around these issues, the script will generate "wrapper toolchains"
# with the prefix that the configure scripts expects. I.e. small scripts that
# redirect to the correct toolchain, eventually adding hidden extra compiler
# flags. This seems to completely get rid of the problems described above.
#


# $1: system tag (e.g. linux-x86)
tag_to_os ()
{
    local RET
    case $1 in
        linux-*) RET="linux";;
        darwin-*) RET="darwin";;
        windows|windows-*) RET="windows";;
    esac
    echo $RET
}

# $1: system tag (e.g. linux-x86)
tag_to_arch ()
{
    local RET
    case $1 in
        windows|*-x86) RET=x86;;
        *-x86_64) RET=x86_64;;
    esac
    echo $RET
}

# $1: system tag (e.g. linux-x86)
tag_to_bits ()
{
    local RET
    case $1 in
        windows|*-x86) RET=32;;
        *-x86_64) RET=64;;
    esac
    echo $RET
}

if [ "$NO_COLOR" ]; then
    COLOR_GREEN=
    COLOR_PURPLE=
    COLOR_CYAN=
    COLOR_END=
else
    COLOR_GREEN="\e[32m"
    COLOR_PURPLE="\e[35m"
    COLOR_CYAN="\e[36m"
    COLOR_END="\e[0m"
fi

# Pretty printing with colors!
host_text ()
{
    printf "[${COLOR_GREEN}${HOST}${COLOR_END}]"
}

toolchain_text ()
{
    printf "[${COLOR_PURPLE}${TOOLCHAIN}${COLOR_END}]"
}

target_text ()
{
    printf "[${COLOR_CYAN}${TARGET}${COLOR_END}]"
}

arch_text ()
{
    # Print arch name in cyan
    printf "[${COLOR_CYAN}${ARCH}${COLOR_END}]"
}

# We're going to cheat a little here. If we're only building a linux-x86
# on a linux-x86_64 machine, we want to change the value of BUILD_TAG
# to linux-x86 instead to speed-up the build.
#
# More generally speaking, we need to verify that if:
#   - we build a $BUILD_OS-x86 toolchain on a $BUILD_OS-x86_64 machine
#   - we don't want to build $BUILD_OS-x86_64 either.
#
# Then we can change our BUILD values to $BUILD_OS-x86
# This assumes that the build machine's toolchain can generate both
# 32-bit and 64-bit binaries with either -m32 or -m64
#
BUILD_BUILD_32=
BUILD_BUILD_64=
for SYSTEM in $HOST_SYSTEMS; do
    if [ "$(tag_to_os $SYSTEM)" = "$BUILD_OS" ]; then
        BUILD_BUILD_OS=true
        case $(tag_to_bits $SYSTEM) in
            32) BUILD_BUILD_32=true;;
            64) BUILD_BUILD_64=true;;
        esac
    fi
done

case $(tag_to_bits $BUILD_TAG) in
    64)
        # Building on a 64-bit machine
        if [ "$BUILD_BUILD_32" -a -z "$BUILD_BUILD_64" ]; then
            # Ok, we want to build a 32-bit toolchain on a 64-bit machine
            # So cheat a little now :-)
            BUILD_ARCH=x86
            BUILD_TAG=$BUILD_OS-$BUILD_ARCH
            dump "Forcing build config: $BUILD_TAG"
        fi
        ;;
esac

BUILD_BITS=$(tag_to_bits $BUILD_TAG)

# On Darwin, parallel installs of certain libraries do not work on
# some multi-core machines. So define NUM_BUILD_JOBS as 1 on this
# platform.
case $BUILD_OS in
    darwin) NUM_INSTALL_JOBS=1;;
    *) NUM_INSTALL_JOBS=$NUM_JOBS;;
esac

extract_version ()
{
    echo $1 | tr '-' '\n' | tail -1
}

# Given an input string of the form <foo>-<bar>-<version>, where
# <version> can be <major>.<minor>, extract <major>
#
# $1: versioned name (e.g. arm-linux-androideabi-4.6)
# Out: major version (e.g. 4)
#
# Examples:  arm-linux-androideabi-4.4.3 -> 4
#            gmp-0.81 -> 0
#
extract_major_version ()
{
    local RET=$(extract_version $1 | cut -d . -f 1)
    RET=${RET:-0}
    echo $RET
}

# Same as extract_major_version, but for the minor version number
# $1: versioned named
# Out: minor version
#
extract_minor_version ()
{
    local RET=$(extract_version $1 | cut -d . -f 2)
    RET=${RET:-0}
    echo $RET
}

# Compare two version numbers and only succeeds if the first one is
# greather or equal than the second one.
#
# $1: first version (e.g. 4.4.3)
# $2: second version (e.g. 4.6)
#
# Example: version_is_greater_than 4.6 4.4.3 --> success
#
version_is_greater_than ()
{
    local A_MAJOR A_MINOR B_MAJOR B_MINOR
    A_MAJOR=$(extract_major_version $1)
    B_MAJOR=$(extract_major_version $2)

    if [ $A_MAJOR -lt $B_MAJOR ]; then
        return 1
    elif [ $A_MAJOR -gt $B_MAJOR ]; then
        return 0
    fi

    # We have A_MAJOR == B_MAJOR here

    A_MINOR=$(extract_minor_version $1)
    B_MINOR=$(extract_minor_version $2)

    if [ $A_MINOR -lt $B_MINOR ]; then
        return 1
    else
        return 0
    fi
}

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=i586-pc-mingw32msvc;;
        windows-x86_64) RET=x86_64-w64-mingw32;;
    esac
    echo "$RET"
}

run_on_setup ()
{
    if [ "$PHASE" = setup ]; then
        run "$@"
    fi
}

setup_build ()
{
    run_on_setup mkdir -p "$BUILD_DIR"
    if [ -n "$FORCE" ]; then
        rm -rf "$BUILD_DIR"/*
    fi

    TOP_BUILD_DIR=$BUILD_DIR

    setup_default_log_file $BUILD_DIR/build.log

    WRAPPERS_DIR="$BUILD_DIR/toolchain-wrappers"
    run_on_setup mkdir -p "$WRAPPERS_DIR" && run_on_setup rm -rf "$WRAPPERS_DIR/*"

    STAMPS_DIR="$BUILD_DIR/timestamps"
    run_on_setup mkdir -p "$STAMPS_DIR"
    if [ -n "$FORCE" ]; then
        run_on_setup rm -f "$STAMPS_DIR"/*
    fi

    if [ "$PACKAGE_DIR" ]; then
        mkdir -p "$PACKAGE_DIR"
        fail_panic "Can't create packaging directory: $PACKAGE_DIR"
    fi

    BUILD=$(tag_to_config_triplet $BUILD_TAG)
}

stamps_do ()
{
    local NAME=$1
    shift
    if [ ! -f "$STAMPS_DIR/$NAME" ]; then
        "$@"
        fail_panic
        mkdir -p "$STAMPS_DIR" && touch "$STAMPS_DIR/$NAME"
    fi
}

# 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
#
check_compiler ()
{
    local CC="$1"
    local TMPC=/tmp/build-host-gcc-$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.
try_host_fullprefix ()
{
    local PREFIX="$1/bin/$2"
    shift; shift;
    if [ -z "$HOST_FULLPREFIX" ]; then
        local GCC="$PREFIX-gcc"
        if [ -f "$GCC" ]; then
            if check_compiler "$GCC" "$@"; then
                HOST_FULLPREFIX="${GCC%%gcc}"
                dump "$(host_text) Using host gcc: $GCC $@"
            else
                dump "$(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)
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 check_compiler "$GCC" "$@"; then
                HOST_FULLPREFIX=${GCC%%gcc}
                dump "$(host_text) Using host gcc: ${HOST_FULLPREFIX}gcc $@"
            else
                dump "$(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)
darwin_arch_to_min_version ()
{
  if [ "$DARWIN_MIN_VERSION" ]; then
    echo "$DARWIN_MIN_VERSION"
  elif [ "$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 architecture
check_darwin_sdk ()
{
    if [ -d "$1" -a -z "$HOST_CFLAGS" ] ; then
        local MINVER=$(darwin_arch_to_min_version $2)
        HOST_CFLAGS="-isysroot $1 -mmacosx-version-min=$MINVER -DMAXOSX_DEPLOYEMENT_TARGET=$MINVER"
        HOST_CXXFLAGS=$HOST_CFLAGS
        HOST_LDFLAGS="-syslibroot $1 -mmacosx-version-min=$MINVER"
        dump "Generating $MINVER-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
check_compiler_bitness ()
{
    local CC="$1"
    local BITS="$2"
    local TMPC=/tmp/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 "$(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 $WRAPPERS_DIR with a prefix of ${HOST}-
# where $HOST is a GNU configuration name.
#
# Important: this script might redefine $HOST to a different value!
# Important: must be called after setup_build.
#
# $1: NDK system tag (e.g. linux-x86)
#
select_toolchain_for_host ()
{
    local HOST_CFLAGS HOST_CXXFLAGS HOST_LDFLAGS HOST_FULLPREFIX DARWIN_ARCH

    # 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)
            # If possible, automatically use our custom toolchain to generate
            # 32-bit executables that work on Ubuntu 8.04 and higher.
            try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/i686-linux-glibc2.7-4.6" i686-linux
            try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/i686-linux-glibc2.7-4.4.3" i686-linux
            try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilt/linux-x86/toolchain/i686-linux-glibc2.7-4.4.3" i686-linux
            try_host_prefix i686-linux-gnu
            try_host_prefix i686-linux
            try_host_prefix x86_64-linux-gnu -m32
            try_host_prefix x86_64-linux -m32
            ;;

        linux-x86_64)
            # If possible, automaticaly use our custom toolchain to generate
            # 64-bit executables that work on Ubuntu 8.04 and higher.
            try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.7-4.6" x86_64-linux
            try_host_prefix x86_64-linux-gnu
            try_host_prefix x84_64-linux
            try_host_prefix i686-linux-gnu -m64
            try_host_prefix i686-linux -m64
            ;;

        darwin-*)
            DARWIN_ARCH=$(tag_to_arch $1)
            case $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.
                        check_darwin_sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX$DARWIN_SDK_SUBDIR $DARWIN_ARCH
                        check_darwin_sdk /Developer/SDKs/MacOSX$DARWIN_SDK_SUBDIR $DARWIN_ARCH
                    else
                        # Since xCode moved to the App Store the SDKs have been 'sandboxed' into the Xcode.app folder.
                        check_darwin_sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk $DARWIN_ARCH
                        check_darwin_sdk /Developer/SDKs/MacOSX10.7.sdk  $DARWIN_ARCH
                        check_darwin_sdk /Developer/SDKs/MacOSX10.6.sdk  $DARWIN_ARCH
                        # NOTE: The 10.5.sdk on Lion is buggy and cannot build basic C++ programs
                        #check_darwin_sdk /Developer/SDKs/MacOSX10.5.sdk  $DARWIN_ARCH
                        # NOTE: The 10.4.sdku is not available anymore and could not be tested.
                        #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
                    local DARWINMINVER=$(darwin_arch_to_min_version $2)
                    check_darwin_sdk $DARWIN_SYSROOT $DARWINARCH
                    try_host_prefix "$DARWIN_TOOLCHAIN" -m$(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 $BUILD_OS in
                linux)
                    # We favor these because they are more recent, and because
                    # we have a script to rebuild them from scratch. See
                    # build-mingw64-toolchain.sh.
                    try_host_prefix x86_64-w64-mingw32 -m32
                    try_host_prefix i686-w64-mingw32
                    # Typically provided by the 'mingw32' package on Debian
                    # and Ubuntu systems.
                    try_host_prefix i586-mingw32msvc
                    # 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.
                    try_host_prefix i686-pc-mingw32
                    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 "   x86_64-w64-mingw32-gcc  (see build-mingw64-toolchain.sh)"
                        dump "   i686-w64-mingw32-gcc    (see build-mingw64-toolchain.sh)"
                        dump "   i586-mingw32msvc-gcc    ('mingw32' Debian/Ubuntu package)"
                        dump "   i686-pc-mingw32         (on Fedora)"
                        dump ""
                        exit 1
                    fi
                    # Adjust $HOST to match the toolchain to ensure proper builds.
                    # I.e. chose configuration triplets that are known to work
                    # with the gmp/mpfr/mpc/binutils/gcc configure scripts.
                    case $HOST_FULLPREFIX in
                        *-mingw32msvc-*|i686-pc-mingw32)
                            HOST=i586-pc-mingw32msvc
                            ;;
                        *)
                            HOST=i686-w64-mingw32msvc
                            ;;
                    esac
                    ;;
                *) panic "Sorry, this script only supports building windows binaries on Linux."
                ;;
            esac
            ;;

        windows-x86_64)
            # Sanity check for GMP which doesn't build with x86_64-w64-mingw32-gcc
            # before 5.0. We already have 5.0.5 in AOSP toolchain source tree, so
            # suggest it here.
            if ! version_is_greater_than $GMP_VERSION 5.0; then
                dump "You cannot build a 64-bit Windows toolchain with this version of libgmp."
                dump "Please use --gmp-version=5.0.5 to fix this."
                exit 1
            fi
            case $BUILD_OS in
                linux)
                    # See comments above for windows-x86
                    try_host_prefix x86_64-w64-mingw32
                    try_host_prefix i686-w64-mingw32 -m64
                    # Beware that this package is completely broken on many
                    # versions of no vinegar Ubuntu (i.e. it fails at building trivial
                    # programs).
                    try_host_prefix amd64-mingw32msvc
                    # There is no x86_64-pc-mingw32 toolchain on Fedora.
                    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 "   i686-w64-mingw32-gcc    (see build-mingw64-toolchain.sh)"
                        dump "   amd64-mingw32msvc-gcc   (Debian/Ubuntu - broken until Ubuntu 11.10)"
                        dump ""
                        exit 1
                    fi
                    # See comment above for windows-x86
                    case $HOST_FULLPREFIX in
                        *-mingw32msvc*)
                            # Actually, this has never been tested.
                            HOST=amd64-pc-mingw32msvc
                            ;;
                        *)
                            HOST=x86_64-w64-mingw32
                            ;;
                    esac
                    ;;

                *) panic "Sorry, this script only supports building windows binaries on Linux."
                ;;
            esac
            ;;
    esac

    mkdir -p "$(host_build_dir)"
    if [ "$FORCE" ]; then
        rm -rf "$(host_build_dir)"/*
    fi

    # 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 ! check_compiler_bitness ${HOST_FULLPREFIX}gcc $HOST_BITS; then
        TRY_CFLAGS=
        case $HOST_BITS in
            32) TRY_CFLAGS=-m32;;
            64) TRY_CFLAGS=-m64;;
        esac
        if ! check_compiler_bitness ${HOST_FULLPREFIX}gcc $HOST_BITS $TRY_CFLAGS; then
            panic "Can't find a way to generate $HOST_BITS binaries with this compiler: ${HOST_FULLPREFIX}gcc"
        fi
        HOST_CFLAGS=$HOST_CFLAGS" "$TRY_CFLAGS
        HOST_CXXFLAGS=$HOST_CXXFLAGS" "$TRY_CFLAGS
    fi

    # Support for ccache, to speed up rebuilds.
    DST_PREFIX=$HOST_FULLPREFIX
    if [ "$NDK_CCACHE" ]; then
        DST_PREFIX="$NDK_CCACHE $HOST_FULLPREFIX"
    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 $NDK_BUILDTOOLS_PATH/gen-toolchain-wrapper.sh "$WRAPPERS_DIR" \
        --src-prefix="$HOST-" \
        --dst-prefix="$DST_PREFIX" \
        --cflags="$HOST_CFLAGS" \
        --cxxflags="$HOST_CXXFLAGS" \
        --ldflags="$HOST_LDFLAGS"
}

# 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).
#
setup_build_for_host ()
{
    local HOST_VARNAME=$(dashes_to_underscores $1)
    local HOST_VAR=_HOST_${HOST_VARNAME}

    # Determine the host configuration triplet in $HOST
    HOST=$(tag_to_config_triplet $1)
    HOST_OS=$(tag_to_os $1)
    HOST_ARCH=$(tag_to_arch $1)
    HOST_BITS=$(tag_to_bits $1)
    HOST_TAG=$1

    # Note: since select_toolchain_for_host can change the value of $HOST
    # 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
        select_toolchain_for_host $1
        var_assign ${HOST_VAR}_CONFIG $HOST
        var_assign ${HOST_VAR}_SETUP true
    else
        HOST=$(var_value ${HOST_VAR}_CONFIG)
    fi
}

# Returns the location of all $HOST specific files (build and install)
host_build_dir ()
{
    echo "$TOP_BUILD_DIR/$HOST"
}

# Return the location of the build directory for a specific component
# $1: component name (e.g. gmp-4.2.4)
host_build_dir_for ()
{
    echo "$(host_build_dir)/build-$1"
}

# Returns the install location of the $HOST pre-reqs libraries
host_prereqs_install_dir ()
{
    echo "$(host_build_dir)/temp-prereqs"
}

# Returns the install location of the $HOST binutils cross-toolchain
host_binutils_install_dir ()
{
    echo "$(host_build_dir)/temp-binutils-$BINUTILS_VERSION-$TARGET"
}

# Returns the install location of the $HOST binutils cross-toolchain
build_binutils_install_dir ()
{
    echo "$TOP_BUILD_DIR/$BUILD/temp-binutils-$BINUTILS_VERSION-$TARGET"
}

# Returns the install location of the $HOST gcc cross-toolchain
host_gcc_install_dir ()
{
    echo "$(host_build_dir)/temp-$TOOLCHAIN"
}

# Returns the install location of the $BUILD gcc cross-toolchain
build_gcc_install_dir ()
{
    echo "$TOP_BUILD_DIR/$BUILD/temp-$TOOLCHAIN"
}


# Location of the host sysroot used during the build
host_sysroot ()
{
    # This must be a sub-directory of $(host_gcc_install_dir)
    # to generate relocatable binaries that are used by
    # standalone versions of the toolchain.
    #
    # If you change this, you will need to modify make-standalone-toolchain.sh
    # as well.
    #
    echo "$(host_gcc_install_dir)/sysroot"
}

# Returns the final install location of the $HOST toolchain
# This ones contains the binutils binaries, the gcc ones,
# the target libraries, but does *not* include the sysroot
# and other stuff (e.g. documentation like info or man files).
#
host_gcc_final_dir ()
{
    echo "$(host_build_dir)/final-$TOOLCHAIN"
}

setup_build_for_toolchain ()
{
    GCC_VERSION=$(extract_version $1)
    BINUTILS_VERSION=$(get_default_binutils_version_for_gcc $1)

    TARGET_ARCH=$(echo $1 | cut -d - -f 1)

    # NOTE: The 'mipsel' toolchain architecture name maps to the 'mips'
    # NDK architecture name.
    case $TARGET_ARCH in
        arm) TARGET=arm-linux-androideabi;;
        x86) TARGET=i686-linux-android;;
        x86_64) TARGET=x86_64-linux-android;;
        mips|mipsel) TARGET=mipsel-linux-android; TARGET_ARCH=mips;;
        *) panic "Unknown target toolchain architecture: $TARGET_ARCH"
    esac

    # MPC is only needed starting with GCC 4.5
    HOST_NEED_MPC=
    if version_is_greater_than $GCC_VERSION 4.5; then
        HOST_NEED_MPC=true
    fi

    # TODO: We will need to place these under
    #      $NDK_DIR/prebuilts/$HOST/android-$TARGET_ARCH-gcc-$GCC_VERSION/
    #      in a future patch.
    TOOLCHAIN_SUB_DIR=toolchains/$TOOLCHAIN/prebuilt/$HOST_TAG
    TOOLCHAIN_INSTALL_DIR=$NDK_DIR/$TOOLCHAIN_SUB_DIR

    # These will go into CFLAGS_FOR_TARGET and others during the build
    # of GCC target libraries.
    if [ -z "$NO_STRIP" ]; then
        TARGET_CFLAGS="-O2 -s"
    else
        TARGET_CFLAGS="-Os -g"
    fi

    TARGET_CXXFLAGS=$TARGET_CFLAGS
    TARGET_LDFLAGS=""

    case $TARGET_ARCH in
        mips)
        # Enable C++ exceptions, RTTI and GNU libstdc++ at the same time
        # You can't really build these separately at the moment.
        # Add -fpic, because MIPS NDK will need to link .a into .so.
        TARGET_CFLAGS=$TARGET_CFLAGS" -fexceptions -fpic"
        TARGET_CXXFLAGS=$TARGET_CXXFLAGS" -frtti -fpic"
        ;;
    esac
}

# This function is used to setup the build environment whenever we
# generate host-specific binaries.
#
setup_host_env ()
{
    CC=$HOST-gcc
    CXX=$HOST-g++
    LD=$HOST-ld
    AR=$HOST-ar
    AS=$HOST-as
    RANLIB=$HOST-ranlib
    NM=$HOST-nm
    STRIP=$HOST-strip
    STRINGS=$HOST-strings
    export CC CXX AS LD AR RANLIB STRIP STRINGS NM

    CFLAGS=
    CXXFLAGS=
    LDFLAGS=
    if [ -z "$NO_STRIP" ]; then
        CFLAGS="-O2 -Os -fomit-frame-pointer -s"
        CXXFLAGS=$CFLAGS
    fi

    # This should only used when building the target GCC libraries
    CFLAGS_FOR_TARGET=$TARGET_CFLAGS
    CXXFLAGS_FOR_TARGET=$TARGET_CXXFLAGS
    LDFLAGS_FOR_TARGET=$TARGET_LDFLAGS

    export CFLAGS CXXFLAGS LDFLAGS CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET LDFLAGS_FOR_TARGET

    PATH=$WRAPPERS_DIR:$PATH
}

# $1: NDK architecture name (e.g. 'arm')
arch_sysroot_install_dir ()
{
    echo "$BUILD_DIR/arch-$1/sysroot"
}

# $1: NDK architecture name (e.g. 'arm')
arch_sysroot_dir ()
{
    echo "$(arch_sysroot_install_dir $1)/$(get_default_platform_sysroot_for_arch $1)"
}

# $1: architecture name
gen_minimal_sysroot ()
{
    local ARCH=$1
    local INSTALL_DIR=$(arch_sysroot_install_dir $ARCH)

    dump "$(arch_text) Generating minimal sysroot."
    run2 $NDK_BUILDTOOLS_PATH/gen-platforms.sh --minimal --arch=$ARCH --dst-dir="$INSTALL_DIR"
}


# $1: gmp version
extract_gmp_sources ()
{
    local SRC_DIR="$TOP_BUILD_DIR/temp-src"

    dump "Extracting gmp-$1"
    run2 mkdir -p "$SRC_DIR" &&
    run2 tar xjf "$TOOLCHAIN_SRC_DIR/gmp/gmp-$1.tar.bz2" -C "$SRC_DIR"
}

# $1: gmp version
build_gmp ()
{
    local SRC_DIR="$TOP_BUILD_DIR/temp-src/gmp-$1"
    local INSTALL_DIR="$(host_prereqs_install_dir)"
    local BUILD_DIR

    stamps_do extract-gmp-$1 extract_gmp_sources $1

    dump "$(host_text) Building gmp-$1"
    (
        setup_host_env &&
        BUILD_DIR="$(host_build_dir_for gmp-$GMP_VERSION)" &&
        run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* &&
        cd "$BUILD_DIR" &&
        run2 "$SRC_DIR"/configure \
            --prefix=$INSTALL_DIR \
            --build=$BUILD \
            --host=$HOST \
            --disable-shared &&
        run2 make -j$NUM_JOBS &&
        run2 make install -j$NUM_INSTALL_JOBS
    )
    return $?
}

extract_mpfr_sources ()
{
    local SRC_DIR="$TOP_BUILD_DIR/temp-src"

    dump "Extracting mpfr-$1"
    run2 mkdir -p "$SRC_DIR" &&
    run2 tar xjf "$TOOLCHAIN_SRC_DIR/mpfr/mpfr-$1.tar.bz2" -C "$SRC_DIR"
}

# $1: mpfr-version
build_mpfr ()
{
    local SRC_DIR="$TOP_BUILD_DIR/temp-src/mpfr-$1"
    local INSTALL_DIR="$(host_prereqs_install_dir)"
    local BUILD_DIR

    stamps_do extract-mpfr-$MPFR_VERSION extract_mpfr_sources $1

    stamps_do build-gmp-$GMP_VERSION-$HOST build_gmp $GMP_VERSION

    dump "$(host_text) Building mpfr-$1"
    (
        setup_host_env &&
        BUILD_DIR="$(host_build_dir_for mpfr-$MPFR_VERSION)" &&
        run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* &&
        cd $BUILD_DIR &&
        run2 "$SRC_DIR"/configure \
            --prefix=$INSTALL_DIR \
            --build=$BUILD \
            --host=$HOST \
            --disable-shared \
            --with-gmp=$INSTALL_DIR &&
        run2 make -j$NUM_JOBS &&
        run2 make -j$NUM_INSTALL_JOBS install
    )
    return $?
}

# $1: mpc-version
extract_mpc_sources ()
{
    local SRC_DIR="$TOP_BUILD_DIR/temp-src"

    dump "Extracting mpc-$1"
    run2 mkdir -p "$SRC_DIR" &&
    run2 tar xzf "$TOOLCHAIN_SRC_DIR/mpc/mpc-$1.tar.gz" -C "$SRC_DIR"
}


# $1: mpc-version
build_mpc ()
{
    local SRC_DIR="$TOP_BUILD_DIR/temp-src/mpc-$1"
    local INSTALL_DIR="$(host_prereqs_install_dir)"
    local BUILD_DIR

    stamps_do extract-mpc-$1 extract_mpc_sources $1

    stamps_do build-mpfr-$MPFR_VERSION-$HOST build_mpfr $MPFR_VERSION

    dump "$(host_text) Building mpc-$1"
    (
        setup_host_env &&
        BUILD_DIR="$(host_build_dir_for mpc-$MPC_VERSION)" &&
        run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* &&
        cd $BUILD_DIR &&
        run2 "$SRC_DIR"/configure \
            --prefix=$INSTALL_DIR \
            --build=$BUILD \
            --host=$HOST \
            --disable-shared \
            --with-gmp=$INSTALL_DIR \
            --with-mpfr=$INSTALL_DIR &&
        run2 make -j$NUM_JOBS &&
        run2 make -j$NUM_INSTALL_JOBS install
    )
    return $?
}

# Build all pre-required host libraries (gmp, mpfr, etc...) that are needed
# by binutils and gcc, as static libraries that will be placed under
# $HOST_BUILD_DIR/temp-install
#
# $1: toolchain source directory
#
build_host_prereqs ()
{
    local INSTALL_DIR="$(host_prereqs_install_dir)"
    local ARGS

    ARGS=" --with-gmp=$INSTALL_DIR --with-mpfr=$INSTALL_DIR"

    # Only build MPC when we need it.
    if [ "$HOST_NEED_MPC" ]; then
        ARGS=$ARGS" --with-mpc=$INSTALL_DIR"
        stamps_do build-mpc-$MPC_VERSION-$HOST build_mpc $MPC_VERSION
    else
        stamps_do build-mpfr-$MPFR_VERSION-$HOST build_mpfr $MPFR_VERSION
    fi

    # This gets used by build_host_binutils and others.
    HOST_PREREQS_ARGS=$ARGS
}

build_host_binutils ()
{
    local SRC_DIR="$TOOLCHAIN_SRC_DIR/binutils/binutils-$BINUTILS_VERSION"
    local INSTALL_DIR="$(host_binutils_install_dir)"
    local PREREQS_INSTALL_DIR="$(host_prereqs_install_dir)"
    local ARGS

    build_host_prereqs

    ARGS=" --with-gmp=$PREREQS_INSTALL_DIR --with-mpfr=$PREREQS_INSTALL_DIR"
    if [ "$HOST_NEED_MPC" ]; then
        ARGS=$ARGS" --with-mpc=$PREREQS_INSTALL_DIR"
    fi

    LD_NAME=$DEFAULT_LD

    # Enable Gold globally. It can be built for all hosts.
    BUILD_GOLD=true

    # Special case, gold is not ready for mips yet.
    if [ "$TARGET" = "mipsel-linux-android" ]; then
        BUILD_GOLD=
    fi

    # Another special case, gold in binutils-2.21 for arch-x86 is buggy
    # (i.e. when building the platform with it, the system doesn't boot)
    #
    if [ "$BINUTILS_VERSION" = "2.21" -a "$TARGET" = "i686-linux-android" ]; then
        USE_LD_DEFAULT=true
        BUILD_GOLD=
    fi

    # Another special case, for arch-x86_64 gold supports x32 starting from 2.23
    #
    if [ "$TARGET" = "x86_64-linux-android" ]; then
       if ! version_is_greater_than $BINUTILS_VERSION 2.23; then
        USE_LD_DEFAULT=true
        BUILD_GOLD=
       fi
    fi

    # Another special case. Not or 2.19, it wasn't ready
    if [ "$BINUTILS_VERSION" = "2.19" ]; then
        BUILD_GOLD=
    fi

    if [ "$DEFAULT_LD" = "gold" -a -z "$BUILD_GOLD" ]; then
        dump "$(host_text)$(target_text): Cannot build Gold for this toolchain!"
        BUILD_GOLD=
    fi

    # Ok, if the user *really* wants it, we're going to build Gold anyway.
    # There are no guarantees about the correctness of the resulting binary.
    # --default-ld still determines the default linker to use by the toolchain.
    #
    if [ "$FORCE_GOLD_BUILD" -a -z "$BUILD_GOLD" ]; then
        dump "$(host_text)$(target_text): Warning: forcing build of potentially buggy Gold linker!"
        BUILD_GOLD=true
    fi

    # The BFD linker is always built, but to build Gold, we need a specific
    # option for the binutils configure script. Note that its format has
    # changed during development.
    export host_configargs=
    if [ "$BUILD_GOLD" ]; then
        # The syntax of the --enable-gold option has changed.
        if version_is_greater_than $BINUTILS_VERSION 2.20; then
            if [ "$DEFAULT_LD" = "bfd" ]; then
                ARGS=$ARGS" --enable-gold --enable-ld=default"
            else
                ARGS=$ARGS" --enable-gold=default --enable-ld"
            fi
        else
            if [ "$DEFAULT_LD" = "bfd" ]; then
                ARGS=$ARGS" --enable-gold=both"
            else
                ARGS=$ARGS" --enable-gold=both/gold"
            fi
        fi
	# This ARG needs quoting when passed to run2.
	GOLD_LDFLAGS_ARG=
        if [ "$HOST_OS" = 'windows' ]; then
            # gold may have runtime dependency on libgcc_sjlj_1.dll and
            # libstdc++-6.dll when built by newer versions of mingw.
            # Link them statically to avoid that.
            if version_is_greater_than $BINUTILS_VERSION 2.22; then
                export host_configargs="--with-gold-ldflags='-static-libgcc -static-libstdc++'"
            elif version_is_greater_than $BINUTILS_VERSION 2.21; then
                GOLD_LDFLAGS_ARG="--with-gold-ldflags=-static-libgcc -static-libstdc++"
            else
                export LDFLAGS=$LDFLAGS" -static-libgcc -static-libstdc++"
            fi
        fi
    fi

    # This is used to install libbfd which is later used to compile
    # oprofile for the platform. This is not technically required for
    # the NDK, but allows us to use the same toolchain for the platform
    # build. TODO: Probably want to move this step to its own script
    # like build-host-libbfd.sh in the future.
    ARGS=$ARGS" --enable-install-libbfd"

    # Enable plugins support for binutils-2.21+
    # This is common feature for binutils and gcc
    case "$BINUTILS_VERSION" in
      2.19)
        # Add nothing
        ;;
      *)
        ARGS=$ARGS" --enable-plugins"
        ;;
    esac

    dump "$(host_text)$(target_text) Building binutils-$BINUTILS_VERSION"
    (
        setup_host_env &&
        BUILD_DIR="$(host_build_dir_for binutils-$BINUTILS_VERSION-$TARGET)" &&
        run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* &&
        cd "$BUILD_DIR" &&
        run2 "$SRC_DIR"/configure \
            --prefix="$INSTALL_DIR" \
            --disable-shared \
            --disable-werror \
            --disable-nls \
            --build=$BUILD \
            --host=$HOST \
            --target=$TARGET \
            --with-sysroot="$INSTALL_DIR/sysroot" \
            $ARGS &&
        run2 make -j$NUM_JOBS &&
        run2 make -j$NUM_INSTALL_JOBS install &&
        # We need to take care of something weird, binutils-2.21 on mips
        # does not seem to build gold, and the Makefile script forgets to
        # copy it to $INSTALL/bin/mipsel-linux-android-ld. Take care of this
        # here with a symlink, which will be enough for now.
        if [ ! -f "$INSTALL_DIR/bin/$TARGET-ld" ]; then
            run2 ln -s "$TARGET-ld.bfd" "$INSTALL_DIR/bin/$TARGET-ld"
        fi
    )
    return $?
}

copy_target_sysroot ()
{
    local SRC_SYSROOT=$(arch_sysroot_dir $TARGET_ARCH)
    local SYSROOT=$(host_sysroot)

    # We need the arch-specific minimal sysroot
    stamps_do sysroot-arch-$TARGET_ARCH gen_minimal_sysroot $TARGET_ARCH

    dump "$(host_text)$(toolchain_text) Copying $TARGET_ARCH sysroot"
    run2 rm -rf "$SYSROOT" &&
    run2 copy_directory "$SRC_SYSROOT" "$SYSROOT"
}

build_host_gcc_core ()
{
    local SRC_DIR="$TOOLCHAIN_SRC_DIR/gcc/gcc-$GCC_VERSION"
    local INSTALL_DIR="$(host_gcc_install_dir)"
    local ARGS NEW_PATH

    stamps_do build-binutils-$BINUTILS_VERSION-$HOST-$TARGET build_host_binutils
    stamps_do sysroot-gcc-$SYSTEM-$TOOLCHAIN copy_target_sysroot

    build_host_prereqs

    NEW_PATH=$(host_gcc_install_dir)/bin:$(host_binutils_install_dir)/bin
    if [ "$HOST" != "$BUILD" ]; then
        NEW_PATH=$(build_gcc_install_dir)/bin:$(build_binutils_install_dir)/bin
    fi

    ARGS=$HOST_PREREQS_ARGS

    case "$GCC_VERSION" in
      4.4.3)
        ARGS=$ARGS" --disable-plugin"
        ;;
    esac

    ARGS=$ARGS" --with-gnu-as --with-gnu-ld"
    ARGS=$ARGS" --enable-threads --disable-libssp --disable-libmudflap"
    ARGS=$ARGS" --disable-libstdc__-v3 --disable-sjlj-exceptions"
    ARGS=$ARGS" --disable-tls"
    ARGS=$ARGS" --disable-libquadmath --disable-libitm --disable-bootstrap"
    ARGS=$ARGS" --enable-languages=c,c++"
    ARGS=$ARGS" --disable-shared"
    ARGS=$ARGS" --disable-nls"
    ARGS=$ARGS" --disable-werror"
    ARGS=$ARGS" --enable-target-optspace"
    ARGS=$ARGS" --enable-eh-frame-hdr-for-static"
    # TODO: Build fails for libsanitizer which appears in 4.8. Disable for now.
    ARGS=$ARGS" --disable-libsanitizer"

    case "$GCC_VERSION" in
     4.4.3)
       ARGS=$ARGS" --disable-libgomp"
       ;;
     *)
       case $TARGET_ARCH in
	     arm) ARGS=$ARGS" --enable-libgomp";;
	     x86*) ARGS=$ARGS" --enable-libgomp";;
	     mips|mipsel) ARGS=$ARGS" --disable-libgomp";;
	 esac
	 ;;
    esac

    # Place constructors/destructors in .init_array/.fini_array, not in
    # .ctors/.dtors on Android. Note that upstream Linux GLibc is now doing
    # the same.
    ARGS=$ARGS" --enable-initfini-array"

    case $TARGET_ARCH in
        arm)
            ARGS=$ARGS" --with-arch=armv5te --with-float=soft --with-fpu=vfpv3-d16"
            ;;
        x86)
            case "$GCC_VERSION" in
               4.4.3|4.7) ARGS=$ARGS" --with-arch=i686 --with-tune=atom --with-fpmath=sse" ;;
               *)         ARGS=$ARGS" --with-arch=i686 --with-tune=intel --with-fpmath=sse" ;;
            esac
            ;;
        x86_64)
            case "$GCC_VERSION" in
               4.4.3|4.7) ARGS=$ARGS" --with-arch=x86-64 --with-tune=atom --with-fpmath=sse --with-multilib-list=m32,m64,mx32" ;;
               *)         ARGS=$ARGS" --with-arch=x86-64 --with-tune=intel --with-fpmath=sse --with-multilib-list=m32,m64,mx32" ;;
            esac
            ;;
        mips)
            # Add --disable-fixed-point to disable fixed-point support
            ARGS=$ARGS" --with-arch=mips32 --disable-fixed-point"
            ;;
    esac

    dump "$(host_text)$(toolchain_text) Building gcc-core"
    (
        setup_host_env &&
        BUILD_DIR="$(host_build_dir_for gcc-$GCC_VERSION-$TARGET)" &&
        run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* &&
        cd "$BUILD_DIR" &&
        PATH=$NEW_PATH:$PATH &&
        run2 "$SRC_DIR"/configure \
            --prefix="$INSTALL_DIR" \
            --build=$BUILD \
            --host=$HOST \
            --target=$TARGET \
            --with-sysroot="$INSTALL_DIR/sysroot" \
            $HOST_PREREQS_ARGS $ARGS &&
        run2 make -j$NUM_JOBS all-gcc &&
        run2 make -j$NUM_INSTALL_JOBS install-gcc
    )
    return $?
}

build_target_gcc_libs ()
{
    local SRC_DIR="$TOOLCHAIN_SRC_DIR/gcc/gcc-$GCC_VERSION"
    local INSTALL_DIR="$(host_gcc_install_dir)"
    local ARGS NEW_PATH

    stamps_do gcc-core-$GCC_VERSION-$SYSTEM-$TOOLCHAIN build_host_gcc_core

    NEW_PATH=$(host_gcc_install_dir)/bin:$(host_binutils_install_dir)/bin

    dump "$(host_text)$(toolchain_text) Building target libraries"
    (
        setup_host_env &&
        BUILD_DIR="$(host_build_dir_for gcc-$GCC_VERSION-$TARGET)" &&
        cd "$BUILD_DIR" &&
        PATH=$NEW_PATH:$PATH &&
        run2 make -j$NUM_JOBS all &&
        run2 make -j$NUM_INSTALL_JOBS install
    )
    return $?
}

copy_target_gcc_libs ()
{
    local SRC_DIR DST_DIR
    dump "$(host_text)$(toolchain_text) Copying target GCC libraries"

    SRC_DIR="$(build_gcc_install_dir)/$TARGET"
    DST_DIR="$(host_gcc_install_dir)/$TARGET"

    run2 copy_directory "$SRC_DIR" "$DST_DIR"
}

build_host_gcc ()
{
    if [ "$SYSTEM" = "$BUILD_TAG" -a -z "$NO_TARGET_LIBS" ]; then
        # This is a regular-cross build, and we need to build the target GCC libraries.
        stamps_do gcc-all-$GCC_VERSION-$SYSTEM-$TOOLCHAIN build_target_gcc_libs
    else
        # This is a canadian-cross build, or we don't need the target GCC libraries.
        stamps_do gcc-core-$GCC_VERSION-$SYSTEM-$TOOLCHAIN build_host_gcc_core
    fi
}

# $1: host system tag (e.g. linux-x86)
# $2: toolchain name (e.g. x86-4.4.3)
build_gcc ()
{
    local SYSTEM=$1
    local TOOLCHAIN=$2

    # When performing canadian-cross builds, ensure we generate the
    # host toolchain first (even if we don't need target GCC libraries)
    if [ "$SYSTEM" != "$BUILD_TAG" ]; then
        build_gcc $BUILD_TAG $TOOLCHAIN
    fi

    # We do this both in the setup and build phase to ensure we perform
    # as many checks as possible before launching the (long) build procedure.
    setup_build_for_host $SYSTEM
    setup_build_for_toolchain $TOOLCHAIN

    if [ "$PHASE" = build ]; then
        stamps_do build-gcc-$SYSTEM-$TOOLCHAIN build_host_gcc
    fi
}

do_relink ()
{
    log "Relink $1 --> $2"
    local BASENAME DIRNAME
    DIRNAME=$(dirname "$1")
    BASENAME=$(basename "$1")
    ( cd "$DIRNAME" && rm -f "$BASENAME" && ln -s "$2" "$BASENAME" )
}

# $1: host system tag (e.g. linux-x86)
# $2: toolchain name (e.g. x86-4.4.3)
install_gcc ()
{
    local SYSTEM=$1
    local TOOLCHAIN=$2
    local BINUTILS_DIR GCC_DIR TARGET_LIBS_DIR INSTALL_DIR PROG

    build_gcc $SYSTEM $TOOLCHAIN

    dump "$(host_text)$(toolchain_text) Installing to NDK."

    BINUTILS_DIR=$(host_binutils_install_dir)
    GCC_DIR=$(host_gcc_install_dir)
    TARGET_LIBS_DIR=$(build_gcc_install_dir)
    INSTALL_DIR=$TOOLCHAIN_INSTALL_DIR

    # Copy binutils binaries
    run2 copy_directory "$BINUTILS_DIR/bin" "$INSTALL_DIR/bin" &&
    run2 copy_directory "$BINUTILS_DIR/$TARGET/lib" "$INSTALL_DIR/$TARGET/lib" &&

    # The following is used to copy the libbfd. See --enable-install-libbfd
    # which is set in build_host_binutils above.
    run2 copy_directory "$BINUTILS_DIR/$HOST/$TARGET/include" "$INSTALL_DIR/include" &&
    run2 copy_directory "$BINUTILS_DIR/$HOST/$TARGET/lib"     "$INSTALL_DIR/lib$(tag_to_bits $SYSTEM)" &&

    # Copy gcc core binaries
    run2 copy_directory "$GCC_DIR/bin" "$INSTALL_DIR/bin" &&
    run2 copy_directory "$GCC_DIR/lib/gcc/$TARGET" "$INSTALL_DIR/lib/gcc/$TARGET" &&
    run2 copy_directory "$GCC_DIR/libexec/gcc/$TARGET" "$INSTALL_DIR/libexec/gcc/$TARGET" &&

    # Copy target gcc libraries
    run2 copy_directory "$TARGET_LIBS_DIR/lib/gcc/$TARGET" "$INSTALL_DIR/lib/gcc/$TARGET"
    run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/lib" "$INSTALL_DIR/$TARGET/lib"
    # Multilib compiler should have these
    if [ -d "$TARGET_LIBS_DIR/$TARGET/libx32" ]; then
       run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/libx32" "$INSTALL_DIR/$TARGET/libx32"
    fi
    if [ -d "$TARGET_LIBS_DIR/$TARGET/lib32" ]; then
       run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/lib32" "$INSTALL_DIR/$TARGET/lib32"
    fi
    if [ -d "$TARGET_LIBS_DIR/$TARGET/lib64" ]; then
       run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/lib64" "$INSTALL_DIR/$TARGET/lib64"
    fi

    # We need to generate symlinks for the binutils binaries from
    # $INSTALL_DIR/$TARGET/bin/$PROG to $INSTALL_DIR/bin/$TARGET-$PROG
    mkdir -p "$INSTALL_DIR/$TARGET/bin" &&
    for PROG in $(cd $INSTALL_DIR/$TARGET/bin && ls * 2>/dev/null); do
        do_relink "$INSTALL_DIR/$TARGET/bin/$PROG" ../../bin/$TARGET-$PROG
        fail_panic
    done

    # Also relink a few files under $INSTALL_DIR/bin/
    do_relink "$INSTALL_DIR"/bin/$TARGET-c++ $TARGET-g++ &&
    do_relink "$INSTALL_DIR"/bin/$TARGET-gcc-$GCC_VERSION $TARGET-gcc &&
    if [ -f "$INSTALL_DIR"/bin/$TARGET-ld.gold ]; then
      do_relink "$INSTALL_DIR"/bin/$TARGET-ld $TARGET-ld.gold
    else
      do_relink "$INSTALL_DIR"/bin/$TARGET-ld $TARGET-ld.bfd
    fi
    fail_panic

    # Remove unwanted $TARGET-run simulator to save about 800 KB.
    run2 rm -f "$INSTALL_DIR"/bin/$TARGET-run

    # Copy the license files
    local TOOLCHAIN_LICENSES="$ANDROID_NDK_ROOT"/build/tools/toolchain-licenses
    run cp -f "$TOOLCHAIN_LICENSES"/COPYING "$TOOLCHAIN_LICENSES"/COPYING.LIB "$INSTALL_DIR"
}

# $1: host system tag (e.g. linux-x86)
# $2: toolchain name (e.g. x86-4.4.3)
# $3: package directory.
package_gcc ()
{
    local SYSTEM=$1
    local TOOLCHAIN=$2
    local PACKAGE_DIR="$3"
    local PACKAGE_NAME="$TOOLCHAIN-$SYSTEM.tar.bz2"
    local PACKAGE_FILE="$PACKAGE_DIR/$PACKAGE_NAME"

    setup_build_for_toolchain $TOOLCHAIN

    dump "Packaging $PACKAGE_NAME."
    pack_archive "$PACKAGE_FILE" "$NDK_DIR" "$TOOLCHAIN_SUB_DIR"
}

setup_build

for PHASE in setup build; do
    for SYSTEM in $HOST_SYSTEMS; do
        setup_build_for_host $SYSTEM
        for TOOLCHAIN in $TOOLCHAINS; do
            build_gcc $SYSTEM $TOOLCHAIN
        done
    done
done

for SYSTEM in $HOST_SYSTEMS; do
    setup_build_for_host $SYSTEM
    for TOOLCHAIN in $TOOLCHAINS; do
        install_gcc $SYSTEM $TOOLCHAIN
    done
done

if [ "$PACKAGE_DIR" ]; then
    for SYSTEM in $HOST_SYSTEMS; do
        setup_build_for_host $SYSTEM
        for TOOLCHAIN in $TOOLCHAINS; do
            package_gcc $SYSTEM $TOOLCHAIN "$PACKAGE_DIR"
        done
    done
    echo "Done. See the content of $PACKAGE_DIR:"
    ls -l "$PACKAGE_DIR"
    echo ""
fi