Revert "Build arm and x86 binaries at the same time."

This fails to build on MacOS X

This reverts commit a39b10bd2574825a815d6ad854499dd127cfa9cb.

1 files changed, 1201 insertions, 60 deletions

diff --git a/Makefile.android b/Makefile.android
index c70f537..1b44140 100644
--- a/Makefile.android
+++ b/Makefile.android
@@ -17,6 +17,7 @@ endif
 # determine the location of platform-specific directories
 #
 CONFIG_DIRS     := \
+    $(LOCAL_PATH)/android/config \
     $(LOCAL_PATH)/android/config/$(QEMU_HOST_TAG)
 
 ifeq ($(BUILD_STANDALONE_EMULATOR),true)
@@ -25,9 +26,6 @@ endif
 
 CONFIG_INCLUDES := $(CONFIG_DIRS:%=-I%)
 
-ifneq ($(BUILD_STANDALONE_EMULATOR),true)
-endif # BUILD_STANDALONE_EMULATOR != true
-
 MY_CC := $(HOST_CC)
 
 MY_OPTIM := -O2 -g -fno-PIC -falign-functions=0 -fomit-frame-pointer
@@ -44,10 +42,12 @@ ifeq ($(BUILD_DEBUG_EMULATOR),true)
                  -fno-PIC -falign-functions=0
 endif
 
+MY_CFLAGS += -DCONFIG_MEMCHECK
+
 # prepare config.h for x86
-#ifeq ($(TARGET_ARCH),x86)
-#MY_CFLAGS += -DARCH_FLAGS_x86
-#endif
+ifeq ($(TARGET_ARCH),x86)
+MY_CFLAGS += -DARCH_FLAGS_x86
+endif
 
 MY_LDLIBS :=
 
@@ -96,17 +96,6 @@ endif
 # adequate values for HOST_CC
 #
 ifneq ($(BUILD_STANDALONE_EMULATOR),true)
-  # On Linux, use our custom 32-bit host toolchain, which contains the
-  # relevant headers and 32-bit libraries for audio (The host 64-bit Lucid
-  # doesn't provide these anymore, only their 64-bit versions).
-  ifeq ($(HOST_OS),linux)
-    HOST_SDK_TOOLCHAIN_PREFIX := prebuilt/linux-x86/toolchain/i686-linux-glibc2.7-4.4.3/bin/i686-linux
-    # Don't do anything if the toolchain is not there
-    ifneq (,$(strip $(wildcard $(HOST_SDK_TOOLCHAIN_PREFIX)-gcc)))
-      MY_CC  := $(HOST_SDK_TOOLCHAIN_PREFIX)-gcc
-      MY_CXX := $(HOST_SDK_TOOLCHAIN_PREFIX)-g++
-    endif # $(HOST_SDK_TOOLCHAIN_PREFIX)-gcc exists
-  endif # HOST_OS == linux
 
   ifneq ($(USE_CCACHE),)
     ccache := prebuilt/$(HOST_PREBUILT_TAG)/ccache/ccache
@@ -130,42 +119,751 @@ endif
 #
 MY_CFLAGS += -Wall -Wno-missing-field-initializers
 
