meson.build

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