android-configure.sh

#!/bin/sh
#
# this script is used to rebuild the Android emulator from sources
# in the current directory. It also contains logic to speed up the
# rebuild if it detects that you're using the Android build system
#
# here's the list of environment variables you can define before
# calling this script to control it (besides options):
#
#

# first, let's see which system we're running this on
cd `dirname $0`

PROGNAME=`basename $0`
PROGDIR=`dirname $0`

## Logging support
##
VERBOSE=yes
VERBOSE2=no

panic () {
    echo "ERROR: $@"
    exit 1
}

log () {
    if [ "$VERBOSE" = "yes" ] ; then
        echo "$1"
    fi
}

log2 () {
    if [ "$VERBOSE2" = "yes" ] ; then
        echo "$1"
    fi
}

## Normalize OS and CPU
##

BUILD_ARCH=$(uname -m)
case "$BUILD_ARCH" in
    i?86) BUILD_ARCH=x86
    ;;
    x86_64|amd64) BUILD_ARCH=x86_64
    ;;
    *) panic "$BUILD_ARCH builds are not supported!"
    ;;
esac

log2 "BUILD_ARCH=$BUILD_ARCH"

# at this point, the supported values for CPU are:
#   x86
#   x86_64
#
# other values may be possible but haven't been tested
#

BUILD_EXEEXT=
BUILD_OS=`uname -s`
case "$BUILD_OS" in
    Darwin) BUILD_OS=darwin;;
    Linux) BUILD_OS=linux;;
    FreeBSD) BUILD_OS=freebsd;;
    CYGWIN*|*_NT-*)
        panic "Please build Windows binaries on Linux with --mingw option."
        ;;
    *) panic "Unknown build OS: $BUILD_OS";;
esac

BUILD_TAG=$BUILD_OS-$BUILD_ARCH

log2 "BUILD_TAG=$BUILD_TAG"
log2 "BUILD_EXEEXT=$BUILD_EXEEXT"

HOST_OS=$BUILD_OS
HOST_ARCH=$BUILD_ARCH
HOST_TAG=$HOST_OS-$HOST_ARCH

#### Toolchain support
####

WINDRES=

# Various probes are going to need to run a small C program
TMPC=/tmp/android-$$-test.c
TMPO=/tmp/android-$$-test.o
TMPE=/tmp/android-$$-test$BUILD_EXEEXT
TMPL=/tmp/android-$$-test.log

# cleanup temporary files
clean_temp () {
    rm -f $TMPC $TMPO $TMPL $TMPLE
}

# cleanup temp files then exit with an error
clean_exit () {
    clean_temp
    exit 1
}

# this function will setup the compiler and linker and check that they work as advertized
setup_toolchain () {
    if [ -z "$CC" ] ; then
        CC=gcc
    fi

    # check that we can compile a trivial C program with this compiler
    cat > $TMPC <<EOF
int main(void) {}
EOF
    compile
    if [ $? != 0 ] ; then
        echo "your C compiler doesn't seem to work: $CC"
        cat $TMPL
        clean_exit
    fi
    log "CC         : compiler check ok ($CC)"
    CC_VER=`$CC --version`
    log "CC_VER     : $CC_VER"

    # check that we can link the trivial program into an executable
    if [ -z "$LD" ] ; then
        LD=$CC
    fi
    link
    if [ $? != 0 ] ; then
        echo "your linker doesn't seem to work:"
        cat $TMPL
        clean_exit
    fi
    log "LD         : linker check ok ($LD)"

    if [ -z "$AR" ]; then
        AR=ar
    fi
    log "AR         : archiver ($AR)"
    clean_temp
}

# try to compile the current source file in $TMPC into an object
# stores the error log into $TMPL
#
compile () {
    log2 "Object     : $CC -o $TMPO -c $CFLAGS $TMPC"
    $CC -o $TMPO -c $CFLAGS $TMPC 2> $TMPL
}

# try to link the recently built file into an executable. error log in $TMPL
#
link() {
    log2 "Link      : $LD -o $TMPE $TMPO $LDFLAGS"
    $LD -o $TMPE $TMPO $LDFLAGS 2> $TMPL
}

## Feature test support
##

# check that a given C header file exists on the host system
# $1: variable name which will be set to "yes" or "no" depending on result
# $2: header name
#
# you can define EXTRA_CFLAGS for extra C compiler flags
# for convenience, this variable will be unset by the function.
#
feature_check_header () {
    local result_ch OLD_CFLAGS
    log2 "HeaderCheck: $2"
    echo "#include $2" > $TMPC
    cat >> $TMPC <<EOF
        int main(void) { return 0; }
EOF
    OLD_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $EXTRA_CFLAGS"
    compile
    if [ $? != 0 ]; then
        result_ch=no
    else
        result_ch=yes
    fi
    log "HeaderCheck: $2 [$result_ch]"
    EXTRA_CFLAGS=
    CFLAGS=$OLD_CFLAGS
    eval $1=$result_ch
    clean_temp
}

# Find pattern $1 in string $2
# This is to be used in if statements as in:
#
#    if pattern_match <pattern> <string>; then
#       ...
#    fi
#
pattern_match () {
    echo "$2" | grep -q -E -e "$1"
}

# Find if a given shell program is available.
# We need to take care of the fact that the 'which <foo>' command
# may return either an empty string (Linux) or something like
# "no <foo> in ..." (Darwin). Also, we need to redirect stderr
# to /dev/null for Cygwin
#
# $1: variable name
# $2: program name
#
# Result: set $1 to the full path of the corresponding command
#         or to the empty/undefined string if not available
#
find_program () {
    local PROG
    PROG=`which $2 2>/dev/null || true`
    if [ -n "$PROG" ] ; then
        if pattern_match '^no ' "$PROG"; then
            PROG=
        fi
    fi
    eval $1="$PROG"
}

# Default value of --ui option.
UI_DEFAULT=qt

# Default value of --gles option.
GLES_DEFAULT=dgl

