blob: 33ec5d09ac27ad14efef8b85004231771fa300eb [file] [log] [blame]
cmake_minimum_required(VERSION 3.5)
if(MSVC)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/android/build/cmake")
include("toolchain-windows_msvc-x86_64")
endif()
message(STATUS "Compiling for target: ${ANDROID_TARGET_TAG}")
if(NOT DEFINED ANDROID_TARGET_TAG)
message(STATUS "ANDROID_TARGET_TAG is undefined [${ANDROID_TARGET_TAG}]")
message(
FATAL_ERROR
"You need to invoke the cmake generator with a proper toolchain from android/build/cmake, pass: -DCMAKE_TOOLCHAIN_FILE=./android/build/cmake/toolchain-xxxx.cmake to cmake"
)
endif()
message(STATUS "Using toolchain for ${ANDROID_TARGET_TAG}")
include(android)
include(prebuilts)
set(OPTION_CRASHUPLOAD "NONE" CACHE STRING "Destination of crash reports.")
set(OPTION_SDK_TOOLS_REVISION "" CACHE STRING "The tools revision to use, if any")
set(OPTION_SDK_TOOLS_BUILD_NUMBER "" CACHE STRING "The sdk buildnumber to use, if any.")
set(OPTION_ASAN "" CACHE STRING "The list of build sanitizers to user")
set(QTWEBENGINE FALSE CACHE BOOL "True if the webengine should be enabled.")
set(QEMU_UPSTREAM TRUE CACHE BOOL "True if the upstream version of qemu should be build.")
string(STRIP "${OPTION_SDK_TOOLS_BUILD_NUMBER}" OPTION_SDK_TOOLS_BUILD_NUMBER)
string(STRIP "${OPTION_SDK_TOOLS_REVISION}" OPTION_SDK_TOOLS_REVISION)
set_property(CACHE OPTION_CRASHUPLOAD PROPERTY STRINGS NONE STAGING PROD)
# Symbol extraction is not supported when cross compiling.
if(OPTION_CRASHUPLOAD STREQUAL "NONE")
set(ANDROID_EXTRACT_SYMBOLS FALSE)
else()
set(ANDROID_EXTRACT_SYMBOLS TRUE)
set(ANDROID_SYMBOL_DIR ${CMAKE_BINARY_DIR}/build/debug_info)
file(MAKE_DIRECTORY ${ANDROID_SYMBOL_DIR})
message(STATUS "Uploading symbols to ${OPTION_CRASHUPLOAD}")
endif()
if(ANDROID_EXTRACT_SYMBOLS
AND NOT ANDROID_HOST_TAG STREQUAL ANDROID_TARGET_TAG
AND NOT ANDROID_TARGET_TAG STREQUAL "windows-x86_64")
message(
WARNING
"Symbol extraction not supported when cross compiling from ${ANDROID_HOST_TAG} -> ${ANDROID_TARGET_TAG}, disabling."
)
set(ANDROID_EXTRACT_SYMBOLS FALSE)
endif()
# Make sure targets have complete control of include order.
set(CMAKE_INCLUDE_CURRENT_DIR OFF)
# So we are using some C++14 features..
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
# Let's bin place everything in the root, with the shared libs in the right place
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib64)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/archives)
set(CMAKE_PDB_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build/debug_info)
# We want to make sure all the cross targets end up in a unique location
set(ANDROID_CROSS_BUILD_DIRECTORY ${CMAKE_BINARY_DIR}/build/${ANDROID_HOST_TAG})
# Feeling courageous? Set this to $ANDROID_SDK_ROOT
set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/distribution/emulator)
# Pthreads from the prebuilts please!
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
set(THREADS_PREFER_PTHREAD_FLAG TRUE)
prebuilt(Threads)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
add_definitions("-DANDROID_DEBUG")
if(MSVC)
# Clang will be running in cl compatibility mode.
add_c_flag("/Od /RTC1 /EHsc")
else()
add_c_flag("-O0 -g3")
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(NOT OPTION_ASAN)
set(OPTION_ASAN address)
endif()
if(NOT ANDROID_TARGET_TAG STREQUAL "windows_msvc-x86_64")
# Build an instrumented version of the code that generates coverage mapping to enable code coverage analysis
set(ANDROID_CODE_COVERAGE TRUE)
add_c_flag("-fcoverage-mapping")
add_c_flag("-fprofile-instr-generate")
add_c_flag("-fprofile-arcs")
add_c_flag("-ftest-coverage")
add_c_flag("--coverage")
endif()
endif()
else()
set(CMAKE_INSTALL_DO_STRIP TRUE)
add_definitions("-DNDEBUG=1")
if(ANDROID_TARGET_TAG MATCHES "windows.*")
add_c_flag("-O2 -g3")
else()
add_c_flag("-O3 -g3")
endif()
endif()
# Note that clang in windows act as a drop in replacement for cl
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
add_definitions("-D__STDC_CONSTANT_MACROS" "-D_LIBCPP_VERSION=__GLIBCPP__")
# If macro expansion goes wrong, we like to see why
add_c_flag("-fmacro-backtrace-limit=0")
# Clang goes balistic on our codebase, so let's just suppress all the things.
add_c_flag("-Wno-mismatched-tags")
add_c_flag("-Wno-\#warnings")
add_c_flag("-Wno-nonportable-include-path") # Let's not break cross compilers.
add_c_flag("-Wno-unused-variable")
add_c_flag("-Wno-deprecated-declarations")
add_c_flag("-Wno-c++14-extensions")
add_c_flag("-Wno-array-bounds")
add_c_flag("-Wno-builtin-requires-header")
add_c_flag("-Wno-constant-conversion")
add_c_flag("-Wno-deprecated-register")
add_c_flag("-Wno-extern-c-compat")
add_c_flag("-Wno-gnu-designator")
add_c_flag("-Wno-inconsistent-missing-override")
add_c_flag("-Wno-initializer-overrides")
add_c_flag("-Wno-invalid-constexpr")
add_c_flag("-Wno-macro-redefined")
add_c_flag("-Wno-missing-braces")
add_c_flag("-Wno-missing-field-initializers")
add_c_flag("-Wno-parentheses-equality")
add_c_flag("-Wno-pessimizing-move")
add_c_flag("-Wno-pointer-bool-conversion")
add_c_flag("-Wno-return-type-c-linkage")
add_c_flag("-Wno-self-assign")
add_c_flag("-Wno-shift-negative-value")
add_c_flag("-Wno-string-plus-int")
add_c_flag("-Wno-uninitialized")
add_c_flag("-Wno-unknown-pragmas")
add_c_flag("-Wno-unused-command-line-argument")
add_c_flag("-Wno-unused-const-variable")
add_c_flag("-Wno-unused-function")
add_c_flag("-Wno-unused-lambda-capture")
add_c_flag("-Wno-unused-private-field")
add_c_flag("-Wno-unused-value")
add_c_flag("-Wswitch")
add_c_flag("-Wno-defaulted-function-deleted")
add_c_flag("-Wno-return-type")
endif()
if(ANDROID_TARGET_TAG STREQUAL "windows_msvc-x86_64")
add_c_flag("-Wno-microsoft-enum-forward-reference")
add_c_flag("-Wno-address-of-packed-member")
add_c_flag("-Wno-incompatible-ms-struct")
add_c_flag("-Wno-c++11-narrowing")
add_c_flag("-Wno-unknown-argument")
add_c_flag("-Wno-return-type")
add_c_flag("-Wno-microsoft-include")
add_c_flag("-Wno-incompatible-pointer-types")
add_c_flag("-Wno-incompatible-pointer-types-discards-qualifiers")
add_c_flag("-Wno-int-to-void-pointer-cast")
add_c_flag("-Wno-inconsistent-dllimport")
add_c_flag("-MD")
endif()
add_c_flag("-g")
# Disable generation of information about every class with virtual functions for use by the C++ runtime type
# identification features (dynamic_cast and typeid). If you don't use those parts of the language, you can save some
# space by using this flag. Note that exception handling uses the same information, but it will generate it as needed.
# The dynamic_cast operator can still be used for casts that do not require runtime type information, i.e. casts to
# void * or to unambiguous base classes.
#
# For msvc build, the msvc C++ headers are using RTTI features (typeid) so have cannot disable it.
if(NOT ANDROID_TARGET_TAG MATCHES "windows_msvc.*")
add_cxx_flag("-fno-rtti")
endif()
# Compiling with -fno-exceptions disables exceptions support and uses the variant of C++ libraries without exceptions.
# Use of try, catch, or throw results in an error message. Linking objects that have been compiled with -fno-
# exceptions automatically selects the libraries without exceptions. You can use the linker option --no_exceptions to
# diagnose whether the objects being linked contain exceptions. If an exception propagates into a function that has
# been compiled without exceptions support, then the program terminates.
add_cxx_flag("-fno-exceptions")
add_cxx_flag("-Wno-invalid-offsetof")
# Ensure that <inttypes.h> always defines all interesting macros.
add_definitions("-D__STDC_LIMIT_MACROS=1" "-D__STDC_FORMAT_MACROS=1")
# (From https://stackoverflow.com/questions/5582211/what-does-define-gnu-source-imply) with GNU_SOURCE, you will get:
#
# * access to lots of nonstandard GNU/Linux extension functions
# * access to traditional functions which were omitted from the POSIX standard (often for good reason, such as being
# replaced with better alternatives, or being tied to particular legacy implementations)
# * access to low-level functions that cannot be portable, but that you sometimes need for implementing system utilities
# like mount, ifconfig, etc. broken behavior for lots of POSIX-specified functions, where the GNU folks disagreed with
# the standards committee on how the functions should behave and decided to do their own thing. As long as you're
# aware of these things, it should not be a problem to define _GNU_SOURCE, but you should avoid defining it and
# instead define _POSIX_C_SOURCE=200809L or _XOPEN_SOURCE=700 when possible to ensure that your programs are portable.
add_definitions("-D_GNU_SOURCE=1")
# Enable large-file support (i.e. make off_t a 64-bit value).
add_definitions("-D_FILE_OFFSET_BITS=64" "-D_LARGEFILE_SOURCE")
if(OPTION_ASAN AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT ANDROID_TARGET_TAG STREQUAL "windows_msvc-x86_64")
message(STATUS "Enabling ASAN with: ${OPTION_ASAN}")
add_c_flag("-fsanitize=${OPTION_ASAN}")
add_c_flag("-g3")
if(OPTION_ASAN STREQUAL "address")
add_c_flag("-fno-omit-frame-pointer")
endif()
endif()
# We now have configured our base compiler..
# Unit tests please!
enable_testing()
# TODO(jansene): Make these prebuilts. Files on which the emulator (and some unit tests dependes). If a target takes a
# prebuilt_dependency on these, then they will be binplaced in ${EXECUTABLE_DIRECTORY}/lib/...
set(EMULATOR_FEATURE_DEPENDENCIES "${ANDROID_QEMU2_TOP_DIR}/android/data/advancedFeatures.ini>lib/advancedFeatures.ini"
"${ANDROID_QEMU2_TOP_DIR}/android/data/advancedFeaturesCanary.ini>lib/advancedFeaturesCanary.ini"
"${ANDROID_QEMU2_TOP_DIR}/android/data/emu-original-feature-flags.protobuf>lib/emu-original-feature-flags.protobuf")
set(
SWIFTSHADER_DEPENDENCIES
"${ANDROID_QEMU2_TOP_DIR}/../../prebuilts/android-emulator-build/common/swiftshader/${ANDROID_TARGET_OS_FLAVOR}-x86_64/lib/libEGL${CMAKE_SHARED_LIBRARY_SUFFIX}>lib64/gles_swiftshader/libEGL${CMAKE_SHARED_LIBRARY_SUFFIX}"
"${ANDROID_QEMU2_TOP_DIR}/../../prebuilts/android-emulator-build/common/swiftshader/${ANDROID_TARGET_OS_FLAVOR}-x86_64/lib/libGLES_CM${CMAKE_SHARED_LIBRARY_SUFFIX}>lib64/gles_swiftshader/libGLES_CM${CMAKE_SHARED_LIBRARY_SUFFIX}"
"${ANDROID_QEMU2_TOP_DIR}/../../prebuilts/android-emulator-build/common/swiftshader/${ANDROID_TARGET_OS_FLAVOR}-x86_64/lib/libGLESv2${CMAKE_SHARED_LIBRARY_SUFFIX}>lib64/gles_swiftshader/libGLESv2${CMAKE_SHARED_LIBRARY_SUFFIX}"
)
prebuilt(GLIB2)
prebuilt(SDL2)
prebuilt(FDT)
prebuilt(PIXMAN)
if(NOT ANDROID_TARGET_TAG MATCHES "windows_msvc.*")
prebuilt(VIRGLRENDERER)
endif()
prebuilt(TCMALLOC)
# There is no USB support on windows, so we will not try to resolve it.
if(NOT ANDROID_TARGET_TAG MATCHES "windows.*")
prebuilt(USB)
endif()
# Get the versions from git (Note that both functions are doing pretty much the same)
get_git_version(ANDROID_QEMU_VERSION)
get_git_sha(ANDROID_QEMU_SHA)
# Generate the qemu-version header.
configure_file(qemu-version.h.in qemu-version.h @ONLY)
# Lets set up a qemu dependency that we all can rely on
android_add_interface(android-qemu-deps)
# This defines all the include directories needed to compile the libqemu libraries. There should be no need to make
# additions here.
target_include_directories(
android-qemu-deps
INTERFACE tcg
tcg/i386
accel/tcg
include
disas/libvixl
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_BINARY_DIR}
qemu2-auto-generated
../../prebuilts/android-emulator-build/qemu-android-deps/${ANDROID_TARGET_TAG}/include
android-qemu2-glue/config/${ANDROID_TARGET_TAG}/)
# These are the rules that every qemu component needs, regardless of the platform you are compiling on. Please document
# any flags you set as not everyone is a compiler expert!
target_compile_definitions(android-qemu-deps INTERFACE
# Enable faster migration code when saving RAM to a snapshot
"-DCONFIG_MIGRATION_RAM_SINGLE_ITERATION")
if(NOT ANDROID_TARGET_TAG MATCHES "windows_msvc.*")
target_compile_definitions(android-qemu-deps INTERFACE
# Enable VIRGL
"-DCONFIG_VIRGL")
endif()
target_compile_options(android-qemu-deps
INTERFACE "-Werror=implicit-function-declaration" "-Wno-unused-function"
# Do not allow the compiler to assume the strictest aliasing rules
# applicable to the language being compiled. For C (and C++), this activates
# optimizations based on the type of expressions. In particular, an object
# of one type is assumed never to reside at the same address as an object of
# a different type, unless the types are almost the same. Supposedly this
# can introduce weird failures esp. on older gcc versions (MINGW)
# (See http://thiemonagel.de/2010/01/no-strict-aliasing/)
"-fno-strict-aliasing")
target_compile_options(android-qemu-deps
INTERFACE # This option instructs the compiler to assume that signed arithmetic
# overflow of addition, subtraction and multiplication wraps around using
# twos-complement representation. This flag enables some optimizations and
# disables others. The options -ftrapv and -fwrapv override each other, so
# using -ftrapv -fwrapv on the command-line results in -fwrapv being
# effective. Qemu is using this, so we use it as well.
"-fwrapv"
# The -fno-common option specifies that the compiler should instead place
# uninitialized global variables in the data section of the object file.
# This inhibits the merging of tentative definitions by the linker so you
# get a multiple-definition error if the same variable is defined in more
# than one compilation unit. Compiling with -fno-common is useful on targets
# for which it provides better performance, or if you wish to verify that
# the program will work on other systems that always treat uninitialized
# variable definitions this way.
# Remove this and you'll get all sorts of fun linker issues.
"-fno-common")
# Make sure we make our dependent libraries available.
target_link_libraries(android-qemu-deps INTERFACE GLIB2::GLIB2 PIXMAN::PIXMAN zlib)
if(NOT ANDROID_TARGET_TAG MATCHES "windows_msvc.*")
# no virglrenderer available for windows_msvc
target_link_libraries(android-qemu-deps INTERFACE VIRGL::VIRGL)
endif()
# We only support usb on mac/lin
android_target_link_libraries(android-qemu-deps darwin-x86_64 INTERFACE USB::USB)
android_target_link_libraries(android-qemu-deps linux-x86_64 INTERFACE USB::USB)
# Now we add the normal android libs, so we can use them
add_subdirectory(android)
add_subdirectory(android-qemu2-glue)
set(ANDROID_QEMU_COMMON_DEVICES "hw/pci/goldfish_address_space.c;hw/i386/pc_piix.c")
# Darwin definitions
set(ANDROID_QEMU_i386_DEVICES_darwin-x86_64 "hw/i386/acpi-build.c;${ANDROID_QEMU_COMMON_DEVICES}")
set(ANDROID_QEMU_arm_DEVICES_darwin-x86_64 "hvf-stub.c;accel/stubs/hax-stub.c")
target_compile_definitions(android-qemu-deps INTERFACE "-DANDROID_IO")
android_target_compile_options(android-qemu-deps darwin-x86_64 INTERFACE
# Emit extra code to check for buffer overflows, such as stack smashing
# attacks. This is done by adding a guard variable to functions with
# vulnerable objects. This includes functions that call alloca, and
# functions with buffers larger than 8 bytes. The guards are initialized
# when a function is entered and then checked when the function exits. If a
# guard check fails, an error message is printed and the program exits.
# Like -fstack-protector but includes additional functions to be protected —
# those that have local array definitions, or have references to local frame
# addresses.
"-fstack-protector-strong"
"-Wno-address-of-packed-member"
"-Wno-format-security"
"-Wno-initializer-overrides"
"-Wno-tautological-compare"
"-Wno-tautological-pointer-compare"
"-Wno-unused-variable"
"-Wno-format")
android_target_compile_definitions(android-qemu-deps darwin-x86_64 INTERFACE "-D_DARWIN_C_SOURCE=1")
android_target_link_libraries(android-qemu-deps darwin-x86_64 INTERFACE "-framework IOKit" "-framework CoreFoundation")
# Windows x86 definitions
set(ANDROID_QEMU_arm_DEVICES_windows-x86 "hvf-stub.c;accel/stubs/hax-stub.c")
set(ANDROID_QEMU_i386_DEVICES_windows-x86 "hvf-stub.c;hw/i386/acpi-build.c;${ANDROID_QEMU_COMMON_DEVICES}")
set(ANDROID_QEMU_arm_DEVICES_windows-x86_64 "hvf-stub.c;accel/stubs/hax-stub.c")
set(ANDROID_QEMU_i386_DEVICES_windows-x86_64 "hvf-stub.c;hw/i386/acpi-build.c;${ANDROID_QEMU_COMMON_DEVICES}")
set(ANDROID_QEMU_arm_DEVICES_windows_msvc-x86_64 "hvf-stub.c;accel/stubs/hax-stub.c")
set(ANDROID_QEMU_i386_DEVICES_windows_msvc-x86_64 "hvf-stub.c;hw/i386/acpi-build.c;${ANDROID_QEMU_COMMON_DEVICES}")
android_target_compile_options(android-qemu-deps
windows_msvc
INTERFACE
"-Wno-int-to-void-pointer-cast"
"-Werror=implicit-function-declaration"
"-Wno-unused-variable"
"-mms-bitfields"
"-mcx16")
android_target_compile_options(android-qemu-deps
windows-x86
INTERFACE
"-Werror=implicit-function-declaration"
"-mms-bitfields"
"-Wno-unused-variable"
"-Wno-unused-but-set-variable"
"-Wno-maybe-uninitialized"
"-mcx16")
android_target_compile_definitions(android-qemu-deps
windows
INTERFACE
"-DWIN32_LEAN_AND_MEAN"
"-DWINVER=0x601"
"-D_WIN32_WINNT=0x601"
"-D__USE_MINGW_ANSI_STDIO=1")
# Linux settings
set(ANDROID_QEMU_i386_DEVICES_linux-x86_64
"hvf-stub.c;accel/stubs/hax-stub.c;hw/i386/acpi-build.c;${ANDROID_QEMU_COMMON_DEVICES}")
set(ANDROID_QEMU_arm_DEVICES_linux-x86_64 "hvf-stub.c;accel/stubs/hax-stub.c")
android_target_include_directories(android-qemu-deps linux-x86_64 INTERFACE linux-headers)
android_target_compile_options(android-qemu-deps linux-x86_64 INTERFACE
# Emit extra code to check for buffer overflows, such as stack smashing
# attacks. This is done by adding a guard variable to functions with
# vulnerable objects. This includes functions that call alloca, and
# functions with buffers larger than 8 bytes. The guards are initialized
# when a function is entered and then checked when the function exits. If a
# guard check fails, an error message is printed and the program exits.
# Like -fstack-protector but includes additional functions to be protected —
# those that have local array definitions, or have references to local frame
# addresses.
"-fstack-protector-strong"
"-Wno-address-of-packed-member"
"-Wno-format-security"
"-Wno-initializer-overrides"
"-Wno-tautological-compare"
"-Wno-tautological-pointer-compare"
"-Wno-unused-variable")
android_target_link_libraries(android-qemu-deps linux-x86_64 INTERFACE "${TCMALLOC_LIBRARIES} -lutil")
android_target_link_libraries(android-qemu-deps darwin-x86_64 INTERFACE "-framework CoreAudio")
android_target_link_libraries(android-qemu-deps windows_msvc-x86_64 INTERFACE msvc-posix-compat)
set(ANDROID_AUTOGEN "qemu2-auto-generated")
set(ANDROID_QEMU2_TOP_DIR ${ANDROID_QEMU2_TOP_DIR})
include(cmake-main.${ANDROID_TARGET_TAG}.inc)
set(qemu2-common_src ${qemu2-shared_sources} ${qemu2-shared_generated_sources})
if(MSVC)
# Once we have a newer version of cmake we can generate the object library in a platform independent way b/121393952
android_add_object_library(qemu2-common)
target_link_libraries(qemu2-common PUBLIC msvc-posix-compat)
else()
android_add_library(qemu2-common)
endif()
target_compile_definitions(qemu2-common PRIVATE "-DPOISON_CONFIG_ANDROID")
target_link_libraries(qemu2-common PUBLIC android-qemu-deps)
# Not allowed to have libraries without source files.
set(headless-paaudio_src audio/paaudio-headless-impl-placeholder.c)
set(headless-paaudio_linux-x86_64_src audio/paaudio-headless-impl.c)
android_add_library(headless-paaudio)
android_add_interface(android-qemu-deps-headful)
android_target_link_libraries(android-qemu-deps-headful linux-x86_64 INTERFACE "-lpulse")
android_add_interface(android-qemu-deps-headless)
android_target_link_libraries(android-qemu-deps-headless linux-x86_64 INTERFACE headless-paaudio)
set(libqemu2-util_src ${libqemuutil_sources} ${libqemuutil_generated_sources})
if(ANDROID_TARGET_TAG STREQUAL "windows_msvc-x86_64")
# So we have some linker issues on MSVC debug (b/122598666) where clang places things in the .pdata sections which the
# MSVC linker cannot handle. We cannot use the lld-link.exe linker as it deadlocks for unknown. The workaround is to
# compile mail-loop.c with all optimizations enabled.
set_source_files_properties(util/main-loop.c PROPERTIES COMPILE_FLAGS "-O2")
set_source_files_properties(util/main-loop.c PROPERTIES COMPILE_DEFINITIONS "NDEBUG=1")
endif()
android_add_library(libqemu2-util)
target_link_libraries(libqemu2-util PRIVATE android-qemu-deps FDT)
android_target_link_libraries(libqemu2-util windows PRIVATE psapi::psapi winmm::winmm dxguid::dxguid)
android_target_link_libraries(libqemu2-util windows_msvc-x86_64 PUBLIC msvc-posix-compat)
target_compile_definitions(libqemu2-util PRIVATE "-DPOISON_CONFIG_ANDROID")
set(libqemustub_src ${libqemustub_sources} ${libqemuutil_generated_sources})
android_add_library(libqemustub)
target_link_libraries(libqemustub PRIVATE android-qemu-deps)
android_target_link_libraries(libqemustub windows_msvc-x86_64 PUBLIC msvc-posix-compat)
# Qemu-img
set(qemu-img_src ${qemu-img_sources} block/qcow2-bitmap.c)
set(qemu-img_linux-x86_64_src scsi/pr-manager.c)
android_add_executable(qemu-img)
target_link_libraries(qemu-img PRIVATE libqemu2-util libqemustub android-qemu-deps)
android_install_exe(qemu-img .)
# Create the qemu targets.
android_add_qemu_executable(i386 "${ANDROID_QEMU_i386_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_executable(x86_64 "${ANDROID_QEMU_i386_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_executable(aarch64 "${ANDROID_QEMU_arm_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_executable(armel "${ANDROID_QEMU_arm_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_headless_executable(x86_64 "${ANDROID_QEMU_i386_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_headless_executable(aarch64 "${ANDROID_QEMU_arm_DEVICES_${ANDROID_TARGET_TAG}}")
# and the upstream qemu targets, if desired.
if(QEMU_UPSTREAM)
message(STATUS "Building upstream qemu.")
android_add_qemu_upstream_executable(i386 "${ANDROID_QEMU_i386_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_upstream_executable(x86_64 "${ANDROID_QEMU_i386_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_upstream_executable(aarch64 "${ANDROID_QEMU_arm_DEVICES_${ANDROID_TARGET_TAG}}")
android_add_qemu_upstream_executable(armel "${ANDROID_QEMU_arm_DEVICES_${ANDROID_TARGET_TAG}}")
endif()
# The tests currently work on linux only.
if(ANDROID_TARGET_TAG MATCHES "linux.*")
include(qemu-test.cmake)
endif()
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/target.tag "${ANDROID_TARGET_TAG}")