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