# Parse options
OPTION_PREBUILT_QEMU2=
OPTION_DEBUG=no
OPTION_SANITIZER=no
OPTION_EMUGL_PRINTOUT=no
OPTION_IGNORE_AUDIO=no
OPTION_AOSP_PREBUILTS_DIR=
OPTION_OUT_DIR=
OPTION_HELP=no
OPTION_STRIP=yes
OPTION_CRASHUPLOAD=
OPTION_MINGW=no
OPTION_GLES=
OPTION_SDK_REV=
OPTION_SYMBOLS=no
ANDROID_SDK_TOOLS_REVISION=
ANDROID_SDK_TOOLS_BUILD_NUMBER=

GLES_SUPPORT=no

PCBIOS_PROBE=yes

HOST_CC=${CC:-gcc}
OPTION_CC=

HOST_CXX=${CXX:-g++}
OPTION_CXX=

AOSP_PREBUILTS_DIR=$(dirname "$0")/../../prebuilts
if [ -d "$AOSP_PREBUILTS_DIR" ]; then
    AOSP_PREBUILTS_DIR=$(cd "$AOSP_PREBUILTS_DIR" && pwd -P 2>/dev/null)
else
    AOSP_PREBUILTS_DIR=
fi

for opt do
  optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
  case "$opt" in
  --help|-h|-\?) OPTION_HELP=yes
  ;;
  --verbose)
    if [ "$VERBOSE" = "yes" ] ; then
        VERBOSE2=yes
    else
        VERBOSE=yes
    fi
  ;;
  --verbosity=*)
    if [ "$optarg" -gt 1 ]; then
        VERBOSE=yes
        if [ "$optarg" -gt 2 ]; then
            VERBOSE2=yes
        fi
    fi
    ;;

  --debug) OPTION_DEBUG=yes; OPTION_STRIP=no
  ;;
  --mingw) OPTION_MINGW=yes
  ;;
  --sanitizer=*) OPTION_SANITIZER=$optarg
  ;;
  --emugl-printout) OPTION_EMUGL_PRINTOUT=yes
  ;;
  --cc=*) OPTION_CC="$optarg"
  ;;
  --cxx=*) OPTION_CXX="$optarg"
  ;;
  --strip) OPTION_STRIP=yes
  ;;
  --no-strip) OPTION_STRIP=no
  ;;
  --crash-staging) OPTION_CRASHUPLOAD=staging
  ;;
  --crash-prod) OPTION_CRASHUPLOAD=prod
  ;;
  --out-dir=*) OPTION_OUT_DIR=$optarg
  ;;
  --aosp-prebuilts-dir=*) OPTION_AOSP_PREBUILTS_DIR=$optarg
  ;;
  --prebuilt-qemu2) OPTION_PREBUILT_QEMU2=true
  ;;
  --no-pcbios) PCBIOS_PROBE=no
  ;;
  --no-tests)
  # Ignore this option, only used by android-rebuild.sh
  ;;
  --symbols) OPTION_SYMBOLS=yes
  ;;
  --no-symbols) OPTION_SYMBOLS=no
  ;;
  --gles=dgl) OPTION_GLES=dgl
  ;;
  --gles=angle) OPTION_GLES=angle
  ;;
  --gles=*) echo "Unknown --gles value, try one of: dgl angle"
  ;;
  --sdk-revision=*) ANDROID_SDK_TOOLS_REVISION=$optarg
  ;;
  --sdk-build-number=*) ANDROID_SDK_TOOLS_BUILD_NUMBER=$optarg
  ;;
  *)
    echo "unknown option '$opt', use --help"
    exit 1
  esac
done

# Print the help message
#
if [ "$OPTION_HELP" = "yes" ] ; then
    cat << EOF

Usage: rebuild.sh [options]
Options: [defaults in brackets after descriptions]
EOF
    echo "Standard options:"
    echo "  --help                      Print this message"
    echo "  --cc=PATH                   Specify C compiler [$HOST_CC]"
    echo "  --cxx=PATH                  Specify C++ compiler [$HOST_CXX]"
    echo "  --no-strip                  Do not strip emulator executables."
    echo "  --strip                     Strip emulator executables (default)."
    echo "  --symbols                   Generating Breakpad symbol files."
    echo "  --no-symbols                Do not generate Breakpad symbol files (default)."
    echo "  --crash-[staging,prod]      Send crashes to specific server (no crash reporting by default)."
    echo "  --gles=dgl                  Build the OpenGLES to Desktop OpenGL Translator (default)"
    echo "  --gles=angle                Build the OpenGLES to ANGLE wrapper"
    echo "  --aosp-prebuilts-dir=<path> Use specific prebuilt toolchain root directory [$AOSP_PREBUILTS_DIR]"
    echo "  --out-dir=<path>            Use specific output directory [objs/]"
    echo "  --mingw                     Build Windows executable on Linux"
    echo "  --verbose                   Verbose configuration"
    echo "  --debug                     Build debug version of the emulator"
    echo "  --sanitizer=[...]           Build with LLVM sanitizer (sanitizer=[address, thread])"
    echo "  --no-pcbios                 Disable copying of PC Bios files"
    echo "  --no-tests                  Don't run unit test suite"
    echo "  --prebuilt-qemu2            Don't build QEMU2 from sources, use prebuilts."
    echo ""
    exit 1
fi

if [ "$OPTION_AOSP_PREBUILTS_DIR" ]; then
    if [ ! -d "$OPTION_AOSP_PREBUILTS_DIR"/gcc -a \
         ! -d "$OPTION_AOSP_PREBUILTS_DIR"/clang ]; then
        echo "ERROR: Prebuilts directory does not exist: $OPTION_AOSP_PREBUILTS_DIR/gcc"
        exit 1
    fi
    AOSP_PREBUILTS_DIR=$OPTION_AOSP_PREBUILTS_DIR
fi

