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: ['slow', 'thorough'], is_default: true)
   7 add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
   8 add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
   9
  10 not_found = dependency('', required: false)
  11 keyval = import('keyval')
  12 ss = import('sourceset')
  13 fs = import('fs')
  14
  15 sh = find_program('sh')
  16 cc = meson.get_compiler('c')
  17 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
  18 enable_modules = 'CONFIG_MODULES' in config_host
  19 enable_static = 'CONFIG_STATIC' in config_host
  20
  21 # Allow both shared and static libraries unless --enable-static
  22 static_kwargs = enable_static ? {'static': true} : {}
  23
  24 # Temporary directory used for files created while
  25 # configure runs. Since it is in the build directory
  26 # we can safely blow away any previous version of it
  27 # (and we need not jump through hoops to try to delete
  28 # it when configure exits.)
  29 tmpdir = meson.current_build_dir() / 'meson-private/temp'
  30
  31 if get_option('qemu_suffix').startswith('/')
  32   error('qemu_suffix cannot start with a /')
  33 endif
  34
  35 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
  36 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
  37 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
  38 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
  39
  40 qemu_desktopdir = get_option('datadir') / 'applications'
  41 qemu_icondir = get_option('datadir') / 'icons'
  42
  43 config_host_data = configuration_data()
  44 genh = []
  45 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, version: '>= 2.1',
 459                      method: 'pkg-config', 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
