project('qemu', ['c'], meson_version: '>=1.5.0',

default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++23', 'b_colorout=auto',

'b_staticpic=false', 'stdsplit=false', 'optimization=2', 'b_pie=true'] +

# build.rust_std breaks with older meson, but Rust does not

# support old meson anyway

(meson.version().version_compare('>= 1.9') ? ['rust_std=2021', 'build.rust_std=2021'] : []),

version: files('VERSION'))

add_test_setup('quick', exclude_suites: ['slow', 'thorough'], is_default: true,

env: ['RUST_BACKTRACE=1'])

add_test_setup('slow', exclude_suites: ['thorough'],

env: ['G_TEST_SLOW=1', 'SPEED=slow', 'RUST_BACKTRACE=1'])

add_test_setup('thorough',

env: ['G_TEST_SLOW=1', 'SPEED=thorough', 'RUST_BACKTRACE=1'])

meson.add_postconf_script(find_program('scripts/symlink-install-tree.py'))

####################

# Global variables #

####################

not_found = dependency('', required: false)

keyval = import('keyval')

rust = import('rust')

ss = import('sourceset')

fs = import('fs')

host_os = host_machine.system()

config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')

# Temporary directory used for files created while

# configure runs. Since it is in the build directory

# we can safely blow away any previous version of it

# (and we need not jump through hoops to try to delete

# it when configure exits.)

tmpdir = meson.current_build_dir() / 'meson-private/temp'

if get_option('qemu_suffix').startswith('/')

error('qemu_suffix cannot start with a /')

endif

qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')

qemu_datadir = get_option('datadir') / get_option('qemu_suffix')

qemu_docdir = get_option('docdir') / get_option('qemu_suffix')

qemu_moddir = get_option('libdir') / get_option('qemu_suffix')

qemu_desktopdir = get_option('datadir') / 'applications'

qemu_icondir = get_option('datadir') / 'icons'

genh = []

qapi_trace_events = []

bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']

supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux', 'emscripten']

supported_cpus = ['ppc64', 's390x', 'riscv64', 'x86_64',

'aarch64', 'loongarch64', 'mips64', 'sparc64', 'wasm64']

cpu = host_machine.cpu_family()

target_dirs = config_host['TARGET_DIRS'].split()

# type of binaries to build

have_linux_user = false

have_bsd_user = false

have_system = false

foreach target : target_dirs

have_linux_user = have_linux_user or target.endswith('linux-user')

have_bsd_user = have_bsd_user or target.endswith('bsd-user')

have_system = have_system or target.endswith('-softmmu')

endforeach

have_user = have_linux_user or have_bsd_user

############

# Programs #

############

sh = find_program('sh')

python = import('python').find_installation()

cc = meson.get_compiler('c')

all_languages = ['c']

enable_cpp = host_os == 'windows' or get_option('plugins')

if enable_cpp and add_languages('cpp', required: false, native: false)

all_languages += ['cpp']

cxx = meson.get_compiler('cpp')

endif

if host_os == 'darwin' and \

add_languages('objc', required: true, native: false)

all_languages += ['objc']

objc = meson.get_compiler('objc')

endif

have_rust = add_languages('rust', native: false,

required: get_option('rust').disable_auto_if(not have_system))

have_rust = have_rust and add_languages('rust', native: true,

required: get_option('rust').disable_auto_if(not have_system))

if have_rust

rustc = meson.get_compiler('rust')

if rustc.version().version_compare('<1.83.0')

if get_option('rust').enabled()

error('rustc version ' + rustc.version() + ' is unsupported. Please upgrade to at least 1.83.0')

else

warning('rustc version ' + rustc.version() + ' is unsupported, disabling Rust compilation.')

message('Please upgrade to at least 1.83.0 to use Rust.')

have_rust = false

endif

endif

endif

if have_rust

rustdoc = find_program('rustdoc', required: get_option('rust'))

bindgen = find_program('bindgen', required: get_option('rust'))

if not bindgen.found() or bindgen.version().version_compare('<0.60.0')

if get_option('rust').enabled()

error('bindgen version ' + bindgen.version() + ' is unsupported. You can install a new version with "cargo install --locked bindgen-cli"')

else

if bindgen.found()

warning('bindgen version ' + bindgen.version() + ' is unsupported, disabling Rust compilation.')

else

warning('bindgen not found, disabling Rust compilation.')

endif