if [ -z "$OPTION_GLES" ]; then
    OPTION_GLES=$GLES_DEFAULT
    log "Auto-config: --gles=$OPTION_GLES"
fi

if [ "$OPTION_OUT_DIR" ]; then
    OUT_DIR="$OPTION_OUT_DIR"
    mkdir -p "$OUT_DIR" || panic "Could not create output directory: $OUT_DIR"
else
    OUT_DIR=objs
    log "Auto-config: --out-dir=objs"
fi

CCACHE=
if [ "$USE_CCACHE" != 0 ]; then
    CCACHE=$(which ccache 2>/dev/null || true)
fi

if [ -n "$CCACHE" -a -f "$CCACHE" ]; then
    if [ "$HOST_OS" = "darwin" -a "$OPTION_DEBUG" = "yes" ]; then
        # http://llvm.org/bugs/show_bug.cgi?id=20297
        # ccache works for mingw/gdb, therefore probably works for gcc/gdb
        log "Prebuilt   : CCACHE disabled for OSX debug builds"
        CCACHE=
    else
        log "Prebuilt   : CCACHE=$CCACHE"
    fi
else
    log "Prebuilt   : CCACHE can't be found"
    CCACHE=
fi

# Use gen-android-sdk-toolchain.sh to generate a toolchain that will
# build binaries compatible with the SDK deployement systems.
GEN_SDK=$PROGDIR/android/scripts/gen-android-sdk-toolchain.sh
GEN_SDK_FLAGS=--cxx11
if [ "$CCACHE" ]; then
    GEN_SDK_FLAGS="$GEN_SDK_FLAGS --ccache=$CCACHE"
else
    GEN_SDK_FLAGS="$GEN_SDK_FLAGS --no-ccache"
fi
SDK_TOOLCHAIN_DIR=$OUT_DIR/build/toolchain
GEN_SDK_FLAGS="$GEN_SDK_FLAGS --aosp-dir=$AOSP_PREBUILTS_DIR/.."
"$GEN_SDK" $GEN_SDK_FLAGS "$SDK_TOOLCHAIN_DIR" || panic "Cannot generate SDK toolchain!"
BINPREFIX=$("$GEN_SDK" $GEN_SDK_FLAGS --print=binprefix "$SDK_TOOLCHAIN_DIR")
CC="$SDK_TOOLCHAIN_DIR/${BINPREFIX}gcc"
CXX="$SDK_TOOLCHAIN_DIR/${BINPREFIX}g++"
AR="$SDK_TOOLCHAIN_DIR/${BINPREFIX}ar"
LD=$CC
OBJCOPY="$SDK_TOOLCHAIN_DIR/${BINPREFIX}objcopy"
TOOLCHAIN_SYSROOT="$("${GEN_SDK}" $GEN_SDK_FLAGS --print=sysroot "${SDK_TOOLCHAIN_DIR}")"

if [ -n "$OPTION_CC" ]; then
    echo "Using specified C compiler: $OPTION_CC"
    CC="$OPTION_CC"
fi

if [ -n "$OPTION_CXX" ]; then
    echo "Using specified C++ compiler: $OPTION_CXX"
    CC="$OPTION_CXX"
fi

setup_toolchain

BUILD_AR=$AR
BUILD_CC=$CC
BUILD_CXX=$CXX
BUILD_LD=$LD
BUILD_OBJCOPY=$OBJCOPY
BUILD_CFLAGS=$CFLAGS
BUILD_CXXFLAGS=$CXXFLAGS
BUILD_LDFLAGS=$LDFLAGS

# Teach make to build static executables where this makes sense. Darwin doesn't
# have a sane way of linking statically against system libraries at all.
if [ "$HOST_OS" = "darwin" ]; then
  BUILD_STATIC_FLAGS=
else
  BUILD_STATIC_FLAGS="-static"
fi

if [ "$OPTION_MINGW" = "yes" ] ; then
    # Are we on Linux ?
    log "Mingw      : Checking for Linux host"
    if [ "$HOST_OS" != "linux" ] ; then
        echo "Sorry, but mingw compilation is only supported on Linux !"
        exit 1
    fi
    GEN_SDK_FLAGS="$GEN_SDK_FLAGS --host=windows-x86_64"
    "$GEN_SDK" $GEN_SDK_FLAGS "$SDK_TOOLCHAIN_DIR" || panic "Cannot generate SDK toolchain!"
    BINPREFIX=$("$GEN_SDK" $GEN_SDK_FLAGS --print=binprefix "$SDK_TOOLCHAIN_DIR")
    CC="$SDK_TOOLCHAIN_DIR/${BINPREFIX}gcc"
    CXX="$SDK_TOOLCHAIN_DIR/${BINPREFIX}g++"
    LD=$CC
    WINDRES=$SDK_TOOLCHAIN_DIR/${BINPREFIX}windres
    AR="$SDK_TOOLCHAIN_DIR/${BINPREFIX}ar"
    OBJCOPY="$SDK_TOOLCHAIN_DIR/${BINPREFIX}objcopy"
    HOST_OS=windows
    HOST_TAG=$HOST_OS-$HOST_ARCH
fi

# Try to find the GLES emulation headers and libraries automatically
GLES_DIR=distrib/android-emugl
if [ ! -d "$GLES_DIR" ]; then
    panic "GLES       : Could not find GPU emulation sources!: $GLES_DIR"
else
    echo "GLES       : Found GPU emulation sources: $GLES_DIR"
fi