1596 have_coroutine_pool = get_option('coroutine_pool')
1597 if get_option('debug_stack_usage') and have_coroutine_pool
1598   message('Disabling coroutine pool to measure stack usage')
1599   have_coroutine_pool = false
1600 endif
1601 config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
1602 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
1603 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
1604 config_host_data.set('CONFIG_GPROF', get_option('gprof'))
1605 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
1606 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
1607 config_host_data.set('CONFIG_REPLICATION', get_option('live_block_migration').allowed())
1608
1609 # has_header
1610 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1611 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1612 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1613 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1614 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1615 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1616 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1617 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1618 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1619
1620 # has_function
1621 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1622 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1623 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1624 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1625 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1626 # Note that we need to specify prefix: here to avoid incorrectly
1627 # thinking that Windows has posix_memalign()
1628 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
1629 config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
1630 config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
1631 config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
1632 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1633 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1634 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
1635 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1636 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1637 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1638 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1639 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1640 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1641 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1642 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1643 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1644 if rdma.found()
1645   config_host_data.set('HAVE_IBV_ADVISE_MR',
1646                        cc.has_function('ibv_advise_mr',
1647                                        args: config_host['RDMA_LIBS'].split(),
1648                                        prefix: '#include <infiniband/verbs.h>'))
1649 endif
1650
1651 # has_header_symbol
1652 config_host_data.set('CONFIG_BYTESWAP_H',
1653                      cc.has_header_symbol('byteswap.h', 'bswap_32'))
1654 config_host_data.set('CONFIG_EPOLL_CREATE1',
1655                      cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1656 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1657                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1658                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1659 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1660                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1661 config_host_data.set('CONFIG_FIEMAP',
1662                      cc.has_header('linux/fiemap.h') and
1663                      cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1664 config_host_data.set('CONFIG_GETRANDOM',
1665                      cc.has_function('getrandom') and
1666                      cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1667 config_host_data.set('CONFIG_INOTIFY',
1668                      cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1669 config_host_data.set('CONFIG_INOTIFY1',
1670                      cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1671 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1672                      cc.has_header_symbol('machine/bswap.h', 'bswap32',
1673                                           prefix: '''#include <sys/endian.h>
1674                                                      #include <sys/types.h>'''))
1675 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1676                      cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1677 config_host_data.set('CONFIG_RTNETLINK',
1678                      cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1679 config_host_data.set('CONFIG_SYSMACROS',
1680                      cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1681 config_host_data.set('HAVE_OPTRESET',
1682                      cc.has_header_symbol('getopt.h', 'optreset'))
1683 config_host_data.set('HAVE_IPPROTO_MPTCP',
1684                      cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
1685
1686 # has_member
1687 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1688                      cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1689                                    prefix: '#include <signal.h>'))
1690 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1691                      cc.has_member('struct stat', 'st_atim',
1692                                    prefix: '#include <sys/stat.h>'))
1693
1694 # has_type
1695 config_host_data.set('CONFIG_IOVEC',
1696                      cc.has_type('struct iovec',
1697                                  prefix: '#include <sys/uio.h>'))
1698 config_host_data.set('HAVE_UTMPX',
1699                      cc.has_type('struct utmpx',
1700                                  prefix: '#include <utmpx.h>'))
1701
1702 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1703   #include <sys/eventfd.h>
1704   int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1705 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1706   #include <unistd.h>
1707   int main(void) {
1708   #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1709   return fdatasync(0);
1710   #else
1711   #error Not supported
1712   #endif
1713   }'''))
1714
1715 has_madvise = cc.links(gnu_source_prefix + '''
1716   #include <sys/types.h>
1717   #include <sys/mman.h>
1718   #include <stddef.h>
1719   int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
1720 missing_madvise_proto = false
1721 if has_madvise
1722   # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
1723   # but forget to prototype it. In this case, has_madvise will be true (the
1724   # test program links despite a compile warning). To detect the
1725   # missing-prototype case, we try again with a definitely-bogus prototype.
1726   # This will only compile if the system headers don't provide the prototype;
1727   # otherwise the conflicting prototypes will cause a compiler error.
1728   missing_madvise_proto = cc.links(gnu_source_prefix + '''
1729     #include <sys/types.h>
1730     #include <sys/mman.h>
1731     #include <stddef.h>
1732     extern int madvise(int);
1733     int main(void) { return madvise(0); }''')
1734 endif
1735 config_host_data.set('CONFIG_MADVISE', has_madvise)
1736 config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
1737
1738 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1739   #include <sys/mman.h>
1740   int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1741 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1742   #include <fcntl.h>
1743   #if !defined(AT_EMPTY_PATH)
1744   # error missing definition
1745   #else
1746   int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1747   #endif'''))
1748 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1749   #include <unistd.h>
1750   #include <fcntl.h>
1751
1752   int main(void)
1753   {
1754       int pipefd[2];
1755       return pipe2(pipefd, O_CLOEXEC);
1756   }'''))
1757 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1758   #include <sys/mman.h>
1759   #include <stddef.h>
1760   int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1761
1762 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
1763   #include <pthread.h>
1764
1765   static void *f(void *p) { return NULL; }
1766   int main(void)
1767   {
1768     pthread_t thread;
1769     pthread_create(&thread, 0, f, 0);
1770     pthread_setname_np(thread, "QEMU");
1771     return 0;
1772   }''', dependencies: threads))
1773 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
1774   #include <pthread.h>
1775
1776   static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
1777   int main(void)
1778   {
1779     pthread_t thread;
1780     pthread_create(&thread, 0, f, 0);
1781     return 0;
1782   }''', dependencies: threads))
1783 config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
1784   #include <pthread.h>
1785   #include <time.h>
1786
1787   int main(void)
1788   {
1789     pthread_condattr_t attr
1790     pthread_condattr_init(&attr);
1791     pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
1792     return 0;
1793   }''', dependencies: threads))
1794
1795 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1796   #include <sys/signalfd.h>
1797   #include <stddef.h>
1798   int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
1799 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1800   #include <unistd.h>
1801   #include <fcntl.h>
1802   #include <limits.h>
1803
1804   int main(void)
1805   {
1806     int len, fd = 0;
1807     len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1808     splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1809     return 0;
1810   }'''))
1811
1812 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
1813   #include <sys/mman.h>
1814   int main(int argc, char *argv[]) {
1815     return mlockall(MCL_FUTURE);
1816   }'''))
1817
1818 have_l2tpv3 = false
1819 if get_option('l2tpv3').allowed() and have_system
1820   have_l2tpv3 = cc.has_type('struct mmsghdr',
1821     prefix: gnu_source_prefix + '''
1822       #include <sys/socket.h>
1823       #include <linux/ip.h>''')
1824 endif
1825 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
1826
1827 have_netmap = false
1828 if get_option('netmap').allowed() and have_system
1829   have_netmap = cc.compiles('''
1830     #include <inttypes.h>
1831     #include <net/if.h>
1832     #include <net/netmap.h>
1833     #include <net/netmap_user.h>
1834     #if (NETMAP_API < 11) || (NETMAP_API > 15)
1835     #error
1836     #endif
1837     int main(void) { return 0; }''')
1838   if not have_netmap and get_option('netmap').enabled()
1839     error('Netmap headers not available')
1840   endif
1841 endif
1842 config_host_data.set('CONFIG_NETMAP', have_netmap)
1843
1844 # Work around a system header bug with some kernel/XFS header
1845 # versions where they both try to define 'struct fsxattr':
1846 # xfs headers will not try to redefine structs from linux headers
1847 # if this macro is set.
1848 config_host_data.set('HAVE_FSXATTR', cc.links('''
1849   #include <linux/fs.h>
1850   struct fsxattr foo;
1851   int main(void) {
1852     return 0;
1853   }'''))
1854
1855 # Some versions of Mac OS X incorrectly define SIZE_MAX
1856 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1857     #include <stdint.h>
1858     #include <stdio.h>
1859     int main(int argc, char *argv[]) {
1860         return printf("%zu", SIZE_MAX);
1861     }''', args: ['-Werror']))
1862
1863 atomic_test = '''
1864   #include <stdint.h>
1865   int main(void)
1866   {
1867     @0@ x = 0, y = 0;
1868     y = __atomic_load_n(&x, __ATOMIC_RELAXED);
1869     __atomic_store_n(&x, y, __ATOMIC_RELAXED);
1870     __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
1871     __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
1872     __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
1873     return 0;
1874   }'''
1875
1876 # See if 64-bit atomic operations are supported.
1877 # Note that without __atomic builtins, we can only
1878 # assume atomic loads/stores max at pointer size.
1879 config_host_data.set('CONFIG_ATOMIC64', cc.links(atomic_test.format('uint64_t')))
1880
1881 has_int128 = cc.links('''
1882   __int128_t a;
1883   __uint128_t b;
1884   int main (void) {
1885     a = a + b;
1886     b = a * b;
1887     a = a * a;
1888     return 0;
1889   }''')
1890
1891 config_host_data.set('CONFIG_INT128', has_int128)
1892
1893 if has_int128
1894   # "do we have 128-bit atomics which are handled inline and specifically not
1895   # via libatomic". The reason we can't use libatomic is documented in the
1896   # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
1897   has_atomic128 = cc.links(atomic_test.format('unsigned __int128'))
1898
1899   config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
1900
1901   if not has_atomic128
1902     has_cmpxchg128 = cc.links('''
1903       int main(void)
1904       {
1905         unsigned __int128 x = 0, y = 0;
1906         __sync_val_compare_and_swap_16(&x, y, x);
1907         return 0;
1908       }
1909     ''')
1910
1911     config_host_data.set('CONFIG_CMPXCHG128', has_cmpxchg128)
1912   endif
1913 endif
1914
1915 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
1916   #include <sys/auxv.h>
1917   int main(void) {
1918     return getauxval(AT_HWCAP) == 0;
1919   }'''))
1920
1921 have_cpuid_h = cc.links('''
1922   #include <cpuid.h>
1923   int main(void) {
1924     unsigned a, b, c, d;
1925     unsigned max = __get_cpuid_max(0, 0);
1926
1927     if (max >= 1) {
1928         __cpuid(1, a, b, c, d);
1929     }
1930
1931     if (max >= 7) {
1932         __cpuid_count(7, 0, a, b, c, d);
1933     }
1934
1935     return 0;
1936   }''')
1937 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
1938
1939 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
1940   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
1941   .require(cc.links('''
1942     #pragma GCC push_options
1943     #pragma GCC target("avx2")
1944     #include <cpuid.h>
1945     #include <immintrin.h>
1946     static int bar(void *a) {
1947       __m256i x = *(__m256i *)a;
1948       return _mm256_testz_si256(x, x);
1949     }
1950     int main(int argc, char *argv[]) { return bar(argv[0]); }
1951   '''), error_message: 'AVX2 not available').allowed())
1952
1953 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
1954   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
1955   .require(cc.links('''
1956     #pragma GCC push_options
1957     #pragma GCC target("avx512f")
1958     #include <cpuid.h>
1959     #include <immintrin.h>
1960     static int bar(void *a) {
1961       __m512i x = *(__m512i *)a;
1962       return _mm512_test_epi64_mask(x, x);
1963     }
1964     int main(int argc, char *argv[]) { return bar(argv[0]); }
1965   '''), error_message: 'AVX512F not available').allowed())
1966
1967 if get_option('membarrier').disabled()
1968   have_membarrier = false
1969 elif targetos == 'windows'
1970   have_membarrier = true
1971 elif targetos == 'linux'
1972   have_membarrier = cc.compiles('''
1973     #include <linux/membarrier.h>
1974     #include <sys/syscall.h>
1975     #include <unistd.h>
1976     #include <stdlib.h>
1977     int main(void) {
1978         syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
1979         syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
1980         exit(0);
1981     }''')
1982 endif
1983 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
1984   .require(have_membarrier, error_message: 'membarrier system call not available') \
1985   .allowed())
1986
1987 have_afalg = get_option('crypto_afalg') \
1988   .require(cc.compiles(gnu_source_prefix + '''
1989     #include <errno.h>
1990     #include <sys/types.h>
1991     #include <sys/socket.h>
1992     #include <linux/if_alg.h>
1993     int main(void) {
1994       int sock;
1995       sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
1996       return sock;
1997     }
1998   '''), error_message: 'AF_ALG requested but could not be detected').allowed()
1999 config_host_data.set('CONFIG_AF_ALG', have_afalg)
2000
2001 config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
2002   'linux/vm_sockets.h', 'AF_VSOCK',
2003   prefix: '#include <sys/socket.h>',
2004 ))
2005
2006 have_vss = false
2007 have_vss_sdk = false # old xp/2003 SDK
2008 if targetos == 'windows' and link_language == 'cpp'
2009   have_vss = cxx.compiles('''
2010     #define __MIDL_user_allocate_free_DEFINED__
2011     #include <vss.h>
2012     int main(void) { return VSS_CTX_BACKUP; }''')
2013   have_vss_sdk = cxx.has_header('vscoordint.h')
2014 endif
2015 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2016
2017 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
2018     'HAVE_GDB_BIN']
2019 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
2020 foreach k, v: config_host
2021   if ignored.contains(k)
2022     # do nothing
2023   elif arrays.contains(k)
2024     if v != ''
2025       v = '"' + '", "'.join(v.split()) + '", '
2026     endif
2027     config_host_data.set(k, v)
2028   elif k.startswith('CONFIG_')
2029     config_host_data.set(k, v == 'y' ? 1 : v)
2030   endif
2031 endforeach
2032
2033 ########################
2034 # Target configuration #
2035 ########################
2036
2037 minikconf = find_program('scripts/minikconf.py')
2038 config_all = {}
2039 config_all_devices = {}
2040 config_all_disas = {}
2041 config_devices_mak_list = []
2042 config_devices_h = {}
2043 config_target_h = {}
2044 config_target_mak = {}
2045
2046 disassemblers = {
2047   'alpha' : ['CONFIG_ALPHA_DIS'],
2048   'arm' : ['CONFIG_ARM_DIS'],
2049   'avr' : ['CONFIG_AVR_DIS'],
2050   'cris' : ['CONFIG_CRIS_DIS'],
2051   'hexagon' : ['CONFIG_HEXAGON_DIS'],
2052   'hppa' : ['CONFIG_HPPA_DIS'],
2053   'i386' : ['CONFIG_I386_DIS'],
2054   'x86_64' : ['CONFIG_I386_DIS'],
2055   'm68k' : ['CONFIG_M68K_DIS'],
2056   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2057   'mips' : ['CONFIG_MIPS_DIS'],
2058   'nios2' : ['CONFIG_NIOS2_DIS'],
2059   'or1k' : ['CONFIG_OPENRISC_DIS'],
2060   'ppc' : ['CONFIG_PPC_DIS'],
2061   'riscv' : ['CONFIG_RISCV_DIS'],
2062   'rx' : ['CONFIG_RX_DIS'],
2063   's390' : ['CONFIG_S390_DIS'],
2064   'sh4' : ['CONFIG_SH4_DIS'],
2065   'sparc' : ['CONFIG_SPARC_DIS'],
2066   'xtensa' : ['CONFIG_XTENSA_DIS'],
2067 }
2068 if link_language == 'cpp'
2069   disassemblers += {
2070     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
2071     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
2072     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
2073   }
2074 endif
2075
2076 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2077 host_kconfig = \
2078   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2079   (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2080   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2081   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2082   ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
2083   (x11.found() ? ['CONFIG_X11=y'] : []) + \
2084   ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
2085   ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2086   ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2087   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2088   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2089   ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
2090   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
2091
2092 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2093
2094 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2095 actual_target_dirs = []
2096 fdt_required = []
2097 foreach target : target_dirs
2098   config_target = { 'TARGET_NAME': target.split('-')[0] }
2099   if target.endswith('linux-user')
2100     if targetos != 'linux'
2101       if default_targets
2102         continue
2103       endif
2104       error('Target @0@ is only available on a Linux host'.format(target))
2105     endif
2106     config_target += { 'CONFIG_LINUX_USER': 'y' }
2107   elif target.endswith('bsd-user')
2108     if 'CONFIG_BSD' not in config_host
2109       if default_targets
2110         continue
2111       endif
2112       error('Target @0@ is only available on a BSD host'.format(target))
2113     endif
2114     config_target += { 'CONFIG_BSD_USER': 'y' }
2115   elif target.endswith('softmmu')
2116     config_target += { 'CONFIG_SOFTMMU': 'y' }
2117   endif
2118   if target.endswith('-user')
2119     config_target += {
2120       'CONFIG_USER_ONLY': 'y',
2121       'CONFIG_QEMU_INTERP_PREFIX':
2122         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
2123     }
2124   endif
2125
2126   accel_kconfig = []
2127   foreach sym: accelerators
2128     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2129       config_target += { sym: 'y' }
2130       config_all += { sym: 'y' }
2131       if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
2132         config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
2133       elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
2134         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
2135       endif
2136       if target in modular_tcg
2137         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2138       else
2139         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2140       endif
2141       accel_kconfig += [ sym + '=y' ]
2142     endif
2143   endforeach
2144   if accel_kconfig.length() == 0
2145     if default_targets
2146       continue
2147     endif
2148     error('No accelerator available for target @0@'.format(target))
2149   endif
2150
2151   actual_target_dirs += target
2152   config_target += keyval.load('configs/targets' / target + '.mak')
2153   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2154
2155   if 'TARGET_NEED_FDT' in config_target
2156     fdt_required += target
2157   endif
2158
2159   # Add default keys
2160   if 'TARGET_BASE_ARCH' not in config_target
2161     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2162   endif
2163   if 'TARGET_ABI_DIR' not in config_target
2164     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2165   endif
2166   if 'TARGET_BIG_ENDIAN' not in config_target
2167     config_target += {'TARGET_BIG_ENDIAN': 'n'}
2168   endif
2169
2170   foreach k, v: disassemblers
2171     if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2172       foreach sym: v
2173         config_target += { sym: 'y' }
2174         config_all_disas += { sym: 'y' }
2175       endforeach
2176     endif
2177   endforeach
2178
2179   config_target_data = configuration_data()
2180   foreach k, v: config_target
2181     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2182       # do nothing
2183     elif ignored.contains(k)
2184       # do nothing
2185     elif k == 'TARGET_BASE_ARCH'
2186       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2187       # not used to select files from sourcesets.
2188       config_target_data.set('TARGET_' + v.to_upper(), 1)
2189     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2190       config_target_data.set_quoted(k, v)
2191     elif v == 'y'
2192       config_target_data.set(k, 1)
2193     elif v == 'n'
2194       config_target_data.set(k, 0)
2195     else
2196       config_target_data.set(k, v)
2197     endif
2198   endforeach
2199   config_target_data.set('QEMU_ARCH',
2200                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2201   config_target_h += {target: configure_file(output: target + '-config-target.h',
2202                                                configuration: config_target_data)}
2203
2204   if target.endswith('-softmmu')
2205     config_input = meson.get_external_property(target, 'default')
2206     config_devices_mak = target + '-config-devices.mak'
2207     config_devices_mak = configure_file(
2208       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2209       output: config_devices_mak,
2210       depfile: config_devices_mak + '.d',
2211       capture: true,
2212       command: [minikconf,
2213                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2214                 config_devices_mak, '@DEPFILE@', '@INPUT@',
2215                 host_kconfig, accel_kconfig,
2216                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2217
2218     config_devices_data = configuration_data()
2219     config_devices = keyval.load(config_devices_mak)
2220     foreach k, v: config_devices
2221       config_devices_data.set(k, 1)
2222     endforeach
2223     config_devices_mak_list += config_devices_mak
2224     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2225                                                 configuration: config_devices_data)}
2226     config_target += config_devices
2227     config_all_devices += config_devices
2228   endif
2229   config_target_mak += {target: config_target}
2230 endforeach
2231 target_dirs = actual_target_dirs
2232
2233 # This configuration is used to build files that are shared by
2234 # multiple binaries, and then extracted out of the "common"
2235 # static_library target.
2236 #
2237 # We do not use all_sources()/all_dependencies(), because it would
2238 # build literally all source files, including devices only used by
2239 # targets that are not built for this compilation.  The CONFIG_ALL
2240 # pseudo symbol replaces it.
2241
2242 config_all += config_all_devices
2243 config_all += config_host
2244 config_all += config_all_disas
2245 config_all += {
2246   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
2247   'CONFIG_SOFTMMU': have_system,
2248   'CONFIG_USER_ONLY': have_user,
2249   'CONFIG_ALL': true,
2250 }
2251
2252 target_configs_h = []
2253 foreach target: target_dirs
2254   target_configs_h += config_target_h[target]
2255   target_configs_h += config_devices_h.get(target, [])
2256 endforeach
2257 genh += custom_target('config-poison.h',
2258                       input: [target_configs_h],
2259                       output: 'config-poison.h',
2260                       capture: true,
2261                       command: [find_program('scripts/make-config-poison.sh'),
2262                                 target_configs_h])
2263
2264 ##############
2265 # Submodules #
2266 ##############
2267
2268 capstone = not_found
2269 capstone_opt = get_option('capstone')
2270 if capstone_opt in ['enabled', 'auto', 'system']
2271   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
2272   capstone = dependency('capstone', version: '>=4.0',
2273                         kwargs: static_kwargs, method: 'pkg-config',
2274                         required: capstone_opt == 'system' or
2275                                   capstone_opt == 'enabled' and not have_internal)
2276
2277   # Some versions of capstone have broken pkg-config file
2278   # that reports a wrong -I path, causing the #include to
2279   # fail later. If the system has such a broken version
2280   # do not use it.
2281   if capstone.found() and not cc.compiles('#include <capstone.h>',
2282                                           dependencies: [capstone])
2283     capstone = not_found
2284     if capstone_opt == 'system'
2285       error('system capstone requested, it does not appear to work')
2286     endif
2287   endif
2288
2289   if capstone.found()
2290     capstone_opt = 'system'
2291   elif have_internal
2292     capstone_opt = 'internal'
2293   else
2294     capstone_opt = 'disabled'
2295   endif
2296 endif
2297 if capstone_opt == 'internal'
2298   capstone_data = configuration_data()
2299   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
2300
2301   capstone_files = files(
2302     'capstone/cs.c',
2303     'capstone/MCInst.c',
2304     'capstone/MCInstrDesc.c',
2305     'capstone/MCRegisterInfo.c',
2306     'capstone/SStream.c',
2307     'capstone/utils.c'
2308   )
2309
2310   if 'CONFIG_ARM_DIS' in config_all_disas
2311     capstone_data.set('CAPSTONE_HAS_ARM', '1')
2312     capstone_files += files(
2313       'capstone/arch/ARM/ARMDisassembler.c',
2314       'capstone/arch/ARM/ARMInstPrinter.c',
2315       'capstone/arch/ARM/ARMMapping.c',
2316       'capstone/arch/ARM/ARMModule.c'
2317     )
2318   endif
2319
2320   # FIXME: This config entry currently depends on a c++ compiler.
2321   # Which is needed for building libvixl, but not for capstone.
2322   if 'CONFIG_ARM_A64_DIS' in config_all_disas
2323     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
2324     capstone_files += files(
2325       'capstone/arch/AArch64/AArch64BaseInfo.c',
2326       'capstone/arch/AArch64/AArch64Disassembler.c',
2327       'capstone/arch/AArch64/AArch64InstPrinter.c',
2328       'capstone/arch/AArch64/AArch64Mapping.c',
2329       'capstone/arch/AArch64/AArch64Module.c'
2330     )
2331   endif
2332
2333   if 'CONFIG_PPC_DIS' in config_all_disas
2334     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2335     capstone_files += files(
2336       'capstone/arch/PowerPC/PPCDisassembler.c',
2337       'capstone/arch/PowerPC/PPCInstPrinter.c',
2338       'capstone/arch/PowerPC/PPCMapping.c',
2339       'capstone/arch/PowerPC/PPCModule.c'
2340     )
2341   endif
2342
2343   if 'CONFIG_S390_DIS' in config_all_disas
2344     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2345     capstone_files += files(
2346       'capstone/arch/SystemZ/SystemZDisassembler.c',
2347       'capstone/arch/SystemZ/SystemZInstPrinter.c',
2348       'capstone/arch/SystemZ/SystemZMapping.c',
2349       'capstone/arch/SystemZ/SystemZModule.c',
2350       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2351     )
2352   endif
2353
2354   if 'CONFIG_I386_DIS' in config_all_disas
2355     capstone_data.set('CAPSTONE_HAS_X86', 1)
2356     capstone_files += files(
2357       'capstone/arch/X86/X86Disassembler.c',
2358       'capstone/arch/X86/X86DisassemblerDecoder.c',
2359       'capstone/arch/X86/X86ATTInstPrinter.c',
2360       'capstone/arch/X86/X86IntelInstPrinter.c',
2361       'capstone/arch/X86/X86InstPrinterCommon.c',
2362       'capstone/arch/X86/X86Mapping.c',
2363       'capstone/arch/X86/X86Module.c'
2364     )
2365   endif
2366
2367   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2368
2369   capstone_cargs = [
2370     # FIXME: There does not seem to be a way to completely replace the c_args
2371     # that come from add_project_arguments() -- we can only add to them.
2372     # So: disable all warnings with a big hammer.
2373     '-Wno-error', '-w',
2374
2375     # Include all configuration defines via a header file, which will wind up
2376     # as a dependency on the object file, and thus changes here will result
2377     # in a rebuild.
2378     '-include', 'capstone-defs.h'
2379   ]
2380
2381   libcapstone = static_library('capstone',
2382                                build_by_default: false,
2383                                sources: capstone_files,
2384                                c_args: capstone_cargs,
2385                                include_directories: 'capstone/include')
2386   capstone = declare_dependency(link_with: libcapstone,
2387                                 include_directories: 'capstone/include/capstone')
2388 endif
2389
2390 slirp = not_found
2391 slirp_opt = 'disabled'
2392 if have_system
2393   slirp_opt = get_option('slirp')
2394   if slirp_opt in ['enabled', 'auto', 'system']
2395     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2396     slirp = dependency('slirp', kwargs: static_kwargs,
2397                        method: 'pkg-config',
2398                        required: slirp_opt == 'system' or
2399                                  slirp_opt == 'enabled' and not have_internal)
2400     if slirp.found()
2401       slirp_opt = 'system'
2402     elif have_internal
2403       slirp_opt = 'internal'
2404     else
2405       slirp_opt = 'disabled'
2406     endif
2407   endif
2408   if slirp_opt == 'internal'
2409     slirp_deps = []
2410     if targetos == 'windows'
2411       slirp_deps = cc.find_library('iphlpapi')
2412     elif targetos == 'darwin'
2413       slirp_deps = cc.find_library('resolv')
2414     endif
2415     slirp_conf = configuration_data()
2416     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2417     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2418     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2419     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2420     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2421     slirp_files = [
2422       'slirp/src/arp_table.c',
2423       'slirp/src/bootp.c',
2424       'slirp/src/cksum.c',
2425       'slirp/src/dhcpv6.c',
2426       'slirp/src/dnssearch.c',
2427       'slirp/src/if.c',
2428       'slirp/src/ip6_icmp.c',
2429       'slirp/src/ip6_input.c',
2430       'slirp/src/ip6_output.c',
2431       'slirp/src/ip_icmp.c',
2432       'slirp/src/ip_input.c',
2433       'slirp/src/ip_output.c',
2434       'slirp/src/mbuf.c',
2435       'slirp/src/misc.c',
2436       'slirp/src/ncsi.c',
2437       'slirp/src/ndp_table.c',
2438       'slirp/src/sbuf.c',
2439       'slirp/src/slirp.c',
2440       'slirp/src/socket.c',
2441       'slirp/src/state.c',
2442       'slirp/src/stream.c',
2443       'slirp/src/tcp_input.c',
2444       'slirp/src/tcp_output.c',
2445       'slirp/src/tcp_subr.c',
2446       'slirp/src/tcp_timer.c',
2447       'slirp/src/tftp.c',
2448       'slirp/src/udp.c',
2449       'slirp/src/udp6.c',
2450       'slirp/src/util.c',
2451       'slirp/src/version.c',
2452       'slirp/src/vmstate.c',
2453     ]
2454
2455     configure_file(
2456       input : 'slirp/src/libslirp-version.h.in',
2457       output : 'libslirp-version.h',
2458       configuration: slirp_conf)
2459
2460     slirp_inc = include_directories('slirp', 'slirp/src')
2461     libslirp = static_library('slirp',
2462                               build_by_default: false,
2463                               sources: slirp_files,
2464                               c_args: slirp_cargs,
2465                               include_directories: slirp_inc)
2466     slirp = declare_dependency(link_with: libslirp,
2467                                dependencies: slirp_deps,
2468                                include_directories: slirp_inc)
2469   endif
2470 endif
2471
2472 # For CFI, we need to compile slirp as a static library together with qemu.
2473 # This is because we register slirp functions as callbacks for QEMU Timers.
2474 # When using a system-wide shared libslirp, the type information for the
2475 # callback is missing and the timer call produces a false positive with CFI.
2476 #
2477 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2478 # with control-flow integrity.
2479 if get_option('cfi') and slirp_opt == 'system'
2480   error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2481          + ' Please configure with --enable-slirp=git')
2482 endif
2483
2484 fdt = not_found
2485 if have_system
2486   fdt_opt = get_option('fdt')
2487   if fdt_opt in ['enabled', 'auto', 'system']
2488     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2489     fdt = cc.find_library('fdt', kwargs: static_kwargs,
2490                           required: fdt_opt == 'system' or
2491                                     fdt_opt == 'enabled' and not have_internal)
2492     if fdt.found() and cc.links('''
2493        #include <libfdt.h>
2494        #include <libfdt_env.h>
2495        int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2496          dependencies: fdt)
2497       fdt_opt = 'system'
2498     elif fdt_opt == 'system'
2499        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2500     elif have_internal
2501       fdt_opt = 'internal'
2502     else
2503       fdt_opt = 'disabled'
2504       fdt = not_found
2505     endif
2506   endif
2507   if fdt_opt == 'internal'
2508     fdt_files = files(
2509       'dtc/libfdt/fdt.c',
2510       'dtc/libfdt/fdt_ro.c',
2511       'dtc/libfdt/fdt_wip.c',
2512       'dtc/libfdt/fdt_sw.c',
2513       'dtc/libfdt/fdt_rw.c',
2514       'dtc/libfdt/fdt_strerror.c',
2515       'dtc/libfdt/fdt_empty_tree.c',
2516       'dtc/libfdt/fdt_addresses.c',
2517       'dtc/libfdt/fdt_overlay.c',
2518       'dtc/libfdt/fdt_check.c',
2519     )
2520
2521     fdt_inc = include_directories('dtc/libfdt')
2522     libfdt = static_library('fdt',
2523                             build_by_default: false,
2524                             sources: fdt_files,
2525                             include_directories: fdt_inc)
2526     fdt = declare_dependency(link_with: libfdt,
2527                              include_directories: fdt_inc)
2528   endif
2529 else
2530   fdt_opt = 'disabled'
2531 endif
2532 if not fdt.found() and fdt_required.length() > 0
2533   error('fdt not available but required by targets ' + ', '.join(fdt_required))
2534 endif
2535
2536 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2537 config_host_data.set('CONFIG_FDT', fdt.found())
2538 config_host_data.set('CONFIG_SLIRP', slirp.found())
2539
2540 #####################
2541 # Generated sources #
2542 #####################
2543
2544 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2545
2546 hxtool = find_program('scripts/hxtool')
2547 shaderinclude = find_program('scripts/shaderinclude.pl')
2548 qapi_gen = find_program('scripts/qapi-gen.py')
2549 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2550                      meson.current_source_dir() / 'scripts/qapi/commands.py',
2551                      meson.current_source_dir() / 'scripts/qapi/common.py',
2552                      meson.current_source_dir() / 'scripts/qapi/error.py',
2553                      meson.current_source_dir() / 'scripts/qapi/events.py',
2554                      meson.current_source_dir() / 'scripts/qapi/expr.py',
2555                      meson.current_source_dir() / 'scripts/qapi/gen.py',
2556                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
2557                      meson.current_source_dir() / 'scripts/qapi/parser.py',
2558                      meson.current_source_dir() / 'scripts/qapi/schema.py',
2559                      meson.current_source_dir() / 'scripts/qapi/source.py',
2560                      meson.current_source_dir() / 'scripts/qapi/types.py',
2561                      meson.current_source_dir() / 'scripts/qapi/visit.py',
2562                      meson.current_source_dir() / 'scripts/qapi/common.py',
2563                      meson.current_source_dir() / 'scripts/qapi-gen.py'
2564 ]
2565
2566 tracetool = [
2567   python, files('scripts/tracetool.py'),
2568    '--backend=' + ','.join(get_option('trace_backends'))
2569 ]
2570 tracetool_depends = files(
2571   'scripts/tracetool/backend/log.py',
2572   'scripts/tracetool/backend/__init__.py',
2573   'scripts/tracetool/backend/dtrace.py',
2574   'scripts/tracetool/backend/ftrace.py',
2575   'scripts/tracetool/backend/simple.py',
2576   'scripts/tracetool/backend/syslog.py',
2577   'scripts/tracetool/backend/ust.py',
2578   'scripts/tracetool/format/ust_events_c.py',
2579   'scripts/tracetool/format/ust_events_h.py',
2580   'scripts/tracetool/format/__init__.py',
2581   'scripts/tracetool/format/d.py',
2582   'scripts/tracetool/format/simpletrace_stap.py',
2583   'scripts/tracetool/format/c.py',
2584   'scripts/tracetool/format/h.py',
2585   'scripts/tracetool/format/log_stap.py',
2586   'scripts/tracetool/format/stap.py',
2587   'scripts/tracetool/__init__.py',
2588   'scripts/tracetool/transform.py',
2589   'scripts/tracetool/vcpu.py'
2590 )
2591
2592 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2593                     meson.current_source_dir(),
2594                     config_host['PKGVERSION'], meson.project_version()]
2595 qemu_version = custom_target('qemu-version.h',
2596                              output: 'qemu-version.h',
2597                              command: qemu_version_cmd,
2598                              capture: true,
2599                              build_by_default: true,
2600                              build_always_stale: true)
2601 genh += qemu_version
2602
2603 hxdep = []
2604 hx_headers = [
2605   ['qemu-options.hx', 'qemu-options.def'],
2606   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2607 ]
2608 if have_system
2609   hx_headers += [
2610     ['hmp-commands.hx', 'hmp-commands.h'],
2611     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2612   ]
2613 endif
2614 foreach d : hx_headers
2615   hxdep += custom_target(d[1],
2616                 input: files(d[0]),
2617                 output: d[1],
2618                 capture: true,
2619                 build_by_default: true, # to be removed when added to a target
2620                 command: [hxtool, '-h', '@INPUT0@'])
2621 endforeach
2622 genh += hxdep
2623
2624 ###################
2625 # Collect sources #
2626 ###################
2627
2628 authz_ss = ss.source_set()
2629 blockdev_ss = ss.source_set()
2630 block_ss = ss.source_set()
2631 chardev_ss = ss.source_set()
2632 common_ss = ss.source_set()
2633 crypto_ss = ss.source_set()
2634 hwcore_ss = ss.source_set()
2635 io_ss = ss.source_set()
2636 qmp_ss = ss.source_set()
2637 qom_ss = ss.source_set()
2638 softmmu_ss = ss.source_set()
2639 specific_fuzz_ss = ss.source_set()
2640 specific_ss = ss.source_set()
2641 stub_ss = ss.source_set()
2642 trace_ss = ss.source_set()
2643 user_ss = ss.source_set()
2644 util_ss = ss.source_set()
2645
2646 # accel modules
2647 qtest_module_ss = ss.source_set()
2648 tcg_module_ss = ss.source_set()
2649
2650 modules = {}
2651 target_modules = {}
2652 hw_arch = {}
2653 target_arch = {}
2654 target_softmmu_arch = {}
2655 target_user_arch = {}
2656
2657 ###############
2658 # Trace files #
2659 ###############
2660
2661 # TODO: add each directory to the subdirs from its own meson.build, once
2662 # we have those
2663 trace_events_subdirs = [
2664   'crypto',
2665   'qapi',
2666   'qom',
2667   'monitor',
2668   'util',
2669 ]
2670 if have_linux_user
2671   trace_events_subdirs += [ 'linux-user' ]
2672 endif
2673 if have_bsd_user
2674   trace_events_subdirs += [ 'bsd-user' ]
2675 endif
2676 if have_block
2677   trace_events_subdirs += [
2678     'authz',
2679     'block',
2680     'io',
2681     'nbd',
2682     'scsi',
2683   ]
2684 endif
2685 if have_system
2686   trace_events_subdirs += [
2687     'accel/kvm',
2688     'audio',
2689     'backends',
2690     'backends/tpm',
2691     'chardev',
2692     'ebpf',
2693     'hw/9pfs',
2694     'hw/acpi',
2695     'hw/adc',
2696     'hw/alpha',
2697     'hw/arm',
2698     'hw/audio',
2699     'hw/block',
2700     'hw/block/dataplane',
2701     'hw/char',
2702     'hw/display',
2703     'hw/dma',
2704     'hw/hppa',
2705     'hw/hyperv',
2706     'hw/i2c',
2707     'hw/i386',
2708     'hw/i386/xen',
2709     'hw/ide',
2710     'hw/input',
2711     'hw/intc',
2712     'hw/isa',
2713     'hw/mem',
2714     'hw/mips',
2715     'hw/misc',
2716     'hw/misc/macio',
2717     'hw/net',
2718     'hw/net/can',
2719     'hw/nubus',
2720     'hw/nvme',
2721     'hw/nvram',
2722     'hw/pci',
2723     'hw/pci-host',
2724     'hw/ppc',
2725     'hw/rdma',
2726     'hw/rdma/vmw',
2727     'hw/rtc',
2728     'hw/s390x',
2729     'hw/scsi',
2730     'hw/sd',
2731     'hw/sh4',
2732     'hw/sparc',
2733     'hw/sparc64',
2734     'hw/ssi',
2735     'hw/timer',
2736     'hw/tpm',
2737     'hw/usb',
2738     'hw/vfio',
2739     'hw/virtio',
2740     'hw/watchdog',
2741     'hw/xen',
2742     'hw/gpio',
2743     'migration',
2744     'net',
2745     'softmmu',
2746     'ui',
2747     'hw/remote',
2748   ]
2749 endif
2750 if have_system or have_user
2751   trace_events_subdirs += [
2752     'accel/tcg',
2753     'hw/core',
2754     'target/arm',
2755     'target/arm/hvf',
2756     'target/hppa',
2757     'target/i386',
2758     'target/i386/kvm',
2759     'target/mips/tcg',
2760     'target/nios2',
2761     'target/ppc',
2762     'target/riscv',
2763     'target/s390x',
2764     'target/s390x/kvm',
2765     'target/sparc',
2766   ]
2767 endif
2768
2769 vhost_user = not_found
2770 if targetos == 'linux' and 'CONFIG_VHOST_USER' in config_host
2771   libvhost_user = subproject('libvhost-user')
2772   vhost_user = libvhost_user.get_variable('vhost_user_dep')
2773 endif
2774
2775 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
2776 # that is filled in by qapi/.
2777 subdir('qapi')
2778 subdir('qobject')
2779 subdir('stubs')
2780 subdir('trace')
2781 subdir('util')
2782 subdir('qom')
2783 subdir('authz')
2784 subdir('crypto')
2785 subdir('ui')
2786
2787
2788 if enable_modules
2789   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2790   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2791 endif
2792
2793 stub_ss = stub_ss.apply(config_all, strict: false)
2794
2795 util_ss.add_all(trace_ss)
2796 util_ss = util_ss.apply(config_all, strict: false)
2797 libqemuutil = static_library('qemuutil',
2798                              sources: util_ss.sources() + stub_ss.sources() + genh,
2799                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2800 qemuutil = declare_dependency(link_with: libqemuutil,
2801                               sources: genh + version_res)
2802
2803 if have_system or have_user
2804   decodetree = generator(find_program('scripts/decodetree.py'),
2805                          output: 'decode-@BASENAME@.c.inc',
2806                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2807   subdir('libdecnumber')
2808   subdir('target')
2809 endif
2810
2811 subdir('audio')
2812 subdir('io')
2813 subdir('chardev')
2814 subdir('fsdev')
2815 subdir('dump')
2816
2817 if have_block
2818   block_ss.add(files(
2819     'block.c',
2820     'blockjob.c',
2821     'job.c',
2822     'qemu-io-cmds.c',
2823   ))
2824   if config_host_data.get('CONFIG_REPLICATION')
2825     block_ss.add(files('replication.c'))
2826   endif
2827
2828   subdir('nbd')
2829   subdir('scsi')
2830   subdir('block')
2831
2832   blockdev_ss.add(files(
2833     'blockdev.c',
2834     'blockdev-nbd.c',
2835     'iothread.c',
2836     'job-qmp.c',
2837   ), gnutls)
2838
2839   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2840   # os-win32.c does not
2841   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2842   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2843 endif
2844
2845 common_ss.add(files('cpus-common.c'))
2846
2847 subdir('softmmu')
2848
2849 common_ss.add(capstone)
2850 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2851
2852 # Work around a gcc bug/misfeature wherein constant propagation looks
2853 # through an alias:
2854 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2855 # to guess that a const variable is always zero.  Without lto, this is
2856 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
2857 # without lto, not even the alias is required -- we simply use different
2858 # declarations in different compilation units.
2859 pagevary = files('page-vary-common.c')
2860 if get_option('b_lto')
2861   pagevary_flags = ['-fno-lto']
2862   if get_option('cfi')
2863     pagevary_flags += '-fno-sanitize=cfi-icall'
2864   endif
2865   pagevary = static_library('page-vary-common', sources: pagevary + genh,
2866                             c_args: pagevary_flags)
2867   pagevary = declare_dependency(link_with: pagevary)
2868 endif
2869 common_ss.add(pagevary)
2870 specific_ss.add(files('page-vary.c'))
2871
2872 subdir('backends')
2873 subdir('disas')
2874 subdir('migration')
2875 subdir('monitor')
2876 subdir('net')
2877 subdir('replay')
2878 subdir('semihosting')
2879 subdir('hw')
2880 subdir('tcg')
2881 subdir('fpu')
2882 subdir('accel')
2883 subdir('plugins')
2884 subdir('ebpf')
2885
2886 common_user_inc = []
2887
2888 subdir('common-user')
2889 subdir('bsd-user')
2890 subdir('linux-user')
2891
2892 # needed for fuzzing binaries
2893 subdir('tests/qtest/libqos')
2894 subdir('tests/qtest/fuzz')
2895
2896 # accel modules
2897 tcg_real_module_ss = ss.source_set()
2898 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2899 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2900 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2901                                 'tcg': tcg_real_module_ss }}
2902
2903 ########################
2904 # Library dependencies #
2905 ########################
2906
2907 modinfo_collect = find_program('scripts/modinfo-collect.py')
2908 modinfo_generate = find_program('scripts/modinfo-generate.py')
2909 modinfo_files = []
2910
2911 block_mods = []
2912 softmmu_mods = []
2913 foreach d, list : modules
2914   foreach m, module_ss : list
2915     if enable_modules and targetos != 'windows'
2916       module_ss = module_ss.apply(config_all, strict: false)
2917       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2918                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2919       if d == 'block'
2920         block_mods += sl
2921       else
2922         softmmu_mods += sl
2923       endif
2924       if module_ss.sources() != []
2925         # FIXME: Should use sl.extract_all_objects(recursive: true) as
2926         # input. Sources can be used multiple times but objects are
2927         # unique when it comes to lookup in compile_commands.json.
2928         # Depnds on a mesion version with
2929         # https://github.com/mesonbuild/meson/pull/8900
2930         modinfo_files += custom_target(d + '-' + m + '.modinfo',
2931                                        output: d + '-' + m + '.modinfo',
2932                                        input: module_ss.sources() + genh,
2933                                        capture: true,
2934                                        command: [modinfo_collect, module_ss.sources()])
2935       endif
2936     else
2937       if d == 'block'
2938         block_ss.add_all(module_ss)
2939       else
2940         softmmu_ss.add_all(module_ss)
2941       endif
2942     endif
2943   endforeach
2944 endforeach
2945
2946 foreach d, list : target_modules
2947   foreach m, module_ss : list
2948     if enable_modules and targetos != 'windows'
2949       foreach target : target_dirs
2950         if target.endswith('-softmmu')
2951           config_target = config_target_mak[target]
2952           config_target += config_host
2953           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2954           c_args = ['-DNEED_CPU_H',
2955                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2956                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2957           target_module_ss = module_ss.apply(config_target, strict: false)
2958           if target_module_ss.sources() != []
2959             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2960             sl = static_library(module_name,
2961                                 [genh, target_module_ss.sources()],
2962                                 dependencies: [modulecommon, target_module_ss.dependencies()],
2963                                 include_directories: target_inc,
2964                                 c_args: c_args,
2965                                 pic: true)
2966             softmmu_mods += sl
2967             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2968             modinfo_files += custom_target(module_name + '.modinfo',
2969                                            output: module_name + '.modinfo',
2970                                            input: target_module_ss.sources() + genh,
2971                                            capture: true,
2972                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2973           endif
2974         endif
2975       endforeach
2976     else
2977       specific_ss.add_all(module_ss)
2978     endif
2979   endforeach
2980 endforeach
2981
2982 if enable_modules
2983   modinfo_src = custom_target('modinfo.c',
2984                               output: 'modinfo.c',
2985                               input: modinfo_files,
2986                               command: [modinfo_generate, '@INPUT@'],
2987                               capture: true)
2988   modinfo_lib = static_library('modinfo', modinfo_src)
2989   modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2990   softmmu_ss.add(modinfo_dep)
2991 endif
2992
2993 nm = find_program('nm')
2994 undefsym = find_program('scripts/undefsym.py')
2995 block_syms = custom_target('block.syms', output: 'block.syms',
2996                              input: [libqemuutil, block_mods],
2997                              capture: true,
2998                              command: [undefsym, nm, '@INPUT@'])
2999 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3000                              input: [libqemuutil, softmmu_mods],
3001                              capture: true,
3002                              command: [undefsym, nm, '@INPUT@'])
3003
3004 qom_ss = qom_ss.apply(config_host, strict: false)
3005 libqom = static_library('qom', qom_ss.sources() + genh,
3006                         dependencies: [qom_ss.dependencies()],
3007                         name_suffix: 'fa')
3008
3009 qom = declare_dependency(link_whole: libqom)
3010
3011 authz_ss = authz_ss.apply(config_host, strict: false)
3012 libauthz = static_library('authz', authz_ss.sources() + genh,
3013                           dependencies: [authz_ss.dependencies()],
3014                           name_suffix: 'fa',
3015                           build_by_default: false)
3016
3017 authz = declare_dependency(link_whole: libauthz,
3018                            dependencies: qom)
3019
3020 crypto_ss = crypto_ss.apply(config_host, strict: false)
3021 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3022                            dependencies: [crypto_ss.dependencies()],
3023                            name_suffix: 'fa',
3024                            build_by_default: false)
3025
3026 crypto = declare_dependency(link_whole: libcrypto,
3027                             dependencies: [authz, qom])
3028
3029 io_ss = io_ss.apply(config_host, strict: false)
3030 libio = static_library('io', io_ss.sources() + genh,
3031                        dependencies: [io_ss.dependencies()],
3032                        link_with: libqemuutil,
3033                        name_suffix: 'fa',
3034                        build_by_default: false)
3035
3036 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3037
3038 libmigration = static_library('migration', sources: migration_files + genh,
3039                               name_suffix: 'fa',
3040                               build_by_default: false)
3041 migration = declare_dependency(link_with: libmigration,
3042                                dependencies: [zlib, qom, io])
3043 softmmu_ss.add(migration)
3044
3045 block_ss = block_ss.apply(config_host, strict: false)
3046 libblock = static_library('block', block_ss.sources() + genh,
3047                           dependencies: block_ss.dependencies(),
3048                           link_depends: block_syms,
3049                           name_suffix: 'fa',
3050                           build_by_default: false)
3051
3052 block = declare_dependency(link_whole: [libblock],
3053                            link_args: '@block.syms',
3054                            dependencies: [crypto, io])
3055
3056 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3057 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3058                              dependencies: blockdev_ss.dependencies(),
3059                              name_suffix: 'fa',
3060                              build_by_default: false)
3061
3062 blockdev = declare_dependency(link_whole: [libblockdev],
3063                               dependencies: [block])
3064
3065 qmp_ss = qmp_ss.apply(config_host, strict: false)
3066 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3067                         dependencies: qmp_ss.dependencies(),
3068                         name_suffix: 'fa',
3069                         build_by_default: false)
3070
3071 qmp = declare_dependency(link_whole: [libqmp])
3072
3073 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3074                             name_suffix: 'fa',
3075                             dependencies: chardev_ss.dependencies(),
3076                             build_by_default: false)
3077
3078 chardev = declare_dependency(link_whole: libchardev)
3079
3080 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3081 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3082                            name_suffix: 'fa',
3083                            build_by_default: false)
3084 hwcore = declare_dependency(link_whole: libhwcore)
3085 common_ss.add(hwcore)
3086
3087 ###########
3088 # Targets #
3089 ###########
3090
3091 emulator_modules = []
3092 foreach m : block_mods + softmmu_mods
3093   emulator_modules += shared_module(m.name(),
3094                 build_by_default: true,
3095                 name_prefix: '',
3096                 link_whole: m,
3097                 install: true,
3098                 install_dir: qemu_moddir)
3099 endforeach
3100
3101 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3102 common_ss.add(qom, qemuutil)
3103
3104 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3105 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3106
3107 common_all = common_ss.apply(config_all, strict: false)
3108 common_all = static_library('common',
3109                             build_by_default: false,
3110                             sources: common_all.sources() + genh,
3111                             include_directories: common_user_inc,
3112                             implicit_include_directories: false,
3113                             dependencies: common_all.dependencies(),
3114                             name_suffix: 'fa')
3115
3116 feature_to_c = find_program('scripts/feature_to_c.sh')
3117
3118 if targetos == 'darwin'
3119   entitlement = find_program('scripts/entitlement.sh')
3120 endif
3121
3122 emulators = {}
3123 foreach target : target_dirs
3124   config_target = config_target_mak[target]
3125   target_name = config_target['TARGET_NAME']
3126   target_base_arch = config_target['TARGET_BASE_ARCH']
3127   arch_srcs = [config_target_h[target]]
3128   arch_deps = []
3129   c_args = ['-DNEED_CPU_H',
3130             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3131             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3132   link_args = emulator_link_args
3133
3134   config_target += config_host
3135   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3136   if targetos == 'linux'
3137     target_inc += include_directories('linux-headers', is_system: true)
3138   endif
3139   if target.endswith('-softmmu')
3140     qemu_target_name = 'qemu-system-' + target_name
3141     target_type='system'
3142     t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3143     arch_srcs += t.sources()
3144     arch_deps += t.dependencies()
3145
3146     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3147     hw = hw_arch[hw_dir].apply(config_target, strict: false)
3148     arch_srcs += hw.sources()
3149     arch_deps += hw.dependencies()
3150
3151     arch_srcs += config_devices_h[target]
3152     link_args += ['@block.syms', '@qemu.syms']
3153   else
3154     abi = config_target['TARGET_ABI_DIR']
3155     target_type='user'
3156     target_inc += common_user_inc
3157     qemu_target_name = 'qemu-' + target_name
3158     if target_base_arch in target_user_arch
3159       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3160       arch_srcs += t.sources()
3161       arch_deps += t.dependencies()
3162     endif
3163     if 'CONFIG_LINUX_USER' in config_target
3164       base_dir = 'linux-user'
3165     endif
3166     if 'CONFIG_BSD_USER' in config_target
3167       base_dir = 'bsd-user'
3168       target_inc += include_directories('bsd-user/' / targetos)
3169       target_inc += include_directories('bsd-user/host/' / host_arch)
3170       dir = base_dir / abi
3171       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3172     endif
3173     target_inc += include_directories(
3174       base_dir,
3175       base_dir / abi,
3176     )
3177     if 'CONFIG_LINUX_USER' in config_target
3178       dir = base_dir / abi
3179       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3180       if config_target.has_key('TARGET_SYSTBL_ABI')
3181         arch_srcs += \
3182           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3183                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3184       endif
3185     endif
3186   endif
3187
3188   if 'TARGET_XML_FILES' in config_target
3189     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3190                                 output: target + '-gdbstub-xml.c',
3191                                 input: files(config_target['TARGET_XML_FILES'].split()),
3192                                 command: [feature_to_c, '@INPUT@'],
3193                                 capture: true)
3194     arch_srcs += gdbstub_xml
3195   endif
3196
3197   t = target_arch[target_base_arch].apply(config_target, strict: false)
3198   arch_srcs += t.sources()
3199   arch_deps += t.dependencies()
3200
3201   target_common = common_ss.apply(config_target, strict: false)
3202   objects = common_all.extract_objects(target_common.sources())
3203   deps = target_common.dependencies()
3204
3205   target_specific = specific_ss.apply(config_target, strict: false)
3206   arch_srcs += target_specific.sources()
3207   arch_deps += target_specific.dependencies()
3208
3209   lib = static_library('qemu-' + target,
3210                  sources: arch_srcs + genh,
3211                  dependencies: arch_deps,
3212                  objects: objects,
3213                  include_directories: target_inc,
3214                  c_args: c_args,
3215                  build_by_default: false,
3216                  name_suffix: 'fa')
3217
3218   if target.endswith('-softmmu')
3219     execs = [{
3220       'name': 'qemu-system-' + target_name,
3221       'win_subsystem': 'console',
3222       'sources': files('softmmu/main.c'),
3223       'dependencies': []
3224     }]
3225     if targetos == 'windows' and (sdl.found() or gtk.found())
3226       execs += [{
3227         'name': 'qemu-system-' + target_name + 'w',
3228         'win_subsystem': 'windows',
3229         'sources': files('softmmu/main.c'),
3230         'dependencies': []
3231       }]
3232     endif
3233     if get_option('fuzzing')
3234       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3235       execs += [{
3236         'name': 'qemu-fuzz-' + target_name,
3237         'win_subsystem': 'console',
3238         'sources': specific_fuzz.sources(),
3239         'dependencies': specific_fuzz.dependencies(),
3240       }]
3241     endif
3242   else
3243     execs = [{
3244       'name': 'qemu-' + target_name,
3245       'win_subsystem': 'console',
3246       'sources': [],
3247       'dependencies': []
3248     }]
3249   endif
3250   foreach exe: execs
3251     exe_name = exe['name']
3252     if targetos == 'darwin'
3253       exe_name += '-unsigned'
3254     endif
3255
3256     emulator = executable(exe_name, exe['sources'],
3257                install: true,
3258                c_args: c_args,
3259                dependencies: arch_deps + deps + exe['dependencies'],
3260                objects: lib.extract_all_objects(recursive: true),
3261                link_language: link_language,
3262                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3263                link_args: link_args,
3264                win_subsystem: exe['win_subsystem'])
3265
3266     if targetos == 'darwin'
3267       icon = 'pc-bios/qemu.rsrc'
3268       build_input = [emulator, files(icon)]
3269       install_input = [
3270         get_option('bindir') / exe_name,
3271         meson.current_source_dir() / icon
3272       ]
3273       if 'CONFIG_HVF' in config_target
3274         entitlements = 'accel/hvf/entitlements.plist'
3275         build_input += files(entitlements)
3276         install_input += meson.current_source_dir() / entitlements
3277       endif
3278
3279       emulators += {exe['name'] : custom_target(exe['name'],
3280                    input: build_input,
3281                    output: exe['name'],
3282                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3283       }
3284
3285       meson.add_install_script(entitlement, '--install',
3286                                get_option('bindir') / exe['name'],
3287                                install_input)
3288     else
3289       emulators += {exe['name']: emulator}
3290     endif
3291
3292     if stap.found()
3293       foreach stp: [
3294         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3295         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3296         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3297         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3298       ]
3299         custom_target(exe['name'] + stp['ext'],
3300                       input: trace_events_all,
3301                       output: exe['name'] + stp['ext'],
3302                       install: stp['install'],
3303                       install_dir: get_option('datadir') / 'systemtap/tapset',
3304                       command: [
3305                         tracetool, '--group=all', '--format=' + stp['fmt'],
3306                         '--binary=' + stp['bin'],
3307                         '--target-name=' + target_name,
3308                         '--target-type=' + target_type,
3309                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3310                         '@INPUT@', '@OUTPUT@'
3311                       ],
3312                       depend_files: tracetool_depends)
3313       endforeach
3314     endif
3315   endforeach
3316 endforeach
3317
3318 # Other build targets
3319
3320 if 'CONFIG_PLUGIN' in config_host
3321   install_headers('include/qemu/qemu-plugin.h')
3322 endif
3323
3324 subdir('qga')
3325
3326 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3327 # when we don't build tools or system
3328 if xkbcommon.found()
3329   # used for the update-keymaps target, so include rules even if !have_tools
3330   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3331                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3332 endif
3333
3334 if have_tools
3335   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3336              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3337   qemu_io = executable('qemu-io', files('qemu-io.c'),
3338              dependencies: [block, qemuutil], install: true)
3339   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3340                dependencies: [blockdev, qemuutil, gnutls, selinux],
3341                install: true)
3342
3343   subdir('storage-daemon')
3344   subdir('contrib/rdmacm-mux')
3345   subdir('contrib/elf2dmp')
3346
3347   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3348              dependencies: qemuutil,
3349              install: true)
3350
3351   if 'CONFIG_VHOST_USER' in config_host
3352     subdir('contrib/vhost-user-blk')
3353     subdir('contrib/vhost-user-gpu')
3354     subdir('contrib/vhost-user-input')
3355     subdir('contrib/vhost-user-scsi')
3356   endif
3357
3358   if targetos == 'linux'
3359     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3360                dependencies: [qemuutil, libcap_ng],
3361                install: true,
3362                install_dir: get_option('libexecdir'))
3363
3364     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3365                dependencies: [authz, crypto, io, qom, qemuutil,
3366                               libcap_ng, mpathpersist],
3367                install: true)
3368   endif
3369
3370   if have_ivshmem
3371     subdir('contrib/ivshmem-client')
3372     subdir('contrib/ivshmem-server')
3373   endif
3374 endif
3375
3376 subdir('scripts')
3377 subdir('tools')
3378 subdir('pc-bios')
3379 subdir('docs')
3380 subdir('tests')
3381 if gtk.found()
3382   subdir('po')
3383 endif
3384
3385 if host_machine.system() == 'windows'
3386   nsis_cmd = [
3387     find_program('scripts/nsis.py'),
3388     '@OUTPUT@',
3389     get_option('prefix'),
3390     meson.current_source_dir(),
3391     host_machine.cpu(),
3392     '--',
3393     '-DDISPLAYVERSION=' + meson.project_version(),
3394   ]
3395   if build_docs
3396     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3397   endif
3398   if gtk.found()
3399     nsis_cmd += '-DCONFIG_GTK=y'
3400   endif
3401
3402   nsis = custom_target('nsis',
3403                        output: 'qemu-setup-' + meson.project_version() + '.exe',
3404                        input: files('qemu.nsi'),
3405                        build_always_stale: true,
3406                        command: nsis_cmd + ['@INPUT@'])
3407   alias_target('installer', nsis)
3408 endif
3409
3410 #########################
3411 # Configuration summary #
3412 #########################
3413
3414 # Directories
3415 summary_info = {}
3416 summary_info += {'Install prefix':    get_option('prefix')}
3417 summary_info += {'BIOS directory':    qemu_datadir}
3418 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
3419 summary_info += {'binary directory':  get_option('bindir')}
3420 summary_info += {'library directory': get_option('libdir')}
3421 summary_info += {'module directory':  qemu_moddir}
3422 summary_info += {'libexec directory': get_option('libexecdir')}
3423 summary_info += {'include directory': get_option('includedir')}
3424 summary_info += {'config directory':  get_option('sysconfdir')}
3425 if targetos != 'windows'
3426   summary_info += {'local state directory': get_option('localstatedir')}
3427   summary_info += {'Manual directory':      get_option('mandir')}
3428 else
3429   summary_info += {'local state directory': 'queried at runtime'}
3430 endif
3431 summary_info += {'Doc directory':     get_option('docdir')}
3432 summary_info += {'Build directory':   meson.current_build_dir()}
3433 summary_info += {'Source path':       meson.current_source_dir()}
3434 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
3435 summary(summary_info, bool_yn: true, section: 'Directories')
3436
3437 # Host binaries
3438 summary_info = {}
3439 summary_info += {'git':               config_host['GIT']}
3440 summary_info += {'make':              config_host['MAKE']}
3441 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3442 summary_info += {'sphinx-build':      sphinx_build}
3443 if config_host.has_key('HAVE_GDB_BIN')
3444   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
3445 endif
3446 if get_option('iasl') != ''
3447   summary_info += {'iasl':            get_option('iasl')}
3448 else
3449   summary_info += {'iasl':            false}
3450 endif
3451 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
3452 if targetos == 'windows' and have_ga
3453   summary_info += {'wixl':            wixl}
3454 endif
3455 if slirp_opt != 'disabled' and have_system
3456   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
3457 endif
3458 summary(summary_info, bool_yn: true, section: 'Host binaries')
3459
3460 # Configurable features
3461 summary_info = {}
3462 summary_info += {'Documentation':     build_docs}
3463 summary_info += {'system-mode emulation': have_system}
3464 summary_info += {'user-mode emulation': have_user}
3465 summary_info += {'block layer':       have_block}
3466 summary_info += {'Install blobs':     get_option('install_blobs')}
3467 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
3468 if config_host.has_key('CONFIG_MODULES')
3469   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3470 endif
3471 summary_info += {'fuzzing support':   get_option('fuzzing')}
3472 if have_system
3473   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
3474 endif
3475 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
3476 if 'simple' in get_option('trace_backends')
3477   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3478 endif
3479 summary_info += {'D-Bus display':     dbus_display}
3480 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
3481 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3482 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3483 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3484 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3485 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3486 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3487 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3488 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3489 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3490 summary_info += {'build guest agent': have_ga}
3491 summary(summary_info, bool_yn: true, section: 'Configurable features')
3492
3493 # Compilation information
3494 summary_info = {}
3495 summary_info += {'host CPU':          cpu}
3496 summary_info += {'host endianness':   build_machine.endian()}
3497 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
3498 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3499 if link_language == 'cpp'
3500   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
3501 else
3502   summary_info += {'C++ compiler':      false}
3503 endif
3504 if targetos == 'darwin'
3505   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3506 endif
3507 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
3508                                                + ['-O' + get_option('optimization')]
3509                                                + (get_option('debug') ? ['-g'] : []))}
3510 if link_language == 'cpp'
3511   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
3512                                                + ['-O' + get_option('optimization')]
3513                                                + (get_option('debug') ? ['-g'] : []))}
3514 endif
3515 if targetos == 'darwin'
3516   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args')
3517                                                + ['-O' + get_option('optimization')]
3518                                                + (get_option('debug') ? ['-g'] : []))}
3519 endif
3520 link_args = get_option(link_language + '_link_args')
3521 if link_args.length() > 0
3522   summary_info += {'LDFLAGS':         ' '.join(link_args)}
3523 endif
3524 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
3525 summary_info += {'QEMU_CXXFLAGS':     config_host['QEMU_CXXFLAGS']}
3526 summary_info += {'QEMU_OBJCFLAGS':    config_host['QEMU_OBJCFLAGS']}
3527 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
3528 summary_info += {'profiler':          get_option('profiler')}
3529 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3530 summary_info += {'PIE':               get_option('b_pie')}
3531 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
3532 summary_info += {'malloc trim support': has_malloc_trim}
3533 summary_info += {'membarrier':        have_membarrier}
3534 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3535 summary_info += {'mutex debugging':   get_option('debug_mutex')}
3536 summary_info += {'memory allocator':  get_option('malloc')}
3537 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3538 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3539 summary_info += {'gprof enabled':     get_option('gprof')}
3540 summary_info += {'gcov':              get_option('b_coverage')}
3541 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
3542 summary_info += {'CFI support':       get_option('cfi')}
3543 if get_option('cfi')
3544   summary_info += {'CFI debug support': get_option('cfi_debug')}
3545 endif
3546 summary_info += {'strip binaries':    get_option('strip')}
3547 summary_info += {'sparse':            sparse}
3548 summary_info += {'mingw32 support':   targetos == 'windows'}
3549
3550 # snarf the cross-compilation information for tests
3551 foreach target: target_dirs
3552   tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3553   if fs.exists(tcg_mak)
3554     config_cross_tcg = keyval.load(tcg_mak)
3555     target = config_cross_tcg['TARGET_NAME']
3556     compiler = ''
3557     if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3558       summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3559                                           ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3560     elif 'CROSS_CC_GUEST' in config_cross_tcg
3561       summary_info += {target + ' tests'
3562                                 : config_cross_tcg['CROSS_CC_GUEST'] }
3563     endif
3564    endif
3565 endforeach
3566
3567 summary(summary_info, bool_yn: true, section: 'Compilation')
3568
3569 # Targets and accelerators
3570 summary_info = {}
3571 if have_system
3572   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
3573   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
3574   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
3575   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
3576   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
3577   summary_info += {'Xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
3578   if config_host.has_key('CONFIG_XEN_BACKEND')
3579     summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3580   endif
3581 endif
3582 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
3583 if config_all.has_key('CONFIG_TCG')
3584   if get_option('tcg_interpreter')
3585     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
3586   else
3587     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
3588   endif
3589   summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3590   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3591 endif
3592 summary_info += {'target list':       ' '.join(target_dirs)}
3593 if have_system
3594   summary_info += {'default devices':   get_option('default_devices')}
3595   summary_info += {'out of process emulation': multiprocess_allowed}
3596 endif
3597 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3598
3599 # Block layer
3600 summary_info = {}
3601 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3602 summary_info += {'coroutine pool':    have_coroutine_pool}
3603 if have_block
3604   summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3605   summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3606   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3607   summary_info += {'VirtFS support':    have_virtfs}
3608   summary_info += {'build virtiofs daemon': have_virtiofsd}
3609   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3610   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3611   summary_info += {'bochs support':     get_option('bochs').allowed()}
3612   summary_info += {'cloop support':     get_option('cloop').allowed()}
3613   summary_info += {'dmg support':       get_option('dmg').allowed()}
3614   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
3615   summary_info += {'vdi support':       get_option('vdi').allowed()}
3616   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
3617   summary_info += {'qed support':       get_option('qed').allowed()}
3618   summary_info += {'parallels support': get_option('parallels').allowed()}
3619   summary_info += {'FUSE exports':      fuse}
3620 endif
3621 summary(summary_info, bool_yn: true, section: 'Block layer support')
3622
3623 # Crypto
3624 summary_info = {}
3625 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
3626 summary_info += {'GNUTLS support':    gnutls}
3627 if gnutls.found()
3628   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
3629 endif
3630 summary_info += {'libgcrypt':         gcrypt}
3631 summary_info += {'nettle':            nettle}
3632 if nettle.found()
3633    summary_info += {'  XTS':             xts != 'private'}
3634 endif
3635 summary_info += {'AF_ALG support':    have_afalg}
3636 summary_info += {'rng-none':          get_option('rng_none')}
3637 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
3638 summary(summary_info, bool_yn: true, section: 'Crypto')
3639
3640 # Libraries
3641 summary_info = {}
3642 if targetos == 'darwin'
3643   summary_info += {'Cocoa support':   cocoa}
3644 endif
3645 summary_info += {'SDL support':       sdl}
3646 summary_info += {'SDL image support': sdl_image}
3647 summary_info += {'GTK support':       gtk}
3648 summary_info += {'pixman':            pixman}
3649 summary_info += {'VTE support':       vte}
3650 summary_info += {'slirp support':     slirp_opt == 'internal' ? slirp_opt : slirp}
3651 summary_info += {'libtasn1':          tasn1}
3652 summary_info += {'PAM':               pam}
3653 summary_info += {'iconv support':     iconv}
3654 summary_info += {'curses support':    curses}
3655 summary_info += {'virgl support':     virgl}
3656 summary_info += {'curl support':      curl}
3657 summary_info += {'Multipath support': mpathpersist}
3658 summary_info += {'VNC support':       vnc}
3659 if vnc.found()
3660   summary_info += {'VNC SASL support':  sasl}
3661   summary_info += {'VNC JPEG support':  jpeg}
3662   summary_info += {'VNC PNG support':   png}
3663 endif
3664 if targetos not in ['darwin', 'haiku', 'windows']
3665   summary_info += {'OSS support':     oss}
3666 elif targetos == 'darwin'
3667   summary_info += {'CoreAudio support': coreaudio}
3668 elif targetos == 'windows'
3669   summary_info += {'DirectSound support': dsound}
3670 endif
3671 if targetos == 'linux'
3672   summary_info += {'ALSA support':    alsa}
3673   summary_info += {'PulseAudio support': pulse}
3674 endif
3675 summary_info += {'JACK support':      jack}
3676 summary_info += {'brlapi support':    brlapi}
3677 summary_info += {'vde support':       vde}
3678 summary_info += {'netmap support':    have_netmap}
3679 summary_info += {'l2tpv3 support':    have_l2tpv3}
3680 summary_info += {'Linux AIO support': libaio}
3681 summary_info += {'Linux io_uring support': linux_io_uring}
3682 summary_info += {'ATTR/XATTR support': libattr}
3683 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
3684 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
3685 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
3686 summary_info += {'libcap-ng support': libcap_ng}
3687 summary_info += {'bpf support':       libbpf}
3688 summary_info += {'spice protocol support': spice_protocol}
3689 if spice_protocol.found()
3690   summary_info += {'  spice server support': spice}
3691 endif
3692 summary_info += {'rbd support':       rbd}
3693 summary_info += {'smartcard support': cacard}
3694 summary_info += {'U2F support':       u2f}
3695 summary_info += {'libusb':            libusb}
3696 summary_info += {'usb net redir':     usbredir}
3697 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
3698 summary_info += {'GBM':               gbm}
3699 summary_info += {'libiscsi support':  libiscsi}
3700 summary_info += {'libnfs support':    libnfs}
3701 if targetos == 'windows'
3702   if have_ga
3703     summary_info += {'QGA VSS support':   have_qga_vss}
3704   endif
3705 endif
3706 summary_info += {'seccomp support':   seccomp}
3707 summary_info += {'GlusterFS support': glusterfs}
3708 summary_info += {'TPM support':       have_tpm}
3709 summary_info += {'libssh support':    libssh}
3710 summary_info += {'lzo support':       lzo}
3711 summary_info += {'snappy support':    snappy}
3712 summary_info += {'bzip2 support':     libbzip2}
3713 summary_info += {'lzfse support':     liblzfse}
3714 summary_info += {'zstd support':      zstd}
3715 summary_info += {'NUMA host support': numa}
3716 summary_info += {'capstone':          capstone_opt == 'internal' ? capstone_opt : capstone}
3717 summary_info += {'libpmem support':   libpmem}
3718 summary_info += {'libdaxctl support': libdaxctl}
3719 summary_info += {'libudev':           libudev}
3720 # Dummy dependency, keep .found()
3721 summary_info += {'FUSE lseek':        fuse_lseek.found()}
3722 summary_info += {'selinux':           selinux}
3723 summary(summary_info, bool_yn: true, section: 'Dependencies')
3724
3725 if not supported_cpus.contains(cpu)
3726   message()
3727   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3728   message()
3729   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3730   message('The QEMU project intends to remove support for this host CPU in')
3731   message('a future release if nobody volunteers to maintain it and to')
3732   message('provide a build host for our continuous integration setup.')
3733   message('configure has succeeded and you can continue to build, but')
3734   message('if you care about QEMU on this platform you should contact')
3735   message('us upstream at qemu-devel@nongnu.org.')
3736 endif
3737
3738 if not supported_oses.contains(targetos)
3739   message()
3740   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3741   message()
3742   message('Host OS ' + targetos + 'support is not currently maintained.')
3743   message('The QEMU project intends to remove support for this host OS in')
3744   message('a future release if nobody volunteers to maintain it and to')
3745   message('provide a build host for our continuous integration setup.')
3746   message('configure has succeeded and you can continue to build, but')
3747   message('if you care about QEMU on this platform you should contact')
3748   message('us upstream at qemu-devel@nongnu.org.')
3749 endif