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