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 'CONFIG_BRLAPI' in config_host
 578   brlapi = declare_dependency(link_args: config_host['BRLAPI_LIBS'].split())
 579 endif
 580
 581 sdl = not_found
 582 if have_system
 583   sdl = dependency('sdl2', required: get_option('sdl'), static: enable_static)
 584   sdl_image = not_found
 585 endif
 586 if sdl.found()
 587   # work around 2.0.8 bug
 588   sdl = declare_dependency(compile_args: '-Wno-undef',
 589                            dependencies: sdl)
 590   sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
 591                          method: 'pkg-config', static: enable_static)
 592 else
 593   if get_option('sdl_image').enabled()
 594     error('sdl-image required, but SDL was @0@'.format(
 595           get_option('sdl').disabled() ? 'disabled' : 'not found'))
 596   endif
 597   sdl_image = not_found
 598 endif
 599
 600 rbd = not_found
 601 if 'CONFIG_RBD' in config_host
 602   rbd = declare_dependency(link_args: config_host['RBD_LIBS'].split())
 603 endif
 604 glusterfs = not_found
 605 if 'CONFIG_GLUSTERFS' in config_host
 606   glusterfs = declare_dependency(compile_args: config_host['GLUSTERFS_CFLAGS'].split(),
 607                                  link_args: config_host['GLUSTERFS_LIBS'].split())
 608 endif
 609 libssh = not_found
 610 if 'CONFIG_LIBSSH' in config_host
 611   libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
 612                               link_args: config_host['LIBSSH_LIBS'].split())
 613 endif
 614 libbzip2 = not_found
 615 if 'CONFIG_BZIP2' in config_host
 616   libbzip2 = declare_dependency(link_args: config_host['BZIP2_LIBS'].split())
 617 endif
 618 liblzfse = not_found
 619 if 'CONFIG_LZFSE' in config_host
 620   liblzfse = declare_dependency(link_args: config_host['LZFSE_LIBS'].split())
 621 endif
 622 oss = not_found
 623 if 'CONFIG_AUDIO_OSS' in config_host
 624   oss = declare_dependency(link_args: config_host['OSS_LIBS'].split())
 625 endif
 626 dsound = not_found
 627 if 'CONFIG_AUDIO_DSOUND' in config_host
 628   dsound = declare_dependency(link_args: config_host['DSOUND_LIBS'].split())
 629 endif
 630 coreaudio = not_found
 631 if 'CONFIG_AUDIO_COREAUDIO' in config_host
 632   coreaudio = declare_dependency(link_args: config_host['COREAUDIO_LIBS'].split())
 633 endif
 634 opengl = not_found
 635 if 'CONFIG_OPENGL' in config_host
 636   opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
 637                               link_args: config_host['OPENGL_LIBS'].split())
 638 endif
 639 gtk = not_found
 640 if 'CONFIG_GTK' in config_host
 641   gtk = declare_dependency(compile_args: config_host['GTK_CFLAGS'].split(),
 642                               link_args: config_host['GTK_LIBS'].split())
 643 endif
 644 vte = not_found
 645 if 'CONFIG_VTE' in config_host
 646   vte = declare_dependency(compile_args: config_host['VTE_CFLAGS'].split(),
 647                            link_args: config_host['VTE_LIBS'].split())
 648 endif
 649 x11 = not_found
 650 if 'CONFIG_X11' in config_host
 651   x11 = declare_dependency(compile_args: config_host['X11_CFLAGS'].split(),
 652                            link_args: config_host['X11_LIBS'].split())
 653 endif
 654 vnc = not_found
 655 png = not_found
 656 jpeg = not_found
 657 sasl = not_found
 658 if get_option('vnc').enabled()
 659   vnc = declare_dependency() # dummy dependency
 660   png = dependency('libpng', required: get_option('vnc_png'),
 661                    method: 'pkg-config', static: enable_static)
 662   jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
 663                     method: 'pkg-config', static: enable_static)
 664   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
 665                          required: get_option('vnc_sasl'),
 666                          static: enable_static)
 667   if sasl.found()
 668     sasl = declare_dependency(dependencies: sasl,
 669                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
 670   endif
 671 endif
 672 snappy = not_found
 673 if 'CONFIG_SNAPPY' in config_host
 674   snappy = declare_dependency(link_args: config_host['SNAPPY_LIBS'].split())
 675 endif
 676 lzo = not_found
 677 if 'CONFIG_LZO' in config_host
 678   lzo = declare_dependency(link_args: config_host['LZO_LIBS'].split())
 679 endif
 680 rdma = not_found
 681 if 'CONFIG_RDMA' in config_host
 682   rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
 683 endif
 684 numa = not_found
 685 if 'CONFIG_NUMA' in config_host
 686   numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
 687 endif
 688 xen = not_found
 689 if 'CONFIG_XEN_BACKEND' in config_host
 690   xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
 691                            link_args: config_host['XEN_LIBS'].split())
 692 endif
 693 cacard = not_found
 694 if 'CONFIG_SMARTCARD' in config_host
 695   cacard = declare_dependency(compile_args: config_host['SMARTCARD_CFLAGS'].split(),
 696                               link_args: config_host['SMARTCARD_LIBS'].split())
 697 endif
 698 u2f = not_found
 699 if have_system
 700   u2f = dependency('u2f-emu', required: get_option('u2f'),
 701                    method: 'pkg-config',
 702                    static: enable_static)
 703 endif
 704 usbredir = not_found
 705 if 'CONFIG_USB_REDIR' in config_host
 706   usbredir = declare_dependency(compile_args: config_host['USB_REDIR_CFLAGS'].split(),
 707                                 link_args: config_host['USB_REDIR_LIBS'].split())
 708 endif
 709 libusb = not_found
 710 if 'CONFIG_USB_LIBUSB' in config_host
 711   libusb = declare_dependency(compile_args: config_host['LIBUSB_CFLAGS'].split(),
 712                               link_args: config_host['LIBUSB_LIBS'].split())
 713 endif
 714 libpmem = not_found
 715 if 'CONFIG_LIBPMEM' in config_host
 716   libpmem = declare_dependency(compile_args: config_host['LIBPMEM_CFLAGS'].split(),
 717                                link_args: config_host['LIBPMEM_LIBS'].split())
 718 endif
 719 libdaxctl = not_found
 720 if 'CONFIG_LIBDAXCTL' in config_host
 721   libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split())
 722 endif
 723 tasn1 = not_found
 724 if 'CONFIG_TASN1' in config_host
 725   tasn1 = declare_dependency(compile_args: config_host['TASN1_CFLAGS'].split(),
 726                              link_args: config_host['TASN1_LIBS'].split())
 727 endif
 728 keyutils = dependency('libkeyutils', required: false,
 729                       method: 'pkg-config', static: enable_static)
 730
 731 has_gettid = cc.has_function('gettid')
 732
 733 # Malloc tests
 734
 735 malloc = []
 736 if get_option('malloc') == 'system'
 737   has_malloc_trim = \
 738     not get_option('malloc_trim').disabled() and \
 739     cc.links('''#include <malloc.h>
 740                 int main(void) { malloc_trim(0); return 0; }''')
 741 else
 742   has_malloc_trim = false
 743   malloc = cc.find_library(get_option('malloc'), required: true)
 744 endif
 745 if not has_malloc_trim and get_option('malloc_trim').enabled()
 746   if get_option('malloc') == 'system'
 747     error('malloc_trim not available on this platform.')
 748   else
 749     error('malloc_trim not available with non-libc memory allocator')
 750   endif
 751 endif
 752
 753 # Check whether the glibc provides statx()
 754
 755 statx_test = '''
 756   #ifndef _GNU_SOURCE
 757   #define _GNU_SOURCE
 758   #endif
 759   #include <sys/stat.h>
 760   int main(void) {
 761     struct statx statxbuf;
 762     statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
 763     return 0;
 764   }'''
 765
 766 has_statx = cc.links(statx_test)
 767
 768 have_vhost_user_blk_server = (targetos == 'linux' and
 769     'CONFIG_VHOST_USER' in config_host)
 770
 771 if get_option('vhost_user_blk_server').enabled()
 772     if targetos != 'linux'
 773         error('vhost_user_blk_server requires linux')
 774     elif 'CONFIG_VHOST_USER' not in config_host
 775         error('vhost_user_blk_server requires vhost-user support')
 776     endif
 777 elif get_option('vhost_user_blk_server').disabled() or not have_system
 778     have_vhost_user_blk_server = false
 779 endif
 780
 781
 782 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
 783   error('Cannot enable fuse-lseek while fuse is disabled')
 784 endif
 785
 786 fuse = dependency('fuse3', required: get_option('fuse'),
 787                   version: '>=3.1', method: 'pkg-config',
 788                   static: enable_static)
 789
 790 fuse_lseek = not_found
 791 if not get_option('fuse_lseek').disabled()
 792   if fuse.version().version_compare('>=3.8')
 793     # Dummy dependency
 794     fuse_lseek = declare_dependency()
 795   elif get_option('fuse_lseek').enabled()
 796     if fuse.found()
 797       error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
 798     else
 799       error('fuse-lseek requires libfuse, which was not found')
 800     endif
 801   endif
 802 endif
 803
 804 if get_option('cfi')
 805   cfi_flags=[]
 806   # Check for dependency on LTO
 807   if not get_option('b_lto')
 808     error('Selected Control-Flow Integrity but LTO is disabled')
 809   endif
 810   if config_host.has_key('CONFIG_MODULES')
 811     error('Selected Control-Flow Integrity is not compatible with modules')
 812   endif
 813   # Check for cfi flags. CFI requires LTO so we can't use
 814   # get_supported_arguments, but need a more complex "compiles" which allows
 815   # custom arguments
 816   if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
 817                  args: ['-flto', '-fsanitize=cfi-icall'] )
 818     cfi_flags += '-fsanitize=cfi-icall'
 819   else
 820     error('-fsanitize=cfi-icall is not supported by the compiler')
 821   endif
 822   if cc.compiles('int main () { return 0; }',
 823                  name: '-fsanitize-cfi-icall-generalize-pointers',
 824                  args: ['-flto', '-fsanitize=cfi-icall',
 825                         '-fsanitize-cfi-icall-generalize-pointers'] )
 826     cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
 827   else
 828     error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
 829   endif
 830   if get_option('cfi_debug')
 831     if cc.compiles('int main () { return 0; }',
 832                    name: '-fno-sanitize-trap=cfi-icall',
 833                    args: ['-flto', '-fsanitize=cfi-icall',
 834                           '-fno-sanitize-trap=cfi-icall'] )
 835       cfi_flags += '-fno-sanitize-trap=cfi-icall'
 836     else
 837       error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
 838     endif
 839   endif
 840   add_project_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
 841   add_project_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
 842 endif
 843
 844 #################
 845 # config-host.h #
 846 #################
 847
 848 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
 849 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
 850 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
 851 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
 852 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
 853 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
 854 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
 855 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
 856 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
 857 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
 858 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
 859 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
 860
 861 config_host_data.set('CONFIG_COCOA', cocoa.found())
 862 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
 863 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
 864 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
 865 config_host_data.set('CONFIG_CURSES', curses.found())
 866 config_host_data.set('CONFIG_SDL', sdl.found())
 867 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
 868 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
 869 config_host_data.set('CONFIG_VNC', vnc.found())
 870 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
 871 config_host_data.set('CONFIG_VNC_PNG', png.found())
 872 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
 873 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
 874 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
 875 config_host_data.set('CONFIG_GETTID', has_gettid)
 876 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
 877 config_host_data.set('CONFIG_STATX', has_statx)
 878 config_host_data.set('CONFIG_FUSE', fuse.found())
 879 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
 880 config_host_data.set('CONFIG_CFI', get_option('cfi'))
 881 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
 882 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
 883 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
 884 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
 885
 886 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
 887 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
 888 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
 889 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
 890 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
 891 config_host_data.set('HAVE_SYS_SIGNAL_H', cc.has_header('sys/signal.h'))
 892
 893 ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target
 894 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
 895 strings = ['HOST_DSOSUF', 'CONFIG_IASL']
 896 foreach k, v: config_host
 897   if ignored.contains(k)
 898     # do nothing
 899   elif arrays.contains(k)
 900     if v != ''
 901       v = '"' + '", "'.join(v.split()) + '", '
 902     endif
 903     config_host_data.set(k, v)
 904   elif k == 'ARCH'
 905     config_host_data.set('HOST_' + v.to_upper(), 1)
 906   elif strings.contains(k)
 907     if not k.startswith('CONFIG_')
 908       k = 'CONFIG_' + k.to_upper()
 909     endif
 910     config_host_data.set_quoted(k, v)
 911   elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
 912     config_host_data.set(k, v == 'y' ? 1 : v)
 913   endif
 914 endforeach
 915
 916 ########################
 917 # Target configuration #
 918 ########################
 919
 920 minikconf = find_program('scripts/minikconf.py')
 921 config_all = {}
 922 config_all_devices = {}
 923 config_all_disas = {}
 924 config_devices_mak_list = []
 925 config_devices_h = {}
 926 config_target_h = {}
 927 config_target_mak = {}
 928
 929 disassemblers = {
 930   'alpha' : ['CONFIG_ALPHA_DIS'],
 931   'arm' : ['CONFIG_ARM_DIS'],
 932   'avr' : ['CONFIG_AVR_DIS'],
 933   'cris' : ['CONFIG_CRIS_DIS'],
 934   'hppa' : ['CONFIG_HPPA_DIS'],
 935   'i386' : ['CONFIG_I386_DIS'],
 936   'x86_64' : ['CONFIG_I386_DIS'],
 937   'x32' : ['CONFIG_I386_DIS'],
 938   'lm32' : ['CONFIG_LM32_DIS'],
 939   'm68k' : ['CONFIG_M68K_DIS'],
 940   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
 941   'mips' : ['CONFIG_MIPS_DIS'],
 942   'moxie' : ['CONFIG_MOXIE_DIS'],
 943   'nios2' : ['CONFIG_NIOS2_DIS'],
 944   'or1k' : ['CONFIG_OPENRISC_DIS'],
 945   'ppc' : ['CONFIG_PPC_DIS'],
 946   'riscv' : ['CONFIG_RISCV_DIS'],
 947   'rx' : ['CONFIG_RX_DIS'],
 948   's390' : ['CONFIG_S390_DIS'],
 949   'sh4' : ['CONFIG_SH4_DIS'],
 950   'sparc' : ['CONFIG_SPARC_DIS'],
 951   'xtensa' : ['CONFIG_XTENSA_DIS'],
 952 }
 953 if link_language == 'cpp'
 954   disassemblers += {
 955     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
 956     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
 957     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
 958   }
 959 endif
 960
 961 host_kconfig = \
 962   ('CONFIG_TPM' in config_host ? ['CONFIG_TPM=y'] : []) + \
 963   ('CONFIG_SPICE' in config_host ? ['CONFIG_SPICE=y'] : []) + \
 964   ('CONFIG_IVSHMEM' in config_host ? ['CONFIG_IVSHMEM=y'] : []) + \
 965   ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
 966   ('CONFIG_X11' in config_host ? ['CONFIG_X11=y'] : []) + \
 967   ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
 968   ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
 969   ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
 970   ('CONFIG_VIRTFS' in config_host ? ['CONFIG_VIRTFS=y'] : []) + \
 971   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
 972   ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : [])
 973
 974 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
 975
 976 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
 977 actual_target_dirs = []
 978 fdt_required = []
 979 foreach target : target_dirs
 980   config_target = { 'TARGET_NAME': target.split('-')[0] }
 981   if target.endswith('linux-user')
 982     if targetos != 'linux'
 983       if default_targets
 984         continue
 985       endif
 986       error('Target @0@ is only available on a Linux host'.format(target))
 987     endif
 988     config_target += { 'CONFIG_LINUX_USER': 'y' }
 989   elif target.endswith('bsd-user')
 990     if 'CONFIG_BSD' not in config_host
 991       if default_targets
 992         continue
 993       endif
 994       error('Target @0@ is only available on a BSD host'.format(target))
 995     endif
 996     config_target += { 'CONFIG_BSD_USER': 'y' }
 997   elif target.endswith('softmmu')
 998     config_target += { 'CONFIG_SOFTMMU': 'y' }
 999   endif