message('To use Rust you can install a new version with "cargo install bindgen-cli"')

have_rust = false

endif

endif

endif

if have_rust

rustc_args = [find_program('scripts/rust/rustc_args.py'),

'--rustc-version', rustc.version(),

'--workspace', meson.project_source_root() / 'rust']

rustfmt = find_program('rustfmt', required: false)

rustc_lint_args = run_command(rustc_args, '--lints',

capture: true, check: true).stdout().strip().splitlines()

if get_option('strict_rust_lints')

rustc_lint_args += ['-Dwarnings', '-Funknown_lints']

endif

add_project_arguments(rustc_lint_args + ['--cfg', 'MESON'],

native: false, language: 'rust')

add_project_arguments(rustc_lint_args + ['--cfg', 'MESON'],

native: true, language: 'rust')

endif

dtrace = not_found

stap = not_found

if 'dtrace' in get_option('trace_backends')

dtrace = find_program('dtrace', required: true)

stap = find_program('stap', required: false)

if stap.found()

# Workaround to avoid dtrace(1) producing a file with 'hidden' symbol

# visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility

# instead. QEMU --enable-modules depends on this because the SystemTap

# semaphores are linked into the main binary and not the module's shared

# object.

add_global_arguments('-DSTAP_SDT_V2',

native: false, language: all_languages)

endif

endif

if get_option('iasl') == ''

iasl = find_program('iasl', required: false)

else

iasl = find_program(get_option('iasl'), required: true)

endif

edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu', 'riscv64-softmmu', 'loongarch64-softmmu' ]

unpack_edk2_blobs = false

foreach target : edk2_targets

if target in target_dirs

bzip2 = find_program('bzip2', required: get_option('install_blobs'))

unpack_edk2_blobs = bzip2.found()

break

endif

endforeach

#####################

# Option validation #

#####################

# Fuzzing

if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \

not cc.links('''

#include <stdint.h>

#include <sys/types.h>

int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);

int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }

''',

args: ['-Werror', '-fsanitize=fuzzer'])

error('Your compiler does not support -fsanitize=fuzzer')

endif

# Tracing backends

if 'ftrace' in get_option('trace_backends') and host_os != 'linux'

error('ftrace is supported only on Linux')

endif

if 'syslog' in get_option('trace_backends') and not cc.compiles('''

#include <syslog.h>

int main(void) {

openlog("qemu", LOG_PID, LOG_DAEMON);

syslog(LOG_INFO, "configure");

return 0;

}''')

error('syslog is not supported on this system')

endif

# Miscellaneous Linux-only features

get_option('mpath') \

.require(host_os == 'linux', error_message: 'Multipath is supported only on Linux')

multiprocess_allowed = get_option('multiprocess') \