if [ "$PCBIOS_PROBE" = "yes" ]; then
    PCBIOS_DIR=$AOSP_PREBUILTS_DIR/qemu-kernel/x86/pc-bios
    if [ ! -d "$PCBIOS_DIR" ]; then
        log2 "PC Bios    : Probing $PCBIOS_DIR (missing)"
        PCBIOS_DIR=../pc-bios
    fi
    log2 "PC Bios    : Probing $PCBIOS_DIR"
    if [ ! -d "$PCBIOS_DIR" ]; then
        log "PC Bios    : Could not find prebuilts directory."
    else
        mkdir -p $OUT_DIR/lib/pc-bios || panic "Could not create dir $OUT_DIR/lib/pc-bios"
        for BIOS_FILE in bios.bin vgabios-cirrus.bin bios-256k.bin efi-virtio.rom kvmvapic.bin linuxboot.bin; do
            log "PC Bios    : Copying $BIOS_FILE"
            cp -f $PCBIOS_DIR/$BIOS_FILE $OUT_DIR/lib/pc-bios/$BIOS_FILE ||
                panic "Missing BIOS file: $PCBIOS_DIR/$BIOS_FILE"
        done
    fi
fi

setup_toolchain

###
###  Audio subsystems probes
###
PROBE_COREAUDIO=no
PROBE_ALSA=no
PROBE_OSS=no
PROBE_ESD=no
PROBE_PULSEAUDIO=no
PROBE_WINAUDIO=no

case "$HOST_OS" in
    darwin) PROBE_COREAUDIO=yes;
    ;;
    linux) PROBE_ALSA=yes; PROBE_OSS=yes; PROBE_ESD=yes; PROBE_PULSEAUDIO=yes;
    ;;
    freebsd) PROBE_OSS=yes;
    ;;
    windows) PROBE_WINAUDIO=yes
    ;;
esac

probe_prebuilts_dir () {
    local PREBUILTS_DIR
    PREBUILTS_DIR=$AOSP_PREBUILTS_DIR/android-emulator-build/$3
    if [ ! -d "$PREBUILTS_DIR" ]; then
        panic "Missing prebuilts directory: $PREBUILTS_DIR"
    fi
    log "$1 prebuilts dir: $PREBUILTS_DIR"
    eval $2=\$PREBUILTS_DIR
}

###
###  Zlib probe
###
probe_prebuilts_dir "Zlib" ZLIB_PREBUILTS_DIR qemu-android-deps

###
###  Libpng probe
###
probe_prebuilts_dir "Libpng" LIBPNG_PREBUILTS_DIR qemu-android-deps

###
###  Libxml2 probe
###
probe_prebuilts_dir "Libxml2" LIBXML2_PREBUILTS_DIR common/libxml2

###
###  Libcurl probe
###
probe_prebuilts_dir "LibCURL" LIBCURL_PREBUILTS_DIR curl

CACERTS_FILE="$PROGDIR/android/data/ca-bundle.pem"
if [ ! -f "$CACERTS_FILE" ]; then
    panic "Missing cacerts file: $CACERTS_FILE"
fi
mkdir -p $OUT_DIR/lib
cp -f "$CACERTS_FILE" "$OUT_DIR/lib/"

###
###  Breakpad probe
###
probe_prebuilts_dir "Breakpad" BREAKPAD_PREBUILTS_DIR common/breakpad
if [ "$OPTION_MINGW" = "yes" ] ; then
    DUMPSYMS=$BREAKPAD_PREBUILTS_DIR/$BUILD_TAG/bin/dump_syms_dwarf
else
    ##Mac and Linux builds
    DUMPSYMS=$BREAKPAD_PREBUILTS_DIR/$BUILD_TAG/bin/dump_syms
fi

###
###  Qt probe
###
QT_PREBUILTS_DIR=
probe_prebuilts_dir "Qt" QT_PREBUILTS_DIR qt

###
###  e2fsprogs probe
###
probe_prebuilts_dir "e2fsprogs" E2FSPROGS_PREBUILTS_DIR common/e2fsprogs

# create the objs directory that is going to contain all generated files
# including the configuration ones
#
mkdir -p $OUT_DIR

###
###  Compiler probe
###

####
####  Host system probe
####

# because the previous version could be read-only
clean_temp

# check whether we have <byteswap.h>
#
feature_check_header HAVE_BYTESWAP_H      "<byteswap.h>"
feature_check_header HAVE_MACHINE_BSWAP_H "<machine/bswap.h>"
feature_check_header HAVE_FNMATCH_H       "<fnmatch.h>"

# check for Mingw version.
if [ "$HOST_OS" = "windows" ]; then
log "Mingw      : Probing for GCC version."
GCC_VERSION=$($CC -v 2>&1 | awk '$1 == "gcc" && $2 == "version" { print $3; }')
GCC_MAJOR=$(echo "$GCC_VERSION" | cut -f1 -d.)
GCC_MINOR=$(echo "$GCC_VERSION" | cut -f2 -d.)
log "Mingw      : Found GCC version $GCC_MAJOR.$GCC_MINOR [$GCC_VERSION]"
MINGW_GCC_VERSION=$(( $GCC_MAJOR * 100 + $GCC_MINOR ))
fi
# Build the config.make file
#

PREBUILT_PATH_PAIRS=
PREBUILT_SYMPATH_PAIRS=

# Copy a single file
# $1: Source file path.
# $2: Destination file path (not a directory!)
copy_file () {
    local SRC_FILE="$1"
    local DST_FILE="$2"

    log2 "Copying $SRC_FILE -> $DST_FILE"

    case $DST_FILE in
        */)
            if [ ! -d "$DST_FILE" ]; then
                mkdir -p "${DST_FILE%%/}" ||
                        panic "Cannot create destination directory: $DST_FILE"
            fi
            DST_FILE=${DST_FILE%%/}
            ;;
        *)
            if [ -d "$DST_FILE" ]; then
                DST_FILE=${DST_FILE}/
            else
                local DST_DIR="$(dirname "$DST_FILE")"
                if [ ! -d "$DST_DIR" ]; then
                    mkdir -p "$(dirname "$DST_FILE")" ||
                            panic "Could not create destination directory: $DST_DIR"
                fi
            fi
            ;;
    esac
    cp -a $SRC_FILE $DST_FILE ||
            panic "Could not copy $SRC_FILE into $DST_FILE !?"
}