-# Needed to build fpu/softfloat-native.h properly
-MY_CFLAGS += -D_GNU_SOURCE=1
+include $(CLEAR_VARS)
+
+###########################################################
+# Zlib configuration
+#
+ZLIB_DIR := distrib/zlib-1.2.3
+include $(LOCAL_PATH)/$(ZLIB_DIR)/sources.make
+
+###########################################################
+# Libpng configuration
+#
+LIBPNG_DIR := distrib/libpng-1.2.19
+include $(LOCAL_PATH)/$(LIBPNG_DIR)/sources.make
+
+###############################################################################
+# build the TCG code generator
+#
+include $(CLEAR_VARS)
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_CFLAGS                    := $(MY_CFLAGS) $(LOCAL_CFLAGS)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_MODULE                    := emulator-tcg
+
+TCG_TARGET := $(HOST_ARCH)
+ifeq ($(TCG_TARGET),x86)
+  TCG_TARGET := i386
+endif
+
+TCG_CFLAGS := -I$(LOCAL_PATH)/tcg -I$(LOCAL_PATH)/tcg/$(TCG_TARGET)
+
+LOCAL_CFLAGS += $(TCG_CFLAGS) -DNEED_CPU_H \
+                -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) \
+                -I$(LOCAL_PATH)/fpu \
+
+LOCAL_SRC_FILES := \
+    tcg/tcg.c \
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# build the HW emulation support
+#
+include $(CLEAR_VARS)
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_MODULE                    := emulator-hw
+
+HW_CFLAGS    := -I$(LOCAL_PATH)/hw
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) -DNEED_CPU_H
+LOCAL_CFLAGS += -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) -I$(LOCAL_PATH)/fpu $(HW_CFLAGS)
+LOCAL_CFLAGS += $(ZLIB_CFLAGS) -I$(LOCAL_PATH)/$(ZLIB_DIR)
+
+HW_SOURCES := \
+    bt.c \
+    bt-hci.c \
+    bt-hid.c \
+    bt-l2cap.c \
+    bt-sdp.c \
+    cdrom.c \
+    dma.c \
+    irq.c \
+    goldfish_device.c \
+    goldfish_events_device.c \
+    goldfish_fb.c \
+    goldfish_battery.c \
+    goldfish_mmc.c   \
+    goldfish_memlog.c \
+    goldfish_nand.c \
+    goldfish_tty.c \
+    msmouse.c \
+    pci.c \
+    qdev.c \
+    scsi-disk.c \
+    sysbus.c \
+    usb-hid.c \
+    usb-hub.c \
+    usb-msd.c \
+    usb-ohci.c \
+    usb.c \
+    watchdog.c \
+
+ifeq ($(TARGET_ARCH),arm)
+HW_SOURCES += android_arm.c \
+    arm_pic.c \
+    smc91c111.c \
+    goldfish_audio.c \
+    goldfish_interrupt.c \
+    goldfish_switch.c \
+    goldfish_timer.c \
+    goldfish_trace.c \
+
+endif
+
+ifeq ($(TARGET_ARCH),x86)
+HW_SOURCES += pc.c \
+    apic.c \
+    i8259.c \
+    mc146818rtc.c \
+    piix_pci.c \
+    i8254.c \
+    ne2000.c \
+    pckbd.c \
+    ioapic.c \
+    ps2.c \
+    smbios.c \
+    fw_cfg.c \
+
+endif
+
+LOCAL_SRC_FILES += $(HW_SOURCES:%=hw/%)
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# build the ELF/DWARF stuff
+# This library is used by emulator's memory checker to extract debug information
+# from the symbol files when reporting memory allocation violations. In
+# particular, this library is used to extract routine name and source file
+# location for the code address where violation has been detected.
+#
+include $(CLEAR_VARS)
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_MODULE                    := emulator-elff
+LOCAL_CPP_EXTENSION             := .cc
+
+ELFF_CFLAGS    := -I$(LOCAL_PATH)/elff
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) -fno-exceptions
+LOCAL_CFLAGS += -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) -I$(LOCAL_PATH)/fpu $(ELFF_CFLAGS)
+LOCAL_CFLAGS += $(ZLIB_CFLAGS) -I$(LOCAL_PATH)/$(ZLIB_DIR)
+
+ELFF_SOURCES := \
+    dwarf_cu.cc \
+    dwarf_die.cc \
+    dwarf_utils.cc \
+    elf_alloc.cc \
+    elf_file.cc \
+    elf_mapped_section.cc \
+    elff_api.cc \
+
+LOCAL_SRC_FILES += $(ELFF_SOURCES:%=elff/%)
+ELFF_LDLIBS := -lstdc++
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# build the memory access checking support
+# Memory access checker uses information collected by instrumented code in
+# libc.so in order to keep track of memory blocks allocated from heap. Memory
+# checker then uses this information to make sure that every access to allocated
+# memory is within allocated block. This information also allows detecting
+# memory leaks and attempts to free/realloc invalid pointers.
+#
+include $(CLEAR_VARS)
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_MODULE                    := emulator-memcheck
+
+MCHK_CFLAGS    := -I$(LOCAL_PATH)/memcheck -I$(LOCAL_PATH)/elff
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) -DNEED_CPU_H
+LOCAL_CFLAGS += -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) -I$(LOCAL_PATH)/fpu $(MCHK_CFLAGS)
+LOCAL_CFLAGS += $(ZLIB_CFLAGS) -I$(LOCAL_PATH)/$(ZLIB_DIR)
+
+MCHK_SOURCES := \
+    memcheck.c \
+    memcheck_proc_management.c \
+    memcheck_malloc_map.c \
+    memcheck_mmrange_map.c \
+    memcheck_util.c \
+
+LOCAL_SRC_FILES += $(MCHK_SOURCES:%=memcheck/%)
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# build the CPU-specific emulation engine sources
+#
+include $(CLEAR_VARS)
+
+ifeq ($(TARGET_ARCH),arm)
+LOCAL_MODULE			:= emulator-arm
+endif
+ifeq ($(TARGET_ARCH),x86)
+LOCAL_MODULE			:= emulator-i386
+LOCAL_MODULE_TAGS		:= optional
+endif
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_MODULE                    := $(LOCAL_MODULE)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_CFLAGS                    := $(MY_CFLAGS) $(LOCAL_CFLAGS)
+LOCAL_STATIC_LIBRARIES          := emulator-hw
+
+LOCAL_CFLAGS := -fno-PIC -fomit-frame-pointer -Wno-sign-compare
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS)
+
+LOCAL_CFLAGS += -I$(LOCAL_PATH) \
+                -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) \
+                -I$(LOCAL_PATH)/fpu \
+                $(TCG_CFLAGS) \
+                $(HW_CFLAGS) \
+                -DNEED_CPU_H \
+
+ifeq ($(HOST_ARCH),ppc)
+    LOCAL_CFLAGS += -D__powerpc__
+endif
+
+ifeq ($(TARGET_ARCH),arm)
+LOCAL_SRC_FILES += exec.c cpu-exec.c  \
+                   $(EMULATOR_TARGET_CPU)/op_helper.c \
+                   $(EMULATOR_TARGET_CPU)/iwmmxt_helper.c \
+                   $(EMULATOR_TARGET_CPU)/neon_helper.c \
+                   $(EMULATOR_TARGET_CPU)/helper.c \
+                   $(EMULATOR_TARGET_CPU)/translate.c \
+                   $(EMULATOR_TARGET_CPU)/machine.c \
+                   translate-all.c \
+                   hw/armv7m.c \
+                   hw/armv7m_nvic.c \
+                   arm-semi.c \
+                   trace.c \
+                   varint.c \
+                   dcache.c \
+                   softmmu_outside_jit.c \
+
+LOCAL_SRC_FILES += fpu/softfloat.c
+endif
+
+ifeq ($(TARGET_ARCH), x86)
+LOCAL_SRC_FILES += exec.c cpu-exec.c  \
+                   $(EMULATOR_TARGET_CPU)/op_helper.c \
+                   $(EMULATOR_TARGET_CPU)/helper.c \
+                   $(EMULATOR_TARGET_CPU)/translate.c \
+                   $(EMULATOR_TARGET_CPU)/machine.c \
+                   translate-all.c \
+                   trace.c \
+                   varint.c \
+                   dcache.c \
+                   softmmu_outside_jit.c \
+
+LOCAL_SRC_FILES += fpu/softfloat-native.c
+endif
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# SDL-related definitions
+#
+
+# Build SDL from sources except on linux-x86, to avoid installing all
+# the X11 development packages on our build servers.
+#
+BUILD_SDL_FROM_SOURCES := true
+ifeq ($(QEMU_HOST_TAG),linux-x86)
+    BUILD_SDL_FROM_SOURCES := false
+endif
+ifeq ($(QEMU_HOST_TAG),darwin-x86)
+    BUILD_SDL_FROM_SOURCES := false
+endif
+ifeq ($(BUILD_STANDALONE_EMULATOR),true)
+    BUILD_SDL_FROM_SOURCES := true
+endif
+
+ifneq ($(SDL_CONFIG),)
+    BUILD_SDL_FROM_SOURCES := false
+endif
+
+ifneq ($(BUILD_SDL_FROM_SOURCES),true)
+
+SDL_CONFIG ?= prebuilt/$(QEMU_HOST_TAG)/sdl/bin/sdl-config
+SDL_CFLAGS := $(shell $(SDL_CONFIG) --cflags)
+
+# We need to filter out the _GNU_SOURCE variable because it breaks recent
+# releases of Cygwin when using the -mno-cygwin option. Moreover, we don't
+# need this macro at all to build the Android emulator.
+SDL_CFLAGS := $(filter-out -D_GNU_SOURCE=1,$(SDL_CFLAGS))
+SDL_LDLIBS := $(filter-out %.a %.lib,$(shell $(SDL_CONFIG) --static-libs))
+
+# Circular dependencies between libSDL and libSDLmain;
+# We repeat the libraries in the final link to work around it.
+SDL_STATIC_LIBRARIES := libSDL libSDLmain libSDL libSDLmain
+
+else   # !BUILD_STANDALONE_EMULATOR
+
+SDL_DIR := distrib/sdl-1.2.12
+include $(LOCAL_PATH)/$(SDL_DIR)/sources.make
+
+endif  # !BUILD_STANDALONE_EMULATOR
+
+##############################################################################
+# determine audio sources, build the prebuilt audio-library if needed
+#
+
+# determine AUDIO sources based on current configuration
+#
+AUDIO_SOURCES := audio.c noaudio.c wavaudio.c wavcapture.c mixeng.c
+AUDIO_CFLAGS  := -I$(LOCAL_PATH)/audio -DHAS_AUDIO
+AUDIO_LDLIBS  :=
+
+ifeq ($(HOST_OS),darwin)
+  CONFIG_COREAUDIO ?= yes
+  AUDIO_CFLAGS += -DHOST_BSD=1
+endif
+
+ifeq ($(HOST_OS),windows)
+  CONFIG_WINAUDIO ?= yes
+endif
+
+ifeq ($(HOST_OS),linux)
+  CONFIG_OSS  ?= yes
+  CONFIG_ALSA ?= yes
+  CONFIG_PULSEAUDIO ?= yes
+  CONFIG_ESD  ?= yes
+endif
+
+ifeq ($(HOST_OS),freebsd)
+  CONFIG_OSS ?= yes
+endif
+
+ifeq ($(CONFIG_COREAUDIO),yes)
+  AUDIO_SOURCES += coreaudio.c
+  AUDIO_CFLAGS  += -DCONFIG_COREAUDIO
+  AUDIO_LDLIBS  += -Wl,-framework,CoreAudio
+endif
+
+ifeq ($(CONFIG_WINAUDIO),yes)
+  AUDIO_SOURCES += winaudio.c
+  AUDIO_CFLAGS  += -DCONFIG_WINAUDIO
+endif
+
+ifeq ($(CONFIG_PULSEAUDIO),yes)
+  AUDIO_SOURCES += paaudio.c audio_pt_int.c
+  AUDIO_CFLAGS  += -DCONFIG_PULSEAUDIO
+endif
+
+ifeq ($(CONFIG_ALSA),yes)
+  AUDIO_SOURCES += alsaaudio.c audio_pt_int.c
+  AUDIO_CFLAGS  += -DCONFIG_ALSA
+endif
+
+ifeq ($(CONFIG_ESD),yes)
+  AUDIO_SOURCES += esdaudio.c
+  AUDIO_CFLAGS  += -DCONFIG_ESD
+endif
+
+ifeq ($(CONFIG_OSS),yes)
+  AUDIO_SOURCES += ossaudio.c
+  AUDIO_CFLAGS  += -DCONFIG_OSS
+endif
+
+AUDIO_SOURCES := $(call sort,$(AUDIO_SOURCES:%=audio/%))
+
+# determine whether we're going to use the prebuilt
+# audio library (this is useful on Linux to avoid requiring
+# all sound-related development packages to be installed on
+# the build and developer machines).
+#
+# note that you can define BUILD_QEMU_AUDIO_LIB to true
+# in your environment to force recompilation.
+#
+QEMU_AUDIO_LIB :=
+
+ifneq ($(BUILD_STANDALONE_EMULATOR),true)
+  QEMU_AUDIO_LIB := $(wildcard \
+	prebuilt/$(QEMU_HOST_TAG)/emulator/libqemu-audio.a)
+endif
+
+ifeq ($(BUILD_QEMU_AUDIO_LIB),true)
+  include $(CLEAR_VARS)
+  LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+  LOCAL_CC                        := $(MY_CC)
+  LOCAL_MODULE                    := libqemu-audio
+  LOCAL_LDLIBS                    := $(MY_LDLIBS)
+
+  LOCAL_CFLAGS := -Wno-sign-compare \
+                  -fno-strict-aliasing -W -Wall -Wno-unused-parameter \
+                  -I$(LOCAL_PATH) \
+                  -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) \
+                  -I$(LOCAL_PATH)/fpu \
+
+  # this is very important, otherwise the generated binaries may
+  # not link properly on our build servers
+  ifeq ($(HOST_OS),linux)
+    LOCAL_CFLAGS += -fno-stack-protector
+  endif
+
+  LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) $(AUDIO_CFLAGS)
+
+  LOCAL_CFLAGS += $(SDL_CFLAGS)
+
+  LOCAL_SRC_FILES += $(AUDIO_SOURCES)
+
+  include $(BUILD_HOST_STATIC_LIBRARY)
+  QEMU_AUDIO_LIB := $(LOCAL_BUILT_MODULE)
+
+endif  # !QEMU_AUDIO_LIB
+
+##############################################################################
+# Common CFLAGS for UI and Core builds
+
+# add the build ID to the default macro definitions
+UI_AND_CORE_CFLAGS := -DANDROID_BUILD_ID="$(strip $(BUILD_ID))-$(strip $(BUILD_NUMBER))"
+
+# For non-standalone builds, extract the major version number from the Android SDK
+# tools revision number.
+ifneq ($(BUILD_STANDALONE_EMULATOR),true)
+    ANDROID_SDK_TOOLS_REVISION := $(shell awk -F= '/Pkg.Revision/ { print $$2; }' sdk/files/tools_source.properties)
+endif
+
+ANDROID_SDK_TOOLS_REVISION := $(strip $(ANDROID_SDK_TOOLS_REVISION))
+ifdef ANDROID_SDK_TOOLS_REVISION
+    UI_AND_CORE_CFLAGS += -DANDROID_SDK_TOOLS_REVISION=$(ANDROID_SDK_TOOLS_REVISION)
+endif
+
+UI_AND_CORE_CFLAGS += -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+
+
+##############################################################################
+# Build emulator core library.
+# This library contains "pure" emulation code separated from the intricacies
+# of the UI.
+#
+include $(CLEAR_VARS)
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_MODULE                    := emulator-core
+
+# don't remove the -fno-strict-aliasing, or you'll break things
+# (e.g. slirp-android/network support)
+#
+EMULATOR_CORE_CFLAGS := -fno-PIC -Wno-sign-compare \
+                -fno-strict-aliasing -g -W -Wall -Wno-unused-parameter
+
+# Needed by the upstream code
+EMULATOR_CORE_CFLAGS += -DNEED_CPU_H
+
+# Common includes for the emulator
+EMULATOR_CORE_CFLAGS += -I$(LOCAL_PATH)/ \
+                        -I$(LOCAL_PATH)/$(EMULATOR_TARGET_CPU) \
+                        -I$(LOCAL_PATH)/fpu \
+                        $(TCG_CFLAGS) \
+                        $(HW_CFLAGS) \
+
+# Required by block.c, default value is empty in upstream
+EMULATOR_CORE_CFLAGS += -DCONFIG_BDRV_WHITELIST=""
+
+# Required
+EMULATOR_CORE_CFLAGS += -D_XOPEN_SOURCE=600 -D_BSD_SOURCE=1
+# include slirp-android code, i.e. the user-level networking stuff
+#
+SLIRP_SOURCES := bootp.c     cksum.c      debug.c  if.c     ip_icmp.c  ip_input.c   ip_output.c  \
+                 mbuf.c      misc.c       sbuf.c   slirp.c  socket.c   tcp_input.c  tcp_output.c \
+                 tcp_subr.c  tcp_timer.c  tftp.c   udp.c
+
+LOCAL_SRC_FILES += $(SLIRP_SOURCES:%=slirp-android/%)
+EMULATOR_CORE_CFLAGS += -I$(LOCAL_PATH)/slirp-android
+
+# socket proxy support
+#
+PROXY_SOURCES := \
+    proxy_common.c \
+    proxy_http.c \
+    proxy_http_connector.c \
+    proxy_http_rewriter.c \
+
+LOCAL_SRC_FILES += $(PROXY_SOURCES:%=proxy/%)
+EMULATOR_CORE_CFLAGS += -I$(LOCAL_PATH)/proxy
+
+# include telephony stuff
+#
+TELEPHONY_SOURCES := android_modem.c modem_driver.c gsm.c sim_card.c sysdeps_qemu.c sms.c remote_call.c
+LOCAL_SRC_FILES += $(TELEPHONY_SOURCES:%=telephony/%)
+EMULATOR_CORE_CFLAGS += -I$(LOCAL_PATH)/telephony
+
+# include android related stuff
+#
+ANDROID_SOURCES := qemu-setup.c
+LOCAL_SRC_FILES += $(ANDROID_SOURCES:%=android/%)
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) $(EMULATOR_CORE_CFLAGS)
+LOCAL_CFLAGS += $(UI_AND_CORE_CFLAGS)
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# Build emulator UI library.
+# This library contains some emulator related UI components.
+#
+include $(CLEAR_VARS)
+
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+LOCAL_MODULE                    := emulator-uilib
+
+EMULATOR_UI_CFLAGS :=
+
+# include the SDL sources
+#
+
+# IMPORTANT: Normally, we should add SDLMAIN_SOURCES here, however this breaks
+#            the Linux mingw32 build. Apparently, the i586-mingw32-ld wants the
+#            implementation of _WinMain@16 to be in an object file on the final
+#            link command used to generate the executable, and will not search
+#            in the static libraries that are used to build it.
+#
+LOCAL_SRC_FILES += $(SDL_SOURCES) #$(SDLMAIN_SOURCES)
+EMULATOR_UI_CFLAGS += $(SDL_CFLAGS) -I$(LOCAL_PATH)/$(SDL_DIR)/include
+
+# the skin support sources
+#
+SKIN_SOURCES := rect.c \
+                region.c \
+                image.c \
+                trackball.c \
+                keyboard.c \
+                keyset.c \
+                file.c \
+                window.c \
+                scaler.c \
+                composer.c \
+                surface.c \
+
+LOCAL_SRC_FILES += $(SKIN_SOURCES:%=android/skin/%)
+EMULATOR_UI_CFLAGS += -I$(LOCAL_PATH)/skin
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) $(EMULATOR_CORE_CFLAGS) $(EMULATOR_UI_CFLAGS)
+
+LOCAL_MODULE_TAGS := debug
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+##############################################################################
+# lists of source files used to build the emulator core
+#
+
+# block sources
+#
+CORE_BLOCK_SOURCES = block.c \
+                     blockdev.c \
+                     block/qcow.c \
+                     block/qcow2.c \
+                     block/qcow2-refcount.c \
+                     block/qcow2-snapshot.c \
+                     block/qcow2-cluster.c \
+                     block/cloop.c \
+                     block/dmg.c \
+                     block/vvfat.c \
+                     block/raw.c
+ifeq ($(HOST_OS),windows)
+  CORE_BLOCK_SOURCES += block/raw-win32.c
+else
+  CORE_BLOCK_SOURCES += block/raw-posix.c
+endif
+
+# hw sources
+#
+ifeq ($(TARGET_ARCH),arm)
+CORE_HW_SOURCES = hw/arm_boot.c \
+                  hw/android_arm.c
+endif
+
+ifeq ($(TARGET_ARCH),x86)
+CORE_HW_SOURCES = hw/pc.c
+endif
 