.require(host_os == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \

.allowed()

vfio_user_server_allowed = get_option('vfio_user_server') \

.require(host_os == 'linux', error_message: 'vfio-user server is supported only on Linux') \

.allowed()

have_tpm = get_option('tpm') \

.require(host_os != 'windows', error_message: 'TPM emulation only available on POSIX systems') \

.allowed()

# vhost

have_vhost_user = get_option('vhost_user') \

.disable_auto_if(host_os != 'linux') \

.require(host_os != 'windows',

error_message: 'vhost-user is not available on Windows').allowed()

have_vhost_vdpa = get_option('vhost_vdpa') \

.require(host_os == 'linux',

error_message: 'vhost-vdpa is only available on Linux').allowed()

have_vhost_kernel = get_option('vhost_kernel') \

.require(host_os == 'linux',

error_message: 'vhost-kernel is only available on Linux').allowed()

have_vhost_user_crypto = get_option('vhost_crypto') \

.require(have_vhost_user,

error_message: 'vhost-crypto requires vhost-user to be enabled').allowed()

have_vhost = have_vhost_user or have_vhost_vdpa or have_vhost_kernel

have_vhost_net_user = have_vhost_user and get_option('vhost_net').allowed()

have_vhost_net_vdpa = have_vhost_vdpa and get_option('vhost_net').allowed()

have_vhost_net_kernel = have_vhost_kernel and get_option('vhost_net').allowed()

have_vhost_net = have_vhost_net_kernel or have_vhost_net_user or have_vhost_net_vdpa

have_tcg = get_option('tcg').allowed() and (have_system or have_user)

have_tools = get_option('tools') \

.disable_auto_if(not have_system) \

.allowed()

have_ga = get_option('guest_agent') \

.disable_auto_if(not have_system and not have_tools) \

.require(host_os in ['sunos', 'linux', 'windows', 'freebsd', 'netbsd', 'openbsd'],

error_message: 'unsupported OS for QEMU guest agent') \

.allowed()

have_block = have_system or have_tools

enable_modules = get_option('modules') \

.require(host_os != 'windows',

error_message: 'Modules are not available for Windows') \

.require(not get_option('prefer_static'),

error_message: 'Modules are incompatible with static linking') \

.allowed()

#######################################

# Variables for host and accelerators #

#######################################

if cpu not in supported_cpus

host_arch = 'unknown'

else

host_arch = cpu

endif

if cpu == 'x86_64'

kvm_targets = ['i386-softmmu', 'x86_64-softmmu']

elif cpu == 'aarch64'

kvm_targets = ['aarch64-softmmu']

elif cpu == 's390x'

kvm_targets = ['s390x-softmmu']

elif cpu == 'ppc64'

kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']

elif cpu == 'mips64'

kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']

elif cpu == 'riscv64'

kvm_targets = ['riscv64-softmmu']

elif cpu == 'loongarch64'

kvm_targets = ['loongarch64-softmmu']

else

kvm_targets = []

endif

accelerator_targets = { 'CONFIG_KVM': kvm_targets }

if cpu == 'x86_64'

xen_targets = ['i386-softmmu', 'x86_64-softmmu']

elif cpu == 'aarch64'

# i386 emulator provides xenpv machine type for multiple architectures

xen_targets = ['i386-softmmu', 'x86_64-softmmu', 'aarch64-softmmu']

else

xen_targets = []

endif

accelerator_targets += { 'CONFIG_XEN': xen_targets }

if cpu == 'aarch64'

accelerator_targets += {

'CONFIG_HVF': ['aarch64-softmmu'],

'CONFIG_NITRO': ['aarch64-softmmu'],

'CONFIG_WHPX': ['aarch64-softmmu']

}

elif cpu == 'x86_64'

accelerator_targets += {

'CONFIG_HVF': ['x86_64-softmmu'],

'CONFIG_NITRO': ['x86_64-softmmu'],

'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],

'CONFIG_WHPX': ['x86_64-softmmu'],

'CONFIG_MSHV': ['x86_64-softmmu'],

}

endif

##################

# Compiler flags #

##################

if (cc.sizeof('void *') < 8) and (have_system or have_user)

error('QEMU emulator requires a 64-bit CPU host architecture. Only tools may be built for 32-bit.')

endif

foreach lang : all_languages

compiler = meson.get_compiler(lang)

if compiler.get_id() == 'gcc' and compiler.version().version_compare('>=7.4')

# ok

elif compiler.get_id() == 'clang' and compiler.compiles('''

#ifdef __apple_build_version__

# if __clang_major__ < 15 || (__clang_major__ == 15 && __clang_minor__ < 0)

# error You need at least XCode Clang v15.0 to compile QEMU

# endif

#else

# if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)

# error You need at least Clang v10.0 to compile QEMU

# endif

#endif''')

# ok

elif compiler.get_id() == 'emscripten'

# ok

else

error('You either need GCC v7.4 or Clang v10.0 (or XCode Clang v15.0) to compile QEMU')

endif

endforeach

# default flags for all hosts

# We use -fwrapv to tell the compiler that we require a C dialect where

# left shift of signed integers is well defined and has the expected

# 2s-complement style results. (Both clang and gcc agree that it

# provides these semantics.)

qemu_common_flags = [

'-D_GNU_SOURCE', '-D_FILE_OFFSET_BITS=64', '-D_LARGEFILE_SOURCE',

'-fno-strict-aliasing', '-fno-common', '-fwrapv' ]

qemu_cflags = []

qemu_ldflags = []

if host_os == 'darwin'

# Disable attempts to use ObjectiveC features in os/object.h since they

# won't work when we're compiling with gcc as a C compiler.

if compiler.get_id() == 'gcc'

qemu_common_flags += '-DOS_OBJECT_USE_OBJC=0'

endif

elif host_os == 'sunos'

# needed for CMSG_ macros in sys/socket.h

qemu_common_flags += '-D_XOPEN_SOURCE=600'

# needed for TIOCWIN* defines in termios.h

qemu_common_flags += '-D__EXTENSIONS__'

elif host_os == 'haiku'

qemu_common_flags += ['-DB_USE_POSITIVE_POSIX_ERRORS', '-D_BSD_SOURCE', '-fPIC']

elif host_os == 'windows'

# plugins use delaylib, and clang needs to be used with lld to make it work.

if compiler.get_id() == 'clang' and compiler.get_linker_id() != 'ld.lld'

error('On windows, you need to use lld with clang - use msys2 clang64/clangarm64 env')

endif

endif

# Choose instruction set (currently x86-only)

qemu_isa_flags = []

# Pick x86-64 baseline version

if host_arch == 'x86_64'

if get_option('x86_version') == '0'

error('x86_64-v1 required for x86-64 hosts')

endif

# add flags for individual instruction set extensions

if get_option('x86_version') >= '1'

# present on basically all processors but technically not part of

# x86-64-v1, so only include -mneeded for x86-64 version 2 and above

qemu_isa_flags += ['-mcx16']

endif

if get_option('x86_version') >= '2'

qemu_isa_flags += ['-mpopcnt']

qemu_isa_flags += cc.get_supported_arguments('-mneeded')

endif

if get_option('x86_version') >= '3'

qemu_isa_flags += ['-mmovbe', '-mabm', '-mbmi', '-mbmi2', '-mfma', '-mf16c']

endif

# add required vector instruction set (each level implies those below)

if get_option('x86_version') == '1'

qemu_isa_flags += ['-msse2']

elif get_option('x86_version') == '2'

qemu_isa_flags += ['-msse4.2']

elif get_option('x86_version') == '3'

qemu_isa_flags += ['-mavx2']

elif get_option('x86_version') == '4'

qemu_isa_flags += ['-mavx512f', '-mavx512bw', '-mavx512cd', '-mavx512dq', '-mavx512vl']

endif

endif

# GCC >= 16 automatically tries to link libatomic for all programs.

#

# QEMU explicitly does NOT want to use libatomic for int128 types.

#

# Later checks assume we won't get atomic ops for int128 without

# explicitly asking for -latomic, so we must disable GCC's new

# automatic linking with the new -fno-link-libatomic flag.

#

# When not building the emulators, but qemu helper tools only

# (e.g. on 32-bit hosts), libatomic is sometimes required and

# thus acceptable.

if (have_system or have_user)

qemu_isa_flags += cc.get_supported_arguments('-fno-link-libatomic')

else

qemu_ldflags += cc.get_supported_link_arguments('-latomic')

endif

qemu_common_flags = qemu_isa_flags + qemu_common_flags

if get_option('prefer_static')

qemu_ldflags += get_option('b_pie') ? '-static-pie' : '-static'

endif

# Meson currently only handles pie as a boolean for now, so if the user

# has explicitly disabled PIE we need to extend our cflags.

#

# -no-pie is supposedly a linker flag that has no effect on the compiler

# command line, but some distros, that didn't quite know what they were

# doing, made local changes to gcc's specs file that turned it into

# a compiler command-line flag.

#

# What about linker flags? For a static build, no PIE is implied by -static

# which we added above (and if it's not because of the same specs patching,

# there's nothing we can do: compilation will fail, report a bug to your

# distro and do not use --disable-pie in the meanwhile). For dynamic linking,

# instead, we can't add -no-pie because it overrides -shared: the linker then

# tries to build an executable instead of a shared library and fails. So

# don't add -no-pie anywhere and cross fingers. :(

#

# Emscripten doesn't support -no-pie but meson can't catch the compiler

# warning. So explicitly omit the flag for Emscripten.

if not get_option('b_pie') and host_os != 'emscripten'

qemu_common_flags += cc.get_supported_arguments('-fno-pie', '-no-pie')

endif

if not get_option('stack_protector').disabled()

stack_protector_probe = '''

int main(int argc, char *argv[])

{

char arr[64], *p = arr, *c = argv[argc - 1];

while (*c) {

*p++ = *c++;

}

return 0;

}'''

have_stack_protector = false

foreach arg : ['-fstack-protector-strong', '-fstack-protector-all']

# We need to check both a compile and a link, since some compiler

# setups fail only on a .c->.o compile and some only at link time

if cc.compiles(stack_protector_probe, args: ['-Werror', arg]) and \

cc.links(stack_protector_probe, args: ['-Werror', arg])

have_stack_protector = true

qemu_cflags += arg

qemu_ldflags += arg

break

endif

endforeach

get_option('stack_protector') \

.require(have_stack_protector, error_message: 'Stack protector not supported')

endif

coroutine_backend = get_option('coroutine_backend')

ucontext_probe = '''

#include <ucontext.h>

#ifdef __stub_makecontext

#error Ignoring glibc stub makecontext which will always fail

#endif

int main(void) { makecontext(0, 0, 0); return 0; }'''

# On Windows the only valid backend is the Windows specific one.

# For POSIX prefer ucontext, but it's not always possible. The fallback

# is sigcontext.

supported_backends = []

if host_os == 'windows'

supported_backends += ['windows']

elif host_os == 'emscripten'

supported_backends += ['wasm']

else

if host_os != 'darwin' and cc.links(ucontext_probe)

supported_backends += ['ucontext']

endif

supported_backends += ['sigaltstack']

endif

if coroutine_backend == 'auto'

coroutine_backend = supported_backends[0]

elif coroutine_backend not in supported_backends

error('"@0@" backend requested but not available. Available backends: @1@' \

.format(coroutine_backend, ', '.join(supported_backends)))

endif

# Compiles if SafeStack *not* enabled

safe_stack_probe = '''

int main(void)

{

#if defined(__has_feature)

#if __has_feature(safe_stack)

#error SafeStack Enabled

#endif

#endif

return 0;

}'''

if get_option('safe_stack') != not cc.compiles(safe_stack_probe)

safe_stack_arg = get_option('safe_stack') ? '-fsanitize=safe-stack' : '-fno-sanitize=safe-stack'

if get_option('safe_stack') != not cc.compiles(safe_stack_probe, args: safe_stack_arg)

error(get_option('safe_stack') \

? 'SafeStack not supported by your compiler' \

: 'Cannot disable SafeStack')

endif

qemu_cflags += safe_stack_arg

qemu_ldflags += safe_stack_arg

endif

if get_option('safe_stack') and coroutine_backend != 'ucontext'

error('SafeStack is only supported with the ucontext coroutine backend')

endif

if get_option('asan')

if cc.has_argument('-fsanitize=address')

qemu_cflags = ['-fsanitize=address'] + qemu_cflags

qemu_ldflags = ['-fsanitize=address'] + qemu_ldflags

else

error('Your compiler does not support -fsanitize=address')

endif

endif

if get_option('ubsan')

# Detect static linking issue with ubsan:

# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84285

if cc.links('int main(int argc, char **argv) { return argc + 1; }',

args: [qemu_ldflags, '-fsanitize=undefined'])

qemu_cflags += ['-fsanitize=undefined']

qemu_ldflags += ['-fsanitize=undefined']

# Suppress undefined behaviour from function call to mismatched type.

# In addition, tcg prologue does not emit function type prefix

# required by function call sanitizer.

if cc.has_argument('-fno-sanitize=function')

qemu_cflags += ['-fno-sanitize=function']

endif

else

error('Your compiler does not support -fsanitize=undefined')

endif

endif

# Thread sanitizer is, for now, much noisier than the other sanitizers;

# keep it separate until that is not the case.

if get_option('tsan')

if get_option('asan') or get_option('ubsan')

error('TSAN is not supported with other sanitizers')

endif

if not cc.has_function('__tsan_create_fiber',

args: '-fsanitize=thread',

prefix: '#include <sanitizer/tsan_interface.h>')

error('Cannot enable TSAN due to missing fiber annotation interface')

endif

tsan_warn_suppress = []

# gcc (>=11) will report constructions not supported by tsan:

# "error: ‘atomic_thread_fence’ is not supported with ‘-fsanitize=thread’"

# https://gcc.gnu.org/gcc-11/changes.html

# However, clang does not support this warning and this triggers an error.

if cc.has_argument('-Wno-tsan')

tsan_warn_suppress = ['-Wno-tsan']

endif

qemu_cflags = ['-fsanitize=thread'] + tsan_warn_suppress + qemu_cflags

qemu_ldflags = ['-fsanitize=thread'] + qemu_ldflags

endif

# Detect support for PT_GNU_RELRO + DT_BIND_NOW.

# The combination is known as "full relro", because .got.plt is read-only too.

qemu_ldflags += cc.get_supported_link_arguments('-Wl,-z,relro', '-Wl,-z,now')

if host_os == 'windows'

qemu_ldflags += cc.get_supported_link_arguments('-Wl,--no-seh', '-Wl,--nxcompat')

qemu_ldflags += cc.get_supported_link_arguments('-Wl,--dynamicbase', '-Wl,--high-entropy-va')

endif

if get_option('fuzzing')

# Specify a filter to only instrument code that is directly related to

# virtual-devices.

configure_file(output: 'instrumentation-filter',

input: 'scripts/oss-fuzz/instrumentation-filter-template',

copy: true)

if cc.compiles('int main () { return 0; }',

name: '-fsanitize-coverage-allowlist=/dev/null',

args: ['-fsanitize-coverage-allowlist=/dev/null',

'-fsanitize-coverage=trace-pc'] )

qemu_common_flags += ['-fsanitize-coverage-allowlist=instrumentation-filter']

endif

if get_option('fuzzing_engine') == ''

# Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the

# compiled code. To build non-fuzzer binaries with --enable-fuzzing, link

# everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be

# unable to bind the fuzzer-related callbacks added by instrumentation.

qemu_common_flags += ['-fsanitize=fuzzer-no-link']

qemu_ldflags += ['-fsanitize=fuzzer-no-link']

# For the actual fuzzer binaries, we need to link against the libfuzzer

# library. They need to be configurable, to support OSS-Fuzz

fuzz_exe_ldflags = ['-fsanitize=fuzzer']

else

# LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and

# the needed CFLAGS have already been provided

fuzz_exe_ldflags = get_option('fuzzing_engine').split()

endif

endif

if get_option('cfi')

cfi_flags=[]

# Check for dependency on LTO

if not get_option('b_lto')

error('Selected Control-Flow Integrity but LTO is disabled')

endif

if enable_modules

error('Selected Control-Flow Integrity is not compatible with modules')

endif

# Check for cfi flags. CFI requires LTO so we can't use

# get_supported_arguments, but need a more complex "compiles" which allows

# custom arguments

if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',

args: ['-flto', '-fsanitize=cfi-icall'] )

