meson.build

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