-# A useful function that can be used to start the declaration of a host
-# module. Avoids repeating the same stuff again and again.
-# Usage:
+# migration sources
 #
-#  $(call start-emulator-library, <module-name>)
+CORE_MIGRATION_SOURCES = iolooper-select.c
+ifeq ($(HOST_OS),windows)
+  CORE_MIGRATION_SOURCES += migration-dummy-android.c
+else
+  CORE_MIGRATION_SOURCES += migration.c \
+                            migration-exec.c \
+                            migration-tcp-android.c
+endif
+
+# misc. sources
 #
-#  ... declarations
+CORE_MISC_SOURCES = vl-android.c \
+                    async.c \
+                    console.c \
+                    qemu-malloc.c \
+                    cutils.c \
+                    osdep.c \
+                    loader.c \
+                    monitor.c \
+                    readline.c \
+                    qemu-char-android.c \
+                    outputchannel.c \
+                    qemu-error.c \
+                    qerror.c \
+                    disas.c \
+                    aes.c \
+                    d3des.c \
+                    vnc-android.c \
+                    acl.c \
+                    keymaps.c \
+                    buffered_file.c \
+                    cbuffer.c \
+                    gdbstub.c \
+                    input.c \
+                    ioport.c \
+                    notify.c \
+                    path.c \
+                    shaper.c \
+                    charpipe.c \
+                    tcpdump.c \
+                    qemu-option.c \
+                    savevm.c \
+                    net-android.c \
+                    aio-android.c \
+                    dma-helpers.c \
+                    qemu-config.c \
+                    qemu-sockets-android.c \
+                    bt-host.c \
+                    bt-vhci.c \
+                    module.c \
+                    qemu-timer.c \
+                    android/boot-properties.c \
+                    android/hw-kmsg.c \
+                    android/hw-lcd.c \
+                    android/gps.c \
+                    android/hw-events.c \
+                    android/hw-control.c \
+                    android/console.c \
+                    android/hw-sensors.c \
+                    android/hw-qemud.c \
+                    android/core-init-utils.c   \
+                    android/config.c \
+                    android/snapshot.c \
+                    android/utils/timezone.c \
+
+ifeq ($(TARGET_ARCH),arm)
+    CORE_MISC_SOURCES += arm-dis.c
+endif
+
+ifeq ($(HOST_ARCH),x86)
+    CORE_MISC_SOURCES += i386-dis.c
+endif
+ifeq ($(HOST_ARCH),x86_64)
+    CORE_MISC_SOURCES += i386-dis.c
+endif
+ifeq ($(HOST_ARCH),ppc)
+    CORE_MISC_SOURCES += ppc-dis.c \
+                         cache-utils.c
+endif
+
+ifeq ($(HOST_OS),linux)
+    CORE_MISC_SOURCES += usb-linux.c \
+                         qemu-thread.c
+else
+    CORE_MISC_SOURCES += usb-dummy-android.c
+endif
+
+ifeq ($(HOST_OS),windows)
+  CORE_MISC_SOURCES   += tap-win32.c
+else
+  CORE_MISC_SOURCES   += posix-aio-compat.c
+endif
+
+# sources inherited from upstream, but not fully
+# integrated into android emulator
 #