cfi_flags += '-fsanitize=cfi-icall'

else

error('-fsanitize=cfi-icall is not supported by the compiler')

endif

if cc.compiles('int main () { return 0; }',

name: '-fsanitize-cfi-icall-generalize-pointers',

args: ['-flto', '-fsanitize=cfi-icall',

'-fsanitize-cfi-icall-generalize-pointers'] )

cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'

else

error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')

endif

if get_option('cfi_debug')

if get_option('safe_stack')

error('cfi_debug is not compatible with safe_stack')

endif

if cc.compiles('int main () { return 0; }',

name: '-fno-sanitize-trap=cfi-icall',

args: ['-flto', '-fsanitize=cfi-icall',

'-fno-sanitize-trap=cfi-icall'] )

cfi_flags += '-fno-sanitize-trap=cfi-icall'

else

error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')

endif

endif

add_global_arguments(cfi_flags, native: false, language: all_languages)

add_global_link_arguments(cfi_flags, native: false, language: all_languages)

endif

# Check further flags that make QEMU more robust against malicious parties

hardening_flags = [

# Initialize all stack variables to zero. This makes

# it harder to take advantage of uninitialized stack

# data to drive exploits

'-ftrivial-auto-var-init=zero',

]

# Zero out registers used during a function call

# upon its return. This makes it harder to assemble

