meson.build

   1 project('qemu', ['c'], meson_version: '>=0.63.0',
   2         default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
   3                           'b_staticpic=false', 'stdsplit=false', 'optimization=2', 'b_pie=true'],
   4         version: files('VERSION'))
   5
   6 add_test_setup('quick', exclude_suites: ['slow', 'thorough'], is_default: true)
   7 add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
   8 add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
   9
  10 meson.add_postconf_script(find_program('scripts/symlink-install-tree.py'))
  11
  12 ####################
  13 # Global variables #
  14 ####################
  15
  16 not_found = dependency('', required: false)
  17 keyval = import('keyval')
  18 ss = import('sourceset')
  19 fs = import('fs')
  20
  21 host_os = host_machine.system()
  22 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
  23
  24 # Temporary directory used for files created while
  25 # configure runs. Since it is in the build directory
  26 # we can safely blow away any previous version of it
  27 # (and we need not jump through hoops to try to delete
  28 # it when configure exits.)
  29 tmpdir = meson.current_build_dir() / 'meson-private/temp'
  30
  31 if get_option('qemu_suffix').startswith('/')
  32   error('qemu_suffix cannot start with a /')
  33 endif
  34
  35 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
  36 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
  37 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
  38 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
  39
  40 qemu_desktopdir = get_option('datadir') / 'applications'
  41 qemu_icondir = get_option('datadir') / 'icons'
  42
  43 genh = []
  44 qapi_trace_events = []
  45
  46 bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']
  47 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
  48 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
  49   'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc64']
  50
  51 cpu = host_machine.cpu_family()
  52
  53 target_dirs = config_host['TARGET_DIRS'].split()
  54
  55 ############
  56 # Programs #
  57 ############
  58
  59 sh = find_program('sh')
  60 python = import('python').find_installation()
  61
  62 cc = meson.get_compiler('c')
  63 all_languages = ['c']
  64 if host_os == 'windows' and add_languages('cpp', required: false, native: false)
  65   all_languages += ['cpp']
  66   cxx = meson.get_compiler('cpp')
  67 endif
  68 if host_os == 'darwin' and \
  69    add_languages('objc', required: get_option('cocoa'), native: false)
  70   all_languages += ['objc']
  71   objc = meson.get_compiler('objc')
  72 endif
  73
  74 dtrace = not_found
  75 stap = not_found
  76 if 'dtrace' in get_option('trace_backends')
  77   dtrace = find_program('dtrace', required: true)
  78   stap = find_program('stap', required: false)
  79   if stap.found()
  80     # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
  81     # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
  82     # instead. QEMU --enable-modules depends on this because the SystemTap
  83     # semaphores are linked into the main binary and not the module's shared
  84     # object.
  85     add_global_arguments('-DSTAP_SDT_V2',
  86                          native: false, language: all_languages)
  87   endif
  88 endif
  89
  90 if get_option('iasl') == ''
  91   iasl = find_program('iasl', required: false)
  92 else
  93   iasl = find_program(get_option('iasl'), required: true)
  94 endif
  95
  96 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
  97 unpack_edk2_blobs = false
  98 foreach target : edk2_targets
  99   if target in target_dirs
 100     bzip2 = find_program('bzip2', required: get_option('install_blobs'))
 101     unpack_edk2_blobs = bzip2.found()
 102     break
 103   endif
 104 endforeach
 105
 106 #####################
 107 # Option validation #
 108 #####################
 109
 110 # Fuzzing
 111 if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
 112     not cc.links('''
 113           #include <stdint.h>
 114           #include <sys/types.h>
 115           int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
 116           int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
 117         ''',
 118         args: ['-Werror', '-fsanitize=fuzzer'])
 119   error('Your compiler does not support -fsanitize=fuzzer')
 120 endif
 121
 122 # Tracing backends
 123 if 'ftrace' in get_option('trace_backends') and host_os != 'linux'
 124   error('ftrace is supported only on Linux')
 125 endif
 126 if 'syslog' in get_option('trace_backends') and not cc.compiles('''
 127     #include <syslog.h>
 128     int main(void) {
 129         openlog("qemu", LOG_PID, LOG_DAEMON);
 130         syslog(LOG_INFO, "configure");
 131         return 0;
 132     }''')
 133   error('syslog is not supported on this system')
 134 endif
 135
 136 # Miscellaneous Linux-only features
 137 get_option('mpath') \
 138   .require(host_os == 'linux', error_message: 'Multipath is supported only on Linux')
 139
 140 multiprocess_allowed = get_option('multiprocess') \
 141   .require(host_os == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
 142   .allowed()
 143
 144 vfio_user_server_allowed = get_option('vfio_user_server') \
 145   .require(host_os == 'linux', error_message: 'vfio-user server is supported only on Linux') \
 146   .allowed()
 147
 148 have_tpm = get_option('tpm') \
 149   .require(host_os != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
 150   .allowed()
 151
 152 # vhost
 153 have_vhost_user = get_option('vhost_user') \
 154   .disable_auto_if(host_os != 'linux') \
 155   .require(host_os != 'windows',
 156            error_message: 'vhost-user is not available on Windows').allowed()
 157 have_vhost_vdpa = get_option('vhost_vdpa') \
 158   .require(host_os == 'linux',
 159            error_message: 'vhost-vdpa is only available on Linux').allowed()
 160 have_vhost_kernel = get_option('vhost_kernel') \
 161   .require(host_os == 'linux',
 162            error_message: 'vhost-kernel is only available on Linux').allowed()
 163 have_vhost_user_crypto = get_option('vhost_crypto') \
 164   .require(have_vhost_user,
 165            error_message: 'vhost-crypto requires vhost-user to be enabled').allowed()
 166
 167 have_vhost = have_vhost_user or have_vhost_vdpa or have_vhost_kernel
 168
 169 have_vhost_net_user = have_vhost_user and get_option('vhost_net').allowed()
 170 have_vhost_net_vdpa = have_vhost_vdpa and get_option('vhost_net').allowed()
 171 have_vhost_net_kernel = have_vhost_kernel and get_option('vhost_net').allowed()
 172 have_vhost_net = have_vhost_net_kernel or have_vhost_net_user or have_vhost_net_vdpa
 173
 174 # type of binaries to build
 175 have_linux_user = false
 176 have_bsd_user = false
 177 have_system = false
 178 foreach target : target_dirs
 179   have_linux_user = have_linux_user or target.endswith('linux-user')
 180   have_bsd_user = have_bsd_user or target.endswith('bsd-user')
 181   have_system = have_system or target.endswith('-softmmu')
 182 endforeach
 183 have_user = have_linux_user or have_bsd_user
 184
 185 have_tools = get_option('tools') \
 186   .disable_auto_if(not have_system) \
 187   .allowed()
 188 have_ga = get_option('guest_agent') \
 189   .disable_auto_if(not have_system and not have_tools) \
 190   .require(host_os in ['sunos', 'linux', 'windows', 'freebsd', 'netbsd', 'openbsd'],
 191            error_message: 'unsupported OS for QEMU guest agent') \
 192   .allowed()
 193 have_block = have_system or have_tools
 194
 195 enable_modules = get_option('modules') \
 196   .require(host_os != 'windows',
 197            error_message: 'Modules are not available for Windows') \
 198   .require(not get_option('prefer_static'),
 199            error_message: 'Modules are incompatible with static linking') \
 200   .allowed()
 201
 202 #######################################
 203 # Variables for host and accelerators #
 204 #######################################
 205
 206 if cpu not in supported_cpus
 207   host_arch = 'unknown'
 208 elif cpu == 'x86'
 209   host_arch = 'i386'
 210 elif cpu == 'mips64'
 211   host_arch = 'mips'
 212 elif cpu in ['riscv32', 'riscv64']
 213   host_arch = 'riscv'
 214 else
 215   host_arch = cpu
 216 endif
 217
 218 if cpu in ['x86', 'x86_64']
 219   kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
 220 elif cpu == 'aarch64'
 221   kvm_targets = ['aarch64-softmmu']
 222 elif cpu == 's390x'
 223   kvm_targets = ['s390x-softmmu']
 224 elif cpu in ['ppc', 'ppc64']
 225   kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
 226 elif cpu in ['mips', 'mips64']
 227   kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
 228 elif cpu in ['riscv32']
 229   kvm_targets = ['riscv32-softmmu']
 230 elif cpu in ['riscv64']
 231   kvm_targets = ['riscv64-softmmu']
 232 else
 233   kvm_targets = []
 234 endif
 235 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
 236
 237 if cpu in ['x86', 'x86_64']
 238   xen_targets = ['i386-softmmu', 'x86_64-softmmu']
 239 elif cpu in ['arm', 'aarch64']
 240   # i386 emulator provides xenpv machine type for multiple architectures
 241   xen_targets = ['i386-softmmu', 'x86_64-softmmu', 'aarch64-softmmu']
 242 else
 243   xen_targets = []
 244 endif
 245 accelerator_targets += { 'CONFIG_XEN': xen_targets }
 246
 247 if cpu in ['aarch64']
 248   accelerator_targets += {
 249     'CONFIG_HVF': ['aarch64-softmmu']
 250   }
 251 endif
 252
 253 if cpu in ['x86', 'x86_64']
 254   accelerator_targets += {
 255     'CONFIG_HVF': ['x86_64-softmmu'],
 256     'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
 257     'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
 258   }
 259 endif
 260
 261 modular_tcg = []
 262 # Darwin does not support references to thread-local variables in modules
 263 if host_os != 'darwin'
 264   modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
 265 endif
 266
 267 ##################
 268 # Compiler flags #
 269 ##################
 270
 271 foreach lang : all_languages
 272   compiler = meson.get_compiler(lang)
 273   if compiler.get_id() == 'gcc' and compiler.version().version_compare('>=7.4')
 274     # ok
 275   elif compiler.get_id() == 'clang' and compiler.compiles('''
 276       #ifdef __apple_build_version__
 277       # if __clang_major__ < 12 || (__clang_major__ == 12 && __clang_minor__ < 0)
 278       #  error You need at least XCode Clang v12.0 to compile QEMU
 279       # endif
 280       #else
 281       # if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)
 282       #  error You need at least Clang v10.0 to compile QEMU
 283       # endif
 284       #endif''')
 285     # ok
 286   else
 287     error('You either need GCC v7.4 or Clang v10.0 (or XCode Clang v12.0) to compile QEMU')
 288   endif
 289 endforeach
 290
 291 # default flags for all hosts
 292 # We use -fwrapv to tell the compiler that we require a C dialect where
 293 # left shift of signed integers is well defined and has the expected
 294 # 2s-complement style results. (Both clang and gcc agree that it
 295 # provides these semantics.)
 296
 297 qemu_common_flags = [
 298   '-D_GNU_SOURCE', '-D_FILE_OFFSET_BITS=64', '-D_LARGEFILE_SOURCE',
 299   '-fno-strict-aliasing', '-fno-common', '-fwrapv' ]
 300 qemu_cflags = []
 301 qemu_ldflags = []
 302
 303 if host_os == 'darwin'
 304   # Disable attempts to use ObjectiveC features in os/object.h since they
 305   # won't work when we're compiling with gcc as a C compiler.
 306   if compiler.get_id() == 'gcc'
 307     qemu_common_flags += '-DOS_OBJECT_USE_OBJC=0'
 308   endif
 309 elif host_os == 'sunos'
 310   # needed for CMSG_ macros in sys/socket.h
 311   qemu_common_flags += '-D_XOPEN_SOURCE=600'
 312   # needed for TIOCWIN* defines in termios.h
 313   qemu_common_flags += '-D__EXTENSIONS__'
 314 elif host_os == 'haiku'
 315   qemu_common_flags += ['-DB_USE_POSITIVE_POSIX_ERRORS', '-D_BSD_SOURCE', '-fPIC']
 316 endif
 317
 318 # __sync_fetch_and_and requires at least -march=i486. Many toolchains
 319 # use i686 as default anyway, but for those that don't, an explicit
 320 # specification is necessary
 321 if host_arch == 'i386' and not cc.links('''
 322   static int sfaa(int *ptr)
 323   {
 324     return __sync_fetch_and_and(ptr, 0);
 325   }
 326
 327   int main(void)
 328   {
 329     int val = 42;
 330     val = __sync_val_compare_and_swap(&val, 0, 1);
 331     sfaa(&val);
 332     return val;
 333   }''')
 334   qemu_common_flags = ['-march=i486'] + qemu_common_flags
 335 endif
 336
 337 if get_option('prefer_static')
 338   qemu_ldflags += get_option('b_pie') ? '-static-pie' : '-static'
 339 endif
 340
 341 # Meson currently only handles pie as a boolean for now, so if the user
 342 # has explicitly disabled PIE we need to extend our cflags.
 343 #
 344 # -no-pie is supposedly a linker flag that has no effect on the compiler
 345 # command line, but some distros, that didn't quite know what they were
 346 # doing, made local changes to gcc's specs file that turned it into
 347 # a compiler command-line flag.
 348 #
 349 # What about linker flags?  For a static build, no PIE is implied by -static
 350 # which we added above (and if it's not because of the same specs patching,
 351 # there's nothing we can do: compilation will fail, report a bug to your
 352 # distro and do not use --disable-pie in the meanwhile).  For dynamic linking,
 353 # instead, we can't add -no-pie because it overrides -shared: the linker then
 354 # tries to build an executable instead of a shared library and fails.  So
 355 # don't add -no-pie anywhere and cross fingers. :(
 356 if not get_option('b_pie')
 357   qemu_common_flags += cc.get_supported_arguments('-fno-pie', '-no-pie')
 358 endif
 359
 360 if not get_option('stack_protector').disabled()
 361   stack_protector_probe = '''
 362     int main(int argc, char *argv[])
 363     {
 364       char arr[64], *p = arr, *c = argv[argc - 1];
 365       while (*c) {
 366           *p++ = *c++;
 367       }
 368       return 0;
 369     }'''
 370   have_stack_protector = false
 371   foreach arg : ['-fstack-protector-strong', '-fstack-protector-all']
 372     # We need to check both a compile and a link, since some compiler
 373     # setups fail only on a .c->.o compile and some only at link time
 374     if cc.compiles(stack_protector_probe, args: ['-Werror', arg]) and \
 375        cc.links(stack_protector_probe, args: ['-Werror', arg])
 376       have_stack_protector = true
 377       qemu_cflags += arg
 378       qemu_ldflags += arg
 379       break
 380     endif
 381   endforeach
 382   get_option('stack_protector') \
 383     .require(have_stack_protector, error_message: 'Stack protector not supported')
 384 endif
 385
 386 coroutine_backend = get_option('coroutine_backend')
 387 ucontext_probe = '''
 388   #include <ucontext.h>
 389   #ifdef __stub_makecontext
 390   #error Ignoring glibc stub makecontext which will always fail
 391   #endif
 392   int main(void) { makecontext(0, 0, 0); return 0; }'''
 393
 394 # On Windows the only valid backend is the Windows specific one.
 395 # For POSIX prefer ucontext, but it's not always possible. The fallback
 396 # is sigcontext.
 397 supported_backends = []
 398 if host_os == 'windows'
 399   supported_backends += ['windows']
 400 else
 401   if host_os != 'darwin' and cc.links(ucontext_probe)
 402     supported_backends += ['ucontext']
 403   endif
 404   supported_backends += ['sigaltstack']
 405 endif
 406
 407 if coroutine_backend == 'auto'
 408   coroutine_backend = supported_backends[0]
 409 elif coroutine_backend not in supported_backends
 410   error('"@0@" backend requested but not available.  Available backends: @1@' \
 411         .format(coroutine_backend, ', '.join(supported_backends)))
 412 endif
 413
 414 # Compiles if SafeStack *not* enabled
 415 safe_stack_probe = '''
 416   int main(void)
 417   {
 418   #if defined(__has_feature)
 419   #if __has_feature(safe_stack)
 420   #error SafeStack Enabled
 421   #endif
 422   #endif
 423       return 0;
 424   }'''
 425 if get_option('safe_stack') != not cc.compiles(safe_stack_probe)
 426   safe_stack_arg = get_option('safe_stack') ? '-fsanitize=safe-stack' : '-fno-sanitize=safe-stack'
 427   if get_option('safe_stack') != not cc.compiles(safe_stack_probe, args: safe_stack_arg)
 428     error(get_option('safe_stack') \
 429           ? 'SafeStack not supported by your compiler' \
 430           : 'Cannot disable SafeStack')
 431   endif
 432   qemu_cflags += safe_stack_arg
 433   qemu_ldflags += safe_stack_arg
 434 endif
 435 if get_option('safe_stack') and coroutine_backend != 'ucontext'
 436   error('SafeStack is only supported with the ucontext coroutine backend')
 437 endif
 438
 439 if get_option('sanitizers')
 440   if cc.has_argument('-fsanitize=address')
 441     qemu_cflags = ['-fsanitize=address'] + qemu_cflags
 442     qemu_ldflags = ['-fsanitize=address'] + qemu_ldflags
 443   endif
 444
 445   # Detect static linking issue with ubsan - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84285
 446   if cc.links('int main(int argc, char **argv) { return argc + 1; }',
 447               args: [qemu_ldflags, '-fsanitize=undefined'])
 448     qemu_cflags = ['-fsanitize=undefined'] + qemu_cflags
 449     qemu_ldflags = ['-fsanitize=undefined'] + qemu_ldflags
 450   endif
 451 endif
 452
 453 # Thread sanitizer is, for now, much noisier than the other sanitizers;
 454 # keep it separate until that is not the case.
 455 if get_option('tsan')
 456   if get_option('sanitizers')
 457     error('TSAN is not supported with other sanitizers')
 458   endif
 459   if not cc.has_function('__tsan_create_fiber',
 460                          args: '-fsanitize=thread',
 461                          prefix: '#include <sanitizer/tsan_interface.h>')
 462     error('Cannot enable TSAN due to missing fiber annotation interface')
 463   endif
 464   qemu_cflags = ['-fsanitize=thread'] + qemu_cflags
 465   qemu_ldflags = ['-fsanitize=thread'] + qemu_ldflags
 466 endif
 467
 468 # Detect support for PT_GNU_RELRO + DT_BIND_NOW.
 469 # The combination is known as "full relro", because .got.plt is read-only too.
 470 qemu_ldflags += cc.get_supported_link_arguments('-Wl,-z,relro', '-Wl,-z,now')
 471
 472 if host_os == 'windows'
 473   qemu_ldflags += cc.get_supported_link_arguments('-Wl,--no-seh', '-Wl,--nxcompat')
 474   qemu_ldflags += cc.get_supported_link_arguments('-Wl,--dynamicbase', '-Wl,--high-entropy-va')
 475 endif
 476
 477 # Exclude --warn-common with TSan to suppress warnings from the TSan libraries.
 478 if host_os != 'sunos' and not get_option('tsan')
 479   qemu_ldflags += cc.get_supported_link_arguments('-Wl,--warn-common')
 480 endif
 481
 482 if get_option('fuzzing')
 483   # Specify a filter to only instrument code that is directly related to
 484   # virtual-devices.
 485   configure_file(output: 'instrumentation-filter',
 486                  input: 'scripts/oss-fuzz/instrumentation-filter-template',
 487                  copy: true)
 488
 489   if cc.compiles('int main () { return 0; }',
 490                   name: '-fsanitize-coverage-allowlist=/dev/null',
 491                  args: ['-fsanitize-coverage-allowlist=/dev/null',
 492                         '-fsanitize-coverage=trace-pc'] )
 493     qemu_common_flags += ['-fsanitize-coverage-allowlist=instrumentation-filter']
 494   endif
 495
 496   if get_option('fuzzing_engine') == ''
 497     # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
 498     # compiled code.  To build non-fuzzer binaries with --enable-fuzzing, link
 499     # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
 500     # unable to bind the fuzzer-related callbacks added by instrumentation.
 501     qemu_common_flags += ['-fsanitize=fuzzer-no-link']
 502     qemu_ldflags += ['-fsanitize=fuzzer-no-link']
 503     # For the actual fuzzer binaries, we need to link against the libfuzzer
 504     # library. They need to be configurable, to support OSS-Fuzz
 505     fuzz_exe_ldflags = ['-fsanitize=fuzzer']
 506   else
 507     # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
 508     # the needed CFLAGS have already been provided
 509     fuzz_exe_ldflags = get_option('fuzzing_engine').split()
 510   endif
 511 endif
 512
 513 if get_option('cfi')
 514   cfi_flags=[]
 515   # Check for dependency on LTO
 516   if not get_option('b_lto')
 517     error('Selected Control-Flow Integrity but LTO is disabled')
 518   endif
 519   if enable_modules
 520     error('Selected Control-Flow Integrity is not compatible with modules')
 521   endif
 522   # Check for cfi flags. CFI requires LTO so we can't use
 523   # get_supported_arguments, but need a more complex "compiles" which allows
 524   # custom arguments
 525   if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
 526                  args: ['-flto', '-fsanitize=cfi-icall'] )
 527     cfi_flags += '-fsanitize=cfi-icall'
 528   else
 529     error('-fsanitize=cfi-icall is not supported by the compiler')
 530   endif
 531   if cc.compiles('int main () { return 0; }',
 532                  name: '-fsanitize-cfi-icall-generalize-pointers',
 533                  args: ['-flto', '-fsanitize=cfi-icall',
 534                         '-fsanitize-cfi-icall-generalize-pointers'] )
 535     cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
 536   else
 537     error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
 538   endif
 539   if get_option('cfi_debug')
 540     if cc.compiles('int main () { return 0; }',
 541                    name: '-fno-sanitize-trap=cfi-icall',
 542                    args: ['-flto', '-fsanitize=cfi-icall',
 543                           '-fno-sanitize-trap=cfi-icall'] )
 544       cfi_flags += '-fno-sanitize-trap=cfi-icall'
 545     else
 546       error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
 547     endif
 548   endif
 549   add_global_arguments(cfi_flags, native: false, language: all_languages)
 550   add_global_link_arguments(cfi_flags, native: false, language: all_languages)
 551 endif
 552
 553 add_global_arguments(qemu_common_flags, native: false, language: all_languages)
 554 add_global_link_arguments(qemu_ldflags, native: false, language: all_languages)
 555
 556 # Collect warnings that we want to enable
 557
 558 warn_flags = [
 559   '-Wundef',
 560   '-Wwrite-strings',
 561   '-Wmissing-prototypes',
 562   '-Wstrict-prototypes',
 563   '-Wredundant-decls',
 564   '-Wold-style-declaration',
 565   '-Wold-style-definition',
 566   '-Wtype-limits',
 567   '-Wformat-security',
 568   '-Wformat-y2k',
 569   '-Winit-self',
 570   '-Wignored-qualifiers',
 571   '-Wempty-body',
 572   '-Wnested-externs',
 573   '-Wendif-labels',
 574   '-Wexpansion-to-defined',
 575   '-Wimplicit-fallthrough=2',
 576   '-Wmissing-format-attribute',
 577   '-Wno-initializer-overrides',
 578   '-Wno-missing-include-dirs',
 579   '-Wno-shift-negative-value',
 580   '-Wno-string-plus-int',
 581   '-Wno-typedef-redefinition',
 582   '-Wno-tautological-type-limit-compare',
 583   '-Wno-psabi',
 584   '-Wno-gnu-variable-sized-type-not-at-end',
 585   '-Wshadow=local',
 586 ]
 587
 588 if host_os != 'darwin'
 589   warn_flags += ['-Wthread-safety']
 590 endif
 591
 592 # Set up C++ compiler flags
 593 qemu_cxxflags = []
 594 if 'cpp' in all_languages
 595   qemu_cxxflags = ['-D__STDC_LIMIT_MACROS', '-D__STDC_CONSTANT_MACROS', '-D__STDC_FORMAT_MACROS'] + qemu_cflags
 596 endif
 597
 598 add_project_arguments(qemu_cflags, native: false, language: 'c')
 599 add_project_arguments(cc.get_supported_arguments(warn_flags), native: false, language: 'c')
 600 if 'cpp' in all_languages
 601   add_project_arguments(qemu_cxxflags, native: false, language: 'cpp')
 602   add_project_arguments(cxx.get_supported_arguments(warn_flags), native: false, language: 'cpp')
 603 endif
 604 if 'objc' in all_languages
 605   # Note sanitizer flags are not applied to Objective-C sources!
 606   add_project_arguments(objc.get_supported_arguments(warn_flags), native: false, language: 'objc')
 607 endif
 608 if host_os == 'linux'
 609   add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
 610                         '-isystem', 'linux-headers',
 611                         language: all_languages)
 612 endif
 613
 614 add_project_arguments('-iquote', '.',
 615                       '-iquote', meson.current_source_dir(),
 616                       '-iquote', meson.current_source_dir() / 'include',
 617                       language: all_languages)
 618
 619 # If a host-specific include directory exists, list that first...
 620 host_include = meson.current_source_dir() / 'host/include/'
 621 if fs.is_dir(host_include / host_arch)
 622   add_project_arguments('-iquote', host_include / host_arch,
 623                         language: all_languages)
 624 endif
 625 # ... followed by the generic fallback.
 626 add_project_arguments('-iquote', host_include / 'generic',
 627                       language: all_languages)
 628
 629 sparse = find_program('cgcc', required: get_option('sparse'))
 630 if sparse.found()
 631   run_target('sparse',
 632              command: [find_program('scripts/check_sparse.py'),
 633                        'compile_commands.json', sparse.full_path(), '-Wbitwise',
 634                        '-Wno-transparent-union', '-Wno-old-initializer',
 635                        '-Wno-non-pointer-null'])
 636 endif
 637
 638 #####################################
 639 # Host-specific libraries and flags #
 640 #####################################
 641
 642 libm = cc.find_library('m', required: false)
 643 threads = dependency('threads')
 644 util = cc.find_library('util', required: false)
 645 winmm = []
 646 socket = []
 647 version_res = []
 648 coref = []
 649 iokit = []
 650 emulator_link_args = []
 651 midl = not_found
 652 widl = not_found
 653 pathcch = not_found
 654 host_dsosuf = '.so'
 655 if host_os == 'windows'
 656   midl = find_program('midl', required: false)
 657   widl = find_program('widl', required: false)
 658   pathcch = cc.find_library('pathcch')
 659   socket = cc.find_library('ws2_32')
 660   winmm = cc.find_library('winmm')
 661
 662   win = import('windows')
 663   version_res = win.compile_resources('version.rc',
 664                                       depend_files: files('pc-bios/qemu-nsis.ico'),
 665                                       include_directories: include_directories('.'))
 666   host_dsosuf = '.dll'
 667 elif host_os == 'darwin'
 668   coref = dependency('appleframeworks', modules: 'CoreFoundation')
 669   iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
 670   host_dsosuf = '.dylib'
 671 elif host_os == 'sunos'
 672   socket = [cc.find_library('socket'),
 673             cc.find_library('nsl'),
 674             cc.find_library('resolv')]
 675 elif host_os == 'haiku'
 676   socket = [cc.find_library('posix_error_mapper'),
 677             cc.find_library('network'),
 678             cc.find_library('bsd')]
 679 elif host_os == 'openbsd'
 680   if get_option('tcg').allowed() and target_dirs.length() > 0
 681     # Disable OpenBSD W^X if available
 682     emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
 683   endif
 684 endif
 685
 686 ###############################################
 687 # Host-specific configuration of accelerators #
 688 ###############################################
 689
 690 accelerators = []
 691 if get_option('kvm').allowed() and host_os == 'linux'
 692   accelerators += 'CONFIG_KVM'
 693 endif
 694 if get_option('whpx').allowed() and host_os == 'windows'
 695   if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
 696     error('WHPX requires 64-bit host')
 697   elif cc.has_header('winhvplatform.h', required: get_option('whpx')) and \
 698        cc.has_header('winhvemulation.h', required: get_option('whpx'))
 699     accelerators += 'CONFIG_WHPX'
 700   endif
 701 endif
 702
 703 hvf = not_found
 704 if get_option('hvf').allowed()
 705   hvf = dependency('appleframeworks', modules: 'Hypervisor',
 706                    required: get_option('hvf'))
 707   if hvf.found()
 708     accelerators += 'CONFIG_HVF'
 709   endif
 710 endif
 711
 712 nvmm = not_found
 713 if host_os == 'netbsd'
 714   nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
 715   if nvmm.found()
 716     accelerators += 'CONFIG_NVMM'
 717   endif
 718 endif
 719
 720 tcg_arch = host_arch
 721 if get_option('tcg').allowed()
 722   if host_arch == 'unknown'
 723     if not get_option('tcg_interpreter')
 724       error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
 725     endif
 726   elif get_option('tcg_interpreter')
 727     warning('Use of the TCG interpreter is not recommended on this host')
 728     warning('architecture. There is a native TCG execution backend available')
 729     warning('which provides substantially better performance and reliability.')
 730     warning('It is strongly recommended to remove the --enable-tcg-interpreter')
 731     warning('configuration option on this architecture to use the native')
 732     warning('backend.')
 733   endif
 734   if get_option('tcg_interpreter')
 735     tcg_arch = 'tci'
 736   elif host_arch == 'x86_64'
 737     tcg_arch = 'i386'
 738   elif host_arch == 'ppc64'
 739     tcg_arch = 'ppc'
 740   endif
 741   add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
 742                         language: all_languages)
 743
 744   accelerators += 'CONFIG_TCG'
 745 endif
 746
 747 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
 748   error('KVM not available on this platform')
 749 endif
 750 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
 751   error('HVF not available on this platform')
 752 endif
 753 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
 754   error('NVMM not available on this platform')
 755 endif
 756 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
 757   error('WHPX not available on this platform')
 758 endif
 759
 760 xen = not_found
 761 if get_option('xen').enabled() or (get_option('xen').auto() and have_system)
 762   xencontrol = dependency('xencontrol', required: false,
 763                           method: 'pkg-config')
 764   if xencontrol.found()
 765     xen_pc = declare_dependency(version: xencontrol.version(),
 766       dependencies: [
 767         xencontrol,
 768         # disabler: true makes xen_pc.found() return false if any is not found
 769         dependency('xenstore', required: false,
 770                    method: 'pkg-config',
 771                    disabler: true),
 772         dependency('xenforeignmemory', required: false,
 773                    method: 'pkg-config',
 774                    disabler: true),
 775         dependency('xengnttab', required: false,
 776                    method: 'pkg-config',
 777                    disabler: true),
 778         dependency('xenevtchn', required: false,
 779                    method: 'pkg-config',
 780                    disabler: true),
 781         dependency('xendevicemodel', required: false,
 782                    method: 'pkg-config',
 783                    disabler: true),
 784         # optional, no "disabler: true"
 785         dependency('xentoolcore', required: false,
 786                    method: 'pkg-config')])
 787     if xen_pc.found()
 788       xen = xen_pc
 789     endif
 790   endif
 791   if not xen.found()
 792     xen_tests = [ '4.11.0', '4.10.0', '4.9.0', '4.8.0', '4.7.1' ]
 793     xen_libs = {
 794       '4.11.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
 795       '4.10.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
 796       '4.9.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
 797       '4.8.0': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
 798       '4.7.1': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
 799     }
 800     xen_deps = {}
 801     foreach ver: xen_tests
 802       # cache the various library tests to avoid polluting the logs
 803       xen_test_deps = []
 804       foreach l: xen_libs[ver]
 805         if l not in xen_deps
 806           xen_deps += { l: cc.find_library(l, required: false) }
 807         endif
 808         xen_test_deps += xen_deps[l]
 809       endforeach
 810
 811       # Use -D to pick just one of the test programs in scripts/xen-detect.c
 812       xen_version = ver.split('.')
 813       xen_ctrl_version = xen_version[0] + \
 814         ('0' + xen_version[1]).substring(-2) + \
 815         ('0' + xen_version[2]).substring(-2)
 816       if cc.links(files('scripts/xen-detect.c'),
 817                   args: '-DCONFIG_XEN_CTRL_INTERFACE_VERSION=' + xen_ctrl_version,
 818                   dependencies: xen_test_deps)
 819         xen = declare_dependency(version: ver, dependencies: xen_test_deps)
 820         break
 821       endif
 822     endforeach
 823   endif
 824   if xen.found()
 825     accelerators += 'CONFIG_XEN'
 826   elif get_option('xen').enabled()
 827     error('could not compile and link Xen test program')
 828   endif
 829 endif
 830 have_xen_pci_passthrough = get_option('xen_pci_passthrough') \
 831   .require(xen.found(),
 832            error_message: 'Xen PCI passthrough requested but Xen not enabled') \
 833   .require(host_os == 'linux',
 834            error_message: 'Xen PCI passthrough not available on this platform') \
 835   .require(cpu == 'x86'  or cpu == 'x86_64',
 836            error_message: 'Xen PCI passthrough not available on this platform') \
 837   .allowed()
 838
 839 ################
 840 # Dependencies #
 841 ################
 842
 843 # When bumping glib minimum version, please check also whether to increase
 844 # the _WIN32_WINNT setting in osdep.h according to the value from glib
 845 glib_req_ver = '>=2.56.0'
 846 glib_pc = dependency('glib-2.0', version: glib_req_ver, required: true,
 847                     method: 'pkg-config')
 848 glib_cflags = []
 849 if enable_modules
 850   gmodule = dependency('gmodule-export-2.0', version: glib_req_ver, required: true,
 851                        method: 'pkg-config')
 852 elif get_option('plugins')
 853   gmodule = dependency('gmodule-no-export-2.0', version: glib_req_ver, required: true,
 854                        method: 'pkg-config')
 855 else
 856   gmodule = not_found
 857 endif
 858
 859 # This workaround is required due to a bug in pkg-config file for glib as it
 860 # doesn't define GLIB_STATIC_COMPILATION for pkg-config --static
 861 if host_os == 'windows' and get_option('prefer_static')
 862   glib_cflags += ['-DGLIB_STATIC_COMPILATION']
 863 endif
 864
 865 # Sanity check that the current size_t matches the
 866 # size that glib thinks it should be. This catches
 867 # problems on multi-arch where people try to build
 868 # 32-bit QEMU while pointing at 64-bit glib headers
 869
 870 if not cc.compiles('''
 871   #include <glib.h>
 872   #include <unistd.h>
 873
 874   #define QEMU_BUILD_BUG_ON(x) \
 875   typedef char qemu_build_bug_on[(x)?-1:1] __attribute__((unused));
 876
 877   int main(void) {
 878      QEMU_BUILD_BUG_ON(sizeof(size_t) != GLIB_SIZEOF_SIZE_T);
 879      return 0;
 880   }''', dependencies: glib_pc, args: glib_cflags)
 881   error('''sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T.
 882         You probably need to set PKG_CONFIG_LIBDIR" to point
 883         to the right pkg-config files for your build target.''')
 884 endif
 885
 886 # Silence clang warnings triggered by glib < 2.57.2
 887 if not cc.compiles('''
 888   #include <glib.h>
 889   typedef struct Foo {
 890     int i;
 891   } Foo;
 892   static void foo_free(Foo *f)
 893   {
 894     g_free(f);
 895   }
 896   G_DEFINE_AUTOPTR_CLEANUP_FUNC(Foo, foo_free)
 897   int main(void) { return 0; }''', dependencies: glib_pc, args: ['-Wunused-function', '-Werror'])
 898   glib_cflags += cc.get_supported_arguments('-Wno-unused-function')
 899 endif
 900 glib = declare_dependency(dependencies: [glib_pc, gmodule],
 901                           compile_args: glib_cflags,
 902                           version: glib_pc.version())
 903
 904 # Check whether glib has gslice, which we have to avoid for correctness.
 905 # TODO: remove this check and the corresponding workaround (qtree) when
 906 # the minimum supported glib is >= 2.75.3
 907 glib_has_gslice = glib.version().version_compare('<2.75.3')
 908
 909 # override glib dep to include the above refinements
 910 meson.override_dependency('glib-2.0', glib)
 911
 912 # The path to glib.h is added to all compilation commands.
 913 add_project_dependencies(glib.partial_dependency(compile_args: true, includes: true),
 914                          native: false, language: all_languages)
 915
 916 gio = not_found
 917 gdbus_codegen = not_found
 918 gdbus_codegen_error = '@0@ requires gdbus-codegen, please install libgio'
 919 if not get_option('gio').auto() or have_system
 920   gio = dependency('gio-2.0', required: get_option('gio'),
 921                    method: 'pkg-config')
 922   if gio.found() and not cc.links('''
 923     #include <gio/gio.h>
 924     int main(void)
 925     {
 926       g_dbus_proxy_new_sync(0, 0, 0, 0, 0, 0, 0, 0);
 927       return 0;
 928     }''', dependencies: [glib, gio])
 929     if get_option('gio').enabled()
 930       error('The installed libgio is broken for static linking')
 931     endif
 932     gio = not_found
 933   endif
 934   if gio.found()
 935     gdbus_codegen = find_program(gio.get_variable('gdbus_codegen'),
 936                                  required: get_option('gio'))
 937     gio_unix = dependency('gio-unix-2.0', required: get_option('gio'),
 938                           method: 'pkg-config')
 939     gio = declare_dependency(dependencies: [gio, gio_unix],
 940                              version: gio.version())
 941   endif
 942 endif
 943 if gdbus_codegen.found() and get_option('cfi')
 944   gdbus_codegen = not_found
 945   gdbus_codegen_error = '@0@ uses gdbus-codegen, which does not support control flow integrity'
 946 endif
 947
 948 xml_pp = find_program('scripts/xml-preprocess.py')
 949
 950 lttng = not_found
 951 if 'ust' in get_option('trace_backends')
 952   lttng = dependency('lttng-ust', required: true, version: '>= 2.1',
 953                      method: 'pkg-config')
 954 endif
 955 pixman = not_found
 956 if not get_option('pixman').auto() or have_system or have_tools
 957   pixman = dependency('pixman-1', required: get_option('pixman'), version:'>=0.21.8',
 958                       method: 'pkg-config')
 959 endif
 960
 961 zlib = dependency('zlib', required: true)
 962
 963 libaio = not_found
 964 if not get_option('linux_aio').auto() or have_block
 965   libaio = cc.find_library('aio', has_headers: ['libaio.h'],
 966                            required: get_option('linux_aio'))
 967 endif
 968
 969 linux_io_uring_test = '''
 970   #include <liburing.h>
 971   #include <linux/errqueue.h>
 972
 973   int main(void) { return 0; }'''
 974
 975 linux_io_uring = not_found
 976 if not get_option('linux_io_uring').auto() or have_block
 977   linux_io_uring = dependency('liburing', version: '>=0.3',
 978                               required: get_option('linux_io_uring'),
 979                               method: 'pkg-config')
 980   if not cc.links(linux_io_uring_test)
 981     linux_io_uring = not_found
 982   endif
 983 endif
 984
 985 libnfs = not_found
 986 if not get_option('libnfs').auto() or have_block
 987   libnfs = dependency('libnfs', version: '>=1.9.3',
 988                       required: get_option('libnfs'),
 989                       method: 'pkg-config')
 990 endif
 991
 992 libattr_test = '''
 993   #include <stddef.h>
 994   #include <sys/types.h>
 995   #ifdef CONFIG_LIBATTR
 996   #include <attr/xattr.h>
 997   #else
 998   #include <sys/xattr.h>
 999   #endif
1000   int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
1001
1002 libattr = not_found
1003 have_old_libattr = false
1004 if get_option('attr').allowed()
1005   if cc.links(libattr_test)
1006     libattr = declare_dependency()
1007   else
1008     libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
1009                               required: get_option('attr'))
1010     if libattr.found() and not \
1011       cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
1012       libattr = not_found
1013       if get_option('attr').enabled()
1014         error('could not link libattr')
1015       else
1016         warning('could not link libattr, disabling')
1017       endif
1018     else
1019       have_old_libattr = libattr.found()
1020     endif
1021   endif
1022 endif
1023
1024 cocoa = dependency('appleframeworks', modules: ['Cocoa', 'CoreVideo'],
1025                    required: get_option('cocoa'))
1026
1027 vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet'))
1028 if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h',
1029                                               'VMNET_BRIDGED_MODE',
1030                                               dependencies: vmnet)
1031   vmnet = not_found
1032   if get_option('vmnet').enabled()
1033     error('vmnet.framework API is outdated')
1034   else
1035     warning('vmnet.framework API is outdated, disabling')
1036   endif
1037 endif
1038
1039 seccomp = not_found
1040 seccomp_has_sysrawrc = false
1041 if not get_option('seccomp').auto() or have_system or have_tools
1042   seccomp = dependency('libseccomp', version: '>=2.3.0',
1043                        required: get_option('seccomp'),
1044                        method: 'pkg-config')
1045   if seccomp.found()
1046     seccomp_has_sysrawrc = cc.has_header_symbol('seccomp.h',
1047                                                 'SCMP_FLTATR_API_SYSRAWRC',
1048                                                 dependencies: seccomp)
1049   endif
1050 endif
1051
1052 libcap_ng = not_found
1053 if not get_option('cap_ng').auto() or have_system or have_tools
1054   libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
1055                               required: get_option('cap_ng'))
1056 endif
1057 if libcap_ng.found() and not cc.links('''
1058    #include <cap-ng.h>
1059    int main(void)
1060    {
1061      capng_capability_to_name(CAPNG_EFFECTIVE);
1062      return 0;
1063    }''', dependencies: libcap_ng)
1064   libcap_ng = not_found
1065   if get_option('cap_ng').enabled()
1066     error('could not link libcap-ng')
1067   else
1068     warning('could not link libcap-ng, disabling')
1069   endif
1070 endif
1071
1072 if get_option('xkbcommon').auto() and not have_system and not have_tools
1073   xkbcommon = not_found
1074 else
1075   xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
1076                          method: 'pkg-config')
1077 endif
1078
1079 slirp = not_found
1080 if not get_option('slirp').auto() or have_system
1081   slirp = dependency('slirp', required: get_option('slirp'),
1082                      method: 'pkg-config')
1083   # slirp < 4.7 is incompatible with CFI support in QEMU.  This is because
1084   # it passes function pointers within libslirp as callbacks for timers.
1085   # When using a system-wide shared libslirp, the type information for the
1086   # callback is missing and the timer call produces a false positive with CFI.
1087   # Do not use the "version" keyword argument to produce a better error.
1088   # with control-flow integrity.
1089   if get_option('cfi') and slirp.found() and slirp.version().version_compare('<4.7')
1090     if get_option('slirp').enabled()
1091       error('Control-Flow Integrity requires libslirp 4.7.')
1092     else
1093       warning('Cannot use libslirp since Control-Flow Integrity requires libslirp >= 4.7.')
1094       slirp = not_found
1095     endif
1096   endif
1097 endif
1098
1099 vde = not_found
1100 if not get_option('vde').auto() or have_system or have_tools
1101   vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
1102                            required: get_option('vde'))
1103 endif
1104 if vde.found() and not cc.links('''
1105    #include <libvdeplug.h>
1106    int main(void)
1107    {
1108      struct vde_open_args a = {0, 0, 0};
1109      char s[] = "";
1110      vde_open(s, s, &a);
1111      return 0;
1112    }''', dependencies: vde)
1113   vde = not_found
1114   if get_option('cap_ng').enabled()
1115     error('could not link libvdeplug')
1116   else
1117     warning('could not link libvdeplug, disabling')
1118   endif
1119 endif
1120
1121 pulse = not_found
1122 if not get_option('pa').auto() or (host_os == 'linux' and have_system)
1123   pulse = dependency('libpulse', required: get_option('pa'),
1124                      method: 'pkg-config')
1125 endif
1126 alsa = not_found
1127 if not get_option('alsa').auto() or (host_os == 'linux' and have_system)
1128   alsa = dependency('alsa', required: get_option('alsa'),
1129                     method: 'pkg-config')
1130 endif
1131 jack = not_found
1132 if not get_option('jack').auto() or have_system
1133   jack = dependency('jack', required: get_option('jack'),
1134                     method: 'pkg-config')
1135 endif
1136 pipewire = not_found
1137 if not get_option('pipewire').auto() or (host_os == 'linux' and have_system)
1138   pipewire = dependency('libpipewire-0.3', version: '>=0.3.60',
1139                     required: get_option('pipewire'),
1140                     method: 'pkg-config')
1141 endif
1142 sndio = not_found
1143 if not get_option('sndio').auto() or have_system
1144   sndio = dependency('sndio', required: get_option('sndio'),
1145                     method: 'pkg-config')
1146 endif
1147
1148 spice_protocol = not_found
1149 if not get_option('spice_protocol').auto() or have_system
1150   spice_protocol = dependency('spice-protocol', version: '>=0.14.0',
1151                               required: get_option('spice_protocol'),
1152                               method: 'pkg-config')
1153 endif
1154 spice = not_found
1155 if get_option('spice') \
1156              .disable_auto_if(not have_system) \
1157              .require(pixman.found(),
1158                       error_message: 'cannot enable SPICE if pixman is not available') \
1159              .allowed()
1160   spice = dependency('spice-server', version: '>=0.14.0',
1161                      required: get_option('spice'),
1162                      method: 'pkg-config')
1163 endif
1164 spice_headers = spice.partial_dependency(compile_args: true, includes: true)
1165
1166 rt = cc.find_library('rt', required: false)
1167
1168 libiscsi = not_found
1169 if not get_option('libiscsi').auto() or have_block
1170   libiscsi = dependency('libiscsi', version: '>=1.9.0',
1171                          required: get_option('libiscsi'),
1172                          method: 'pkg-config')
1173 endif
1174 zstd = not_found
1175 if not get_option('zstd').auto() or have_block
1176   zstd = dependency('libzstd', version: '>=1.4.0',
1177                     required: get_option('zstd'),
1178                     method: 'pkg-config')
1179 endif
1180 virgl = not_found
1181
1182 have_vhost_user_gpu = have_tools and host_os == 'linux' and pixman.found()
1183 if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu
1184   virgl = dependency('virglrenderer',
1185                      method: 'pkg-config',
1186                      required: get_option('virglrenderer'))
1187 endif
1188 rutabaga = not_found
1189 if not get_option('rutabaga_gfx').auto() or have_system or have_vhost_user_gpu
1190   rutabaga = dependency('rutabaga_gfx_ffi',
1191                          method: 'pkg-config',
1192                          required: get_option('rutabaga_gfx'))
1193 endif
1194 blkio = not_found
1195 if not get_option('blkio').auto() or have_block
1196   blkio = dependency('blkio',
1197                      method: 'pkg-config',
1198                      required: get_option('blkio'))
1199 endif
1200 curl = not_found
1201 if not get_option('curl').auto() or have_block
1202   curl = dependency('libcurl', version: '>=7.29.0',
1203                     method: 'pkg-config',
1204                     required: get_option('curl'))
1205 endif
1206 libudev = not_found
1207 if host_os == 'linux' and (have_system or have_tools)
1208   libudev = dependency('libudev',
1209                        method: 'pkg-config',
1210                        required: get_option('libudev'))
1211 endif
1212
1213 mpathlibs = [libudev]
1214 mpathpersist = not_found
1215 if host_os == 'linux' and have_tools and get_option('mpath').allowed()
1216   mpath_test_source = '''
1217     #include <libudev.h>
1218     #include <mpath_persist.h>
1219     unsigned mpath_mx_alloc_len = 1024;
1220     int logsink;
1221     static struct config *multipath_conf;
1222     extern struct udev *udev;
1223     extern struct config *get_multipath_config(void);
1224     extern void put_multipath_config(struct config *conf);
1225     struct udev *udev;
1226     struct config *get_multipath_config(void) { return multipath_conf; }
1227     void put_multipath_config(struct config *conf) { }
1228     int main(void) {
1229         udev = udev_new();
1230         multipath_conf = mpath_lib_init();
1231         return 0;
1232     }'''
1233   libmpathpersist = cc.find_library('mpathpersist',
1234                                     required: get_option('mpath'))
1235   if libmpathpersist.found()
1236     mpathlibs += libmpathpersist
1237     if get_option('prefer_static')
1238       mpathlibs += cc.find_library('devmapper',
1239                                      required: get_option('mpath'))
1240     endif
1241     mpathlibs += cc.find_library('multipath',
1242                                  required: get_option('mpath'))
1243     foreach lib: mpathlibs
1244       if not lib.found()
1245         mpathlibs = []
1246         break
1247       endif
1248     endforeach
1249     if mpathlibs.length() == 0
1250       msg = 'Dependencies missing for libmpathpersist'
1251     elif cc.links(mpath_test_source, dependencies: mpathlibs)
1252       mpathpersist = declare_dependency(dependencies: mpathlibs)
1253     else
1254       msg = 'Cannot detect libmpathpersist API'
1255     endif
1256     if not mpathpersist.found()
1257       if get_option('mpath').enabled()
1258         error(msg)
1259       else
1260         warning(msg + ', disabling')
1261       endif
1262     endif
1263   endif
1264 endif
1265
1266 iconv = not_found
1267 curses = not_found
1268 if have_system and get_option('curses').allowed()
1269   curses_test = '''
1270     #if defined(__APPLE__) || defined(__OpenBSD__)
1271     #define _XOPEN_SOURCE_EXTENDED 1
1272     #endif
1273     #include <locale.h>
1274     #include <curses.h>
1275     #include <wchar.h>
1276     int main(void) {
1277       wchar_t wch = L'w';
1278       setlocale(LC_ALL, "");
1279       resize_term(0, 0);
1280       addwstr(L"wide chars\n");
1281       addnwstr(&wch, 1);
1282       add_wch(WACS_DEGREE);
1283       return 0;
1284     }'''
1285
1286   curses_dep_list = host_os == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
1287   curses = dependency(curses_dep_list,
1288                       required: false,
1289                       method: 'pkg-config')
1290   msg = get_option('curses').enabled() ? 'curses library not found' : ''
1291   curses_compile_args = ['-DNCURSES_WIDECHAR=1']
1292   if curses.found()
1293     if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
1294       curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses],
1295                                   version: curses.version())
1296     else
1297       msg = 'curses package not usable'
1298       curses = not_found
1299     endif
1300   endif
1301   if not curses.found()
1302     has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
1303     if host_os != 'windows' and not has_curses_h
1304       message('Trying with /usr/include/ncursesw')
1305       curses_compile_args += ['-I/usr/include/ncursesw']
1306       has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
1307     endif
1308     if has_curses_h
1309       curses_libname_list = (host_os == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
1310       foreach curses_libname : curses_libname_list
1311         libcurses = cc.find_library(curses_libname,
1312                                     required: false)
1313         if libcurses.found()
1314           if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
1315             curses = declare_dependency(compile_args: curses_compile_args,
1316                                         dependencies: [libcurses])
1317             break
1318           else
1319             msg = 'curses library not usable'
1320           endif
1321         endif
1322       endforeach
1323     endif
1324   endif
1325   if get_option('iconv').allowed()
1326     foreach link_args : [ ['-liconv'], [] ]
1327       # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
1328       # We need to use libiconv if available because mixing libiconv's headers with
1329       # the system libc does not work.
1330       # However, without adding glib to the dependencies -L/usr/local/lib will not be
1331       # included in the command line and libiconv will not be found.
1332       if cc.links('''
1333         #include <iconv.h>
1334         int main(void) {
1335           iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
1336           return conv != (iconv_t) -1;
1337         }''', args: link_args, dependencies: glib)
1338         iconv = declare_dependency(link_args: link_args, dependencies: glib)
1339         break
1340       endif
1341     endforeach
1342   endif
1343   if curses.found() and not iconv.found()
1344     if get_option('iconv').enabled()
1345       error('iconv not available')
1346     endif
1347     msg = 'iconv required for curses UI but not available'
1348     curses = not_found
1349   endif
1350   if not curses.found() and msg != ''
1351     if get_option('curses').enabled()
1352       error(msg)
1353     else
1354       warning(msg + ', disabling')
1355     endif
1356   endif
1357 endif
1358
1359 brlapi = not_found
1360 if not get_option('brlapi').auto() or have_system
1361   brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
1362                          required: get_option('brlapi'))
1363   if brlapi.found() and not cc.links('''
1364      #include <brlapi.h>
1365      #include <stddef.h>
1366      int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
1367     brlapi = not_found
1368     if get_option('brlapi').enabled()
1369       error('could not link brlapi')
1370     else
1371       warning('could not link brlapi, disabling')
1372     endif
1373   endif
1374 endif
1375
1376 sdl = not_found
1377 if not get_option('sdl').auto() or have_system
1378   sdl = dependency('sdl2', required: get_option('sdl'))
1379   sdl_image = not_found
1380 endif
1381 if sdl.found()
1382   # Some versions of SDL have problems with -Wundef
1383   if not cc.compiles('''
1384                      #include <SDL.h>
1385                      #include <SDL_syswm.h>
1386                      int main(int argc, char *argv[]) { return 0; }
1387                      ''', dependencies: sdl, args: '-Werror=undef')
1388     sdl = declare_dependency(compile_args: '-Wno-undef',
1389                              dependencies: sdl,
1390                              version: sdl.version())
1391   endif
1392   sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
1393                          method: 'pkg-config')
1394 else
1395   if get_option('sdl_image').enabled()
1396     error('sdl-image required, but SDL was @0@'.format(
1397           get_option('sdl').disabled() ? 'disabled' : 'not found'))
1398   endif
1399   sdl_image = not_found
1400 endif
1401
1402 rbd = not_found
1403 if not get_option('rbd').auto() or have_block
1404   librados = cc.find_library('rados', required: get_option('rbd'))
1405   librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
1406                            required: get_option('rbd'))
1407   if librados.found() and librbd.found()
1408     if cc.links('''
1409       #include <stdio.h>
1410       #include <rbd/librbd.h>
1411       int main(void) {
1412         rados_t cluster;
1413         rados_create(&cluster, NULL);
1414         #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
1415         #error
1416         #endif
1417         return 0;
1418       }''', dependencies: [librbd, librados])
1419       rbd = declare_dependency(dependencies: [librbd, librados])
1420     elif get_option('rbd').enabled()
1421       error('librbd >= 1.12.0 required')
1422     else
1423       warning('librbd >= 1.12.0 not found, disabling')
1424     endif
1425   endif
1426 endif
1427
1428 glusterfs = not_found
1429 glusterfs_ftruncate_has_stat = false
1430 glusterfs_iocb_has_stat = false
1431 if not get_option('glusterfs').auto() or have_block
1432   glusterfs = dependency('glusterfs-api', version: '>=3',
1433                          required: get_option('glusterfs'),
1434                          method: 'pkg-config')
1435   if glusterfs.found()
1436     glusterfs_ftruncate_has_stat = cc.links('''
1437       #include <glusterfs/api/glfs.h>
1438
1439       int
1440       main(void)
1441       {
1442           /* new glfs_ftruncate() passes two additional args */
1443           return glfs_ftruncate(NULL, 0, NULL, NULL);
1444       }
1445     ''', dependencies: glusterfs)
1446     glusterfs_iocb_has_stat = cc.links('''
1447       #include <glusterfs/api/glfs.h>
1448
1449       /* new glfs_io_cbk() passes two additional glfs_stat structs */
1450       static void
1451       glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
1452       {}
1453
1454       int
1455       main(void)
1456       {
1457           glfs_io_cbk iocb = &glusterfs_iocb;
1458           iocb(NULL, 0 , NULL, NULL, NULL);
1459           return 0;
1460       }
1461     ''', dependencies: glusterfs)
1462   endif
1463 endif
1464
1465 hv_balloon = false
1466 if get_option('hv_balloon').allowed() and have_system
1467   if cc.links('''
1468     #include <string.h>
1469     #include <gmodule.h>
1470     int main(void) {
1471         GTree *tree;
1472
1473         tree = g_tree_new((GCompareFunc)strcmp);
1474         (void)g_tree_node_first(tree);
1475         g_tree_destroy(tree);
1476         return 0;
1477     }
1478   ''', dependencies: glib)
1479     hv_balloon = true
1480   else
1481     if get_option('hv_balloon').enabled()
1482       error('could not enable hv-balloon, update your glib')
1483     else
1484       warning('could not find glib support for hv-balloon, disabling')
1485     endif
1486   endif
1487 endif
1488
1489 libssh = not_found
1490 if not get_option('libssh').auto() or have_block
1491   libssh = dependency('libssh', version: '>=0.8.7',
1492                     method: 'pkg-config',
1493                     required: get_option('libssh'))
1494 endif
1495
1496 libbzip2 = not_found
1497 if not get_option('bzip2').auto() or have_block
1498   libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
1499                              required: get_option('bzip2'))
1500   if libbzip2.found() and not cc.links('''
1501      #include <bzlib.h>
1502      int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
1503     libbzip2 = not_found
1504     if get_option('bzip2').enabled()
1505       error('could not link libbzip2')
1506     else
1507       warning('could not link libbzip2, disabling')
1508     endif
1509   endif
1510 endif
1511
1512 liblzfse = not_found
1513 if not get_option('lzfse').auto() or have_block
1514   liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
1515                              required: get_option('lzfse'))
1516 endif
1517 if liblzfse.found() and not cc.links('''
1518    #include <lzfse.h>
1519    int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
1520   liblzfse = not_found
1521   if get_option('lzfse').enabled()
1522     error('could not link liblzfse')
1523   else
1524     warning('could not link liblzfse, disabling')
1525   endif
1526 endif
1527
1528 oss = not_found
1529 if get_option('oss').allowed() and have_system
1530   if not cc.has_header('sys/soundcard.h')
1531     # not found
1532   elif host_os == 'netbsd'
1533     oss = cc.find_library('ossaudio', required: get_option('oss'))
1534   else
1535     oss = declare_dependency()
1536   endif
1537
1538   if not oss.found()
1539     if get_option('oss').enabled()
1540       error('OSS not found')
1541     endif
1542   endif
1543 endif
1544 dsound = not_found
1545 if not get_option('dsound').auto() or (host_os == 'windows' and have_system)
1546   if cc.has_header('dsound.h')
1547     dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
1548   endif
1549
1550   if not dsound.found()
1551     if get_option('dsound').enabled()
1552       error('DirectSound not found')
1553     endif
1554   endif
1555 endif
1556
1557 coreaudio = not_found
1558 if not get_option('coreaudio').auto() or (host_os == 'darwin' and have_system)
1559   coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
1560                          required: get_option('coreaudio'))
1561 endif
1562
1563 opengl = not_found
1564 if not get_option('opengl').auto() or have_system or have_vhost_user_gpu
1565   epoxy = dependency('epoxy', method: 'pkg-config',
1566                       required: get_option('opengl'))
1567   if cc.has_header('epoxy/egl.h', dependencies: epoxy)
1568     opengl = epoxy
1569   elif get_option('opengl').enabled()
1570     error('epoxy/egl.h not found')
1571   endif
1572 endif
1573 gbm = not_found
1574 if (have_system or have_tools) and (virgl.found() or opengl.found())
1575   gbm = dependency('gbm', method: 'pkg-config', required: false)
1576 endif
1577 have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and opengl.found() and gbm.found()
1578
1579 gnutls = not_found
1580 gnutls_crypto = not_found
1581 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
1582   # For general TLS support our min gnutls matches
1583   # that implied by our platform support matrix
1584   #
1585   # For the crypto backends, we look for a newer
1586   # gnutls:
1587   #
1588   #   Version 3.6.8  is needed to get XTS
1589   #   Version 3.6.13 is needed to get PBKDF
1590   #   Version 3.6.14 is needed to get HW accelerated XTS
1591   #
1592   # If newer enough gnutls isn't available, we can
1593   # still use a different crypto backend to satisfy
1594   # the platform support requirements
1595   gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
1596                              method: 'pkg-config',
1597                              required: false)
1598   if gnutls_crypto.found()
1599     gnutls = gnutls_crypto
1600   else
1601     # Our min version if all we need is TLS
1602     gnutls = dependency('gnutls', version: '>=3.5.18',
1603                         method: 'pkg-config',
1604                         required: get_option('gnutls'))
1605   endif
1606 endif
1607
1608 # We prefer use of gnutls for crypto, unless the options
1609 # explicitly asked for nettle or gcrypt.
1610 #
1611 # If gnutls isn't available for crypto, then we'll prefer
1612 # gcrypt over nettle for performance reasons.
1613 gcrypt = not_found
1614 nettle = not_found
1615 hogweed = not_found
1616 xts = 'none'
1617
1618 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1619   error('Only one of gcrypt & nettle can be enabled')
1620 endif
1621
1622 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
1623 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1624   gnutls_crypto = not_found
1625 endif
1626
1627 if not gnutls_crypto.found()
1628   if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1629     gcrypt = dependency('libgcrypt', version: '>=1.8',
1630                         method: 'config-tool',
1631                         required: get_option('gcrypt'))
1632     # Debian has removed -lgpg-error from libgcrypt-config
1633     # as it "spreads unnecessary dependencies" which in
1634     # turn breaks static builds...
1635     if gcrypt.found() and get_option('prefer_static')
1636       gcrypt = declare_dependency(dependencies:
1637         [gcrypt,
1638          cc.find_library('gpg-error', required: true)],
1639         version: gcrypt.version())
1640     endif
1641   endif
1642   if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1643     nettle = dependency('nettle', version: '>=3.4',
1644                         method: 'pkg-config',
1645                         required: get_option('nettle'))
1646     if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1647       xts = 'private'
1648     endif
1649   endif
1650 endif
1651
1652 capstone = not_found
1653 if not get_option('capstone').auto() or have_system or have_user
1654   capstone = dependency('capstone', version: '>=3.0.5',
1655                         method: 'pkg-config',
1656                         required: get_option('capstone'))
1657
1658   # Some versions of capstone have broken pkg-config file
1659   # that reports a wrong -I path, causing the #include to
1660   # fail later. If the system has such a broken version
1661   # do not use it.
1662   if capstone.found() and not cc.compiles('#include <capstone.h>',
1663                                           dependencies: [capstone])
1664     capstone = not_found
1665     if get_option('capstone').enabled()
1666       error('capstone requested, but it does not appear to work')
1667     endif
1668   endif
1669 endif
1670
1671 gmp = dependency('gmp', required: false, method: 'pkg-config')
1672 if nettle.found() and gmp.found()
1673   hogweed = dependency('hogweed', version: '>=3.4',
1674                        method: 'pkg-config',
1675                        required: get_option('nettle'))
1676 endif
1677
1678
1679 gtk = not_found
1680 gtkx11 = not_found
1681 vte = not_found
1682 have_gtk_clipboard = get_option('gtk_clipboard').enabled()
1683
1684 if get_option('gtk') \
1685              .disable_auto_if(not have_system) \
1686              .require(pixman.found(),
1687                       error_message: 'cannot enable GTK if pixman is not available') \
1688              .allowed()
1689   gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1690                    method: 'pkg-config',
1691                    required: get_option('gtk'))
1692   if gtk.found()
1693     gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1694                         method: 'pkg-config',
1695                         required: false)
1696     gtk = declare_dependency(dependencies: [gtk, gtkx11],
1697                              version: gtk.version())
1698
1699     if not get_option('vte').auto() or have_system
1700       vte = dependency('vte-2.91',
1701                        method: 'pkg-config',
1702                        required: get_option('vte'))
1703     endif
1704   elif have_gtk_clipboard
1705     error('GTK clipboard requested, but GTK not found')
1706   endif
1707 endif
1708
1709 x11 = not_found
1710 if gtkx11.found()
1711   x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found())
1712 endif
1713 png = not_found
1714 if get_option('png').allowed() and have_system
1715    png = dependency('libpng', version: '>=1.6.34', required: get_option('png'),
1716                     method: 'pkg-config')
1717 endif
1718 vnc = not_found
1719 jpeg = not_found
1720 sasl = not_found
1721 if get_option('vnc') \
1722              .disable_auto_if(not have_system) \
1723              .require(pixman.found(),
1724                       error_message: 'cannot enable VNC if pixman is not available') \
1725              .allowed()
1726   vnc = declare_dependency() # dummy dependency
1727   jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1728                     method: 'pkg-config')
1729   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1730                          required: get_option('vnc_sasl'))
1731   if sasl.found()
1732     sasl = declare_dependency(dependencies: sasl,
1733                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
1734   endif
1735 endif
1736
1737 pam = not_found
1738 if not get_option('auth_pam').auto() or have_system
1739   pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1740                         required: get_option('auth_pam'))
1741 endif
1742 if pam.found() and not cc.links('''
1743    #include <stddef.h>
1744    #include <security/pam_appl.h>
1745    int main(void) {
1746      const char *service_name = "qemu";
1747      const char *user = "frank";
1748      const struct pam_conv pam_conv = { 0 };
1749      pam_handle_t *pamh = NULL;
1750      pam_start(service_name, user, &pam_conv, &pamh);
1751      return 0;
1752    }''', dependencies: pam)
1753   pam = not_found
1754   if get_option('auth_pam').enabled()
1755     error('could not link libpam')
1756   else
1757     warning('could not link libpam, disabling')
1758   endif
1759 endif
1760
1761 snappy = not_found
1762 if not get_option('snappy').auto() or have_system
1763   snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1764                            required: get_option('snappy'))
1765 endif
1766 if snappy.found() and not cc.links('''
1767    #include <snappy-c.h>
1768    int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1769   snappy = not_found
1770   if get_option('snappy').enabled()
1771     error('could not link libsnappy')
1772   else
1773     warning('could not link libsnappy, disabling')
1774   endif
1775 endif
1776
1777 lzo = not_found
1778 if not get_option('lzo').auto() or have_system
1779   lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1780                         required: get_option('lzo'))
1781 endif
1782 if lzo.found() and not cc.links('''
1783    #include <lzo/lzo1x.h>
1784    int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1785   lzo = not_found
1786   if get_option('lzo').enabled()
1787     error('could not link liblzo2')
1788   else
1789     warning('could not link liblzo2, disabling')
1790   endif
1791 endif
1792
1793 numa = not_found
1794 if not get_option('numa').auto() or have_system or have_tools
1795   numa = cc.find_library('numa', has_headers: ['numa.h'],
1796                               required: get_option('numa'))
1797 endif
1798 if numa.found() and not cc.links('''
1799    #include <numa.h>
1800    int main(void) { return numa_available(); }
1801    ''', dependencies: numa)
1802   numa = not_found
1803   if get_option('numa').enabled()
1804     error('could not link numa')
1805   else
1806     warning('could not link numa, disabling')
1807   endif
1808 endif
1809
1810 rdma = not_found
1811 if not get_option('rdma').auto() or have_system
1812   libumad = cc.find_library('ibumad', required: get_option('rdma'))
1813   rdma_libs = [cc.find_library('rdmacm', has_headers: ['rdma/rdma_cma.h'],
1814                                required: get_option('rdma')),
1815                cc.find_library('ibverbs', required: get_option('rdma')),
1816                libumad]
1817   rdma = declare_dependency(dependencies: rdma_libs)
1818   foreach lib: rdma_libs
1819     if not lib.found()
1820       rdma = not_found
1821     endif
1822   endforeach
1823 endif
1824
1825 cacard = not_found
1826 if not get_option('smartcard').auto() or have_system
1827   cacard = dependency('libcacard', required: get_option('smartcard'),
1828                       version: '>=2.5.1', method: 'pkg-config')
1829 endif
1830 u2f = not_found
1831 if not get_option('u2f').auto() or have_system
1832   u2f = dependency('u2f-emu', required: get_option('u2f'),
1833                    method: 'pkg-config')
1834 endif
1835 canokey = not_found
1836 if not get_option('canokey').auto() or have_system
1837   canokey = dependency('canokey-qemu', required: get_option('canokey'),
1838                    method: 'pkg-config')
1839 endif
1840 usbredir = not_found
1841 if not get_option('usb_redir').auto() or have_system
1842   usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1843                         version: '>=0.6', method: 'pkg-config')
1844 endif
1845 libusb = not_found
1846 if not get_option('libusb').auto() or have_system
1847   libusb = dependency('libusb-1.0', required: get_option('libusb'),
1848                       version: '>=1.0.13', method: 'pkg-config')
1849 endif
1850
1851 libpmem = not_found
1852 if not get_option('libpmem').auto() or have_system
1853   libpmem = dependency('libpmem', required: get_option('libpmem'),
1854                        method: 'pkg-config')
1855 endif
1856 libdaxctl = not_found
1857 if not get_option('libdaxctl').auto() or have_system
1858   libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1859                          version: '>=57', method: 'pkg-config')
1860 endif
1861 tasn1 = not_found
1862 if gnutls.found()
1863   tasn1 = dependency('libtasn1',
1864                      method: 'pkg-config')
1865 endif
1866 keyutils = not_found
1867 if not get_option('libkeyutils').auto() or have_block
1868   keyutils = dependency('libkeyutils', required: get_option('libkeyutils'),
1869                         method: 'pkg-config')
1870 endif
1871
1872 has_gettid = cc.has_function('gettid')
1873
1874 # libselinux
1875 selinux = dependency('libselinux',
1876                      required: get_option('selinux'),
1877                      method: 'pkg-config')
1878
1879 # Malloc tests
1880
1881 malloc = []
1882 if get_option('malloc') == 'system'
1883   has_malloc_trim = \
1884     get_option('malloc_trim').allowed() and \
1885     cc.has_function('malloc_trim', prefix: '#include <malloc.h>')
1886 else
1887   has_malloc_trim = false
1888   malloc = cc.find_library(get_option('malloc'), required: true)
1889 endif
1890 if not has_malloc_trim and get_option('malloc_trim').enabled()
1891   if get_option('malloc') == 'system'
1892     error('malloc_trim not available on this platform.')
1893   else
1894     error('malloc_trim not available with non-libc memory allocator')
1895   endif
1896 endif
1897
1898 gnu_source_prefix = '''
1899   #ifndef _GNU_SOURCE
1900   #define _GNU_SOURCE
1901   #endif
1902 '''
1903
1904 # Check whether the glibc provides STATX_BASIC_STATS
1905
1906 has_statx = cc.has_header_symbol('sys/stat.h', 'STATX_BASIC_STATS', prefix: gnu_source_prefix)
1907
1908 # Check whether statx() provides mount ID information
1909
1910 has_statx_mnt_id = cc.has_header_symbol('sys/stat.h', 'STATX_MNT_ID', prefix: gnu_source_prefix)
1911
1912 have_vhost_user_blk_server = get_option('vhost_user_blk_server') \
1913   .require(host_os == 'linux',
1914            error_message: 'vhost_user_blk_server requires linux') \
1915   .require(have_vhost_user,
1916            error_message: 'vhost_user_blk_server requires vhost-user support') \
1917   .disable_auto_if(not have_tools and not have_system) \
1918   .allowed()
1919
1920 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1921   error('Cannot enable fuse-lseek while fuse is disabled')
1922 endif
1923
1924 fuse = dependency('fuse3', required: get_option('fuse'),
1925                   version: '>=3.1', method: 'pkg-config')
1926
1927 fuse_lseek = not_found
1928 if get_option('fuse_lseek').allowed()
1929   if fuse.version().version_compare('>=3.8')
1930     # Dummy dependency
1931     fuse_lseek = declare_dependency()
1932   elif get_option('fuse_lseek').enabled()
1933     if fuse.found()
1934       error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1935     else
1936       error('fuse-lseek requires libfuse, which was not found')
1937     endif
1938   endif
1939 endif
1940
1941 have_libvduse = (host_os == 'linux')
1942 if get_option('libvduse').enabled()
1943     if host_os != 'linux'
1944         error('libvduse requires linux')
1945     endif
1946 elif get_option('libvduse').disabled()
1947     have_libvduse = false
1948 endif
1949
1950 have_vduse_blk_export = (have_libvduse and host_os == 'linux')
1951 if get_option('vduse_blk_export').enabled()
1952     if host_os != 'linux'
1953         error('vduse_blk_export requires linux')
1954     elif not have_libvduse
1955         error('vduse_blk_export requires libvduse support')
1956     endif
1957 elif get_option('vduse_blk_export').disabled()
1958     have_vduse_blk_export = false
1959 endif
1960
1961 # libbpf
1962 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1963 if libbpf.found() and not cc.links('''
1964    #include <bpf/libbpf.h>
1965    int main(void)
1966    {
1967      bpf_object__destroy_skeleton(NULL);
1968      return 0;
1969    }''', dependencies: libbpf)
1970   libbpf = not_found
1971   if get_option('bpf').enabled()
1972     error('libbpf skeleton test failed')
1973   else
1974     warning('libbpf skeleton test failed, disabling')
1975   endif
1976 endif
1977
1978 # libxdp
1979 libxdp = not_found
1980 if not get_option('af_xdp').auto() or have_system
1981     libxdp = dependency('libxdp', required: get_option('af_xdp'),
1982                         version: '>=1.4.0', method: 'pkg-config')
1983 endif
1984
1985 # libdw
1986 libdw = not_found
1987 if not get_option('libdw').auto() or \
1988         (not get_option('prefer_static') and (have_system or have_user))
1989     libdw = dependency('libdw',
1990                        method: 'pkg-config',
1991                        required: get_option('libdw'))
1992 endif
1993
1994 #################
1995 # config-host.h #
1996 #################
1997
1998 config_host_data = configuration_data()
1999
2000 audio_drivers_selected = []
2001 if have_system
2002   audio_drivers_available = {
2003     'alsa': alsa.found(),
2004     'coreaudio': coreaudio.found(),
2005     'dsound': dsound.found(),
2006     'jack': jack.found(),
2007     'oss': oss.found(),
2008     'pa': pulse.found(),
2009     'pipewire': pipewire.found(),
2010     'sdl': sdl.found(),
2011     'sndio': sndio.found(),
2012   }
2013   foreach k, v: audio_drivers_available
2014     config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
2015   endforeach
2016
2017   # Default to native drivers first, OSS second, SDL third
2018   audio_drivers_priority = \
2019     [ 'pa', 'coreaudio', 'dsound', 'sndio', 'oss' ] + \
2020     (host_os == 'linux' ? [] : [ 'sdl' ])
2021   audio_drivers_default = []
2022   foreach k: audio_drivers_priority
2023     if audio_drivers_available[k]
2024       audio_drivers_default += k
2025     endif
2026   endforeach
2027
2028   foreach k: get_option('audio_drv_list')
2029     if k == 'default'
2030       audio_drivers_selected += audio_drivers_default
2031     elif not audio_drivers_available[k]
2032       error('Audio driver "@0@" not available.'.format(k))
2033     else
2034       audio_drivers_selected += k
2035     endif
2036   endforeach
2037 endif
2038 config_host_data.set('CONFIG_AUDIO_DRIVERS',
2039                      '"' + '", "'.join(audio_drivers_selected) + '", ')
2040
2041 have_host_block_device = (host_os != 'darwin' or
2042     cc.has_header('IOKit/storage/IOMedia.h'))
2043
2044 dbus_display = get_option('dbus_display') \
2045   .require(gio.version().version_compare('>=2.64'),
2046            error_message: '-display dbus requires glib>=2.64') \
2047   .require(gdbus_codegen.found(),
2048            error_message: gdbus_codegen_error.format('-display dbus')) \
2049   .allowed()
2050
2051 have_virtfs = get_option('virtfs') \
2052     .require(host_os == 'linux' or host_os == 'darwin',
2053              error_message: 'virtio-9p (virtfs) requires Linux or macOS') \
2054     .require(host_os == 'linux' or cc.has_function('pthread_fchdir_np'),
2055              error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \
2056     .require(host_os == 'darwin' or libattr.found(),
2057              error_message: 'virtio-9p (virtfs) on Linux requires libattr-devel') \
2058     .disable_auto_if(not have_tools and not have_system) \
2059     .allowed()
2060
2061 have_virtfs_proxy_helper = get_option('virtfs_proxy_helper') \
2062     .require(host_os != 'darwin', error_message: 'the virtfs proxy helper is incompatible with macOS') \
2063     .require(have_virtfs, error_message: 'the virtfs proxy helper requires that virtfs is enabled') \
2064     .disable_auto_if(not have_tools) \
2065     .require(libcap_ng.found(), error_message: 'the virtfs proxy helper requires libcap-ng') \
2066     .allowed()
2067
2068 if get_option('block_drv_ro_whitelist') == ''
2069   config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '')
2070 else
2071   config_host_data.set('CONFIG_BDRV_RO_WHITELIST',
2072         '"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ')
2073 endif
2074 if get_option('block_drv_rw_whitelist') == ''
2075   config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '')
2076 else
2077   config_host_data.set('CONFIG_BDRV_RW_WHITELIST',
2078         '"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ')
2079 endif
2080
2081 foreach k : get_option('trace_backends')
2082   config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
2083 endforeach
2084 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
2085 config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority'))
2086 if iasl.found()
2087   config_host_data.set_quoted('CONFIG_IASL', iasl.full_path())
2088 endif
2089 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
2090 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
2091 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
2092 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
2093 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
2094
2095 qemu_firmwarepath = ''
2096 foreach k : get_option('qemu_firmwarepath')
2097   qemu_firmwarepath += '"' + get_option('prefix') / k + '", '
2098 endforeach
2099 config_host_data.set('CONFIG_QEMU_FIRMWAREPATH', qemu_firmwarepath)
2100
2101 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
2102 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
2103 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
2104 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
2105 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
2106 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
2107
2108 if enable_modules
2109   config_host_data.set('CONFIG_STAMP', run_command(
2110       meson.current_source_dir() / 'scripts/qemu-stamp.py',
2111       meson.project_version(), get_option('pkgversion'), '--',
2112       meson.current_source_dir() / 'configure',
2113       capture: true, check: true).stdout().strip())
2114 endif
2115
2116 have_slirp_smbd = get_option('slirp_smbd') \
2117   .require(host_os != 'windows', error_message: 'Host smbd not supported on this platform.') \
2118   .allowed()
2119 if have_slirp_smbd
2120   smbd_path = get_option('smbd')
2121   if smbd_path == ''
2122     smbd_path = (host_os == 'sunos' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
2123   endif
2124   config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
2125 endif
2126
2127 config_host_data.set('HOST_' + host_arch.to_upper(), 1)
2128
2129 kvm_targets_c = '""'
2130 if get_option('kvm').allowed() and host_os == 'linux'
2131   kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
2132 endif
2133 config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
2134
2135 if get_option('module_upgrades') and not enable_modules
2136   error('Cannot enable module-upgrades as modules are not enabled')
2137 endif
2138 config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades'))
2139
2140 config_host_data.set('CONFIG_ATTR', libattr.found())
2141 config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
2142 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
2143 config_host_data.set('CONFIG_BSD', host_os in bsd_oses)
2144 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2145 config_host_data.set('CONFIG_COCOA', cocoa.found())
2146 config_host_data.set('CONFIG_DARWIN', host_os == 'darwin')
2147 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
2148 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
2149 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
2150 config_host_data.set('CONFIG_LINUX', host_os == 'linux')
2151 config_host_data.set('CONFIG_POSIX', host_os != 'windows')
2152 config_host_data.set('CONFIG_WIN32', host_os == 'windows')
2153 config_host_data.set('CONFIG_LZO', lzo.found())
2154 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
2155 config_host_data.set('CONFIG_BLKIO', blkio.found())
2156 if blkio.found()
2157   config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD',
2158                        blkio.version().version_compare('>=1.3.0'))
2159 endif
2160 config_host_data.set('CONFIG_CURL', curl.found())
2161 config_host_data.set('CONFIG_CURSES', curses.found())
2162 config_host_data.set('CONFIG_GBM', gbm.found())
2163 config_host_data.set('CONFIG_GIO', gio.found())
2164 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
2165 if glusterfs.found()
2166   config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
2167   config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
2168   config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
2169   config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
2170   config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
2171   config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
2172 endif
2173 config_host_data.set('CONFIG_GTK', gtk.found())
2174 config_host_data.set('CONFIG_VTE', vte.found())
2175 config_host_data.set('CONFIG_GTK_CLIPBOARD', have_gtk_clipboard)
2176 config_host_data.set('CONFIG_HEXAGON_IDEF_PARSER', get_option('hexagon_idef_parser'))
2177 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
2178 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
2179 config_host_data.set('CONFIG_EBPF', libbpf.found())
2180 config_host_data.set('CONFIG_AF_XDP', libxdp.found())
2181 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
2182 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
2183 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
2184 config_host_data.set('CONFIG_LIBSSH', libssh.found())
2185 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
2186 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
2187 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
2188 config_host_data.set('CONFIG_MODULES', enable_modules)
2189 config_host_data.set('CONFIG_NUMA', numa.found())
2190 if numa.found()
2191   config_host_data.set('HAVE_NUMA_HAS_PREFERRED_MANY',
2192                        cc.has_function('numa_has_preferred_many',
2193                                        dependencies: numa))
2194 endif
2195 config_host_data.set('CONFIG_OPENGL', opengl.found())
2196 config_host_data.set('CONFIG_PLUGIN', get_option('plugins'))
2197 config_host_data.set('CONFIG_RBD', rbd.found())
2198 config_host_data.set('CONFIG_RDMA', rdma.found())
2199 config_host_data.set('CONFIG_RELOCATABLE', get_option('relocatable'))
2200 config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
2201 config_host_data.set('CONFIG_SDL', sdl.found())
2202 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
2203 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
2204 if seccomp.found()
2205   config_host_data.set('CONFIG_SECCOMP_SYSRAWRC', seccomp_has_sysrawrc)
2206 endif
2207 config_host_data.set('CONFIG_PIXMAN', pixman.found())
2208 config_host_data.set('CONFIG_SLIRP', slirp.found())
2209 config_host_data.set('CONFIG_SNAPPY', snappy.found())
2210 config_host_data.set('CONFIG_SOLARIS', host_os == 'sunos')
2211 if get_option('tcg').allowed()
2212   config_host_data.set('CONFIG_TCG', 1)
2213   config_host_data.set('CONFIG_TCG_INTERPRETER', tcg_arch == 'tci')
2214 endif
2215 config_host_data.set('CONFIG_TPM', have_tpm)
2216 config_host_data.set('CONFIG_TSAN', get_option('tsan'))
2217 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
2218 config_host_data.set('CONFIG_VDE', vde.found())
2219 config_host_data.set('CONFIG_VHOST', have_vhost)
2220 config_host_data.set('CONFIG_VHOST_NET', have_vhost_net)
2221 config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user)
2222 config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa)
2223 config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
2224 config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
2225 config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
2226 config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
2227 config_host_data.set('CONFIG_VMNET', vmnet.found())
2228 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
2229 config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export)
2230 config_host_data.set('CONFIG_PNG', png.found())
2231 config_host_data.set('CONFIG_VNC', vnc.found())
2232 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
2233 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
2234 if virgl.found()
2235   config_host_data.set('HAVE_VIRGL_D3D_INFO_EXT',
2236                        cc.has_member('struct virgl_renderer_resource_info_ext', 'd3d_tex2d',
2237                                      prefix: '#include <virglrenderer.h>',
2238                                      dependencies: virgl))
2239 endif
2240 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
2241 config_host_data.set('CONFIG_VTE', vte.found())
2242 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
2243 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
2244 config_host_data.set('CONFIG_GETTID', has_gettid)
2245 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
2246 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
2247 config_host_data.set('CONFIG_TASN1', tasn1.found())
2248 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
2249 config_host_data.set('CONFIG_NETTLE', nettle.found())
2250 config_host_data.set('CONFIG_HOGWEED', hogweed.found())
2251 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
2252 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
2253 config_host_data.set('CONFIG_STATX', has_statx)
2254 config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
2255 config_host_data.set('CONFIG_ZSTD', zstd.found())
2256 config_host_data.set('CONFIG_FUSE', fuse.found())
2257 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
2258 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
2259 if spice_protocol.found()
2260 config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
2261 config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
2262 config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
2263 endif
2264 config_host_data.set('CONFIG_SPICE', spice.found())
2265 config_host_data.set('CONFIG_X11', x11.found())
2266 config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
2267 config_host_data.set('CONFIG_CFI', get_option('cfi'))
2268 config_host_data.set('CONFIG_SELINUX', selinux.found())
2269 config_host_data.set('CONFIG_XEN_BACKEND', xen.found())
2270 config_host_data.set('CONFIG_LIBDW', libdw.found())
2271 if xen.found()
2272   # protect from xen.version() having less than three components
2273   xen_version = xen.version().split('.') + ['0', '0']
2274   xen_ctrl_version = xen_version[0] + \
2275     ('0' + xen_version[1]).substring(-2) + \
2276     ('0' + xen_version[2]).substring(-2)
2277   config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version)
2278 endif
2279 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
2280 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
2281 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
2282 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
2283
2284 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
2285 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
2286
2287 have_coroutine_pool = get_option('coroutine_pool')
2288 if get_option('debug_stack_usage') and have_coroutine_pool
2289   message('Disabling coroutine pool to measure stack usage')
2290   have_coroutine_pool = false
2291 endif
2292 config_host_data.set('CONFIG_COROUTINE_POOL', have_coroutine_pool)
2293 config_host_data.set('CONFIG_DEBUG_GRAPH_LOCK', get_option('debug_graph_lock'))
2294 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
2295 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
2296 config_host_data.set('CONFIG_DEBUG_TCG', get_option('debug_tcg'))
2297 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
2298 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
2299 config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed())
2300
2301 # has_header
2302 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
2303 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
2304 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
2305 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
2306 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
2307 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
2308 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
2309 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
2310 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
2311 if host_os == 'windows'
2312   config_host_data.set('HAVE_AFUNIX_H', cc.has_header('afunix.h'))
2313 endif
2314
2315 # has_function
2316 config_host_data.set('CONFIG_CLOSE_RANGE', cc.has_function('close_range'))
2317 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
2318 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
2319 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
2320 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
2321 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
2322 config_host_data.set('CONFIG_GETCPU', cc.has_function('getcpu', prefix: gnu_source_prefix))
2323 config_host_data.set('CONFIG_SCHED_GETCPU', cc.has_function('sched_getcpu', prefix: '#include <sched.h>'))
2324 # Note that we need to specify prefix: here to avoid incorrectly
2325 # thinking that Windows has posix_memalign()
2326 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
2327 config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
2328 config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
2329 config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
2330 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
2331 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
2332 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
2333 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
2334 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
2335 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
2336 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
2337 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
2338 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
2339 config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs'))
2340 config_host_data.set('HAVE_GLIB_WITH_SLICE_ALLOCATOR', glib_has_gslice)
2341 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
2342 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
2343 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
2344 if rbd.found()
2345   config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
2346                        cc.has_function('rbd_namespace_exists',
2347                                        dependencies: rbd,
2348                                        prefix: '#include <rbd/librbd.h>'))
2349 endif
2350 if rdma.found()
2351   config_host_data.set('HAVE_IBV_ADVISE_MR',
2352                        cc.has_function('ibv_advise_mr',
2353                                        dependencies: rdma,
2354                                        prefix: '#include <infiniband/verbs.h>'))
2355 endif
2356
2357 have_asan_fiber = false
2358 if get_option('sanitizers') and \
2359    not cc.has_function('__sanitizer_start_switch_fiber',
2360                          args: '-fsanitize=address',
2361                          prefix: '#include <sanitizer/asan_interface.h>')
2362   warning('Missing ASAN due to missing fiber annotation interface')
2363   warning('Without code annotation, the report may be inferior.')
2364 else
2365   have_asan_fiber = true
2366 endif
2367 config_host_data.set('CONFIG_ASAN_IFACE_FIBER', have_asan_fiber)
2368
2369 # has_header_symbol
2370 config_host_data.set('CONFIG_BLKZONED',
2371                      cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE'))
2372 config_host_data.set('CONFIG_EPOLL_CREATE1',
2373                      cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
2374 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
2375                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
2376                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
2377 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
2378                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
2379 config_host_data.set('CONFIG_FIEMAP',
2380                      cc.has_header('linux/fiemap.h') and
2381                      cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
2382 config_host_data.set('CONFIG_GETRANDOM',
2383                      cc.has_function('getrandom') and
2384                      cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
2385 config_host_data.set('CONFIG_INOTIFY',
2386                      cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
2387 config_host_data.set('CONFIG_INOTIFY1',
2388                      cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
2389 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
2390                      cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
2391 config_host_data.set('CONFIG_RTNETLINK',
2392                      cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
2393 config_host_data.set('CONFIG_SYSMACROS',
2394                      cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
2395 config_host_data.set('HAVE_OPTRESET',
2396                      cc.has_header_symbol('getopt.h', 'optreset'))
2397 config_host_data.set('HAVE_IPPROTO_MPTCP',
2398                      cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
2399
2400 # has_member
2401 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
2402                      cc.has_member('struct sigevent', 'sigev_notify_thread_id',
2403                                    prefix: '#include <signal.h>'))
2404 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
2405                      cc.has_member('struct stat', 'st_atim',
2406                                    prefix: '#include <sys/stat.h>'))
2407 config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY',
2408                      cc.has_member('struct blk_zone', 'capacity',
2409                                    prefix: '#include <linux/blkzoned.h>'))
2410
2411 # has_type
2412 config_host_data.set('CONFIG_IOVEC',
2413                      cc.has_type('struct iovec',
2414                                  prefix: '#include <sys/uio.h>'))
2415 config_host_data.set('HAVE_UTMPX',
2416                      cc.has_type('struct utmpx',
2417                                  prefix: '#include <utmpx.h>'))
2418
2419 config_host_data.set('CONFIG_EVENTFD', cc.links('''
2420   #include <sys/eventfd.h>
2421   int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
2422 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
2423   #include <unistd.h>
2424   int main(void) {
2425   #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
2426   return fdatasync(0);
2427   #else
2428   #error Not supported
2429   #endif
2430   }'''))
2431
2432 has_madvise = cc.links(gnu_source_prefix + '''
2433   #include <sys/types.h>
2434   #include <sys/mman.h>
2435   #include <stddef.h>
2436   int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
2437 missing_madvise_proto = false
2438 if has_madvise
2439   # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
2440   # but forget to prototype it. In this case, has_madvise will be true (the
2441   # test program links despite a compile warning). To detect the
2442   # missing-prototype case, we try again with a definitely-bogus prototype.
2443   # This will only compile if the system headers don't provide the prototype;
2444   # otherwise the conflicting prototypes will cause a compiler error.
2445   missing_madvise_proto = cc.links(gnu_source_prefix + '''
2446     #include <sys/types.h>
2447     #include <sys/mman.h>
2448     #include <stddef.h>
2449     extern int madvise(int);
2450     int main(void) { return madvise(0); }''')
2451 endif
2452 config_host_data.set('CONFIG_MADVISE', has_madvise)
2453 config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
2454
2455 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
2456   #include <sys/mman.h>
2457   int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
2458 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
2459   #include <fcntl.h>
2460   #if !defined(AT_EMPTY_PATH)
2461   # error missing definition
2462   #else
2463   int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
2464   #endif'''))
2465 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
2466   #include <sys/mman.h>
2467   #include <stddef.h>
2468   int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
2469
2470 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
2471   #include <pthread.h>
2472
2473   static void *f(void *p) { return NULL; }
2474   int main(void)
2475   {
2476     pthread_t thread;
2477     pthread_create(&thread, 0, f, 0);
2478     pthread_setname_np(thread, "QEMU");
2479     return 0;
2480   }''', dependencies: threads))
2481 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
2482   #include <pthread.h>
2483
2484   static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
2485   int main(void)
2486   {
2487     pthread_t thread;
2488     pthread_create(&thread, 0, f, 0);
2489     return 0;
2490   }''', dependencies: threads))
2491 config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + '''
2492   #include <pthread.h>
2493   #include <pthread_np.h>
2494
2495   static void *f(void *p) { return NULL; }
2496   int main(void)
2497   {
2498     pthread_t thread;
2499     pthread_create(&thread, 0, f, 0);
2500     pthread_set_name_np(thread, "QEMU");
2501     return 0;
2502   }''', dependencies: threads))
2503 config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
2504   #include <pthread.h>
2505   #include <time.h>
2506
2507   int main(void)
2508   {
2509     pthread_condattr_t attr
2510     pthread_condattr_init(&attr);
2511     pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
2512     return 0;
2513   }''', dependencies: threads))
2514 config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + '''
2515   #include <pthread.h>
2516
2517   static void *f(void *p) { return NULL; }
2518   int main(void)
2519   {
2520     int setsize = CPU_ALLOC_SIZE(64);
2521     pthread_t thread;
2522     cpu_set_t *cpuset;
2523     pthread_create(&thread, 0, f, 0);
2524     cpuset = CPU_ALLOC(64);
2525     CPU_ZERO_S(setsize, cpuset);
2526     pthread_setaffinity_np(thread, setsize, cpuset);
2527     pthread_getaffinity_np(thread, setsize, cpuset);
2528     CPU_FREE(cpuset);
2529     return 0;
2530   }''', dependencies: threads))
2531 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
2532   #include <sys/signalfd.h>
2533   #include <stddef.h>
2534   int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
2535 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
2536   #include <unistd.h>
2537   #include <fcntl.h>
2538   #include <limits.h>
2539
2540   int main(void)
2541   {
2542     int len, fd = 0;
2543     len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
2544     splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
2545     return 0;
2546   }'''))
2547
2548 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
2549   #include <sys/mman.h>
2550   int main(void) {
2551     return mlockall(MCL_FUTURE);
2552   }'''))
2553
2554 have_l2tpv3 = false
2555 if get_option('l2tpv3').allowed() and have_system
2556   have_l2tpv3 = cc.has_type('struct mmsghdr',
2557     prefix: gnu_source_prefix + '''
2558       #include <sys/socket.h>
2559       #include <linux/ip.h>''')
2560 endif
2561 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
2562
2563 have_netmap = false
2564 if get_option('netmap').allowed() and have_system
2565   have_netmap = cc.compiles('''
2566     #include <inttypes.h>
2567     #include <net/if.h>
2568     #include <net/netmap.h>
2569     #include <net/netmap_user.h>
2570     #if (NETMAP_API < 11) || (NETMAP_API > 15)
2571     #error
2572     #endif
2573     int main(void) { return 0; }''')
2574   if not have_netmap and get_option('netmap').enabled()
2575     error('Netmap headers not available')
2576   endif
2577 endif
2578 config_host_data.set('CONFIG_NETMAP', have_netmap)
2579
2580 # Work around a system header bug with some kernel/XFS header
2581 # versions where they both try to define 'struct fsxattr':
2582 # xfs headers will not try to redefine structs from linux headers
2583 # if this macro is set.
2584 config_host_data.set('HAVE_FSXATTR', cc.links('''
2585   #include <linux/fs.h>
2586   struct fsxattr foo;
2587   int main(void) {
2588     return 0;
2589   }'''))
2590
2591 # Some versions of Mac OS X incorrectly define SIZE_MAX
2592 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
2593     #include <stdint.h>
2594     #include <stdio.h>
2595     int main(void) {
2596         return printf("%zu", SIZE_MAX);
2597     }''', args: ['-Werror']))
2598
2599 # See if 64-bit atomic operations are supported.
2600 # Note that without __atomic builtins, we can only
2601 # assume atomic loads/stores max at pointer size.
2602 config_host_data.set('CONFIG_ATOMIC64', cc.links('''
2603   #include <stdint.h>
2604   int main(void)
2605   {
2606     uint64_t x = 0, y = 0;
2607     y = __atomic_load_n(&x, __ATOMIC_RELAXED);
2608     __atomic_store_n(&x, y, __ATOMIC_RELAXED);
2609     __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2610     __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
2611     __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
2612     return 0;
2613   }'''))
2614
2615 has_int128_type = cc.compiles('''
2616   __int128_t a;
2617   __uint128_t b;
2618   int main(void) { b = a; }''')
2619 config_host_data.set('CONFIG_INT128_TYPE', has_int128_type)
2620
2621 has_int128 = has_int128_type and cc.links('''
2622   __int128_t a;
2623   __uint128_t b;
2624   int main (void) {
2625     a = a + b;
2626     b = a * b;
2627     a = a * a;
2628     return 0;
2629   }''')
2630 config_host_data.set('CONFIG_INT128', has_int128)
2631
2632 if has_int128_type
2633   # "do we have 128-bit atomics which are handled inline and specifically not
2634   # via libatomic". The reason we can't use libatomic is documented in the
2635   # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
2636   # We only care about these operations on 16-byte aligned pointers, so
2637   # force 16-byte alignment of the pointer, which may be greater than
2638   # __alignof(unsigned __int128) for the host.
2639   atomic_test_128 = '''
2640     int main(int ac, char **av) {
2641       __uint128_t *p = __builtin_assume_aligned(av[ac - 1], 16);
2642       p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED);
2643       __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED);
2644       __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2645       return 0;
2646     }'''
2647   has_atomic128 = cc.links(atomic_test_128)
2648
2649   config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
2650
2651   if not has_atomic128
2652     # Even with __builtin_assume_aligned, the above test may have failed
2653     # without optimization enabled.  Try again with optimizations locally
2654     # enabled for the function.  See
2655     #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389
2656     has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128)
2657     config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt)
2658
2659     if not has_atomic128_opt
2660       config_host_data.set('CONFIG_CMPXCHG128', cc.links('''
2661         int main(void)
2662         {
2663           __uint128_t x = 0, y = 0;
2664           __sync_val_compare_and_swap_16(&x, y, x);
2665           return 0;
2666         }
2667       '''))
2668     endif
2669   endif
2670 endif
2671
2672 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
2673   #include <sys/auxv.h>
2674   int main(void) {
2675     return getauxval(AT_HWCAP) == 0;
2676   }'''))
2677
2678 config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles('''
2679   #include <linux/usbdevice_fs.h>
2680
2681   #ifndef USBDEVFS_GET_CAPABILITIES
2682   #error "USBDEVFS_GET_CAPABILITIES undefined"
2683   #endif
2684
2685   #ifndef USBDEVFS_DISCONNECT_CLAIM
2686   #error "USBDEVFS_DISCONNECT_CLAIM undefined"
2687   #endif
2688
2689   int main(void) { return 0; }'''))
2690
2691 have_keyring = get_option('keyring') \
2692   .require(host_os == 'linux', error_message: 'keyring is only available on Linux') \
2693   .require(cc.compiles('''
2694     #include <errno.h>
2695     #include <asm/unistd.h>
2696     #include <linux/keyctl.h>
2697     #include <sys/syscall.h>
2698     #include <unistd.h>
2699     int main(void) {
2700         return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0);
2701     }'''), error_message: 'keyctl syscall not available on this system').allowed()
2702 config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring)
2703
2704 have_cpuid_h = cc.links('''
2705   #include <cpuid.h>
2706   int main(void) {
2707     unsigned a, b, c, d;
2708     unsigned max = __get_cpuid_max(0, 0);
2709
2710     if (max >= 1) {
2711         __cpuid(1, a, b, c, d);
2712     }
2713
2714     if (max >= 7) {
2715         __cpuid_count(7, 0, a, b, c, d);
2716     }
2717
2718     return 0;
2719   }''')
2720 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
2721
2722 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
2723   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
2724   .require(cc.links('''
2725     #include <cpuid.h>
2726     #include <immintrin.h>
2727     static int __attribute__((target("avx2"))) bar(void *a) {
2728       __m256i x = *(__m256i *)a;
2729       return _mm256_testz_si256(x, x);
2730     }
2731     int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2732   '''), error_message: 'AVX2 not available').allowed())
2733
2734 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
2735   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
2736   .require(cc.links('''
2737     #include <cpuid.h>
2738     #include <immintrin.h>
2739     static int __attribute__((target("avx512f"))) bar(void *a) {
2740       __m512i x = *(__m512i *)a;
2741       return _mm512_test_epi64_mask(x, x);
2742     }
2743     int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2744   '''), error_message: 'AVX512F not available').allowed())
2745
2746 config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \
2747   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \
2748   .require(cc.links('''
2749     #include <cpuid.h>
2750     #include <immintrin.h>
2751     static int __attribute__((target("avx512bw"))) bar(void *a) {
2752       __m512i *x = a;
2753       __m512i res= _mm512_abs_epi8(*x);
2754       return res[1];
2755     }
2756     int main(int argc, char *argv[]) { return bar(argv[0]); }
2757   '''), error_message: 'AVX512BW not available').allowed())
2758
2759 # For both AArch64 and AArch32, detect if builtins are available.
2760 config_host_data.set('CONFIG_ARM_AES_BUILTIN', cc.compiles('''
2761     #include <arm_neon.h>
2762     #ifndef __ARM_FEATURE_AES
2763     __attribute__((target("+crypto")))
2764     #endif
2765     void foo(uint8x16_t *p) { *p = vaesmcq_u8(*p); }
2766   '''))
2767
2768 have_pvrdma = get_option('pvrdma') \
2769   .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \
2770   .require(cc.compiles(gnu_source_prefix + '''
2771     #include <sys/mman.h>
2772     int main(void)
2773     {
2774       char buf = 0;
2775       void *addr = &buf;
2776       addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED);
2777
2778       return 0;
2779     }'''), error_message: 'PVRDMA requires mremap').allowed()
2780
2781 if have_pvrdma
2782   config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links('''
2783     #include <infiniband/verbs.h>
2784     int main(void)
2785     {
2786       struct ibv_mr *mr;
2787       struct ibv_pd *pd = NULL;
2788       size_t length = 10;
2789       uint64_t iova = 0;
2790       int access = 0;
2791       void *addr = NULL;
2792
2793       mr = ibv_reg_mr_iova(pd, addr, length, iova, access);
2794       ibv_dereg_mr(mr);
2795       return 0;
2796     }'''))
2797 endif
2798
2799 if get_option('membarrier').disabled()
2800   have_membarrier = false
2801 elif host_os == 'windows'
2802   have_membarrier = true
2803 elif host_os == 'linux'
2804   have_membarrier = cc.compiles('''
2805     #include <linux/membarrier.h>
2806     #include <sys/syscall.h>
2807     #include <unistd.h>
2808     #include <stdlib.h>
2809     int main(void) {
2810         syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
2811         syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
2812         exit(0);
2813     }''')
2814 endif
2815 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
2816   .require(have_membarrier, error_message: 'membarrier system call not available') \
2817   .allowed())
2818
2819 have_afalg = get_option('crypto_afalg') \
2820   .require(cc.compiles(gnu_source_prefix + '''
2821     #include <errno.h>
2822     #include <sys/types.h>
2823     #include <sys/socket.h>
2824     #include <linux/if_alg.h>
2825     int main(void) {
2826       int sock;
2827       sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
2828       return sock;
2829     }
2830   '''), error_message: 'AF_ALG requested but could not be detected').allowed()
2831 config_host_data.set('CONFIG_AF_ALG', have_afalg)
2832
2833 config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
2834   'linux/vm_sockets.h', 'AF_VSOCK',
2835   prefix: '#include <sys/socket.h>',
2836 ))
2837
2838 have_vss = false
2839 have_vss_sdk = false # old xp/2003 SDK
2840 if host_os == 'windows' and 'cpp' in all_languages
2841   have_vss = cxx.compiles('''
2842     #define __MIDL_user_allocate_free_DEFINED__
2843     #include <vss.h>
2844     int main(void) { return VSS_CTX_BACKUP; }''')
2845   have_vss_sdk = cxx.has_header('vscoordint.h')
2846 endif
2847 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2848
2849 # Older versions of MinGW do not import _lock_file and _unlock_file properly.
2850 # This was fixed for v6.0.0 with commit b48e3ac8969d.
2851 if host_os == 'windows'
2852   config_host_data.set('HAVE__LOCK_FILE', cc.links('''
2853     #include <stdio.h>
2854     int main(void) {
2855       _lock_file(NULL);
2856       _unlock_file(NULL);
2857       return 0;
2858     }''', name: '_lock_file and _unlock_file'))
2859 endif
2860
2861 if host_os == 'windows'
2862   mingw_has_setjmp_longjmp = cc.links('''
2863     #include <setjmp.h>
2864     int main(void) {
2865       /*
2866        * These functions are not available in setjmp header, but may be
2867        * available at link time, from libmingwex.a.
2868        */
2869       extern int __mingw_setjmp(jmp_buf);
2870       extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int);
2871       jmp_buf env;
2872       __mingw_setjmp(env);
2873       __mingw_longjmp(env, 0);
2874     }
2875   ''', name: 'mingw setjmp and longjmp')
2876
2877   if cpu == 'aarch64' and not mingw_has_setjmp_longjmp
2878     error('mingw must provide setjmp/longjmp for windows-arm64')
2879   endif
2880 endif
2881
2882 ########################
2883 # Target configuration #
2884 ########################
2885
2886 minikconf = find_program('scripts/minikconf.py')
2887
2888 config_all_accel = {}
2889 config_all_devices = {}
2890 config_devices_mak_list = []
2891 config_devices_h = {}
2892 config_target_h = {}
2893 config_target_mak = {}
2894
2895 disassemblers = {
2896   'alpha' : ['CONFIG_ALPHA_DIS'],
2897   'avr' : ['CONFIG_AVR_DIS'],
2898   'cris' : ['CONFIG_CRIS_DIS'],
2899   'hexagon' : ['CONFIG_HEXAGON_DIS'],
2900   'hppa' : ['CONFIG_HPPA_DIS'],
2901   'i386' : ['CONFIG_I386_DIS'],
2902   'x86_64' : ['CONFIG_I386_DIS'],
2903   'm68k' : ['CONFIG_M68K_DIS'],
2904   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2905   'mips' : ['CONFIG_MIPS_DIS'],
2906   'nios2' : ['CONFIG_NIOS2_DIS'],
2907   'or1k' : ['CONFIG_OPENRISC_DIS'],
2908   'ppc' : ['CONFIG_PPC_DIS'],
2909   'riscv' : ['CONFIG_RISCV_DIS'],
2910   'rx' : ['CONFIG_RX_DIS'],
2911   's390' : ['CONFIG_S390_DIS'],
2912   'sh4' : ['CONFIG_SH4_DIS'],
2913   'sparc' : ['CONFIG_SPARC_DIS'],
2914   'xtensa' : ['CONFIG_XTENSA_DIS'],
2915   'loongarch' : ['CONFIG_LOONGARCH_DIS'],
2916 }
2917
2918 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2919 host_kconfig = \
2920   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2921   (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2922   (pixman.found() ? ['CONFIG_PIXMAN=y'] : []) + \
2923   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2924   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2925   (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
2926   (x11.found() ? ['CONFIG_X11=y'] : []) + \
2927   (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
2928   (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2929   (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2930   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2931   (host_os == 'linux' ? ['CONFIG_LINUX=y'] : []) + \
2932   (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
2933   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
2934   (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : []) + \
2935   (hv_balloon ? ['CONFIG_HV_BALLOON_POSSIBLE=y'] : [])
2936
2937 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2938
2939 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2940 actual_target_dirs = []
2941 fdt_required = []
2942 foreach target : target_dirs
2943   config_target = { 'TARGET_NAME': target.split('-')[0] }
2944   if target.endswith('linux-user')
2945     if host_os != 'linux'
2946       if default_targets
2947         continue
2948       endif
2949       error('Target @0@ is only available on a Linux host'.format(target))
2950     endif
2951     config_target += { 'CONFIG_LINUX_USER': 'y' }
2952   elif target.endswith('bsd-user')
2953     if host_os not in bsd_oses
2954       if default_targets
2955         continue
2956       endif
2957       error('Target @0@ is only available on a BSD host'.format(target))
2958     endif
2959     config_target += { 'CONFIG_BSD_USER': 'y' }
2960   elif target.endswith('softmmu')
2961     config_target += { 'CONFIG_SYSTEM_ONLY': 'y' }
2962     config_target += { 'CONFIG_SOFTMMU': 'y' }
2963   endif
2964   if target.endswith('-user')
2965     config_target += {
2966       'CONFIG_USER_ONLY': 'y',
2967       'CONFIG_QEMU_INTERP_PREFIX':
2968         get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
2969     }
2970   endif
2971
2972   accel_kconfig = []
2973   foreach sym: accelerators
2974     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2975       config_target += { sym: 'y' }
2976       config_all_accel += { sym: 'y' }
2977       if target in modular_tcg
2978         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2979       else
2980         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2981       endif
2982       accel_kconfig += [ sym + '=y' ]
2983     endif
2984   endforeach
2985   if accel_kconfig.length() == 0
2986     if default_targets
2987       continue
2988     endif
2989     error('No accelerator available for target @0@'.format(target))
2990   endif
2991
2992   actual_target_dirs += target
2993   config_target += keyval.load('configs/targets' / target + '.mak')
2994   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2995
2996   if 'TARGET_NEED_FDT' in config_target
2997     fdt_required += target
2998   endif
2999
3000   # Add default keys
3001   if 'TARGET_BASE_ARCH' not in config_target
3002     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
3003   endif
3004   if 'TARGET_ABI_DIR' not in config_target
3005     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
3006   endif
3007   if 'TARGET_BIG_ENDIAN' not in config_target
3008     config_target += {'TARGET_BIG_ENDIAN': 'n'}
3009   endif
3010
3011   foreach k, v: disassemblers
3012     if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
3013       foreach sym: v
3014         config_target += { sym: 'y' }
3015       endforeach
3016     endif
3017   endforeach
3018
3019   config_target_data = configuration_data()
3020   foreach k, v: config_target
3021     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
3022       # do nothing
3023     elif ignored.contains(k)
3024       # do nothing
3025     elif k == 'TARGET_BASE_ARCH'
3026       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
3027       # not used to select files from sourcesets.
3028       config_target_data.set('TARGET_' + v.to_upper(), 1)
3029     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
3030       config_target_data.set_quoted(k, v)
3031     elif v == 'y'
3032       config_target_data.set(k, 1)
3033     elif v == 'n'
3034       config_target_data.set(k, 0)
3035     else
3036       config_target_data.set(k, v)
3037     endif
3038   endforeach
3039   config_target_data.set('QEMU_ARCH',
3040                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
3041   config_target_h += {target: configure_file(output: target + '-config-target.h',
3042                                                configuration: config_target_data)}
3043
3044   if target.endswith('-softmmu')
3045     config_input = meson.get_external_property(target, 'default')
3046     config_devices_mak = target + '-config-devices.mak'
3047     config_devices_mak = configure_file(
3048       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
3049       output: config_devices_mak,
3050       depfile: config_devices_mak + '.d',
3051       capture: true,
3052       command: [minikconf,
3053                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
3054                 config_devices_mak, '@DEPFILE@', '@INPUT@',
3055                 host_kconfig, accel_kconfig,
3056                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
3057
3058     config_devices_data = configuration_data()
3059     config_devices = keyval.load(config_devices_mak)
3060     foreach k, v: config_devices
3061       config_devices_data.set(k, 1)
3062     endforeach
3063     config_devices_mak_list += config_devices_mak
3064     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
3065                                                 configuration: config_devices_data)}
3066     config_target += config_devices
3067     config_all_devices += config_devices
3068   endif
3069   config_target_mak += {target: config_target}
3070 endforeach
3071 target_dirs = actual_target_dirs
3072
3073 target_configs_h = []
3074 foreach target: target_dirs
3075   target_configs_h += config_target_h[target]
3076   target_configs_h += config_devices_h.get(target, [])
3077 endforeach
3078 genh += custom_target('config-poison.h',
3079                       input: [target_configs_h],
3080                       output: 'config-poison.h',
3081                       capture: true,
3082                       command: [find_program('scripts/make-config-poison.sh'),
3083                                 target_configs_h])
3084
3085 ###############
3086 # Subprojects #
3087 ###############
3088
3089 libvfio_user_dep = not_found
3090 if have_system and vfio_user_server_allowed
3091   libvfio_user_proj = subproject('libvfio-user', required: true)
3092   libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep')
3093 endif
3094
3095 fdt = not_found
3096 fdt_opt = get_option('fdt')
3097 if fdt_required.length() > 0 or fdt_opt == 'enabled'
3098   if fdt_opt == 'disabled'
3099     error('fdt disabled but required by targets ' + ', '.join(fdt_required))
3100   endif
3101
3102   if fdt_opt in ['enabled', 'auto', 'system']
3103     if get_option('wrap_mode') == 'nodownload'
3104       fdt_opt = 'system'
3105     endif
3106     fdt = cc.find_library('fdt', required: fdt_opt == 'system')
3107     if fdt.found() and cc.links('''
3108        #include <libfdt.h>
3109        #include <libfdt_env.h>
3110        int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
3111          dependencies: fdt)
3112       fdt_opt = 'system'
3113     elif fdt_opt == 'system'
3114        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
3115     else
3116       fdt_opt = 'internal'
3117       fdt = not_found
3118     endif
3119   endif
3120   if not fdt.found()
3121     assert(fdt_opt == 'internal')
3122     libfdt_proj = subproject('dtc', required: true,
3123                              default_options: ['tools=false',  'yaml=disabled',
3124                                                'python=disabled', 'default_library=static'])
3125     fdt = libfdt_proj.get_variable('libfdt_dep')
3126   endif
3127 else
3128   fdt_opt = 'disabled'
3129 endif
3130
3131 config_host_data.set('CONFIG_FDT', fdt.found())
3132
3133 vhost_user = not_found
3134 if host_os == 'linux' and have_vhost_user
3135   libvhost_user = subproject('libvhost-user')
3136   vhost_user = libvhost_user.get_variable('vhost_user_dep')
3137 endif
3138
3139 libvduse = not_found
3140 if have_libvduse
3141   libvduse_proj = subproject('libvduse')
3142   libvduse = libvduse_proj.get_variable('libvduse_dep')
3143 endif
3144
3145 #####################
3146 # Generated sources #
3147 #####################
3148
3149 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
3150
3151 hxtool = find_program('scripts/hxtool')
3152 shaderinclude = find_program('scripts/shaderinclude.py')
3153 qapi_gen = find_program('scripts/qapi-gen.py')
3154 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
3155                      meson.current_source_dir() / 'scripts/qapi/commands.py',
3156                      meson.current_source_dir() / 'scripts/qapi/common.py',
3157                      meson.current_source_dir() / 'scripts/qapi/error.py',
3158                      meson.current_source_dir() / 'scripts/qapi/events.py',
3159                      meson.current_source_dir() / 'scripts/qapi/expr.py',
3160                      meson.current_source_dir() / 'scripts/qapi/gen.py',
3161                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
3162                      meson.current_source_dir() / 'scripts/qapi/main.py',
3163                      meson.current_source_dir() / 'scripts/qapi/parser.py',
3164                      meson.current_source_dir() / 'scripts/qapi/schema.py',
3165                      meson.current_source_dir() / 'scripts/qapi/source.py',
3166                      meson.current_source_dir() / 'scripts/qapi/types.py',
3167                      meson.current_source_dir() / 'scripts/qapi/visit.py',
3168                      meson.current_source_dir() / 'scripts/qapi-gen.py'
3169 ]
3170
3171 tracetool = [
3172   python, files('scripts/tracetool.py'),
3173    '--backend=' + ','.join(get_option('trace_backends'))
3174 ]
3175 tracetool_depends = files(
3176   'scripts/tracetool/backend/log.py',
3177   'scripts/tracetool/backend/__init__.py',
3178   'scripts/tracetool/backend/dtrace.py',
3179   'scripts/tracetool/backend/ftrace.py',
3180   'scripts/tracetool/backend/simple.py',
3181   'scripts/tracetool/backend/syslog.py',
3182   'scripts/tracetool/backend/ust.py',
3183   'scripts/tracetool/format/ust_events_c.py',
3184   'scripts/tracetool/format/ust_events_h.py',
3185   'scripts/tracetool/format/__init__.py',
3186   'scripts/tracetool/format/d.py',
3187   'scripts/tracetool/format/simpletrace_stap.py',
3188   'scripts/tracetool/format/c.py',
3189   'scripts/tracetool/format/h.py',
3190   'scripts/tracetool/format/log_stap.py',
3191   'scripts/tracetool/format/stap.py',
3192   'scripts/tracetool/__init__.py',
3193   'scripts/tracetool/vcpu.py'
3194 )
3195
3196 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
3197                     meson.current_source_dir(),
3198                     get_option('pkgversion'), meson.project_version()]
3199 qemu_version = custom_target('qemu-version.h',
3200                              output: 'qemu-version.h',
3201                              command: qemu_version_cmd,
3202                              capture: true,
3203                              build_by_default: true,
3204                              build_always_stale: true)
3205 genh += qemu_version
3206
3207 hxdep = []
3208 hx_headers = [
3209   ['qemu-options.hx', 'qemu-options.def'],
3210   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
3211 ]
3212 if have_system
3213   hx_headers += [
3214     ['hmp-commands.hx', 'hmp-commands.h'],
3215     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
3216   ]
3217 endif
3218 foreach d : hx_headers
3219   hxdep += custom_target(d[1],
3220                 input: files(d[0]),
3221                 output: d[1],
3222                 capture: true,
3223                 command: [hxtool, '-h', '@INPUT0@'])
3224 endforeach
3225 genh += hxdep
3226
3227 ###############
3228 # Trace files #
3229 ###############
3230
3231 # TODO: add each directory to the subdirs from its own meson.build, once
3232 # we have those
3233 trace_events_subdirs = [
3234   'crypto',
3235   'qapi',
3236   'qom',
3237   'monitor',
3238   'util',
3239   'gdbstub',
3240 ]
3241 if have_linux_user
3242   trace_events_subdirs += [ 'linux-user' ]
3243 endif
3244 if have_bsd_user
3245   trace_events_subdirs += [ 'bsd-user' ]
3246 endif
3247 if have_block
3248   trace_events_subdirs += [
3249     'authz',
3250     'block',
3251     'io',
3252     'nbd',
3253     'scsi',
3254   ]
3255 endif
3256 if have_system
3257   trace_events_subdirs += [
3258     'accel/kvm',
3259     'audio',
3260     'backends',
3261     'backends/tpm',
3262     'chardev',
3263     'ebpf',
3264     'hw/9pfs',
3265     'hw/acpi',
3266     'hw/adc',
3267     'hw/alpha',
3268     'hw/arm',
3269     'hw/audio',
3270     'hw/block',
3271     'hw/block/dataplane',
3272     'hw/char',
3273     'hw/display',
3274     'hw/dma',
3275     'hw/hyperv',
3276     'hw/i2c',
3277     'hw/i386',
3278     'hw/i386/xen',
3279     'hw/i386/kvm',
3280     'hw/ide',
3281     'hw/input',
3282     'hw/intc',
3283     'hw/isa',
3284     'hw/mem',
3285     'hw/mips',
3286     'hw/misc',
3287     'hw/misc/macio',
3288     'hw/net',
3289     'hw/net/can',
3290     'hw/nubus',
3291     'hw/nvme',
3292     'hw/nvram',
3293     'hw/pci',
3294     'hw/pci-host',
3295     'hw/ppc',
3296     'hw/rdma',
3297     'hw/rdma/vmw',
3298     'hw/rtc',
3299     'hw/s390x',
3300     'hw/scsi',
3301     'hw/sd',
3302     'hw/sh4',
3303     'hw/sparc',
3304     'hw/sparc64',
3305     'hw/ssi',
3306     'hw/timer',
3307     'hw/tpm',
3308     'hw/ufs',
3309     'hw/usb',
3310     'hw/vfio',
3311     'hw/virtio',
3312     'hw/watchdog',
3313     'hw/xen',
3314     'hw/gpio',
3315     'migration',
3316     'net',
3317     'system',
3318     'ui',
3319     'hw/remote',
3320   ]
3321 endif
3322 if have_system or have_user
3323   trace_events_subdirs += [
3324     'accel/tcg',
3325     'hw/core',
3326     'target/arm',
3327     'target/arm/hvf',
3328     'target/hppa',
3329     'target/i386',
3330     'target/i386/kvm',
3331     'target/mips/tcg',
3332     'target/nios2',
3333     'target/ppc',
3334     'target/riscv',
3335     'target/s390x',
3336     'target/s390x/kvm',
3337     'target/sparc',
3338   ]
3339 endif
3340
3341 ###################
3342 # Collect sources #
3343 ###################
3344
3345 authz_ss = ss.source_set()
3346 blockdev_ss = ss.source_set()
3347 block_ss = ss.source_set()
3348 chardev_ss = ss.source_set()
3349 common_ss = ss.source_set()
3350 crypto_ss = ss.source_set()
3351 hwcore_ss = ss.source_set()
3352 io_ss = ss.source_set()
3353 qmp_ss = ss.source_set()
3354 qom_ss = ss.source_set()
3355 system_ss = ss.source_set()
3356 specific_fuzz_ss = ss.source_set()
3357 specific_ss = ss.source_set()
3358 stub_ss = ss.source_set()
3359 trace_ss = ss.source_set()
3360 user_ss = ss.source_set()
3361 util_ss = ss.source_set()
3362
3363 # accel modules
3364 qtest_module_ss = ss.source_set()
3365 tcg_module_ss = ss.source_set()
3366
3367 modules = {}
3368 target_modules = {}
3369 hw_arch = {}
3370 target_arch = {}
3371 target_system_arch = {}
3372 target_user_arch = {}
3373
3374 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3375 # that is filled in by qapi/.
3376 subdir('qapi')
3377 subdir('qobject')
3378 subdir('stubs')
3379 subdir('trace')
3380 subdir('util')
3381 subdir('qom')
3382 subdir('authz')
3383 subdir('crypto')
3384 subdir('ui')
3385 subdir('hw')
3386 subdir('gdbstub')
3387
3388 if enable_modules
3389   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3390   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3391 endif
3392
3393 qom_ss = qom_ss.apply({})
3394 libqom = static_library('qom', qom_ss.sources() + genh,
3395                         dependencies: [qom_ss.dependencies()],
3396                         name_suffix: 'fa',
3397                         build_by_default: false)
3398 qom = declare_dependency(link_whole: libqom)
3399
3400 event_loop_base = files('event-loop-base.c')
3401 event_loop_base = static_library('event-loop-base',
3402                                  sources: event_loop_base + genh,
3403                                  name_suffix: 'fa',
3404                                  build_by_default: false)
3405 event_loop_base = declare_dependency(link_whole: event_loop_base,
3406                                      dependencies: [qom])
3407
3408 stub_ss = stub_ss.apply({})
3409
3410 util_ss.add_all(trace_ss)
3411 util_ss = util_ss.apply({})
3412 libqemuutil = static_library('qemuutil',
3413                              build_by_default: false,
3414                              sources: util_ss.sources() + stub_ss.sources() + genh,
3415                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3416 qemuutil = declare_dependency(link_with: libqemuutil,
3417                               sources: genh + version_res,
3418                               dependencies: [event_loop_base])
3419
3420 if have_system or have_user
3421   decodetree = generator(find_program('scripts/decodetree.py'),
3422                          output: 'decode-@BASENAME@.c.inc',
3423                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3424   subdir('libdecnumber')
3425   subdir('target')
3426 endif
3427
3428 subdir('audio')
3429 subdir('io')
3430 subdir('chardev')
3431 subdir('fsdev')
3432 subdir('dump')
3433
3434 if have_block
3435   block_ss.add(files(
3436     'block.c',
3437     'blockjob.c',
3438     'job.c',
3439     'qemu-io-cmds.c',
3440   ))
3441   if config_host_data.get('CONFIG_REPLICATION')
3442     block_ss.add(files('replication.c'))
3443   endif
3444
3445   subdir('nbd')
3446   subdir('scsi')
3447   subdir('block')
3448
3449   blockdev_ss.add(files(
3450     'blockdev.c',
3451     'blockdev-nbd.c',
3452     'iothread.c',
3453     'job-qmp.c',
3454   ), gnutls)
3455
3456   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3457   # os-win32.c does not
3458   if host_os == 'windows'
3459     system_ss.add(files('os-win32.c'))
3460   else
3461     blockdev_ss.add(files('os-posix.c'))
3462   endif
3463 endif
3464
3465 common_ss.add(files('cpu-common.c'))
3466 specific_ss.add(files('cpu-target.c'))
3467
3468 subdir('system')
3469
3470 # Work around a gcc bug/misfeature wherein constant propagation looks
3471 # through an alias:
3472 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3473 # to guess that a const variable is always zero.  Without lto, this is
3474 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
3475 # without lto, not even the alias is required -- we simply use different
3476 # declarations in different compilation units.
3477 pagevary = files('page-vary-common.c')
3478 if get_option('b_lto')
3479   pagevary_flags = ['-fno-lto']
3480   if get_option('cfi')
3481     pagevary_flags += '-fno-sanitize=cfi-icall'
3482   endif
3483   pagevary = static_library('page-vary-common', sources: pagevary + genh,
3484                             c_args: pagevary_flags)
3485   pagevary = declare_dependency(link_with: pagevary)
3486 endif
3487 common_ss.add(pagevary)
3488 specific_ss.add(files('page-vary-target.c'))
3489
3490 subdir('backends')
3491 subdir('disas')
3492 subdir('migration')
3493 subdir('monitor')
3494 subdir('net')
3495 subdir('replay')
3496 subdir('semihosting')
3497 subdir('stats')
3498 subdir('tcg')
3499 subdir('fpu')
3500 subdir('accel')
3501 subdir('plugins')
3502 subdir('ebpf')
3503
3504 common_user_inc = []
3505
3506 subdir('common-user')
3507 subdir('bsd-user')
3508 subdir('linux-user')
3509
3510 # needed for fuzzing binaries
3511 subdir('tests/qtest/libqos')
3512 subdir('tests/qtest/fuzz')
3513
3514 # accel modules
3515 tcg_real_module_ss = ss.source_set()
3516 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3517 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3518 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3519                                 'tcg': tcg_real_module_ss }}
3520
3521 ##############################################
3522 # Internal static_libraries and dependencies #
3523 ##############################################
3524
3525 modinfo_collect = find_program('scripts/modinfo-collect.py')
3526 modinfo_generate = find_program('scripts/modinfo-generate.py')
3527 modinfo_files = []
3528
3529 block_mods = []
3530 system_mods = []
3531 foreach d, list : modules
3532   if not (d == 'block' ? have_block : have_system)
3533     continue
3534   endif
3535
3536   foreach m, module_ss : list
3537     if enable_modules
3538       module_ss = module_ss.apply(config_all_devices, strict: false)
3539       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3540                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3541       if d == 'block'
3542         block_mods += sl
3543       else
3544         system_mods += sl
3545       endif
3546       if module_ss.sources() != []
3547         # FIXME: Should use sl.extract_all_objects(recursive: true) as
3548         # input. Sources can be used multiple times but objects are
3549         # unique when it comes to lookup in compile_commands.json.
3550         # Depnds on a mesion version with
3551         # https://github.com/mesonbuild/meson/pull/8900
3552         modinfo_files += custom_target(d + '-' + m + '.modinfo',
3553                                        output: d + '-' + m + '.modinfo',
3554                                        input: module_ss.sources() + genh,
3555                                        capture: true,
3556                                        command: [modinfo_collect, module_ss.sources()])
3557       endif
3558     else
3559       if d == 'block'
3560         block_ss.add_all(module_ss)
3561       else
3562         system_ss.add_all(module_ss)
3563       endif
3564     endif
3565   endforeach
3566 endforeach
3567
3568 foreach d, list : target_modules
3569   foreach m, module_ss : list
3570     if enable_modules
3571       foreach target : target_dirs
3572         if target.endswith('-softmmu')
3573           config_target = config_target_mak[target]
3574           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3575           c_args = ['-DNEED_CPU_H',
3576                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3577                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3578           target_module_ss = module_ss.apply(config_target, strict: false)
3579           if target_module_ss.sources() != []
3580             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3581             sl = static_library(module_name,
3582                                 [genh, target_module_ss.sources()],
3583                                 dependencies: [modulecommon, target_module_ss.dependencies()],
3584                                 include_directories: target_inc,
3585                                 c_args: c_args,
3586                                 pic: true)
3587             system_mods += sl
3588             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3589             modinfo_files += custom_target(module_name + '.modinfo',
3590                                            output: module_name + '.modinfo',
3591                                            input: target_module_ss.sources() + genh,
3592                                            capture: true,
3593                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3594           endif
3595         endif
3596       endforeach
3597     else
3598       specific_ss.add_all(module_ss)
3599     endif
3600   endforeach
3601 endforeach
3602
3603 if enable_modules
3604   foreach target : target_dirs
3605     if target.endswith('-softmmu')
3606       config_target = config_target_mak[target]
3607       config_devices_mak = target + '-config-devices.mak'
3608       modinfo_src = custom_target('modinfo-' + target + '.c',
3609                                   output: 'modinfo-' + target + '.c',
3610                                   input: modinfo_files,
3611                                   command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3612                                   capture: true)
3613
3614       modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3615       modinfo_dep = declare_dependency(link_with: modinfo_lib)
3616
3617       arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3618       hw_arch[arch].add(modinfo_dep)
3619     endif
3620   endforeach
3621 endif
3622
3623 nm = find_program('nm')
3624 undefsym = find_program('scripts/undefsym.py')
3625 block_syms = custom_target('block.syms', output: 'block.syms',
3626                              input: [libqemuutil, block_mods],
3627                              capture: true,
3628                              command: [undefsym, nm, '@INPUT@'])
3629 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3630                              input: [libqemuutil, system_mods],
3631                              capture: true,
3632                              command: [undefsym, nm, '@INPUT@'])
3633
3634 authz_ss = authz_ss.apply({})
3635 libauthz = static_library('authz', authz_ss.sources() + genh,
3636                           dependencies: [authz_ss.dependencies()],
3637                           name_suffix: 'fa',
3638                           build_by_default: false)
3639
3640 authz = declare_dependency(link_whole: libauthz,
3641                            dependencies: qom)
3642
3643 crypto_ss = crypto_ss.apply({})
3644 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3645                            dependencies: [crypto_ss.dependencies()],
3646                            name_suffix: 'fa',
3647                            build_by_default: false)
3648
3649 crypto = declare_dependency(link_whole: libcrypto,
3650                             dependencies: [authz, qom])
3651
3652 io_ss = io_ss.apply({})
3653 libio = static_library('io', io_ss.sources() + genh,
3654                        dependencies: [io_ss.dependencies()],
3655                        link_with: libqemuutil,
3656                        name_suffix: 'fa',
3657                        build_by_default: false)
3658
3659 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3660
3661 libmigration = static_library('migration', sources: migration_files + genh,
3662                               name_suffix: 'fa',
3663                               build_by_default: false)
3664 migration = declare_dependency(link_with: libmigration,
3665                                dependencies: [zlib, qom, io])
3666 system_ss.add(migration)
3667
3668 block_ss = block_ss.apply({})
3669 libblock = static_library('block', block_ss.sources() + genh,
3670                           dependencies: block_ss.dependencies(),
3671                           link_depends: block_syms,
3672                           name_suffix: 'fa',
3673                           build_by_default: false)
3674
3675 block = declare_dependency(link_whole: [libblock],
3676                            link_args: '@block.syms',
3677                            dependencies: [crypto, io])
3678
3679 blockdev_ss = blockdev_ss.apply({})
3680 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3681                              dependencies: blockdev_ss.dependencies(),
3682                              name_suffix: 'fa',
3683                              build_by_default: false)
3684
3685 blockdev = declare_dependency(link_whole: [libblockdev],
3686                               dependencies: [block, event_loop_base])
3687
3688 qmp_ss = qmp_ss.apply({})
3689 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3690                         dependencies: qmp_ss.dependencies(),
3691                         name_suffix: 'fa',
3692                         build_by_default: false)
3693
3694 qmp = declare_dependency(link_whole: [libqmp])
3695
3696 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3697                             name_suffix: 'fa',
3698                             dependencies: chardev_ss.dependencies(),
3699                             build_by_default: false)
3700
3701 chardev = declare_dependency(link_whole: libchardev)
3702
3703 hwcore_ss = hwcore_ss.apply({})
3704 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3705                            name_suffix: 'fa',
3706                            build_by_default: false)
3707 hwcore = declare_dependency(link_whole: libhwcore)
3708 common_ss.add(hwcore)
3709
3710 ###########
3711 # Targets #
3712 ###########
3713
3714 emulator_modules = []
3715 foreach m : block_mods + system_mods
3716   emulator_modules += shared_module(m.name(),
3717                 build_by_default: true,
3718                 name_prefix: '',
3719                 link_whole: m,
3720                 install: true,
3721                 install_dir: qemu_moddir)
3722 endforeach
3723 if emulator_modules.length() > 0
3724   alias_target('modules', emulator_modules)
3725 endif
3726
3727 system_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3728 common_ss.add(qom, qemuutil)
3729
3730 common_ss.add_all(when: 'CONFIG_SYSTEM_ONLY', if_true: [system_ss])
3731 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3732
3733 # Note that this library is never used directly (only through extract_objects)
3734 # and is not built by default; therefore, source files not used by the build
3735 # configuration will be in build.ninja, but are never built by default.
3736 common_all = static_library('common',
3737                             build_by_default: false,
3738                             sources: common_ss.all_sources() + genh,
3739                             include_directories: common_user_inc,
3740                             implicit_include_directories: false,
3741                             dependencies: common_ss.all_dependencies(),
3742                             name_suffix: 'fa')
3743
3744 feature_to_c = find_program('scripts/feature_to_c.py')
3745
3746 if host_os == 'darwin'
3747   entitlement = find_program('scripts/entitlement.sh')
3748 endif
3749
3750 emulators = {}
3751 foreach target : target_dirs
3752   config_target = config_target_mak[target]
3753   target_name = config_target['TARGET_NAME']
3754   target_base_arch = config_target['TARGET_BASE_ARCH']
3755   arch_srcs = [config_target_h[target]]
3756   arch_deps = []
3757   c_args = ['-DNEED_CPU_H',
3758             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3759             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3760   link_args = emulator_link_args
3761
3762   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3763   if host_os == 'linux'
3764     target_inc += include_directories('linux-headers', is_system: true)
3765   endif
3766   if target.endswith('-softmmu')
3767     target_type='system'
3768     t = target_system_arch[target_base_arch].apply(config_target, strict: false)
3769     arch_srcs += t.sources()
3770     arch_deps += t.dependencies()
3771
3772     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3773     if hw_arch.has_key(hw_dir)
3774       hw = hw_arch[hw_dir].apply(config_target, strict: false)
3775       arch_srcs += hw.sources()
3776       arch_deps += hw.dependencies()
3777     endif
3778
3779     arch_srcs += config_devices_h[target]
3780     link_args += ['@block.syms', '@qemu.syms']
3781   else
3782     abi = config_target['TARGET_ABI_DIR']
3783     target_type='user'
3784     target_inc += common_user_inc
3785     if target_base_arch in target_user_arch
3786       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3787       arch_srcs += t.sources()
3788       arch_deps += t.dependencies()
3789     endif
3790     if 'CONFIG_LINUX_USER' in config_target
3791       base_dir = 'linux-user'
3792     endif
3793     if 'CONFIG_BSD_USER' in config_target
3794       base_dir = 'bsd-user'
3795       target_inc += include_directories('bsd-user/' / host_os)
3796       target_inc += include_directories('bsd-user/host/' / host_arch)
3797       dir = base_dir / abi
3798       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3799     endif
3800     target_inc += include_directories(
3801       base_dir,
3802       base_dir / abi,
3803     )
3804     if 'CONFIG_LINUX_USER' in config_target
3805       dir = base_dir / abi
3806       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3807       if config_target.has_key('TARGET_SYSTBL_ABI')
3808         arch_srcs += \
3809           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3810                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3811       endif
3812     endif
3813   endif
3814
3815   if 'TARGET_XML_FILES' in config_target
3816     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3817                                 output: target + '-gdbstub-xml.c',
3818                                 input: files(config_target['TARGET_XML_FILES'].split()),
3819                                 command: [feature_to_c, '@INPUT@'],
3820                                 capture: true)
3821     arch_srcs += gdbstub_xml
3822   endif
3823
3824   t = target_arch[target_base_arch].apply(config_target, strict: false)
3825   arch_srcs += t.sources()
3826   arch_deps += t.dependencies()
3827
3828   target_common = common_ss.apply(config_target, strict: false)
3829   objects = common_all.extract_objects(target_common.sources())
3830   deps = target_common.dependencies()
3831
3832   target_specific = specific_ss.apply(config_target, strict: false)
3833   arch_srcs += target_specific.sources()
3834   arch_deps += target_specific.dependencies()
3835
3836   lib = static_library('qemu-' + target,
3837                  sources: arch_srcs + genh,
3838                  dependencies: arch_deps,
3839                  objects: objects,
3840                  include_directories: target_inc,
3841                  c_args: c_args,
3842                  build_by_default: false,
3843                  name_suffix: 'fa')
3844
3845   if target.endswith('-softmmu')
3846     execs = [{
3847       'name': 'qemu-system-' + target_name,
3848       'win_subsystem': 'console',
3849       'sources': files('system/main.c'),
3850       'dependencies': []
3851     }]
3852     if host_os == 'windows' and (sdl.found() or gtk.found())
3853       execs += [{
3854         'name': 'qemu-system-' + target_name + 'w',
3855         'win_subsystem': 'windows',
3856         'sources': files('system/main.c'),
3857         'dependencies': []
3858       }]
3859     endif
3860     if get_option('fuzzing')
3861       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3862       execs += [{
3863         'name': 'qemu-fuzz-' + target_name,
3864         'win_subsystem': 'console',
3865         'sources': specific_fuzz.sources(),
3866         'dependencies': specific_fuzz.dependencies(),
3867       }]
3868     endif
3869   else
3870     execs = [{
3871       'name': 'qemu-' + target_name,
3872       'win_subsystem': 'console',
3873       'sources': [],
3874       'dependencies': []
3875     }]
3876   endif
3877   foreach exe: execs
3878     exe_name = exe['name']
3879     if host_os == 'darwin'
3880       exe_name += '-unsigned'
3881     endif
3882
3883     emulator = executable(exe_name, exe['sources'],
3884                install: true,
3885                c_args: c_args,
3886                dependencies: arch_deps + deps + exe['dependencies'],
3887                objects: lib.extract_all_objects(recursive: true),
3888                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3889                link_args: link_args,
3890                win_subsystem: exe['win_subsystem'])
3891
3892     if host_os == 'darwin'
3893       icon = 'pc-bios/qemu.rsrc'
3894       build_input = [emulator, files(icon)]
3895       install_input = [
3896         get_option('bindir') / exe_name,
3897         meson.current_source_dir() / icon
3898       ]
3899       if 'CONFIG_HVF' in config_target
3900         entitlements = 'accel/hvf/entitlements.plist'
3901         build_input += files(entitlements)
3902         install_input += meson.current_source_dir() / entitlements
3903       endif
3904
3905       emulators += {exe['name'] : custom_target(exe['name'],
3906                    input: build_input,
3907                    output: exe['name'],
3908                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3909       }
3910
3911       meson.add_install_script(entitlement, '--install',
3912                                get_option('bindir') / exe['name'],
3913                                install_input)
3914     else
3915       emulators += {exe['name']: emulator}
3916     endif
3917
3918     if stap.found()
3919       foreach stp: [
3920         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3921         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3922         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3923         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3924       ]
3925         custom_target(exe['name'] + stp['ext'],
3926                       input: trace_events_all,
3927                       output: exe['name'] + stp['ext'],
3928                       install: stp['install'],
3929                       install_dir: get_option('datadir') / 'systemtap/tapset',
3930                       command: [
3931                         tracetool, '--group=all', '--format=' + stp['fmt'],
3932                         '--binary=' + stp['bin'],
3933                         '--target-name=' + target_name,
3934                         '--target-type=' + target_type,
3935                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3936                         '@INPUT@', '@OUTPUT@'
3937                       ],
3938                       depend_files: tracetool_depends)
3939       endforeach
3940     endif
3941   endforeach
3942 endforeach
3943
3944 # Other build targets
3945
3946 if get_option('plugins')
3947   install_headers('include/qemu/qemu-plugin.h')
3948   if host_os == 'windows'
3949     # On windows, we want to deliver the qemu_plugin_api.lib file in the qemu installer,
3950     # so that plugin authors can compile against it.
3951     install_data(win32_qemu_plugin_api_lib, install_dir: 'lib')
3952   endif
3953 endif
3954
3955 subdir('qga')
3956
3957 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3958 # when we don't build tools or system
3959 if xkbcommon.found()
3960   # used for the update-keymaps target, so include rules even if !have_tools
3961   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3962                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3963 endif
3964
3965 if have_tools
3966   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3967              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3968   qemu_io = executable('qemu-io', files('qemu-io.c'),
3969              dependencies: [block, qemuutil], install: true)
3970   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3971                dependencies: [blockdev, qemuutil, gnutls, selinux],
3972                install: true)
3973
3974   subdir('storage-daemon')
3975   subdir('contrib/rdmacm-mux')
3976   subdir('contrib/elf2dmp')
3977
3978   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3979              dependencies: qemuutil,
3980              install: true)
3981
3982   if have_vhost_user
3983     subdir('contrib/vhost-user-blk')
3984     subdir('contrib/vhost-user-gpu')
3985     subdir('contrib/vhost-user-input')
3986     subdir('contrib/vhost-user-scsi')
3987   endif
3988
3989   if host_os == 'linux'
3990     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3991                dependencies: [qemuutil, libcap_ng],
3992                install: true,
3993                install_dir: get_option('libexecdir'))
3994
3995     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3996                dependencies: [authz, crypto, io, qom, qemuutil,
3997                               libcap_ng, mpathpersist],
3998                install: true)
3999   endif
4000
4001   if have_ivshmem
4002     subdir('contrib/ivshmem-client')
4003     subdir('contrib/ivshmem-server')
4004   endif
4005 endif
4006
4007 subdir('scripts')
4008 subdir('tools')
4009 subdir('pc-bios')
4010 subdir('docs')
4011 subdir('tests')
4012 if gtk.found()
4013   subdir('po')
4014 endif
4015
4016 if host_machine.system() == 'windows'
4017   nsis_cmd = [
4018     find_program('scripts/nsis.py'),
4019     '@OUTPUT@',
4020     get_option('prefix'),
4021     meson.current_source_dir(),
4022     glib_pc.get_variable('bindir'),
4023     host_machine.cpu(),
4024     '--',
4025     '-DDISPLAYVERSION=' + meson.project_version(),
4026   ]
4027   if build_docs
4028     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
4029   endif
4030   if gtk.found()
4031     nsis_cmd += '-DCONFIG_GTK=y'
4032   endif
4033
4034   nsis = custom_target('nsis',
4035                        output: 'qemu-setup-' + meson.project_version() + '.exe',
4036                        input: files('qemu.nsi'),
4037                        build_always_stale: true,
4038                        command: nsis_cmd + ['@INPUT@'])
4039   alias_target('installer', nsis)
4040 endif
4041
4042 #########################
4043 # Configuration summary #
4044 #########################
4045
4046 # Build environment
4047 summary_info = {}
4048 summary_info += {'Build directory':   meson.current_build_dir()}
4049 summary_info += {'Source path':       meson.current_source_dir()}
4050 summary_info += {'Download dependencies': get_option('wrap_mode') != 'nodownload'}
4051 summary(summary_info, bool_yn: true, section: 'Build environment')
4052
4053 # Directories
4054 summary_info += {'Install prefix':    get_option('prefix')}
4055 summary_info += {'BIOS directory':    qemu_datadir}
4056 pathsep = host_os == 'windows' ? ';' : ':'
4057 summary_info += {'firmware path':     pathsep.join(get_option('qemu_firmwarepath'))}
4058 summary_info += {'binary directory':  get_option('prefix') / get_option('bindir')}
4059 summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
4060 summary_info += {'module directory':  qemu_moddir}
4061 summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
4062 summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
4063 summary_info += {'config directory':  get_option('prefix') / get_option('sysconfdir')}
4064 if host_os != 'windows'
4065   summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
4066   summary_info += {'Manual directory':      get_option('prefix') / get_option('mandir')}
4067 else
4068   summary_info += {'local state directory': 'queried at runtime'}
4069 endif
4070 summary_info += {'Doc directory':     get_option('prefix') / get_option('docdir')}
4071 summary(summary_info, bool_yn: true, section: 'Directories')
4072
4073 # Host binaries
4074 summary_info = {}
4075 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
4076 summary_info += {'sphinx-build':      sphinx_build}
4077
4078 # FIXME: the [binaries] section of machine files, which can be probed
4079 # with find_program(), would be great for passing gdb and genisoimage
4080 # paths from configure to Meson.  However, there seems to be no way to
4081 # hide a program (for example if gdb is too old).
4082 if config_host.has_key('GDB')
4083   summary_info += {'gdb':             config_host['GDB']}
4084 endif
4085 summary_info += {'iasl':              iasl}
4086 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
4087 if host_os == 'windows' and have_ga
4088   summary_info += {'wixl':            wixl}
4089 endif
4090 if slirp.found() and have_system
4091   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
4092 endif
4093 summary(summary_info, bool_yn: true, section: 'Host binaries')
4094
4095 # Configurable features
4096 summary_info = {}
4097 summary_info += {'Documentation':     build_docs}
4098 summary_info += {'system-mode emulation': have_system}
4099 summary_info += {'user-mode emulation': have_user}
4100 summary_info += {'block layer':       have_block}
4101 summary_info += {'Install blobs':     get_option('install_blobs')}
4102 summary_info += {'module support':    enable_modules}
4103 if enable_modules
4104   summary_info += {'alternative module path': get_option('module_upgrades')}
4105 endif
4106 summary_info += {'fuzzing support':   get_option('fuzzing')}
4107 if have_system
4108   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
4109 endif
4110 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
4111 if 'simple' in get_option('trace_backends')
4112   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
4113 endif
4114 summary_info += {'D-Bus display':     dbus_display}
4115 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
4116 summary_info += {'Relocatable install': get_option('relocatable')}
4117 summary_info += {'vhost-kernel support': have_vhost_kernel}
4118 summary_info += {'vhost-net support': have_vhost_net}
4119 summary_info += {'vhost-user support': have_vhost_user}
4120 summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
4121 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
4122 summary_info += {'vhost-vdpa support': have_vhost_vdpa}
4123 summary_info += {'build guest agent': have_ga}
4124 summary(summary_info, bool_yn: true, section: 'Configurable features')
4125
4126 # Compilation information
4127 summary_info = {}
4128 summary_info += {'host CPU':          cpu}
4129 summary_info += {'host endianness':   build_machine.endian()}
4130 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
4131 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
4132 if 'cpp' in all_languages
4133   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
4134 else
4135   summary_info += {'C++ compiler':      false}
4136 endif
4137 if 'objc' in all_languages
4138   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
4139 else
4140   summary_info += {'Objective-C compiler': false}
4141 endif
4142 option_cflags = (get_option('debug') ? ['-g'] : [])
4143 if get_option('optimization') != 'plain'
4144   option_cflags += ['-O' + get_option('optimization')]
4145 endif
4146 summary_info += {'CFLAGS':            ' '.join(get_option('c_args') + option_cflags)}
4147 if 'cpp' in all_languages
4148   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args') + option_cflags)}
4149 endif
4150 if 'objc' in all_languages
4151   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args') + option_cflags)}
4152 endif
4153 link_args = get_option('c_link_args')
4154 if link_args.length() > 0
4155   summary_info += {'LDFLAGS':         ' '.join(link_args)}
4156 endif
4157 summary_info += {'QEMU_CFLAGS':       ' '.join(qemu_common_flags + qemu_cflags)}
4158 if 'cpp' in all_languages
4159   summary_info += {'QEMU_CXXFLAGS':     ' '.join(qemu_common_flags + qemu_cxxflags)}
4160 endif
4161 if 'objc' in all_languages
4162   summary_info += {'QEMU_OBJCFLAGS':    ' '.join(qemu_common_flags)}
4163 endif
4164 summary_info += {'QEMU_LDFLAGS':      ' '.join(qemu_ldflags)}
4165 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
4166 summary_info += {'PIE':               get_option('b_pie')}
4167 summary_info += {'static build':      get_option('prefer_static')}
4168 summary_info += {'malloc trim support': has_malloc_trim}
4169 summary_info += {'membarrier':        have_membarrier}
4170 summary_info += {'debug graph lock':  get_option('debug_graph_lock')}
4171 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
4172 summary_info += {'mutex debugging':   get_option('debug_mutex')}
4173 summary_info += {'memory allocator':  get_option('malloc')}
4174 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
4175 summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')}
4176 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
4177 summary_info += {'gcov':              get_option('b_coverage')}
4178 summary_info += {'thread sanitizer':  get_option('tsan')}
4179 summary_info += {'CFI support':       get_option('cfi')}
4180 if get_option('cfi')
4181   summary_info += {'CFI debug support': get_option('cfi_debug')}
4182 endif
4183 summary_info += {'strip binaries':    get_option('strip')}
4184 summary_info += {'sparse':            sparse}
4185 summary_info += {'mingw32 support':   host_os == 'windows'}
4186 summary(summary_info, bool_yn: true, section: 'Compilation')
4187
4188 # snarf the cross-compilation information for tests
4189 summary_info = {}
4190 have_cross = false
4191 foreach target: target_dirs
4192   tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak'
4193   if fs.exists(tcg_mak)
4194     config_cross_tcg = keyval.load(tcg_mak)
4195     if 'CC' in config_cross_tcg
4196       summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
4197       have_cross = true
4198     endif
4199   endif
4200 endforeach
4201 if have_cross
4202   summary(summary_info, bool_yn: true, section: 'Cross compilers')
4203 endif
4204
4205 # Targets and accelerators
4206 summary_info = {}
4207 if have_system
4208   summary_info += {'KVM support':       config_all_accel.has_key('CONFIG_KVM')}
4209   summary_info += {'HVF support':       config_all_accel.has_key('CONFIG_HVF')}
4210   summary_info += {'WHPX support':      config_all_accel.has_key('CONFIG_WHPX')}
4211   summary_info += {'NVMM support':      config_all_accel.has_key('CONFIG_NVMM')}
4212   summary_info += {'Xen support':       xen.found()}
4213   if xen.found()
4214     summary_info += {'xen ctrl version':  xen.version()}
4215   endif
4216   summary_info += {'Xen emulation':     config_all_devices.has_key('CONFIG_XEN_EMU')}
4217 endif
4218 summary_info += {'TCG support':       config_all_accel.has_key('CONFIG_TCG')}
4219 if config_all_accel.has_key('CONFIG_TCG')
4220   if get_option('tcg_interpreter')
4221     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
4222   else
4223     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
4224   endif
4225   summary_info += {'TCG plugins':       get_option('plugins')}
4226   summary_info += {'TCG debug enabled': get_option('debug_tcg')}
4227 endif
4228 summary_info += {'target list':       ' '.join(target_dirs)}
4229 if have_system
4230   summary_info += {'default devices':   get_option('default_devices')}
4231   summary_info += {'out of process emulation': multiprocess_allowed}
4232   summary_info += {'vfio-user server': vfio_user_server_allowed}
4233 endif
4234 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
4235
4236 # Block layer
4237 summary_info = {}
4238 summary_info += {'coroutine backend': coroutine_backend}
4239 summary_info += {'coroutine pool':    have_coroutine_pool}
4240 if have_block
4241   summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
4242   summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
4243   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
4244   summary_info += {'VirtFS (9P) support':    have_virtfs}
4245   summary_info += {'VirtFS (9P) Proxy Helper support (deprecated)': have_virtfs_proxy_helper}
4246   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
4247   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
4248   summary_info += {'bochs support':     get_option('bochs').allowed()}
4249   summary_info += {'cloop support':     get_option('cloop').allowed()}
4250   summary_info += {'dmg support':       get_option('dmg').allowed()}
4251   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
4252   summary_info += {'vdi support':       get_option('vdi').allowed()}
4253   summary_info += {'vhdx support':      get_option('vhdx').allowed()}
4254   summary_info += {'vmdk support':      get_option('vmdk').allowed()}
4255   summary_info += {'vpc support':       get_option('vpc').allowed()}
4256   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
4257   summary_info += {'qed support':       get_option('qed').allowed()}
4258   summary_info += {'parallels support': get_option('parallels').allowed()}
4259   summary_info += {'FUSE exports':      fuse}
4260   summary_info += {'VDUSE block exports': have_vduse_blk_export}
4261 endif
4262 summary(summary_info, bool_yn: true, section: 'Block layer support')
4263
4264 # Crypto
4265 summary_info = {}
4266 summary_info += {'TLS priority':      get_option('tls_priority')}
4267 summary_info += {'GNUTLS support':    gnutls}
4268 if gnutls.found()
4269   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
4270 endif
4271 summary_info += {'libgcrypt':         gcrypt}
4272 summary_info += {'nettle':            nettle}
4273 if nettle.found()
4274    summary_info += {'  XTS':             xts != 'private'}
4275 endif
4276 summary_info += {'AF_ALG support':    have_afalg}
4277 summary_info += {'rng-none':          get_option('rng_none')}
4278 summary_info += {'Linux keyring':     have_keyring}
4279 summary_info += {'Linux keyutils':    keyutils}
4280 summary(summary_info, bool_yn: true, section: 'Crypto')
4281
4282 # UI
4283 summary_info = {}
4284 if host_os == 'darwin'
4285   summary_info += {'Cocoa support':           cocoa}
4286 endif
4287 summary_info += {'SDL support':       sdl}
4288 summary_info += {'SDL image support': sdl_image}
4289 summary_info += {'GTK support':       gtk}
4290 summary_info += {'pixman':            pixman}
4291 summary_info += {'VTE support':       vte}
4292 summary_info += {'PNG support':       png}
4293 summary_info += {'VNC support':       vnc}
4294 if vnc.found()
4295   summary_info += {'VNC SASL support':  sasl}
4296   summary_info += {'VNC JPEG support':  jpeg}
4297 endif
4298 summary_info += {'spice protocol support': spice_protocol}
4299 if spice_protocol.found()
4300   summary_info += {'  spice server support': spice}
4301 endif
4302 summary_info += {'curses support':    curses}
4303 summary_info += {'brlapi support':    brlapi}
4304 summary(summary_info, bool_yn: true, section: 'User interface')
4305
4306 # Graphics backends
4307 summary_info = {}
4308 summary_info += {'VirGL support':     virgl}
4309 summary_info += {'Rutabaga support':  rutabaga}
4310 summary(summary_info, bool_yn: true, section: 'Graphics backends')
4311
4312 # Audio backends
4313 summary_info = {}
4314 if host_os not in ['darwin', 'haiku', 'windows']
4315   summary_info += {'OSS support':     oss}
4316   summary_info += {'sndio support':   sndio}
4317 elif host_os == 'darwin'
4318   summary_info += {'CoreAudio support': coreaudio}
4319 elif host_os == 'windows'
4320   summary_info += {'DirectSound support': dsound}
4321 endif
4322 if host_os == 'linux'
4323   summary_info += {'ALSA support':    alsa}
4324   summary_info += {'PulseAudio support': pulse}
4325 endif
4326 summary_info += {'PipeWire support':  pipewire}
4327 summary_info += {'JACK support':      jack}
4328 summary(summary_info, bool_yn: true, section: 'Audio backends')
4329
4330 # Network backends
4331 summary_info = {}
4332 if host_os == 'darwin'
4333   summary_info += {'vmnet.framework support': vmnet}
4334 endif
4335 summary_info += {'AF_XDP support':    libxdp}
4336 summary_info += {'slirp support':     slirp}
4337 summary_info += {'vde support':       vde}
4338 summary_info += {'netmap support':    have_netmap}
4339 summary_info += {'l2tpv3 support':    have_l2tpv3}
4340 summary(summary_info, bool_yn: true, section: 'Network backends')
4341
4342 # Libraries
4343 summary_info = {}
4344 summary_info += {'libtasn1':          tasn1}
4345 summary_info += {'PAM':               pam}
4346 summary_info += {'iconv support':     iconv}
4347 summary_info += {'blkio support':     blkio}
4348 summary_info += {'curl support':      curl}
4349 summary_info += {'Multipath support': mpathpersist}
4350 summary_info += {'Linux AIO support': libaio}
4351 summary_info += {'Linux io_uring support': linux_io_uring}
4352 summary_info += {'ATTR/XATTR support': libattr}
4353 summary_info += {'RDMA support':      rdma}
4354 summary_info += {'PVRDMA support':    have_pvrdma}
4355 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
4356 summary_info += {'libcap-ng support': libcap_ng}
4357 summary_info += {'bpf support':       libbpf}
4358 summary_info += {'rbd support':       rbd}
4359 summary_info += {'smartcard support': cacard}
4360 summary_info += {'U2F support':       u2f}
4361 summary_info += {'libusb':            libusb}
4362 summary_info += {'usb net redir':     usbredir}
4363 summary_info += {'OpenGL support (epoxy)': opengl}
4364 summary_info += {'GBM':               gbm}
4365 summary_info += {'libiscsi support':  libiscsi}
4366 summary_info += {'libnfs support':    libnfs}
4367 if host_os == 'windows'
4368   if have_ga
4369     summary_info += {'QGA VSS support':   have_qga_vss}
4370   endif
4371 endif
4372 summary_info += {'seccomp support':   seccomp}
4373 summary_info += {'GlusterFS support': glusterfs}
4374 summary_info += {'hv-balloon support': hv_balloon}
4375 summary_info += {'TPM support':       have_tpm}
4376 summary_info += {'libssh support':    libssh}
4377 summary_info += {'lzo support':       lzo}
4378 summary_info += {'snappy support':    snappy}
4379 summary_info += {'bzip2 support':     libbzip2}
4380 summary_info += {'lzfse support':     liblzfse}
4381 summary_info += {'zstd support':      zstd}
4382 summary_info += {'NUMA host support': numa}
4383 summary_info += {'capstone':          capstone}
4384 summary_info += {'libpmem support':   libpmem}
4385 summary_info += {'libdaxctl support': libdaxctl}
4386 summary_info += {'libudev':           libudev}
4387 # Dummy dependency, keep .found()
4388 summary_info += {'FUSE lseek':        fuse_lseek.found()}
4389 summary_info += {'selinux':           selinux}
4390 summary_info += {'libdw':             libdw}
4391 summary(summary_info, bool_yn: true, section: 'Dependencies')
4392
4393 if host_arch == 'unknown'
4394   message()
4395   warning('UNSUPPORTED HOST CPU')
4396   message()
4397   message('Support for CPU host architecture ' + cpu + ' is not currently')
4398   message('maintained. The QEMU project does not guarantee that QEMU will')
4399   message('compile or work on this host CPU. You can help by volunteering')
4400   message('to maintain it and providing a build host for our continuous')
4401   message('integration setup.')
4402   if get_option('tcg').allowed() and target_dirs.length() > 0
4403     message()
4404     message('configure has succeeded and you can continue to build, but')
4405     message('QEMU will use a slow interpreter to emulate the target CPU.')
4406   endif
4407 endif
4408
4409 if not supported_oses.contains(host_os)
4410   message()
4411   warning('UNSUPPORTED HOST OS')
4412   message()
4413   message('Support for host OS ' + host_os + 'is not currently maintained.')
4414   message('configure has succeeded and you can continue to build, but')
4415   message('the QEMU project does not guarantee that QEMU will compile or')
4416   message('work on this operating system. You can help by volunteering')
4417   message('to maintain it and providing a build host for our continuous')
4418   message('integration setup. This will ensure that future versions of QEMU')
4419   message('will keep working on ' + host_os + '.')
4420 endif
4421
4422 if host_arch == 'unknown' or not supported_oses.contains(host_os)
4423   message()
4424   message('If you want to help supporting QEMU on this platform, please')
4425   message('contact the developers at qemu-devel@nongnu.org.')
4426 endif
4427
4428 actually_reloc = get_option('relocatable')
4429 # check if get_relocated_path() is actually able to relocate paths
4430 if get_option('relocatable') and \
4431   not (get_option('prefix') / get_option('bindir')).startswith(get_option('prefix') / '')
4432   message()
4433   warning('bindir not included within prefix, the installation will not be relocatable.')
4434   actually_reloc = false
4435 endif
4436 if not actually_reloc and (host_os == 'windows' or get_option('relocatable'))
4437   if host_os == 'windows'
4438     message()
4439     warning('Windows installs should usually be relocatable.')
4440   endif
4441   message()
4442   message('QEMU will have to be installed under ' + get_option('prefix') + '.')
4443   message('Use --disable-relocatable to remove this warning.')
4444 endif