#!/bin/sh

# Copyright 2014 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.

. $(dirname "$0")/common.shi
shell_import build-defaults.shi

case $(uname -s) in
    Linux)
        BUILD_OS=linux
        DEFAULT_SYSTEMS="linux-x86_64,windows-x86_64"
        ;;
    Darwin)
        BUILD_OS=darwin
        DEFAULT_SYSTEMS="darwin-x86_64"
        ;;
    *)
        panic "Your operating system is not supported!"
        ;;
esac

# List of valid target systems.
VALID_SYSTEMS="linux-x86,linux-x86_64,windows-x86,windows-x86_64,darwin-x86,darwin-x86_64"
VALID_TARGETS="arm,arm64,x86,x86_64,mips,mips64"

DEFAULT_TARGETS=arm64

OPT_BUILD_DIR=
OPT_DARWIN_SSH=
OPT_HELP=
OPT_NO_CCACHE=
OPT_NUM_JOBS=
OPT_SYSTEM=
OPT_USE_SDL1=
OPT_TARGET=

for OPT; do
    OPTARG=$(expr "x$OPT" : "x[^=]*=\\(.*\\)" || true)
    case $OPT in
        --build-dir=*)
            OPT_BUILD_DIR=$OPTARG
            ;;
        --darwin-ssh=*)
            OPT_DARWIN_SSH=$OPTARG
            ;;
        --help|-?)
            OPT_HELP=true
            ;;
        -j*)
            OPT_NUM_JOBS=${OPT##-j}
            ;;
        --jobs=*)
            OPT_NUM_JOBS=$OPTARG
            ;;
        --no-ccache)
            OPT_NO_CCACHE=true
            ;;
        --quiet)
            decrement_verbosity
            ;;
        --system=*)
            OPT_SYSTEM=$OPTARG
            ;;
        --target=*)
            OPT_TARGET="$OPT_TARGET $OPTARG"
            ;;
        --use-sdl1)
            OPT_USE_SDL1=true
            ;;
        --verbose)
            increment_verbosity
            ;;
        -*)
            panic "Unknown option '$OPT', see --help."
            ;;
        *)
            PARAM_COUNT=$(( $PARAM_COUNT + 1))
            var_assign PARAM_${PARAM_COUNT} "$OPT"
            ;;
    esac
done

if [ "$OPT_HELP" ]; then
    cat <<EOF
Usage: $(program_name) [options]  <qemu-android-dir> <aosp-dir>

Rebuild qemu-android binaries from scratch. This requires two other
directories to be available:

  <qemu-android-dir>
      Path to a checkout of the QEMU-Android sources from
      https://qemu-android.googlesource.com/qemu-android

  <aosp-dir>
      Path to a checkout of an AOSP workspace. This is only used to
      use the prebuilts toolchains under prebuilts/gcc/

By default, everything is rebuilt in a temporary directory that is
automatically removed after script completion (and after the binaries are
copied into binaries/). This is very long due to the dependencies.

When performing incremental builds, it is HIGHLY recommended to use the
--build-dir=<path> option. This ensures that the dependencies are only
rebuilt once and kept under <path>. Note that the build directory will
also not be removed by the script in this case.

Valid options:
    --help|-?           Print this message.
    --verbose           Increase verbosity.
    --quiet             Decrease verbosity.
    --system=<list>     List of host systems [$DEFAULT_SYSTEMS].
    --darwin-ssh=<host> Perform remote build through SSH.
    --build-dir=<path>  Use specific build directory (default is temporary).
    --no-ccache         Don't try to probe and use ccache during build.
    -j<count>           Run <count> parallel build jobs.
    --jobs=<count>      Same as -j<count>.
    --target=<name>     Build binary for target <name> [$DEFAULT_TARGETS].
    --use-sdl1          Use SDL 1.x instead of SDL 2.x.

EOF
    exit 0
fi

##
## Handle host system list
##
if [ "$OPT_SYSTEM" ]; then
    SYSTEMS=$(commas_to_spaces "$OPT_SYSTEM")
else
    SYSTEMS=$(commas_to_spaces "$DEFAULT_SYSTEMS")
    log "Auto-config: --system='$SYSTEMS'"
fi

BAD_SYSTEMS=
for SYSTEM in $SYSTEMS; do
    if ! list_contains "$VALID_SYSTEMS" "$SYSTEM"; then
        BAD_SYSTEMS="$BAD_SYSTEMS $SYSTEM"
    fi
done
if [ "$BAD_SYSTEMS" ]; then
    panic "Invalid system name(s): [$BAD_SYSTEMS], use one of: $VALID_SYSTEMS"