# ROP gadgets into something usable

#

# NB: Clang 17 is broken and SEGVs

# https://github.com/llvm/llvm-project/issues/75168

if cc.compiles('extern struct { void (*cb)(void); } s; void f(void) { s.cb(); }',

name: '-fzero-call-used-regs=used-gpr',

args: ['-O2', '-fzero-call-used-regs=used-gpr'])

hardening_flags += '-fzero-call-used-regs=used-gpr'

endif

qemu_common_flags += hardening_flags

# Collect warning flags we want to set, sorted alphabetically

warn_flags = [

# First enable interesting warnings

'-Wempty-body',

'-Wendif-labels',

'-Wexpansion-to-defined',

'-Wformat-overflow=2',

'-Wformat-security',

'-Wformat-y2k',

'-Wignored-qualifiers',

'-Wimplicit-fallthrough=2',

'-Winit-self',

'-Wmissing-format-attribute',

'-Wmissing-prototypes',

'-Wnested-externs',

'-Wold-style-declaration',

'-Wold-style-definition',

'-Wredundant-decls',

'-Wshadow=local',

'-Wstrict-prototypes',

'-Wtype-limits',

'-Wundef',

'-Wvla',

'-Wwrite-strings',

# Then disable some undesirable warnings

'-Wno-gnu-variable-sized-type-not-at-end',

'-Wno-initializer-overrides',

'-Wno-missing-include-dirs',

'-Wno-psabi',

'-Wno-shift-negative-value',

'-Wno-string-plus-int',

'-Wno-tautological-type-limit-compare',

'-Wno-typedef-redefinition',

]