-#  $(call end-emulator-library)
+CORE_UPSTREAM_SOURCES = json-lexer.c \
+                        json-parser.c \
+                        json-streamer.c \
+                        qjson.c \
+                        qbool.c \
+                        qdict.c \
+                        qfloat.c \
+                        qint.c \
+                        qlist.c \
+                        qstring.c \
+
+
+CORE_SOURCES = $(CORE_BLOCK_SOURCES) $(CORE_HW_SOURCES)
+CORE_SOURCES += $(CORE_MIGRATION_SOURCES) $(CORE_MISC_SOURCES)
+CORE_SOURCES += $(CORE_UPSTREAM_SOURCES)
+
+CORE_SOURCES += android/audio-test.c
+
+##############################################################################
+# lists of source files used to build the emulator UI
 #
-start-emulator-library = \
-    $(eval include $(CLEAR_VARS)) \
-    $(eval LOCAL_NO_DEFAULT_COMPILER_FLAGS := true) \
-    $(eval LOCAL_CC := $(MY_CC)) \
-    $(eval LOCAL_CXX := $(MY_CXX)) \
-    $(eval LOCAL_CFLAGS := $(MY_CFLAGS)) \
-    $(eval LOCAL_LDLIBS := $(MY_LDLIBS)) \
-    $(eval LOCAL_MODULE_TAGS := debug) \
-    $(eval LOCAL_MODULE := $1)
 