# Set a prebuilt file to be copied
# $1: PKG root directory
# $2: Source file path relative to PKG SRC directory
# $3: Destination file path (not a directory!) relative to OUT_DIR
install_prebuilt_dll () {
    local SRC_FILE="$1"
    local DST_FILE="$2"

    if [ -L $SRC_FILE ]; then
        PREBUILT_SYMPATH_PAIRS="$PREBUILT_SYMPATH_PAIRS $SRC_FILE:$DST_FILE"
    else
        PREBUILT_PATH_PAIRS="$PREBUILT_PATH_PAIRS $SRC_FILE:$DST_FILE"
    fi
}

PREBUILT_ARCHS=
case $HOST_OS in
    windows)
        PREBUILT_ARCHS="x86 x86_64"
        ;;
    *)
        PREBUILT_ARCHS="x86_64"
        ;;
esac

###
### Copy ANGLE if available
###
ANGLE_PREBUILTS_DIR=$AOSP_PREBUILTS_DIR/android-emulator-build/common/ANGLE
if [ -d $ANGLE_PREBUILTS_DIR ]; then
    log "Copying ANGLE prebuilt libraries from $ANGLE_PREBUILTS_DIR"
    ANGLE_PREFIX=lib
    ANGLE_HOST=$HOST_OS
    case $ANGLE_HOST in
        windows)
            ANGLE_SUFFIX=.dll
            ;;
        linux)
            ANGLE_SUFFIX=.so
            ;;
        *)
    esac
    # Windows only (for now)
    if [ "$ANGLE_HOST" = "windows" ]; then
        for LIBNAME in EGL GLESv2; do # GLESv2 only for now
            for ANGLE_ARCH in $PREBUILT_ARCHS; do
                if [ "$ANGLE_ARCH" = "x86" ]; then
                    ANGLE_LIBDIR=lib
                else
                    ANGLE_LIBDIR=lib64
                fi
                ANGLE_LIBNAME=$ANGLE_PREFIX$LIBNAME$ANGLE_SUFFIX
                ANGLE_SRCDIR=$ANGLE_PREBUILTS_DIR/$ANGLE_HOST-$ANGLE_ARCH

                ANGLE_DSTDIR="$OUT_DIR/$ANGLE_LIBDIR/gles_angle"
                ANGLE_DSTLIB="$ANGLE_LIBNAME"
                if [ -f "$ANGLE_SRCDIR/lib/$ANGLE_LIBNAME" ]; then
                    install_prebuilt_dll "$ANGLE_SRCDIR/lib/$ANGLE_LIBNAME" \
                                     "$ANGLE_DSTDIR/$ANGLE_DSTLIB"
                fi
            done
        done
    fi
fi

###
### Copy Swiftshader if available
###
SWIFTSHADER_PREBUILTS_DIR=$AOSP_PREBUILTS_DIR/android-emulator-build/common/swiftshader
if [ -d $SWIFTSHADER_PREBUILTS_DIR ]; then
    log "Copying Swiftshader prebuilt libraries from $SWIFTSHADER_PREBUILTS_DIR"
    SWIFTSHADER_PREFIX=lib
    SWIFTSHADER_HOST=$HOST_OS
    case $SWIFTSHADER_HOST in
        windows)
            SWIFTSHADER_SUFFIX=.dll
            ;;
        linux)
            SWIFTSHADER_SUFFIX=.so
            ;;
        *)
    esac
    for LIBNAME in EGL GLES_CM GLESv2; do
        for SWIFTSHADER_ARCH in $PREBUILT_ARCHS; do
            if [ "$SWIFTSHADER_ARCH" = "x86" ]; then
                SWIFTSHADER_LIBDIR=lib
            else
                SWIFTSHADER_LIBDIR=lib64
            fi
            SWIFTSHADER_LIBNAME=$SWIFTSHADER_PREFIX$LIBNAME$SWIFTSHADER_SUFFIX
            SWIFTSHADER_SRCDIR=$SWIFTSHADER_PREBUILTS_DIR/$SWIFTSHADER_HOST-$SWIFTSHADER_ARCH

            SWIFTSHADER_DSTDIR="$OUT_DIR/$SWIFTSHADER_LIBDIR/gles_swiftshader"
            SWIFTSHADER_DSTLIB="$SWIFTSHADER_LIBNAME"
            if [ -f "$SWIFTSHADER_SRCDIR/lib/$SWIFTSHADER_LIBNAME" ]; then
                install_prebuilt_dll "$SWIFTSHADER_SRCDIR/lib/$SWIFTSHADER_LIBNAME" \
                                 "$SWIFTSHADER_DSTDIR/$SWIFTSHADER_DSTLIB"
            fi
        done
    done
fi


###
###  Copy Mesa if available
###
MESA_PREBUILTS_DIR=$AOSP_PREBUILTS_DIR/android-emulator-build/mesa
if [ -d $MESA_PREBUILTS_DIR ]; then
    log "Copying Mesa prebuilt libraries from $MESA_PREBUILTS_DIR"
    case $HOST_OS in
        windows)
            MESA_LIBNAME=opengl32.dll
            ;;
        linux)
            MESA_LIBNAME="libGL.so libGL.so.1"
            ;;
        *)
            MESA_LIBNAME=
    esac
    for LIBNAME in $MESA_LIBNAME; do
        for MESA_ARCH in $PREBUILT_ARCHS; do
            if [ "$MESA_ARCH" = "x86" ]; then
                MESA_LIBDIR=lib
            else
                MESA_LIBDIR=lib64
            fi
            MESA_SRCDIR=$MESA_PREBUILTS_DIR/$HOST_OS-$MESA_ARCH
            MESA_DSTDIR="$OUT_DIR/$MESA_LIBDIR/gles_mesa"
            MESA_DSTLIB="$LIBNAME"
            if [ "$LIBNAME" = "opengl32.dll" ]; then
                MESA_DSTLIB="mesa_opengl32.dll"
            fi
            install_prebuilt_dll "$MESA_SRCDIR/lib/$LIBNAME" "$MESA_DSTDIR/$MESA_DSTLIB"
        done
    done