if host_os != 'darwin'

tsa_has_cleanup = cc.compiles('''

struct __attribute__((capability("mutex"))) mutex {};

void lock(struct mutex *m) __attribute__((acquire_capability(m)));

void unlock(struct mutex *m) __attribute__((release_capability(m)));

void test(void) {

struct mutex __attribute__((cleanup(unlock))) m;

lock(&m);

}

''', args: ['-Wthread-safety', '-Werror'])

if tsa_has_cleanup

warn_flags += ['-Wthread-safety']

endif

endif

# Set up C++ compiler flags

qemu_cxxflags = []

if 'cpp' in all_languages

qemu_cxxflags = ['-D__STDC_LIMIT_MACROS', '-D__STDC_CONSTANT_MACROS', '-D__STDC_FORMAT_MACROS'] + qemu_cflags

endif

add_project_arguments(cc.get_supported_arguments(qemu_common_flags + qemu_cflags + warn_flags),

native: false, language: 'c')

add_global_link_arguments(qemu_ldflags, native: false, language: all_languages)

if 'cpp' in all_languages

add_project_arguments(cxx.get_supported_arguments(qemu_common_flags + qemu_cxxflags),

native: false, language: 'cpp')

add_project_arguments(cxx.get_supported_arguments(warn_flags), native: false, language: 'cpp')