fi

##
## Handle target system list
##
if [ "$OPT_TARGET" ]; then
    TARGETS=$(commas_to_spaces "$OPT_TARGET")
else
    TARGETS=$(commas_to_spaces "$DEFAULT_TARGETS")
    log "Auto-config: --target='$TARGETS'"
fi

BAD_TARGETS=
for TARGET in $TARGETS; do
    if ! list_contains "$VALID_TARGETS" "$TARGET"; then
        BAD_TARGETS="$BAD_TARGETS $TARGET"
    fi
done
if [ "$BAD_TARGETS" ]; then
    panic "Invalid target name(s): [$BAD_TARGETS], use one of: $VALID_TARGETS"
fi

##
## Handle remote darwin build
##
DARWIN_SSH=
if [ "$OPT_DARWIN_SSH" ]; then
    DARWIN_SSH=$OPT_DARWIN_SSH
elif [ "$ANDROID_EMULATOR_DARWIN_SSH" ]; then
    DARWIN_SSH=$ANDROID_EMULATOR_DARWIN_SSH
    log "Auto-config: --darwin-ssh=$DARWIN_SSH  [ANDROID_EMULATOR_DARWIN_SSH]"
fi

if [ "$DARWIN_SSH" ]; then
    HAS_DARWIN=
    for SYSTEM in $(commas_to_spaces "$SYSTEMS"); do
        case $SYSTEM in
            darwin-*)
                HAS_DARWIN=true
                ;;
        esac
    done
    if [ -z "$HAS_DARWIN" ]; then
        SYSTEMS="$SYSTEMS darwin-x86_64"
        log "Auto-config: --system='$SYSTEMS'  [darwin-ssh]"
    fi
fi

##
##  Parameters checks
##
if [ "$PARAM_COUNT" != 2 ]; then
    panic "This script requires two arguments, see --help for details."
fi

QEMU_ANDROID=$PARAM_1
if [ ! -f "$QEMU_ANDROID/include/qemu-common.h" ]; then
    panic "Not a valid qemu-android source directory: $QEMU_ANDROID"
fi

# Sanity check: a fresh qemu-android checkout is missing the libfdt
# sub-module and won't compile without it
if [ ! -f "$QEMU_ANDROID/dtc/Makefile" ]; then
    >&2 cat <<EOF
ERROR: Your qemu-android checkout does not have the device-tree library
       submodule (libfdt, a.k.a. DTC) checked out. Please run the
       following command, then re-run this script:

  (cd $QEMU_ANDROID && git submodule update --init dtc)

EOF
    exit 1
fi

# Sanity check: We need the 'ranchu' branch checked out in qemu-android
if [ ! -f "$QEMU_ANDROID/hw/misc/android_pipe.c" ]; then
    >&2 cat <<EOF
ERROR: Your qemu-android checkout is not from the 'ranchu' branch. Please
       run the following command an re-run this script:

  (cd $QEMU_ANDROID && git checkout origin/ranchu)

EOF
    exit 1
fi

AOSP_SOURCE_DIR=$PARAM_2
if [ ! -d "$AOSP_SOURCE_DIR"/prebuilts/gcc ]; then
    panic "Not a valid AOSP checkout directory: $AOSP_SOURCE_DIR"
fi

# Do we have ccache ?
if [ -z "$OPT_NO_CCACHE" ]; then
    CCACHE=$(which ccache 2>/dev/null || true)
    if [ "$CCACHE" ]; then
        log "Found ccache as: $CCACHE"
    else
        log "Cannot find ccache in PATH."
    fi
fi

ARCHIVE_DIR=$(dirname "$0")/../archive
if [ ! -d "$ARCHIVE_DIR" ]; then
    panic "Missing archive directory: $ARCHIVE_DIR"
fi
ARCHIVE_DIR=$(cd "$ARCHIVE_DIR" && pwd -P)
log "Using archive directory: $ARCHIVE_DIR"

case $BUILD_OS in
    darwin)
        # Force the use of the 10.8 SDK on OS X, this
        # ensures that the generated binaries run properly
        # on that platform, and also avoids build failures
        # in SDL!!
        export SDKROOT=macosx10.8
        ;;
esac

if [ "$OPT_BUILD_DIR" ]; then
    TEMP_DIR=$OPT_BUILD_DIR
else
    TEMP_DIR=/tmp/$USER-build-qemu-ranchu-$$
    log "Auto-config: --build-dir=$TEMP_DIR"
fi
run mkdir -p "$TEMP_DIR" ||
panic "Could not create build directory: $TEMP_DIR"

cleanup_temp_dir () {
    rm -rf "$TEMP_DIR"
    exit $1
}