-# Used with start-emulator-library
-end-emulator-library = \
-    $(eval include $(BUILD_HOST_STATIC_LIBRARY))
+UI_SOURCES = loadpng.c \
+             android/user-config.c \
+             android/resource.c \
+             android/qemulator.c \
+             android/keycode.c \
+             android/help.c \
+             android/avd/info.c \
+
+##############################################################################
+# lists of source files used by both, emulator UI and emulator core
+#
 
-# A variant of start-emulator-library to start the definition of a host
-# program instead. Use with end-emulator-program
-start-emulator-program = $(call start-emulator-library,$1)
+UI_AND_CORE_SOURCES = \
+                      sockets.c \
+                      android/keycode-array.c \
+                      android/charmap.c \
+                      android/async-utils.c \
+                      android/sync-utils.c \
+                      android/async-console.c \
+                      android/utils/assert.c \
+                      android/utils/bufprint.c \
+                      android/utils/debug.c \
+                      android/utils/path.c \
+                      android/utils/dirscanner.c \
+                      android/utils/filelock.c \
+                      android/utils/mapfile.c \
+                      android/utils/misc.c \
+                      android/utils/panic.c \
+                      android/utils/reflist.c \
+                      android/utils/refset.c \
+                      android/utils/stralloc.c \
+                      android/utils/system.c \
+                      android/utils/tempfile.c \
+                      android/utils/vector.c \
+                      android/avd/hw-config.c \
+                      android/utils/ini.c \
 
-# A varient of end-emulator-library for host programs instead
-end-emulator-program = \
-    $(eval LOCAL_LDLIBS += $(QEMU_SYSTEM_LDLIBS)) \
-    $(eval include $(BUILD_HOST_EXECUTABLE))
+# include the Zlib sources
+#
+UI_AND_CORE_SOURCES += $(ZLIB_SOURCES)
+UI_AND_CORE_CFLAGS  += $(ZLIB_CFLAGS) -I$(LOCAL_PATH)/$(ZLIB_DIR)
 
+# include the Libpng sources
+#
+UI_AND_CORE_SOURCES += $(LIBPNG_SOURCES)
+UI_AND_CORE_CFLAGS  += $(LIBPNG_CFLAGS) -I$(LOCAL_PATH)/$(LIBPNG_DIR)
 
 # The common libraries
 #
@@ -192,28 +890,471 @@ ifeq ($(HOST_OS),darwin)
   QEMU_SYSTEM_LDLIBS += -Wl,-framework,Cocoa
 endif
 
-include $(LOCAL_PATH)/Makefile.common
 