1000   if target.endswith('-user')
1001     config_target += {
1002       'CONFIG_USER_ONLY': 'y',
1003       'CONFIG_QEMU_INTERP_PREFIX':
1004         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
1005     }
1006   endif
1007
1008   accel_kconfig = []
1009   foreach sym: accelerators
1010     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
1011       config_target += { sym: 'y' }
1012       config_all += { sym: 'y' }
1013       if sym == 'CONFIG_XEN' and have_xen_pci_passthrough
1014         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
1015       endif
1016       accel_kconfig += [ sym + '=y' ]
1017     endif
1018   endforeach
1019   if accel_kconfig.length() == 0
1020     if default_targets
1021       continue
1022     endif
1023     error('No accelerator available for target @0@'.format(target))
1024   endif
1025
1026   actual_target_dirs += target
1027   config_target += keyval.load('default-configs/targets' / target + '.mak')
1028   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
1029
1030   if 'TARGET_NEED_FDT' in config_target
1031     fdt_required += target
1032   endif
1033
1034   # Add default keys
1035   if 'TARGET_BASE_ARCH' not in config_target
1036     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
1037   endif
1038   if 'TARGET_ABI_DIR' not in config_target
1039     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
1040   endif
1041
1042   foreach k, v: disassemblers
1043     if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
1044       foreach sym: v
1045         config_target += { sym: 'y' }
1046         config_all_disas += { sym: 'y' }
1047       endforeach
1048     endif
1049   endforeach
1050
1051   config_target_data = configuration_data()
1052   foreach k, v: config_target
1053     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
1054       # do nothing
1055     elif ignored.contains(k)
1056       # do nothing
1057     elif k == 'TARGET_BASE_ARCH'
1058       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
1059       # not used to select files from sourcesets.
1060       config_target_data.set('TARGET_' + v.to_upper(), 1)
1061     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
1062       config_target_data.set_quoted(k, v)
1063     elif v == 'y'
1064       config_target_data.set(k, 1)
1065     else
1066       config_target_data.set(k, v)
1067     endif
1068   endforeach
1069   config_target_h += {target: configure_file(output: target + '-config-target.h',
1070                                                configuration: config_target_data)}
1071
1072   if target.endswith('-softmmu')
1073     config_devices_mak = target + '-config-devices.mak'
1074     config_devices_mak = configure_file(
1075       input: ['default-configs/devices' / target + '.mak', 'Kconfig'],
1076       output: config_devices_mak,
1077       depfile: config_devices_mak + '.d',
1078       capture: true,
1079       command: [minikconf, config_host['CONFIG_MINIKCONF_MODE'],
1080                 config_devices_mak, '@DEPFILE@', '@INPUT@',
1081                 host_kconfig, accel_kconfig])
1082
1083     config_devices_data = configuration_data()
1084     config_devices = keyval.load(config_devices_mak)
1085     foreach k, v: config_devices
1086       config_devices_data.set(k, 1)
1087     endforeach
1088     config_devices_mak_list += config_devices_mak
1089     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
1090                                                 configuration: config_devices_data)}
1091     config_target += config_devices
1092     config_all_devices += config_devices
1093   endif
1094   config_target_mak += {target: config_target}
1095 endforeach
1096 target_dirs = actual_target_dirs
1097
1098 # This configuration is used to build files that are shared by
1099 # multiple binaries, and then extracted out of the "common"
1100 # static_library target.
1101 #
1102 # We do not use all_sources()/all_dependencies(), because it would
1103 # build literally all source files, including devices only used by
1104 # targets that are not built for this compilation.  The CONFIG_ALL
1105 # pseudo symbol replaces it.
1106
1107 config_all += config_all_devices
1108 config_all += config_host
1109 config_all += config_all_disas
1110 config_all += {
1111   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
1112   'CONFIG_SOFTMMU': have_system,
1113   'CONFIG_USER_ONLY': have_user,
1114   'CONFIG_ALL': true,
1115 }
1116
1117 ##############
1118 # Submodules #
1119 ##############
1120
1121 capstone = not_found
1122 capstone_opt = get_option('capstone')
1123 if capstone_opt in ['enabled', 'auto', 'system']
1124   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
1125   capstone = dependency('capstone', version: '>=4.0',
1126                         static: enable_static, method: 'pkg-config',
1127                         required: capstone_opt == 'system' or
1128                                   capstone_opt == 'enabled' and not have_internal)
1129   if capstone.found()
1130     capstone_opt = 'system'
1131   elif have_internal
1132     capstone_opt = 'internal'
1133   else
1134     capstone_opt = 'disabled'
1135   endif
1136 endif
1137 if capstone_opt == 'internal'
1138   capstone_data = configuration_data()
1139   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
1140
1141   capstone_files = files(
1142     'capstone/cs.c',
1143     'capstone/MCInst.c',
1144     'capstone/MCInstrDesc.c',
1145     'capstone/MCRegisterInfo.c',
1146     'capstone/SStream.c',
1147     'capstone/utils.c'
1148   )
1149
1150   if 'CONFIG_ARM_DIS' in config_all_disas
1151     capstone_data.set('CAPSTONE_HAS_ARM', '1')
1152     capstone_files += files(
1153       'capstone/arch/ARM/ARMDisassembler.c',
1154       'capstone/arch/ARM/ARMInstPrinter.c',
1155       'capstone/arch/ARM/ARMMapping.c',
1156       'capstone/arch/ARM/ARMModule.c'
1157     )
1158   endif
1159
1160   # FIXME: This config entry currently depends on a c++ compiler.
1161   # Which is needed for building libvixl, but not for capstone.
1162   if 'CONFIG_ARM_A64_DIS' in config_all_disas
1163     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
1164     capstone_files += files(
1165       'capstone/arch/AArch64/AArch64BaseInfo.c',
1166       'capstone/arch/AArch64/AArch64Disassembler.c',
1167       'capstone/arch/AArch64/AArch64InstPrinter.c',
1168       'capstone/arch/AArch64/AArch64Mapping.c',
1169       'capstone/arch/AArch64/AArch64Module.c'
1170     )
1171   endif
1172
1173   if 'CONFIG_PPC_DIS' in config_all_disas
1174     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
1175     capstone_files += files(
1176       'capstone/arch/PowerPC/PPCDisassembler.c',
1177       'capstone/arch/PowerPC/PPCInstPrinter.c',
1178       'capstone/arch/PowerPC/PPCMapping.c',
1179       'capstone/arch/PowerPC/PPCModule.c'
1180     )
1181   endif
1182
1183   if 'CONFIG_S390_DIS' in config_all_disas
1184     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
1185     capstone_files += files(
1186       'capstone/arch/SystemZ/SystemZDisassembler.c',
1187       'capstone/arch/SystemZ/SystemZInstPrinter.c',
1188       'capstone/arch/SystemZ/SystemZMapping.c',
1189       'capstone/arch/SystemZ/SystemZModule.c',
1190       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
1191     )
1192   endif
1193
1194   if 'CONFIG_I386_DIS' in config_all_disas
1195     capstone_data.set('CAPSTONE_HAS_X86', 1)
1196     capstone_files += files(
1197       'capstone/arch/X86/X86Disassembler.c',
1198       'capstone/arch/X86/X86DisassemblerDecoder.c',
1199       'capstone/arch/X86/X86ATTInstPrinter.c',
1200       'capstone/arch/X86/X86IntelInstPrinter.c',
1201       'capstone/arch/X86/X86InstPrinterCommon.c',
1202       'capstone/arch/X86/X86Mapping.c',
1203       'capstone/arch/X86/X86Module.c'
1204     )
1205   endif
1206
1207   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
1208
1209   capstone_cargs = [
1210     # FIXME: There does not seem to be a way to completely replace the c_args
1211     # that come from add_project_arguments() -- we can only add to them.
1212     # So: disable all warnings with a big hammer.
1213     '-Wno-error', '-w',
1214
1215     # Include all configuration defines via a header file, which will wind up
1216     # as a dependency on the object file, and thus changes here will result
1217     # in a rebuild.
1218     '-include', 'capstone-defs.h'
1219   ]
1220
1221   libcapstone = static_library('capstone',
1222                                sources: capstone_files,
1223                                c_args: capstone_cargs,
1224                                include_directories: 'capstone/include')
1225   capstone = declare_dependency(link_with: libcapstone,
1226                                 include_directories: 'capstone/include/capstone')
1227 endif
1228
1229 slirp = not_found
1230 slirp_opt = 'disabled'
1231 if have_system
1232   slirp_opt = get_option('slirp')
1233   if slirp_opt in ['enabled', 'auto', 'system']
1234     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
1235     slirp = dependency('slirp', static: enable_static,
1236                        method: 'pkg-config',
1237                        required: slirp_opt == 'system' or
1238                                  slirp_opt == 'enabled' and not have_internal)
1239     if slirp.found()
1240       slirp_opt = 'system'
1241     elif have_internal
1242       slirp_opt = 'internal'
1243     else
1244       slirp_opt = 'disabled'
1245     endif
1246   endif
1247   if slirp_opt == 'internal'
1248     slirp_deps = []
1249     if targetos == 'windows'
1250       slirp_deps = cc.find_library('iphlpapi')
1251     endif
1252     slirp_conf = configuration_data()
1253     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
1254     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
1255     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
1256     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
1257     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
1258     slirp_files = [
1259       'slirp/src/arp_table.c',
1260       'slirp/src/bootp.c',
1261       'slirp/src/cksum.c',
1262       'slirp/src/dhcpv6.c',
1263       'slirp/src/dnssearch.c',
1264       'slirp/src/if.c',
1265       'slirp/src/ip6_icmp.c',
1266       'slirp/src/ip6_input.c',
1267       'slirp/src/ip6_output.c',
1268       'slirp/src/ip_icmp.c',
1269       'slirp/src/ip_input.c',
1270       'slirp/src/ip_output.c',
1271       'slirp/src/mbuf.c',
1272       'slirp/src/misc.c',
1273       'slirp/src/ncsi.c',
1274       'slirp/src/ndp_table.c',
1275       'slirp/src/sbuf.c',
1276       'slirp/src/slirp.c',
1277       'slirp/src/socket.c',
1278       'slirp/src/state.c',
1279       'slirp/src/stream.c',
1280       'slirp/src/tcp_input.c',
1281       'slirp/src/tcp_output.c',
1282       'slirp/src/tcp_subr.c',
1283       'slirp/src/tcp_timer.c',
1284       'slirp/src/tftp.c',
1285       'slirp/src/udp.c',
1286       'slirp/src/udp6.c',
1287       'slirp/src/util.c',
1288       'slirp/src/version.c',
1289       'slirp/src/vmstate.c',
1290     ]
1291
1292     configure_file(
1293       input : 'slirp/src/libslirp-version.h.in',
1294       output : 'libslirp-version.h',
1295       configuration: slirp_conf)
1296
1297     slirp_inc = include_directories('slirp', 'slirp/src')
1298     libslirp = static_library('slirp',
1299                               sources: slirp_files,
1300                               c_args: slirp_cargs,
1301                               include_directories: slirp_inc)
1302     slirp = declare_dependency(link_with: libslirp,
1303                                dependencies: slirp_deps,
1304                                include_directories: slirp_inc)
1305   endif
1306 endif
1307
1308 fdt = not_found
1309 fdt_opt = get_option('fdt')
1310 if have_system
1311   if fdt_opt in ['enabled', 'auto', 'system']
1312     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
1313     fdt = cc.find_library('fdt', static: enable_static,
1314                           required: fdt_opt == 'system' or
1315                                     fdt_opt == 'enabled' and not have_internal)
1316     if fdt.found() and cc.links('''
1317        #include <libfdt.h>
1318        #include <libfdt_env.h>
1319        int main(void) { fdt_check_full(NULL, 0); return 0; }''',
1320          dependencies: fdt)
1321       fdt_opt = 'system'
1322     elif have_internal
1323       fdt_opt = 'internal'
1324     else
1325       fdt_opt = 'disabled'
1326     endif
1327   endif
1328   if fdt_opt == 'internal'
1329     fdt_files = files(
1330       'dtc/libfdt/fdt.c',
1331       'dtc/libfdt/fdt_ro.c',
1332       'dtc/libfdt/fdt_wip.c',
1333       'dtc/libfdt/fdt_sw.c',
1334       'dtc/libfdt/fdt_rw.c',
1335       'dtc/libfdt/fdt_strerror.c',
1336       'dtc/libfdt/fdt_empty_tree.c',
1337       'dtc/libfdt/fdt_addresses.c',
1338       'dtc/libfdt/fdt_overlay.c',
1339       'dtc/libfdt/fdt_check.c',
1340     )
1341
1342     fdt_inc = include_directories('dtc/libfdt')
1343     libfdt = static_library('fdt',
1344                             sources: fdt_files,
1345                             include_directories: fdt_inc)
1346     fdt = declare_dependency(link_with: libfdt,
1347                              include_directories: fdt_inc)
1348   endif
1349 endif
1350 if not fdt.found() and fdt_required.length() > 0
1351   error('fdt not available but required by targets ' + ', '.join(fdt_required))
1352 endif
1353
1354 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
1355 config_host_data.set('CONFIG_FDT', fdt.found())
1356 config_host_data.set('CONFIG_SLIRP', slirp.found())
1357
1358 #####################
1359 # Generated sources #
1360 #####################
1361
1362 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
1363
1364 hxtool = find_program('scripts/hxtool')
1365 shaderinclude = find_program('scripts/shaderinclude.pl')
1366 qapi_gen = find_program('scripts/qapi-gen.py')
1367 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
1368                      meson.source_root() / 'scripts/qapi/commands.py',
1369                      meson.source_root() / 'scripts/qapi/common.py',
1370                      meson.source_root() / 'scripts/qapi/error.py',
1371                      meson.source_root() / 'scripts/qapi/events.py',
1372                      meson.source_root() / 'scripts/qapi/expr.py',
1373                      meson.source_root() / 'scripts/qapi/gen.py',
1374                      meson.source_root() / 'scripts/qapi/introspect.py',
1375                      meson.source_root() / 'scripts/qapi/parser.py',
1376                      meson.source_root() / 'scripts/qapi/schema.py',
1377                      meson.source_root() / 'scripts/qapi/source.py',
1378                      meson.source_root() / 'scripts/qapi/types.py',
1379                      meson.source_root() / 'scripts/qapi/visit.py',
1380                      meson.source_root() / 'scripts/qapi/common.py',
1381                      meson.source_root() / 'scripts/qapi-gen.py'
1382 ]
1383
1384 tracetool = [
1385   python, files('scripts/tracetool.py'),
1386    '--backend=' + config_host['TRACE_BACKENDS']
1387 ]
1388
1389 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
1390                     meson.current_source_dir(),
1391                     config_host['PKGVERSION'], meson.project_version()]
1392 qemu_version = custom_target('qemu-version.h',
1393                              output: 'qemu-version.h',
1394                              command: qemu_version_cmd,
1395                              capture: true,
1396                              build_by_default: true,
1397                              build_always_stale: true)
1398 genh += qemu_version
1399
1400 hxdep = []
1401 hx_headers = [
1402   ['qemu-options.hx', 'qemu-options.def'],
1403   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
1404 ]
1405 if have_system
1406   hx_headers += [
1407     ['hmp-commands.hx', 'hmp-commands.h'],
1408     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
1409   ]
1410 endif
1411 foreach d : hx_headers
1412   hxdep += custom_target(d[1],
1413                 input: files(d[0]),
1414                 output: d[1],
1415                 capture: true,
1416                 build_by_default: true, # to be removed when added to a target
1417                 command: [hxtool, '-h', '@INPUT0@'])
1418 endforeach
1419 genh += hxdep
1420
1421 ###################
1422 # Collect sources #
1423 ###################
1424
1425 authz_ss = ss.source_set()
1426 blockdev_ss = ss.source_set()
1427 block_ss = ss.source_set()
1428 bsd_user_ss = ss.source_set()
1429 chardev_ss = ss.source_set()
1430 common_ss = ss.source_set()
1431 crypto_ss = ss.source_set()
1432 io_ss = ss.source_set()
1433 linux_user_ss = ss.source_set()
1434 qmp_ss = ss.source_set()
1435 qom_ss = ss.source_set()
1436 softmmu_ss = ss.source_set()
1437 specific_fuzz_ss = ss.source_set()
1438 specific_ss = ss.source_set()
1439 stub_ss = ss.source_set()
1440 trace_ss = ss.source_set()
1441 user_ss = ss.source_set()
1442 util_ss = ss.source_set()
1443
1444 modules = {}
1445 hw_arch = {}
1446 target_arch = {}
1447 target_softmmu_arch = {}
1448
1449 ###############
1450 # Trace files #
1451 ###############
1452
1453 # TODO: add each directory to the subdirs from its own meson.build, once
1454 # we have those
1455 trace_events_subdirs = [
1456   'accel/kvm',
1457   'accel/tcg',
1458   'crypto',
1459   'monitor',
1460 ]
1461 if have_user
1462   trace_events_subdirs += [ 'linux-user' ]
1463 endif
1464 if have_block
1465   trace_events_subdirs += [
1466     'authz',
1467     'block',
1468     'io',
1469     'nbd',
1470     'scsi',
1471   ]
1472 endif
1473 if have_system
1474   trace_events_subdirs += [
1475     'audio',
1476     'backends',
1477     'backends/tpm',
1478     'chardev',
1479     'hw/9pfs',
1480     'hw/acpi',
1481     'hw/alpha',
1482     'hw/arm',
1483     'hw/audio',
1484     'hw/block',
1485     'hw/block/dataplane',
1486     'hw/char',
1487     'hw/display',
1488     'hw/dma',
1489     'hw/hppa',
1490     'hw/hyperv',
1491     'hw/i2c',
1492     'hw/i386',
1493     'hw/i386/xen',
1494     'hw/ide',
1495     'hw/input',
1496     'hw/intc',
1497     'hw/isa',
1498     'hw/mem',
1499     'hw/mips',
1500     'hw/misc',
1501     'hw/misc/macio',
1502     'hw/net',
1503     'hw/net/can',
1504     'hw/nvram',
1505     'hw/pci',
1506     'hw/pci-host',
1507     'hw/ppc',
1508     'hw/rdma',
1509     'hw/rdma/vmw',
1510     'hw/rtc',
1511     'hw/s390x',
1512     'hw/scsi',
1513     'hw/sd',
1514     'hw/sparc',
1515     'hw/sparc64',
1516     'hw/ssi',
1517     'hw/timer',
1518     'hw/tpm',
1519     'hw/usb',
1520     'hw/vfio',
1521     'hw/virtio',
1522     'hw/watchdog',
1523     'hw/xen',
1524     'hw/gpio',
1525     'migration',
1526     'net',
1527     'softmmu',
1528     'ui',
1529   ]
1530 endif
1531 trace_events_subdirs += [
1532   'hw/core',
1533   'qapi',
1534   'qom',
1535   'target/arm',
1536   'target/hppa',
1537   'target/i386',
1538   'target/i386/kvm',
1539   'target/mips',
1540   'target/ppc',
1541   'target/riscv',
1542   'target/s390x',
1543   'target/sparc',
1544   'util',
1545 ]
1546
1547 vhost_user = not_found
1548 if 'CONFIG_VHOST_USER' in config_host
1549   libvhost_user = subproject('libvhost-user')
1550   vhost_user = libvhost_user.get_variable('vhost_user_dep')
1551 endif
1552
1553 subdir('qapi')
1554 subdir('qobject')
1555 subdir('stubs')
1556 subdir('trace')
1557 subdir('util')
1558 subdir('qom')
1559 subdir('authz')
1560 subdir('crypto')
1561 subdir('ui')
1562
1563
1564 if enable_modules
1565   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
1566   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
1567 endif
1568
1569 stub_ss = stub_ss.apply(config_all, strict: false)
1570
1571 util_ss.add_all(trace_ss)
1572 util_ss = util_ss.apply(config_all, strict: false)
1573 libqemuutil = static_library('qemuutil',
1574                              sources: util_ss.sources() + stub_ss.sources() + genh,
1575                              dependencies: [util_ss.dependencies(), m, glib, socket, malloc])
1576 qemuutil = declare_dependency(link_with: libqemuutil,
1577                               sources: genh + version_res)
1578
1579 decodetree = generator(find_program('scripts/decodetree.py'),
1580                        output: 'decode-@BASENAME@.c.inc',
1581                        arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
1582
1583 subdir('audio')
1584 subdir('io')
1585 subdir('chardev')
1586 subdir('fsdev')
1587 subdir('libdecnumber')
1588 subdir('target')
1589 subdir('dump')
1590
1591 block_ss.add(files(
1592   'block.c',
1593   'blockjob.c',
1594   'job.c',
1595   'qemu-io-cmds.c',
1596 ))
1597 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
1598
1599 subdir('nbd')
1600 subdir('scsi')
1601 subdir('block')
1602
1603 blockdev_ss.add(files(
1604   'blockdev.c',
1605   'blockdev-nbd.c',
1606   'iothread.c',
1607   'job-qmp.c',
1608 ))
1609
1610 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
1611 # os-win32.c does not
1612 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
1613 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
1614
1615 common_ss.add(files('cpus-common.c'))
1616
1617 subdir('softmmu')
1618
1619 common_ss.add(capstone)
1620 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
1621 specific_ss.add(files('exec-vary.c'))
1622 specific_ss.add(when: 'CONFIG_TCG', if_true: files(
1623   'fpu/softfloat.c',
1624   'tcg/optimize.c',
1625   'tcg/tcg-common.c',
1626   'tcg/tcg-op-gvec.c',
1627   'tcg/tcg-op-vec.c',
1628   'tcg/tcg-op.c',
1629   'tcg/tcg.c',
1630 ))
1631 specific_ss.add(when: 'CONFIG_TCG_INTERPRETER', if_true: files('disas/tci.c', 'tcg/tci.c'))
1632
1633 subdir('backends')
1634 subdir('disas')
1635 subdir('migration')
1636 subdir('monitor')
1637 subdir('net')
1638 subdir('replay')
1639 subdir('hw')
1640 subdir('accel')
1641 subdir('plugins')
1642 subdir('bsd-user')
1643 subdir('linux-user')
1644
1645 bsd_user_ss.add(files('gdbstub.c'))
1646 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
1647
1648 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
1649 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
1650
1651 # needed for fuzzing binaries
1652 subdir('tests/qtest/libqos')
1653 subdir('tests/qtest/fuzz')
1654
1655 ########################
1656 # Library dependencies #
1657 ########################
1658
1659 block_mods = []
1660 softmmu_mods = []
1661 foreach d, list : modules
1662   foreach m, module_ss : list
1663     if enable_modules and targetos != 'windows'
1664       module_ss = module_ss.apply(config_all, strict: false)
1665       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
1666                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
1667       if d == 'block'
1668         block_mods += sl
1669       else
1670         softmmu_mods += sl
1671       endif
1672     else
1673       if d == 'block'
1674         block_ss.add_all(module_ss)
1675       else
1676         softmmu_ss.add_all(module_ss)
1677       endif
1678     endif
1679   endforeach
1680 endforeach
1681
1682 nm = find_program('nm')
1683 undefsym = find_program('scripts/undefsym.py')
1684 block_syms = custom_target('block.syms', output: 'block.syms',
1685                              input: [libqemuutil, block_mods],
1686                              capture: true,
1687                              command: [undefsym, nm, '@INPUT@'])
1688 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
1689                              input: [libqemuutil, softmmu_mods],
1690                              capture: true,
1691                              command: [undefsym, nm, '@INPUT@'])
1692
1693 qom_ss = qom_ss.apply(config_host, strict: false)
1694 libqom = static_library('qom', qom_ss.sources() + genh,
1695                         dependencies: [qom_ss.dependencies()],
1696                         name_suffix: 'fa')
1697
1698 qom = declare_dependency(link_whole: libqom)
1699
1700 authz_ss = authz_ss.apply(config_host, strict: false)
1701 libauthz = static_library('authz', authz_ss.sources() + genh,
1702                           dependencies: [authz_ss.dependencies()],
1703                           name_suffix: 'fa',
1704                           build_by_default: false)
1705
1706 authz = declare_dependency(link_whole: libauthz,
1707                            dependencies: qom)
1708
1709 crypto_ss = crypto_ss.apply(config_host, strict: false)
1710 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
1711                            dependencies: [crypto_ss.dependencies()],
1712                            name_suffix: 'fa',
1713                            build_by_default: false)
1714
1715 crypto = declare_dependency(link_whole: libcrypto,
1716                             dependencies: [authz, qom])
1717
1718 io_ss = io_ss.apply(config_host, strict: false)
1719 libio = static_library('io', io_ss.sources() + genh,
1720                        dependencies: [io_ss.dependencies()],
1721                        link_with: libqemuutil,
1722                        name_suffix: 'fa',
1723                        build_by_default: false)
1724
1725 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
1726
1727 libmigration = static_library('migration', sources: migration_files + genh,
1728                               name_suffix: 'fa',
1729                               build_by_default: false)
1730 migration = declare_dependency(link_with: libmigration,
1731                                dependencies: [zlib, qom, io])
1732 softmmu_ss.add(migration)
1733
1734 block_ss = block_ss.apply(config_host, strict: false)
1735 libblock = static_library('block', block_ss.sources() + genh,
1736                           dependencies: block_ss.dependencies(),
1737                           link_depends: block_syms,
1738                           name_suffix: 'fa',
1739                           build_by_default: false)
1740
1741 block = declare_dependency(link_whole: [libblock],
1742                            link_args: '@block.syms',
1743                            dependencies: [crypto, io])
1744
1745 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
1746 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
1747                              dependencies: blockdev_ss.dependencies(),
1748                              name_suffix: 'fa',
1749                              build_by_default: false)
1750
1751 blockdev = declare_dependency(link_whole: [libblockdev],
1752                               dependencies: [block])
1753
1754 qmp_ss = qmp_ss.apply(config_host, strict: false)
1755 libqmp = static_library('qmp', qmp_ss.sources() + genh,
1756                         dependencies: qmp_ss.dependencies(),
1757                         name_suffix: 'fa',
1758                         build_by_default: false)
1759
1760 qmp = declare_dependency(link_whole: [libqmp])
1761
1762 libchardev = static_library('chardev', chardev_ss.sources() + genh,
1763                             name_suffix: 'fa',
1764                             build_by_default: false)
1765
1766 chardev = declare_dependency(link_whole: libchardev)
1767
1768 libhwcore = static_library('hwcore', sources: hwcore_files + genh,
1769                            name_suffix: 'fa',
1770                            build_by_default: false)
1771 hwcore = declare_dependency(link_whole: libhwcore)
1772 common_ss.add(hwcore)
1773
1774 ###########
1775 # Targets #
1776 ###########
1777
1778 foreach m : block_mods + softmmu_mods
1779   shared_module(m.name(),
1780                 name_prefix: '',
1781                 link_whole: m,
1782                 install: true,
1783                 install_dir: qemu_moddir)
1784 endforeach
1785
1786 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
1787 common_ss.add(qom, qemuutil)
1788
1789 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
1790 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
1791
1792 common_all = common_ss.apply(config_all, strict: false)
1793 common_all = static_library('common',
1794                             build_by_default: false,
1795                             sources: common_all.sources() + genh,
1796                             dependencies: common_all.dependencies(),
1797                             name_suffix: 'fa')
1798
1799 feature_to_c = find_program('scripts/feature_to_c.sh')
1800
1801 emulators = {}
1802 foreach target : target_dirs
1803   config_target = config_target_mak[target]
1804   target_name = config_target['TARGET_NAME']
1805   arch = config_target['TARGET_BASE_ARCH']
1806   arch_srcs = [config_target_h[target]]
1807   arch_deps = []
1808   c_args = ['-DNEED_CPU_H',
1809             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
1810             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
1811   link_args = emulator_link_args
1812
1813   config_target += config_host
1814   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
1815   if targetos == 'linux'
1816     target_inc += include_directories('linux-headers', is_system: true)
1817   endif
1818   if target.endswith('-softmmu')
1819     qemu_target_name = 'qemu-system-' + target_name
1820     target_type='system'
1821     t = target_softmmu_arch[arch].apply(config_target, strict: false)
1822     arch_srcs += t.sources()
1823     arch_deps += t.dependencies()
1824
1825     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
1826     hw = hw_arch[hw_dir].apply(config_target, strict: false)
1827     arch_srcs += hw.sources()
1828     arch_deps += hw.dependencies()
1829
1830     arch_srcs += config_devices_h[target]
1831     link_args += ['@block.syms', '@qemu.syms']
1832   else
1833     abi = config_target['TARGET_ABI_DIR']
1834     target_type='user'
1835     qemu_target_name = 'qemu-' + target_name
1836     if 'CONFIG_LINUX_USER' in config_target
1837       base_dir = 'linux-user'
1838       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
1839     else
1840       base_dir = 'bsd-user'
1841     endif
1842     target_inc += include_directories(
1843       base_dir,
1844       base_dir / abi,
1845     )
1846     if 'CONFIG_LINUX_USER' in config_target
1847       dir = base_dir / abi
1848       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
1849       if config_target.has_key('TARGET_SYSTBL_ABI')
1850         arch_srcs += \
1851           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
1852                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
1853       endif
1854     endif
1855   endif
1856
1857   if 'TARGET_XML_FILES' in config_target
1858     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
1859                                 output: target + '-gdbstub-xml.c',
1860                                 input: files(config_target['TARGET_XML_FILES'].split()),
1861                                 command: [feature_to_c, '@INPUT@'],
1862                                 capture: true)
1863     arch_srcs += gdbstub_xml
1864   endif
1865
1866   t = target_arch[arch].apply(config_target, strict: false)
1867   arch_srcs += t.sources()
1868   arch_deps += t.dependencies()
1869
1870   target_common = common_ss.apply(config_target, strict: false)
1871   objects = common_all.extract_objects(target_common.sources())
1872   deps = target_common.dependencies()
1873
1874   target_specific = specific_ss.apply(config_target, strict: false)
1875   arch_srcs += target_specific.sources()
1876   arch_deps += target_specific.dependencies()
1877
1878   lib = static_library('qemu-' + target,
1879                  sources: arch_srcs + genh,
1880                  dependencies: arch_deps,
1881                  objects: objects,
1882                  include_directories: target_inc,
1883                  c_args: c_args,
1884                  build_by_default: false,
1885                  name_suffix: 'fa')
1886
1887   if target.endswith('-softmmu')
1888     execs = [{
1889       'name': 'qemu-system-' + target_name,
1890       'gui': false,
1891       'sources': files('softmmu/main.c'),
1892       'dependencies': []
1893     }]
1894     if targetos == 'windows' and (sdl.found() or gtk.found())
1895       execs += [{
1896         'name': 'qemu-system-' + target_name + 'w',
1897         'gui': true,
1898         'sources': files('softmmu/main.c'),
1899         'dependencies': []
1900       }]
1901     endif
1902     if config_host.has_key('CONFIG_FUZZ')
1903       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
1904       execs += [{
1905         'name': 'qemu-fuzz-' + target_name,
1906         'gui': false,
1907         'sources': specific_fuzz.sources(),
1908         'dependencies': specific_fuzz.dependencies(),
1909       }]
1910     endif
1911   else
1912     execs = [{
1913       'name': 'qemu-' + target_name,
1914       'gui': false,
1915       'sources': [],
1916       'dependencies': []
1917     }]
1918   endif
1919   foreach exe: execs
1920     emulators += {exe['name']:
1921          executable(exe['name'], exe['sources'],
1922                install: true,
1923                c_args: c_args,
1924                dependencies: arch_deps + deps + exe['dependencies'],
1925                objects: lib.extract_all_objects(recursive: true),
1926                link_language: link_language,
1927                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
1928                link_args: link_args,
1929                gui_app: exe['gui'])
1930     }
1931
1932     if 'CONFIG_TRACE_SYSTEMTAP' in config_host
1933       foreach stp: [
1934         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
1935         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
1936         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
1937         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
1938       ]
1939         custom_target(exe['name'] + stp['ext'],
1940                       input: trace_events_all,
1941                       output: exe['name'] + stp['ext'],
1942                       capture: true,
1943                       install: stp['install'],
1944                       install_dir: get_option('datadir') / 'systemtap/tapset',
1945                       command: [
1946                         tracetool, '--group=all', '--format=' + stp['fmt'],
1947                         '--binary=' + stp['bin'],
1948                         '--target-name=' + target_name,
1949                         '--target-type=' + target_type,
1950                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
1951                         '@INPUT@',
1952                       ])
1953       endforeach
1954     endif
1955   endforeach
1956 endforeach
1957
1958 # Other build targets
1959
1960 if 'CONFIG_PLUGIN' in config_host
1961   install_headers('include/qemu/qemu-plugin.h')
1962 endif
1963
1964 if 'CONFIG_GUEST_AGENT' in config_host
1965   subdir('qga')
1966 endif
1967
1968 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
1969 # when we don't build tools or system
1970 if xkbcommon.found()
1971   # used for the update-keymaps target, so include rules even if !have_tools
1972   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
1973                            dependencies: [qemuutil, xkbcommon], install: have_tools)
1974 endif
1975
1976 if have_tools
1977   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
1978              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
1979   qemu_io = executable('qemu-io', files('qemu-io.c'),
1980              dependencies: [block, qemuutil], install: true)
1981   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
1982                dependencies: [blockdev, qemuutil], install: true)
1983
1984   subdir('storage-daemon')
1985   subdir('contrib/rdmacm-mux')
1986   subdir('contrib/elf2dmp')
1987
1988   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
1989              dependencies: qemuutil,
1990              install: true)
1991
1992   if 'CONFIG_VHOST_USER' in config_host
1993     subdir('contrib/vhost-user-blk')
1994     subdir('contrib/vhost-user-gpu')
1995     subdir('contrib/vhost-user-input')
1996     subdir('contrib/vhost-user-scsi')
1997   endif
1998
1999   if targetos == 'linux'
2000     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
2001                dependencies: [qemuutil, libcap_ng],
2002                install: true,
2003                install_dir: get_option('libexecdir'))
2004
2005     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
2006                dependencies: [authz, crypto, io, qom, qemuutil,
2007                               libcap_ng, mpathpersist],
2008                install: true)
2009   endif
2010
2011   if 'CONFIG_IVSHMEM' in config_host
2012     subdir('contrib/ivshmem-client')
2013     subdir('contrib/ivshmem-server')
2014   endif
2015 endif
2016
2017 subdir('scripts')
2018 subdir('tools')
2019 subdir('pc-bios')
2020 subdir('docs')
2021 subdir('tests')
2022 if 'CONFIG_GTK' in config_host
2023   subdir('po')
2024 endif
2025
2026 if host_machine.system() == 'windows'
2027   nsis_cmd = [
2028     find_program('scripts/nsis.py'),
2029     '@OUTPUT@',
2030     get_option('prefix'),
2031     meson.current_source_dir(),
2032     host_machine.cpu(),
2033     '--',
2034     '-DDISPLAYVERSION=' + meson.project_version(),
2035   ]
2036   if build_docs
2037     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
2038   endif
2039   if 'CONFIG_GTK' in config_host
2040     nsis_cmd += '-DCONFIG_GTK=y'
2041   endif
2042
2043   nsis = custom_target('nsis',
2044                        output: 'qemu-setup-' + meson.project_version() + '.exe',
2045                        input: files('qemu.nsi'),
2046                        build_always_stale: true,
2047                        command: nsis_cmd + ['@INPUT@'])
2048   alias_target('installer', nsis)
2049 endif
2050
2051 #########################
2052 # Configuration summary #
2053 #########################
2054
2055 summary_info = {}
2056 summary_info += {'Install prefix':    get_option('prefix')}
2057 summary_info += {'BIOS directory':    qemu_datadir}
2058 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
2059 summary_info += {'binary directory':  get_option('bindir')}
2060 summary_info += {'library directory': get_option('libdir')}
2061 summary_info += {'module directory':  qemu_moddir}
2062 summary_info += {'libexec directory': get_option('libexecdir')}
2063 summary_info += {'include directory': get_option('includedir')}
2064 summary_info += {'config directory':  get_option('sysconfdir')}
2065 if targetos != 'windows'
2066   summary_info += {'local state directory': get_option('localstatedir')}
2067   summary_info += {'Manual directory':      get_option('mandir')}
2068 else
2069   summary_info += {'local state directory': 'queried at runtime'}
2070 endif
2071 summary_info += {'Doc directory':     get_option('docdir')}
2072 summary_info += {'Build directory':   meson.current_build_dir()}
2073 summary_info += {'Source path':       meson.current_source_dir()}
2074 summary_info += {'GIT binary':        config_host['GIT']}
2075 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
2076 summary_info += {'C compiler':        meson.get_compiler('c').cmd_array()[0]}
2077 summary_info += {'Host C compiler':   meson.get_compiler('c', native: true).cmd_array()[0]}
2078 if link_language == 'cpp'
2079   summary_info += {'C++ compiler':      meson.get_compiler('cpp').cmd_array()[0]}
2080 else
2081   summary_info += {'C++ compiler':      false}
2082 endif
2083 if targetos == 'darwin'
2084   summary_info += {'Objective-C compiler': meson.get_compiler('objc').cmd_array()[0]}
2085 endif
2086 summary_info += {'ARFLAGS':           config_host['ARFLAGS']}
2087 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
2088                                                + ['-O' + get_option('optimization')]
2089                                                + (get_option('debug') ? ['-g'] : []))}
2090 if link_language == 'cpp'
2091   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
2092                                                + ['-O' + get_option('optimization')]
2093                                                + (get_option('debug') ? ['-g'] : []))}
2094 endif
2095 link_args = get_option(link_language + '_link_args')
2096 if link_args.length() > 0
2097   summary_info += {'LDFLAGS':         ' '.join(link_args)}
2098 endif
2099 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
2100 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
2101 summary_info += {'make':              config_host['MAKE']}
2102 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
2103 summary_info += {'sphinx-build':      sphinx_build.found()}
2104 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
2105 # TODO: add back version
2106 summary_info += {'slirp support':     slirp_opt == 'disabled' ? false : slirp_opt}
2107 if slirp_opt != 'disabled'
2108   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
2109 endif
2110 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
2111 if config_host.has_key('CONFIG_MODULES')
2112   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
2113 endif
2114 summary_info += {'host CPU':          cpu}
2115 summary_info += {'host endianness':   build_machine.endian()}
2116 summary_info += {'target list':       ' '.join(target_dirs)}
2117 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
2118 summary_info += {'sparse enabled':    sparse.found()}
2119 summary_info += {'strip binaries':    get_option('strip')}
2120 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
2121 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
2122 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
2123 if targetos == 'darwin'
2124   summary_info += {'Cocoa support': config_host.has_key('CONFIG_COCOA')}
2125 endif
2126 # TODO: add back version
2127 summary_info += {'SDL support':       sdl.found()}
2128 summary_info += {'SDL image support': sdl_image.found()}
2129 # TODO: add back version
2130 summary_info += {'GTK support':       config_host.has_key('CONFIG_GTK')}
2131 summary_info += {'GTK GL support':    config_host.has_key('CONFIG_GTK_GL')}
2132 summary_info += {'pixman':            pixman.found()}
2133 # TODO: add back version
2134 summary_info += {'VTE support':       config_host.has_key('CONFIG_VTE')}
2135 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
2136 summary_info += {'GNUTLS support':    config_host.has_key('CONFIG_GNUTLS')}
2137 # TODO: add back version
2138 summary_info += {'libgcrypt':         config_host.has_key('CONFIG_GCRYPT')}
2139 if config_host.has_key('CONFIG_GCRYPT')
2140    summary_info += {'  hmac':            config_host.has_key('CONFIG_GCRYPT_HMAC')}
2141    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
2142 endif
2143 # TODO: add back version
2144 summary_info += {'nettle':            config_host.has_key('CONFIG_NETTLE')}
2145 if config_host.has_key('CONFIG_NETTLE')
2146    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
2147 endif
2148 summary_info += {'libtasn1':          config_host.has_key('CONFIG_TASN1')}
2149 summary_info += {'PAM':               config_host.has_key('CONFIG_AUTH_PAM')}
2150 summary_info += {'iconv support':     iconv.found()}
2151 summary_info += {'curses support':    curses.found()}
2152 # TODO: add back version
2153 summary_info += {'virgl support':     config_host.has_key('CONFIG_VIRGL')}
2154 summary_info += {'curl support':      config_host.has_key('CONFIG_CURL')}
2155 summary_info += {'mingw32 support':   targetos == 'windows'}
2156 summary_info += {'Audio drivers':     config_host['CONFIG_AUDIO_DRIVERS']}
2157 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
2158 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
2159 summary_info += {'VirtFS support':    config_host.has_key('CONFIG_VIRTFS')}
2160 summary_info += {'build virtiofs daemon': have_virtiofsd}
2161 summary_info += {'Multipath support': mpathpersist.found()}
2162 summary_info += {'VNC support':       vnc.found()}
2163 if vnc.found()
2164   summary_info += {'VNC SASL support':  sasl.found()}
2165   summary_info += {'VNC JPEG support':  jpeg.found()}
2166   summary_info += {'VNC PNG support':   png.found()}
2167 endif
2168 summary_info += {'xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
2169 if config_host.has_key('CONFIG_XEN_BACKEND')
2170   summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
2171 endif
2172 summary_info += {'brlapi support':    config_host.has_key('CONFIG_BRLAPI')}
2173 summary_info += {'Documentation':     build_docs}
2174 summary_info += {'PIE':               get_option('b_pie')}
2175 summary_info += {'vde support':       config_host.has_key('CONFIG_VDE')}
2176 summary_info += {'netmap support':    config_host.has_key('CONFIG_NETMAP')}
2177 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
2178 summary_info += {'Linux io_uring support': config_host.has_key('CONFIG_LINUX_IO_URING')}
2179 summary_info += {'ATTR/XATTR support': config_host.has_key('CONFIG_ATTR')}
2180 summary_info += {'Install blobs':     get_option('install_blobs')}
2181 summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
2182 summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
2183 summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
2184 summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
2185 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
2186 if config_all.has_key('CONFIG_TCG')
2187   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
2188   summary_info += {'TCG interpreter':   config_host.has_key('CONFIG_TCG_INTERPRETER')}
2189 endif
2190 summary_info += {'malloc trim support': has_malloc_trim}
2191 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
2192 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
2193 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
2194 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
2195 summary_info += {'preadv support':    config_host.has_key('CONFIG_PREADV')}
2196 summary_info += {'fdatasync':         config_host.has_key('CONFIG_FDATASYNC')}
2197 summary_info += {'madvise':           config_host.has_key('CONFIG_MADVISE')}
2198 summary_info += {'posix_madvise':     config_host.has_key('CONFIG_POSIX_MADVISE')}
2199 summary_info += {'posix_memalign':    config_host.has_key('CONFIG_POSIX_MEMALIGN')}
2200 summary_info += {'libcap-ng support': config_host.has_key('CONFIG_LIBCAP_NG')}
2201 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
2202 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
2203 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
2204 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
2205 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
2206 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
2207 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
2208 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
2209 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
2210 summary_info += {'Trace backends':    config_host['TRACE_BACKENDS']}
2211 if config_host['TRACE_BACKENDS'].split().contains('simple')
2212   summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
2213 endif
2214 # TODO: add back protocol and server version
2215 summary_info += {'spice support':     config_host.has_key('CONFIG_SPICE')}
2216 summary_info += {'rbd support':       config_host.has_key('CONFIG_RBD')}
2217 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
2218 summary_info += {'smartcard support': config_host.has_key('CONFIG_SMARTCARD')}
2219 summary_info += {'U2F support':       u2f.found()}
2220 summary_info += {'libusb':            config_host.has_key('CONFIG_USB_LIBUSB')}
2221 summary_info += {'usb net redir':     config_host.has_key('CONFIG_USB_REDIR')}
2222 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
2223 summary_info += {'OpenGL dmabufs':    config_host.has_key('CONFIG_OPENGL_DMABUF')}
2224 summary_info += {'libiscsi support':  config_host.has_key('CONFIG_LIBISCSI')}
2225 summary_info += {'libnfs support':    config_host.has_key('CONFIG_LIBNFS')}
2226 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
2227 if targetos == 'windows'
2228   if 'WIN_SDK' in config_host
2229     summary_info += {'Windows SDK':       config_host['WIN_SDK']}
2230   endif
2231   summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
2232   summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
2233   summary_info += {'QGA MSI support':   config_host.has_key('CONFIG_QGA_MSI')}
2234 endif
2235 summary_info += {'seccomp support':   config_host.has_key('CONFIG_SECCOMP')}
2236 summary_info += {'CFI support':       get_option('cfi')}
2237 summary_info += {'CFI debug support': get_option('cfi_debug')}
2238 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
2239 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
2240 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
2241 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
2242 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
2243 summary_info += {'GlusterFS support': config_host.has_key('CONFIG_GLUSTERFS')}
2244 summary_info += {'gcov':              get_option('b_coverage')}
2245 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
2246 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
2247 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
2248 summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
2249 summary_info += {'lzo support':       config_host.has_key('CONFIG_LZO')}
2250 summary_info += {'snappy support':    config_host.has_key('CONFIG_SNAPPY')}
2251 summary_info += {'bzip2 support':     config_host.has_key('CONFIG_BZIP2')}
2252 summary_info += {'lzfse support':     config_host.has_key('CONFIG_LZFSE')}
2253 summary_info += {'zstd support':      config_host.has_key('CONFIG_ZSTD')}
2254 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
2255 summary_info += {'libxml2':           config_host.has_key('CONFIG_LIBXML2')}
2256 summary_info += {'memory allocator':  get_option('malloc')}
2257 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
2258 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
2259 summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
2260 summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
2261 summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
2262 summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
2263 summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
2264 summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
2265 summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
2266 summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
2267 summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
2268 summary_info += {'sheepdog support':  config_host.has_key('CONFIG_SHEEPDOG')}
2269 summary_info += {'capstone':          capstone_opt == 'disabled' ? false : capstone_opt}
2270 summary_info += {'libpmem support':   config_host.has_key('CONFIG_LIBPMEM')}
2271 summary_info += {'libdaxctl support': config_host.has_key('CONFIG_LIBDAXCTL')}
2272 summary_info += {'libudev':           libudev.found()}
2273 summary_info += {'default devices':   config_host['CONFIG_MINIKCONF_MODE'] == '--defconfig'}
2274 summary_info += {'plugin support':    config_host.has_key('CONFIG_PLUGIN')}
2275 summary_info += {'fuzzing support':   config_host.has_key('CONFIG_FUZZ')}
2276 if config_host.has_key('HAVE_GDB_BIN')
2277   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
2278 endif
2279 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
2280 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
2281 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
2282 summary_info += {'FUSE exports':      fuse.found()}
2283 summary_info += {'FUSE lseek':        fuse_lseek.found()}
2284 summary(summary_info, bool_yn: true)
2285
2286 if not supported_cpus.contains(cpu)
2287   message()
2288   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
2289   message()
2290   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
2291   message('The QEMU project intends to remove support for this host CPU in')
2292   message('a future release if nobody volunteers to maintain it and to')
2293   message('provide a build host for our continuous integration setup.')
2294   message('configure has succeeded and you can continue to build, but')
2295   message('if you care about QEMU on this platform you should contact')
2296   message('us upstream at qemu-devel@nongnu.org.')
2297 endif
2298
2299 if not supported_oses.contains(targetos)
2300   message()
2301   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
2302   message()
2303   message('Host OS ' + targetos + 'support is not currently maintained.')
2304   message('The QEMU project intends to remove support for this host OS in')
2305   message('a future release if nobody volunteers to maintain it and to')
2306   message('provide a build host for our continuous integration setup.')
2307   message('configure has succeeded and you can continue to build, but')
2308   message('if you care about QEMU on this platform you should contact')
2309   message('us upstream at qemu-devel@nongnu.org.')
2310 endif