fi

# Copy Qt shared libraries, if needed.
log "Copying Qt prebuilt libraries from $QT_PREBUILTS_DIR"
for QT_ARCH in $PREBUILT_ARCHS; do
    QT_SRCDIR=$QT_PREBUILTS_DIR/$HOST_OS-$QT_ARCH
    case $QT_ARCH in
        x86) QT_DSTDIR=$OUT_DIR/lib/qt;;
        x86_64) QT_DSTDIR=$OUT_DIR/lib64/qt;;
        *) panic "Invalid Qt host architecture: $QT_ARCH";;
    esac
    mkdir -p "$QT_DSTDIR" || panic "Could not create Qt library sub-directory!"
    if [ ! -d "$QT_SRCDIR" ]; then
        continue
    fi
    case $HOST_OS in
        windows) QT_DLL_FILTER="*.dll";;
        darwin) QT_DLL_FILTER="*.dylib";;
        *) QT_DLL_FILTER="*.so*";;
    esac
    QT_LIBS=$(cd "$QT_SRCDIR" && find . -name "$QT_DLL_FILTER" -not -path "*.dSYM/*" 2>/dev/null)
    if [ -z "$QT_LIBS" ]; then
        panic "Cannot find Qt prebuilt libraries!?"
    fi
    for QT_LIB in $QT_LIBS; do
        QT_LIB=${QT_LIB#./}
        QT_DST_LIB=$QT_LIB
        if [ "$HOST_OS" = "windows" ]; then
            # NOTE: On Windows, the prebuilt libraries are placed under
            # $PREBUILTS/qt/bin, not $PREBUILTS/qt/lib, ensure that they
            # are always copied to $OUT_DIR/lib[64]/qt/lib/.
            QT_DST_LIB=$(printf %s "$QT_DST_LIB" | sed -e 's|^bin/|lib/|g')
        fi
        install_prebuilt_dll "$QT_SRCDIR/$QT_LIB" "$QT_DSTDIR/$QT_DST_LIB"
    done
done

# Copy e2fsprogs binaries.
log "Copying e2fsprogs binaries."
for E2FS_ARCH in $PREBUILT_ARCHS; do
    # NOTE: in windows only 32-bit binaries are available, so we'll copy the
    # 32-bit executables to the bin64/ directory to cover all our bases
    case $HOST_OS in
        windows) E2FS_SRCDIR=$E2FSPROGS_PREBUILTS_DIR/$HOST_OS-x86;;
        *) E2FS_SRCDIR=$E2FSPROGS_PREBUILTS_DIR/$HOST_OS-$E2FS_ARCH;;
    esac

    if [ ! -d "$E2FS_SRCDIR" ]; then
        continue
    fi

    case $E2FS_ARCH in
        x86) E2FS_DSTDIR=$OUT_DIR/bin;;
        x86_64) E2FS_DSTDIR=$OUT_DIR/bin64;;
        *) panic "Invalid e2fsprogs host architecture: $E2FS_ARCH"
    esac
    copy_file "$E2FS_SRCDIR/sbin/*" "$E2FS_DSTDIR/"
done

# Copy the requested library from the toolchain sysroot.
# This function
#   - resolves symlinks to find the actual library
#   - copies the actual library with the resolved name.
#   - copies all the symlinks found in $SRCDIR to that library as well.
# This way, linking against generic/specific version works on systems that
# do/don't understand symlinks.
#   $1: Destination directory.
#   $2: Source directory.
#   $3: Name of the library (without the .so suffix).
copy_toolchain_lib () {
    local DESTDIR SRCDIR NAME
    local FROM REALNAME
    local SYMLINK SYMNAME
    DESTDIR="$1"
    SRCDIR="$2"
    NAME="$3.so"

    mkdir -p "${DESTDIR}" || panic "Failed to created ${DESTDIR}"

    FROM="$(readlink -qnm "${SRCDIR}/${NAME}")" ||
            panic "Coulnd't resolve ${SRCDIR}/${NAME}"
    REALNAME="$(basename "${FROM}")"

    cp -f "${FROM}" "${DESTDIR}/${REALNAME}" ||
            panic "Cound't copy ${FROM} --> ${DESTDIR}/${REALNAME}"

    # Now re-create all the symlinks as relative path symlinks.
    for SYMLINK in "${SRCDIR}/${NAME}".*; do
        if [ "${SYMLINK}" = "${FROM}" -o "$(readlink -qnm "${SYMLINK}")" != "${FROM}" ]; then
            continue
        fi
        SYMNAME="$(basename "${SYMLINK}")"
        if [ ! -e "${DESTDIR}/${SYMNAME}" -o "$(readlink -qnm "${DESTDIR}/${SYMNAME}")" != "${DESTDIR}/${REALNAME}" ]; then
            rm -f "${DESTDIR}/${SYMNAME}"
            ln -s "${REALNAME}" "${DESTDIR}/${SYMNAME}" || \
                    panic "Failed to create symlink ${DESTDIR}/${SYMNAME} --> ${REALNAME}"
        fi
    done
}

if [ -n "${TOOLCHAIN_SYSROOT}" ]; then
    # We currently only bundle libraries for linux
    # - mingw: Statically links all libraries (b.android.com/191369)
    # - darwin: We use the development machine's installed SDK. No point
    #       bundling, since we don't have a uniform libraries to begin with.
    case $HOST_OS in
        linux*)
            log "Copying toolchain libraries to bundle with the program"
            for BUNDLED_LIB in libstdc++; do
                log "  Bundling ${BUNDLED_LIB}"
                copy_toolchain_lib "${OUT_DIR}/lib/libstdc++" "${TOOLCHAIN_SYSROOT}/lib32" "${BUNDLED_LIB}"
                copy_toolchain_lib "${OUT_DIR}/lib64/libstdc++" "${TOOLCHAIN_SYSROOT}/lib64" "${BUNDLED_LIB}"
            done
        ;;
        *) log "Not copying toolchain libraries for ${HOST_OS}";;
    esac