endif

if 'objc' in all_languages

# Note sanitizer flags are not applied to Objective-C sources!

add_project_arguments(objc.get_supported_arguments(qemu_common_flags + warn_flags),

native: false, language: 'objc')

endif

if host_os == 'linux'

add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',

'-isystem', 'linux-headers',

language: all_languages)

endif

add_project_arguments('-iquote', '.',

'-iquote', meson.current_source_dir(),

'-iquote', meson.current_source_dir() / 'include',

language: all_languages)

# If a host-specific include directory exists, list that first...

host_include = meson.current_source_dir() / 'host/include/'

if fs.is_dir(host_include / host_arch)

add_project_arguments('-iquote', host_include / host_arch,

language: all_languages)

endif

# ... followed by the generic fallback.

add_project_arguments('-iquote', host_include / 'generic',

language: all_languages)

sparse = find_program('cgcc', required: get_option('sparse'))

if sparse.found()

run_target('sparse',

command: [find_program('scripts/check_sparse.py'),

'compile_commands.json', sparse.full_path(), '-Wbitwise',

'-Wno-transparent-union', '-Wno-old-initializer',

'-Wno-non-pointer-null'])

endif

#####################################

# Host-specific libraries and flags #

#####################################

libm = cc.find_library('m', required: false)

threads = dependency('threads')

util = cc.find_library('util', required: false)

winmm = []

socket = []

version_res = []

coref = []

iokit = []

pvg = not_found

emulator_link_args = []

midl = not_found

widl = not_found

pathcch = not_found

synchronization = not_found

host_dsosuf = '.so'

if host_os == 'windows'

midl = find_program('midl', required: false)

widl = find_program('widl', required: false)

# MinGW uses lowercase for library names

pathcch = cc.find_library('pathcch', required: true)

synchronization = cc.find_library('synchronization', required: true)

socket = cc.find_library('ws2_32', required: true)

winmm = cc.find_library('winmm', required: true)

win = import('windows')

version_res = win.compile_resources('version.rc',

depend_files: files('pc-bios/qemu-nsis.ico'),

include_directories: include_directories('.'))

host_dsosuf = '.dll'

elif host_os == 'darwin'

coref = dependency('appleframeworks', modules: 'CoreFoundation')

iokit = dependency('appleframeworks', modules: 'IOKit', required: false)

host_dsosuf = '.dylib'

pvg = dependency('appleframeworks', modules: ['ParavirtualizedGraphics', 'Metal'],

required: get_option('pvg'))

elif host_os == 'sunos'

