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