meson.build

   1 project('qemu', ['c'], meson_version: '>=0.58.2',
   2         default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
   3                           'b_staticpic=false'],
   4         version: files('VERSION'))
   5
   6 not_found = dependency('', required: false)
   7 keyval = import('keyval')
   8 ss = import('sourceset')
   9 fs = import('fs')
  10
  11 sh = find_program('sh')
  12 cc = meson.get_compiler('c')
  13 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
  14 enable_modules = 'CONFIG_MODULES' in config_host
  15 enable_static = 'CONFIG_STATIC' in config_host
  16
  17 # Allow both shared and static libraries unless --enable-static
  18 static_kwargs = enable_static ? {'static': true} : {}
  19
  20 # Temporary directory used for files created while
  21 # configure runs. Since it is in the build directory
  22 # we can safely blow away any previous version of it
  23 # (and we need not jump through hoops to try to delete
  24 # it when configure exits.)
  25 tmpdir = meson.current_build_dir() / 'meson-private/temp'
  26
  27 if get_option('qemu_suffix').startswith('/')
  28   error('qemu_suffix cannot start with a /')
  29 endif
  30
  31 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
  32 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
  33 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
  34 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
  35
  36 qemu_desktopdir = get_option('datadir') / 'applications'
  37 qemu_icondir = get_option('datadir') / 'icons'
  38
  39 config_host_data = configuration_data()
  40 genh = []
  41
  42 target_dirs = config_host['TARGET_DIRS'].split()
  43 have_user = false
  44 have_system = false
  45 foreach target : target_dirs
  46   have_user = have_user or target.endswith('-user')
  47   have_system = have_system or target.endswith('-softmmu')
  48 endforeach
  49 have_tools = 'CONFIG_TOOLS' in config_host
  50 have_block = have_system or have_tools
  51
  52 python = import('python').find_installation()
  53
  54 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
  55 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
  56   'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
  57
  58 cpu = host_machine.cpu_family()
  59 targetos = host_machine.system()
  60
  61 if cpu in ['x86', 'x86_64']
  62   kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
  63 elif cpu == 'aarch64'
  64   kvm_targets = ['aarch64-softmmu']
  65 elif cpu == 's390x'
  66   kvm_targets = ['s390x-softmmu']
  67 elif cpu in ['ppc', 'ppc64']
  68   kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
  69 elif cpu in ['mips', 'mips64']
  70   kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
  71 else
  72   kvm_targets = []
  73 endif
  74
  75 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
  76
  77 if cpu in ['aarch64']
  78   accelerator_targets += {
  79     'CONFIG_HVF': ['aarch64-softmmu']
  80   }
  81 endif
  82
  83 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
  84   # i386 emulator provides xenpv machine type for multiple architectures
  85   accelerator_targets += {
  86     'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
  87   }
  88 endif
  89 if cpu in ['x86', 'x86_64']
  90   accelerator_targets += {
  91     'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
  92     'CONFIG_HVF': ['x86_64-softmmu'],
  93     'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
  94     'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
  95   }
  96 endif
  97
  98 modular_tcg = []
  99 # Darwin does not support references to thread-local variables in modules
 100 if targetos != 'darwin'
 101   modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
 102 endif
 103
 104 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
 105 unpack_edk2_blobs = false
 106 foreach target : edk2_targets
 107   if target in target_dirs
 108     bzip2 = find_program('bzip2', required: get_option('install_blobs'))
 109     unpack_edk2_blobs = bzip2.found()
 110     break
 111   endif
 112 endforeach
 113
 114 dtrace = not_found
 115 stap = not_found
 116 if 'dtrace' in get_option('trace_backends')
 117   dtrace = find_program('dtrace', required: true)
 118   stap = find_program('stap', required: false)
 119   if stap.found()
 120     # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
 121     # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
 122     # instead. QEMU --enable-modules depends on this because the SystemTap
 123     # semaphores are linked into the main binary and not the module's shared
 124     # object.
 125     add_global_arguments('-DSTAP_SDT_V2',
 126                          native: false, language: ['c', 'cpp', 'objc'])
 127   endif
 128 endif
 129
 130 ##################
 131 # Compiler flags #
 132 ##################
 133
 134 # Specify linker-script with add_project_link_arguments so that it is not placed
 135 # within a linker --start-group/--end-group pair
 136 if get_option('fuzzing')
 137   add_project_link_arguments(['-Wl,-T,',
 138                               (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
 139                              native: false, language: ['c', 'cpp', 'objc'])
 140
 141   # Specify a filter to only instrument code that is directly related to
 142   # virtual-devices.
 143   configure_file(output: 'instrumentation-filter',
 144                  input: 'scripts/oss-fuzz/instrumentation-filter-template',
 145                  copy: true)
 146   add_global_arguments(
 147       cc.get_supported_arguments('-fsanitize-coverage-allowlist=instrumentation-filter'),
 148       native: false, language: ['c', 'cpp', 'objc'])
 149
 150   if get_option('fuzzing_engine') == ''
 151     # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
 152     # compiled code.  To build non-fuzzer binaries with --enable-fuzzing, link
 153     # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
 154     # unable to bind the fuzzer-related callbacks added by instrumentation.
 155     add_global_arguments('-fsanitize=fuzzer-no-link',
 156                          native: false, language: ['c', 'cpp', 'objc'])
 157     add_global_link_arguments('-fsanitize=fuzzer-no-link',
 158                               native: false, language: ['c', 'cpp', 'objc'])
 159     # For the actual fuzzer binaries, we need to link against the libfuzzer
 160     # library. They need to be configurable, to support OSS-Fuzz
 161     fuzz_exe_ldflags = ['-fsanitize=fuzzer']
 162   else
 163     # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
 164     # the needed CFLAGS have already been provided
 165     fuzz_exe_ldflags = get_option('fuzzing_engine').split()
 166   endif
 167 endif
 168
 169 add_global_arguments(config_host['QEMU_CFLAGS'].split(),
 170                      native: false, language: ['c', 'objc'])
 171 add_global_arguments(config_host['QEMU_CXXFLAGS'].split(),
 172                      native: false, language: 'cpp')
 173 add_global_link_arguments(config_host['QEMU_LDFLAGS'].split(),
 174                           native: false, language: ['c', 'cpp', 'objc'])
 175
 176 if targetos == 'linux'
 177   add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
 178                         '-isystem', 'linux-headers',
 179                         language: ['c', 'cpp'])
 180 endif
 181
 182 add_project_arguments('-iquote', '.',
 183                       '-iquote', meson.current_source_dir(),
 184                       '-iquote', meson.current_source_dir() / 'include',
 185                       '-iquote', meson.current_source_dir() / 'disas/libvixl',
 186                       language: ['c', 'cpp', 'objc'])
 187
 188 link_language = meson.get_external_property('link_language', 'cpp')
 189 if link_language == 'cpp'
 190   add_languages('cpp', required: true, native: false)
 191 endif
 192 if host_machine.system() == 'darwin'
 193   add_languages('objc', required: false, native: false)
 194 endif
 195
 196 sparse = find_program('cgcc', required: get_option('sparse'))
 197 if sparse.found()
 198   run_target('sparse',
 199              command: [find_program('scripts/check_sparse.py'),
 200                        'compile_commands.json', sparse.full_path(), '-Wbitwise',
 201                        '-Wno-transparent-union', '-Wno-old-initializer',
 202                        '-Wno-non-pointer-null'])
 203 endif
 204
 205 ###########################################
 206 # Target-specific checks and dependencies #
 207 ###########################################
 208
 209 if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
 210     not cc.links('''
 211           #include <stdint.h>
 212           #include <sys/types.h>
 213           int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
 214           int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
 215         ''',
 216         args: ['-Werror', '-fsanitize=fuzzer'])
 217   error('Your compiler does not support -fsanitize=fuzzer')
 218 endif
 219
 220 if 'ftrace' in get_option('trace_backends') and targetos != 'linux'
 221   error('ftrace is supported only on Linux')
 222 endif
 223 if 'syslog' in get_option('trace_backends') and not cc.compiles('''
 224     #include <syslog.h>
 225     int main(void) {
 226         openlog("qemu", LOG_PID, LOG_DAEMON);
 227         syslog(LOG_INFO, "configure");
 228         return 0;
 229     }''')
 230   error('syslog is not supported on this system')
 231 endif
 232
 233 if targetos != 'linux' and get_option('mpath').enabled()
 234   error('Multipath is supported only on Linux')
 235 endif
 236
 237 if targetos != 'linux' and get_option('multiprocess').enabled()
 238   error('Multiprocess QEMU is supported only on Linux')
 239 endif
 240 multiprocess_allowed = targetos == 'linux' and not get_option('multiprocess').disabled()
 241
 242 libm = cc.find_library('m', required: false)
 243 threads = dependency('threads')
 244 util = cc.find_library('util', required: false)
 245 winmm = []
 246 socket = []
 247 version_res = []
 248 coref = []
 249 iokit = []
 250 emulator_link_args = []
 251 nvmm =not_found
 252 hvf = not_found
 253 host_dsosuf = '.so'
 254 if targetos == 'windows'
 255   socket = cc.find_library('ws2_32')
 256   winmm = cc.find_library('winmm')
 257
 258   win = import('windows')
 259   version_res = win.compile_resources('version.rc',
 260                                       depend_files: files('pc-bios/qemu-nsis.ico'),
 261                                       include_directories: include_directories('.'))
 262   host_dsosuf = '.dll'
 263 elif targetos == 'darwin'
 264   coref = dependency('appleframeworks', modules: 'CoreFoundation')
 265   iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
 266   host_dsosuf = '.dylib'
 267 elif targetos == 'sunos'
 268   socket = [cc.find_library('socket'),
 269             cc.find_library('nsl'),
 270             cc.find_library('resolv')]
 271 elif targetos == 'haiku'
 272   socket = [cc.find_library('posix_error_mapper'),
 273             cc.find_library('network'),
 274             cc.find_library('bsd')]
 275 elif targetos == 'openbsd'
 276   if not get_option('tcg').disabled() and target_dirs.length() > 0
 277     # Disable OpenBSD W^X if available
 278     emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
 279   endif
 280 endif
 281
 282 accelerators = []
 283 if not get_option('kvm').disabled() and targetos == 'linux'
 284   accelerators += 'CONFIG_KVM'
 285 endif
 286 if not get_option('xen').disabled() and 'CONFIG_XEN_BACKEND' in config_host
 287   accelerators += 'CONFIG_XEN'
 288   have_xen_pci_passthrough = not get_option('xen_pci_passthrough').disabled() and targetos == 'linux'
 289 else
 290   have_xen_pci_passthrough = false
 291 endif
 292 if not get_option('whpx').disabled() and targetos == 'windows'
 293   if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
 294     error('WHPX requires 64-bit host')
 295   elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
 296        cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
 297     accelerators += 'CONFIG_WHPX'
 298   endif
 299 endif
 300 if not get_option('hvf').disabled()
 301   hvf = dependency('appleframeworks', modules: 'Hypervisor',
 302                    required: get_option('hvf'))
 303   if hvf.found()
 304     accelerators += 'CONFIG_HVF'
 305   endif
 306 endif
 307 if not get_option('hax').disabled()
 308   if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
 309     accelerators += 'CONFIG_HAX'
 310   endif
 311 endif
 312 if targetos == 'netbsd'
 313   if cc.has_header_symbol('nvmm.h', 'nvmm_cpu_stop', required: get_option('nvmm'))
 314     nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
 315   endif
 316   if nvmm.found()
 317     accelerators += 'CONFIG_NVMM'
 318   endif
 319 endif
 320
 321 tcg_arch = config_host['ARCH']
 322 if not get_option('tcg').disabled()
 323   if cpu not in supported_cpus
 324     if get_option('tcg_interpreter')
 325       warning('Unsupported CPU @0@, will use TCG with TCI (experimental and slow)'.format(cpu))
 326     else
 327       error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
 328     endif
 329   elif get_option('tcg_interpreter')
 330     warning('Use of the TCG interpretor is not recommended on this host')
 331     warning('architecture. There is a native TCG execution backend available')
 332     warning('which provides substantially better performance and reliability.')
 333     warning('It is strongly recommended to remove the --enable-tcg-interpreter')
 334     warning('configuration option on this architecture to use the native')
 335     warning('backend.')
 336   endif
 337   if get_option('tcg_interpreter')
 338     tcg_arch = 'tci'
 339   elif config_host['ARCH'] == 'sparc64'
 340     tcg_arch = 'sparc'
 341   elif config_host['ARCH'] in ['x86_64', 'x32']
 342     tcg_arch = 'i386'
 343   elif config_host['ARCH'] == 'ppc64'
 344     tcg_arch = 'ppc'
 345   elif config_host['ARCH'] in ['riscv32', 'riscv64']
 346     tcg_arch = 'riscv'
 347   endif
 348   add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
 349                         language: ['c', 'cpp', 'objc'])
 350
 351   accelerators += 'CONFIG_TCG'
 352   config_host += { 'CONFIG_TCG': 'y' }
 353 endif
 354
 355 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
 356   error('KVM not available on this platform')
 357 endif
 358 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
 359   error('HVF not available on this platform')
 360 endif
 361 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
 362   error('NVMM not available on this platform')
 363 endif
 364 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
 365   error('WHPX not available on this platform')
 366 endif
 367 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
 368   if 'CONFIG_XEN' in accelerators
 369     error('Xen PCI passthrough not available on this platform')
 370   else
 371     error('Xen PCI passthrough requested but Xen not enabled')
 372   endif
 373 endif
 374
 375 ################
 376 # Dependencies #
 377 ################
 378
 379 # The path to glib.h is added to all compilation commands.  This was
 380 # grandfathered in from the QEMU Makefiles.
 381 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
 382                       native: false, language: ['c', 'cpp', 'objc'])
 383 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
 384                           link_args: config_host['GLIB_LIBS'].split())
 385 # override glib dep with the configure results (for subprojects)
 386 meson.override_dependency('glib-2.0', glib)
 387
 388 gio = not_found
 389 if 'CONFIG_GIO' in config_host
 390   gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
 391                            link_args: config_host['GIO_LIBS'].split())
 392 endif
 393 lttng = not_found
 394 if 'ust' in get_option('trace_backends')
 395   lttng = dependency('lttng-ust', required: true, method: 'pkg-config',
 396                      kwargs: static_kwargs)
 397 endif
 398 pixman = not_found
 399 if have_system or have_tools
 400   pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
 401                       method: 'pkg-config', kwargs: static_kwargs)
 402 endif
 403 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
 404
 405 libaio = not_found
 406 if not get_option('linux_aio').auto() or have_block
 407   libaio = cc.find_library('aio', has_headers: ['libaio.h'],
 408                            required: get_option('linux_aio'),
 409                            kwargs: static_kwargs)
 410 endif
 411 linux_io_uring = not_found
 412 if not get_option('linux_io_uring').auto() or have_block
 413   linux_io_uring = dependency('liburing', required: get_option('linux_io_uring'),
 414                               method: 'pkg-config', kwargs: static_kwargs)
 415 endif
 416 libxml2 = not_found
 417 if not get_option('libxml2').auto() or have_block
 418   libxml2 = dependency('libxml-2.0', required: get_option('libxml2'),
 419                        method: 'pkg-config', kwargs: static_kwargs)
 420 endif
 421 libnfs = not_found
 422 if not get_option('libnfs').auto() or have_block
 423   libnfs = dependency('libnfs', version: '>=1.9.3',
 424                       required: get_option('libnfs'),
 425                       method: 'pkg-config', kwargs: static_kwargs)
 426 endif
 427
 428 libattr_test = '''
 429   #include <stddef.h>
 430   #include <sys/types.h>
 431   #ifdef CONFIG_LIBATTR
 432   #include <attr/xattr.h>
 433   #else
 434   #include <sys/xattr.h>
 435   #endif
 436   int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
 437
 438 libattr = not_found
 439 have_old_libattr = false
 440 if not get_option('attr').disabled()
 441   if cc.links(libattr_test)
 442     libattr = declare_dependency()
 443   else
 444     libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
 445                               required: get_option('attr'),
 446                               kwargs: static_kwargs)
 447     if libattr.found() and not \
 448       cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
 449       libattr = not_found
 450       if get_option('attr').enabled()
 451         error('could not link libattr')
 452       else
 453         warning('could not link libattr, disabling')
 454       endif
 455     else
 456       have_old_libattr = libattr.found()
 457     endif
 458   endif
 459 endif
 460
 461 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
 462 if cocoa.found() and get_option('sdl').enabled()
 463   error('Cocoa and SDL cannot be enabled at the same time')
 464 endif
 465 if cocoa.found() and get_option('gtk').enabled()
 466   error('Cocoa and GTK+ cannot be enabled at the same time')
 467 endif
 468
 469 seccomp = not_found
 470 if not get_option('seccomp').auto() or have_system or have_tools
 471   seccomp = dependency('libseccomp', version: '>=2.3.0',
 472                        required: get_option('seccomp'),
 473                        method: 'pkg-config', kwargs: static_kwargs)
 474 endif
 475
 476 libcap_ng = not_found
 477 if not get_option('cap_ng').auto() or have_system or have_tools
 478   libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
 479                               required: get_option('cap_ng'),
 480                               kwargs: static_kwargs)
 481 endif
 482 if libcap_ng.found() and not cc.links('''
 483    #include <cap-ng.h>
 484    int main(void)
 485    {
 486      capng_capability_to_name(CAPNG_EFFECTIVE);
 487      return 0;
 488    }''', dependencies: libcap_ng)
 489   libcap_ng = not_found
 490   if get_option('cap_ng').enabled()
 491     error('could not link libcap-ng')
 492   else
 493     warning('could not link libcap-ng, disabling')
 494   endif
 495 endif
 496
 497 if get_option('xkbcommon').auto() and not have_system and not have_tools
 498   xkbcommon = not_found
 499 else
 500   xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
 501                          method: 'pkg-config', kwargs: static_kwargs)
 502 endif
 503
 504 vde = not_found
 505 if not get_option('vde').auto() or have_system or have_tools
 506   vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
 507                            required: get_option('vde'),
 508                            kwargs: static_kwargs)
 509 endif
 510 if vde.found() and not cc.links('''
 511    #include <libvdeplug.h>
 512    int main(void)
 513    {
 514      struct vde_open_args a = {0, 0, 0};
 515      char s[] = "";
 516      vde_open(s, s, &a);
 517      return 0;
 518    }''', dependencies: vde)
 519   vde = not_found
 520   if get_option('cap_ng').enabled()
 521     error('could not link libvdeplug')
 522   else
 523     warning('could not link libvdeplug, disabling')
 524   endif
 525 endif
 526
 527 pulse = not_found
 528 if not get_option('pa').auto() or (targetos == 'linux' and have_system)
 529   pulse = dependency('libpulse', required: get_option('pa'),
 530                      method: 'pkg-config', kwargs: static_kwargs)
 531 endif
 532 alsa = not_found
 533 if not get_option('alsa').auto() or (targetos == 'linux' and have_system)
 534   alsa = dependency('alsa', required: get_option('alsa'),
 535                     method: 'pkg-config', kwargs: static_kwargs)
 536 endif
 537 jack = not_found
 538 if not get_option('jack').auto() or have_system
 539   jack = dependency('jack', required: get_option('jack'),
 540                     method: 'pkg-config', kwargs: static_kwargs)
 541 endif
 542
 543 spice_protocol = not_found
 544 if not get_option('spice_protocol').auto() or have_system
 545   spice_protocol = dependency('spice-protocol', version: '>=0.12.3',
 546                               required: get_option('spice_protocol'),
 547                               method: 'pkg-config', kwargs: static_kwargs)
 548 endif
 549 spice = not_found
 550 if not get_option('spice').auto() or have_system
 551   spice = dependency('spice-server', version: '>=0.12.5',
 552                      required: get_option('spice'),
 553                      method: 'pkg-config', kwargs: static_kwargs)
 554 endif
 555 spice_headers = spice.partial_dependency(compile_args: true, includes: true)
 556
 557 rt = cc.find_library('rt', required: false)
 558 libdl = not_found
 559 if 'CONFIG_PLUGIN' in config_host
 560   libdl = cc.find_library('dl', required: false)
 561   if not cc.has_function('dlopen', dependencies: libdl)
 562     error('dlopen not found')
 563   endif
 564 endif
 565 libiscsi = not_found
 566 if not get_option('libiscsi').auto() or have_block
 567   libiscsi = dependency('libiscsi', version: '>=1.9.0',
 568                          required: get_option('libiscsi'),
 569                          method: 'pkg-config', kwargs: static_kwargs)
 570 endif
 571 zstd = not_found
 572 if not get_option('zstd').auto() or have_block
 573   zstd = dependency('libzstd', version: '>=1.4.0',
 574                     required: get_option('zstd'),
 575                     method: 'pkg-config', kwargs: static_kwargs)
 576 endif
 577 virgl = not_found
 578 if not get_option('virglrenderer').auto() or have_system
 579   virgl = dependency('virglrenderer',
 580                      method: 'pkg-config',
 581                      required: get_option('virglrenderer'),
 582                      kwargs: static_kwargs)
 583 endif
 584 curl = not_found
 585 if not get_option('curl').auto() or have_block
 586   curl = dependency('libcurl', version: '>=7.29.0',
 587                     method: 'pkg-config',
 588                     required: get_option('curl'),
 589                     kwargs: static_kwargs)
 590 endif
 591 libudev = not_found
 592 if targetos == 'linux' and (have_system or have_tools)
 593   libudev = dependency('libudev',
 594                        method: 'pkg-config',
 595                        required: get_option('libudev'),
 596                        kwargs: static_kwargs)
 597 endif
 598
 599 mpathlibs = [libudev]
 600 mpathpersist = not_found
 601 mpathpersist_new_api = false
 602 if targetos == 'linux' and have_tools and not get_option('mpath').disabled()
 603   mpath_test_source_new = '''
 604     #include <libudev.h>
 605     #include <mpath_persist.h>
 606     unsigned mpath_mx_alloc_len = 1024;
 607     int logsink;
 608     static struct config *multipath_conf;
 609     extern struct udev *udev;
 610     extern struct config *get_multipath_config(void);
 611     extern void put_multipath_config(struct config *conf);
 612     struct udev *udev;
 613     struct config *get_multipath_config(void) { return multipath_conf; }
 614     void put_multipath_config(struct config *conf) { }
 615     int main(void) {
 616         udev = udev_new();
 617         multipath_conf = mpath_lib_init();
 618         return 0;
 619     }'''
 620   mpath_test_source_old = '''
 621       #include <libudev.h>
 622       #include <mpath_persist.h>
 623       unsigned mpath_mx_alloc_len = 1024;
 624       int logsink;
 625       int main(void) {
 626           struct udev *udev = udev_new();
 627           mpath_lib_init(udev);
 628           return 0;
 629       }'''
 630   libmpathpersist = cc.find_library('mpathpersist',
 631                                     required: get_option('mpath'),
 632                                     kwargs: static_kwargs)
 633   if libmpathpersist.found()
 634     mpathlibs += libmpathpersist
 635     if enable_static
 636       mpathlibs += cc.find_library('devmapper',
 637                                      required: get_option('mpath'),
 638                                      kwargs: static_kwargs)
 639     endif
 640     mpathlibs += cc.find_library('multipath',
 641                                  required: get_option('mpath'),
 642                                  kwargs: static_kwargs)
 643     foreach lib: mpathlibs
 644       if not lib.found()
 645         mpathlibs = []
 646         break
 647       endif
 648     endforeach
 649     if mpathlibs.length() == 0
 650       msg = 'Dependencies missing for libmpathpersist'
 651     elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
 652       mpathpersist = declare_dependency(dependencies: mpathlibs)
 653       mpathpersist_new_api = true
 654     elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
 655       mpathpersist = declare_dependency(dependencies: mpathlibs)
 656     else
 657       msg = 'Cannot detect libmpathpersist API'
 658     endif
 659     if not mpathpersist.found()
 660       if get_option('mpath').enabled()
 661         error(msg)
 662       else
 663         warning(msg + ', disabling')
 664       endif
 665     endif
 666   endif
 667 endif
 668
 669 iconv = not_found
 670 curses = not_found
 671 if have_system and not get_option('curses').disabled()
 672   curses_test = '''
 673     #include <locale.h>
 674     #include <curses.h>
 675     #include <wchar.h>
 676     int main(void) {
 677       wchar_t wch = L'w';
 678       setlocale(LC_ALL, "");
 679       resize_term(0, 0);
 680       addwstr(L"wide chars\n");
 681       addnwstr(&wch, 1);
 682       add_wch(WACS_DEGREE);
 683       return 0;
 684     }'''
 685
 686   curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
 687   foreach curses_dep : curses_dep_list
 688     if not curses.found()
 689       curses = dependency(curses_dep,
 690                           required: false,
 691                           method: 'pkg-config',
 692                           kwargs: static_kwargs)
 693     endif
 694   endforeach
 695   msg = get_option('curses').enabled() ? 'curses library not found' : ''
 696   curses_compile_args = ['-DNCURSES_WIDECHAR']
 697   if curses.found()
 698     if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
 699       curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
 700     else
 701       msg = 'curses package not usable'
 702       curses = not_found
 703     endif
 704   endif
 705   if not curses.found()
 706     has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
 707     if targetos != 'windows' and not has_curses_h
 708       message('Trying with /usr/include/ncursesw')
 709       curses_compile_args += ['-I/usr/include/ncursesw']
 710       has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
 711     endif
 712     if has_curses_h
 713       curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
 714       foreach curses_libname : curses_libname_list
 715         libcurses = cc.find_library(curses_libname,
 716                                     required: false,
 717                                     kwargs: static_kwargs)
 718         if libcurses.found()
 719           if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
 720             curses = declare_dependency(compile_args: curses_compile_args,
 721                                         dependencies: [libcurses])
 722             break
 723           else
 724             msg = 'curses library not usable'
 725           endif
 726         endif
 727       endforeach
 728     endif
 729   endif
 730   if not get_option('iconv').disabled()
 731     foreach link_args : [ ['-liconv'], [] ]
 732       # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
 733       # We need to use libiconv if available because mixing libiconv's headers with
 734       # the system libc does not work.
 735       # However, without adding glib to the dependencies -L/usr/local/lib will not be
 736       # included in the command line and libiconv will not be found.
 737       if cc.links('''
 738         #include <iconv.h>
 739         int main(void) {
 740           iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
 741           return conv != (iconv_t) -1;
 742         }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
 743         iconv = declare_dependency(link_args: link_args, dependencies: glib)
 744         break
 745       endif
 746     endforeach
 747   endif
 748   if curses.found() and not iconv.found()
 749     if get_option('iconv').enabled()
 750       error('iconv not available')
 751     endif
 752     msg = 'iconv required for curses UI but not available'
 753     curses = not_found
 754   endif
 755   if not curses.found() and msg != ''
 756     if get_option('curses').enabled()
 757       error(msg)
 758     else
 759       warning(msg + ', disabling')
 760     endif
 761   endif
 762 endif
 763
 764 brlapi = not_found
 765 if not get_option('brlapi').auto() or have_system
 766   brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
 767                          required: get_option('brlapi'),
 768                          kwargs: static_kwargs)
 769   if brlapi.found() and not cc.links('''
 770      #include <brlapi.h>
 771      #include <stddef.h>
 772      int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
 773     brlapi = not_found
 774     if get_option('brlapi').enabled()
 775       error('could not link brlapi')
 776     else
 777       warning('could not link brlapi, disabling')
 778     endif
 779   endif
 780 endif
 781
 782 sdl = not_found
 783 if not get_option('sdl').auto() or (have_system and not cocoa.found())
 784   sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
 785   sdl_image = not_found
 786 endif
 787 if sdl.found()
 788   # work around 2.0.8 bug
 789   sdl = declare_dependency(compile_args: '-Wno-undef',
 790                            dependencies: sdl)
 791   sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
 792                          method: 'pkg-config', kwargs: static_kwargs)
 793 else
 794   if get_option('sdl_image').enabled()
 795     error('sdl-image required, but SDL was @0@'.format(
 796           get_option('sdl').disabled() ? 'disabled' : 'not found'))
 797   endif
 798   sdl_image = not_found
 799 endif
 800
 801 rbd = not_found
 802 if not get_option('rbd').auto() or have_block
 803   librados = cc.find_library('rados', required: get_option('rbd'),
 804                              kwargs: static_kwargs)
 805   librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
 806                            required: get_option('rbd'),
 807                            kwargs: static_kwargs)
 808   if librados.found() and librbd.found()
 809     if cc.links('''
 810       #include <stdio.h>
 811       #include <rbd/librbd.h>
 812       int main(void) {
 813         rados_t cluster;
 814         rados_create(&cluster, NULL);
 815         #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
 816         #error
 817         #endif
 818         return 0;
 819       }''', dependencies: [librbd, librados])
 820       rbd = declare_dependency(dependencies: [librbd, librados])
 821     elif get_option('rbd').enabled()
 822       error('librbd >= 1.12.0 required')
 823     else
 824       warning('librbd >= 1.12.0 not found, disabling')
 825     endif
 826   endif
 827 endif
 828
 829 glusterfs = not_found
 830 glusterfs_ftruncate_has_stat = false
 831 glusterfs_iocb_has_stat = false
 832 if not get_option('glusterfs').auto() or have_block
 833   glusterfs = dependency('glusterfs-api', version: '>=3',
 834                          required: get_option('glusterfs'),
 835                          method: 'pkg-config', kwargs: static_kwargs)
 836   if glusterfs.found()
 837     glusterfs_ftruncate_has_stat = cc.links('''
 838       #include <glusterfs/api/glfs.h>
 839
 840       int
 841       main(void)
 842       {
 843           /* new glfs_ftruncate() passes two additional args */
 844           return glfs_ftruncate(NULL, 0, NULL, NULL);
 845       }
 846     ''', dependencies: glusterfs)
 847     glusterfs_iocb_has_stat = cc.links('''
 848       #include <glusterfs/api/glfs.h>
 849
 850       /* new glfs_io_cbk() passes two additional glfs_stat structs */
 851       static void
 852       glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
 853       {}
 854
 855       int
 856       main(void)
 857       {
 858           glfs_io_cbk iocb = &glusterfs_iocb;
 859           iocb(NULL, 0 , NULL, NULL, NULL);
 860           return 0;
 861       }
 862     ''', dependencies: glusterfs)
 863   endif
 864 endif
 865 libssh = not_found
 866 if 'CONFIG_LIBSSH' in config_host
 867   libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
 868                               link_args: config_host['LIBSSH_LIBS'].split())
 869 endif
 870 libbzip2 = not_found
 871 if not get_option('bzip2').auto() or have_block
 872   libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
 873                              required: get_option('bzip2'),
 874                              kwargs: static_kwargs)
 875   if libbzip2.found() and not cc.links('''
 876      #include <bzlib.h>
 877      int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
 878     libbzip2 = not_found
 879     if get_option('bzip2').enabled()
 880       error('could not link libbzip2')
 881     else
 882       warning('could not link libbzip2, disabling')
 883     endif
 884   endif
 885 endif
 886
 887 liblzfse = not_found
 888 if not get_option('lzfse').auto() or have_block
 889   liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
 890                              required: get_option('lzfse'),
 891                              kwargs: static_kwargs)
 892 endif
 893 if liblzfse.found() and not cc.links('''
 894    #include <lzfse.h>
 895    int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
 896   liblzfse = not_found
 897   if get_option('lzfse').enabled()
 898     error('could not link liblzfse')
 899   else
 900     warning('could not link liblzfse, disabling')
 901   endif
 902 endif
 903
 904 oss = not_found
 905 if not get_option('oss').auto() or have_system
 906   if not cc.has_header('sys/soundcard.h')
 907     # not found
 908   elif targetos == 'netbsd'
 909     oss = cc.find_library('ossaudio', required: get_option('oss'),
 910                           kwargs: static_kwargs)
 911   else
 912     oss = declare_dependency()
 913   endif
 914
 915   if not oss.found()
 916     if get_option('oss').enabled()
 917       error('OSS not found')
 918     else
 919       warning('OSS not found, disabling')
 920     endif
 921   endif
 922 endif
 923 dsound = not_found
 924 if not get_option('dsound').auto() or (targetos == 'windows' and have_system)
 925   if cc.has_header('dsound.h')
 926     dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
 927   endif
 928
 929   if not dsound.found()
 930     if get_option('dsound').enabled()
 931       error('DirectSound not found')
 932     else
 933       warning('DirectSound not found, disabling')
 934     endif
 935   endif
 936 endif
 937
 938 coreaudio = not_found
 939 if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system)
 940   coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
 941                          required: get_option('coreaudio'))
 942   if coreaudio.found() and not cc.links('''
 943     #include <CoreAudio/CoreAudio.h>
 944     int main(void)
 945     {
 946       return (int)AudioGetCurrentHostTime();
 947     }''')
 948     coreaudio = not_found
 949   endif
 950
 951   if not coreaudio.found()
 952     if get_option('coreaudio').enabled()
 953       error('CoreAudio not found')
 954     else
 955       warning('CoreAudio not found, disabling')
 956     endif
 957   endif
 958 endif
 959
 960 opengl = not_found
 961 if 'CONFIG_OPENGL' in config_host
 962   opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
 963                               link_args: config_host['OPENGL_LIBS'].split())
 964 endif
 965 gbm = not_found
 966 if (have_system or have_tools) and (virgl.found() or opengl.found())
 967   gbm = dependency('gbm', method: 'pkg-config', required: false,
 968                    kwargs: static_kwargs)
 969 endif
 970
 971 gnutls = not_found
 972 gnutls_crypto = not_found
 973 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
 974   # For general TLS support our min gnutls matches
 975   # that implied by our platform support matrix
 976   #
 977   # For the crypto backends, we look for a newer
 978   # gnutls:
 979   #
 980   #   Version 3.6.8  is needed to get XTS
 981   #   Version 3.6.13 is needed to get PBKDF
 982   #   Version 3.6.14 is needed to get HW accelerated XTS
 983   #
 984   # If newer enough gnutls isn't available, we can
 985   # still use a different crypto backend to satisfy
 986   # the platform support requirements
 987   gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
 988                              method: 'pkg-config',
 989                              required: false,
 990                              kwargs: static_kwargs)
 991   if gnutls_crypto.found()
 992     gnutls = gnutls_crypto
 993   else
 994     # Our min version if all we need is TLS
 995     gnutls = dependency('gnutls', version: '>=3.5.18',
 996                         method: 'pkg-config',
 997                         required: get_option('gnutls'),
 998                         kwargs: static_kwargs)
 999   endif
1000 endif
1001
1002 # We prefer use of gnutls for crypto, unless the options
1003 # explicitly asked for nettle or gcrypt.
1004 #
1005 # If gnutls isn't available for crypto, then we'll prefer
1006 # gcrypt over nettle for performance reasons.
1007 gcrypt = not_found
1008 nettle = not_found
1009 xts = 'none'
1010
1011 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1012   error('Only one of gcrypt & nettle can be enabled')
1013 endif
1014
1015 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
1016 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1017   gnutls_crypto = not_found
1018 endif
1019
1020 if not gnutls_crypto.found()
1021   if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1022     gcrypt = dependency('libgcrypt', version: '>=1.8',
1023                         method: 'config-tool',
1024                         required: get_option('gcrypt'),
1025                         kwargs: static_kwargs)
1026     # Debian has removed -lgpg-error from libgcrypt-config
1027     # as it "spreads unnecessary dependencies" which in
1028     # turn breaks static builds...
1029     if gcrypt.found() and enable_static
1030       gcrypt = declare_dependency(dependencies: [
1031         gcrypt,
1032         cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
1033     endif
1034   endif
1035   if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1036     nettle = dependency('nettle', version: '>=3.4',
1037                         method: 'pkg-config',
1038                         required: get_option('nettle'),
1039                         kwargs: static_kwargs)
1040     if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1041       xts = 'private'
1042     endif
1043   endif
1044 endif
1045
1046 gtk = not_found
1047 gtkx11 = not_found
1048 vte = not_found
1049 if not get_option('gtk').auto() or (have_system and not cocoa.found())
1050   gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1051                    method: 'pkg-config',
1052                    required: get_option('gtk'),
1053                    kwargs: static_kwargs)
1054   if gtk.found()
1055     gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1056                         method: 'pkg-config',
1057                         required: false,
1058                         kwargs: static_kwargs)
1059     gtk = declare_dependency(dependencies: [gtk, gtkx11])
1060
1061     if not get_option('vte').auto() or have_system
1062       vte = dependency('vte-2.91',
1063                        method: 'pkg-config',
1064                        required: get_option('vte'),
1065                        kwargs: static_kwargs)
1066     endif
1067   endif
1068 endif
1069
1070 x11 = not_found
1071 if gtkx11.found()
1072   x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
1073                    kwargs: static_kwargs)
1074 endif
1075 vnc = not_found
1076 png = not_found
1077 jpeg = not_found
1078 sasl = not_found
1079 if have_system and not get_option('vnc').disabled()
1080   vnc = declare_dependency() # dummy dependency
1081   png = dependency('libpng', required: get_option('vnc_png'),
1082                    method: 'pkg-config', kwargs: static_kwargs)
1083   jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1084                     method: 'pkg-config', kwargs: static_kwargs)
1085   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1086                          required: get_option('vnc_sasl'),
1087                          kwargs: static_kwargs)
1088   if sasl.found()
1089     sasl = declare_dependency(dependencies: sasl,
1090                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
1091   endif
1092 endif
1093
1094 pam = not_found
1095 if not get_option('auth_pam').auto() or have_system
1096   pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1097                         required: get_option('auth_pam'),
1098                         kwargs: static_kwargs)
1099 endif
1100 if pam.found() and not cc.links('''
1101    #include <stddef.h>
1102    #include <security/pam_appl.h>
1103    int main(void) {
1104      const char *service_name = "qemu";
1105      const char *user = "frank";
1106      const struct pam_conv pam_conv = { 0 };
1107      pam_handle_t *pamh = NULL;
1108      pam_start(service_name, user, &pam_conv, &pamh);
1109      return 0;
1110    }''', dependencies: pam)
1111   pam = not_found
1112   if get_option('auth_pam').enabled()
1113     error('could not link libpam')
1114   else
1115     warning('could not link libpam, disabling')
1116   endif
1117 endif
1118
1119 snappy = not_found
1120 if not get_option('snappy').auto() or have_system
1121   snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1122                            required: get_option('snappy'),
1123                            kwargs: static_kwargs)
1124 endif
1125 if snappy.found() and not cc.links('''
1126    #include <snappy-c.h>
1127    int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1128   snappy = not_found
1129   if get_option('snappy').enabled()
1130     error('could not link libsnappy')
1131   else
1132     warning('could not link libsnappy, disabling')
1133   endif
1134 endif
1135
1136 lzo = not_found
1137 if not get_option('lzo').auto() or have_system
1138   lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1139                         required: get_option('lzo'),
1140                         kwargs: static_kwargs)
1141 endif
1142 if lzo.found() and not cc.links('''
1143    #include <lzo/lzo1x.h>
1144    int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1145   lzo = not_found
1146   if get_option('lzo').enabled()
1147     error('could not link liblzo2')
1148   else
1149     warning('could not link liblzo2, disabling')
1150   endif
1151 endif
1152
1153 rdma = not_found
1154 if 'CONFIG_RDMA' in config_host
1155   rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
1156 endif
1157 numa = not_found
1158 if 'CONFIG_NUMA' in config_host
1159   numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
1160 endif
1161 xen = not_found
1162 if 'CONFIG_XEN_BACKEND' in config_host
1163   xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
1164                            link_args: config_host['XEN_LIBS'].split())
1165 endif
1166 cacard = not_found
1167 if not get_option('smartcard').auto() or have_system
1168   cacard = dependency('libcacard', required: get_option('smartcard'),
1169                       version: '>=2.5.1', method: 'pkg-config',
1170                       kwargs: static_kwargs)
1171 endif
1172 u2f = not_found
1173 if have_system
1174   u2f = dependency('u2f-emu', required: get_option('u2f'),
1175                    method: 'pkg-config',
1176                    kwargs: static_kwargs)
1177 endif
1178 usbredir = not_found
1179 if not get_option('usb_redir').auto() or have_system
1180   usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1181                         version: '>=0.6', method: 'pkg-config',
1182                         kwargs: static_kwargs)
1183 endif
1184 libusb = not_found
1185 if not get_option('libusb').auto() or have_system
1186   libusb = dependency('libusb-1.0', required: get_option('libusb'),
1187                       version: '>=1.0.13', method: 'pkg-config',
1188                       kwargs: static_kwargs)
1189 endif
1190
1191 libpmem = not_found
1192 if not get_option('libpmem').auto() or have_system
1193   libpmem = dependency('libpmem', required: get_option('libpmem'),
1194                        method: 'pkg-config', kwargs: static_kwargs)
1195 endif
1196 libdaxctl = not_found
1197 if not get_option('libdaxctl').auto() or have_system
1198   libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1199                          version: '>=57', method: 'pkg-config',
1200                          kwargs: static_kwargs)
1201 endif
1202 tasn1 = not_found
1203 if gnutls.found()
1204   tasn1 = dependency('libtasn1',
1205                      method: 'pkg-config',
1206                      kwargs: static_kwargs)
1207 endif
1208 keyutils = dependency('libkeyutils', required: false,
1209                       method: 'pkg-config', kwargs: static_kwargs)
1210
1211 has_gettid = cc.has_function('gettid')
1212
1213 # Malloc tests
1214
1215 malloc = []
1216 if get_option('malloc') == 'system'
1217   has_malloc_trim = \
1218     not get_option('malloc_trim').disabled() and \
1219     cc.links('''#include <malloc.h>
1220                 int main(void) { malloc_trim(0); return 0; }''')
1221 else
1222   has_malloc_trim = false
1223   malloc = cc.find_library(get_option('malloc'), required: true)
1224 endif
1225 if not has_malloc_trim and get_option('malloc_trim').enabled()
1226   if get_option('malloc') == 'system'
1227     error('malloc_trim not available on this platform.')
1228   else
1229     error('malloc_trim not available with non-libc memory allocator')
1230   endif
1231 endif
1232
1233 # Check whether the glibc provides statx()
1234
1235 gnu_source_prefix = '''
1236   #ifndef _GNU_SOURCE
1237   #define _GNU_SOURCE
1238   #endif
1239 '''
1240 statx_test = gnu_source_prefix + '''
1241   #include <sys/stat.h>
1242   int main(void) {
1243     struct statx statxbuf;
1244     statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
1245     return 0;
1246   }'''
1247
1248 has_statx = cc.links(statx_test)
1249
1250 have_vhost_user_blk_server = (targetos == 'linux' and
1251     'CONFIG_VHOST_USER' in config_host)
1252
1253 if get_option('vhost_user_blk_server').enabled()
1254     if targetos != 'linux'
1255         error('vhost_user_blk_server requires linux')
1256     elif 'CONFIG_VHOST_USER' not in config_host
1257         error('vhost_user_blk_server requires vhost-user support')
1258     endif
1259 elif get_option('vhost_user_blk_server').disabled() or not have_system
1260     have_vhost_user_blk_server = false
1261 endif
1262
1263
1264 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1265   error('Cannot enable fuse-lseek while fuse is disabled')
1266 endif
1267
1268 fuse = dependency('fuse3', required: get_option('fuse'),
1269                   version: '>=3.1', method: 'pkg-config',
1270                   kwargs: static_kwargs)
1271
1272 fuse_lseek = not_found
1273 if not get_option('fuse_lseek').disabled()
1274   if fuse.version().version_compare('>=3.8')
1275     # Dummy dependency
1276     fuse_lseek = declare_dependency()
1277   elif get_option('fuse_lseek').enabled()
1278     if fuse.found()
1279       error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1280     else
1281       error('fuse-lseek requires libfuse, which was not found')
1282     endif
1283   endif
1284 endif
1285
1286 # libbpf
1287 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1288 if libbpf.found() and not cc.links('''
1289    #include <bpf/libbpf.h>
1290    int main(void)
1291    {
1292      bpf_object__destroy_skeleton(NULL);
1293      return 0;
1294    }''', dependencies: libbpf)
1295   libbpf = not_found
1296   if get_option('bpf').enabled()
1297     error('libbpf skeleton test failed')
1298   else
1299     warning('libbpf skeleton test failed, disabling')
1300   endif
1301 endif
1302
1303 #################
1304 # config-host.h #
1305 #################
1306
1307 audio_drivers_selected = []
1308 if have_system
1309   audio_drivers_available = {
1310     'alsa': alsa.found(),
1311     'coreaudio': coreaudio.found(),
1312     'dsound': dsound.found(),
1313     'jack': jack.found(),
1314     'oss': oss.found(),
1315     'pa': pulse.found(),
1316     'sdl': sdl.found(),
1317   }
1318   foreach k, v: audio_drivers_available
1319     config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
1320   endforeach
1321
1322   # Default to native drivers first, OSS second, SDL third
1323   audio_drivers_priority = \
1324     [ 'pa', 'coreaudio', 'dsound', 'oss' ] + \
1325     (targetos == 'linux' ? [] : [ 'sdl' ])
1326   audio_drivers_default = []
1327   foreach k: audio_drivers_priority
1328     if audio_drivers_available[k]
1329       audio_drivers_default += k
1330     endif
1331   endforeach
1332
1333   foreach k: get_option('audio_drv_list')
1334     if k == 'default'
1335       audio_drivers_selected += audio_drivers_default
1336     elif not audio_drivers_available[k]
1337       error('Audio driver "@0@" not available.'.format(k))
1338     else
1339       audio_drivers_selected += k
1340     endif
1341   endforeach
1342 endif
1343 config_host_data.set('CONFIG_AUDIO_DRIVERS',
1344                      '"' + '", "'.join(audio_drivers_selected) + '", ')
1345
1346 if get_option('cfi')
1347   cfi_flags=[]
1348   # Check for dependency on LTO
1349   if not get_option('b_lto')
1350     error('Selected Control-Flow Integrity but LTO is disabled')
1351   endif
1352   if config_host.has_key('CONFIG_MODULES')
1353     error('Selected Control-Flow Integrity is not compatible with modules')
1354   endif
1355   # Check for cfi flags. CFI requires LTO so we can't use
1356   # get_supported_arguments, but need a more complex "compiles" which allows
1357   # custom arguments
1358   if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1359                  args: ['-flto', '-fsanitize=cfi-icall'] )
1360     cfi_flags += '-fsanitize=cfi-icall'
1361   else
1362     error('-fsanitize=cfi-icall is not supported by the compiler')
1363   endif
1364   if cc.compiles('int main () { return 0; }',
1365                  name: '-fsanitize-cfi-icall-generalize-pointers',
1366                  args: ['-flto', '-fsanitize=cfi-icall',
1367                         '-fsanitize-cfi-icall-generalize-pointers'] )
1368     cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1369   else
1370     error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1371   endif
1372   if get_option('cfi_debug')
1373     if cc.compiles('int main () { return 0; }',
1374                    name: '-fno-sanitize-trap=cfi-icall',
1375                    args: ['-flto', '-fsanitize=cfi-icall',
1376                           '-fno-sanitize-trap=cfi-icall'] )
1377       cfi_flags += '-fno-sanitize-trap=cfi-icall'
1378     else
1379       error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1380     endif
1381   endif
1382   add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1383   add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1384 endif
1385
1386 have_host_block_device = (targetos != 'darwin' or
1387     cc.has_header('IOKit/storage/IOMedia.h'))
1388
1389 have_virtfs = (targetos == 'linux' and
1390     have_system and
1391     libattr.found() and
1392     libcap_ng.found())
1393
1394 have_virtfs_proxy_helper = have_virtfs and have_tools
1395
1396 if get_option('virtfs').enabled()
1397   if not have_virtfs
1398     if targetos != 'linux'
1399       error('virtio-9p (virtfs) requires Linux')
1400     elif not libcap_ng.found() or not libattr.found()
1401       error('virtio-9p (virtfs) requires libcap-ng-devel and libattr-devel')
1402     elif not have_system
1403       error('virtio-9p (virtfs) needs system emulation support')
1404     endif
1405   endif
1406 elif get_option('virtfs').disabled()
1407   have_virtfs = false
1408 endif
1409
1410 foreach k : get_option('trace_backends')
1411   config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
1412 endforeach
1413 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
1414
1415 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1416 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1417 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1418 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1419 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1420 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1421 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1422 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1423 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1424 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1425 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1426 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1427
1428 config_host_data.set('CONFIG_ATTR', libattr.found())
1429 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1430 config_host_data.set('CONFIG_COCOA', cocoa.found())
1431 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
1432 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
1433 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1434 config_host_data.set('CONFIG_LZO', lzo.found())
1435 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1436 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1437 config_host_data.set('CONFIG_CURL', curl.found())
1438 config_host_data.set('CONFIG_CURSES', curses.found())
1439 config_host_data.set('CONFIG_GBM', gbm.found())
1440 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1441 if glusterfs.found()
1442   config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1443   config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1444   config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1445   config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1446   config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1447   config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1448 endif
1449 config_host_data.set('CONFIG_GTK', gtk.found())
1450 config_host_data.set('CONFIG_VTE', vte.found())
1451 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1452 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1453 config_host_data.set('CONFIG_EBPF', libbpf.found())
1454 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
1455 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1456 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1457 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
1458 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
1459 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
1460 config_host_data.set('CONFIG_RBD', rbd.found())
1461 config_host_data.set('CONFIG_SDL', sdl.found())
1462 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1463 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1464 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1465 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1466 config_host_data.set('CONFIG_VDE', vde.found())
1467 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1468 config_host_data.set('CONFIG_VNC', vnc.found())
1469 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1470 config_host_data.set('CONFIG_VNC_PNG', png.found())
1471 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1472 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1473 config_host_data.set('CONFIG_VTE', vte.found())
1474 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1475 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1476 config_host_data.set('CONFIG_GETTID', has_gettid)
1477 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1478 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
1479 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1480 config_host_data.set('CONFIG_NETTLE', nettle.found())
1481 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1482 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1483 config_host_data.set('CONFIG_STATX', has_statx)
1484 config_host_data.set('CONFIG_ZSTD', zstd.found())
1485 config_host_data.set('CONFIG_FUSE', fuse.found())
1486 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1487 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
1488 config_host_data.set('CONFIG_SPICE', spice.found())
1489 config_host_data.set('CONFIG_X11', x11.found())
1490 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1491 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1492 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1493 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1494 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1495
1496 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
1497 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
1498 config_host_data.set('HOST_WORDS_BIGENDIAN', host_machine.endian() == 'big')
1499
1500 # has_header
1501 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1502 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1503 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1504 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1505 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1506 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1507 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1508 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1509 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1510
1511 # has_function
1512 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1513 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1514 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1515 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1516 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1517 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign'))
1518 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1519 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1520 config_host_data.set('CONFIG_SEM_TIMEDWAIT', cc.has_function('sem_timedwait', dependencies: threads))
1521 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1522 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1523 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1524 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1525 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1526 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1527 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1528 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1529 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1530
1531 # has_header_symbol
1532 config_host_data.set('CONFIG_BYTESWAP_H',
1533                      cc.has_header_symbol('byteswap.h', 'bswap_32'))
1534 config_host_data.set('CONFIG_EPOLL_CREATE1',
1535                      cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1536 config_host_data.set('CONFIG_HAS_ENVIRON',
1537                      cc.has_header_symbol('unistd.h', 'environ', prefix: gnu_source_prefix))
1538 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1539                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1540                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1541 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1542                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1543 config_host_data.set('CONFIG_FIEMAP',
1544                      cc.has_header('linux/fiemap.h') and
1545                      cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1546 config_host_data.set('CONFIG_GETRANDOM',
1547                      cc.has_function('getrandom') and
1548                      cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1549 config_host_data.set('CONFIG_INOTIFY',
1550                      cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1551 config_host_data.set('CONFIG_INOTIFY1',
1552                      cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1553 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1554                      cc.has_header_symbol('machine/bswap.h', 'bswap32',
1555                                           prefix: '''#include <sys/endian.h>
1556                                                      #include <sys/types.h>'''))
1557 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1558                      cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1559 config_host_data.set('CONFIG_RTNETLINK',
1560                      cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1561 config_host_data.set('CONFIG_SYSMACROS',
1562                      cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1563 config_host_data.set('HAVE_OPTRESET',
1564                      cc.has_header_symbol('getopt.h', 'optreset'))
1565 config_host_data.set('HAVE_UTMPX',
1566                      cc.has_header_symbol('utmpx.h', 'struct utmpx'))
1567 config_host_data.set('HAVE_IPPROTO_MPTCP',
1568                      cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
1569
1570 # has_member
1571 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1572                      cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1573                                    prefix: '#include <signal.h>'))
1574 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1575                      cc.has_member('struct stat', 'st_atim',
1576                                    prefix: '#include <sys/stat.h>'))
1577
1578 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1579   #include <sys/eventfd.h>
1580   int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1581 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1582   #include <unistd.h>
1583   int main(void) {
1584   #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1585   return fdatasync(0);
1586   #else
1587   #error Not supported
1588   #endif
1589   }'''))
1590 config_host_data.set('CONFIG_MADVISE', cc.links(gnu_source_prefix + '''
1591   #include <sys/types.h>
1592   #include <sys/mman.h>
1593   #include <stddef.h>
1594   int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }'''))
1595 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1596   #include <sys/mman.h>
1597   int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1598 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1599   #include <fcntl.h>
1600   #if !defined(AT_EMPTY_PATH)
1601   # error missing definition
1602   #else
1603   int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1604   #endif'''))
1605 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1606   #include <unistd.h>
1607   #include <fcntl.h>
1608
1609   int main(void)
1610   {
1611       int pipefd[2];
1612       return pipe2(pipefd, O_CLOEXEC);
1613   }'''))
1614 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1615   #include <sys/mman.h>
1616   #include <stddef.h>
1617   int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1618
1619 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links('''
1620   #include <pthread.h>
1621
1622   static void *f(void *p) { return NULL; }
1623   int main(void)
1624   {
1625     pthread_t thread;
1626     pthread_create(&thread, 0, f, 0);
1627     pthread_setname_np(thread, "QEMU");
1628     return 0;
1629   }''', dependencies: threads))
1630 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links('''
1631   #include <pthread.h>
1632
1633   static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
1634   int main(void)
1635   {
1636     pthread_t thread;
1637     pthread_create(&thread, 0, f, 0);
1638     return 0;
1639   }''', dependencies: threads))
1640
1641 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1642   #include <sys/signalfd.h>
1643   #include <stddef.h>
1644   int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
1645 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1646   #include <unistd.h>
1647   #include <fcntl.h>
1648   #include <limits.h>
1649
1650   int main(void)
1651   {
1652     int len, fd = 0;
1653     len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1654     splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1655     return 0;
1656   }'''))
1657
1658 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
1659   #include <sys/mman.h>
1660   int main(int argc, char *argv[]) {
1661     return mlockall(MCL_FUTURE);
1662   }'''))
1663
1664 have_netmap = false
1665 if not get_option('netmap').disabled() and have_system
1666   have_netmap = cc.compiles('''
1667     #include <inttypes.h>
1668     #include <net/if.h>
1669     #include <net/netmap.h>
1670     #include <net/netmap_user.h>
1671     #if (NETMAP_API < 11) || (NETMAP_API > 15)
1672     #error
1673     #endif
1674     int main(void) { return 0; }''')
1675   if not have_netmap and get_option('netmap').enabled()
1676     error('Netmap headers not available')
1677   endif
1678 endif
1679 config_host_data.set('CONFIG_NETMAP', have_netmap)
1680
1681 # Work around a system header bug with some kernel/XFS header
1682 # versions where they both try to define 'struct fsxattr':
1683 # xfs headers will not try to redefine structs from linux headers
1684 # if this macro is set.
1685 config_host_data.set('HAVE_FSXATTR', cc.links('''
1686   #include <linux/fs.h>'
1687   struct fsxattr foo;
1688   int main(void) {
1689     return 0;
1690   }'''))
1691
1692 # Some versions of Mac OS X incorrectly define SIZE_MAX
1693 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1694     #include <stdint.h>
1695     #include <stdio.h>
1696     int main(int argc, char *argv[]) {
1697         return printf("%zu", SIZE_MAX);
1698     }''', args: ['-Werror']))
1699
1700 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
1701     'HAVE_GDB_BIN']
1702 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1703 strings = ['CONFIG_IASL']
1704 foreach k, v: config_host
1705   if ignored.contains(k)
1706     # do nothing
1707   elif arrays.contains(k)
1708     if v != ''
1709       v = '"' + '", "'.join(v.split()) + '", '
1710     endif
1711     config_host_data.set(k, v)
1712   elif k == 'ARCH'
1713     config_host_data.set('HOST_' + v.to_upper(), 1)
1714   elif strings.contains(k)
1715     config_host_data.set_quoted(k, v)
1716   elif k.startswith('CONFIG_')
1717     config_host_data.set(k, v == 'y' ? 1 : v)
1718   endif
1719 endforeach
1720
1721 ########################
1722 # Target configuration #
1723 ########################
1724
1725 minikconf = find_program('scripts/minikconf.py')
1726 config_all = {}
1727 config_all_devices = {}
1728 config_all_disas = {}
1729 config_devices_mak_list = []
1730 config_devices_h = {}
1731 config_target_h = {}
1732 config_target_mak = {}
1733
1734 disassemblers = {
1735   'alpha' : ['CONFIG_ALPHA_DIS'],
1736   'arm' : ['CONFIG_ARM_DIS'],
1737   'avr' : ['CONFIG_AVR_DIS'],
1738   'cris' : ['CONFIG_CRIS_DIS'],
1739   'hexagon' : ['CONFIG_HEXAGON_DIS'],
1740   'hppa' : ['CONFIG_HPPA_DIS'],
1741   'i386' : ['CONFIG_I386_DIS'],
1742   'x86_64' : ['CONFIG_I386_DIS'],
1743   'x32' : ['CONFIG_I386_DIS'],
1744   'm68k' : ['CONFIG_M68K_DIS'],
1745   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
1746   'mips' : ['CONFIG_MIPS_DIS'],
1747   'nios2' : ['CONFIG_NIOS2_DIS'],
1748   'or1k' : ['CONFIG_OPENRISC_DIS'],
1749   'ppc' : ['CONFIG_PPC_DIS'],
1750   'riscv' : ['CONFIG_RISCV_DIS'],
1751   'rx' : ['CONFIG_RX_DIS'],
1752   's390' : ['CONFIG_S390_DIS'],
1753   'sh4' : ['CONFIG_SH4_DIS'],
1754   'sparc' : ['CONFIG_SPARC_DIS'],
1755   'xtensa' : ['CONFIG_XTENSA_DIS'],
1756 }
1757 if link_language == 'cpp'
1758   disassemblers += {
1759     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
1760     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
1761     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
1762   }
1763 endif
1764
1765 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
1766 host_kconfig = \
1767   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
1768   ('CONFIG_TPM' in config_host ? ['CONFIG_TPM=y'] : []) + \
1769   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
1770   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
1771   ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
1772   (x11.found() ? ['CONFIG_X11=y'] : []) + \
1773   ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
1774   ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
1775   ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
1776   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
1777   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
1778   ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
1779   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
1780
1781 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
1782
1783 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
1784 actual_target_dirs = []
1785 fdt_required = []
1786 foreach target : target_dirs
1787   config_target = { 'TARGET_NAME': target.split('-')[0] }
1788   if target.endswith('linux-user')
1789     if targetos != 'linux'
1790       if default_targets
1791         continue
1792       endif
1793       error('Target @0@ is only available on a Linux host'.format(target))
1794     endif
1795     config_target += { 'CONFIG_LINUX_USER': 'y' }
1796   elif target.endswith('bsd-user')
1797     if 'CONFIG_BSD' not in config_host
1798       if default_targets
1799         continue
1800       endif
1801       error('Target @0@ is only available on a BSD host'.format(target))
1802     endif
1803     config_target += { 'CONFIG_BSD_USER': 'y' }
1804   elif target.endswith('softmmu')
1805     config_target += { 'CONFIG_SOFTMMU': 'y' }
1806   endif
1807   if target.endswith('-user')
1808     config_target += {
1809       'CONFIG_USER_ONLY': 'y',
1810       'CONFIG_QEMU_INTERP_PREFIX':
1811         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
1812     }
1813   endif
1814
1815   accel_kconfig = []
1816   foreach sym: accelerators
1817     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
1818       config_target += { sym: 'y' }
1819       config_all += { sym: 'y' }
1820       if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
1821         config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
1822       elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
1823         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
1824       endif
1825       if target in modular_tcg
1826         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
1827       else
1828         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
1829       endif
1830       accel_kconfig += [ sym + '=y' ]
1831     endif
1832   endforeach
1833   if accel_kconfig.length() == 0
1834     if default_targets
1835       continue
1836     endif
1837     error('No accelerator available for target @0@'.format(target))
1838   endif
1839
1840   actual_target_dirs += target
1841   config_target += keyval.load('configs/targets' / target + '.mak')
1842   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
1843
1844   if 'TARGET_NEED_FDT' in config_target
1845     fdt_required += target
1846   endif
1847
1848   # Add default keys
1849   if 'TARGET_BASE_ARCH' not in config_target
1850     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
1851   endif
1852   if 'TARGET_ABI_DIR' not in config_target
1853     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
1854   endif
1855
1856   foreach k, v: disassemblers
1857     if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
1858       foreach sym: v
1859         config_target += { sym: 'y' }
1860         config_all_disas += { sym: 'y' }
1861       endforeach
1862     endif
1863   endforeach
1864
1865   config_target_data = configuration_data()
1866   foreach k, v: config_target
1867     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
1868       # do nothing
1869     elif ignored.contains(k)
1870       # do nothing
1871     elif k == 'TARGET_BASE_ARCH'
1872       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
1873       # not used to select files from sourcesets.
1874       config_target_data.set('TARGET_' + v.to_upper(), 1)
1875     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
1876       config_target_data.set_quoted(k, v)
1877     elif v == 'y'
1878       config_target_data.set(k, 1)
1879     else
1880       config_target_data.set(k, v)
1881     endif
1882   endforeach
1883   config_target_data.set('QEMU_ARCH',
1884                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
1885   config_target_h += {target: configure_file(output: target + '-config-target.h',
1886                                                configuration: config_target_data)}
1887
1888   if target.endswith('-softmmu')
1889     config_input = meson.get_external_property(target, 'default')
1890     config_devices_mak = target + '-config-devices.mak'
1891     config_devices_mak = configure_file(
1892       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
1893       output: config_devices_mak,
1894       depfile: config_devices_mak + '.d',
1895       capture: true,
1896       command: [minikconf,
1897                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
1898                 config_devices_mak, '@DEPFILE@', '@INPUT@',
1899                 host_kconfig, accel_kconfig,
1900                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
1901
1902     config_devices_data = configuration_data()
1903     config_devices = keyval.load(config_devices_mak)
1904     foreach k, v: config_devices
1905       config_devices_data.set(k, 1)
1906     endforeach
1907     config_devices_mak_list += config_devices_mak
1908     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
1909                                                 configuration: config_devices_data)}
1910     config_target += config_devices
1911     config_all_devices += config_devices
1912   endif
1913   config_target_mak += {target: config_target}
1914 endforeach
1915 target_dirs = actual_target_dirs
1916
1917 # This configuration is used to build files that are shared by
1918 # multiple binaries, and then extracted out of the "common"
1919 # static_library target.
1920 #
1921 # We do not use all_sources()/all_dependencies(), because it would
1922 # build literally all source files, including devices only used by
1923 # targets that are not built for this compilation.  The CONFIG_ALL
1924 # pseudo symbol replaces it.
1925
1926 config_all += config_all_devices
1927 config_all += config_host
1928 config_all += config_all_disas
1929 config_all += {
1930   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
1931   'CONFIG_SOFTMMU': have_system,
1932   'CONFIG_USER_ONLY': have_user,
1933   'CONFIG_ALL': true,
1934 }
1935
1936 ##############
1937 # Submodules #
1938 ##############
1939
1940 capstone = not_found
1941 capstone_opt = get_option('capstone')
1942 if capstone_opt in ['enabled', 'auto', 'system']
1943   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
1944   capstone = dependency('capstone', version: '>=4.0',
1945                         kwargs: static_kwargs, method: 'pkg-config',
1946                         required: capstone_opt == 'system' or
1947                                   capstone_opt == 'enabled' and not have_internal)
1948
1949   # Some versions of capstone have broken pkg-config file
1950   # that reports a wrong -I path, causing the #include to
1951   # fail later. If the system has such a broken version
1952   # do not use it.
1953   if capstone.found() and not cc.compiles('#include <capstone.h>',
1954                                           dependencies: [capstone])
1955     capstone = not_found
1956     if capstone_opt == 'system'
1957       error('system capstone requested, it does not appear to work')
1958     endif
1959   endif
1960
1961   if capstone.found()
1962     capstone_opt = 'system'
1963   elif have_internal
1964     capstone_opt = 'internal'
1965   else
1966     capstone_opt = 'disabled'
1967   endif
1968 endif
1969 if capstone_opt == 'internal'
1970   capstone_data = configuration_data()
1971   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
1972
1973   capstone_files = files(
1974     'capstone/cs.c',
1975     'capstone/MCInst.c',
1976     'capstone/MCInstrDesc.c',
1977     'capstone/MCRegisterInfo.c',
1978     'capstone/SStream.c',
1979     'capstone/utils.c'
1980   )
1981
1982   if 'CONFIG_ARM_DIS' in config_all_disas
1983     capstone_data.set('CAPSTONE_HAS_ARM', '1')
1984     capstone_files += files(
1985       'capstone/arch/ARM/ARMDisassembler.c',
1986       'capstone/arch/ARM/ARMInstPrinter.c',
1987       'capstone/arch/ARM/ARMMapping.c',
1988       'capstone/arch/ARM/ARMModule.c'
1989     )
1990   endif
1991
1992   # FIXME: This config entry currently depends on a c++ compiler.
1993   # Which is needed for building libvixl, but not for capstone.
1994   if 'CONFIG_ARM_A64_DIS' in config_all_disas
1995     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
1996     capstone_files += files(
1997       'capstone/arch/AArch64/AArch64BaseInfo.c',
1998       'capstone/arch/AArch64/AArch64Disassembler.c',
1999       'capstone/arch/AArch64/AArch64InstPrinter.c',
2000       'capstone/arch/AArch64/AArch64Mapping.c',
2001       'capstone/arch/AArch64/AArch64Module.c'
2002     )
2003   endif
2004
2005   if 'CONFIG_PPC_DIS' in config_all_disas
2006     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2007     capstone_files += files(
2008       'capstone/arch/PowerPC/PPCDisassembler.c',
2009       'capstone/arch/PowerPC/PPCInstPrinter.c',
2010       'capstone/arch/PowerPC/PPCMapping.c',
2011       'capstone/arch/PowerPC/PPCModule.c'
2012     )
2013   endif
2014
2015   if 'CONFIG_S390_DIS' in config_all_disas
2016     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2017     capstone_files += files(
2018       'capstone/arch/SystemZ/SystemZDisassembler.c',
2019       'capstone/arch/SystemZ/SystemZInstPrinter.c',
2020       'capstone/arch/SystemZ/SystemZMapping.c',
2021       'capstone/arch/SystemZ/SystemZModule.c',
2022       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2023     )
2024   endif
2025
2026   if 'CONFIG_I386_DIS' in config_all_disas
2027     capstone_data.set('CAPSTONE_HAS_X86', 1)
2028     capstone_files += files(
2029       'capstone/arch/X86/X86Disassembler.c',
2030       'capstone/arch/X86/X86DisassemblerDecoder.c',
2031       'capstone/arch/X86/X86ATTInstPrinter.c',
2032       'capstone/arch/X86/X86IntelInstPrinter.c',
2033       'capstone/arch/X86/X86InstPrinterCommon.c',
2034       'capstone/arch/X86/X86Mapping.c',
2035       'capstone/arch/X86/X86Module.c'
2036     )
2037   endif
2038
2039   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2040
2041   capstone_cargs = [
2042     # FIXME: There does not seem to be a way to completely replace the c_args
2043     # that come from add_project_arguments() -- we can only add to them.
2044     # So: disable all warnings with a big hammer.
2045     '-Wno-error', '-w',
2046
2047     # Include all configuration defines via a header file, which will wind up
2048     # as a dependency on the object file, and thus changes here will result
2049     # in a rebuild.
2050     '-include', 'capstone-defs.h'
2051   ]
2052
2053   libcapstone = static_library('capstone',
2054                                build_by_default: false,
2055                                sources: capstone_files,
2056                                c_args: capstone_cargs,
2057                                include_directories: 'capstone/include')
2058   capstone = declare_dependency(link_with: libcapstone,
2059                                 include_directories: 'capstone/include/capstone')
2060 endif
2061
2062 slirp = not_found
2063 slirp_opt = 'disabled'
2064 if have_system
2065   slirp_opt = get_option('slirp')
2066   if slirp_opt in ['enabled', 'auto', 'system']
2067     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2068     slirp = dependency('slirp', kwargs: static_kwargs,
2069                        method: 'pkg-config',
2070                        required: slirp_opt == 'system' or
2071                                  slirp_opt == 'enabled' and not have_internal)
2072     if slirp.found()
2073       slirp_opt = 'system'
2074     elif have_internal
2075       slirp_opt = 'internal'
2076     else
2077       slirp_opt = 'disabled'
2078     endif
2079   endif
2080   if slirp_opt == 'internal'
2081     slirp_deps = []
2082     if targetos == 'windows'
2083       slirp_deps = cc.find_library('iphlpapi')
2084     elif targetos == 'darwin'
2085       slirp_deps = cc.find_library('resolv')
2086     endif
2087     slirp_conf = configuration_data()
2088     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2089     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2090     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2091     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2092     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2093     slirp_files = [
2094       'slirp/src/arp_table.c',
2095       'slirp/src/bootp.c',
2096       'slirp/src/cksum.c',
2097       'slirp/src/dhcpv6.c',
2098       'slirp/src/dnssearch.c',
2099       'slirp/src/if.c',
2100       'slirp/src/ip6_icmp.c',
2101       'slirp/src/ip6_input.c',
2102       'slirp/src/ip6_output.c',
2103       'slirp/src/ip_icmp.c',
2104       'slirp/src/ip_input.c',
2105       'slirp/src/ip_output.c',
2106       'slirp/src/mbuf.c',
2107       'slirp/src/misc.c',
2108       'slirp/src/ncsi.c',
2109       'slirp/src/ndp_table.c',
2110       'slirp/src/sbuf.c',
2111       'slirp/src/slirp.c',
2112       'slirp/src/socket.c',
2113       'slirp/src/state.c',
2114       'slirp/src/stream.c',
2115       'slirp/src/tcp_input.c',
2116       'slirp/src/tcp_output.c',
2117       'slirp/src/tcp_subr.c',
2118       'slirp/src/tcp_timer.c',
2119       'slirp/src/tftp.c',
2120       'slirp/src/udp.c',
2121       'slirp/src/udp6.c',
2122       'slirp/src/util.c',
2123       'slirp/src/version.c',
2124       'slirp/src/vmstate.c',
2125     ]
2126
2127     configure_file(
2128       input : 'slirp/src/libslirp-version.h.in',
2129       output : 'libslirp-version.h',
2130       configuration: slirp_conf)
2131
2132     slirp_inc = include_directories('slirp', 'slirp/src')
2133     libslirp = static_library('slirp',
2134                               build_by_default: false,
2135                               sources: slirp_files,
2136                               c_args: slirp_cargs,
2137                               include_directories: slirp_inc)
2138     slirp = declare_dependency(link_with: libslirp,
2139                                dependencies: slirp_deps,
2140                                include_directories: slirp_inc)
2141   endif
2142 endif
2143
2144 # For CFI, we need to compile slirp as a static library together with qemu.
2145 # This is because we register slirp functions as callbacks for QEMU Timers.
2146 # When using a system-wide shared libslirp, the type information for the
2147 # callback is missing and the timer call produces a false positive with CFI.
2148 #
2149 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2150 # with control-flow integrity.
2151 if get_option('cfi') and slirp_opt == 'system'
2152   error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2153          + ' Please configure with --enable-slirp=git')
2154 endif
2155
2156 fdt = not_found
2157 fdt_opt = get_option('fdt')
2158 if have_system
2159   if fdt_opt in ['enabled', 'auto', 'system']
2160     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2161     fdt = cc.find_library('fdt', kwargs: static_kwargs,
2162                           required: fdt_opt == 'system' or
2163                                     fdt_opt == 'enabled' and not have_internal)
2164     if fdt.found() and cc.links('''
2165        #include <libfdt.h>
2166        #include <libfdt_env.h>
2167        int main(void) { fdt_check_full(NULL, 0); return 0; }''',
2168          dependencies: fdt)
2169       fdt_opt = 'system'
2170     elif fdt_opt == 'system'
2171        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2172     elif have_internal
2173       fdt_opt = 'internal'
2174     else
2175       fdt_opt = 'disabled'
2176       fdt = not_found
2177     endif
2178   endif
2179   if fdt_opt == 'internal'
2180     fdt_files = files(
2181       'dtc/libfdt/fdt.c',
2182       'dtc/libfdt/fdt_ro.c',
2183       'dtc/libfdt/fdt_wip.c',
2184       'dtc/libfdt/fdt_sw.c',
2185       'dtc/libfdt/fdt_rw.c',
2186       'dtc/libfdt/fdt_strerror.c',
2187       'dtc/libfdt/fdt_empty_tree.c',
2188       'dtc/libfdt/fdt_addresses.c',
2189       'dtc/libfdt/fdt_overlay.c',
2190       'dtc/libfdt/fdt_check.c',
2191     )
2192
2193     fdt_inc = include_directories('dtc/libfdt')
2194     libfdt = static_library('fdt',
2195                             build_by_default: false,
2196                             sources: fdt_files,
2197                             include_directories: fdt_inc)
2198     fdt = declare_dependency(link_with: libfdt,
2199                              include_directories: fdt_inc)
2200   endif
2201 endif
2202 if not fdt.found() and fdt_required.length() > 0
2203   error('fdt not available but required by targets ' + ', '.join(fdt_required))
2204 endif
2205
2206 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2207 config_host_data.set('CONFIG_FDT', fdt.found())
2208 config_host_data.set('CONFIG_SLIRP', slirp.found())
2209
2210 #####################
2211 # Generated sources #
2212 #####################
2213
2214 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2215
2216 hxtool = find_program('scripts/hxtool')
2217 shaderinclude = find_program('scripts/shaderinclude.pl')
2218 qapi_gen = find_program('scripts/qapi-gen.py')
2219 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2220                      meson.current_source_dir() / 'scripts/qapi/commands.py',
2221                      meson.current_source_dir() / 'scripts/qapi/common.py',
2222                      meson.current_source_dir() / 'scripts/qapi/error.py',
2223                      meson.current_source_dir() / 'scripts/qapi/events.py',
2224                      meson.current_source_dir() / 'scripts/qapi/expr.py',
2225                      meson.current_source_dir() / 'scripts/qapi/gen.py',
2226                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
2227                      meson.current_source_dir() / 'scripts/qapi/parser.py',
2228                      meson.current_source_dir() / 'scripts/qapi/schema.py',
2229                      meson.current_source_dir() / 'scripts/qapi/source.py',
2230                      meson.current_source_dir() / 'scripts/qapi/types.py',
2231                      meson.current_source_dir() / 'scripts/qapi/visit.py',
2232                      meson.current_source_dir() / 'scripts/qapi/common.py',
2233                      meson.current_source_dir() / 'scripts/qapi-gen.py'
2234 ]
2235
2236 tracetool = [
2237   python, files('scripts/tracetool.py'),
2238    '--backend=' + ','.join(get_option('trace_backends'))
2239 ]
2240 tracetool_depends = files(
2241   'scripts/tracetool/backend/log.py',
2242   'scripts/tracetool/backend/__init__.py',
2243   'scripts/tracetool/backend/dtrace.py',
2244   'scripts/tracetool/backend/ftrace.py',
2245   'scripts/tracetool/backend/simple.py',
2246   'scripts/tracetool/backend/syslog.py',
2247   'scripts/tracetool/backend/ust.py',
2248   'scripts/tracetool/format/tcg_h.py',
2249   'scripts/tracetool/format/ust_events_c.py',
2250   'scripts/tracetool/format/ust_events_h.py',
2251   'scripts/tracetool/format/__init__.py',
2252   'scripts/tracetool/format/d.py',
2253   'scripts/tracetool/format/tcg_helper_c.py',
2254   'scripts/tracetool/format/simpletrace_stap.py',
2255   'scripts/tracetool/format/c.py',
2256   'scripts/tracetool/format/h.py',
2257   'scripts/tracetool/format/tcg_helper_h.py',
2258   'scripts/tracetool/format/log_stap.py',
2259   'scripts/tracetool/format/stap.py',
2260   'scripts/tracetool/format/tcg_helper_wrapper_h.py',
2261   'scripts/tracetool/__init__.py',
2262   'scripts/tracetool/transform.py',
2263   'scripts/tracetool/vcpu.py'
2264 )
2265
2266 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2267                     meson.current_source_dir(),
2268                     config_host['PKGVERSION'], meson.project_version()]
2269 qemu_version = custom_target('qemu-version.h',
2270                              output: 'qemu-version.h',
2271                              command: qemu_version_cmd,
2272                              capture: true,
2273                              build_by_default: true,
2274                              build_always_stale: true)
2275 genh += qemu_version
2276
2277 hxdep = []
2278 hx_headers = [
2279   ['qemu-options.hx', 'qemu-options.def'],
2280   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2281 ]
2282 if have_system
2283   hx_headers += [
2284     ['hmp-commands.hx', 'hmp-commands.h'],
2285     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2286   ]
2287 endif
2288 foreach d : hx_headers
2289   hxdep += custom_target(d[1],
2290                 input: files(d[0]),
2291                 output: d[1],
2292                 capture: true,
2293                 build_by_default: true, # to be removed when added to a target
2294                 command: [hxtool, '-h', '@INPUT0@'])
2295 endforeach
2296 genh += hxdep
2297
2298 ###################
2299 # Collect sources #
2300 ###################
2301
2302 authz_ss = ss.source_set()
2303 blockdev_ss = ss.source_set()
2304 block_ss = ss.source_set()
2305 bsd_user_ss = ss.source_set()
2306 chardev_ss = ss.source_set()
2307 common_ss = ss.source_set()
2308 crypto_ss = ss.source_set()
2309 io_ss = ss.source_set()
2310 linux_user_ss = ss.source_set()
2311 qmp_ss = ss.source_set()
2312 qom_ss = ss.source_set()
2313 softmmu_ss = ss.source_set()
2314 specific_fuzz_ss = ss.source_set()
2315 specific_ss = ss.source_set()
2316 stub_ss = ss.source_set()
2317 trace_ss = ss.source_set()
2318 user_ss = ss.source_set()
2319 util_ss = ss.source_set()
2320
2321 # accel modules
2322 qtest_module_ss = ss.source_set()
2323 tcg_module_ss = ss.source_set()
2324
2325 modules = {}
2326 target_modules = {}
2327 hw_arch = {}
2328 target_arch = {}
2329 target_softmmu_arch = {}
2330 target_user_arch = {}
2331
2332 ###############
2333 # Trace files #
2334 ###############
2335
2336 # TODO: add each directory to the subdirs from its own meson.build, once
2337 # we have those
2338 trace_events_subdirs = [
2339   'crypto',
2340   'qapi',
2341   'qom',
2342   'monitor',
2343   'util',
2344 ]
2345 if have_user
2346   trace_events_subdirs += [ 'linux-user' ]
2347 endif
2348 if have_block
2349   trace_events_subdirs += [
2350     'authz',
2351     'block',
2352     'io',
2353     'nbd',
2354     'scsi',
2355   ]
2356 endif
2357 if have_system
2358   trace_events_subdirs += [
2359     'accel/kvm',
2360     'audio',
2361     'backends',
2362     'backends/tpm',
2363     'chardev',
2364     'ebpf',
2365     'hw/9pfs',
2366     'hw/acpi',
2367     'hw/adc',
2368     'hw/alpha',
2369     'hw/arm',
2370     'hw/audio',
2371     'hw/block',
2372     'hw/block/dataplane',
2373     'hw/char',
2374     'hw/display',
2375     'hw/dma',
2376     'hw/hppa',
2377     'hw/hyperv',
2378     'hw/i2c',
2379     'hw/i386',
2380     'hw/i386/xen',
2381     'hw/ide',
2382     'hw/input',
2383     'hw/intc',
2384     'hw/isa',
2385     'hw/mem',
2386     'hw/mips',
2387     'hw/misc',
2388     'hw/misc/macio',
2389     'hw/net',
2390     'hw/net/can',
2391     'hw/nubus',
2392     'hw/nvme',
2393     'hw/nvram',
2394     'hw/pci',
2395     'hw/pci-host',
2396     'hw/ppc',
2397     'hw/rdma',
2398     'hw/rdma/vmw',
2399     'hw/rtc',
2400     'hw/s390x',
2401     'hw/scsi',
2402     'hw/sd',
2403     'hw/sparc',
2404     'hw/sparc64',
2405     'hw/ssi',
2406     'hw/timer',
2407     'hw/tpm',
2408     'hw/usb',
2409     'hw/vfio',
2410     'hw/virtio',
2411     'hw/watchdog',
2412     'hw/xen',
2413     'hw/gpio',
2414     'migration',
2415     'net',
2416     'softmmu',
2417     'ui',
2418     'hw/remote',
2419   ]
2420 endif
2421 if have_system or have_user
2422   trace_events_subdirs += [
2423     'accel/tcg',
2424     'hw/core',
2425     'target/arm',
2426     'target/arm/hvf',
2427     'target/hppa',
2428     'target/i386',
2429     'target/i386/kvm',
2430     'target/mips/tcg',
2431     'target/ppc',
2432     'target/riscv',
2433     'target/s390x',
2434     'target/s390x/kvm',
2435     'target/sparc',
2436   ]
2437 endif
2438
2439 vhost_user = not_found
2440 if 'CONFIG_VHOST_USER' in config_host
2441   libvhost_user = subproject('libvhost-user')
2442   vhost_user = libvhost_user.get_variable('vhost_user_dep')
2443 endif
2444
2445 subdir('qapi')
2446 subdir('qobject')
2447 subdir('stubs')
2448 subdir('trace')
2449 subdir('util')
2450 subdir('qom')
2451 subdir('authz')
2452 subdir('crypto')
2453 subdir('ui')
2454
2455
2456 if enable_modules
2457   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2458   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2459 endif
2460
2461 stub_ss = stub_ss.apply(config_all, strict: false)
2462
2463 util_ss.add_all(trace_ss)
2464 util_ss = util_ss.apply(config_all, strict: false)
2465 libqemuutil = static_library('qemuutil',
2466                              sources: util_ss.sources() + stub_ss.sources() + genh,
2467                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2468 qemuutil = declare_dependency(link_with: libqemuutil,
2469                               sources: genh + version_res)
2470
2471 if have_system or have_user
2472   decodetree = generator(find_program('scripts/decodetree.py'),
2473                          output: 'decode-@BASENAME@.c.inc',
2474                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2475   subdir('libdecnumber')
2476   subdir('target')
2477 endif
2478
2479 subdir('audio')
2480 subdir('io')
2481 subdir('chardev')
2482 subdir('fsdev')
2483 subdir('dump')
2484
2485 if have_block
2486   block_ss.add(files(
2487     'block.c',
2488     'blockjob.c',
2489     'job.c',
2490     'qemu-io-cmds.c',
2491   ))
2492   block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
2493
2494   subdir('nbd')
2495   subdir('scsi')
2496   subdir('block')
2497
2498   blockdev_ss.add(files(
2499     'blockdev.c',
2500     'blockdev-nbd.c',
2501     'iothread.c',
2502     'job-qmp.c',
2503   ), gnutls)
2504
2505   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2506   # os-win32.c does not
2507   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2508   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2509 endif
2510
2511 common_ss.add(files('cpus-common.c'))
2512
2513 subdir('softmmu')
2514
2515 common_ss.add(capstone)
2516 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2517
2518 # Work around a gcc bug/misfeature wherein constant propagation looks
2519 # through an alias:
2520 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2521 # to guess that a const variable is always zero.  Without lto, this is
2522 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
2523 # without lto, not even the alias is required -- we simply use different
2524 # declarations in different compilation units.
2525 pagevary = files('page-vary-common.c')
2526 if get_option('b_lto')
2527   pagevary_flags = ['-fno-lto']
2528   if get_option('cfi')
2529     pagevary_flags += '-fno-sanitize=cfi-icall'
2530   endif
2531   pagevary = static_library('page-vary-common', sources: pagevary,
2532                             c_args: pagevary_flags)
2533   pagevary = declare_dependency(link_with: pagevary)
2534 endif
2535 common_ss.add(pagevary)
2536 specific_ss.add(files('page-vary.c'))
2537
2538 subdir('backends')
2539 subdir('disas')
2540 subdir('migration')
2541 subdir('monitor')
2542 subdir('net')
2543 subdir('replay')
2544 subdir('semihosting')
2545 subdir('hw')
2546 subdir('tcg')
2547 subdir('fpu')
2548 subdir('accel')
2549 subdir('plugins')
2550 subdir('bsd-user')
2551 subdir('linux-user')
2552 subdir('ebpf')
2553
2554 bsd_user_ss.add(files('gdbstub.c'))
2555 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
2556
2557 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
2558 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
2559
2560 # needed for fuzzing binaries
2561 subdir('tests/qtest/libqos')
2562 subdir('tests/qtest/fuzz')
2563
2564 # accel modules
2565 tcg_real_module_ss = ss.source_set()
2566 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2567 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2568 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2569                                 'tcg': tcg_real_module_ss }}
2570
2571 ########################
2572 # Library dependencies #
2573 ########################
2574
2575 modinfo_collect = find_program('scripts/modinfo-collect.py')
2576 modinfo_generate = find_program('scripts/modinfo-generate.py')
2577 modinfo_files = []
2578
2579 block_mods = []
2580 softmmu_mods = []
2581 foreach d, list : modules
2582   foreach m, module_ss : list
2583     if enable_modules and targetos != 'windows'
2584       module_ss = module_ss.apply(config_all, strict: false)
2585       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2586                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2587       if d == 'block'
2588         block_mods += sl
2589       else
2590         softmmu_mods += sl
2591       endif
2592       if module_ss.sources() != []
2593         # FIXME: Should use sl.extract_all_objects(recursive: true) as
2594         # input. Sources can be used multiple times but objects are
2595         # unique when it comes to lookup in compile_commands.json.
2596         # Depnds on a mesion version with
2597         # https://github.com/mesonbuild/meson/pull/8900
2598         modinfo_files += custom_target(d + '-' + m + '.modinfo',
2599                                        output: d + '-' + m + '.modinfo',
2600                                        input: module_ss.sources() + genh,
2601                                        capture: true,
2602                                        command: [modinfo_collect, module_ss.sources()])
2603       endif
2604     else
2605       if d == 'block'
2606         block_ss.add_all(module_ss)
2607       else
2608         softmmu_ss.add_all(module_ss)
2609       endif
2610     endif
2611   endforeach
2612 endforeach
2613
2614 foreach d, list : target_modules
2615   foreach m, module_ss : list
2616     if enable_modules and targetos != 'windows'
2617       foreach target : target_dirs
2618         if target.endswith('-softmmu')
2619           config_target = config_target_mak[target]
2620           config_target += config_host
2621           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2622           c_args = ['-DNEED_CPU_H',
2623                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2624                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2625           target_module_ss = module_ss.apply(config_target, strict: false)
2626           if target_module_ss.sources() != []
2627             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2628             sl = static_library(module_name,
2629                                 [genh, target_module_ss.sources()],
2630                                 dependencies: [modulecommon, target_module_ss.dependencies()],
2631                                 include_directories: target_inc,
2632                                 c_args: c_args,
2633                                 pic: true)
2634             softmmu_mods += sl
2635             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2636             modinfo_files += custom_target(module_name + '.modinfo',
2637                                            output: module_name + '.modinfo',
2638                                            input: target_module_ss.sources() + genh,
2639                                            capture: true,
2640                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2641           endif
2642         endif
2643       endforeach
2644     else
2645       specific_ss.add_all(module_ss)
2646     endif
2647   endforeach
2648 endforeach
2649
2650 if enable_modules
2651   modinfo_src = custom_target('modinfo.c',
2652                               output: 'modinfo.c',
2653                               input: modinfo_files,
2654                               command: [modinfo_generate, '@INPUT@'],
2655                               capture: true)
2656   modinfo_lib = static_library('modinfo', modinfo_src)
2657   modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2658   softmmu_ss.add(modinfo_dep)
2659 endif
2660
2661 nm = find_program('nm')
2662 undefsym = find_program('scripts/undefsym.py')
2663 block_syms = custom_target('block.syms', output: 'block.syms',
2664                              input: [libqemuutil, block_mods],
2665                              capture: true,
2666                              command: [undefsym, nm, '@INPUT@'])
2667 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2668                              input: [libqemuutil, softmmu_mods],
2669                              capture: true,
2670                              command: [undefsym, nm, '@INPUT@'])
2671
2672 qom_ss = qom_ss.apply(config_host, strict: false)
2673 libqom = static_library('qom', qom_ss.sources() + genh,
2674                         dependencies: [qom_ss.dependencies()],
2675                         name_suffix: 'fa')
2676
2677 qom = declare_dependency(link_whole: libqom)
2678
2679 authz_ss = authz_ss.apply(config_host, strict: false)
2680 libauthz = static_library('authz', authz_ss.sources() + genh,
2681                           dependencies: [authz_ss.dependencies()],
2682                           name_suffix: 'fa',
2683                           build_by_default: false)
2684
2685 authz = declare_dependency(link_whole: libauthz,
2686                            dependencies: qom)
2687
2688 crypto_ss = crypto_ss.apply(config_host, strict: false)
2689 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2690                            dependencies: [crypto_ss.dependencies()],
2691                            name_suffix: 'fa',
2692                            build_by_default: false)
2693
2694 crypto = declare_dependency(link_whole: libcrypto,
2695                             dependencies: [authz, qom])
2696
2697 io_ss = io_ss.apply(config_host, strict: false)
2698 libio = static_library('io', io_ss.sources() + genh,
2699                        dependencies: [io_ss.dependencies()],
2700                        link_with: libqemuutil,
2701                        name_suffix: 'fa',
2702                        build_by_default: false)
2703
2704 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
2705
2706 libmigration = static_library('migration', sources: migration_files + genh,
2707                               name_suffix: 'fa',
2708                               build_by_default: false)
2709 migration = declare_dependency(link_with: libmigration,
2710                                dependencies: [zlib, qom, io])
2711 softmmu_ss.add(migration)
2712
2713 block_ss = block_ss.apply(config_host, strict: false)
2714 libblock = static_library('block', block_ss.sources() + genh,
2715                           dependencies: block_ss.dependencies(),
2716                           link_depends: block_syms,
2717                           name_suffix: 'fa',
2718                           build_by_default: false)
2719
2720 block = declare_dependency(link_whole: [libblock],
2721                            link_args: '@block.syms',
2722                            dependencies: [crypto, io])
2723
2724 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
2725 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
2726                              dependencies: blockdev_ss.dependencies(),
2727                              name_suffix: 'fa',
2728                              build_by_default: false)
2729
2730 blockdev = declare_dependency(link_whole: [libblockdev],
2731                               dependencies: [block])
2732
2733 qmp_ss = qmp_ss.apply(config_host, strict: false)
2734 libqmp = static_library('qmp', qmp_ss.sources() + genh,
2735                         dependencies: qmp_ss.dependencies(),
2736                         name_suffix: 'fa',
2737                         build_by_default: false)
2738
2739 qmp = declare_dependency(link_whole: [libqmp])
2740
2741 libchardev = static_library('chardev', chardev_ss.sources() + genh,
2742                             name_suffix: 'fa',
2743                             dependencies: [gnutls],
2744                             build_by_default: false)
2745
2746 chardev = declare_dependency(link_whole: libchardev)
2747
2748 libhwcore = static_library('hwcore', sources: hwcore_files + genh,
2749                            name_suffix: 'fa',
2750                            build_by_default: false)
2751 hwcore = declare_dependency(link_whole: libhwcore)
2752 common_ss.add(hwcore)
2753
2754 ###########
2755 # Targets #
2756 ###########
2757
2758 foreach m : block_mods + softmmu_mods
2759   shared_module(m.name(),
2760                 name_prefix: '',
2761                 link_whole: m,
2762                 install: true,
2763                 install_dir: qemu_moddir)
2764 endforeach
2765
2766 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
2767 common_ss.add(qom, qemuutil)
2768
2769 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
2770 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
2771
2772 common_all = common_ss.apply(config_all, strict: false)
2773 common_all = static_library('common',
2774                             build_by_default: false,
2775                             sources: common_all.sources() + genh,
2776                             implicit_include_directories: false,
2777                             dependencies: common_all.dependencies(),
2778                             name_suffix: 'fa')
2779
2780 feature_to_c = find_program('scripts/feature_to_c.sh')
2781
2782 emulators = {}
2783 foreach target : target_dirs
2784   config_target = config_target_mak[target]
2785   target_name = config_target['TARGET_NAME']
2786   arch = config_target['TARGET_BASE_ARCH']
2787   arch_srcs = [config_target_h[target]]
2788   arch_deps = []
2789   c_args = ['-DNEED_CPU_H',
2790             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2791             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2792   link_args = emulator_link_args
2793
2794   config_target += config_host
2795   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2796   if targetos == 'linux'
2797     target_inc += include_directories('linux-headers', is_system: true)
2798   endif
2799   if target.endswith('-softmmu')
2800     qemu_target_name = 'qemu-system-' + target_name
2801     target_type='system'
2802     t = target_softmmu_arch[arch].apply(config_target, strict: false)
2803     arch_srcs += t.sources()
2804     arch_deps += t.dependencies()
2805
2806     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
2807     hw = hw_arch[hw_dir].apply(config_target, strict: false)
2808     arch_srcs += hw.sources()
2809     arch_deps += hw.dependencies()
2810
2811     arch_srcs += config_devices_h[target]
2812     link_args += ['@block.syms', '@qemu.syms']
2813   else
2814     abi = config_target['TARGET_ABI_DIR']
2815     target_type='user'
2816     qemu_target_name = 'qemu-' + target_name
2817     if arch in target_user_arch
2818       t = target_user_arch[arch].apply(config_target, strict: false)
2819       arch_srcs += t.sources()
2820       arch_deps += t.dependencies()
2821     endif
2822     if 'CONFIG_LINUX_USER' in config_target
2823       base_dir = 'linux-user'
2824       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
2825     endif
2826     if 'CONFIG_BSD_USER' in config_target
2827       base_dir = 'bsd-user'
2828       target_inc += include_directories('bsd-user/' / targetos)
2829       dir = base_dir / abi
2830       arch_srcs += files(dir / 'target_arch_cpu.c')
2831     endif
2832     target_inc += include_directories(
2833       base_dir,
2834       base_dir / abi,
2835     )
2836     if 'CONFIG_LINUX_USER' in config_target
2837       dir = base_dir / abi
2838       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
2839       if config_target.has_key('TARGET_SYSTBL_ABI')
2840         arch_srcs += \
2841           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
2842                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
2843       endif
2844     endif
2845   endif
2846
2847   if 'TARGET_XML_FILES' in config_target
2848     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
2849                                 output: target + '-gdbstub-xml.c',
2850                                 input: files(config_target['TARGET_XML_FILES'].split()),
2851                                 command: [feature_to_c, '@INPUT@'],
2852                                 capture: true)
2853     arch_srcs += gdbstub_xml
2854   endif
2855
2856   t = target_arch[arch].apply(config_target, strict: false)
2857   arch_srcs += t.sources()
2858   arch_deps += t.dependencies()
2859
2860   target_common = common_ss.apply(config_target, strict: false)
2861   objects = common_all.extract_objects(target_common.sources())
2862   deps = target_common.dependencies()
2863
2864   target_specific = specific_ss.apply(config_target, strict: false)
2865   arch_srcs += target_specific.sources()
2866   arch_deps += target_specific.dependencies()
2867
2868   lib = static_library('qemu-' + target,
2869                  sources: arch_srcs + genh,
2870                  dependencies: arch_deps,
2871                  objects: objects,
2872                  include_directories: target_inc,
2873                  c_args: c_args,
2874                  build_by_default: false,
2875                  name_suffix: 'fa')
2876
2877   if target.endswith('-softmmu')
2878     execs = [{
2879       'name': 'qemu-system-' + target_name,
2880       'win_subsystem': 'console',
2881       'sources': files('softmmu/main.c'),
2882       'dependencies': []
2883     }]
2884     if targetos == 'windows' and (sdl.found() or gtk.found())
2885       execs += [{
2886         'name': 'qemu-system-' + target_name + 'w',
2887         'win_subsystem': 'windows',
2888         'sources': files('softmmu/main.c'),
2889         'dependencies': []
2890       }]
2891     endif
2892     if get_option('fuzzing')
2893       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
2894       execs += [{
2895         'name': 'qemu-fuzz-' + target_name,
2896         'win_subsystem': 'console',
2897         'sources': specific_fuzz.sources(),
2898         'dependencies': specific_fuzz.dependencies(),
2899       }]
2900     endif
2901   else
2902     execs = [{
2903       'name': 'qemu-' + target_name,
2904       'win_subsystem': 'console',
2905       'sources': [],
2906       'dependencies': []
2907     }]
2908   endif
2909   foreach exe: execs
2910     exe_name = exe['name']
2911     if targetos == 'darwin'
2912       exe_name += '-unsigned'
2913     endif
2914
2915     emulator = executable(exe_name, exe['sources'],
2916                install: true,
2917                c_args: c_args,
2918                dependencies: arch_deps + deps + exe['dependencies'],
2919                objects: lib.extract_all_objects(recursive: true),
2920                link_language: link_language,
2921                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
2922                link_args: link_args,
2923                win_subsystem: exe['win_subsystem'])
2924
2925     if targetos == 'darwin'
2926       icon = 'pc-bios/qemu.rsrc'
2927       build_input = [emulator, files(icon)]
2928       install_input = [
2929         get_option('bindir') / exe_name,
2930         meson.current_source_dir() / icon
2931       ]
2932       if 'CONFIG_HVF' in config_target
2933         entitlements = 'accel/hvf/entitlements.plist'
2934         build_input += files(entitlements)
2935         install_input += meson.current_source_dir() / entitlements
2936       endif
2937
2938       emulators += {exe['name'] : custom_target(exe['name'],
2939                    input: build_input,
2940                    output: exe['name'],
2941                    command: [
2942                      files('scripts/entitlement.sh'),
2943                      '@OUTPUT@',
2944                      '@INPUT@'
2945                    ])
2946       }
2947
2948       meson.add_install_script('scripts/entitlement.sh', '--install',
2949                                get_option('bindir') / exe['name'],
2950                                install_input)
2951     else
2952       emulators += {exe['name']: emulator}
2953     endif
2954
2955     if stap.found()
2956       foreach stp: [
2957         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
2958         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
2959         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
2960         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
2961       ]
2962         custom_target(exe['name'] + stp['ext'],
2963                       input: trace_events_all,
2964                       output: exe['name'] + stp['ext'],
2965                       install: stp['install'],
2966                       install_dir: get_option('datadir') / 'systemtap/tapset',
2967                       command: [
2968                         tracetool, '--group=all', '--format=' + stp['fmt'],
2969                         '--binary=' + stp['bin'],
2970                         '--target-name=' + target_name,
2971                         '--target-type=' + target_type,
2972                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
2973                         '@INPUT@', '@OUTPUT@'
2974                       ],
2975                       depend_files: tracetool_depends)
2976       endforeach
2977     endif
2978   endforeach
2979 endforeach
2980
2981 # Other build targets
2982
2983 if 'CONFIG_PLUGIN' in config_host
2984   install_headers('include/qemu/qemu-plugin.h')
2985 endif
2986
2987 if 'CONFIG_GUEST_AGENT' in config_host
2988   subdir('qga')
2989 elif get_option('guest_agent_msi').enabled()
2990   error('Guest agent MSI requested, but the guest agent is not being built')
2991 endif
2992
2993 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
2994 # when we don't build tools or system
2995 if xkbcommon.found()
2996   # used for the update-keymaps target, so include rules even if !have_tools
2997   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
2998                            dependencies: [qemuutil, xkbcommon], install: have_tools)
2999 endif
3000
3001 if have_tools
3002   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3003              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3004   qemu_io = executable('qemu-io', files('qemu-io.c'),
3005              dependencies: [block, qemuutil], install: true)
3006   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3007                dependencies: [blockdev, qemuutil, gnutls], install: true)
3008
3009   subdir('storage-daemon')
3010   subdir('contrib/rdmacm-mux')
3011   subdir('contrib/elf2dmp')
3012
3013   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3014              dependencies: qemuutil,
3015              install: true)
3016
3017   if 'CONFIG_VHOST_USER' in config_host
3018     subdir('contrib/vhost-user-blk')
3019     subdir('contrib/vhost-user-gpu')
3020     subdir('contrib/vhost-user-input')
3021     subdir('contrib/vhost-user-scsi')
3022   endif
3023
3024   if targetos == 'linux'
3025     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3026                dependencies: [qemuutil, libcap_ng],
3027                install: true,
3028                install_dir: get_option('libexecdir'))
3029
3030     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3031                dependencies: [authz, crypto, io, qom, qemuutil,
3032                               libcap_ng, mpathpersist],
3033                install: true)
3034   endif
3035
3036   if have_ivshmem
3037     subdir('contrib/ivshmem-client')
3038     subdir('contrib/ivshmem-server')
3039   endif
3040 endif
3041
3042 subdir('scripts')
3043 subdir('tools')
3044 subdir('pc-bios')
3045 subdir('docs')
3046 subdir('tests')
3047 if gtk.found()
3048   subdir('po')
3049 endif
3050
3051 if host_machine.system() == 'windows'
3052   nsis_cmd = [
3053     find_program('scripts/nsis.py'),
3054     '@OUTPUT@',
3055     get_option('prefix'),
3056     meson.current_source_dir(),
3057     host_machine.cpu(),
3058     '--',
3059     '-DDISPLAYVERSION=' + meson.project_version(),
3060   ]
3061   if build_docs
3062     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3063   endif
3064   if gtk.found()
3065     nsis_cmd += '-DCONFIG_GTK=y'
3066   endif
3067
3068   nsis = custom_target('nsis',
3069                        output: 'qemu-setup-' + meson.project_version() + '.exe',
3070                        input: files('qemu.nsi'),
3071                        build_always_stale: true,
3072                        command: nsis_cmd + ['@INPUT@'])
3073   alias_target('installer', nsis)
3074 endif
3075
3076 #########################
3077 # Configuration summary #
3078 #########################
3079
3080 # Directories
3081 summary_info = {}
3082 summary_info += {'Install prefix':    get_option('prefix')}
3083 summary_info += {'BIOS directory':    qemu_datadir}
3084 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
3085 summary_info += {'binary directory':  get_option('bindir')}
3086 summary_info += {'library directory': get_option('libdir')}
3087 summary_info += {'module directory':  qemu_moddir}
3088 summary_info += {'libexec directory': get_option('libexecdir')}
3089 summary_info += {'include directory': get_option('includedir')}
3090 summary_info += {'config directory':  get_option('sysconfdir')}
3091 if targetos != 'windows'
3092   summary_info += {'local state directory': get_option('localstatedir')}
3093   summary_info += {'Manual directory':      get_option('mandir')}
3094 else
3095   summary_info += {'local state directory': 'queried at runtime'}
3096 endif
3097 summary_info += {'Doc directory':     get_option('docdir')}
3098 summary_info += {'Build directory':   meson.current_build_dir()}
3099 summary_info += {'Source path':       meson.current_source_dir()}
3100 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
3101 summary(summary_info, bool_yn: true, section: 'Directories')
3102
3103 # Host binaries
3104 summary_info = {}
3105 summary_info += {'git':               config_host['GIT']}
3106 summary_info += {'make':              config_host['MAKE']}
3107 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3108 summary_info += {'sphinx-build':      sphinx_build}
3109 if config_host.has_key('HAVE_GDB_BIN')
3110   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
3111 endif
3112 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
3113 if targetos == 'windows' and config_host.has_key('CONFIG_GUEST_AGENT')
3114   summary_info += {'wixl':            wixl}
3115 endif
3116 if slirp_opt != 'disabled' and 'CONFIG_SLIRP_SMBD' in config_host
3117   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
3118 endif
3119 summary(summary_info, bool_yn: true, section: 'Host binaries')
3120
3121 # Configurable features
3122 summary_info = {}
3123 summary_info += {'Documentation':     build_docs}
3124 summary_info += {'system-mode emulation': have_system}
3125 summary_info += {'user-mode emulation': have_user}
3126 summary_info += {'block layer':       have_block}
3127 summary_info += {'Install blobs':     get_option('install_blobs')}
3128 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
3129 if config_host.has_key('CONFIG_MODULES')
3130   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3131 endif
3132 summary_info += {'fuzzing support':   get_option('fuzzing')}
3133 if have_system
3134   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
3135 endif
3136 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
3137 if 'simple' in get_option('trace_backends')
3138   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3139 endif
3140 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
3141 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3142 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3143 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3144 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3145 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3146 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3147 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3148 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3149 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3150 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
3151 summary(summary_info, bool_yn: true, section: 'Configurable features')
3152
3153 # Compilation information
3154 summary_info = {}
3155 summary_info += {'host CPU':          cpu}
3156 summary_info += {'host endianness':   build_machine.endian()}
3157 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
3158 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3159 if link_language == 'cpp'
3160   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
3161 else
3162   summary_info += {'C++ compiler':      false}
3163 endif
3164 if targetos == 'darwin'
3165   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3166 endif
3167 if targetos == 'windows'
3168   if 'WIN_SDK' in config_host
3169     summary_info += {'Windows SDK':   config_host['WIN_SDK']}
3170   endif
3171 endif
3172 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
3173                                                + ['-O' + get_option('optimization')]
3174                                                + (get_option('debug') ? ['-g'] : []))}
3175 if link_language == 'cpp'
3176   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
3177                                                + ['-O' + get_option('optimization')]
3178                                                + (get_option('debug') ? ['-g'] : []))}
3179 endif
3180 link_args = get_option(link_language + '_link_args')
3181 if link_args.length() > 0
3182   summary_info += {'LDFLAGS':         ' '.join(link_args)}
3183 endif
3184 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
3185 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
3186 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
3187 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3188 summary_info += {'PIE':               get_option('b_pie')}
3189 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
3190 summary_info += {'malloc trim support': has_malloc_trim}
3191 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
3192 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
3193 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
3194 summary_info += {'memory allocator':  get_option('malloc')}
3195 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
3196 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
3197 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
3198 summary_info += {'gcov':              get_option('b_coverage')}
3199 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
3200 summary_info += {'CFI support':       get_option('cfi')}
3201 if get_option('cfi')
3202   summary_info += {'CFI debug support': get_option('cfi_debug')}
3203 endif
3204 summary_info += {'strip binaries':    get_option('strip')}
3205 summary_info += {'sparse':            sparse}
3206 summary_info += {'mingw32 support':   targetos == 'windows'}
3207
3208 # snarf the cross-compilation information for tests
3209 foreach target: target_dirs
3210   tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3211   if fs.exists(tcg_mak)
3212     config_cross_tcg = keyval.load(tcg_mak)
3213     target = config_cross_tcg['TARGET_NAME']
3214     compiler = ''
3215     if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3216       summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3217                                           ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3218     elif 'CROSS_CC_GUEST' in config_cross_tcg
3219       summary_info += {target + ' tests'
3220                                 : config_cross_tcg['CROSS_CC_GUEST'] }
3221     endif
3222    endif
3223 endforeach
3224
3225 summary(summary_info, bool_yn: true, section: 'Compilation')
3226
3227 # Targets and accelerators
3228 summary_info = {}
3229 if have_system
3230   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
3231   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
3232   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
3233   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
3234   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
3235   summary_info += {'Xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
3236   if config_host.has_key('CONFIG_XEN_BACKEND')
3237     summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3238   endif
3239 endif
3240 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
3241 if config_all.has_key('CONFIG_TCG')
3242   if get_option('tcg_interpreter')
3243     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, experimental and slow)'}
3244   else
3245     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
3246   endif
3247   summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3248   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3249 endif
3250 summary_info += {'target list':       ' '.join(target_dirs)}
3251 if have_system
3252   summary_info += {'default devices':   get_option('default_devices')}
3253   summary_info += {'out of process emulation': multiprocess_allowed}
3254 endif
3255 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3256
3257 # Block layer
3258 summary_info = {}
3259 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3260 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
3261 if have_block
3262   summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3263   summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3264   summary_info += {'Use block whitelist in tools': config_host.has_key('CONFIG_BDRV_WHITELIST_TOOLS')}
3265   summary_info += {'VirtFS support':    have_virtfs}
3266   summary_info += {'build virtiofs daemon': have_virtiofsd}
3267   summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
3268   summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
3269   summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
3270   summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
3271   summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
3272   summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
3273   summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
3274   summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
3275   summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
3276   summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
3277   summary_info += {'FUSE exports':      fuse}
3278 endif
3279 summary(summary_info, bool_yn: true, section: 'Block layer support')
3280
3281 # Crypto
3282 summary_info = {}
3283 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
3284 summary_info += {'GNUTLS support':    gnutls}
3285 if gnutls.found()
3286   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
3287 endif
3288 summary_info += {'libgcrypt':         gcrypt}
3289 summary_info += {'nettle':            nettle}
3290 if nettle.found()
3291    summary_info += {'  XTS':             xts != 'private'}
3292 endif
3293 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
3294 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
3295 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
3296 summary(summary_info, bool_yn: true, section: 'Crypto')
3297
3298 # Libraries
3299 summary_info = {}
3300 if targetos == 'darwin'
3301   summary_info += {'Cocoa support':   cocoa}
3302 endif
3303 summary_info += {'SDL support':       sdl}
3304 summary_info += {'SDL image support': sdl_image}
3305 summary_info += {'GTK support':       gtk}
3306 summary_info += {'pixman':            pixman}
3307 summary_info += {'VTE support':       vte}
3308 summary_info += {'slirp support':     slirp_opt == 'internal' ? slirp_opt : slirp}
3309 summary_info += {'libtasn1':          tasn1}
3310 summary_info += {'PAM':               pam}
3311 summary_info += {'iconv support':     iconv}
3312 summary_info += {'curses support':    curses}
3313 summary_info += {'virgl support':     virgl}
3314 summary_info += {'curl support':      curl}
3315 summary_info += {'Multipath support': mpathpersist}
3316 summary_info += {'VNC support':       vnc}
3317 if vnc.found()
3318   summary_info += {'VNC SASL support':  sasl}
3319   summary_info += {'VNC JPEG support':  jpeg}
3320   summary_info += {'VNC PNG support':   png}
3321 endif
3322 if targetos not in ['darwin', 'haiku', 'windows']
3323   summary_info += {'OSS support':     oss}
3324 elif targetos == 'darwin'
3325   summary_info += {'CoreAudio support': coreaudio}
3326 elif targetos == 'windows'
3327   summary_info += {'DirectSound support': dsound}
3328 endif
3329 if targetos == 'linux'
3330   summary_info += {'ALSA support':    alsa}
3331   summary_info += {'PulseAudio support': pulse}
3332 endif
3333 summary_info += {'JACK support':      jack}
3334 summary_info += {'brlapi support':    brlapi}
3335 summary_info += {'vde support':       vde}
3336 summary_info += {'netmap support':    have_netmap}
3337 summary_info += {'Linux AIO support': libaio}
3338 summary_info += {'Linux io_uring support': linux_io_uring}
3339 summary_info += {'ATTR/XATTR support': libattr}
3340 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
3341 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
3342 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
3343 summary_info += {'libcap-ng support': libcap_ng}
3344 summary_info += {'bpf support':       libbpf}
3345 summary_info += {'spice protocol support': spice_protocol}
3346 if spice_protocol.found()
3347   summary_info += {'  spice server support': spice}
3348 endif
3349 summary_info += {'rbd support':       rbd}
3350 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
3351 summary_info += {'smartcard support': cacard}
3352 summary_info += {'U2F support':       u2f}
3353 summary_info += {'libusb':            libusb}
3354 summary_info += {'usb net redir':     usbredir}
3355 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
3356 summary_info += {'GBM':               gbm}
3357 summary_info += {'libiscsi support':  libiscsi}
3358 summary_info += {'libnfs support':    libnfs}
3359 if targetos == 'windows'
3360   if config_host.has_key('CONFIG_GUEST_AGENT')
3361     summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
3362     summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
3363   endif
3364 endif
3365 summary_info += {'seccomp support':   seccomp}
3366 summary_info += {'GlusterFS support': glusterfs}
3367 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
3368 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
3369 summary_info += {'lzo support':       lzo}
3370 summary_info += {'snappy support':    snappy}
3371 summary_info += {'bzip2 support':     libbzip2}
3372 summary_info += {'lzfse support':     liblzfse}
3373 summary_info += {'zstd support':      zstd}
3374 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
3375 summary_info += {'libxml2':           libxml2}
3376 summary_info += {'capstone':          capstone_opt == 'internal' ? capstone_opt : capstone}
3377 summary_info += {'libpmem support':   libpmem}
3378 summary_info += {'libdaxctl support': libdaxctl}
3379 summary_info += {'libudev':           libudev}
3380 # Dummy dependency, keep .found()
3381 summary_info += {'FUSE lseek':        fuse_lseek.found()}
3382 summary(summary_info, bool_yn: true, section: 'Dependencies')
3383
3384 if not supported_cpus.contains(cpu)
3385   message()
3386   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3387   message()
3388   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3389   message('The QEMU project intends to remove support for this host CPU in')
3390   message('a future release if nobody volunteers to maintain it and to')
3391   message('provide a build host for our continuous integration setup.')
3392   message('configure has succeeded and you can continue to build, but')
3393   message('if you care about QEMU on this platform you should contact')
3394   message('us upstream at qemu-devel@nongnu.org.')
3395 endif
3396
3397 if not supported_oses.contains(targetos)
3398   message()
3399   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3400   message()
3401   message('Host OS ' + targetos + 'support is not currently maintained.')
3402   message('The QEMU project intends to remove support for this host OS in')
3403   message('a future release if nobody volunteers to maintain it and to')
3404   message('provide a build host for our continuous integration setup.')
3405   message('configure has succeeded and you can continue to build, but')
3406   message('if you care about QEMU on this platform you should contact')
3407   message('us upstream at qemu-devel@nongnu.org.')
3408 endif