fi



# Re-create the configuration file
config_mk=$OUT_DIR/build/config.make
config_dir=$(dirname $config_mk)
mkdir -p "$config_dir" 2> $TMPL
if [ $? != 0 ] ; then
    echo "Can't create directory for build config file: $config_dir"
    cat $TMPL
    clean_exit
fi

log "Generate   : $config_mk"

echo "# This file was autogenerated by $PROGNAME. Do not edit !" > $config_mk
echo "BUILD_TARGET_OS       := $HOST_OS" >> $config_mk
echo "BUILD_TARGET_ARCH     := $HOST_ARCH" >> $config_mk
echo "BUILD_TARGET_CC       := $CC" >> $config_mk
echo "BUILD_TARGET_CXX      := $CXX" >> $config_mk
echo "BUILD_TARGET_LD       := $LD" >> $config_mk
echo "BUILD_TARGET_AR       := $AR" >> $config_mk
echo "BUILD_TARGET_OBJCOPY  := $OBJCOPY" >> $config_mk
echo "BUILD_TARGET_WINDRES  := $WINDRES" >> $config_mk
echo "BUILD_TARGET_DUMPSYMS := $DUMPSYMS" >> $config_mk
echo "BUILD_OBJS_DIR        := $OUT_DIR" >> $config_mk

echo "" >> $config_mk
echo "BUILD_HOST_AR         := $BUILD_AR" >> $config_mk
echo "BUILD_HOST_CC         := $BUILD_CC" >> $config_mk
echo "BUILD_HOST_CXX        := $BUILD_CXX" >> $config_mk
echo "BUILD_HOST_LD         := $BUILD_LD" >> $config_mk
echo "BUILD_HOST_OBJCOPY    := $BUILD_OBJCOPY" >> $config_mk
echo "BUILD_HOST_CFLAGS     := $BUILD_CFLAGS" >> $config_mk
echo "BUILD_HOST_LDFLAGS    := $BUILD_LDFLAGS" >> $config_mk
echo "BUILD_HOST_DUMPSYMS   := $DUMPSYMS" >> $config_mk

echo "CONFIG_COREAUDIO  := $PROBE_COREAUDIO" >> $config_mk
echo "CONFIG_WINAUDIO   := $PROBE_WINAUDIO" >> $config_mk
echo "CONFIG_ESD        := $PROBE_ESD" >> $config_mk
echo "CONFIG_ALSA       := $PROBE_ALSA" >> $config_mk
echo "CONFIG_OSS        := $PROBE_OSS" >> $config_mk
echo "CONFIG_PULSEAUDIO := $PROBE_PULSEAUDIO" >> $config_mk
echo "QT_PREBUILTS_DIR  := $QT_PREBUILTS_DIR" >> $config_mk

if [ "$OPTION_GLES" = "angle" ] ; then
    echo "EMULATOR_USE_ANGLE := true" >> $config_mk
else
    echo "EMULATOR_USE_ANGLE := false" >> $config_mk
fi

echo "ZLIB_PREBUILTS_DIR := $ZLIB_PREBUILTS_DIR" >> $config_mk
echo "LIBPNG_PREBUILTS_DIR := $LIBPNG_PREBUILTS_DIR" >> $config_mk
echo "LIBXML2_PREBUILTS_DIR := $LIBXML2_PREBUILTS_DIR" >> $config_mk
echo "LIBCURL_PREBUILTS_DIR := $LIBCURL_PREBUILTS_DIR" >> $config_mk
echo "BREAKPAD_PREBUILTS_DIR := $BREAKPAD_PREBUILTS_DIR" >> $config_mk
# libuuid is a part of e2fsprogs package
echo "LIBUUID_PREBUILTS_DIR := $E2FSPROGS_PREBUILTS_DIR" >> $config_mk

if [ $OPTION_DEBUG = "yes" ] ; then
    echo "BUILD_DEBUG := true" >> $config_mk
fi
if [ $OPTION_SANITIZER != "no" ] ; then
    echo "BUILD_SANITIZER := $OPTION_SANITIZER" >> $config_mk
fi
if [ $OPTION_EMUGL_PRINTOUT = "yes" ] ; then
    echo "BUILD_EMUGL_PRINTOUT := true" >> $config_mk
fi
if [ "$OPTION_STRIP" = "yes" ]; then
    echo "BUILD_STRIP_BINARIES := true" >> $config_mk
fi
if [ "$OPTION_SYMBOLS" = "yes" ]; then
    echo "BUILD_GENERATE_SYMBOLS := true" >> $config_mk
    echo "" >> $config_mk
fi
if [ "$OPTION_CRASHUPLOAD" = "prod" ]; then
    echo "EMULATOR_CRASHUPLOAD := PROD" >> $config_mk
elif [ "$OPTION_CRASHUPLOAD" = "staging" ]; then
    echo "EMULATOR_CRASHUPLOAD := STAGING" >> $config_mk
else
    echo "EMULATOR_CRASHUPLOAD := NONE" >> $config_mk
fi

if [ "$ANDROID_SDK_TOOLS_REVISION" ] ; then
  echo "ANDROID_SDK_TOOLS_REVISION := $ANDROID_SDK_TOOLS_REVISION" >> $config_mk
fi

if [ "$ANDROID_SDK_TOOLS_BUILD_NUMBER" ] ; then
  echo "ANDROID_SDK_TOOLS_BUILD_NUMBER := $ANDROID_SDK_TOOLS_BUILD_NUMBER" >> $config_mk
fi

if [ "$config_mk" = "yes" ] ; then
    echo "" >> $config_mk
    echo "USE_MINGW := 1" >> $config_mk
    echo "HOST_OS   := windows" >> $config_mk
    echo "HOST_MINGW_VERSION := $MINGW_GCC_VERSION" >> $config_mk