if [ -z "$OPT_BUILD_DIR" ]; then
    # Ensure temporary directory is deleted on script exit, unless
    # --build-dir=<path> was used.
    trap "cleanup_temp_dir 0" EXIT
    trap "cleanup_temp_dir \$?" QUIT INT HUP
fi

log "Cleaning up build directory."
run rm -rf "$TEMP_DIR"/build-*

if [ "$OPT_NUM_JOBS" ]; then
    NUM_JONS=$OPT_NUM_JOBS
    log "Parallel jobs count: $NUM_JOBS"
else
    NUM_JOBS=$(get_build_num_cores)
    log "Auto-config: --jobs=$NUM_JOBS"
fi

ORIGINAL_PATH=$PATH

export PKG_CONFIG=$(which pkg-config 2>/dev/null)
if [ "$PKG_CONFIG" ]; then
    log "Found pkg-config at: $PKG_CONFIG"
else
    log "pkg-config is not installed on this system."
fi

# Prepare the build for a given host system.
# $1: Host system name (e.g. linux-x86_64)
prepare_build_for_host () {
    CURRENT_HOST=$1

    CURRENT_TEXT="[$CURRENT_HOST]"

    HOST_EXE_EXTENSION=
    case $CURRENT_HOST in
        windows-*)
            HOST_EXE_EXTENSION=.exe
            ;;
        *)
            ;;
    esac

    case $CURRENT_HOST in
        linux-x86_64)
            GNU_CONFIG_HOST=x86_64-linux
            ;;
        linux-x86)
            GNU_CONFIG_HOST=i686-linux
            ;;
        windows-x86)
            GNU_CONFIG_HOST=i686-w64-mingw32
            ;;
        windows-x86_64)
            GNU_CONFIG_HOST=x86_64-w64-mingw32
            ;;
        darwin-*)
            # Use host compiler.
            GNU_CONFIG_HOST=
            ;;
        *)
            panic "Host system '$CURRENT_HOST' is not supported by this script!"
            ;;
    esac

    if [ "$GNU_CONFIG_HOST" ]; then
        GNU_CONFIG_HOST_FLAG="--host=$GNU_CONFIG_HOST"
        GNU_CONFIG_HOST_PREFIX=${GNU_CONFIG_HOST}-
    else
        GNU_CONFIG_HOST_FLAG=
        GNU_CONFIG_HOST_PREFIX=
    fi

    PATH=$ORIGINAL_PATH

    BUILD_DIR=$TEMP_DIR/build-$CURRENT_HOST
    log "$CURRENT_TEXT Creating build directory: $BUILD_DIR"
    run mkdir -p "$BUILD_DIR"
    run rm -rf "$BUILD_DIR"/*

    PREFIX=$TEMP_DIR/install-$CURRENT_HOST
    log "$CURRENT_TEXT Using build prefix: $PREFIX"

    if [ "$GNU_CONFIG_HOST" ]; then
      log "$CURRENT_TEXT Generating $GNU_CONFIG_HOST wrapper toolchain in $TOOLCHAIN_WRAPPER_DIR"
      TOOLCHAIN_WRAPPER_DIR=$BUILD_DIR/toolchain-wrapper
      if [ "$CCACHE" ]; then
          CCACHE_FLAGS="--ccache=$CCACHE"
      else
          CCACHE_FLAGS="--no-ccache"
      fi
      run $(program_directory)/gen-android-sdk-toolchain.sh \
            --aosp-dir=$AOSP_SOURCE_DIR \
            --host=$CURRENT_HOST \
            --binprefix=$GNU_CONFIG_HOST \
            --prefix=$PREFIX \
            $CCACHE_FLAGS \
            $TOOLCHAIN_WRAPPER_DIR
      PATH=$TOOLCHAIN_WRAPPER_DIR:$PATH
      log "$CURRENT_TEXT Path: $(echo \"$PATH\" | tr ' ' '\n')"
    fi

    # Save environment definitions to file.
    set > $BUILD_DIR/environment.txt
}

# Handle zlib, only on Win32 because the zlib configure script
# doesn't know how to generate a static library with -fPIC!
do_windows_zlib_package () {
    local ZLIB_VERSION ZLIB_PACKAGE
    local LOC LDFLAGS
    case $CURRENT_HOST in
        windows-x86)
            LOC=-m32
            LDFLAGS=-m32
            ;;
        windows-x86_64)
            LOC=-m64
            LDFLAGS=-m64
            ;;
    esac
    ZLIB_VERSION=$(get_source_package_version zlib)
    dump "$CURRENT_TEXT Building zlib-$ZLIB_VERSION"
    ZLIB_PACKAGE=$(get_source_package_name zlib)
    unpack_archive "$ARCHIVE_DIR/$ZLIB_PACKAGE" "$BUILD_DIR"
    (
        run cd "$BUILD_DIR/zlib-$ZLIB_VERSION" &&
        export BINARY_PATH=$PREFIX/bin &&
        export INCLUDE_PATH=$PREFIX/include &&
        export LIBRARY_PATH=$PREFIX/lib &&
        run make -fwin32/Makefile.gcc install PREFIX=$GNU_CONFIG_HOST_PREFIX LOC=$LOC LDFLAGS=$LDFLAGS
    )
}

do_zlib_package () {
    local ZLIB_VERSION ZLIB_PACKAGE
    local LOC LDFLAGS
    case $CURRENT_HOST in
        *-x86)
            LOC=-m32
            LDFLAGS=-m32
            ;;
        *-x86_64)
            LOC=-m64
            LDFLAGS=-m64
            ;;
    esac
    ZLIB_VERSION=$(get_source_package_version zlib)
    dump "$CURRENT_TEXT Building zlib-$ZLIB_VERSION"
    ZLIB_PACKAGE=$(get_source_package_name zlib)
    unpack_archive "$ARCHIVE_DIR/$ZLIB_PACKAGE" "$BUILD_DIR"
    (
        run cd "$BUILD_DIR/zlib-$ZLIB_VERSION" &&
        export CROSS_PREFIX=${GNU_CONFIG_HOST_PREFIX} &&
        run ./configure --prefix=$PREFIX &&
        run make -j$NUM_JOBS &&
        run make install
    )
}

require_program () {
    local VARNAME PROGNAME CMD
    VARNAME=$1
    PROGNAME=$2
    CMD=$(which $PROGNAME 2>/dev/null)
    if [ -z "$CMD" ]; then
        panic "Cannot find required build executable: $PROGNAME"
    fi
    eval $VARNAME=\'$CMD\'
}

# Unpack and patch GLib sources
# $1: Unversioned package name (e.g. 'glib')
unpack_and_patch () {
    local PKG_NAME="$1"
    local PKG_VERSION PKG_PACKAGE PKG_PATCHES_DIR PKG_PATCHES_PACKAGE
    local PKG_DIR PATCH
    PKG_VERSION=$(get_source_package_version $PKG_NAME)
    if [ -z "$PKG_VERSION" ]; then
        panic "Cannot find version for package $PKG_NAME!"
    fi
    log "Extracting $PKG_NAME-$PKG_VERSION"
    PKG_PACKAGE=$(get_source_package_name $PKG_NAME)
    unpack_archive "$ARCHIVE_DIR/$PKG_PACKAGE" "$BUILD_DIR" ||
    panic "Could not unpack $PKG_NAME-$PKG_VERSION"
    PKG_DIR=$BUILD_DIR/$PKG_NAME-$PKG_VERSION

    PKG_PATCHES_DIR=$PKG_NAME-$PKG_VERSION-patches
    PKG_PATCHES_PACKAGE=$ARCHIVE_DIR/${PKG_PATCHES_DIR}.tar.xz
    if [ -f "$PKG_PATCHES_PACKAGE" ]; then
        log "Patching $PKG_NAME-$PKG_VERSION"
        unpack_archive "$PKG_PATCHES_PACKAGE" "$BUILD_DIR"
        for PATCH in $(cd "$BUILD_DIR" && ls "$PKG_PATCHES_DIR"/*.patch); do
            log "Applying patch: $PATCH"
            (cd "$PKG_DIR" && run patch -p1 < "../$PATCH") ||
                    panic "Could not apply $PATCH"
        done
    fi
}

# Cross-compiling glib for Win32 is broken and requires special care.
# The following was inspired by the glib.mk from MXE (http://mxe.cc/)
# $1: bitness (32 or 64)
do_windows_glib_package () {
    unpack_and_patch glib
    local GLIB_VERSION GLIB_PACKAGE GLIB_DIR
    GLIB_VERSION=$(get_source_package_version glib)
    GLIB_DIR=$BUILD_DIR/glib-$GLIB_VERSION
    dump "$CURRENT_TEXT Building glib-$GLIB_VERSION"
    require_program GLIB_GENMARSHAL glib-genmarshal
    require_program GLIB_COMPILE_SCHEMAS glib-compile-schemas
    require_program GLIB_COMPILE_RESOURCES glib-compile-resources
    (
        run cd "$GLIB_DIR" &&
        export LDFLAGS="-L$PREFIX/lib -L$PREFIX/lib$1" &&
        export CPPFLAGS="-I$PREFIX/include -I$GLIB_DIR -I$GLIB_DIR/glib" &&
        export CC=${GNU_CONFIG_HOST_PREFIX}gcc &&
        export CXX=${GNU_CONFIG_HOST_PREFIX}c++ &&
        export PKG_CONFIG=$(which pkg-config) &&
        export PKG_CONFIG_PATH=$PREFIX/lib/pkgconfig &&
        run ./configure \
            --prefix=$PREFIX \
            $GNU_CONFIG_HOST_FLAG \
            --disable-shared \
            --with-threads=win32 \
            --with-pcre=internal \
            --disable-debug \
            --disable-man \
            --with-libiconv=no \
            GLIB_GENMARSHAL=$GLIB_GENMARSHAL \
            GLIB_COMPILE_SCHEMAS=$GLIB_COMPILE_SCHEMAS \
            GLIB_COMPILE_RESOURCES=$GLIB_COMPILE_RESOURCES &&

        # Necessary to build gio stuff properly.
        run ln -s "$GLIB_COMPILE_RESOURCES" gio/ &&

        run make -j$NUM_JOBS -C glib install sbin_PROGRAMS= noinst_PROGRAMS= &&
        run make -j$NUM_JOBS -C gmodule install bin_PROGRAMS= sbin_PROGRAMS= noinst_PROGRAMS= &&
        run make -j$NUM_JOBS -C gthread install bin_PROGRAMS= sbin_PROGRAMS= noinst_PROGRAMS= &&
        run make -j$NUM_JOBS -C gobject install bin_PROGRAMS= sbin_PROGRAMS= noinst_PROGRAMS= &&
        run make -j$NUM_JOBS -C gio install bin_PROGRAMS= sbin_PROGRAMS= noinst_PROGRAMS= MISC_STUFF= &&
        run make -j$NUM_JOBS install-pkgconfigDATA &&
        run make -j$NUM_JOBS -C m4macros install &&

        # Missing -lole32 results in link failure later!
        sed -i -e 's|\-lglib-2.0|-lglib-2.0 -lole32|g' \
            $PREFIX/lib/pkgconfig/glib-2.0.pc
    )
}

# Generic routine used to unpack and rebuild a generic auto-tools package
# $1: package name, unversioned and unsuffixed (e.g. 'libpng')
# $2+: extra configuration flags
do_autotools_package () {
    local PKG PKG_VERSION PKG_NAME
    PKG=$1
    shift
    unpack_and_patch $PKG
    PKG_VERSION=$(get_source_package_version $PKG)
    PKG_NAME=$(get_source_package_name $PKG)
    dump "$CURRENT_TEXT Building $PKG-$PKG_VERSION"
    (
        run cd "$BUILD_DIR/$PKG-$PKG_VERSION" &&
        export LDFLAGS="-L$PREFIX/lib" &&
        export CPPFLAGS="-I$PREFIX/include" &&
        export PKG_CONFIG_LIBDIR="$PREFIX/lib/pkgconfig" &&
        run ./configure \
            --prefix=$PREFIX \
            $GNU_CONFIG_HOST_FLAG \
            --disable-shared \
            --with-pic \
            "$@" &&
        run make -j$NUM_JOBS V=1 &&
        run make install V=1
    ) ||
    panic "Could not build and install $PKG_NAME"
}

# $1: host os name.
build_qemu_android_deps () {
    prepare_build_for_host $1

    export PKG_CONFIG_PATH=$PREFIX/lib/pkgconfig
    # Handle zlib for Windows
    case $1 in
        windows-*)
            do_windows_zlib_package
            ;;
        *)
            do_zlib_package
            ;;
    esac

    # libffi is required by glib.
    do_autotools_package libffi

    # Must define LIBFFI_CFLAGS and LIBFFI_LIBS to ensure
    # that GLib picks it up properly. Note that libffi places
    # its headers and libraries in uncommon places.
    LIBFFI_VERSION=$(get_source_package_version libffi)
    LIBFFI_CFLAGS="-I$PREFIX/lib/libffi-$LIBFFI_VERSION/include"
    LIBFFI_LIBS="$PREFIX/lib/libffi.la"
    if [ ! -f "$LIBFFI_LIBS" ]; then
        LIBFFI_LIBS="$PREFIX/lib64/libffi.la"
    fi
    if [ ! -f "$LIBFFI_LIBS" ]; then
        LIBFFI_LIBS="$PREFIX/lib32/libffi.la"
    fi
    if [ ! -f "$LIBFFI_LIBS" ]; then
        panic "Cannot locate libffi libraries!"
    fi

    log "Using LIBFFI_CFLAGS=[$LIBFFI_CFLAGS]"
    log "Using LIBFFI_LIBS=[$LIBFFI_LIBS]"
    export LIBFFI_CFLAGS LIBFFI_LIBS

    # libiconv and gettext are needed on Darwin only
    case $1 in
        darwin-*)
            do_autotools_package libiconv
            do_autotools_package gettext \
                --disable-rpath \
                --disable-acl \
                --disable-curses \
                --disable-openmp \
                --disable-java \
                --disable-native-java \
                --without-emacs \
                --disable-c++ \
                --without-libexpat-prefix
            ;;
    esac

    # glib is required by pkg-config and qemu-android
    case $1 in
        windows-x86)
            do_windows_glib_package 32
            ;;
        windows-x86_64)
            do_windows_glib_package 64
            ;;
        *)
            do_autotools_package glib \
                --disable-always-build-tests \
                --disable-debug \
                --disable-fam \
                --disable-included-printf \
                --disable-installed-tests \
                --disable-libelf \
                --disable-man \
                --disable-selinux \
                --disable-xattr
            ;;
    esac

    # Export these to ensure that pkg-config picks them up properly.
    export GLIB_CFLAGS="-I$PREFIX/include/glib-2.0 -I$PREFIX/lib/glib-2.0/include"
    export GLIB_LIBS="$PREFIX/lib/libglib-2.0.la"
    case $BUILD_OS in
        darwin)
            GLIB_LIBS="$GLIB_LIBS -Wl,-framework,Carbon -Wl,-framework,Foundation"
            ;;
    esac

    # pkg-config is required by qemu-android, and not available on
    # Windows and OS X
    do_autotools_package pkg-config \
        --without-pc-path \
        --disable-host-tool

    # Handle libpng
    do_autotools_package libpng

    do_autotools_package pixman \
        --disable-gtk \
        --disable-libpng

    if [ "$OPT_USE_SDL1" ]; then
        EXTRA_SDL_FLAGS=
        case $BUILD_OS in
            darwin)
                EXTRA_SDL_FLAGS="--disable-video-x11"
                ;;
        esac
        do_autotools_package SDL \
            --disable-audio \
            --disable-joystick \
            --disable-cdrom \
            --disable-file \
            --disable-threads \
            $EXTRA_SDL_FLAGS

        # The SDL build script install a buggy sdl.pc when cross-compiling for
        # Windows as a static library. I.e. it lacks many of the required
        # libraries, that are part of --static-libs. Patch it directly
        # instead.
        case $1 in
            windows-*)
                sed -i -e 's|^Libs: -L\${libdir}  -lmingw32 -lSDLmain -lSDL  -mwindows|Libs: -lmingw32 -lSDLmain -lSDL  -mwindows -lm -luser32 -lgdi32 -lwinmm -ldxguid|g' $PREFIX/lib/pkgconfig/sdl.pc
                ;;
        esac

        SDL_CONFIG=$PREFIX/bin/sdl-config

    else  # !OPT_USE_SDL1

        do_autotools_package SDL2

        SDL_CONFIG=$PREFIX/bin/sdl2-config

    fi  # !OPT_USE_SDL1

    PKG_CONFIG_LIBDIR=$PREFIX/lib/pkgconfig
    case $1 in
        windows-*)
            # Use the host version, or the build will freeze.
            PKG_CONFIG=pkg-config
            ;;
        *)
            PKG_CONFIG=$PREFIX/bin/pkg-config
            ;;
    esac
    export SDL_CONFIG PKG_CONFIG PKG_CONFIG_LIBDIR

    # Create script to setup the environment correctly for the
    # later qemu-android build.
    ENV_SH=$TEMP_DIR/env-$CURRENT_HOST.sh
    cat > $ENV_SH <<EOF
# Auto-generated automatically - DO NOT EDIT
export PREFIX=$PREFIX
export LIBFFI_CFLAGS="$LIBFFI_CFLAGS"
export LIBFFI_LIBS="$LIBFFI_LIBS"
export GLIB_CFLAGS="$GLIB_CFLAGS"
export GLIB_LIBS="$GLIB_LIBS"
export SDL_CONFIG=$SDL_CONFIG
export PKG_CONFIG=$PKG_CONFIG
export PKG_CONFIG_LIBDIR=$PKG_CONFIG_LIBDIR
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH
export PATH=$PATH
EOF
}

# $1: host os name.
build_qemu_android () {
    prepare_build_for_host $1

    ENV_SH=$TEMP_DIR/env-$CURRENT_HOST.sh
    if [ ! -f "$ENV_SH" ]; then
        build_qemu_android_deps $1
    fi

    . "$ENV_SH"

    QEMU_TARGETS=
    QEMU_TARGET_LIST=
    for TARGET in $TARGETS; do
        case $TARGET in
            arm64)
                QEMU_TARGET=aarch64
                ;;
            x86)
                QEMU_TARGET=i386
                ;;
            mips)
                QEMU_TARGET=mipsel
                ;;
            mips64)
                QEMU_TARGET=mips64el
                ;;
            *)
                QEMU_TARGET=$TARGET
                ;;
        esac
        QEMU_TARGETS="$QEMU_TARGETS $QEMU_TARGET"
        QEMU_TARGET_LIST="$QEMU_TARGET_LIST ${QEMU_TARGET}-softmmu"
    done
    QEMU_TARGET_LIST=${QEMU_TARGET_LIST##\ }

    dump "$CURRENT_TEXT Building qemu-android"
    log "Qemu targets: $QEMU_TARGETS"

    (
        run mkdir -p "$BUILD_DIR/qemu-android"
        run rm -rf "$BUILD_DIR"/qemu-android/*
        run cd "$BUILD_DIR/qemu-android"
        EXTRA_LDFLAGS="-L$PREFIX/lib"
        case $1 in
           darwin-*)
               EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Carbon"
               ;;
           *)
               EXTRA_LDFLAGS="$EXTRA_LDFLAGS -static-libgcc -static-libstdc++"
               ;;
        esac
        case $1 in
            windows-*)
                ;;
            *)
                EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl -lm"
                ;;
        esac
        CROSS_PREFIX_FLAG=
        if [ "$GNU_CONFIG_HOST_PREFIX" ]; then
            CROSS_PREFIX_FLAG="--cross-prefix=$GNU_CONFIG_HOST_PREFIX"
        fi
        run $QEMU_ANDROID/configure \
            $CROSS_PREFIX_FLAG \
            --target-list="$QEMU_TARGET_LIST" \
            --prefix=$PREFIX \
            --extra-cflags="-I$PREFIX/include" \
            --extra-ldflags="$EXTRA_LDFLAGS" \
            --disable-attr \
            --disable-blobs \
            --disable-cap-ng \
            --disable-curses \
            --disable-docs \
            --disable-glusterfs \
            --disable-gtk \
            --disable-guest-agent \
            --disable-libnfs \
            --disable-libiscsi \
            --disable-libssh2 \
            --disable-libusb \
            --disable-quorum \
            --disable-seccomp \
            --disable-spice \
            --disable-smartcard-nss \
            --disable-usb-redir \
            --disable-user \
            --disable-vde \
            --disable-vhdx \
            --disable-vhost-net \
            &&

            # The Windows parallel build fails early on, so try to catch
            # up later with -j1 to complete it.
            (run make -j$NUM_JOBS || run make -j1 || true)

            for QEMU_TARGET in $QEMU_TARGETS; do
                if [ ! -f "$QEMU_TARGET-softmmu/qemu-system-$QEMU_TARGET$HOST_EXE_EXTENSION" ]; then
                    panic "$CURRENT_TEXT Could not build qemu-system-$QEMU_TARGET!!"
                fi
            done

    ) || panic "Build failed!!"

    BINARY_DIR=$(program_directory)/../binaries/$CURRENT_HOST
    run mkdir -p "$BINARY_DIR" ||
    panic "Could not create final directory: $BINARY_DIR"

    for QEMU_TARGET in $QEMU_TARGETS; do
        QEMU_EXE=qemu-system-${QEMU_TARGET}${HOST_EXE_EXTENSION}
        dump "$CURRENT_TEXT Copying $QEMU_EXE to binaries/$CURRENT_HOST"

        run cp -p \
            "$BUILD_DIR"/qemu-android/$QEMU_TARGET-softmmu/$QEMU_EXE \
            "$BINARY_DIR"/$QEMU_EXE

        run ${GNU_CONFIG_HOST_PREFIX}strip "$BINARY_DIR"/$QEMU_EXE
    done

    unset PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR SDL_CONFIG
    unset LIBFFI_CFLAGS LIBFFI_LIBS GLIB_CFLAGS GLIB_LIBS
}

# Perform a Darwin build through ssh to a remote machine.
# $1: Darwin host name.
# $2: List of darwin target systems to build for.
do_remote_darwin_build () {
    local PKG_TMP=/tmp/$USER-rebuild-darwin-ssh-$$
    local PKG_SUFFIX=qemu-android-build
    local PKG_DIR=$PKG_TMP/$PKG_SUFFIX
    local PKG_TARBALL=$PKG_SUFFIX.tar.bz2
    local DARWIN_SSH="$1"
    local DARWIN_SYSTEMS="$2"

    DARWIN_SYSTEMS=$(commas_to_spaces "$DARWIN_SYSTEMS")

    dump "Creating tarball for remote darwin build."
    run mkdir -p "$PKG_DIR" && run rm -rf "$PKG_DIR"/*
    run cp -rp "$QEMU_ANDROID" "$PKG_DIR/qemu-android"
    run mkdir -p "$PKG_DIR/aosp/prebuilts/gcc"
    run cp -rp "$(program_directory)" "$PKG_DIR/scripts"
    run cp -rp "$(program_directory)/../archive" "$PKG_DIR/archive"
    local EXTRA_FLAGS=""

    case $(get_verbosity) in
        0)
            # pass
            ;;
        1)
            EXTRA_FLAGS="$EXTRA_FLAGS --verbose"
            ;;
        *)
            EXTRA_FLAGS="$EXTRA_FLAGS --verbose --verbose"
            ;;
    esac

    if [ "$OPT_NUM_JOBS" ]; then
        EXTRA_FLAGS="$EXTRA_FLAGS -j$OPT_NUM_JOBS"
    fi
    if [ "$OPT_NO_CCACHE" ]; then
        EXTRA_FLAGS="$EXTRA_FLAGS --no-ccache"
    fi

    # Generate a script to rebuild all binaries from sources.
    # Note that the use of the '-l' flag is important to ensure
    # that this is run under a login shell. This ensures that
    # ~/.bash_profile is sourced before running the script, which
    # puts MacPorts' /opt/local/bin in the PATH properly.
    #
    # If not, the build is likely to fail with a cryptic error message
    # like "readlink: illegal option -- f"
    cat > $PKG_DIR/build.sh <<EOF
#!/bin/bash -l
PROGDIR=\$(dirname \$0)
\$PROGDIR/scripts/rebuild.sh \\
    --build-dir=/tmp/$PKG_SUFFIX/build \\
    --system=$(spaces_to_commas "$DARWIN_SYSTEMS") \\
    $EXTRA_FLAGS \\
    /tmp/$PKG_SUFFIX/qemu-android \\
    /tmp/$PKG_SUFFIX/aosp
EOF
    chmod a+x $PKG_DIR/build.sh
    run tar cjf "$PKG_TMP/$PKG_TARBALL" -C "$PKG_TMP" "$PKG_SUFFIX"

    dump "Unpacking tarball in remote darwin host."
    run scp "$PKG_TMP/$PKG_TARBALL" "$DARWIN_SSH":/tmp/
    run ssh "$DARWIN_SSH" tar xf /tmp/$PKG_SUFFIX.tar.bz2 -C /tmp

    dump "Performing remote darwin build."
    run ssh "$DARWIN_SSH" /tmp/$PKG_SUFFIX/build.sh

    dump "Retrieving darwin binaries."
    local BINARY_DIR=$(program_directory)/../binaries
    run mkdir -p "$BINARY_DIR" ||
    panic "Could not create final directory: $BINARY_DIR"

    for SYSTEM in $DARWIN_SYSTEMS; do
        run scp -r "$DARWIN_SSH":/tmp/$PKG_SUFFIX/binaries/$SYSTEM $BINARY_DIR/
    done
}

# Special handling for Darwin target systems.
DARWIN_SYSTEMS=
for SYSTEM in $SYSTEMS; do
    case $SYSTEM in
        darwin-*)
            DARWIN_SYSTEMS="$DARWIN_SYSTEMS $SYSTEM"
            ;;
    esac
done

if [ "$DARWIN_SSH" ]; then
    # Perform remote Darwin build first.
    if [ "$DARWIN_SYSTEMS" ]; then
        do_remote_darwin_build "$DARWIN_SSH" "$DARWIN_SYSTEMS"
    elif [ "$OPT_DARWIN_SSH" ]; then
        panic "--darwin-ssh=<host> used, but --system does not list Darwin systems."
    fi
elif [ "$DARWIN_SYSTEMS" -a "$BUILD_OS" != "darwin" ]; then
    panic "Cannot build darwin binaries on this machine. Use --darwin-ssh=<host>."
fi

for SYSTEM in $SYSTEMS; do
    # Ignore darwin builds if we're not on a Darwin
    if [ "$BUILD_OS" != "darwin" ]; then
        case "$SYSTEM" in
            darwin-*)
                continue
                ;;
        esac
    fi

    build_qemu_android $SYSTEM
done

echo "Done!"