meson.build

   1 project('qemu', ['c'], meson_version: '>=0.55.0',
   2         default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto'] +
   3                          (meson.version().version_compare('>=0.56.0') ? [ 'b_staticpic=false' ] : []),
   4         version: run_command('head', meson.source_root() / 'VERSION').stdout().strip())
   5
   6 not_found = dependency('', required: false)
   7 if meson.version().version_compare('>=0.56.0')
   8   keyval = import('keyval')
   9 else
  10   keyval = import('unstable-keyval')
  11 endif
  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
  46 target_dirs = config_host['TARGET_DIRS'].split()
  47 have_user = false
  48 have_system = false
  49 foreach target : target_dirs
  50   have_user = have_user or target.endswith('-user')
  51   have_system = have_system or target.endswith('-softmmu')
  52 endforeach
  53 have_tools = 'CONFIG_TOOLS' in config_host
  54 have_block = have_system or have_tools
  55
  56 python = import('python').find_installation()
  57
  58 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
  59 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
  60   'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
  61
  62 cpu = host_machine.cpu_family()
  63 targetos = host_machine.system()
  64
  65 if cpu in ['x86', 'x86_64']
  66   kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
  67 elif cpu == 'aarch64'
  68   kvm_targets = ['aarch64-softmmu']
  69 elif cpu == 's390x'
  70   kvm_targets = ['s390x-softmmu']
  71 elif cpu in ['ppc', 'ppc64']
  72   kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
  73 elif cpu in ['mips', 'mips64']
  74   kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
  75 else
  76   kvm_targets = []
  77 endif
  78
  79 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
  80 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
  81   # i368 emulator provides xenpv machine type for multiple architectures
  82   accelerator_targets += {
  83     'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
  84   }
  85 endif
  86 if cpu in ['x86', 'x86_64']
  87   accelerator_targets += {
  88     'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
  89     'CONFIG_HVF': ['x86_64-softmmu'],
  90     'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
  91     'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
  92   }
  93 endif
  94
  95 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
  96 install_edk2_blobs = false
  97 if get_option('install_blobs')
  98   foreach target : target_dirs
  99     install_edk2_blobs = install_edk2_blobs or target in edk2_targets
 100   endforeach
 101 endif
 102
 103 bzip2 = find_program('bzip2', required: install_edk2_blobs)
 104
 105 ##################
 106 # Compiler flags #
 107 ##################
 108
 109 # Specify linker-script with add_project_link_arguments so that it is not placed
 110 # within a linker --start-group/--end-group pair
 111 if 'CONFIG_FUZZ' in config_host
 112    add_project_link_arguments(['-Wl,-T,',
 113                                (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
 114                               native: false, language: ['c', 'cpp', 'objc'])
 115 endif
 116
 117 add_global_arguments(config_host['QEMU_CFLAGS'].split(),
 118                      native: false, language: ['c', 'objc'])
 119 add_global_arguments(config_host['QEMU_CXXFLAGS'].split(),
 120                      native: false, language: 'cpp')
 121 add_global_link_arguments(config_host['QEMU_LDFLAGS'].split(),
 122                           native: false, language: ['c', 'cpp', 'objc'])
 123
 124 if targetos == 'linux'
 125   add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
 126                         '-isystem', 'linux-headers',
 127                         language: ['c', 'cpp'])
 128 endif
 129
 130 add_project_arguments('-iquote', '.',
 131                       '-iquote', meson.current_source_dir(),
 132                       '-iquote', meson.current_source_dir() / 'include',
 133                       '-iquote', meson.current_source_dir() / 'disas/libvixl',
 134                       language: ['c', 'cpp', 'objc'])
 135
 136 link_language = meson.get_external_property('link_language', 'cpp')
 137 if link_language == 'cpp'
 138   add_languages('cpp', required: true, native: false)
 139 endif
 140 if host_machine.system() == 'darwin'
 141   add_languages('objc', required: false, native: false)
 142 endif
 143
 144 sparse = find_program('cgcc', required: get_option('sparse'))
 145 if sparse.found()
 146   run_target('sparse',
 147              command: [find_program('scripts/check_sparse.py'),
 148                        'compile_commands.json', sparse.full_path(), '-Wbitwise',
 149                        '-Wno-transparent-union', '-Wno-old-initializer',
 150                        '-Wno-non-pointer-null'])
 151 endif
 152
 153 ###########################################
 154 # Target-specific checks and dependencies #
 155 ###########################################
 156
 157 if targetos != 'linux' and get_option('mpath').enabled()
 158   error('Multipath is supported only on Linux')
 159 endif
 160
 161 if targetos != 'linux' and get_option('multiprocess').enabled()
 162   error('Multiprocess QEMU is supported only on Linux')
 163 endif
 164 multiprocess_allowed = targetos == 'linux' and not get_option('multiprocess').disabled()
 165
 166 libm = cc.find_library('m', required: false)
 167 util = cc.find_library('util', required: false)
 168 winmm = []
 169 socket = []
 170 version_res = []
 171 coref = []
 172 iokit = []
 173 emulator_link_args = []
 174 nvmm =not_found
 175 hvf = not_found
 176 if targetos == 'windows'
 177   socket = cc.find_library('ws2_32')
 178   winmm = cc.find_library('winmm')
 179
 180   win = import('windows')
 181   version_res = win.compile_resources('version.rc',
 182                                       depend_files: files('pc-bios/qemu-nsis.ico'),
 183                                       include_directories: include_directories('.'))
 184 elif targetos == 'darwin'
 185   coref = dependency('appleframeworks', modules: 'CoreFoundation')
 186   iokit = dependency('appleframeworks', modules: 'IOKit')
 187 elif targetos == 'sunos'
 188   socket = [cc.find_library('socket'),
 189             cc.find_library('nsl'),
 190             cc.find_library('resolv')]
 191 elif targetos == 'haiku'
 192   socket = [cc.find_library('posix_error_mapper'),
 193             cc.find_library('network'),
 194             cc.find_library('bsd')]
 195 elif targetos == 'openbsd'
 196   if not get_option('tcg').disabled() and target_dirs.length() > 0
 197     # Disable OpenBSD W^X if available
 198     emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
 199   endif
 200 endif
 201
 202 accelerators = []
 203 if not get_option('kvm').disabled() and targetos == 'linux'
 204   accelerators += 'CONFIG_KVM'
 205 endif
 206 if not get_option('xen').disabled() and 'CONFIG_XEN_BACKEND' in config_host
 207   accelerators += 'CONFIG_XEN'
 208   have_xen_pci_passthrough = not get_option('xen_pci_passthrough').disabled() and targetos == 'linux'
 209 else
 210   have_xen_pci_passthrough = false
 211 endif
 212 if not get_option('whpx').disabled() and targetos == 'windows'
 213   if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
 214     error('WHPX requires 64-bit host')
 215   elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
 216        cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
 217     accelerators += 'CONFIG_WHPX'
 218   endif
 219 endif
 220 if not get_option('hvf').disabled()
 221   hvf = dependency('appleframeworks', modules: 'Hypervisor',
 222                    required: get_option('hvf'))
 223   if hvf.found()
 224     accelerators += 'CONFIG_HVF'
 225   endif
 226 endif
 227 if not get_option('hax').disabled()
 228   if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
 229     accelerators += 'CONFIG_HAX'
 230   endif
 231 endif
 232 if targetos == 'netbsd'
 233   if cc.has_header_symbol('nvmm.h', 'nvmm_cpu_stop', required: get_option('nvmm'))
 234     nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
 235   endif
 236   if nvmm.found()
 237     accelerators += 'CONFIG_NVMM'
 238   endif
 239 endif
 240
 241 tcg_arch = config_host['ARCH']
 242 if not get_option('tcg').disabled()
 243   if cpu not in supported_cpus
 244     if get_option('tcg_interpreter')
 245       warning('Unsupported CPU @0@, will use TCG with TCI (experimental and slow)'.format(cpu))
 246     else
 247       error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
 248     endif
 249   elif get_option('tcg_interpreter')
 250     warning('Use of the TCG interpretor is not recommended on this host')
 251     warning('architecture. There is a native TCG execution backend available')
 252     warning('which provides substantially better performance and reliability.')
 253     warning('It is strongly recommended to remove the --enable-tcg-interpreter')
 254     warning('configuration option on this architecture to use the native')
 255     warning('backend.')
 256   endif
 257   if get_option('tcg_interpreter')
 258     tcg_arch = 'tci'
 259   elif config_host['ARCH'] == 'sparc64'
 260     tcg_arch = 'sparc'
 261   elif config_host['ARCH'] == 's390x'
 262     tcg_arch = 's390'
 263   elif config_host['ARCH'] in ['x86_64', 'x32']
 264     tcg_arch = 'i386'
 265   elif config_host['ARCH'] == 'ppc64'
 266     tcg_arch = 'ppc'
 267   elif config_host['ARCH'] in ['riscv32', 'riscv64']
 268     tcg_arch = 'riscv'
 269   endif
 270   add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
 271                         language: ['c', 'cpp', 'objc'])
 272
 273   accelerators += 'CONFIG_TCG'
 274   config_host += { 'CONFIG_TCG': 'y' }
 275 endif
 276
 277 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
 278   error('KVM not available on this platform')
 279 endif
 280 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
 281   error('HVF not available on this platform')
 282 endif
 283 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
 284   error('NVMM not available on this platform')
 285 endif
 286 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
 287   error('WHPX not available on this platform')
 288 endif
 289 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
 290   if 'CONFIG_XEN' in accelerators
 291     error('Xen PCI passthrough not available on this platform')
 292   else
 293     error('Xen PCI passthrough requested but Xen not enabled')
 294   endif
 295 endif
 296
 297 ################
 298 # Dependencies #
 299 ################
 300
 301 # The path to glib.h is added to all compilation commands.  This was
 302 # grandfathered in from the QEMU Makefiles.
 303 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
 304                       native: false, language: ['c', 'cpp', 'objc'])
 305 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
 306                           link_args: config_host['GLIB_LIBS'].split())
 307 # override glib dep with the configure results (for subprojects)
 308 meson.override_dependency('glib-2.0', glib)
 309
 310 gio = not_found
 311 if 'CONFIG_GIO' in config_host
 312   gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
 313                            link_args: config_host['GIO_LIBS'].split())
 314 endif
 315 lttng = not_found
 316 if 'CONFIG_TRACE_UST' in config_host
 317   lttng = declare_dependency(link_args: config_host['LTTNG_UST_LIBS'].split())
 318 endif
 319 urcubp = not_found
 320 if 'CONFIG_TRACE_UST' in config_host
 321   urcubp = declare_dependency(link_args: config_host['URCU_BP_LIBS'].split())
 322 endif
 323 pixman = not_found
 324 if have_system or have_tools
 325   pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
 326                       method: 'pkg-config', kwargs: static_kwargs)
 327 endif
 328 libaio = cc.find_library('aio', required: false)
 329 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
 330 linux_io_uring = not_found
 331 if 'CONFIG_LINUX_IO_URING' in config_host
 332   linux_io_uring = declare_dependency(compile_args: config_host['LINUX_IO_URING_CFLAGS'].split(),
 333                                       link_args: config_host['LINUX_IO_URING_LIBS'].split())
 334 endif
 335 libxml2 = not_found
 336 if 'CONFIG_LIBXML2' in config_host
 337   libxml2 = declare_dependency(compile_args: config_host['LIBXML2_CFLAGS'].split(),
 338                                link_args: config_host['LIBXML2_LIBS'].split())
 339 endif
 340 libnfs = not_found
 341 if not get_option('libnfs').auto() or have_block
 342   libnfs = dependency('libnfs', version: '>=1.9.3',
 343                       required: get_option('libnfs'),
 344                       method: 'pkg-config', kwargs: static_kwargs)
 345 endif
 346
 347 libattr_test = '''
 348   #include <stddef.h>
 349   #include <sys/types.h>
 350   #ifdef CONFIG_LIBATTR
 351   #include <attr/xattr.h>
 352   #else
 353   #include <sys/xattr.h>
 354   #endif
 355   int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
 356
 357 libattr = not_found
 358 have_old_libattr = false
 359 if not get_option('attr').disabled()
 360   if cc.links(libattr_test)
 361     libattr = declare_dependency()
 362   else
 363     libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
 364                               required: get_option('attr'),
 365                               kwargs: static_kwargs)
 366     if libattr.found() and not \
 367       cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
 368       libattr = not_found
 369       if get_option('attr').enabled()
 370         error('could not link libattr')
 371       else
 372         warning('could not link libattr, disabling')
 373       endif
 374     else
 375       have_old_libattr = libattr.found()
 376     endif
 377   endif
 378 endif
 379
 380 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
 381 if cocoa.found() and get_option('sdl').enabled()
 382   error('Cocoa and SDL cannot be enabled at the same time')
 383 endif
 384 if cocoa.found() and get_option('gtk').enabled()
 385   error('Cocoa and GTK+ cannot be enabled at the same time')
 386 endif
 387
 388 seccomp = not_found
 389 if not get_option('seccomp').auto() or have_system or have_tools
 390   seccomp = dependency('libseccomp', version: '>=2.3.0',
 391                        required: get_option('seccomp'),
 392                        method: 'pkg-config', kwargs: static_kwargs)
 393 endif
 394
 395 libcap_ng = not_found
 396 if not get_option('cap_ng').auto() or have_system or have_tools
 397   libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
 398                               required: get_option('cap_ng'),
 399                               kwargs: static_kwargs)
 400 endif
 401 if libcap_ng.found() and not cc.links('''
 402    #include <cap-ng.h>
 403    int main(void)
 404    {
 405      capng_capability_to_name(CAPNG_EFFECTIVE);
 406      return 0;
 407    }''', dependencies: libcap_ng)
 408   libcap_ng = not_found
 409   if get_option('cap_ng').enabled()
 410     error('could not link libcap-ng')
 411   else
 412     warning('could not link libcap-ng, disabling')
 413   endif
 414 endif
 415
 416 if get_option('xkbcommon').auto() and not have_system and not have_tools
 417   xkbcommon = not_found
 418 else
 419   xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
 420                          method: 'pkg-config', kwargs: static_kwargs)
 421 endif
 422 vde = not_found
 423 if config_host.has_key('CONFIG_VDE')
 424   vde = declare_dependency(link_args: config_host['VDE_LIBS'].split())
 425 endif
 426 pulse = not_found
 427 if 'CONFIG_LIBPULSE' in config_host
 428   pulse = declare_dependency(compile_args: config_host['PULSE_CFLAGS'].split(),
 429                              link_args: config_host['PULSE_LIBS'].split())
 430 endif
 431 alsa = not_found
 432 if 'CONFIG_ALSA' in config_host
 433   alsa = declare_dependency(compile_args: config_host['ALSA_CFLAGS'].split(),
 434                             link_args: config_host['ALSA_LIBS'].split())
 435 endif
 436 jack = not_found
 437 if 'CONFIG_LIBJACK' in config_host
 438   jack = declare_dependency(link_args: config_host['JACK_LIBS'].split())
 439 endif
 440 spice = not_found
 441 spice_headers = not_found
 442 spice_protocol = not_found
 443 if 'CONFIG_SPICE' in config_host
 444   spice = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split(),
 445                              link_args: config_host['SPICE_LIBS'].split())
 446   spice_headers = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split())
 447 endif
 448 if 'CONFIG_SPICE_PROTOCOL' in config_host
 449   spice_protocol = declare_dependency(compile_args: config_host['SPICE_PROTOCOL_CFLAGS'].split())
 450 endif
 451 rt = cc.find_library('rt', required: false)
 452 libdl = not_found
 453 if 'CONFIG_PLUGIN' in config_host
 454   libdl = cc.find_library('dl', required: true)
 455 endif
 456 libiscsi = not_found
 457 if not get_option('libiscsi').auto() or have_block
 458   libiscsi = dependency('libiscsi', version: '>=1.9.0',
 459                          required: get_option('libiscsi'),
 460                          method: 'pkg-config', kwargs: static_kwargs)
 461 endif
 462 zstd = not_found
 463 if not get_option('zstd').auto() or have_block
 464   zstd = dependency('libzstd', version: '>=1.4.0',
 465                     required: get_option('zstd'),
 466                     method: 'pkg-config', kwargs: static_kwargs)
 467 endif
 468 gbm = not_found
 469 if 'CONFIG_GBM' in config_host
 470   gbm = declare_dependency(compile_args: config_host['GBM_CFLAGS'].split(),
 471                            link_args: config_host['GBM_LIBS'].split())
 472 endif
 473 virgl = not_found
 474 if 'CONFIG_VIRGL' in config_host
 475   virgl = declare_dependency(compile_args: config_host['VIRGL_CFLAGS'].split(),
 476                              link_args: config_host['VIRGL_LIBS'].split())
 477 endif
 478 curl = not_found
 479 if not get_option('curl').auto() or have_block
 480   curl = dependency('libcurl', version: '>=7.29.0',
 481                     method: 'pkg-config',
 482                     required: get_option('curl'),
 483                     kwargs: static_kwargs)
 484 endif
 485 libudev = not_found
 486 if targetos == 'linux' and (have_system or have_tools)
 487   libudev = dependency('libudev',
 488                        method: 'pkg-config',
 489                        required: get_option('libudev'),
 490                        kwargs: static_kwargs)
 491 endif
 492
 493 mpathlibs = [libudev]
 494 mpathpersist = not_found
 495 mpathpersist_new_api = false
 496 if targetos == 'linux' and have_tools and not get_option('mpath').disabled()
 497   mpath_test_source_new = '''
 498     #include <libudev.h>
 499     #include <mpath_persist.h>
 500     unsigned mpath_mx_alloc_len = 1024;
 501     int logsink;
 502     static struct config *multipath_conf;
 503     extern struct udev *udev;
 504     extern struct config *get_multipath_config(void);
 505     extern void put_multipath_config(struct config *conf);
 506     struct udev *udev;
 507     struct config *get_multipath_config(void) { return multipath_conf; }
 508     void put_multipath_config(struct config *conf) { }
 509     int main(void) {
 510         udev = udev_new();
 511         multipath_conf = mpath_lib_init();
 512         return 0;
 513     }'''
 514   mpath_test_source_old = '''
 515       #include <libudev.h>
 516       #include <mpath_persist.h>
 517       unsigned mpath_mx_alloc_len = 1024;
 518       int logsink;
 519       int main(void) {
 520           struct udev *udev = udev_new();
 521           mpath_lib_init(udev);
 522           return 0;
 523       }'''
 524   libmpathpersist = cc.find_library('mpathpersist',
 525                                     required: get_option('mpath'),
 526                                     kwargs: static_kwargs)
 527   if libmpathpersist.found()
 528     mpathlibs += libmpathpersist
 529     if enable_static
 530       mpathlibs += cc.find_library('devmapper',
 531                                      required: get_option('mpath'),
 532                                      kwargs: static_kwargs)
 533     endif
 534     mpathlibs += cc.find_library('multipath',
 535                                  required: get_option('mpath'),
 536                                  kwargs: static_kwargs)
 537     foreach lib: mpathlibs
 538       if not lib.found()
 539         mpathlibs = []
 540         break
 541       endif
 542     endforeach
 543     if mpathlibs.length() == 0
 544       msg = 'Dependencies missing for libmpathpersist'
 545     elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
 546       mpathpersist = declare_dependency(dependencies: mpathlibs)
 547       mpathpersist_new_api = true
 548     elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
 549       mpathpersist = declare_dependency(dependencies: mpathlibs)
 550     else
 551       msg = 'Cannot detect libmpathpersist API'
 552     endif
 553     if not mpathpersist.found()
 554       if get_option('mpath').enabled()
 555         error(msg)
 556       else
 557         warning(msg + ', disabling')
 558       endif
 559     endif
 560   endif
 561 endif
 562
 563 iconv = not_found
 564 curses = not_found
 565 if have_system and not get_option('curses').disabled()
 566   curses_test = '''
 567     #include <locale.h>
 568     #include <curses.h>
 569     #include <wchar.h>
 570     int main(void) {
 571       wchar_t wch = L'w';
 572       setlocale(LC_ALL, "");
 573       resize_term(0, 0);
 574       addwstr(L"wide chars\n");
 575       addnwstr(&wch, 1);
 576       add_wch(WACS_DEGREE);
 577       return 0;
 578     }'''
 579
 580   curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
 581   foreach curses_dep : curses_dep_list
 582     if not curses.found()
 583       curses = dependency(curses_dep,
 584                           required: false,
 585                           method: 'pkg-config',
 586                           kwargs: static_kwargs)
 587     endif
 588   endforeach
 589   msg = get_option('curses').enabled() ? 'curses library not found' : ''
 590   curses_compile_args = ['-DNCURSES_WIDECHAR']
 591   if curses.found()
 592     if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
 593       curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
 594     else
 595       msg = 'curses package not usable'
 596       curses = not_found
 597     endif
 598   endif
 599   if not curses.found()
 600     has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
 601     if targetos != 'windows' and not has_curses_h
 602       message('Trying with /usr/include/ncursesw')
 603       curses_compile_args += ['-I/usr/include/ncursesw']
 604       has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
 605     endif
 606     if has_curses_h
 607       curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
 608       foreach curses_libname : curses_libname_list
 609         libcurses = cc.find_library(curses_libname,
 610                                     required: false,
 611                                     kwargs: static_kwargs)
 612         if libcurses.found()
 613           if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
 614             curses = declare_dependency(compile_args: curses_compile_args,
 615                                         dependencies: [libcurses])
 616             break
 617           else
 618             msg = 'curses library not usable'
 619           endif
 620         endif
 621       endforeach
 622     endif
 623   endif
 624   if not get_option('iconv').disabled()
 625     foreach link_args : [ ['-liconv'], [] ]
 626       # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
 627       # We need to use libiconv if available because mixing libiconv's headers with
 628       # the system libc does not work.
 629       # However, without adding glib to the dependencies -L/usr/local/lib will not be
 630       # included in the command line and libiconv will not be found.
 631       if cc.links('''
 632         #include <iconv.h>
 633         int main(void) {
 634           iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
 635           return conv != (iconv_t) -1;
 636         }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
 637         iconv = declare_dependency(link_args: link_args, dependencies: glib)
 638         break
 639       endif
 640     endforeach
 641   endif
 642   if curses.found() and not iconv.found()
 643     if get_option('iconv').enabled()
 644       error('iconv not available')
 645     endif
 646     msg = 'iconv required for curses UI but not available'
 647     curses = not_found
 648   endif
 649   if not curses.found() and msg != ''
 650     if get_option('curses').enabled()
 651       error(msg)
 652     else
 653       warning(msg + ', disabling')
 654     endif
 655   endif
 656 endif
 657
 658 brlapi = not_found
 659 if not get_option('brlapi').auto() or have_system
 660   brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
 661                          required: get_option('brlapi'),
 662                          kwargs: static_kwargs)
 663   if brlapi.found() and not cc.links('''
 664      #include <brlapi.h>
 665      #include <stddef.h>
 666      int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
 667     brlapi = not_found
 668     if get_option('brlapi').enabled()
 669       error('could not link brlapi')
 670     else
 671       warning('could not link brlapi, disabling')
 672     endif
 673   endif
 674 endif
 675
 676 sdl = not_found
 677 if not get_option('sdl').auto() or (have_system and not cocoa.found())
 678   sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
 679   sdl_image = not_found
 680 endif
 681 if sdl.found()
 682   # work around 2.0.8 bug
 683   sdl = declare_dependency(compile_args: '-Wno-undef',
 684                            dependencies: sdl)
 685   sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
 686                          method: 'pkg-config', kwargs: static_kwargs)
 687 else
 688   if get_option('sdl_image').enabled()
 689     error('sdl-image required, but SDL was @0@'.format(
 690           get_option('sdl').disabled() ? 'disabled' : 'not found'))
 691   endif
 692   sdl_image = not_found
 693 endif
 694
 695 rbd = not_found
 696 if not get_option('rbd').auto() or have_block
 697   librados = cc.find_library('rados', required: get_option('rbd'),
 698                              kwargs: static_kwargs)
 699   librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
 700                            required: get_option('rbd'),
 701                            kwargs: static_kwargs)
 702   if librados.found() and librbd.found()
 703     if cc.links('''
 704       #include <stdio.h>
 705       #include <rbd/librbd.h>
 706       int main(void) {
 707         rados_t cluster;
 708         rados_create(&cluster, NULL);
 709         return 0;
 710       }''', dependencies: [librbd, librados])
 711       rbd = declare_dependency(dependencies: [librbd, librados])
 712     elif get_option('rbd').enabled()
 713       error('could not link librados')
 714     else
 715       warning('could not link librados, disabling')
 716     endif
 717   endif
 718 endif
 719
 720 glusterfs = not_found
 721 glusterfs_ftruncate_has_stat = false
 722 glusterfs_iocb_has_stat = false
 723 if not get_option('glusterfs').auto() or have_block
 724   glusterfs = dependency('glusterfs-api', version: '>=3',
 725                          required: get_option('glusterfs'),
 726                          method: 'pkg-config', kwargs: static_kwargs)
 727   if glusterfs.found()
 728     glusterfs_ftruncate_has_stat = cc.links('''
 729       #include <glusterfs/api/glfs.h>
 730
 731       int
 732       main(void)
 733       {
 734           /* new glfs_ftruncate() passes two additional args */
 735           return glfs_ftruncate(NULL, 0, NULL, NULL);
 736       }
 737     ''', dependencies: glusterfs)
 738     glusterfs_iocb_has_stat = cc.links('''
 739       #include <glusterfs/api/glfs.h>
 740
 741       /* new glfs_io_cbk() passes two additional glfs_stat structs */
 742       static void
 743       glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
 744       {}
 745
 746       int
 747       main(void)
 748       {
 749           glfs_io_cbk iocb = &glusterfs_iocb;
 750           iocb(NULL, 0 , NULL, NULL, NULL);
 751           return 0;
 752       }
 753     ''', dependencies: glusterfs)
 754   endif
 755 endif
 756 libssh = not_found
 757 if 'CONFIG_LIBSSH' in config_host
 758   libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
 759                               link_args: config_host['LIBSSH_LIBS'].split())
 760 endif
 761 libbzip2 = not_found
 762 if not get_option('bzip2').auto() or have_block
 763   libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
 764                              required: get_option('bzip2'),
 765                              kwargs: static_kwargs)
 766   if libbzip2.found() and not cc.links('''
 767      #include <bzlib.h>
 768      int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
 769     libbzip2 = not_found
 770     if get_option('bzip2').enabled()
 771       error('could not link libbzip2')
 772     else
 773       warning('could not link libbzip2, disabling')
 774     endif
 775   endif
 776 endif
 777
 778 liblzfse = not_found
 779 if not get_option('lzfse').auto() or have_block
 780   liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
 781                              required: get_option('lzfse'),
 782                              kwargs: static_kwargs)
 783 endif
 784 if liblzfse.found() and not cc.links('''
 785    #include <lzfse.h>
 786    int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
 787   liblzfse = not_found
 788   if get_option('lzfse').enabled()
 789     error('could not link liblzfse')
 790   else
 791     warning('could not link liblzfse, disabling')
 792   endif
 793 endif
 794
 795 oss = not_found
 796 if 'CONFIG_AUDIO_OSS' in config_host
 797   oss = declare_dependency(link_args: config_host['OSS_LIBS'].split())
 798 endif
 799 dsound = not_found
 800 if 'CONFIG_AUDIO_DSOUND' in config_host
 801   dsound = declare_dependency(link_args: config_host['DSOUND_LIBS'].split())
 802 endif
 803 coreaudio = not_found
 804 if 'CONFIG_AUDIO_COREAUDIO' in config_host
 805   coreaudio = declare_dependency(link_args: config_host['COREAUDIO_LIBS'].split())
 806 endif
 807 opengl = not_found
 808 if 'CONFIG_OPENGL' in config_host
 809   opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
 810                               link_args: config_host['OPENGL_LIBS'].split())
 811 endif
 812
 813 gnutls = not_found
 814 if not get_option('gnutls').auto() or have_system
 815   gnutls = dependency('gnutls', version: '>=3.5.18',
 816                       method: 'pkg-config',
 817                       required: get_option('gnutls'),
 818                       kwargs: static_kwargs)
 819 endif
 820
 821 # Nettle has priority over gcrypt
 822 gcrypt = not_found
 823 nettle = not_found
 824 xts = 'private'
 825 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
 826   error('Only one of gcrypt & nettle can be enabled')
 827 elif (not get_option('nettle').auto() or have_system) and not get_option('gcrypt').enabled()
 828   nettle = dependency('nettle', version: '>=3.4',
 829                       method: 'pkg-config',
 830                       required: get_option('nettle'),
 831                       kwargs: static_kwargs)
 832   if nettle.found() and cc.has_header('nettle/xts.h', dependencies: nettle)
 833     xts = 'nettle'
 834   endif
 835 endif
 836 if (not get_option('gcrypt').auto() or have_system) and not nettle.found()
 837   gcrypt = dependency('libgcrypt', version: '>=1.5',
 838                          method: 'config-tool',
 839                          required: get_option('gcrypt'),
 840                          kwargs: static_kwargs)
 841   if gcrypt.found() and cc.compiles('''
 842     #include <gcrypt.h>
 843     int main(void) {
 844       gcry_cipher_hd_t handle;
 845       gcry_cipher_open(&handle, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_XTS, 0);
 846       return 0;
 847     }
 848     ''', dependencies: gcrypt)
 849     xts = 'gcrypt'
 850   endif
 851   # Debian has removed -lgpg-error from libgcrypt-config
 852   # as it "spreads unnecessary dependencies" which in
 853   # turn breaks static builds...
 854   if gcrypt.found() and enable_static
 855     gcrypt = declare_dependency(dependencies: [
 856       gcrypt,
 857       cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
 858   endif
 859 endif
 860
 861 gtk = not_found
 862 gtkx11 = not_found
 863 if not get_option('gtk').auto() or (have_system and not cocoa.found())
 864   gtk = dependency('gtk+-3.0', version: '>=3.22.0',
 865                    method: 'pkg-config',
 866                    required: get_option('gtk'),
 867                    kwargs: static_kwargs)
 868   if gtk.found()
 869     gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
 870                         method: 'pkg-config',
 871                         required: false,
 872                         kwargs: static_kwargs)
 873     gtk = declare_dependency(dependencies: [gtk, gtkx11])
 874   endif
 875 endif
 876
 877 vte = not_found
 878 if 'CONFIG_VTE' in config_host
 879   vte = declare_dependency(compile_args: config_host['VTE_CFLAGS'].split(),
 880                            link_args: config_host['VTE_LIBS'].split())
 881 endif
 882 x11 = not_found
 883 if gtkx11.found()
 884   x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
 885                    kwargs: static_kwargs)
 886 endif
 887 vnc = not_found
 888 png = not_found
 889 jpeg = not_found
 890 sasl = not_found
 891 if get_option('vnc').enabled()
 892   vnc = declare_dependency() # dummy dependency
 893   png = dependency('libpng', required: get_option('vnc_png'),
 894                    method: 'pkg-config', kwargs: static_kwargs)
 895   jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
 896                     method: 'pkg-config', kwargs: static_kwargs)
 897   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
 898                          required: get_option('vnc_sasl'),
 899                          kwargs: static_kwargs)
 900   if sasl.found()
 901     sasl = declare_dependency(dependencies: sasl,
 902                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
 903   endif
 904 endif
 905
 906 pam = not_found
 907 if not get_option('auth_pam').auto() or have_system
 908   pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
 909                         required: get_option('auth_pam'),
 910                         kwargs: static_kwargs)
 911 endif
 912 if pam.found() and not cc.links('''
 913    #include <stddef.h>
 914    #include <security/pam_appl.h>
 915    int main(void) {
 916      const char *service_name = "qemu";
 917      const char *user = "frank";
 918      const struct pam_conv pam_conv = { 0 };
 919      pam_handle_t *pamh = NULL;
 920      pam_start(service_name, user, &pam_conv, &pamh);
 921      return 0;
 922    }''', dependencies: pam)
 923   pam = not_found
 924   if get_option('auth_pam').enabled()
 925     error('could not link libpam')
 926   else
 927     warning('could not link libpam, disabling')
 928   endif
 929 endif
 930
 931 snappy = not_found
 932 if not get_option('snappy').auto() or have_system
 933   snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
 934                            required: get_option('snappy'),
 935                            kwargs: static_kwargs)
 936 endif
 937 if snappy.found() and not cc.links('''
 938    #include <snappy-c.h>
 939    int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
 940   snappy = not_found
 941   if get_option('snappy').enabled()
 942     error('could not link libsnappy')
 943   else
 944     warning('could not link libsnappy, disabling')
 945   endif
 946 endif
 947
 948 lzo = not_found
 949 if not get_option('lzo').auto() or have_system
 950   lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
 951                         required: get_option('lzo'),
 952                         kwargs: static_kwargs)
 953 endif
 954 if lzo.found() and not cc.links('''
 955    #include <lzo/lzo1x.h>
 956    int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
 957   lzo = not_found
 958   if get_option('lzo').enabled()
 959     error('could not link liblzo2')
 960   else
 961     warning('could not link liblzo2, disabling')
 962   endif
 963 endif
 964
 965 rdma = not_found
 966 if 'CONFIG_RDMA' in config_host
 967   rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
 968 endif
 969 numa = not_found
 970 if 'CONFIG_NUMA' in config_host
 971   numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
 972 endif
 973 xen = not_found
 974 if 'CONFIG_XEN_BACKEND' in config_host
 975   xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
 976                            link_args: config_host['XEN_LIBS'].split())
 977 endif
 978 cacard = not_found
 979 if 'CONFIG_SMARTCARD' in config_host
 980   cacard = declare_dependency(compile_args: config_host['SMARTCARD_CFLAGS'].split(),
 981                               link_args: config_host['SMARTCARD_LIBS'].split())
 982 endif
 983 u2f = not_found
 984 if have_system
 985   u2f = dependency('u2f-emu', required: get_option('u2f'),
 986                    method: 'pkg-config',
 987                    kwargs: static_kwargs)
 988 endif
 989 usbredir = not_found
 990 if 'CONFIG_USB_REDIR' in config_host
 991   usbredir = declare_dependency(compile_args: config_host['USB_REDIR_CFLAGS'].split(),
 992                                 link_args: config_host['USB_REDIR_LIBS'].split())
 993 endif
 994 libusb = not_found
 995 if not get_option('libusb').auto() or have_system
 996   libusb = dependency('libusb-1.0', required: get_option('libusb'),
 997                       version: '>=1.0.13', method: 'pkg-config',
 998                       kwargs: static_kwargs)
 999 endif
1000
1001 libpmem = not_found
1002 if 'CONFIG_LIBPMEM' in config_host
1003   libpmem = declare_dependency(compile_args: config_host['LIBPMEM_CFLAGS'].split(),
1004                                link_args: config_host['LIBPMEM_LIBS'].split())
1005 endif
1006 libdaxctl = not_found
1007 if 'CONFIG_LIBDAXCTL' in config_host
1008   libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split())
1009 endif
1010 tasn1 = not_found
1011 if gnutls.found()
1012   tasn1 = dependency('libtasn1',
1013                      method: 'pkg-config',
1014                      kwargs: static_kwargs)
1015 endif
1016 keyutils = dependency('libkeyutils', required: false,
1017                       method: 'pkg-config', kwargs: static_kwargs)
1018
1019 has_gettid = cc.has_function('gettid')
1020
1021 # Malloc tests
1022
1023 malloc = []
1024 if get_option('malloc') == 'system'
1025   has_malloc_trim = \
1026     not get_option('malloc_trim').disabled() and \
1027     cc.links('''#include <malloc.h>
1028                 int main(void) { malloc_trim(0); return 0; }''')
1029 else
1030   has_malloc_trim = false
1031   malloc = cc.find_library(get_option('malloc'), required: true)
1032 endif
1033 if not has_malloc_trim and get_option('malloc_trim').enabled()
1034   if get_option('malloc') == 'system'
1035     error('malloc_trim not available on this platform.')
1036   else
1037     error('malloc_trim not available with non-libc memory allocator')
1038   endif
1039 endif
1040
1041 # Check whether the glibc provides statx()
1042
1043 statx_test = '''
1044   #ifndef _GNU_SOURCE
1045   #define _GNU_SOURCE
1046   #endif
1047   #include <sys/stat.h>
1048   int main(void) {
1049     struct statx statxbuf;
1050     statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
1051     return 0;
1052   }'''
1053
1054 has_statx = cc.links(statx_test)
1055
1056 have_vhost_user_blk_server = (targetos == 'linux' and
1057     'CONFIG_VHOST_USER' in config_host)
1058
1059 if get_option('vhost_user_blk_server').enabled()
1060     if targetos != 'linux'
1061         error('vhost_user_blk_server requires linux')
1062     elif 'CONFIG_VHOST_USER' not in config_host
1063         error('vhost_user_blk_server requires vhost-user support')
1064     endif
1065 elif get_option('vhost_user_blk_server').disabled() or not have_system
1066     have_vhost_user_blk_server = false
1067 endif
1068
1069
1070 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1071   error('Cannot enable fuse-lseek while fuse is disabled')
1072 endif
1073
1074 fuse = dependency('fuse3', required: get_option('fuse'),
1075                   version: '>=3.1', method: 'pkg-config',
1076                   kwargs: static_kwargs)
1077
1078 fuse_lseek = not_found
1079 if not get_option('fuse_lseek').disabled()
1080   if fuse.version().version_compare('>=3.8')
1081     # Dummy dependency
1082     fuse_lseek = declare_dependency()
1083   elif get_option('fuse_lseek').enabled()
1084     if fuse.found()
1085       error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1086     else
1087       error('fuse-lseek requires libfuse, which was not found')
1088     endif
1089   endif
1090 endif
1091
1092 # libbpf
1093 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1094 if libbpf.found() and not cc.links('''
1095    #include <bpf/libbpf.h>
1096    int main(void)
1097    {
1098      bpf_object__destroy_skeleton(NULL);
1099      return 0;
1100    }''', dependencies: libbpf)
1101   libbpf = not_found
1102   if get_option('bpf').enabled()
1103     error('libbpf skeleton test failed')
1104   else
1105     warning('libbpf skeleton test failed, disabling')
1106   endif
1107 endif
1108
1109 if get_option('cfi')
1110   cfi_flags=[]
1111   # Check for dependency on LTO
1112   if not get_option('b_lto')
1113     error('Selected Control-Flow Integrity but LTO is disabled')
1114   endif
1115   if config_host.has_key('CONFIG_MODULES')
1116     error('Selected Control-Flow Integrity is not compatible with modules')
1117   endif
1118   # Check for cfi flags. CFI requires LTO so we can't use
1119   # get_supported_arguments, but need a more complex "compiles" which allows
1120   # custom arguments
1121   if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1122                  args: ['-flto', '-fsanitize=cfi-icall'] )
1123     cfi_flags += '-fsanitize=cfi-icall'
1124   else
1125     error('-fsanitize=cfi-icall is not supported by the compiler')
1126   endif
1127   if cc.compiles('int main () { return 0; }',
1128                  name: '-fsanitize-cfi-icall-generalize-pointers',
1129                  args: ['-flto', '-fsanitize=cfi-icall',
1130                         '-fsanitize-cfi-icall-generalize-pointers'] )
1131     cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1132   else
1133     error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1134   endif
1135   if get_option('cfi_debug')
1136     if cc.compiles('int main () { return 0; }',
1137                    name: '-fno-sanitize-trap=cfi-icall',
1138                    args: ['-flto', '-fsanitize=cfi-icall',
1139                           '-fno-sanitize-trap=cfi-icall'] )
1140       cfi_flags += '-fno-sanitize-trap=cfi-icall'
1141     else
1142       error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1143     endif
1144   endif
1145   add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1146   add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1147 endif
1148
1149 #################
1150 # config-host.h #
1151 #################
1152
1153 have_virtfs = (targetos == 'linux' and
1154     have_system and
1155     libattr.found() and
1156     libcap_ng.found())
1157
1158 have_virtfs_proxy_helper = have_virtfs and have_tools
1159
1160 if get_option('virtfs').enabled()
1161   if not have_virtfs
1162     if targetos != 'linux'
1163       error('virtio-9p (virtfs) requires Linux')
1164     elif not libcap_ng.found() or not libattr.found()
1165       error('virtio-9p (virtfs) requires libcap-ng-devel and libattr-devel')
1166     elif not have_system
1167       error('virtio-9p (virtfs) needs system emulation support')
1168     endif
1169   endif
1170 elif get_option('virtfs').disabled()
1171   have_virtfs = false
1172 endif
1173
1174 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1175 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1176 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1177 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1178 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1179 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1180 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1181 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1182 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1183 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1184 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1185 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1186
1187 config_host_data.set('CONFIG_ATTR', libattr.found())
1188 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1189 config_host_data.set('CONFIG_COCOA', cocoa.found())
1190 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1191 config_host_data.set('CONFIG_LZO', lzo.found())
1192 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1193 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1194 config_host_data.set('CONFIG_CURL', curl.found())
1195 config_host_data.set('CONFIG_CURSES', curses.found())
1196 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1197 if glusterfs.found()
1198   config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1199   config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1200   config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1201   config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1202   config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1203   config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1204 endif
1205 config_host_data.set('CONFIG_GTK', gtk.found())
1206 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1207 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1208 config_host_data.set('CONFIG_EBPF', libbpf.found())
1209 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1210 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1211 config_host_data.set('CONFIG_RBD', rbd.found())
1212 config_host_data.set('CONFIG_SDL', sdl.found())
1213 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1214 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1215 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1216 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1217 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1218 config_host_data.set('CONFIG_VNC', vnc.found())
1219 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1220 config_host_data.set('CONFIG_VNC_PNG', png.found())
1221 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1222 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1223 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1224 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1225 config_host_data.set('CONFIG_GETTID', has_gettid)
1226 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1227 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1228 config_host_data.set('CONFIG_NETTLE', nettle.found())
1229 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1230 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1231 config_host_data.set('CONFIG_STATX', has_statx)
1232 config_host_data.set('CONFIG_ZSTD', zstd.found())
1233 config_host_data.set('CONFIG_FUSE', fuse.found())
1234 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1235 config_host_data.set('CONFIG_X11', x11.found())
1236 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1237 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1238 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1239 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1240 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1241
1242 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1243 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1244 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1245 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1246 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1247 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1248
1249 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1250
1251 ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target
1252 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1253 strings = ['HOST_DSOSUF', 'CONFIG_IASL']
1254 foreach k, v: config_host
1255   if ignored.contains(k)
1256     # do nothing
1257   elif arrays.contains(k)
1258     if v != ''
1259       v = '"' + '", "'.join(v.split()) + '", '
1260     endif
1261     config_host_data.set(k, v)
1262   elif k == 'ARCH'
1263     config_host_data.set('HOST_' + v.to_upper(), 1)
1264   elif strings.contains(k)
1265     if not k.startswith('CONFIG_')
1266       k = 'CONFIG_' + k.to_upper()
1267     endif
1268     config_host_data.set_quoted(k, v)
1269   elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
1270     config_host_data.set(k, v == 'y' ? 1 : v)
1271   endif
1272 endforeach
1273
1274 ########################
1275 # Target configuration #
1276 ########################
1277
1278 minikconf = find_program('scripts/minikconf.py')
1279 config_all = {}
1280 config_all_devices = {}
1281 config_all_disas = {}
1282 config_devices_mak_list = []
1283 config_devices_h = {}
1284 config_target_h = {}
1285 config_target_mak = {}
1286
1287 disassemblers = {
1288   'alpha' : ['CONFIG_ALPHA_DIS'],
1289   'arm' : ['CONFIG_ARM_DIS'],
1290   'avr' : ['CONFIG_AVR_DIS'],
1291   'cris' : ['CONFIG_CRIS_DIS'],
1292   'hexagon' : ['CONFIG_HEXAGON_DIS'],
1293   'hppa' : ['CONFIG_HPPA_DIS'],
1294   'i386' : ['CONFIG_I386_DIS'],
1295   'x86_64' : ['CONFIG_I386_DIS'],
1296   'x32' : ['CONFIG_I386_DIS'],
1297   'm68k' : ['CONFIG_M68K_DIS'],
1298   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
1299   'mips' : ['CONFIG_MIPS_DIS'],
1300   'nios2' : ['CONFIG_NIOS2_DIS'],
1301   'or1k' : ['CONFIG_OPENRISC_DIS'],
1302   'ppc' : ['CONFIG_PPC_DIS'],
1303   'riscv' : ['CONFIG_RISCV_DIS'],
1304   'rx' : ['CONFIG_RX_DIS'],
1305   's390' : ['CONFIG_S390_DIS'],
1306   'sh4' : ['CONFIG_SH4_DIS'],
1307   'sparc' : ['CONFIG_SPARC_DIS'],
1308   'xtensa' : ['CONFIG_XTENSA_DIS'],
1309 }
1310 if link_language == 'cpp'
1311   disassemblers += {
1312     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
1313     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
1314     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
1315   }
1316 endif
1317
1318 host_kconfig = \
1319   ('CONFIG_TPM' in config_host ? ['CONFIG_TPM=y'] : []) + \
1320   ('CONFIG_SPICE' in config_host ? ['CONFIG_SPICE=y'] : []) + \
1321   ('CONFIG_IVSHMEM' in config_host ? ['CONFIG_IVSHMEM=y'] : []) + \
1322   ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
1323   (x11.found() ? ['CONFIG_X11=y'] : []) + \
1324   ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
1325   ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
1326   ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
1327   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
1328   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
1329   ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
1330   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
1331
1332 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
1333
1334 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
1335 actual_target_dirs = []
1336 fdt_required = []
1337 foreach target : target_dirs
1338   config_target = { 'TARGET_NAME': target.split('-')[0] }
1339   if target.endswith('linux-user')
1340     if targetos != 'linux'
1341       if default_targets
1342         continue
1343       endif
1344       error('Target @0@ is only available on a Linux host'.format(target))
1345     endif
1346     config_target += { 'CONFIG_LINUX_USER': 'y' }
1347   elif target.endswith('bsd-user')
1348     if 'CONFIG_BSD' not in config_host
1349       if default_targets
1350         continue
1351       endif
1352       error('Target @0@ is only available on a BSD host'.format(target))
1353     endif
1354     config_target += { 'CONFIG_BSD_USER': 'y' }
1355   elif target.endswith('softmmu')
1356     config_target += { 'CONFIG_SOFTMMU': 'y' }
1357   endif
1358   if target.endswith('-user')
1359     config_target += {
1360       'CONFIG_USER_ONLY': 'y',
1361       'CONFIG_QEMU_INTERP_PREFIX':
1362         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
1363     }
1364   endif
1365
1366   accel_kconfig = []
1367   foreach sym: accelerators
1368     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
1369       config_target += { sym: 'y' }
1370       config_all += { sym: 'y' }
1371       if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
1372         config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
1373       elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
1374         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
1375       endif
1376       accel_kconfig += [ sym + '=y' ]
1377     endif
1378   endforeach
1379   if accel_kconfig.length() == 0
1380     if default_targets
1381       continue
1382     endif
1383     error('No accelerator available for target @0@'.format(target))
1384   endif
1385
1386   actual_target_dirs += target
1387   config_target += keyval.load('default-configs/targets' / target + '.mak')
1388   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
1389
1390   if 'TARGET_NEED_FDT' in config_target
1391     fdt_required += target
1392   endif
1393
1394   # Add default keys
1395   if 'TARGET_BASE_ARCH' not in config_target
1396     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
1397   endif
1398   if 'TARGET_ABI_DIR' not in config_target
1399     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
1400   endif
1401
1402   foreach k, v: disassemblers
1403     if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
1404       foreach sym: v
1405         config_target += { sym: 'y' }
1406         config_all_disas += { sym: 'y' }
1407       endforeach
1408     endif
1409   endforeach
1410
1411   config_target_data = configuration_data()
1412   foreach k, v: config_target
1413     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
1414       # do nothing
1415     elif ignored.contains(k)
1416       # do nothing
1417     elif k == 'TARGET_BASE_ARCH'
1418       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
1419       # not used to select files from sourcesets.
1420       config_target_data.set('TARGET_' + v.to_upper(), 1)
1421     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
1422       config_target_data.set_quoted(k, v)
1423     elif v == 'y'
1424       config_target_data.set(k, 1)
1425     else
1426       config_target_data.set(k, v)
1427     endif
1428   endforeach
1429   config_target_h += {target: configure_file(output: target + '-config-target.h',
1430                                                configuration: config_target_data)}
1431
1432   if target.endswith('-softmmu')
1433     config_devices_mak = target + '-config-devices.mak'
1434     config_devices_mak = configure_file(
1435       input: ['default-configs/devices' / target + '.mak', 'Kconfig'],
1436       output: config_devices_mak,
1437       depfile: config_devices_mak + '.d',
1438       capture: true,
1439       command: [minikconf,
1440                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
1441                 config_devices_mak, '@DEPFILE@', '@INPUT@',
1442                 host_kconfig, accel_kconfig])
1443
1444     config_devices_data = configuration_data()
1445     config_devices = keyval.load(config_devices_mak)
1446     foreach k, v: config_devices
1447       config_devices_data.set(k, 1)
1448     endforeach
1449     config_devices_mak_list += config_devices_mak
1450     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
1451                                                 configuration: config_devices_data)}
1452     config_target += config_devices
1453     config_all_devices += config_devices
1454   endif
1455   config_target_mak += {target: config_target}
1456 endforeach
1457 target_dirs = actual_target_dirs
1458
1459 # This configuration is used to build files that are shared by
1460 # multiple binaries, and then extracted out of the "common"
1461 # static_library target.
1462 #
1463 # We do not use all_sources()/all_dependencies(), because it would
1464 # build literally all source files, including devices only used by
1465 # targets that are not built for this compilation.  The CONFIG_ALL
1466 # pseudo symbol replaces it.
1467
1468 config_all += config_all_devices
1469 config_all += config_host
1470 config_all += config_all_disas
1471 config_all += {
1472   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
1473   'CONFIG_SOFTMMU': have_system,
1474   'CONFIG_USER_ONLY': have_user,
1475   'CONFIG_ALL': true,
1476 }
1477
1478 ##############
1479 # Submodules #
1480 ##############
1481
1482 capstone = not_found
1483 capstone_opt = get_option('capstone')
1484 if capstone_opt in ['enabled', 'auto', 'system']
1485   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
1486   capstone = dependency('capstone', version: '>=4.0',
1487                         kwargs: static_kwargs, method: 'pkg-config',
1488                         required: capstone_opt == 'system' or
1489                                   capstone_opt == 'enabled' and not have_internal)
1490   if capstone.found()
1491     capstone_opt = 'system'
1492   elif have_internal
1493     capstone_opt = 'internal'
1494   else
1495     capstone_opt = 'disabled'
1496   endif
1497 endif
1498 if capstone_opt == 'internal'
1499   capstone_data = configuration_data()
1500   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
1501
1502   capstone_files = files(
1503     'capstone/cs.c',
1504     'capstone/MCInst.c',
1505     'capstone/MCInstrDesc.c',
1506     'capstone/MCRegisterInfo.c',
1507     'capstone/SStream.c',
1508     'capstone/utils.c'
1509   )
1510
1511   if 'CONFIG_ARM_DIS' in config_all_disas
1512     capstone_data.set('CAPSTONE_HAS_ARM', '1')
1513     capstone_files += files(
1514       'capstone/arch/ARM/ARMDisassembler.c',
1515       'capstone/arch/ARM/ARMInstPrinter.c',
1516       'capstone/arch/ARM/ARMMapping.c',
1517       'capstone/arch/ARM/ARMModule.c'
1518     )
1519   endif
1520
1521   # FIXME: This config entry currently depends on a c++ compiler.
1522   # Which is needed for building libvixl, but not for capstone.
1523   if 'CONFIG_ARM_A64_DIS' in config_all_disas
1524     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
1525     capstone_files += files(
1526       'capstone/arch/AArch64/AArch64BaseInfo.c',
1527       'capstone/arch/AArch64/AArch64Disassembler.c',
1528       'capstone/arch/AArch64/AArch64InstPrinter.c',
1529       'capstone/arch/AArch64/AArch64Mapping.c',
1530       'capstone/arch/AArch64/AArch64Module.c'
1531     )
1532   endif
1533
1534   if 'CONFIG_PPC_DIS' in config_all_disas
1535     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
1536     capstone_files += files(
1537       'capstone/arch/PowerPC/PPCDisassembler.c',
1538       'capstone/arch/PowerPC/PPCInstPrinter.c',
1539       'capstone/arch/PowerPC/PPCMapping.c',
1540       'capstone/arch/PowerPC/PPCModule.c'
1541     )
1542   endif
1543
1544   if 'CONFIG_S390_DIS' in config_all_disas
1545     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
1546     capstone_files += files(
1547       'capstone/arch/SystemZ/SystemZDisassembler.c',
1548       'capstone/arch/SystemZ/SystemZInstPrinter.c',
1549       'capstone/arch/SystemZ/SystemZMapping.c',
1550       'capstone/arch/SystemZ/SystemZModule.c',
1551       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
1552     )
1553   endif
1554
1555   if 'CONFIG_I386_DIS' in config_all_disas
1556     capstone_data.set('CAPSTONE_HAS_X86', 1)
1557     capstone_files += files(
1558       'capstone/arch/X86/X86Disassembler.c',
1559       'capstone/arch/X86/X86DisassemblerDecoder.c',
1560       'capstone/arch/X86/X86ATTInstPrinter.c',
1561       'capstone/arch/X86/X86IntelInstPrinter.c',
1562       'capstone/arch/X86/X86InstPrinterCommon.c',
1563       'capstone/arch/X86/X86Mapping.c',
1564       'capstone/arch/X86/X86Module.c'
1565     )
1566   endif
1567
1568   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
1569
1570   capstone_cargs = [
1571     # FIXME: There does not seem to be a way to completely replace the c_args
1572     # that come from add_project_arguments() -- we can only add to them.
1573     # So: disable all warnings with a big hammer.
1574     '-Wno-error', '-w',
1575
1576     # Include all configuration defines via a header file, which will wind up
1577     # as a dependency on the object file, and thus changes here will result
1578     # in a rebuild.
1579     '-include', 'capstone-defs.h'
1580   ]
1581
1582   libcapstone = static_library('capstone',
1583                                build_by_default: false,
1584                                sources: capstone_files,
1585                                c_args: capstone_cargs,
1586                                include_directories: 'capstone/include')
1587   capstone = declare_dependency(link_with: libcapstone,
1588                                 include_directories: 'capstone/include/capstone')
1589 endif
1590
1591 slirp = not_found
1592 slirp_opt = 'disabled'
1593 if have_system
1594   slirp_opt = get_option('slirp')
1595   if slirp_opt in ['enabled', 'auto', 'system']
1596     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
1597     slirp = dependency('slirp', kwargs: static_kwargs,
1598                        method: 'pkg-config',
1599                        required: slirp_opt == 'system' or
1600                                  slirp_opt == 'enabled' and not have_internal)
1601     if slirp.found()
1602       slirp_opt = 'system'
1603     elif have_internal
1604       slirp_opt = 'internal'
1605     else
1606       slirp_opt = 'disabled'
1607     endif
1608   endif
1609   if slirp_opt == 'internal'
1610     slirp_deps = []
1611     if targetos == 'windows'
1612       slirp_deps = cc.find_library('iphlpapi')
1613     endif
1614     slirp_conf = configuration_data()
1615     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
1616     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
1617     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
1618     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
1619     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
1620     slirp_files = [
1621       'slirp/src/arp_table.c',
1622       'slirp/src/bootp.c',
1623       'slirp/src/cksum.c',
1624       'slirp/src/dhcpv6.c',
1625       'slirp/src/dnssearch.c',
1626       'slirp/src/if.c',
1627       'slirp/src/ip6_icmp.c',
1628       'slirp/src/ip6_input.c',
1629       'slirp/src/ip6_output.c',
1630       'slirp/src/ip_icmp.c',
1631       'slirp/src/ip_input.c',
1632       'slirp/src/ip_output.c',
1633       'slirp/src/mbuf.c',
1634       'slirp/src/misc.c',
1635       'slirp/src/ncsi.c',
1636       'slirp/src/ndp_table.c',
1637       'slirp/src/sbuf.c',
1638       'slirp/src/slirp.c',
1639       'slirp/src/socket.c',
1640       'slirp/src/state.c',
1641       'slirp/src/stream.c',
1642       'slirp/src/tcp_input.c',
1643       'slirp/src/tcp_output.c',
1644       'slirp/src/tcp_subr.c',
1645       'slirp/src/tcp_timer.c',
1646       'slirp/src/tftp.c',
1647       'slirp/src/udp.c',
1648       'slirp/src/udp6.c',
1649       'slirp/src/util.c',
1650       'slirp/src/version.c',
1651       'slirp/src/vmstate.c',
1652     ]
1653
1654     configure_file(
1655       input : 'slirp/src/libslirp-version.h.in',
1656       output : 'libslirp-version.h',
1657       configuration: slirp_conf)
1658
1659     slirp_inc = include_directories('slirp', 'slirp/src')
1660     libslirp = static_library('slirp',
1661                               build_by_default: false,
1662                               sources: slirp_files,
1663                               c_args: slirp_cargs,
1664                               include_directories: slirp_inc)
1665     slirp = declare_dependency(link_with: libslirp,
1666                                dependencies: slirp_deps,
1667                                include_directories: slirp_inc)
1668   endif
1669 endif
1670
1671 # For CFI, we need to compile slirp as a static library together with qemu.
1672 # This is because we register slirp functions as callbacks for QEMU Timers.
1673 # When using a system-wide shared libslirp, the type information for the
1674 # callback is missing and the timer call produces a false positive with CFI.
1675 #
1676 # Now that slirp_opt has been defined, check if the selected slirp is compatible
1677 # with control-flow integrity.
1678 if get_option('cfi') and slirp_opt == 'system'
1679   error('Control-Flow Integrity is not compatible with system-wide slirp.' \
1680          + ' Please configure with --enable-slirp=git')
1681 endif
1682
1683 fdt = not_found
1684 fdt_opt = get_option('fdt')
1685 if have_system
1686   if fdt_opt in ['enabled', 'auto', 'system']
1687     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
1688     fdt = cc.find_library('fdt', kwargs: static_kwargs,
1689                           required: fdt_opt == 'system' or
1690                                     fdt_opt == 'enabled' and not have_internal)
1691     if fdt.found() and cc.links('''
1692        #include <libfdt.h>
1693        #include <libfdt_env.h>
1694        int main(void) { fdt_check_full(NULL, 0); return 0; }''',
1695          dependencies: fdt)
1696       fdt_opt = 'system'
1697     elif have_internal
1698       fdt_opt = 'internal'
1699     else
1700       fdt_opt = 'disabled'
1701     endif
1702   endif
1703   if fdt_opt == 'internal'
1704     fdt_files = files(
1705       'dtc/libfdt/fdt.c',
1706       'dtc/libfdt/fdt_ro.c',
1707       'dtc/libfdt/fdt_wip.c',
1708       'dtc/libfdt/fdt_sw.c',
1709       'dtc/libfdt/fdt_rw.c',
1710       'dtc/libfdt/fdt_strerror.c',
1711       'dtc/libfdt/fdt_empty_tree.c',
1712       'dtc/libfdt/fdt_addresses.c',
1713       'dtc/libfdt/fdt_overlay.c',
1714       'dtc/libfdt/fdt_check.c',
1715     )
1716
1717     fdt_inc = include_directories('dtc/libfdt')
1718     libfdt = static_library('fdt',
1719                             build_by_default: false,
1720                             sources: fdt_files,
1721                             include_directories: fdt_inc)
1722     fdt = declare_dependency(link_with: libfdt,
1723                              include_directories: fdt_inc)
1724   endif
1725 endif
1726 if not fdt.found() and fdt_required.length() > 0
1727   error('fdt not available but required by targets ' + ', '.join(fdt_required))
1728 endif
1729
1730 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
1731 config_host_data.set('CONFIG_FDT', fdt.found())
1732 config_host_data.set('CONFIG_SLIRP', slirp.found())
1733
1734 #####################
1735 # Generated sources #
1736 #####################
1737
1738 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
1739
1740 hxtool = find_program('scripts/hxtool')
1741 shaderinclude = find_program('scripts/shaderinclude.pl')
1742 qapi_gen = find_program('scripts/qapi-gen.py')
1743 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
1744                      meson.source_root() / 'scripts/qapi/commands.py',
1745                      meson.source_root() / 'scripts/qapi/common.py',
1746                      meson.source_root() / 'scripts/qapi/error.py',
1747                      meson.source_root() / 'scripts/qapi/events.py',
1748                      meson.source_root() / 'scripts/qapi/expr.py',
1749                      meson.source_root() / 'scripts/qapi/gen.py',
1750                      meson.source_root() / 'scripts/qapi/introspect.py',
1751                      meson.source_root() / 'scripts/qapi/parser.py',
1752                      meson.source_root() / 'scripts/qapi/schema.py',
1753                      meson.source_root() / 'scripts/qapi/source.py',
1754                      meson.source_root() / 'scripts/qapi/types.py',
1755                      meson.source_root() / 'scripts/qapi/visit.py',
1756                      meson.source_root() / 'scripts/qapi/common.py',
1757                      meson.source_root() / 'scripts/qapi-gen.py'
1758 ]
1759
1760 tracetool = [
1761   python, files('scripts/tracetool.py'),
1762    '--backend=' + config_host['TRACE_BACKENDS']
1763 ]
1764 tracetool_depends = files(
1765   'scripts/tracetool/backend/log.py',
1766   'scripts/tracetool/backend/__init__.py',
1767   'scripts/tracetool/backend/dtrace.py',
1768   'scripts/tracetool/backend/ftrace.py',
1769   'scripts/tracetool/backend/simple.py',
1770   'scripts/tracetool/backend/syslog.py',
1771   'scripts/tracetool/backend/ust.py',
1772   'scripts/tracetool/format/tcg_h.py',
1773   'scripts/tracetool/format/ust_events_c.py',
1774   'scripts/tracetool/format/ust_events_h.py',
1775   'scripts/tracetool/format/__init__.py',
1776   'scripts/tracetool/format/d.py',
1777   'scripts/tracetool/format/tcg_helper_c.py',
1778   'scripts/tracetool/format/simpletrace_stap.py',
1779   'scripts/tracetool/format/c.py',
1780   'scripts/tracetool/format/h.py',
1781   'scripts/tracetool/format/tcg_helper_h.py',
1782   'scripts/tracetool/format/log_stap.py',
1783   'scripts/tracetool/format/stap.py',
1784   'scripts/tracetool/format/tcg_helper_wrapper_h.py',
1785   'scripts/tracetool/__init__.py',
1786   'scripts/tracetool/transform.py',
1787   'scripts/tracetool/vcpu.py'
1788 )
1789
1790 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
1791                     meson.current_source_dir(),
1792                     config_host['PKGVERSION'], meson.project_version()]
1793 qemu_version = custom_target('qemu-version.h',
1794                              output: 'qemu-version.h',
1795                              command: qemu_version_cmd,
1796                              capture: true,
1797                              build_by_default: true,
1798                              build_always_stale: true)
1799 genh += qemu_version
1800
1801 hxdep = []
1802 hx_headers = [
1803   ['qemu-options.hx', 'qemu-options.def'],
1804   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
1805 ]
1806 if have_system
1807   hx_headers += [
1808     ['hmp-commands.hx', 'hmp-commands.h'],
1809     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
1810   ]
1811 endif
1812 foreach d : hx_headers
1813   hxdep += custom_target(d[1],
1814                 input: files(d[0]),
1815                 output: d[1],
1816                 capture: true,
1817                 build_by_default: true, # to be removed when added to a target
1818                 command: [hxtool, '-h', '@INPUT0@'])
1819 endforeach
1820 genh += hxdep
1821
1822 ###################
1823 # Collect sources #
1824 ###################
1825
1826 authz_ss = ss.source_set()
1827 blockdev_ss = ss.source_set()
1828 block_ss = ss.source_set()
1829 bsd_user_ss = ss.source_set()
1830 chardev_ss = ss.source_set()
1831 common_ss = ss.source_set()
1832 crypto_ss = ss.source_set()
1833 io_ss = ss.source_set()
1834 linux_user_ss = ss.source_set()
1835 qmp_ss = ss.source_set()
1836 qom_ss = ss.source_set()
1837 softmmu_ss = ss.source_set()
1838 specific_fuzz_ss = ss.source_set()
1839 specific_ss = ss.source_set()
1840 stub_ss = ss.source_set()
1841 trace_ss = ss.source_set()
1842 user_ss = ss.source_set()
1843 util_ss = ss.source_set()
1844
1845 modules = {}
1846 hw_arch = {}
1847 target_arch = {}
1848 target_softmmu_arch = {}
1849 target_user_arch = {}
1850
1851 ###############
1852 # Trace files #
1853 ###############
1854
1855 # TODO: add each directory to the subdirs from its own meson.build, once
1856 # we have those
1857 trace_events_subdirs = [
1858   'crypto',
1859   'qapi',
1860   'qom',
1861   'monitor',
1862   'util',
1863 ]
1864 if have_user
1865   trace_events_subdirs += [ 'linux-user' ]
1866 endif
1867 if have_block
1868   trace_events_subdirs += [
1869     'authz',
1870     'block',
1871     'io',
1872     'nbd',
1873     'scsi',
1874   ]
1875 endif
1876 if have_system
1877   trace_events_subdirs += [
1878     'accel/kvm',
1879     'audio',
1880     'backends',
1881     'backends/tpm',
1882     'chardev',
1883     'ebpf',
1884     'hw/9pfs',
1885     'hw/acpi',
1886     'hw/adc',
1887     'hw/alpha',
1888     'hw/arm',
1889     'hw/audio',
1890     'hw/block',
1891     'hw/block/dataplane',
1892     'hw/char',
1893     'hw/display',
1894     'hw/dma',
1895     'hw/hppa',
1896     'hw/hyperv',
1897     'hw/i2c',
1898     'hw/i386',
1899     'hw/i386/xen',
1900     'hw/ide',
1901     'hw/input',
1902     'hw/intc',
1903     'hw/isa',
1904     'hw/mem',
1905     'hw/mips',
1906     'hw/misc',
1907     'hw/misc/macio',
1908     'hw/net',
1909     'hw/net/can',
1910     'hw/nvme',
1911     'hw/nvram',
1912     'hw/pci',
1913     'hw/pci-host',
1914     'hw/ppc',
1915     'hw/rdma',
1916     'hw/rdma/vmw',
1917     'hw/rtc',
1918     'hw/s390x',
1919     'hw/scsi',
1920     'hw/sd',
1921     'hw/sparc',
1922     'hw/sparc64',
1923     'hw/ssi',
1924     'hw/timer',
1925     'hw/tpm',
1926     'hw/usb',
1927     'hw/vfio',
1928     'hw/virtio',
1929     'hw/watchdog',
1930     'hw/xen',
1931     'hw/gpio',
1932     'migration',
1933     'net',
1934     'softmmu',
1935     'ui',
1936     'hw/remote',
1937   ]
1938 endif
1939 if have_system or have_user
1940   trace_events_subdirs += [
1941     'accel/tcg',
1942     'hw/core',
1943     'target/arm',
1944     'target/hppa',
1945     'target/i386',
1946     'target/i386/kvm',
1947     'target/mips',
1948     'target/ppc',
1949     'target/riscv',
1950     'target/s390x',
1951     'target/sparc',
1952   ]
1953 endif
1954
1955 vhost_user = not_found
1956 if 'CONFIG_VHOST_USER' in config_host
1957   libvhost_user = subproject('libvhost-user')
1958   vhost_user = libvhost_user.get_variable('vhost_user_dep')
1959 endif
1960
1961 subdir('qapi')
1962 subdir('qobject')
1963 subdir('stubs')
1964 subdir('trace')
1965 subdir('util')
1966 subdir('qom')
1967 subdir('authz')
1968 subdir('crypto')
1969 subdir('ui')
1970
1971
1972 if enable_modules
1973   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
1974   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
1975 endif
1976
1977 stub_ss = stub_ss.apply(config_all, strict: false)
1978
1979 util_ss.add_all(trace_ss)
1980 util_ss = util_ss.apply(config_all, strict: false)
1981 libqemuutil = static_library('qemuutil',
1982                              sources: util_ss.sources() + stub_ss.sources() + genh,
1983                              dependencies: [util_ss.dependencies(), libm, glib, socket, malloc, pixman])
1984 qemuutil = declare_dependency(link_with: libqemuutil,
1985                               sources: genh + version_res)
1986
1987 if have_system or have_user
1988   decodetree = generator(find_program('scripts/decodetree.py'),
1989                          output: 'decode-@BASENAME@.c.inc',
1990                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
1991   subdir('libdecnumber')
1992   subdir('target')
1993 endif
1994
1995 subdir('audio')
1996 subdir('io')
1997 subdir('chardev')
1998 subdir('fsdev')
1999 subdir('dump')
2000
2001 if have_block
2002   block_ss.add(files(
2003     'block.c',
2004     'blockjob.c',
2005     'job.c',
2006     'qemu-io-cmds.c',
2007   ))
2008   block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
2009
2010   subdir('nbd')
2011   subdir('scsi')
2012   subdir('block')
2013
2014   blockdev_ss.add(files(
2015     'blockdev.c',
2016     'blockdev-nbd.c',
2017     'iothread.c',
2018     'job-qmp.c',
2019   ), gnutls)
2020
2021   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2022   # os-win32.c does not
2023   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2024   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2025 endif
2026
2027 common_ss.add(files('cpus-common.c'))
2028
2029 subdir('softmmu')
2030
2031 common_ss.add(capstone)
2032 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2033
2034 # Work around a gcc bug/misfeature wherein constant propagation looks
2035 # through an alias:
2036 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2037 # to guess that a const variable is always zero.  Without lto, this is
2038 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
2039 # without lto, not even the alias is required -- we simply use different
2040 # declarations in different compilation units.
2041 pagevary = files('page-vary-common.c')
2042 if get_option('b_lto')
2043   pagevary_flags = ['-fno-lto']
2044   if get_option('cfi')
2045     pagevary_flags += '-fno-sanitize=cfi-icall'
2046   endif
2047   pagevary = static_library('page-vary-common', sources: pagevary,
2048                             c_args: pagevary_flags)
2049   pagevary = declare_dependency(link_with: pagevary)
2050 endif
2051 common_ss.add(pagevary)
2052 specific_ss.add(files('page-vary.c'))
2053
2054 subdir('backends')
2055 subdir('disas')
2056 subdir('migration')
2057 subdir('monitor')
2058 subdir('net')
2059 subdir('replay')
2060 subdir('semihosting')
2061 subdir('hw')
2062 subdir('tcg')
2063 subdir('fpu')
2064 subdir('accel')
2065 subdir('plugins')
2066 subdir('bsd-user')
2067 subdir('linux-user')
2068 subdir('ebpf')
2069
2070 common_ss.add(libbpf)
2071
2072 bsd_user_ss.add(files('gdbstub.c'))
2073 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
2074
2075 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
2076 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
2077
2078 # needed for fuzzing binaries
2079 subdir('tests/qtest/libqos')
2080 subdir('tests/qtest/fuzz')
2081
2082 ########################
2083 # Library dependencies #
2084 ########################
2085
2086 block_mods = []
2087 softmmu_mods = []
2088 foreach d, list : modules
2089   foreach m, module_ss : list
2090     if enable_modules and targetos != 'windows'
2091       module_ss = module_ss.apply(config_all, strict: false)
2092       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2093                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2094       if d == 'block'
2095         block_mods += sl
2096       else
2097         softmmu_mods += sl
2098       endif
2099     else
2100       if d == 'block'
2101         block_ss.add_all(module_ss)
2102       else
2103         softmmu_ss.add_all(module_ss)
2104       endif
2105     endif
2106   endforeach
2107 endforeach
2108
2109 nm = find_program('nm')
2110 undefsym = find_program('scripts/undefsym.py')
2111 block_syms = custom_target('block.syms', output: 'block.syms',
2112                              input: [libqemuutil, block_mods],
2113                              capture: true,
2114                              command: [undefsym, nm, '@INPUT@'])
2115 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2116                              input: [libqemuutil, softmmu_mods],
2117                              capture: true,
2118                              command: [undefsym, nm, '@INPUT@'])
2119
2120 qom_ss = qom_ss.apply(config_host, strict: false)
2121 libqom = static_library('qom', qom_ss.sources() + genh,
2122                         dependencies: [qom_ss.dependencies()],
2123                         name_suffix: 'fa')
2124
2125 qom = declare_dependency(link_whole: libqom)
2126
2127 authz_ss = authz_ss.apply(config_host, strict: false)
2128 libauthz = static_library('authz', authz_ss.sources() + genh,
2129                           dependencies: [authz_ss.dependencies()],
2130                           name_suffix: 'fa',
2131                           build_by_default: false)
2132
2133 authz = declare_dependency(link_whole: libauthz,
2134                            dependencies: qom)
2135
2136 crypto_ss = crypto_ss.apply(config_host, strict: false)
2137 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2138                            dependencies: [crypto_ss.dependencies()],
2139                            name_suffix: 'fa',
2140                            build_by_default: false)
2141
2142 crypto = declare_dependency(link_whole: libcrypto,
2143                             dependencies: [authz, qom])
2144
2145 io_ss = io_ss.apply(config_host, strict: false)
2146 libio = static_library('io', io_ss.sources() + genh,
2147                        dependencies: [io_ss.dependencies()],
2148                        link_with: libqemuutil,
2149                        name_suffix: 'fa',
2150                        build_by_default: false)
2151
2152 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
2153
2154 libmigration = static_library('migration', sources: migration_files + genh,
2155                               name_suffix: 'fa',
2156                               build_by_default: false)
2157 migration = declare_dependency(link_with: libmigration,
2158                                dependencies: [zlib, qom, io])
2159 softmmu_ss.add(migration)
2160
2161 block_ss = block_ss.apply(config_host, strict: false)
2162 libblock = static_library('block', block_ss.sources() + genh,
2163                           dependencies: block_ss.dependencies(),
2164                           link_depends: block_syms,
2165                           name_suffix: 'fa',
2166                           build_by_default: false)
2167
2168 block = declare_dependency(link_whole: [libblock],
2169                            link_args: '@block.syms',
2170                            dependencies: [crypto, io])
2171
2172 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
2173 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
2174                              dependencies: blockdev_ss.dependencies(),
2175                              name_suffix: 'fa',
2176                              build_by_default: false)
2177
2178 blockdev = declare_dependency(link_whole: [libblockdev],
2179                               dependencies: [block])
2180
2181 qmp_ss = qmp_ss.apply(config_host, strict: false)
2182 libqmp = static_library('qmp', qmp_ss.sources() + genh,
2183                         dependencies: qmp_ss.dependencies(),
2184                         name_suffix: 'fa',
2185                         build_by_default: false)
2186
2187 qmp = declare_dependency(link_whole: [libqmp])
2188
2189 libchardev = static_library('chardev', chardev_ss.sources() + genh,
2190                             name_suffix: 'fa',
2191                             dependencies: [gnutls],
2192                             build_by_default: false)
2193
2194 chardev = declare_dependency(link_whole: libchardev)
2195
2196 libhwcore = static_library('hwcore', sources: hwcore_files + genh,
2197                            name_suffix: 'fa',
2198                            build_by_default: false)
2199 hwcore = declare_dependency(link_whole: libhwcore)
2200 common_ss.add(hwcore)
2201
2202 ###########
2203 # Targets #
2204 ###########
2205
2206 foreach m : block_mods + softmmu_mods
2207   shared_module(m.name(),
2208                 name_prefix: '',
2209                 link_whole: m,
2210                 install: true,
2211                 install_dir: qemu_moddir)
2212 endforeach
2213
2214 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
2215 common_ss.add(qom, qemuutil)
2216
2217 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
2218 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
2219
2220 common_all = common_ss.apply(config_all, strict: false)
2221 common_all = static_library('common',
2222                             build_by_default: false,
2223                             sources: common_all.sources() + genh,
2224                             implicit_include_directories: false,
2225                             dependencies: common_all.dependencies(),
2226                             name_suffix: 'fa')
2227
2228 feature_to_c = find_program('scripts/feature_to_c.sh')
2229
2230 emulators = {}
2231 foreach target : target_dirs
2232   config_target = config_target_mak[target]
2233   target_name = config_target['TARGET_NAME']
2234   arch = config_target['TARGET_BASE_ARCH']
2235   arch_srcs = [config_target_h[target]]
2236   arch_deps = []
2237   c_args = ['-DNEED_CPU_H',
2238             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2239             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2240   link_args = emulator_link_args
2241
2242   config_target += config_host
2243   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2244   if targetos == 'linux'
2245     target_inc += include_directories('linux-headers', is_system: true)
2246   endif
2247   if target.endswith('-softmmu')
2248     qemu_target_name = 'qemu-system-' + target_name
2249     target_type='system'
2250     t = target_softmmu_arch[arch].apply(config_target, strict: false)
2251     arch_srcs += t.sources()
2252     arch_deps += t.dependencies()
2253
2254     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
2255     hw = hw_arch[hw_dir].apply(config_target, strict: false)
2256     arch_srcs += hw.sources()
2257     arch_deps += hw.dependencies()
2258
2259     arch_srcs += config_devices_h[target]
2260     link_args += ['@block.syms', '@qemu.syms']
2261   else
2262     abi = config_target['TARGET_ABI_DIR']
2263     target_type='user'
2264     qemu_target_name = 'qemu-' + target_name
2265     if arch in target_user_arch
2266       t = target_user_arch[arch].apply(config_target, strict: false)
2267       arch_srcs += t.sources()
2268       arch_deps += t.dependencies()
2269     endif
2270     if 'CONFIG_LINUX_USER' in config_target
2271       base_dir = 'linux-user'
2272       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
2273     else
2274       base_dir = 'bsd-user'
2275       target_inc += include_directories('bsd-user/freebsd')
2276     endif
2277     target_inc += include_directories(
2278       base_dir,
2279       base_dir / abi,
2280     )
2281     if 'CONFIG_LINUX_USER' in config_target
2282       dir = base_dir / abi
2283       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
2284       if config_target.has_key('TARGET_SYSTBL_ABI')
2285         arch_srcs += \
2286           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
2287                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
2288       endif
2289     endif
2290   endif
2291
2292   if 'TARGET_XML_FILES' in config_target
2293     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
2294                                 output: target + '-gdbstub-xml.c',
2295                                 input: files(config_target['TARGET_XML_FILES'].split()),
2296                                 command: [feature_to_c, '@INPUT@'],
2297                                 capture: true)
2298     arch_srcs += gdbstub_xml
2299   endif
2300
2301   t = target_arch[arch].apply(config_target, strict: false)
2302   arch_srcs += t.sources()
2303   arch_deps += t.dependencies()
2304
2305   target_common = common_ss.apply(config_target, strict: false)
2306   objects = common_all.extract_objects(target_common.sources())
2307   deps = target_common.dependencies()
2308
2309   target_specific = specific_ss.apply(config_target, strict: false)
2310   arch_srcs += target_specific.sources()
2311   arch_deps += target_specific.dependencies()
2312
2313   lib = static_library('qemu-' + target,
2314                  sources: arch_srcs + genh,
2315                  dependencies: arch_deps,
2316                  objects: objects,
2317                  include_directories: target_inc,
2318                  c_args: c_args,
2319                  build_by_default: false,
2320                  name_suffix: 'fa')
2321
2322   if target.endswith('-softmmu')
2323     execs = [{
2324       'name': 'qemu-system-' + target_name,
2325       'gui': false,
2326       'sources': files('softmmu/main.c'),
2327       'dependencies': []
2328     }]
2329     if targetos == 'windows' and (sdl.found() or gtk.found())
2330       execs += [{
2331         'name': 'qemu-system-' + target_name + 'w',
2332         'gui': true,
2333         'sources': files('softmmu/main.c'),
2334         'dependencies': []
2335       }]
2336     endif
2337     if config_host.has_key('CONFIG_FUZZ')
2338       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
2339       execs += [{
2340         'name': 'qemu-fuzz-' + target_name,
2341         'gui': false,
2342         'sources': specific_fuzz.sources(),
2343         'dependencies': specific_fuzz.dependencies(),
2344       }]
2345     endif
2346   else
2347     execs = [{
2348       'name': 'qemu-' + target_name,
2349       'gui': false,
2350       'sources': [],
2351       'dependencies': []
2352     }]
2353   endif
2354   foreach exe: execs
2355     exe_name = exe['name']
2356     exe_sign = 'CONFIG_HVF' in config_target
2357     if exe_sign
2358       exe_name += '-unsigned'
2359     endif
2360
2361     emulator = executable(exe_name, exe['sources'],
2362                install: true,
2363                c_args: c_args,
2364                dependencies: arch_deps + deps + exe['dependencies'],
2365                objects: lib.extract_all_objects(recursive: true),
2366                link_language: link_language,
2367                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
2368                link_args: link_args,
2369                gui_app: exe['gui'])
2370
2371     if exe_sign
2372       emulators += {exe['name'] : custom_target(exe['name'],
2373                    depends: emulator,
2374                    output: exe['name'],
2375                    command: [
2376                      meson.current_source_dir() / 'scripts/entitlement.sh',
2377                      meson.current_build_dir() / exe_name,
2378                      meson.current_build_dir() / exe['name'],
2379                      meson.current_source_dir() / 'accel/hvf/entitlements.plist'
2380                    ])
2381       }
2382
2383       meson.add_install_script('scripts/entitlement.sh', '--install',
2384                                get_option('bindir') / exe_name,
2385                                get_option('bindir') / exe['name'],
2386                                meson.current_source_dir() / 'accel/hvf/entitlements.plist')
2387     else
2388       emulators += {exe['name']: emulator}
2389     endif
2390
2391     if 'CONFIG_TRACE_SYSTEMTAP' in config_host
2392       foreach stp: [
2393         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
2394         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
2395         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
2396         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
2397       ]
2398         custom_target(exe['name'] + stp['ext'],
2399                       input: trace_events_all,
2400                       output: exe['name'] + stp['ext'],
2401                       install: stp['install'],
2402                       install_dir: get_option('datadir') / 'systemtap/tapset',
2403                       command: [
2404                         tracetool, '--group=all', '--format=' + stp['fmt'],
2405                         '--binary=' + stp['bin'],
2406                         '--target-name=' + target_name,
2407                         '--target-type=' + target_type,
2408                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
2409                         '@INPUT@', '@OUTPUT@'
2410                       ],
2411                       depend_files: tracetool_depends)
2412       endforeach
2413     endif
2414   endforeach
2415 endforeach
2416
2417 # Other build targets
2418
2419 if 'CONFIG_PLUGIN' in config_host
2420   install_headers('include/qemu/qemu-plugin.h')
2421 endif
2422
2423 if 'CONFIG_GUEST_AGENT' in config_host
2424   subdir('qga')
2425 elif get_option('guest_agent_msi').enabled()
2426   error('Guest agent MSI requested, but the guest agent is not being built')
2427 endif
2428
2429 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
2430 # when we don't build tools or system
2431 if xkbcommon.found()
2432   # used for the update-keymaps target, so include rules even if !have_tools
2433   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
2434                            dependencies: [qemuutil, xkbcommon], install: have_tools)
2435 endif
2436
2437 if have_tools
2438   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
2439              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
2440   qemu_io = executable('qemu-io', files('qemu-io.c'),
2441              dependencies: [block, qemuutil], install: true)
2442   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
2443                dependencies: [blockdev, qemuutil, gnutls], install: true)
2444
2445   subdir('storage-daemon')
2446   subdir('contrib/rdmacm-mux')
2447   subdir('contrib/elf2dmp')
2448
2449   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
2450              dependencies: qemuutil,
2451              install: true)
2452
2453   if 'CONFIG_VHOST_USER' in config_host
2454     subdir('contrib/vhost-user-blk')
2455     subdir('contrib/vhost-user-gpu')
2456     subdir('contrib/vhost-user-input')
2457     subdir('contrib/vhost-user-scsi')
2458   endif
2459
2460   if targetos == 'linux'
2461     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
2462                dependencies: [qemuutil, libcap_ng],
2463                install: true,
2464                install_dir: get_option('libexecdir'))
2465
2466     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
2467                dependencies: [authz, crypto, io, qom, qemuutil,
2468                               libcap_ng, mpathpersist],
2469                install: true)
2470   endif
2471
2472   if 'CONFIG_IVSHMEM' in config_host
2473     subdir('contrib/ivshmem-client')
2474     subdir('contrib/ivshmem-server')
2475   endif
2476 endif
2477
2478 subdir('scripts')
2479 subdir('tools')
2480 subdir('pc-bios')
2481 subdir('docs')
2482 subdir('tests')
2483 if gtk.found()
2484   subdir('po')
2485 endif
2486
2487 if host_machine.system() == 'windows'
2488   nsis_cmd = [
2489     find_program('scripts/nsis.py'),
2490     '@OUTPUT@',
2491     get_option('prefix'),
2492     meson.current_source_dir(),
2493     host_machine.cpu(),
2494     '--',
2495     '-DDISPLAYVERSION=' + meson.project_version(),
2496   ]
2497   if build_docs
2498     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
2499   endif
2500   if gtk.found()
2501     nsis_cmd += '-DCONFIG_GTK=y'
2502   endif
2503
2504   nsis = custom_target('nsis',
2505                        output: 'qemu-setup-' + meson.project_version() + '.exe',
2506                        input: files('qemu.nsi'),
2507                        build_always_stale: true,
2508                        command: nsis_cmd + ['@INPUT@'])
2509   alias_target('installer', nsis)
2510 endif
2511
2512 #########################
2513 # Configuration summary #
2514 #########################
2515
2516 # Directories
2517 summary_info = {}
2518 summary_info += {'Install prefix':    get_option('prefix')}
2519 summary_info += {'BIOS directory':    qemu_datadir}
2520 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
2521 summary_info += {'binary directory':  get_option('bindir')}
2522 summary_info += {'library directory': get_option('libdir')}
2523 summary_info += {'module directory':  qemu_moddir}
2524 summary_info += {'libexec directory': get_option('libexecdir')}
2525 summary_info += {'include directory': get_option('includedir')}
2526 summary_info += {'config directory':  get_option('sysconfdir')}
2527 if targetos != 'windows'
2528   summary_info += {'local state directory': get_option('localstatedir')}
2529   summary_info += {'Manual directory':      get_option('mandir')}
2530 else
2531   summary_info += {'local state directory': 'queried at runtime'}
2532 endif
2533 summary_info += {'Doc directory':     get_option('docdir')}
2534 summary_info += {'Build directory':   meson.current_build_dir()}
2535 summary_info += {'Source path':       meson.current_source_dir()}
2536 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
2537 summary(summary_info, bool_yn: true, section: 'Directories')
2538
2539 # Host binaries
2540 summary_info = {}
2541 summary_info += {'git':               config_host['GIT']}
2542 summary_info += {'make':              config_host['MAKE']}
2543 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
2544 summary_info += {'sphinx-build':      sphinx_build.found()}
2545 if config_host.has_key('HAVE_GDB_BIN')
2546   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
2547 endif
2548 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
2549 if targetos == 'windows' and config_host.has_key('CONFIG_GUEST_AGENT')
2550   summary_info += {'wixl':            wixl.found() ? wixl.full_path() : false}
2551 endif
2552 if slirp_opt != 'disabled' and 'CONFIG_SLIRP_SMBD' in config_host
2553   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
2554 endif
2555 summary(summary_info, bool_yn: true, section: 'Host binaries')
2556
2557 # Configurable features
2558 summary_info = {}
2559 summary_info += {'Documentation':     build_docs}
2560 summary_info += {'system-mode emulation': have_system}
2561 summary_info += {'user-mode emulation': have_user}
2562 summary_info += {'block layer':       have_block}
2563 summary_info += {'Install blobs':     get_option('install_blobs')}
2564 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
2565 if config_host.has_key('CONFIG_MODULES')
2566   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
2567 endif
2568 summary_info += {'plugin support':    config_host.has_key('CONFIG_PLUGIN')}
2569 summary_info += {'fuzzing support':   config_host.has_key('CONFIG_FUZZ')}
2570 if have_system
2571   summary_info += {'Audio drivers':     config_host['CONFIG_AUDIO_DRIVERS']}
2572 endif
2573 summary_info += {'Trace backends':    config_host['TRACE_BACKENDS']}
2574 if config_host['TRACE_BACKENDS'].split().contains('simple')
2575   summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
2576 endif
2577 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
2578 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
2579 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
2580 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
2581 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
2582 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
2583 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
2584 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
2585 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
2586 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
2587 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
2588 summary(summary_info, bool_yn: true, section: 'Configurable features')
2589
2590 # Compilation information
2591 summary_info = {}
2592 summary_info += {'host CPU':          cpu}
2593 summary_info += {'host endianness':   build_machine.endian()}
2594 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
2595 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
2596 if link_language == 'cpp'
2597   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
2598 else
2599   summary_info += {'C++ compiler':      false}
2600 endif
2601 if targetos == 'darwin'
2602   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
2603 endif
2604 if targetos == 'windows'
2605   if 'WIN_SDK' in config_host
2606     summary_info += {'Windows SDK':   config_host['WIN_SDK']}
2607   endif
2608 endif
2609 summary_info += {'ARFLAGS':           config_host['ARFLAGS']}
2610 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
2611                                                + ['-O' + get_option('optimization')]
2612                                                + (get_option('debug') ? ['-g'] : []))}
2613 if link_language == 'cpp'
2614   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
2615                                                + ['-O' + get_option('optimization')]
2616                                                + (get_option('debug') ? ['-g'] : []))}
2617 endif
2618 link_args = get_option(link_language + '_link_args')
2619 if link_args.length() > 0
2620   summary_info += {'LDFLAGS':         ' '.join(link_args)}
2621 endif
2622 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
2623 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
2624 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
2625 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
2626 summary_info += {'PIE':               get_option('b_pie')}
2627 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
2628 summary_info += {'malloc trim support': has_malloc_trim}
2629 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
2630 summary_info += {'fdatasync':         config_host.has_key('CONFIG_FDATASYNC')}
2631 summary_info += {'madvise':           config_host.has_key('CONFIG_MADVISE')}
2632 summary_info += {'posix_madvise':     config_host.has_key('CONFIG_POSIX_MADVISE')}
2633 summary_info += {'posix_memalign':    config_host.has_key('CONFIG_POSIX_MEMALIGN')}
2634 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
2635 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
2636 summary_info += {'memory allocator':  get_option('malloc')}
2637 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
2638 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
2639 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
2640 summary_info += {'gcov':              get_option('b_coverage')}
2641 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
2642 summary_info += {'CFI support':       get_option('cfi')}
2643 if get_option('cfi')
2644   summary_info += {'CFI debug support': get_option('cfi_debug')}
2645 endif
2646 summary_info += {'strip binaries':    get_option('strip')}
2647 summary_info += {'sparse':            sparse.found() ? sparse.full_path() : false}
2648 summary_info += {'mingw32 support':   targetos == 'windows'}
2649
2650 # snarf the cross-compilation information for tests
2651 foreach target: target_dirs
2652   tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
2653   if fs.exists(tcg_mak)
2654     config_cross_tcg = keyval.load(tcg_mak)
2655     target = config_cross_tcg['TARGET_NAME']
2656     compiler = ''
2657     if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
2658       summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
2659                                           ' via ' + config_cross_tcg['DOCKER_IMAGE']}
2660     elif 'CROSS_CC_GUEST' in config_cross_tcg
2661       summary_info += {target + ' tests'
2662                                 : config_cross_tcg['CROSS_CC_GUEST'] }
2663     endif
2664    endif
2665 endforeach
2666
2667 summary(summary_info, bool_yn: true, section: 'Compilation')
2668
2669 # Targets and accelerators
2670 summary_info = {}
2671 if have_system
2672   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
2673   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
2674   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
2675   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
2676   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
2677   summary_info += {'Xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
2678   if config_host.has_key('CONFIG_XEN_BACKEND')
2679     summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
2680   endif
2681 endif
2682 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
2683 if config_all.has_key('CONFIG_TCG')
2684   if get_option('tcg_interpreter')
2685     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, experimental and slow)'}
2686   else
2687     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
2688   endif
2689   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
2690 endif
2691 summary_info += {'target list':       ' '.join(target_dirs)}
2692 if have_system
2693   summary_info += {'default devices':   get_option('default_devices')}
2694   summary_info += {'out of process emulation': multiprocess_allowed}
2695 endif
2696 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
2697
2698 # Block layer
2699 summary_info = {}
2700 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
2701 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
2702 if have_block
2703   summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
2704   summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
2705   summary_info += {'VirtFS support':    have_virtfs}
2706   summary_info += {'build virtiofs daemon': have_virtiofsd}
2707   summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
2708   summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
2709   summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
2710   summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
2711   summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
2712   summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
2713   summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
2714   summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
2715   summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
2716   summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
2717   summary_info += {'FUSE exports':      fuse.found()}
2718 endif
2719 summary(summary_info, bool_yn: true, section: 'Block layer support')
2720
2721 # Crypto
2722 summary_info = {}
2723 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
2724 summary_info += {'GNUTLS support':    gnutls.found()}
2725 # TODO: add back version
2726 summary_info += {'libgcrypt':         gcrypt.found()}
2727 if gcrypt.found()
2728    summary_info += {'  XTS':             xts != 'private'}
2729 endif
2730 # TODO: add back version
2731 summary_info += {'nettle':            nettle.found()}
2732 if nettle.found()
2733    summary_info += {'  XTS':             xts != 'private'}
2734 endif
2735 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
2736 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
2737 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
2738 summary(summary_info, bool_yn: true, section: 'Crypto')
2739
2740 # Libraries
2741 summary_info = {}
2742 if targetos == 'darwin'
2743   summary_info += {'Cocoa support':   cocoa.found()}
2744 endif
2745 # TODO: add back version
2746 summary_info += {'SDL support':       sdl.found()}
2747 summary_info += {'SDL image support': sdl_image.found()}
2748 # TODO: add back version
2749 summary_info += {'GTK support':       gtk.found()}
2750 summary_info += {'pixman':            pixman.found()}
2751 # TODO: add back version
2752 summary_info += {'VTE support':       config_host.has_key('CONFIG_VTE')}
2753 # TODO: add back version
2754 summary_info += {'slirp support':     slirp_opt == 'disabled' ? false : slirp_opt}
2755 summary_info += {'libtasn1':          tasn1.found()}
2756 summary_info += {'PAM':               pam.found()}
2757 summary_info += {'iconv support':     iconv.found()}
2758 summary_info += {'curses support':    curses.found()}
2759 # TODO: add back version
2760 summary_info += {'virgl support':     config_host.has_key('CONFIG_VIRGL')}
2761 summary_info += {'curl support':      curl.found()}
2762 summary_info += {'Multipath support': mpathpersist.found()}
2763 summary_info += {'VNC support':       vnc.found()}
2764 if vnc.found()
2765   summary_info += {'VNC SASL support':  sasl.found()}
2766   summary_info += {'VNC JPEG support':  jpeg.found()}
2767   summary_info += {'VNC PNG support':   png.found()}
2768 endif
2769 summary_info += {'brlapi support':    brlapi.found()}
2770 summary_info += {'vde support':       config_host.has_key('CONFIG_VDE')}
2771 summary_info += {'netmap support':    config_host.has_key('CONFIG_NETMAP')}
2772 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
2773 summary_info += {'Linux io_uring support': config_host.has_key('CONFIG_LINUX_IO_URING')}
2774 summary_info += {'ATTR/XATTR support': libattr.found()}
2775 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
2776 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
2777 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
2778 summary_info += {'libcap-ng support': libcap_ng.found()}
2779 summary_info += {'bpf support': libbpf.found()}
2780 # TODO: add back protocol and server version
2781 summary_info += {'spice support':     config_host.has_key('CONFIG_SPICE')}
2782 summary_info += {'rbd support':       rbd.found()}
2783 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
2784 summary_info += {'smartcard support': config_host.has_key('CONFIG_SMARTCARD')}
2785 summary_info += {'U2F support':       u2f.found()}
2786 summary_info += {'libusb':            libusb.found()}
2787 summary_info += {'usb net redir':     config_host.has_key('CONFIG_USB_REDIR')}
2788 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
2789 summary_info += {'GBM':               config_host.has_key('CONFIG_GBM')}
2790 summary_info += {'libiscsi support':  libiscsi.found()}
2791 summary_info += {'libnfs support':    libnfs.found()}
2792 if targetos == 'windows'
2793   if config_host.has_key('CONFIG_GUEST_AGENT')
2794     summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
2795     summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
2796   endif
2797 endif
2798 summary_info += {'seccomp support':   seccomp.found()}
2799 summary_info += {'GlusterFS support': glusterfs.found()}
2800 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
2801 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
2802 summary_info += {'lzo support':       lzo.found()}
2803 summary_info += {'snappy support':    snappy.found()}
2804 summary_info += {'bzip2 support':     libbzip2.found()}
2805 summary_info += {'lzfse support':     liblzfse.found()}
2806 summary_info += {'zstd support':      zstd.found()}
2807 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
2808 summary_info += {'libxml2':           config_host.has_key('CONFIG_LIBXML2')}
2809 summary_info += {'capstone':          capstone_opt == 'disabled' ? false : capstone_opt}
2810 summary_info += {'libpmem support':   config_host.has_key('CONFIG_LIBPMEM')}
2811 summary_info += {'libdaxctl support': config_host.has_key('CONFIG_LIBDAXCTL')}
2812 summary_info += {'libudev':           libudev.found()}
2813 summary_info += {'FUSE lseek':        fuse_lseek.found()}
2814 summary(summary_info, bool_yn: true, section: 'Dependencies')
2815
2816 if not supported_cpus.contains(cpu)
2817   message()
2818   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
2819   message()
2820   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
2821   message('The QEMU project intends to remove support for this host CPU in')
2822   message('a future release if nobody volunteers to maintain it and to')
2823   message('provide a build host for our continuous integration setup.')
2824   message('configure has succeeded and you can continue to build, but')
2825   message('if you care about QEMU on this platform you should contact')
2826   message('us upstream at qemu-devel@nongnu.org.')
2827 endif
2828
2829 if not supported_oses.contains(targetos)
2830   message()
2831   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
2832   message()
2833   message('Host OS ' + targetos + 'support is not currently maintained.')
2834   message('The QEMU project intends to remove support for this host OS in')
2835   message('a future release if nobody volunteers to maintain it and to')
2836   message('provide a build host for our continuous integration setup.')
2837   message('configure has succeeded and you can continue to build, but')
2838   message('if you care about QEMU on this platform you should contact')
2839   message('us upstream at qemu-devel@nongnu.org.')
2840 endif