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 have_vss_sdk = false # old xp/2003 SDK
1961 if targetos == 'windows' and link_language == 'cpp'
1962   have_vss = cxx.compiles('''
1963     #define __MIDL_user_allocate_free_DEFINED__
1964     #include <vss.h>
1965     int main(void) { return VSS_CTX_BACKUP; }''')
1966   have_vss_sdk = cxx.has_header('vscoordint.h')
1967 endif
1968 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
1969
1970 have_ntddscsi = false
1971 if targetos == 'windows'
1972   have_ntddscsi = cc.compiles('''
1973     #include <windows.h>
1974     #include <ntddscsi.h>
1975     int main(void) {
1976     #if !defined(IOCTL_SCSI_GET_ADDRESS)
1977     #error Missing required ioctl definitions
1978     #endif
1979       SCSI_ADDRESS addr = { .Lun = 0, .TargetId = 0, .PathId = 0 };
1980       return addr.Lun;
1981     }
1982 ''')
1983 endif
1984 config_host_data.set('HAVE_NTDDSCSI', have_ntddscsi)
1985
1986 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
1987     'HAVE_GDB_BIN']
1988 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1989 foreach k, v: config_host
1990   if ignored.contains(k)
1991     # do nothing
1992   elif arrays.contains(k)
1993     if v != ''
1994       v = '"' + '", "'.join(v.split()) + '", '
1995     endif
1996     config_host_data.set(k, v)
1997   elif k.startswith('CONFIG_')
1998     config_host_data.set(k, v == 'y' ? 1 : v)
1999   endif
2000 endforeach
2001
2002 ########################
2003 # Target configuration #
2004 ########################
2005
2006 minikconf = find_program('scripts/minikconf.py')
2007 config_all = {}
2008 config_all_devices = {}
2009 config_all_disas = {}
2010 config_devices_mak_list = []
2011 config_devices_h = {}
2012 config_target_h = {}
2013 config_target_mak = {}
2014
2015 disassemblers = {
2016   'alpha' : ['CONFIG_ALPHA_DIS'],
2017   'arm' : ['CONFIG_ARM_DIS'],
2018   'avr' : ['CONFIG_AVR_DIS'],
2019   'cris' : ['CONFIG_CRIS_DIS'],
2020   'hexagon' : ['CONFIG_HEXAGON_DIS'],
2021   'hppa' : ['CONFIG_HPPA_DIS'],
2022   'i386' : ['CONFIG_I386_DIS'],
2023   'x86_64' : ['CONFIG_I386_DIS'],
2024   'm68k' : ['CONFIG_M68K_DIS'],
2025   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2026   'mips' : ['CONFIG_MIPS_DIS'],
2027   'nios2' : ['CONFIG_NIOS2_DIS'],
2028   'or1k' : ['CONFIG_OPENRISC_DIS'],
2029   'ppc' : ['CONFIG_PPC_DIS'],
2030   'riscv' : ['CONFIG_RISCV_DIS'],
2031   'rx' : ['CONFIG_RX_DIS'],
2032   's390' : ['CONFIG_S390_DIS'],
2033   'sh4' : ['CONFIG_SH4_DIS'],
2034   'sparc' : ['CONFIG_SPARC_DIS'],
2035   'xtensa' : ['CONFIG_XTENSA_DIS'],
2036 }
2037 if link_language == 'cpp'
2038   disassemblers += {
2039     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
2040     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
2041     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
2042   }
2043 endif
2044
2045 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2046 host_kconfig = \
2047   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2048   (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2049   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2050   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2051   ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
2052   (x11.found() ? ['CONFIG_X11=y'] : []) + \
2053   ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
2054   ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2055   ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2056   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2057   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2058   ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
2059   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
2060
2061 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2062
2063 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2064 actual_target_dirs = []
2065 fdt_required = []
2066 foreach target : target_dirs
2067   config_target = { 'TARGET_NAME': target.split('-')[0] }
2068   if target.endswith('linux-user')
2069     if targetos != 'linux'
2070       if default_targets
2071         continue
2072       endif
2073       error('Target @0@ is only available on a Linux host'.format(target))
2074     endif
2075     config_target += { 'CONFIG_LINUX_USER': 'y' }
2076   elif target.endswith('bsd-user')
2077     if 'CONFIG_BSD' not in config_host
2078       if default_targets
2079         continue
2080       endif
2081       error('Target @0@ is only available on a BSD host'.format(target))
2082     endif
2083     config_target += { 'CONFIG_BSD_USER': 'y' }
2084   elif target.endswith('softmmu')
2085     config_target += { 'CONFIG_SOFTMMU': 'y' }
2086   endif
2087   if target.endswith('-user')
2088     config_target += {
2089       'CONFIG_USER_ONLY': 'y',
2090       'CONFIG_QEMU_INTERP_PREFIX':
2091         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
2092     }
2093   endif
2094
2095   accel_kconfig = []
2096   foreach sym: accelerators
2097     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2098       config_target += { sym: 'y' }
2099       config_all += { sym: 'y' }
2100       if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
2101         config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
2102       elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
2103         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
2104       endif
2105       if target in modular_tcg
2106         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2107       else
2108         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2109       endif
2110       accel_kconfig += [ sym + '=y' ]
2111     endif
2112   endforeach
2113   if accel_kconfig.length() == 0
2114     if default_targets
2115       continue
2116     endif
2117     error('No accelerator available for target @0@'.format(target))
2118   endif
2119
2120   actual_target_dirs += target
2121   config_target += keyval.load('configs/targets' / target + '.mak')
2122   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2123
2124   if 'TARGET_NEED_FDT' in config_target
2125     fdt_required += target
2126   endif
2127
2128   # Add default keys
2129   if 'TARGET_BASE_ARCH' not in config_target
2130     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2131   endif
2132   if 'TARGET_ABI_DIR' not in config_target
2133     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2134   endif
2135
2136   foreach k, v: disassemblers
2137     if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2138       foreach sym: v
2139         config_target += { sym: 'y' }
2140         config_all_disas += { sym: 'y' }
2141       endforeach
2142     endif
2143   endforeach
2144
2145   config_target_data = configuration_data()
2146   foreach k, v: config_target
2147     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2148       # do nothing
2149     elif ignored.contains(k)
2150       # do nothing
2151     elif k == 'TARGET_BASE_ARCH'
2152       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2153       # not used to select files from sourcesets.
2154       config_target_data.set('TARGET_' + v.to_upper(), 1)
2155     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2156       config_target_data.set_quoted(k, v)
2157     elif v == 'y'
2158       config_target_data.set(k, 1)
2159     else
2160       config_target_data.set(k, v)
2161     endif
2162   endforeach
2163   config_target_data.set('QEMU_ARCH',
2164                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2165   config_target_h += {target: configure_file(output: target + '-config-target.h',
2166                                                configuration: config_target_data)}
2167
2168   if target.endswith('-softmmu')
2169     config_input = meson.get_external_property(target, 'default')
2170     config_devices_mak = target + '-config-devices.mak'
2171     config_devices_mak = configure_file(
2172       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2173       output: config_devices_mak,
2174       depfile: config_devices_mak + '.d',
2175       capture: true,
2176       command: [minikconf,
2177                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2178                 config_devices_mak, '@DEPFILE@', '@INPUT@',
2179                 host_kconfig, accel_kconfig,
2180                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2181
2182     config_devices_data = configuration_data()
2183     config_devices = keyval.load(config_devices_mak)
2184     foreach k, v: config_devices
2185       config_devices_data.set(k, 1)
2186     endforeach
2187     config_devices_mak_list += config_devices_mak
2188     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2189                                                 configuration: config_devices_data)}
2190     config_target += config_devices
2191     config_all_devices += config_devices
2192   endif
2193   config_target_mak += {target: config_target}
2194 endforeach
2195 target_dirs = actual_target_dirs
2196
2197 # This configuration is used to build files that are shared by
2198 # multiple binaries, and then extracted out of the "common"
2199 # static_library target.
2200 #
2201 # We do not use all_sources()/all_dependencies(), because it would
2202 # build literally all source files, including devices only used by
2203 # targets that are not built for this compilation.  The CONFIG_ALL
2204 # pseudo symbol replaces it.
2205
2206 config_all += config_all_devices
2207 config_all += config_host
2208 config_all += config_all_disas
2209 config_all += {
2210   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
2211   'CONFIG_SOFTMMU': have_system,
2212   'CONFIG_USER_ONLY': have_user,
2213   'CONFIG_ALL': true,
2214 }
2215
2216 target_configs_h = []
2217 foreach target: target_dirs
2218   target_configs_h += config_target_h[target]
2219   target_configs_h += config_devices_h.get(target, [])
2220 endforeach
2221 genh += custom_target('config-poison.h',
2222                       input: [target_configs_h],
2223                       output: 'config-poison.h',
2224                       capture: true,
2225                       command: [find_program('scripts/make-config-poison.sh'),
2226                                 target_configs_h])
2227
2228 ##############
2229 # Submodules #
2230 ##############
2231
2232 capstone = not_found
2233 capstone_opt = get_option('capstone')
2234 if capstone_opt in ['enabled', 'auto', 'system']
2235   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
2236   capstone = dependency('capstone', version: '>=4.0',
2237                         kwargs: static_kwargs, method: 'pkg-config',
2238                         required: capstone_opt == 'system' or
2239                                   capstone_opt == 'enabled' and not have_internal)
2240
2241   # Some versions of capstone have broken pkg-config file
2242   # that reports a wrong -I path, causing the #include to
2243   # fail later. If the system has such a broken version
2244   # do not use it.
2245   if capstone.found() and not cc.compiles('#include <capstone.h>',
2246                                           dependencies: [capstone])
2247     capstone = not_found
2248     if capstone_opt == 'system'
2249       error('system capstone requested, it does not appear to work')
2250     endif
2251   endif
2252
2253   if capstone.found()
2254     capstone_opt = 'system'
2255   elif have_internal
2256     capstone_opt = 'internal'
2257   else
2258     capstone_opt = 'disabled'
2259   endif
2260 endif
2261 if capstone_opt == 'internal'
2262   capstone_data = configuration_data()
2263   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
2264
2265   capstone_files = files(
2266     'capstone/cs.c',
2267     'capstone/MCInst.c',
2268     'capstone/MCInstrDesc.c',
2269     'capstone/MCRegisterInfo.c',
2270     'capstone/SStream.c',
2271     'capstone/utils.c'
2272   )
2273
2274   if 'CONFIG_ARM_DIS' in config_all_disas
2275     capstone_data.set('CAPSTONE_HAS_ARM', '1')
2276     capstone_files += files(
2277       'capstone/arch/ARM/ARMDisassembler.c',
2278       'capstone/arch/ARM/ARMInstPrinter.c',
2279       'capstone/arch/ARM/ARMMapping.c',
2280       'capstone/arch/ARM/ARMModule.c'
2281     )
2282   endif
2283
2284   # FIXME: This config entry currently depends on a c++ compiler.
2285   # Which is needed for building libvixl, but not for capstone.
2286   if 'CONFIG_ARM_A64_DIS' in config_all_disas
2287     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
2288     capstone_files += files(
2289       'capstone/arch/AArch64/AArch64BaseInfo.c',
2290       'capstone/arch/AArch64/AArch64Disassembler.c',
2291       'capstone/arch/AArch64/AArch64InstPrinter.c',
2292       'capstone/arch/AArch64/AArch64Mapping.c',
2293       'capstone/arch/AArch64/AArch64Module.c'
2294     )
2295   endif
2296
2297   if 'CONFIG_PPC_DIS' in config_all_disas
2298     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2299     capstone_files += files(
2300       'capstone/arch/PowerPC/PPCDisassembler.c',
2301       'capstone/arch/PowerPC/PPCInstPrinter.c',
2302       'capstone/arch/PowerPC/PPCMapping.c',
2303       'capstone/arch/PowerPC/PPCModule.c'
2304     )
2305   endif
2306
2307   if 'CONFIG_S390_DIS' in config_all_disas
2308     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2309     capstone_files += files(
2310       'capstone/arch/SystemZ/SystemZDisassembler.c',
2311       'capstone/arch/SystemZ/SystemZInstPrinter.c',
2312       'capstone/arch/SystemZ/SystemZMapping.c',
2313       'capstone/arch/SystemZ/SystemZModule.c',
2314       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2315     )
2316   endif
2317
2318   if 'CONFIG_I386_DIS' in config_all_disas
2319     capstone_data.set('CAPSTONE_HAS_X86', 1)
2320     capstone_files += files(
2321       'capstone/arch/X86/X86Disassembler.c',
2322       'capstone/arch/X86/X86DisassemblerDecoder.c',
2323       'capstone/arch/X86/X86ATTInstPrinter.c',
2324       'capstone/arch/X86/X86IntelInstPrinter.c',
2325       'capstone/arch/X86/X86InstPrinterCommon.c',
2326       'capstone/arch/X86/X86Mapping.c',
2327       'capstone/arch/X86/X86Module.c'
2328     )
2329   endif
2330
2331   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2332
2333   capstone_cargs = [
2334     # FIXME: There does not seem to be a way to completely replace the c_args
2335     # that come from add_project_arguments() -- we can only add to them.
2336     # So: disable all warnings with a big hammer.
2337     '-Wno-error', '-w',
2338
2339     # Include all configuration defines via a header file, which will wind up
2340     # as a dependency on the object file, and thus changes here will result
2341     # in a rebuild.
2342     '-include', 'capstone-defs.h'
2343   ]
2344
2345   libcapstone = static_library('capstone',
2346                                build_by_default: false,
2347                                sources: capstone_files,
2348                                c_args: capstone_cargs,
2349                                include_directories: 'capstone/include')
2350   capstone = declare_dependency(link_with: libcapstone,
2351                                 include_directories: 'capstone/include/capstone')
2352 endif
2353
2354 slirp = not_found
2355 slirp_opt = 'disabled'
2356 if have_system
2357   slirp_opt = get_option('slirp')
2358   if slirp_opt in ['enabled', 'auto', 'system']
2359     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2360     slirp = dependency('slirp', kwargs: static_kwargs,
2361                        method: 'pkg-config',
2362                        required: slirp_opt == 'system' or
2363                                  slirp_opt == 'enabled' and not have_internal)
2364     if slirp.found()
2365       slirp_opt = 'system'
2366     elif have_internal
2367       slirp_opt = 'internal'
2368     else
2369       slirp_opt = 'disabled'
2370     endif
2371   endif
2372   if slirp_opt == 'internal'
2373     slirp_deps = []
2374     if targetos == 'windows'
2375       slirp_deps = cc.find_library('iphlpapi')
2376     elif targetos == 'darwin'
2377       slirp_deps = cc.find_library('resolv')
2378     endif
2379     slirp_conf = configuration_data()
2380     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2381     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2382     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2383     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2384     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2385     slirp_files = [
2386       'slirp/src/arp_table.c',
2387       'slirp/src/bootp.c',
2388       'slirp/src/cksum.c',
2389       'slirp/src/dhcpv6.c',
2390       'slirp/src/dnssearch.c',
2391       'slirp/src/if.c',
2392       'slirp/src/ip6_icmp.c',
2393       'slirp/src/ip6_input.c',
2394       'slirp/src/ip6_output.c',
2395       'slirp/src/ip_icmp.c',
2396       'slirp/src/ip_input.c',
2397       'slirp/src/ip_output.c',
2398       'slirp/src/mbuf.c',
2399       'slirp/src/misc.c',
2400       'slirp/src/ncsi.c',
2401       'slirp/src/ndp_table.c',
2402       'slirp/src/sbuf.c',
2403       'slirp/src/slirp.c',
2404       'slirp/src/socket.c',
2405       'slirp/src/state.c',
2406       'slirp/src/stream.c',
2407       'slirp/src/tcp_input.c',
2408       'slirp/src/tcp_output.c',
2409       'slirp/src/tcp_subr.c',
2410       'slirp/src/tcp_timer.c',
2411       'slirp/src/tftp.c',
2412       'slirp/src/udp.c',
2413       'slirp/src/udp6.c',
2414       'slirp/src/util.c',
2415       'slirp/src/version.c',
2416       'slirp/src/vmstate.c',
2417     ]
2418
2419     configure_file(
2420       input : 'slirp/src/libslirp-version.h.in',
2421       output : 'libslirp-version.h',
2422       configuration: slirp_conf)
2423
2424     slirp_inc = include_directories('slirp', 'slirp/src')
2425     libslirp = static_library('slirp',
2426                               build_by_default: false,
2427                               sources: slirp_files,
2428                               c_args: slirp_cargs,
2429                               include_directories: slirp_inc)
2430     slirp = declare_dependency(link_with: libslirp,
2431                                dependencies: slirp_deps,
2432                                include_directories: slirp_inc)
2433   endif
2434 endif
2435
2436 # For CFI, we need to compile slirp as a static library together with qemu.
2437 # This is because we register slirp functions as callbacks for QEMU Timers.
2438 # When using a system-wide shared libslirp, the type information for the
2439 # callback is missing and the timer call produces a false positive with CFI.
2440 #
2441 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2442 # with control-flow integrity.
2443 if get_option('cfi') and slirp_opt == 'system'
2444   error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2445          + ' Please configure with --enable-slirp=git')
2446 endif
2447
2448 fdt = not_found
2449 if have_system
2450   fdt_opt = get_option('fdt')
2451   if fdt_opt in ['enabled', 'auto', 'system']
2452     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2453     fdt = cc.find_library('fdt', kwargs: static_kwargs,
2454                           required: fdt_opt == 'system' or
2455                                     fdt_opt == 'enabled' and not have_internal)
2456     if fdt.found() and cc.links('''
2457        #include <libfdt.h>
2458        #include <libfdt_env.h>
2459        int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2460          dependencies: fdt)
2461       fdt_opt = 'system'
2462     elif fdt_opt == 'system'
2463        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2464     elif have_internal
2465       fdt_opt = 'internal'
2466     else
2467       fdt_opt = 'disabled'
2468       fdt = not_found
2469     endif
2470   endif
2471   if fdt_opt == 'internal'
2472     fdt_files = files(
2473       'dtc/libfdt/fdt.c',
2474       'dtc/libfdt/fdt_ro.c',
2475       'dtc/libfdt/fdt_wip.c',
2476       'dtc/libfdt/fdt_sw.c',
2477       'dtc/libfdt/fdt_rw.c',
2478       'dtc/libfdt/fdt_strerror.c',
2479       'dtc/libfdt/fdt_empty_tree.c',
2480       'dtc/libfdt/fdt_addresses.c',
2481       'dtc/libfdt/fdt_overlay.c',
2482       'dtc/libfdt/fdt_check.c',
2483     )
2484
2485     fdt_inc = include_directories('dtc/libfdt')
2486     libfdt = static_library('fdt',
2487                             build_by_default: false,
2488                             sources: fdt_files,
2489                             include_directories: fdt_inc)
2490     fdt = declare_dependency(link_with: libfdt,
2491                              include_directories: fdt_inc)
2492   endif
2493 else
2494   fdt_opt = 'disabled'
2495 endif
2496 if not fdt.found() and fdt_required.length() > 0
2497   error('fdt not available but required by targets ' + ', '.join(fdt_required))
2498 endif
2499
2500 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2501 config_host_data.set('CONFIG_FDT', fdt.found())
2502 config_host_data.set('CONFIG_SLIRP', slirp.found())
2503
2504 #####################
2505 # Generated sources #
2506 #####################
2507
2508 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2509
2510 hxtool = find_program('scripts/hxtool')
2511 shaderinclude = find_program('scripts/shaderinclude.pl')
2512 qapi_gen = find_program('scripts/qapi-gen.py')
2513 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2514                      meson.current_source_dir() / 'scripts/qapi/commands.py',
2515                      meson.current_source_dir() / 'scripts/qapi/common.py',
2516                      meson.current_source_dir() / 'scripts/qapi/error.py',
2517                      meson.current_source_dir() / 'scripts/qapi/events.py',
2518                      meson.current_source_dir() / 'scripts/qapi/expr.py',
2519                      meson.current_source_dir() / 'scripts/qapi/gen.py',
2520                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
2521                      meson.current_source_dir() / 'scripts/qapi/parser.py',
2522                      meson.current_source_dir() / 'scripts/qapi/schema.py',
2523                      meson.current_source_dir() / 'scripts/qapi/source.py',
2524                      meson.current_source_dir() / 'scripts/qapi/types.py',
2525                      meson.current_source_dir() / 'scripts/qapi/visit.py',
2526                      meson.current_source_dir() / 'scripts/qapi/common.py',
2527                      meson.current_source_dir() / 'scripts/qapi-gen.py'
2528 ]
2529
2530 tracetool = [
2531   python, files('scripts/tracetool.py'),
2532    '--backend=' + ','.join(get_option('trace_backends'))
2533 ]
2534 tracetool_depends = files(
2535   'scripts/tracetool/backend/log.py',
2536   'scripts/tracetool/backend/__init__.py',
2537   'scripts/tracetool/backend/dtrace.py',
2538   'scripts/tracetool/backend/ftrace.py',
2539   'scripts/tracetool/backend/simple.py',
2540   'scripts/tracetool/backend/syslog.py',
2541   'scripts/tracetool/backend/ust.py',
2542   'scripts/tracetool/format/ust_events_c.py',
2543   'scripts/tracetool/format/ust_events_h.py',
2544   'scripts/tracetool/format/__init__.py',
2545   'scripts/tracetool/format/d.py',
2546   'scripts/tracetool/format/simpletrace_stap.py',
2547   'scripts/tracetool/format/c.py',
2548   'scripts/tracetool/format/h.py',
2549   'scripts/tracetool/format/log_stap.py',
2550   'scripts/tracetool/format/stap.py',
2551   'scripts/tracetool/__init__.py',
2552   'scripts/tracetool/transform.py',
2553   'scripts/tracetool/vcpu.py'
2554 )
2555
2556 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2557                     meson.current_source_dir(),
2558                     config_host['PKGVERSION'], meson.project_version()]
2559 qemu_version = custom_target('qemu-version.h',
2560                              output: 'qemu-version.h',
2561                              command: qemu_version_cmd,
2562                              capture: true,
2563                              build_by_default: true,
2564                              build_always_stale: true)
2565 genh += qemu_version
2566
2567 hxdep = []
2568 hx_headers = [
2569   ['qemu-options.hx', 'qemu-options.def'],
2570   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2571 ]
2572 if have_system
2573   hx_headers += [
2574     ['hmp-commands.hx', 'hmp-commands.h'],
2575     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2576   ]
2577 endif
2578 foreach d : hx_headers
2579   hxdep += custom_target(d[1],
2580                 input: files(d[0]),
2581                 output: d[1],
2582                 capture: true,
2583                 build_by_default: true, # to be removed when added to a target
2584                 command: [hxtool, '-h', '@INPUT0@'])
2585 endforeach
2586 genh += hxdep
2587
2588 ###################
2589 # Collect sources #
2590 ###################
2591
2592 authz_ss = ss.source_set()
2593 blockdev_ss = ss.source_set()
2594 block_ss = ss.source_set()
2595 chardev_ss = ss.source_set()
2596 common_ss = ss.source_set()
2597 crypto_ss = ss.source_set()
2598 hwcore_ss = ss.source_set()
2599 io_ss = ss.source_set()
2600 qmp_ss = ss.source_set()
2601 qom_ss = ss.source_set()
2602 softmmu_ss = ss.source_set()
2603 specific_fuzz_ss = ss.source_set()
2604 specific_ss = ss.source_set()
2605 stub_ss = ss.source_set()
2606 trace_ss = ss.source_set()
2607 user_ss = ss.source_set()
2608 util_ss = ss.source_set()
2609
2610 # accel modules
2611 qtest_module_ss = ss.source_set()
2612 tcg_module_ss = ss.source_set()
2613
2614 modules = {}
2615 target_modules = {}
2616 hw_arch = {}
2617 target_arch = {}
2618 target_softmmu_arch = {}
2619 target_user_arch = {}
2620
2621 ###############
2622 # Trace files #
2623 ###############
2624
2625 # TODO: add each directory to the subdirs from its own meson.build, once
2626 # we have those
2627 trace_events_subdirs = [
2628   'crypto',
2629   'qapi',
2630   'qom',
2631   'monitor',
2632   'util',
2633 ]
2634 if have_linux_user
2635   trace_events_subdirs += [ 'linux-user' ]
2636 endif
2637 if have_bsd_user
2638   trace_events_subdirs += [ 'bsd-user' ]
2639 endif
2640 if have_block
2641   trace_events_subdirs += [
2642     'authz',
2643     'block',
2644     'io',
2645     'nbd',
2646     'scsi',
2647   ]
2648 endif
2649 if have_system
2650   trace_events_subdirs += [
2651     'accel/kvm',
2652     'audio',
2653     'backends',
2654     'backends/tpm',
2655     'chardev',
2656     'ebpf',
2657     'hw/9pfs',
2658     'hw/acpi',
2659     'hw/adc',
2660     'hw/alpha',
2661     'hw/arm',
2662     'hw/audio',
2663     'hw/block',
2664     'hw/block/dataplane',
2665     'hw/char',
2666     'hw/display',
2667     'hw/dma',
2668     'hw/hppa',
2669     'hw/hyperv',
2670     'hw/i2c',
2671     'hw/i386',
2672     'hw/i386/xen',
2673     'hw/ide',
2674     'hw/input',
2675     'hw/intc',
2676     'hw/isa',
2677     'hw/mem',
2678     'hw/mips',
2679     'hw/misc',
2680     'hw/misc/macio',
2681     'hw/net',
2682     'hw/net/can',
2683     'hw/nubus',
2684     'hw/nvme',
2685     'hw/nvram',
2686     'hw/pci',
2687     'hw/pci-host',
2688     'hw/ppc',
2689     'hw/rdma',
2690     'hw/rdma/vmw',
2691     'hw/rtc',
2692     'hw/s390x',
2693     'hw/scsi',
2694     'hw/sd',
2695     'hw/sh4',
2696     'hw/sparc',
2697     'hw/sparc64',
2698     'hw/ssi',
2699     'hw/timer',
2700     'hw/tpm',
2701     'hw/usb',
2702     'hw/vfio',
2703     'hw/virtio',
2704     'hw/watchdog',
2705     'hw/xen',
2706     'hw/gpio',
2707     'migration',
2708     'net',
2709     'softmmu',
2710     'ui',
2711     'hw/remote',
2712   ]
2713 endif
2714 if have_system or have_user
2715   trace_events_subdirs += [
2716     'accel/tcg',
2717     'hw/core',
2718     'target/arm',
2719     'target/arm/hvf',
2720     'target/hppa',
2721     'target/i386',
2722     'target/i386/kvm',
2723     'target/mips/tcg',
2724     'target/nios2',
2725     'target/ppc',
2726     'target/riscv',
2727     'target/s390x',
2728     'target/s390x/kvm',
2729     'target/sparc',
2730   ]
2731 endif
2732
2733 vhost_user = not_found
2734 if targetos == 'linux' and 'CONFIG_VHOST_USER' in config_host
2735   libvhost_user = subproject('libvhost-user')
2736   vhost_user = libvhost_user.get_variable('vhost_user_dep')
2737 endif
2738
2739 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
2740 # that is filled in by qapi/.
2741 subdir('qapi')
2742 subdir('qobject')
2743 subdir('stubs')
2744 subdir('trace')
2745 subdir('util')
2746 subdir('qom')
2747 subdir('authz')
2748 subdir('crypto')
2749 subdir('ui')
2750
2751
2752 if enable_modules
2753   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2754   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2755 endif
2756
2757 stub_ss = stub_ss.apply(config_all, strict: false)
2758
2759 util_ss.add_all(trace_ss)
2760 util_ss = util_ss.apply(config_all, strict: false)
2761 libqemuutil = static_library('qemuutil',
2762                              sources: util_ss.sources() + stub_ss.sources() + genh,
2763                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2764 qemuutil = declare_dependency(link_with: libqemuutil,
2765                               sources: genh + version_res)
2766
2767 if have_system or have_user
2768   decodetree = generator(find_program('scripts/decodetree.py'),
2769                          output: 'decode-@BASENAME@.c.inc',
2770                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2771   subdir('libdecnumber')
2772   subdir('target')
2773 endif
2774
2775 subdir('audio')
2776 subdir('io')
2777 subdir('chardev')
2778 subdir('fsdev')
2779 subdir('dump')
2780
2781 if have_block
2782   block_ss.add(files(
2783     'block.c',
2784     'blockjob.c',
2785     'job.c',
2786     'qemu-io-cmds.c',
2787   ))
2788   if config_host_data.get('CONFIG_REPLICATION')
2789     block_ss.add(files('replication.c'))
2790   endif
2791
2792   subdir('nbd')
2793   subdir('scsi')
2794   subdir('block')
2795
2796   blockdev_ss.add(files(
2797     'blockdev.c',
2798     'blockdev-nbd.c',
2799     'iothread.c',
2800     'job-qmp.c',
2801   ), gnutls)
2802
2803   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2804   # os-win32.c does not
2805   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2806   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2807 endif
2808
2809 common_ss.add(files('cpus-common.c'))
2810
2811 subdir('softmmu')
2812
2813 common_ss.add(capstone)
2814 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2815
2816 # Work around a gcc bug/misfeature wherein constant propagation looks
2817 # through an alias:
2818 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2819 # to guess that a const variable is always zero.  Without lto, this is
2820 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
2821 # without lto, not even the alias is required -- we simply use different
2822 # declarations in different compilation units.
2823 pagevary = files('page-vary-common.c')
2824 if get_option('b_lto')
2825   pagevary_flags = ['-fno-lto']
2826   if get_option('cfi')
2827     pagevary_flags += '-fno-sanitize=cfi-icall'
2828   endif
2829   pagevary = static_library('page-vary-common', sources: pagevary,
2830                             c_args: pagevary_flags)
2831   pagevary = declare_dependency(link_with: pagevary)
2832 endif
2833 common_ss.add(pagevary)
2834 specific_ss.add(files('page-vary.c'))
2835
2836 subdir('backends')
2837 subdir('disas')
2838 subdir('migration')
2839 subdir('monitor')
2840 subdir('net')
2841 subdir('replay')
2842 subdir('semihosting')
2843 subdir('hw')
2844 subdir('tcg')
2845 subdir('fpu')
2846 subdir('accel')
2847 subdir('plugins')
2848 subdir('ebpf')
2849
2850 common_user_inc = []
2851
2852 subdir('common-user')
2853 subdir('bsd-user')
2854 subdir('linux-user')
2855
2856 # needed for fuzzing binaries
2857 subdir('tests/qtest/libqos')
2858 subdir('tests/qtest/fuzz')
2859
2860 # accel modules
2861 tcg_real_module_ss = ss.source_set()
2862 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2863 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2864 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2865                                 'tcg': tcg_real_module_ss }}
2866
2867 ########################
2868 # Library dependencies #
2869 ########################
2870
2871 modinfo_collect = find_program('scripts/modinfo-collect.py')
2872 modinfo_generate = find_program('scripts/modinfo-generate.py')
2873 modinfo_files = []
2874
2875 block_mods = []
2876 softmmu_mods = []
2877 foreach d, list : modules
2878   foreach m, module_ss : list
2879     if enable_modules and targetos != 'windows'
2880       module_ss = module_ss.apply(config_all, strict: false)
2881       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2882                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2883       if d == 'block'
2884         block_mods += sl
2885       else
2886         softmmu_mods += sl
2887       endif
2888       if module_ss.sources() != []
2889         # FIXME: Should use sl.extract_all_objects(recursive: true) as
2890         # input. Sources can be used multiple times but objects are
2891         # unique when it comes to lookup in compile_commands.json.
2892         # Depnds on a mesion version with
2893         # https://github.com/mesonbuild/meson/pull/8900
2894         modinfo_files += custom_target(d + '-' + m + '.modinfo',
2895                                        output: d + '-' + m + '.modinfo',
2896                                        input: module_ss.sources() + genh,
2897                                        capture: true,
2898                                        command: [modinfo_collect, module_ss.sources()])
2899       endif
2900     else
2901       if d == 'block'
2902         block_ss.add_all(module_ss)
2903       else
2904         softmmu_ss.add_all(module_ss)
2905       endif
2906     endif
2907   endforeach
2908 endforeach
2909
2910 foreach d, list : target_modules
2911   foreach m, module_ss : list
2912     if enable_modules and targetos != 'windows'
2913       foreach target : target_dirs
2914         if target.endswith('-softmmu')
2915           config_target = config_target_mak[target]
2916           config_target += config_host
2917           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2918           c_args = ['-DNEED_CPU_H',
2919                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2920                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2921           target_module_ss = module_ss.apply(config_target, strict: false)
2922           if target_module_ss.sources() != []
2923             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2924             sl = static_library(module_name,
2925                                 [genh, target_module_ss.sources()],
2926                                 dependencies: [modulecommon, target_module_ss.dependencies()],
2927                                 include_directories: target_inc,
2928                                 c_args: c_args,
2929                                 pic: true)
2930             softmmu_mods += sl
2931             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2932             modinfo_files += custom_target(module_name + '.modinfo',
2933                                            output: module_name + '.modinfo',
2934                                            input: target_module_ss.sources() + genh,
2935                                            capture: true,
2936                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2937           endif
2938         endif
2939       endforeach
2940     else
2941       specific_ss.add_all(module_ss)
2942     endif
2943   endforeach
2944 endforeach
2945
2946 if enable_modules
2947   modinfo_src = custom_target('modinfo.c',
2948                               output: 'modinfo.c',
2949                               input: modinfo_files,
2950                               command: [modinfo_generate, '@INPUT@'],
2951                               capture: true)
2952   modinfo_lib = static_library('modinfo', modinfo_src)
2953   modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2954   softmmu_ss.add(modinfo_dep)
2955 endif
2956
2957 nm = find_program('nm')
2958 undefsym = find_program('scripts/undefsym.py')
2959 block_syms = custom_target('block.syms', output: 'block.syms',
2960                              input: [libqemuutil, block_mods],
2961                              capture: true,
2962                              command: [undefsym, nm, '@INPUT@'])
2963 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2964                              input: [libqemuutil, softmmu_mods],
2965                              capture: true,
2966                              command: [undefsym, nm, '@INPUT@'])
2967
2968 qom_ss = qom_ss.apply(config_host, strict: false)
2969 libqom = static_library('qom', qom_ss.sources() + genh,
2970                         dependencies: [qom_ss.dependencies()],
2971                         name_suffix: 'fa')
2972
2973 qom = declare_dependency(link_whole: libqom)
2974
2975 authz_ss = authz_ss.apply(config_host, strict: false)
2976 libauthz = static_library('authz', authz_ss.sources() + genh,
2977                           dependencies: [authz_ss.dependencies()],
2978                           name_suffix: 'fa',
2979                           build_by_default: false)
2980
2981 authz = declare_dependency(link_whole: libauthz,
2982                            dependencies: qom)
2983
2984 crypto_ss = crypto_ss.apply(config_host, strict: false)
2985 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2986                            dependencies: [crypto_ss.dependencies()],
2987                            name_suffix: 'fa',
2988                            build_by_default: false)
2989
2990 crypto = declare_dependency(link_whole: libcrypto,
2991                             dependencies: [authz, qom])
2992
2993 io_ss = io_ss.apply(config_host, strict: false)
2994 libio = static_library('io', io_ss.sources() + genh,
2995                        dependencies: [io_ss.dependencies()],
2996                        link_with: libqemuutil,
2997                        name_suffix: 'fa',
2998                        build_by_default: false)
2999
3000 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3001
3002 libmigration = static_library('migration', sources: migration_files + genh,
3003                               name_suffix: 'fa',
3004                               build_by_default: false)
3005 migration = declare_dependency(link_with: libmigration,
3006                                dependencies: [zlib, qom, io])
3007 softmmu_ss.add(migration)
3008
3009 block_ss = block_ss.apply(config_host, strict: false)
3010 libblock = static_library('block', block_ss.sources() + genh,
3011                           dependencies: block_ss.dependencies(),
3012                           link_depends: block_syms,
3013                           name_suffix: 'fa',
3014                           build_by_default: false)
3015
3016 block = declare_dependency(link_whole: [libblock],
3017                            link_args: '@block.syms',
3018                            dependencies: [crypto, io])
3019
3020 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3021 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3022                              dependencies: blockdev_ss.dependencies(),
3023                              name_suffix: 'fa',
3024                              build_by_default: false)
3025
3026 blockdev = declare_dependency(link_whole: [libblockdev],
3027                               dependencies: [block])
3028
3029 qmp_ss = qmp_ss.apply(config_host, strict: false)
3030 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3031                         dependencies: qmp_ss.dependencies(),
3032                         name_suffix: 'fa',
3033                         build_by_default: false)
3034
3035 qmp = declare_dependency(link_whole: [libqmp])
3036
3037 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3038                             name_suffix: 'fa',
3039                             dependencies: [gnutls],
3040                             build_by_default: false)
3041
3042 chardev = declare_dependency(link_whole: libchardev)
3043
3044 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3045 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3046                            name_suffix: 'fa',
3047                            build_by_default: false)
3048 hwcore = declare_dependency(link_whole: libhwcore)
3049 common_ss.add(hwcore)
3050
3051 ###########
3052 # Targets #
3053 ###########
3054
3055 emulator_modules = []
3056 foreach m : block_mods + softmmu_mods
3057   emulator_modules += shared_module(m.name(),
3058                 build_by_default: true,
3059                 name_prefix: '',
3060                 link_whole: m,
3061                 install: true,
3062                 install_dir: qemu_moddir)
3063 endforeach
3064
3065 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3066 common_ss.add(qom, qemuutil)
3067
3068 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3069 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3070
3071 common_all = common_ss.apply(config_all, strict: false)
3072 common_all = static_library('common',
3073                             build_by_default: false,
3074                             sources: common_all.sources() + genh,
3075                             include_directories: common_user_inc,
3076                             implicit_include_directories: false,
3077                             dependencies: common_all.dependencies(),
3078                             name_suffix: 'fa')
3079
3080 feature_to_c = find_program('scripts/feature_to_c.sh')
3081
3082 if targetos == 'darwin'
3083   entitlement = find_program('scripts/entitlement.sh')
3084 endif
3085
3086 emulators = {}
3087 foreach target : target_dirs
3088   config_target = config_target_mak[target]
3089   target_name = config_target['TARGET_NAME']
3090   target_base_arch = config_target['TARGET_BASE_ARCH']
3091   arch_srcs = [config_target_h[target]]
3092   arch_deps = []
3093   c_args = ['-DNEED_CPU_H',
3094             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3095             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3096   link_args = emulator_link_args
3097
3098   config_target += config_host
3099   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3100   if targetos == 'linux'
3101     target_inc += include_directories('linux-headers', is_system: true)
3102   endif
3103   if target.endswith('-softmmu')
3104     qemu_target_name = 'qemu-system-' + target_name
3105     target_type='system'
3106     t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3107     arch_srcs += t.sources()
3108     arch_deps += t.dependencies()
3109
3110     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3111     hw = hw_arch[hw_dir].apply(config_target, strict: false)
3112     arch_srcs += hw.sources()
3113     arch_deps += hw.dependencies()
3114
3115     arch_srcs += config_devices_h[target]
3116     link_args += ['@block.syms', '@qemu.syms']
3117   else
3118     abi = config_target['TARGET_ABI_DIR']
3119     target_type='user'
3120     target_inc += common_user_inc
3121     qemu_target_name = 'qemu-' + target_name
3122     if target_base_arch in target_user_arch
3123       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3124       arch_srcs += t.sources()
3125       arch_deps += t.dependencies()
3126     endif
3127     if 'CONFIG_LINUX_USER' in config_target
3128       base_dir = 'linux-user'
3129     endif
3130     if 'CONFIG_BSD_USER' in config_target
3131       base_dir = 'bsd-user'
3132       target_inc += include_directories('bsd-user/' / targetos)
3133       target_inc += include_directories('bsd-user/host/' / host_arch)
3134       dir = base_dir / abi
3135       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3136     endif
3137     target_inc += include_directories(
3138       base_dir,
3139       base_dir / abi,
3140     )
3141     if 'CONFIG_LINUX_USER' in config_target
3142       dir = base_dir / abi
3143       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3144       if config_target.has_key('TARGET_SYSTBL_ABI')
3145         arch_srcs += \
3146           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3147                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3148       endif
3149     endif
3150   endif
3151
3152   if 'TARGET_XML_FILES' in config_target
3153     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3154                                 output: target + '-gdbstub-xml.c',
3155                                 input: files(config_target['TARGET_XML_FILES'].split()),
3156                                 command: [feature_to_c, '@INPUT@'],
3157                                 capture: true)
3158     arch_srcs += gdbstub_xml
3159   endif
3160
3161   t = target_arch[target_base_arch].apply(config_target, strict: false)
3162   arch_srcs += t.sources()
3163   arch_deps += t.dependencies()
3164
3165   target_common = common_ss.apply(config_target, strict: false)
3166   objects = common_all.extract_objects(target_common.sources())
3167   deps = target_common.dependencies()
3168
3169   target_specific = specific_ss.apply(config_target, strict: false)
3170   arch_srcs += target_specific.sources()
3171   arch_deps += target_specific.dependencies()
3172
3173   lib = static_library('qemu-' + target,
3174                  sources: arch_srcs + genh,
3175                  dependencies: arch_deps,
3176                  objects: objects,
3177                  include_directories: target_inc,
3178                  c_args: c_args,
3179                  build_by_default: false,
3180                  name_suffix: 'fa')
3181
3182   if target.endswith('-softmmu')
3183     execs = [{
3184       'name': 'qemu-system-' + target_name,
3185       'win_subsystem': 'console',
3186       'sources': files('softmmu/main.c'),
3187       'dependencies': []
3188     }]
3189     if targetos == 'windows' and (sdl.found() or gtk.found())
3190       execs += [{
3191         'name': 'qemu-system-' + target_name + 'w',
3192         'win_subsystem': 'windows',
3193         'sources': files('softmmu/main.c'),
3194         'dependencies': []
3195       }]
3196     endif
3197     if get_option('fuzzing')
3198       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3199       execs += [{
3200         'name': 'qemu-fuzz-' + target_name,
3201         'win_subsystem': 'console',
3202         'sources': specific_fuzz.sources(),
3203         'dependencies': specific_fuzz.dependencies(),
3204       }]
3205     endif
3206   else
3207     execs = [{
3208       'name': 'qemu-' + target_name,
3209       'win_subsystem': 'console',
3210       'sources': [],
3211       'dependencies': []
3212     }]
3213   endif
3214   foreach exe: execs
3215     exe_name = exe['name']
3216     if targetos == 'darwin'
3217       exe_name += '-unsigned'
3218     endif
3219
3220     emulator = executable(exe_name, exe['sources'],
3221                install: true,
3222                c_args: c_args,
3223                dependencies: arch_deps + deps + exe['dependencies'],
3224                objects: lib.extract_all_objects(recursive: true),
3225                link_language: link_language,
3226                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3227                link_args: link_args,
3228                win_subsystem: exe['win_subsystem'])
3229
3230     if targetos == 'darwin'
3231       icon = 'pc-bios/qemu.rsrc'
3232       build_input = [emulator, files(icon)]
3233       install_input = [
3234         get_option('bindir') / exe_name,
3235         meson.current_source_dir() / icon
3236       ]
3237       if 'CONFIG_HVF' in config_target
3238         entitlements = 'accel/hvf/entitlements.plist'
3239         build_input += files(entitlements)
3240         install_input += meson.current_source_dir() / entitlements
3241       endif
3242
3243       emulators += {exe['name'] : custom_target(exe['name'],
3244                    input: build_input,
3245                    output: exe['name'],
3246                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3247       }
3248
3249       meson.add_install_script(entitlement, '--install',
3250                                get_option('bindir') / exe['name'],
3251                                install_input)
3252     else
3253       emulators += {exe['name']: emulator}
3254     endif
3255
3256     if stap.found()
3257       foreach stp: [
3258         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3259         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3260         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3261         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3262       ]
3263         custom_target(exe['name'] + stp['ext'],
3264                       input: trace_events_all,
3265                       output: exe['name'] + stp['ext'],
3266                       install: stp['install'],
3267                       install_dir: get_option('datadir') / 'systemtap/tapset',
3268                       command: [
3269                         tracetool, '--group=all', '--format=' + stp['fmt'],
3270                         '--binary=' + stp['bin'],
3271                         '--target-name=' + target_name,
3272                         '--target-type=' + target_type,
3273                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3274                         '@INPUT@', '@OUTPUT@'
3275                       ],
3276                       depend_files: tracetool_depends)
3277       endforeach
3278     endif
3279   endforeach
3280 endforeach
3281
3282 # Other build targets
3283
3284 if 'CONFIG_PLUGIN' in config_host
3285   install_headers('include/qemu/qemu-plugin.h')
3286 endif
3287
3288 subdir('qga')
3289
3290 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3291 # when we don't build tools or system
3292 if xkbcommon.found()
3293   # used for the update-keymaps target, so include rules even if !have_tools
3294   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3295                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3296 endif
3297
3298 if have_tools
3299   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3300              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3301   qemu_io = executable('qemu-io', files('qemu-io.c'),
3302              dependencies: [block, qemuutil], install: true)
3303   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3304                dependencies: [blockdev, qemuutil, gnutls, selinux],
3305                install: true)
3306
3307   subdir('storage-daemon')
3308   subdir('contrib/rdmacm-mux')
3309   subdir('contrib/elf2dmp')
3310
3311   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3312              dependencies: qemuutil,
3313              install: true)
3314
3315   if 'CONFIG_VHOST_USER' in config_host
3316     subdir('contrib/vhost-user-blk')
3317     subdir('contrib/vhost-user-gpu')
3318     subdir('contrib/vhost-user-input')
3319     subdir('contrib/vhost-user-scsi')
3320   endif
3321
3322   if targetos == 'linux'
3323     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3324                dependencies: [qemuutil, libcap_ng],
3325                install: true,
3326                install_dir: get_option('libexecdir'))
3327
3328     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3329                dependencies: [authz, crypto, io, qom, qemuutil,
3330                               libcap_ng, mpathpersist],
3331                install: true)
3332   endif
3333
3334   if have_ivshmem
3335     subdir('contrib/ivshmem-client')
3336     subdir('contrib/ivshmem-server')
3337   endif
3338 endif
3339
3340 subdir('scripts')
3341 subdir('tools')
3342 subdir('pc-bios')
3343 subdir('docs')
3344 subdir('tests')
3345 if gtk.found()
3346   subdir('po')
3347 endif
3348
3349 if host_machine.system() == 'windows'
3350   nsis_cmd = [
3351     find_program('scripts/nsis.py'),
3352     '@OUTPUT@',
3353     get_option('prefix'),
3354     meson.current_source_dir(),
3355     host_machine.cpu(),
3356     '--',
3357     '-DDISPLAYVERSION=' + meson.project_version(),
3358   ]
3359   if build_docs
3360     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3361   endif
3362   if gtk.found()
3363     nsis_cmd += '-DCONFIG_GTK=y'
3364   endif
3365
3366   nsis = custom_target('nsis',
3367                        output: 'qemu-setup-' + meson.project_version() + '.exe',
3368                        input: files('qemu.nsi'),
3369                        build_always_stale: true,
3370                        command: nsis_cmd + ['@INPUT@'])
3371   alias_target('installer', nsis)
3372 endif
3373
3374 #########################
3375 # Configuration summary #
3376 #########################
3377
3378 # Directories
3379 summary_info = {}
3380 summary_info += {'Install prefix':    get_option('prefix')}
3381 summary_info += {'BIOS directory':    qemu_datadir}
3382 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
3383 summary_info += {'binary directory':  get_option('bindir')}
3384 summary_info += {'library directory': get_option('libdir')}
3385 summary_info += {'module directory':  qemu_moddir}
3386 summary_info += {'libexec directory': get_option('libexecdir')}
3387 summary_info += {'include directory': get_option('includedir')}
3388 summary_info += {'config directory':  get_option('sysconfdir')}
3389 if targetos != 'windows'
3390   summary_info += {'local state directory': get_option('localstatedir')}
3391   summary_info += {'Manual directory':      get_option('mandir')}
3392 else
3393   summary_info += {'local state directory': 'queried at runtime'}
3394 endif
3395 summary_info += {'Doc directory':     get_option('docdir')}
3396 summary_info += {'Build directory':   meson.current_build_dir()}
3397 summary_info += {'Source path':       meson.current_source_dir()}
3398 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
3399 summary(summary_info, bool_yn: true, section: 'Directories')
3400
3401 # Host binaries
3402 summary_info = {}
3403 summary_info += {'git':               config_host['GIT']}
3404 summary_info += {'make':              config_host['MAKE']}
3405 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3406 summary_info += {'sphinx-build':      sphinx_build}
3407 if config_host.has_key('HAVE_GDB_BIN')
3408   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
3409 endif
3410 if get_option('iasl') != ''
3411   summary_info += {'iasl':            get_option('iasl')}
3412 else
3413   summary_info += {'iasl':            false}
3414 endif
3415 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
3416 if targetos == 'windows' and have_ga
3417   summary_info += {'wixl':            wixl}
3418 endif
3419 if slirp_opt != 'disabled' and have_system
3420   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
3421 endif
3422 summary(summary_info, bool_yn: true, section: 'Host binaries')
3423
3424 # Configurable features
3425 summary_info = {}
3426 summary_info += {'Documentation':     build_docs}
3427 summary_info += {'system-mode emulation': have_system}
3428 summary_info += {'user-mode emulation': have_user}
3429 summary_info += {'block layer':       have_block}
3430 summary_info += {'Install blobs':     get_option('install_blobs')}
3431 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
3432 if config_host.has_key('CONFIG_MODULES')
3433   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3434 endif
3435 summary_info += {'fuzzing support':   get_option('fuzzing')}
3436 if have_system
3437   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
3438 endif
3439 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
3440 if 'simple' in get_option('trace_backends')
3441   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3442 endif
3443 summary_info += {'D-Bus display':     dbus_display}
3444 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
3445 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3446 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3447 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3448 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3449 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3450 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3451 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3452 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3453 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3454 summary_info += {'build guest agent': have_ga}
3455 summary(summary_info, bool_yn: true, section: 'Configurable features')
3456
3457 # Compilation information
3458 summary_info = {}
3459 summary_info += {'host CPU':          cpu}
3460 summary_info += {'host endianness':   build_machine.endian()}
3461 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
3462 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3463 if link_language == 'cpp'
3464   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
3465 else
3466   summary_info += {'C++ compiler':      false}
3467 endif
3468 if targetos == 'darwin'
3469   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3470 endif
3471 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
3472                                                + ['-O' + get_option('optimization')]
3473                                                + (get_option('debug') ? ['-g'] : []))}
3474 if link_language == 'cpp'
3475   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
3476                                                + ['-O' + get_option('optimization')]
3477                                                + (get_option('debug') ? ['-g'] : []))}
3478 endif
3479 if targetos == 'darwin'
3480   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args')
3481                                                + ['-O' + get_option('optimization')]
3482                                                + (get_option('debug') ? ['-g'] : []))}
3483 endif
3484 link_args = get_option(link_language + '_link_args')
3485 if link_args.length() > 0
3486   summary_info += {'LDFLAGS':         ' '.join(link_args)}
3487 endif
3488 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
3489 summary_info += {'QEMU_CXXFLAGS':     config_host['QEMU_CXXFLAGS']}
3490 summary_info += {'QEMU_OBJCFLAGS':    config_host['QEMU_OBJCFLAGS']}
3491 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
3492 summary_info += {'profiler':          get_option('profiler')}
3493 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3494 summary_info += {'PIE':               get_option('b_pie')}
3495 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
3496 summary_info += {'malloc trim support': has_malloc_trim}
3497 summary_info += {'membarrier':        have_membarrier}
3498 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3499 summary_info += {'mutex debugging':   get_option('debug_mutex')}
3500 summary_info += {'memory allocator':  get_option('malloc')}
3501 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3502 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3503 summary_info += {'gprof enabled':     get_option('gprof')}
3504 summary_info += {'gcov':              get_option('b_coverage')}
3505 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
3506 summary_info += {'CFI support':       get_option('cfi')}
3507 if get_option('cfi')
3508   summary_info += {'CFI debug support': get_option('cfi_debug')}
3509 endif
3510 summary_info += {'strip binaries':    get_option('strip')}
3511 summary_info += {'sparse':            sparse}
3512 summary_info += {'mingw32 support':   targetos == 'windows'}
3513
3514 # snarf the cross-compilation information for tests
3515 foreach target: target_dirs
3516   tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3517   if fs.exists(tcg_mak)
3518     config_cross_tcg = keyval.load(tcg_mak)
3519     target = config_cross_tcg['TARGET_NAME']
3520     compiler = ''
3521     if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3522       summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3523                                           ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3524     elif 'CROSS_CC_GUEST' in config_cross_tcg
3525       summary_info += {target + ' tests'
3526                                 : config_cross_tcg['CROSS_CC_GUEST'] }
3527     endif
3528    endif
3529 endforeach
3530
3531 summary(summary_info, bool_yn: true, section: 'Compilation')
3532
3533 # Targets and accelerators
3534 summary_info = {}
3535 if have_system
3536   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
3537   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
3538   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
3539   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
3540   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
3541   summary_info += {'Xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
3542   if config_host.has_key('CONFIG_XEN_BACKEND')
3543     summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3544   endif
3545 endif
3546 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
3547 if config_all.has_key('CONFIG_TCG')
3548   if get_option('tcg_interpreter')
3549     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
3550   else
3551     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
3552   endif
3553   summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3554   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3555 endif
3556 summary_info += {'target list':       ' '.join(target_dirs)}
3557 if have_system
3558   summary_info += {'default devices':   get_option('default_devices')}
3559   summary_info += {'out of process emulation': multiprocess_allowed}
3560 endif
3561 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3562
3563 # Block layer
3564 summary_info = {}
3565 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3566 summary_info += {'coroutine pool':    have_coroutine_pool}
3567 if have_block
3568   summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3569   summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3570   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3571   summary_info += {'VirtFS support':    have_virtfs}
3572   summary_info += {'build virtiofs daemon': have_virtiofsd}
3573   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3574   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3575   summary_info += {'bochs support':     get_option('bochs').allowed()}
3576   summary_info += {'cloop support':     get_option('cloop').allowed()}
3577   summary_info += {'dmg support':       get_option('dmg').allowed()}
3578   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
3579   summary_info += {'vdi support':       get_option('vdi').allowed()}
3580   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
3581   summary_info += {'qed support':       get_option('qed').allowed()}
3582   summary_info += {'parallels support': get_option('parallels').allowed()}
3583   summary_info += {'FUSE exports':      fuse}
3584 endif
3585 summary(summary_info, bool_yn: true, section: 'Block layer support')
3586
3587 # Crypto
3588 summary_info = {}
3589 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
3590 summary_info += {'GNUTLS support':    gnutls}
3591 if gnutls.found()
3592   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
3593 endif
3594 summary_info += {'libgcrypt':         gcrypt}
3595 summary_info += {'nettle':            nettle}
3596 if nettle.found()
3597    summary_info += {'  XTS':             xts != 'private'}
3598 endif
3599 summary_info += {'AF_ALG support':    have_afalg}
3600 summary_info += {'rng-none':          get_option('rng_none')}
3601 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
3602 summary(summary_info, bool_yn: true, section: 'Crypto')
3603
3604 # Libraries
3605 summary_info = {}
3606 if targetos == 'darwin'
3607   summary_info += {'Cocoa support':   cocoa}
3608 endif
3609 summary_info += {'SDL support':       sdl}
3610 summary_info += {'SDL image support': sdl_image}
3611 summary_info += {'GTK support':       gtk}
3612 summary_info += {'pixman':            pixman}
3613 summary_info += {'VTE support':       vte}
3614 summary_info += {'slirp support':     slirp_opt == 'internal' ? slirp_opt : slirp}
3615 summary_info += {'libtasn1':          tasn1}
3616 summary_info += {'PAM':               pam}
3617 summary_info += {'iconv support':     iconv}
3618 summary_info += {'curses support':    curses}
3619 summary_info += {'virgl support':     virgl}
3620 summary_info += {'curl support':      curl}
3621 summary_info += {'Multipath support': mpathpersist}
3622 summary_info += {'VNC support':       vnc}
3623 if vnc.found()
3624   summary_info += {'VNC SASL support':  sasl}
3625   summary_info += {'VNC JPEG support':  jpeg}
3626   summary_info += {'VNC PNG support':   png}
3627 endif
3628 if targetos not in ['darwin', 'haiku', 'windows']
3629   summary_info += {'OSS support':     oss}
3630 elif targetos == 'darwin'
3631   summary_info += {'CoreAudio support': coreaudio}
3632 elif targetos == 'windows'
3633   summary_info += {'DirectSound support': dsound}
3634 endif
3635 if targetos == 'linux'
3636   summary_info += {'ALSA support':    alsa}
3637   summary_info += {'PulseAudio support': pulse}
3638 endif
3639 summary_info += {'JACK support':      jack}
3640 summary_info += {'brlapi support':    brlapi}
3641 summary_info += {'vde support':       vde}
3642 summary_info += {'netmap support':    have_netmap}
3643 summary_info += {'l2tpv3 support':    have_l2tpv3}
3644 summary_info += {'Linux AIO support': libaio}
3645 summary_info += {'Linux io_uring support': linux_io_uring}
3646 summary_info += {'ATTR/XATTR support': libattr}
3647 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
3648 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
3649 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
3650 summary_info += {'libcap-ng support': libcap_ng}
3651 summary_info += {'bpf support':       libbpf}
3652 summary_info += {'spice protocol support': spice_protocol}
3653 if spice_protocol.found()
3654   summary_info += {'  spice server support': spice}
3655 endif
3656 summary_info += {'rbd support':       rbd}
3657 summary_info += {'smartcard support': cacard}
3658 summary_info += {'U2F support':       u2f}
3659 summary_info += {'libusb':            libusb}
3660 summary_info += {'usb net redir':     usbredir}
3661 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
3662 summary_info += {'GBM':               gbm}
3663 summary_info += {'libiscsi support':  libiscsi}
3664 summary_info += {'libnfs support':    libnfs}
3665 if targetos == 'windows'
3666   if have_ga
3667     summary_info += {'QGA VSS support':   have_qga_vss}
3668     summary_info += {'QGA w32 disk info': have_ntddscsi}
3669   endif
3670 endif
3671 summary_info += {'seccomp support':   seccomp}
3672 summary_info += {'GlusterFS support': glusterfs}
3673 summary_info += {'TPM support':       have_tpm}
3674 summary_info += {'libssh support':    libssh}
3675 summary_info += {'lzo support':       lzo}
3676 summary_info += {'snappy support':    snappy}
3677 summary_info += {'bzip2 support':     libbzip2}
3678 summary_info += {'lzfse support':     liblzfse}
3679 summary_info += {'zstd support':      zstd}
3680 summary_info += {'NUMA host support': numa}
3681 summary_info += {'capstone':          capstone_opt == 'internal' ? capstone_opt : capstone}
3682 summary_info += {'libpmem support':   libpmem}
3683 summary_info += {'libdaxctl support': libdaxctl}
3684 summary_info += {'libudev':           libudev}
3685 # Dummy dependency, keep .found()
3686 summary_info += {'FUSE lseek':        fuse_lseek.found()}
3687 summary_info += {'selinux':           selinux}
3688 summary(summary_info, bool_yn: true, section: 'Dependencies')
3689
3690 if not supported_cpus.contains(cpu)
3691   message()
3692   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3693   message()
3694   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3695   message('The QEMU project intends to remove support for this host CPU in')
3696   message('a future release if nobody volunteers to maintain it and to')
3697   message('provide a build host for our continuous integration setup.')
3698   message('configure has succeeded and you can continue to build, but')
3699   message('if you care about QEMU on this platform you should contact')
3700   message('us upstream at qemu-devel@nongnu.org.')
3701 endif
3702
3703 if not supported_oses.contains(targetos)
3704   message()
3705   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3706   message()
3707   message('Host OS ' + targetos + 'support is not currently maintained.')
3708   message('The QEMU project intends to remove support for this host OS in')
3709   message('a future release if nobody volunteers to maintain it and to')
3710   message('provide a build host for our continuous integration setup.')
3711   message('configure has succeeded and you can continue to build, but')
3712   message('if you care about QEMU on this platform you should contact')
3713   message('us upstream at qemu-devel@nongnu.org.')
3714 endif