meson.build

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