-# corresponding to the product's target architecture.
+##############################################################################
+# now build the emulator itself
+#
+include $(CLEAR_VARS)
+
+LOCAL_GENERATED_SOURCES :=
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_MODULE                    := emulator
+ifeq ($(TARGET_ARCH),arm)
+LOCAL_STATIC_LIBRARIES          := emulator-memcheck emulator-hw emulator-arm emulator-tcg
+endif
+ifeq ($(TARGET_ARCH),x86)
+LOCAL_STATIC_LIBRARIES          := emulator-memcheck emulator-hw emulator-i386 emulator-tcg
+endif
+LOCAL_STATIC_LIBRARIES          += emulator-elff
+LOCAL_STATIC_LIBRARIES          += emulator-core emulator-uilib
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) $(EMULATOR_CORE_CFLAGS) $(EMULATOR_UI_CFLAGS)
+
+# add the build ID to the default macro definitions
+LOCAL_CFLAGS += $(UI_AND_CORE_CFLAGS)
+
+# include sound support source files. we first try to see if we have a prebuilt audio
+# library. if not, we build things the "hard" way.
+#
+# note that to generate the prebuilt audio library, you should do the following:
+#
+#   cd tools/qemu
+#   ./android-rebuild.sh
+#   distrib/update-audio.sh
+#
+ifeq ($(QEMU_AUDIO_LIB),)
+  LOCAL_SRC_FILES += $(AUDIO_SOURCES)
+endif  # !QEMU_AUDIO_LIB
+
+LOCAL_CFLAGS  += $(AUDIO_CFLAGS)
+LOCAL_LDLIBS  += $(AUDIO_LDLIBS)
+
+# the linux-user sources, I doubt we really need these
+#
+#LINUX_SOURCES := main.c elfload.c mmap.c signal.c path.c syscall.c
+#LOCAL_SRC_FILES += $(LINUX_SOURCES:%=linux-user/%)
+
+ifeq ($(HOST_ARCH),x86)
+# enable MMX code for our skin scaler
+LOCAL_CFLAGS += -DUSE_MMX=1 -mmmx -DNEED_CPU_H
+endif
+
+# include other sources
+#
+VL_SOURCES := android/framebuffer.c \
+              user-events-qemu.c \
+              android/cmdline-option.c \
+              android/display.c \
+              android/looper-qemu.c \
+              android/protocol/ui-commands-qemu.c \
+              android/protocol/core-commands-qemu.c \
+              android/main-common.c \
+              android/main.c \
+
+# Add common system libraries
+#
+LOCAL_LDLIBS += $(QEMU_SYSTEM_LDLIBS)
+
+LOCAL_SRC_FILES += $(VL_SOURCES) $(CORE_SOURCES) $(UI_SOURCES) $(UI_AND_CORE_SOURCES)
+
+# add SDL-specific flags
+#
+LOCAL_CFLAGS += $(SDL_CFLAGS)
+LOCAL_LDLIBS += $(SDL_LDLIBS)
+LOCAL_STATIC_LIBRARIES += $(SDL_STATIC_LIBRARIES)
+
+# add ELFF-specific flags
+#
+LOCAL_LDLIBS += $(ELFF_LDLIBS)
+
+# on Windows, link the icon file as well into the executable
+# unfortunately, our build system doesn't help us much, so we need
+# to use some weird pathnames to make this work...
+#
+ifeq ($(HOST_OS),windows)
+
+# Locate windres executable
+WINDRES := windres
+ifneq ($(USE_MINGW),)
+  # When building the Windows emulator under Linux, use the MinGW one
+  WINDRES := i586-mingw32msvc-windres
+endif
+
+INTERMEDIATE     := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+ANDROID_ICON_OBJ := android_icon.o
+ANDROID_ICON_PATH := $(LOCAL_PATH)/images
+$(ANDROID_ICON_PATH)/$(ANDROID_ICON_OBJ): $(ANDROID_ICON_PATH)/android_icon.rc
+	$(WINDRES) $< -I $(ANDROID_ICON_PATH) -o $@
+
+# seems to be the only way to add an object file that was not generated from
+# a C/C++/Java source file to our build system. and very unfortunately,
+# $(TOPDIR)/$(LOCALPATH) will always be prepended to this value, which forces
+# us to put the object file in the source directory...
+#
+LOCAL_PREBUILT_OBJ_FILES += images/$(ANDROID_ICON_OBJ)
+endif
+
+# qemu-options.h is generated from qemu-options.hx with the "hxtool" shell script
+#
+intermediates := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+
+QEMU_OPTIONS_H := $(intermediates)/qemu-options.h
+$(QEMU_OPTIONS_H): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_OPTIONS_H): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/hxtool -h < $< > $@
+$(QEMU_OPTIONS_H): $(LOCAL_PATH)/qemu-options.hx $(LOCAL_PATH)/hxtool
+	$(transform-generated-source)
+
+$(intermediates)/vl-android.o: $(QEMU_OPTIONS_H)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_OPTIONS_H)
+
+# qemu-monitor.h is generated from qemu-monitor.hx with the "hxtool" shell script
+#
+intermediates := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
 
+QEMU_MONITOR_H := $(intermediates)/qemu-monitor.h
+$(QEMU_MONITOR_H): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_MONITOR_H): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/hxtool -h < $< > $@
+$(QEMU_MONITOR_H): $(LOCAL_PATH)/qemu-monitor.hx $(LOCAL_PATH)/hxtool
+	$(transform-generated-source)
+
+$(intermediates)/vl-android.o: $(QEMU_MONITOR_H)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_MONITOR_H)
+
+
+# gdbstub-xml.c contains C-compilable arrays corresponding to the content
+# of $(LOCAL_PATH)/gdb-xml/, and is generated with the 'feature_to_c.sh' script.
+#
+ifeq ($(QEMU_TARGET_XML_SOURCES),)
+    QEMU_TARGET_XML_SOURCES := arm-core arm-neon arm-vfp arm-vfp3
+    QEMU_TARGET_XML_SOURCES := $(QEMU_TARGET_XML_SOURCES:%=$(LOCAL_PATH)/gdb-xml/%.xml)
+endif
+
+QEMU_GDBSTUB_XML_C := $(intermediates)/gdbstub-xml.c
+$(QEMU_GDBSTUB_XML_C): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_GDBSTUB_XML_C): PRIVATE_SOURCES := $(TARGET_XML_SOURCES)
+$(QEMU_GDBSTUB_XML_C): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/feature_to_c.sh $@ $(QEMU_TARGET_XML_SOURCES)
+$(QEMU_GDBSTUB_XML_C): $(QEMU_TARGET_XML_SOURCES) $(LOCAL_PATH)/feature_to_c.sh
+	$(hide) rm -f $@
+	$(transform-generated-source)
+
+$(intermediates)/vl-android.o: $(QEMU_GDBSTUB_XML_C)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_GDBSTUB_XML_C)
+
+# hw-config-defs.h is generated from android/avd/hardware-properties.ini
+#
+QEMU_HARDWARE_PROPERTIES_INI := $(LOCAL_PATH)/android/avd/hardware-properties.ini
+QEMU_HW_CONFIG_DEFS_H := $(LOCAL_PATH)/android/avd/hw-config-defs.h
+$(QEMU_HW_CONFIG_DEFS_H): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_HW_CONFIG_DEFS_H): PRIVATE_SOURCES := $(QEMU_HARDWARE_PROPERTIES_INI)
+$(QEMU_HW_CONFIG_DEFS_H): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/android/tools/gen-hw-config.py $(QEMU_HARDWARE_PROPERTIES_INI) $@
+$(QEMU_HW_CONFIG_DEFS_H): $(QEMU_HARDWARE_PROPERTIES_INI) $(LOCAL_PATH)/android/tools/gen-hw-config.py
+	$(hide) rm -f $@
+	$(transform-generated-source)
+
+$(LOCAL_PATH)/android/avd/hw-config.h: $(QEMU_HW_CONFIG_DEFS_H)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_HW_CONFIG_DEFS_H)
+
+# this is already done by the Android build system, but is done for the
+# benefit of the stand-alone one.
+#
 ifeq ($(BUILD_STANDALONE_EMULATOR),true)
-    # For standalone builds, we want to build all variants of the emulator
-    # binaries. This makes it easier to catch target-specific regressions
-    # during emulator development.
-    EMULATOR_TARGET_ARCH := arm
-    include $(LOCAL_PATH)/Makefile.target
+  LOCAL_CFLAGS += -I$(intermediates)
+endif
 
