meson.build

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