socket = [cc.find_library('socket'),

cc.find_library('nsl'),

cc.find_library('resolv')]

elif host_os == 'haiku'

socket = [cc.find_library('posix_error_mapper'),

cc.find_library('network'),

cc.find_library('bsd')]

elif host_os == 'openbsd'

if have_tcg

# Disable OpenBSD W^X if available

emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')

endif

endif

###############################################

# Host-specific configuration of accelerators #

###############################################

accelerators = []

if get_option('kvm').allowed() and host_os == 'linux'

accelerators += 'CONFIG_KVM'

endif

if get_option('mshv').allowed() and host_os == 'linux'

if get_option('mshv').enabled() and host_machine.cpu() != 'x86_64'

error('mshv accelerator requires x64_64 host')

endif

accelerators += 'CONFIG_MSHV'

endif

if get_option('whpx').allowed() and host_os == 'windows'

if cpu == 'i386'

if get_option('whpx').enabled()

error('WHPX requires 64-bit host')

endif

# Leave CONFIG_WHPX disabled

else

if cc.has_header('winhvplatform.h', required: get_option('whpx'))

accelerators += 'CONFIG_WHPX'

endif

endif

endif

hvf = not_found

if get_option('hvf').allowed()

hvf = dependency('appleframeworks', modules: 'Hypervisor',

required: get_option('hvf'))

if hvf.found()

accelerators += 'CONFIG_HVF'

endif

endif

nitro = not_found

if get_option('nitro').allowed() and host_os == 'linux'

accelerators += 'CONFIG_NITRO'

endif

nvmm = not_found

if host_os == 'netbsd'

nvmm = cc.find_library('nvmm', required: get_option('nvmm'))

if nvmm.found()

accelerators += 'CONFIG_NVMM'

endif

endif

tcg_arch = host_arch

if have_tcg

if host_arch == 'unknown'

if not get_option('tcg_interpreter')

error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))

endif

elif host_arch == 'wasm64'

if not get_option('tcg_interpreter')

error('WebAssembly host requires --enable-tcg-interpreter')

endif

elif get_option('tcg_interpreter')

warning('Use of the TCG interpreter is not recommended on this host')

warning('architecture. There is a native TCG execution backend available')

warning('which provides substantially better performance and reliability.')

warning('It is strongly recommended to remove the --enable-tcg-interpreter')

warning('configuration option on this architecture to use the native')

warning('backend.')

endif

if get_option('tcg_interpreter')

tcg_arch = 'tci'

endif

add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,

language: all_languages)

accelerators += 'CONFIG_TCG'

endif

if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()

error('KVM not available on this platform')

endif

if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()

error('HVF not available on this platform')

endif

if 'CONFIG_NITRO' not in accelerators and get_option('nitro').enabled()

error('NITRO not available on this platform')

endif

if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()

error('NVMM not available on this platform')

endif

if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()

error('WHPX not available on this platform')

endif

if 'CONFIG_MSHV' not in accelerators and get_option('mshv').enabled()

error('mshv not available on this platform')

endif

xen = not_found

if get_option('xen').enabled() or (get_option('xen').auto() and have_system)

xencontrol = dependency('xencontrol', required: false,

method: 'pkg-config')

if xencontrol.found()

xen_pc = declare_dependency(version: xencontrol.version(),

dependencies: [

xencontrol,

# disabler: true makes xen_pc.found() return false if any is not found

dependency('xenstore', required: false,

method: 'pkg-config',

disabler: true),

dependency('xenforeignmemory', required: false,

method: 'pkg-config',

disabler: true),

dependency('xengnttab', required: false,

method: 'pkg-config',

disabler: true),

dependency('xenevtchn', required: false,

method: 'pkg-config',

disabler: true),

dependency('xendevicemodel', required: false,

method: 'pkg-config',

disabler: true),

# optional, no "disabler: true"

dependency('xentoolcore', required: false,

method: 'pkg-config')])

if xen_pc.found()

xen = xen_pc

endif

endif

if not xen.found()

xen_tests = [ '4.11.0', '4.10.0', '4.9.0', '4.8.0', '4.7.1' ]

xen_libs = {

'4.11.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],

'4.10.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],

'4.9.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],

'4.8.0': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],

'4.7.1': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],

}

xen_deps = {}

foreach ver: xen_tests

# cache the various library tests to avoid polluting the logs

xen_test_deps = []