-    EMULATOR_TARGET_ARCH := x86
-    include $(LOCAL_PATH)/Makefile.target
+LOCAL_LDLIBS += $(QEMU_AUDIO_LIB)
 
-else # !BUILD_STANDALONE_EMULATOR
+# Generate a completely static executable if needed.
+# Note that this means no sound and graphics on Linux.
+#
+ifeq ($(CONFIG_STATIC_EXECUTABLE),true)
+    LOCAL_SRC_FILES += dynlink-static.c
+    LOCAL_LDLIBS    += -static
+endif
+
+LOCAL_MODULE := emulator
+
+# See comment about SDLMAIN_SOURCES in the 'emulator-uilib' module declarations.
+LOCAL_SRC_FILES += $(SDLMAIN_SOURCES)
+
+include $(BUILD_HOST_EXECUTABLE)
+
+##############################################################################
+# Build standalone emulator core.
+#
+include $(CLEAR_VARS)
+
+LOCAL_GENERATED_SOURCES         :=
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_MODULE                    := qemu-android-$(TARGET_ARCH)
+ifeq ($(TARGET_ARCH),arm)
+LOCAL_STATIC_LIBRARIES          := emulator-memcheck emulator-hw emulator-arm emulator-tcg
+endif
+ifeq ($(TARGET_ARCH),x86)
+LOCAL_STATIC_LIBRARIES          := emulator-memcheck emulator-hw emulator-i386 emulator-tcg
+endif
+
+LOCAL_STATIC_LIBRARIES          += emulator-elff
+LOCAL_STATIC_LIBRARIES          += emulator-core
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) $(EMULATOR_CORE_CFLAGS)
+LOCAL_CFLAGS += $(UI_AND_CORE_CFLAGS) -DCONFIG_STANDALONE_CORE
+
+# include sound support source files. we first try to see if we have a prebuilt audio
+# library. if not, we build things the "hard" way.
+#
+# note that to generate the prebuilt audio library, you should do the following:
+#
+#   cd tools/qemu
+#   ./android-rebuild.sh
+#   distrib/update-audio.sh
+#
+ifeq ($(QEMU_AUDIO_LIB),)
+  LOCAL_SRC_FILES += $(AUDIO_SOURCES)
+endif  # !QEMU_AUDIO_LIB
+
+LOCAL_CFLAGS  += $(AUDIO_CFLAGS)
+LOCAL_LDLIBS  += $(AUDIO_LDLIBS)
+
+# the linux-user sources, I doubt we really need these
+#
+#LINUX_SOURCES := main.c elfload.c mmap.c signal.c path.c syscall.c
+#LOCAL_SRC_FILES += $(LINUX_SOURCES:%=linux-user/%)
+
+# include other sources
+#
+VL_SOURCES := android/framebuffer.c \
+              user-events-qemu.c \
+              android/looper-qemu.c \
+              android/looper-generic.c \
+              android/display-core.c \
+              android/protocol/attach-ui-proxy.c \
+              android/protocol/fb-updates-proxy.c \
+              android/protocol/user-events-impl.c \
+              android/protocol/ui-commands-proxy.c \
+              android/protocol/core-commands-impl.c \
+
+# Add common system libraries
+#
+LOCAL_LDLIBS += $(QEMU_SYSTEM_LDLIBS)
+
+LOCAL_SRC_FILES += $(VL_SOURCES) $(CORE_SOURCES) $(UI_AND_CORE_SOURCES)
+
+# add ELFF-specific flags
+#
+LOCAL_LDLIBS += $(ELFF_LDLIBS)
+
+# on Windows, link the icon file as well into the executable
+# unfortunately, our build system doesn't help us much, so we need
+# to use some weird pathnames to make this work...
+#
+ifeq ($(HOST_OS),windows)
+
+# Locate windres executable
+WINDRES := windres
+ifneq ($(USE_MINGW),)
+  # When building the Windows emulator under Linux, use the MinGW one
+  WINDRES := i586-mingw32msvc-windres
+endif
+
+INTERMEDIATE     := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+ANDROID_ICON_OBJ := android_icon.o
+ANDROID_ICON_PATH := $(LOCAL_PATH)/images
+$(ANDROID_ICON_PATH)/$(ANDROID_ICON_OBJ): $(ANDROID_ICON_PATH)/android_icon.rc
+	$(WINDRES) $< -I $(ANDROID_ICON_PATH) -o $@
+
+# seems to be the only way to add an object file that was not generated from
+# a C/C++/Java source file to our build system. and very unfortunately,
+# $(TOPDIR)/$(LOCALPATH) will always be prepended to this value, which forces
+# us to put the object file in the source directory...
+#
+LOCAL_PREBUILT_OBJ_FILES += images/$(ANDROID_ICON_OBJ)
+endif
+
+# qemu-options.h is generated from qemu-options.hx with the "hxtool" shell script
+#
+intermediates := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+
+QEMU_OPTIONS_H := $(intermediates)/qemu-options.h
+$(QEMU_OPTIONS_H): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_OPTIONS_H): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/hxtool -h < $< > $@
+$(QEMU_OPTIONS_H): $(LOCAL_PATH)/qemu-options.hx $(LOCAL_PATH)/hxtool
+	$(transform-generated-source)
+
+$(intermediates)/vl-android.o: $(QEMU_OPTIONS_H)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_OPTIONS_H)
+
+# qemu-monitor.h is generated from qemu-monitor.hx with the "hxtool" shell script
+#
+intermediates := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+
+QEMU_MONITOR_H := $(intermediates)/qemu-monitor.h
+$(QEMU_MONITOR_H): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_MONITOR_H): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/hxtool -h < $< > $@
+$(QEMU_MONITOR_H): $(LOCAL_PATH)/qemu-monitor.hx $(LOCAL_PATH)/hxtool
+	$(transform-generated-source)
+
+$(intermediates)/vl-android.o: $(QEMU_MONITOR_H)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_MONITOR_H)
+
+
+# gdbstub-xml.c contains C-compilable arrays corresponding to the content
+# of $(LOCAL_PATH)/gdb-xml/, and is generated with the 'feature_to_c.sh' script.
+#
+ifeq ($(QEMU_TARGET_XML_SOURCES),)
+    QEMU_TARGET_XML_SOURCES := arm-core arm-neon arm-vfp arm-vfp3
+    QEMU_TARGET_XML_SOURCES := $(QEMU_TARGET_XML_SOURCES:%=$(LOCAL_PATH)/gdb-xml/%.xml)
+endif
+
+QEMU_GDBSTUB_XML_C := $(intermediates)/gdbstub-xml.c
+$(QEMU_GDBSTUB_XML_C): PRIVATE_PATH := $(LOCAL_PATH)
+$(QEMU_GDBSTUB_XML_C): PRIVATE_SOURCES := $(TARGET_XML_SOURCES)
+$(QEMU_GDBSTUB_XML_C): PRIVATE_CUSTOM_TOOL = $(PRIVATE_PATH)/feature_to_c.sh $@ $(QEMU_TARGET_XML_SOURCES)
+$(QEMU_GDBSTUB_XML_C): $(QEMU_TARGET_XML_SOURCES) $(LOCAL_PATH)/feature_to_c.sh
+	$(hide) rm -f $@
+	$(transform-generated-source)
+
+$(intermediates)/vl-android.o: $(QEMU_GDBSTUB_XML_C)
+
+LOCAL_GENERATED_SOURCES += $(QEMU_GDBSTUB_XML_C)
+
+# this is already done by the Android build system, but is done for the
+# benefit of the stand-alone one.
+#
+ifeq ($(BUILD_STANDALONE_EMULATOR),true)
+  LOCAL_CFLAGS += -I$(intermediates)
+endif
+
+# other flags
+ifneq ($(HOST_OS),windows)
+    LOCAL_LDLIBS += -ldl
+endif
+
+LOCAL_LDLIBS += $(QEMU_AUDIO_LIB)
+
+ifeq ($(HOST_OS),darwin)
+    FRAMEWORKS := OpenGL Cocoa QuickTime ApplicationServices Carbon IOKit
+    LOCAL_LDLIBS += $(FRAMEWORKS:%=-Wl,-framework,%)
+endif
+
+# Generate a completely static executable if needed.
+# Note that this means no sound and graphics on Linux.
+#
+ifeq ($(CONFIG_STATIC_EXECUTABLE),true)
+    LOCAL_SRC_FILES += dynlink-static.c
+    LOCAL_LDLIBS    += -static
+endif
+
+LOCAL_MODULE_TAGS := debug
+
+include $(BUILD_HOST_EXECUTABLE)
+
+##############################################################################
+# now build the emulator UI
+#
+include $(CLEAR_VARS)
+
+LOCAL_GENERATED_SOURCES :=
+LOCAL_NO_DEFAULT_COMPILER_FLAGS := true
+LOCAL_CC                        := $(MY_CC)
+LOCAL_MODULE                    := emulator-ui
+LOCAL_STATIC_LIBRARIES          := emulator-uilib
+LOCAL_LDLIBS                    := $(MY_LDLIBS)
+
+LOCAL_CFLAGS := $(MY_CFLAGS) $(LOCAL_CFLAGS) $(EMULATOR_UI_CFLAGS) $(EMULATOR_CORE_CFLAGS)
+
+# add the build ID to the default macro definitions
+LOCAL_CFLAGS += $(UI_AND_CORE_CFLAGS) -DCONFIG_STANDALONE_UI
+
+ifeq ($(HOST_ARCH),x86)
+# enable MMX code for our skin scaler
+LOCAL_CFLAGS += -DUSE_MMX=1 -mmmx
+endif
+
+# include other sources
+#
+VL_SOURCES := android/framebuffer.c \
+              android/cmdline-option.c \
+              android/config.c \
+              android/looper-generic.c \
+              android/snapshot.c \
+              android/main-common.c \
+              android/main-ui.c \
+              vl-android-ui.c \
+              iolooper-select.c \
+              android/protocol/core-connection.c \
+              android/protocol/attach-ui-impl.c \
+              android/protocol/fb-updates-impl.c \
+              android/protocol/ui-commands-impl.c \
+              android/protocol/core-commands-proxy.c \
+              android/protocol/user-events-proxy.c \
+
+# Add common system libraries
+#
+LOCAL_LDLIBS += $(QEMU_SYSTEM_LDLIBS)
+
+LOCAL_SRC_FILES += $(VL_SOURCES) $(UI_SOURCES) $(UI_AND_CORE_SOURCES)
+
+# add SDL-specific flags
+#
+LOCAL_CFLAGS += $(SDL_CFLAGS)
+LOCAL_LDLIBS += $(SDL_LDLIBS)
+LOCAL_STATIC_LIBRARIES += $(SDL_STATIC_LIBRARIES)
+
+# on Windows, link the icon file as well into the executable
+# unfortunately, our build system doesn't help us much, so we need
+# to use some weird pathnames to make this work...
+#
+ifeq ($(HOST_OS),windows)
+
+# Locate windres executable
+WINDRES := windres
+ifneq ($(USE_MINGW),)
+  # When building the Windows emulator under Linux, use the MinGW one
+  WINDRES := i586-mingw32msvc-windres
+endif
+
+INTERMEDIATE     := $(call intermediates-dir-for,EXECUTABLES,$(LOCAL_MODULE),true)
+ANDROID_ICON_OBJ := android_icon.o
+ANDROID_ICON_PATH := $(LOCAL_PATH)/images
+$(ANDROID_ICON_PATH)/$(ANDROID_ICON_OBJ): $(ANDROID_ICON_PATH)/android_icon.rc
+	$(WINDRES) $< -I $(ANDROID_ICON_PATH) -o $@
+
+# seems to be the only way to add an object file that was not generated from
+# a C/C++/Java source file to our build system. and very unfortunately,
+# $(TOPDIR)/$(LOCALPATH) will always be prepended to this value, which forces
+# us to put the object file in the source directory...
+#
+LOCAL_PREBUILT_OBJ_FILES += images/$(ANDROID_ICON_OBJ)
+endif
+
+# this is already done by the Android build system, but is done for the
+# benefit of the stand-alone one.
+#
+ifeq ($(BUILD_STANDALONE_EMULATOR),true)
+  LOCAL_CFLAGS += -I$(intermediates)
+endif
+
+# Generate a completely static executable if needed.
+# Note that this means no sound and graphics on Linux.
+#
+ifeq ($(CONFIG_STATIC_EXECUTABLE),true)
+    LOCAL_SRC_FILES += dynlink-static.c
+    LOCAL_LDLIBS    += -static
+endif
 
-    # On the other hand, for platform builds, only build the binaries
-    # corresponding to the build product's target architecture.
-    #
-    EMULATOR_TARGET_ARCH := $(TARGET_ARCH)
-    include $(LOCAL_PATH)/Makefile.target
+# See comment about SDLMAIN_SOURCES in the 'emulator-uilib' module declarations.
+LOCAL_SRC_FILES += $(SDLMAIN_SOURCES)
 
-endif # !BUILD_STANDALONE_EMULATOR
+include $(BUILD_HOST_EXECUTABLE)
 
 endif  # TARGET_ARCH == arm || TARGET_ARCH == x86