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