ifeq ($(TARGET_ARCH),arm) LOCAL_PATH:= $(call my-dir) # determine the host tag to use QEMU_HOST_TAG := $(HOST_PREBUILT_TAG) ifneq ($(USE_MINGW),) QEMU_HOST_TAG := windows 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) CONFIG_DIRS := $(LOCAL_PATH)/objs $(CONFIG_DIRS) endif CONFIG_INCLUDES := $(CONFIG_DIRS:%=-I%) MY_CC := $(HOST_CC) MY_OPTIM := -O2 -g -fno-PIC -falign-functions=0 -fomit-frame-pointer ifeq ($(BUILD_DEBUG_EMULATOR),true) MY_OPTIM := -O0 -g endif MY_CFLAGS := $(CONFIG_INCLUDES) $(MY_OPTIM) # Overwrite configuration for debug builds. # ifeq ($(BUILD_DEBUG_EMULATOR),true) MY_CFLAGS := $(CONFIG_INCLUDES) -O0 -g \ -fno-PIC -falign-functions=0 endif MY_CFLAGS += -DCONFIG_MEMCHECK MY_LDLIBS := # this is needed to build the emulator on 64-bit Linux systems ifeq ($(HOST_OS)-$(HOST_ARCH),linux-x86) MY_CFLAGS += -Wa,--32 endif ifeq ($(HOST_OS),freebsd) MY_CFLAGS += -Wa,--32 -I /usr/local/include endif ifeq ($(HOST_OS),windows) MY_CFLAGS += -D_WIN32 -mno-cygwin # we need Win32 features that are available since Windows 2000 Professional/Server (NT 5.0) MY_CFLAGS += -DWINVER=0x501 endif ifeq ($(HOST_ARCH),ppc) MY_CFLAGS += -D__powerpc__ endif ifeq ($(HOST_OS),darwin) MY_CFLAGS += -mdynamic-no-pic # When building on Leopard or above, we need to use the 10.4 SDK # or the generated binary will not run on Tiger. DARWIN_VERSION := $(strip $(shell sw_vers -productVersion)) ifneq ($(filter 10.1 10.2 10.3 10.1.% 10.2.% 10.3.% 10.4 10.4.%,$(DARWIN_VERSION)),) $(error Building the Android emulator requires OS X 10.5 or above) endif ifeq ($(filter 10.5 10.5.%,$(DARWIN_VERSION)),) # We are on Snow Leopard or above LEOPARD_SDK := /Developer/SDKs/MacOSX10.5.sdk ifeq ($(strip $(wildcard $(LEOPARD_SDK))),) $(info Please install the 10.5 SDK on this machine at $(LEOPARD_SDK)) $(error Aborting the build.) endif MY_CFLAGS += -isysroot $(LEOPARD_SDK) -mmacosx-version-min=10.5 -DMACOSX_DEPLOYMENT_TARGET=10.5 MY_LDLIBS += -isysroot $(LEOPARD_SDK) -Wl,-syslibroot,$(LEOPARD_SDK) -mmacosx-version-min=10.5 endif endif # BUILD_STANDALONE_EMULATOR is only defined when building with # the android-rebuild.sh script. The script will also provide # adequate values for HOST_CC # ifneq ($(BUILD_STANDALONE_EMULATOR),true) ifneq ($(USE_CCACHE),) ccache := prebuilt/$(HOST_PREBUILT_TAG)/ccache/ccache ifneq ($(ccache),$(firstword $(MY_CC))) MY_CC := $(ccache) $(MY_CC) endif ccache := endif endif ifneq ($(combo_target)$(TARGET_SIMULATOR),HOST_true) ifneq ($(HOST_ARCH),x86_64) MY_CFLAGS += -m32 MY_LDLIBS += -m32 endif endif # Enable warning, except those related to missing field initializers # (the QEMU coding style loves using these). # MY_CFLAGS += -Wall -Wno-missing-field-initializers 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)/target-arm \ -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)/target-arm -I$(LOCAL_PATH)/fpu $(HW_CFLAGS) LOCAL_CFLAGS += $(ZLIB_CFLAGS) -I$(LOCAL_PATH)/$(ZLIB_DIR) HW_SOURCES := \ android_arm.c \ arm_pic.c \ bt.c \ bt-hci.c \ bt-hid.c \ bt-l2cap.c \ bt-sdp.c \ cdrom.c \ dma.c \ irq.c \ goldfish_audio.c \ goldfish_battery.c \ goldfish_device.c \ goldfish_events_device.c \ goldfish_fb.c \ goldfish_interrupt.c \ goldfish_memlog.c \ goldfish_mmc.c \ goldfish_nand.c \ goldfish_switch.c \ goldfish_timer.c \ goldfish_trace.c \ goldfish_tty.c \ msmouse.c \ pci.c \ qdev.c \ scsi-disk.c \ smc91c111.c \ sysbus.c \ usb-hid.c \ usb-hub.c \ usb-msd.c \ usb-ohci.c \ usb.c \ watchdog.c \ 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)/target-arm -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)/target-arm -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 ARM-specific emulation engine sources # include $(CLEAR_VARS) LOCAL_NO_DEFAULT_COMPILER_FLAGS := true LOCAL_CC := $(MY_CC) LOCAL_MODULE := emulator-arm 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)/target-arm \ -I$(LOCAL_PATH)/fpu \ $(TCG_CFLAGS) \ $(HW_CFLAGS) \ -DNEED_CPU_H \ ifeq ($(HOST_ARCH),ppc) LOCAL_CFLAGS += -D__powerpc__ endif LOCAL_SRC_FILES += exec.c cpu-exec.c \ target-arm/op_helper.c \ target-arm/iwmmxt_helper.c \ target-arm/neon_helper.c \ target-arm/helper.c \ target-arm/translate.c \ target-arm/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 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)/target-arm \ -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)/target-arm \ -I$(LOCAL_PATH)/fpu \ $(TCG_CFLAGS) \ $(HW_CFLAGS) \ # 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 \ 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 ifeq ($(HOST_OS),windows) CORE_BLOCK_SOURCES += block/raw-win32.c else CORE_BLOCK_SOURCES += block/raw-posix.c endif # hw sources # CORE_HW_SOURCES = hw/arm_boot.c \ hw/android_arm.c # migration sources # 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 # 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 \ arm-dis.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/display.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 \ 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 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 endif # sources inherited from upstream, but not fully # integrated into android emulator # 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 # UI_SOURCES = loadpng.c \ android/user-config.c \ android/resource.c \ android/qemulator.c \ android/keycode.c \ android/help.c \ ############################################################################## # lists of source files used by both, emulator UI and emulator core # 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/timezone.c \ android/utils/vector.c \ android/avd/hw-config.c \ android/avd/info.c \ android/utils/ini.c \ # 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) # temp files used to collect UI->Core exchange protocol. UI_AND_CORE_SOURCES += android/ui-core-protocol.c android/core-ui-protocol.c # The common libraries # QEMU_SYSTEM_LDLIBS := -lm ifeq ($(HOST_OS),windows) QEMU_SYSTEM_LDLIBS += -mno-cygwin -mwindows -mconsole endif ifeq ($(HOST_OS),freebsd) QEMU_SYSTEM_LDLIBS += -L/usr/local/lib -lpthread -lX11 -lutil endif ifeq ($(HOST_OS),linux) QEMU_SYSTEM_LDLIBS += -lutil -lrt endif ifeq ($(HOST_OS),windows) QEMU_SYSTEM_LDLIBS += -lwinmm -lws2_32 -liphlpapi else QEMU_SYSTEM_LDLIBS += -lpthread endif ifeq ($(HOST_OS),darwin) QEMU_SYSTEM_LDLIBS += -Wl,-framework,Cocoa endif ############################################################################## # now build the emulator itself # include $(CLEAR_VARS) LOCAL_GENERATED_SOURCES := LOCAL_NO_DEFAULT_COMPILER_FLAGS := true LOCAL_CC := $(MY_CC) LOCAL_MODULE := emulator LOCAL_STATIC_LIBRARIES := emulator-memcheck emulator-hw emulator-arm emulator-tcg 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 endif # include other sources # VL_SOURCES := framebuffer.c \ user-events-qemu.c \ android/cmdline-option.c \ android/looper-qemu.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) LOCAL_CFLAGS += -I$(intermediates) endif LOCAL_LDLIBS += $(QEMU_AUDIO_LIB) # 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 LOCAL_STATIC_LIBRARIES := emulator-memcheck emulator-hw emulator-arm emulator-tcg 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 := framebuffer.c \ user-events-qemu.c \ android/looper-qemu.c \ android/looper-generic.c \ android/display-core.c \ android/framebuffer-core.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 := qemu-android 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 := framebuffer.c \ user-events-ui.c \ android/cmdline-option.c \ android/config.c \ android/display.c \ android/looper-generic.c \ android/snapshot.c \ android/core-connection.c \ android/main-ui.c \ qemu-timer-ui.c \ vl-android-ui.c \ console-ui.c \ iolooper-select.c \ android/framebuffer-ui.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 # See comment about SDLMAIN_SOURCES in the 'emulator-uilib' module declarations. LOCAL_SRC_FILES += $(SDLMAIN_SOURCES) include $(BUILD_HOST_EXECUTABLE) endif # TARGET_ARCH == arm