From fc8ed80ba1362d2ce500003625e1c9c39f765661 Mon Sep 17 00:00:00 2001 From: Xavier Ducrohet Date: Wed, 9 Feb 2011 18:04:23 -0800 Subject: Revert "Build arm and x86 binaries at the same time." This fails to build on MacOS X This reverts commit a39b10bd2574825a815d6ad854499dd127cfa9cb. --- Makefile.android | 1261 +++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 1201 insertions(+), 60 deletions(-) (limited to 'Makefile.android') 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, ) +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 -- cgit v1.1