fi

QEMU2_TOP_DIR=
if [ -z "$OPTION_PREBUILT_QEMU2" ]; then
    QEMU2_TOP_DIR=$PROGDIR/../qemu-android
    if [ ! -d "$QEMU2_TOP_DIR" ]; then
        panic "Missing QEMU2 source directory: $QEMU2_TOP_DIR"
    fi
    QEMU2_TOP_DIR=$(cd "$QEMU2_TOP_DIR" && pwd -P)
    log "QEMU2      : $QEMU2_TOP_DIR"

    if [ -d "$QEMU2_TOP_DIR"/android-qemu2-glue ]; then
        echo "QEMU2_TOP_DIR := $QEMU2_TOP_DIR" >> $config_mk
    fi
fi

echo "PREBUILT_PATH_PAIRS := \\" >> $config_mk
for PREBUILT_PATH_PAIR in $PREBUILT_PATH_PAIRS;
do
    echo "    $PREBUILT_PATH_PAIR \\" >> $config_mk
done
echo "" >> $config_mk

echo "PREBUILT_SYMPATH_PAIRS := \\" >> $config_mk
for PREBUILT_SYMPATH_PAIR in $PREBUILT_SYMPATH_PAIRS;
do
    echo "    $PREBUILT_SYMPATH_PAIR \\" >> $config_mk
done
echo "" >> $config_mk

# Build the config-host.h file
#
config_h=$OUT_DIR/build/config-host.h
cat > $config_h <<EOF
/* This file was autogenerated by '$PROGNAME' */

#define CONFIG_QEMU_SHAREDIR   "/usr/local/share/qemu"

EOF

if [ "$HAVE_BYTESWAP_H" = "yes" ] ; then
  echo "#define CONFIG_BYTESWAP_H 1" >> $config_h
fi
if [ "$HAVE_MACHINE_BYTESWAP_H" = "yes" ] ; then
  echo "#define CONFIG_MACHINE_BSWAP_H 1" >> $config_h
fi
if [ "$HAVE_FNMATCH_H" = "yes" ] ; then
  echo "#define CONFIG_FNMATCH  1" >> $config_h
fi
echo "#define CONFIG_GDBSTUB  1" >> $config_h
echo "#define CONFIG_SLIRP    1" >> $config_h
echo "#define CONFIG_SKINS    1" >> $config_h
echo "#define CONFIG_TRACE    1" >> $config_h
echo "#define CONFIG_QT       1" >> $config_h
echo "#undef CONFIG_SDL" >> $config_h

case "$HOST_OS" in
    windows)
        echo "#define CONFIG_WIN32  1" >> $config_h
        ;;
    *)
        echo "#define CONFIG_POSIX  1" >> $config_h
        ;;
esac

case "$HOST_OS" in
    linux)
        echo "#define CONFIG_KVM_GS_RESTORE 1" >> $config_h
        ;;
esac

# only Linux has fdatasync()
case "$HOST_OS" in
    linux)
        echo "#define CONFIG_FDATASYNC    1" >> $config_h
        ;;
esac

case "$HOST_OS" in
    linux|darwin)
        echo "#define CONFIG_MADVISE  1" >> $config_h
        ;;
esac

# the -nand-limits options can only work on non-windows systems
if [ "$HOST_OS" != "windows" ] ; then
    echo "#define CONFIG_NAND_LIMITS  1" >> $config_h
fi
echo "#define QEMU_VERSION    \"0.10.50\"" >> $config_h
echo "#define QEMU_PKGVERSION \"Android\"" >> $config_h
BSD=
case "$HOST_OS" in
    linux) CONFIG_OS=LINUX
    ;;
    darwin) CONFIG_OS=DARWIN
            BSD=1
    ;;
    freebsd) CONFIG_OS=FREEBSD
             BSD=1
    ;;
    windows) CONFIG_OS=WIN32
    ;;
    *) CONFIG_OS=$HOST_OS
esac

case $HOST_OS in
    linux|darwin)
        echo "#define CONFIG_IOVEC 1" >> $config_h
        ;;
esac

echo "#define CONFIG_$CONFIG_OS   1" >> $config_h
if [ "$BSD" ]; then
    echo "#define CONFIG_BSD       1" >> $config_h
    echo "#define O_LARGEFILE      0" >> $config_h
    echo "#define MAP_ANONYMOUS    MAP_ANON" >> $config_h
fi

case "$HOST_OS" in
    linux)
        echo "#define CONFIG_SIGNALFD       1" >> $config_h
        ;;
esac

echo "#define CONFIG_ANDROID       1" >> $config_h

log "Generate   : $config_h"

# Generate the QAPI headers and sources from qapi-schema.json
# Ideally, this would be done in our Makefiles, but as far as I
# understand, the platform build doesn't support a single tool
# that generates several sources files, nor the standalone one.
export PYTHONDONTWRITEBYTECODE=1
AUTOGENERATED_DIR=$OUT_DIR/build/qemu1-qapi-auto-generated
mkdir -p "$AUTOGENERATED_DIR"
python scripts/qapi-types.py qapi.types --output-dir=$AUTOGENERATED_DIR -b < qapi-schema.json
python scripts/qapi-visit.py --output-dir=$AUTOGENERATED_DIR -b < qapi-schema.json
python scripts/qapi-commands.py --output-dir=$AUTOGENERATED_DIR -m < qapi-schema.json

log "Generate   : $AUTOGENERATED_DIR"

if [ -z "$OPTION_PREBUILT_QEMU2" ]; then
    QEMU2_CONFIGURE=$QEMU2_TOP_DIR/android-qemu2-glue/build/configure.sh
    if [ -f "$QEMU2_CONFIGURE" ]; then
        log "QEMU2    : Configuring."
        . "$QEMU2_CONFIGURE"
    fi
fi

clean_temp

echo "Ready to go. Type 'make' to build emulator"