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_lundef=false'],
   3         version: run_command('head', meson.source_root() / 'VERSION').stdout().strip())
   4
   5 not_found = dependency('', required: false)
   6 if meson.version().version_compare('>=0.56.0')
   7   keyval = import('keyval')
   8 else
   9   keyval = import('unstable-keyval')
  10 endif
  11 ss = import('sourceset')
  12
  13 sh = find_program('sh')
  14 cc = meson.get_compiler('c')
  15 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
  16 config_all_disas = keyval.load(meson.current_build_dir() / 'config-all-disas.mak')
  17 enable_modules = 'CONFIG_MODULES' in config_host
  18 enable_static = 'CONFIG_STATIC' in config_host
  19 build_docs = 'BUILD_DOCS' in config_host
  20 config_host_data = configuration_data()
  21 genh = []
  22
  23 target_dirs = config_host['TARGET_DIRS'].split()
  24 have_user = false
  25 have_system = false
  26 foreach target : target_dirs
  27   have_user = have_user or target.endswith('-user')
  28   have_system = have_system or target.endswith('-softmmu')
  29 endforeach
  30 have_tools = 'CONFIG_TOOLS' in config_host
  31 have_block = have_system or have_tools
  32
  33 add_project_arguments(config_host['QEMU_CFLAGS'].split(),
  34                       native: false, language: ['c', 'objc'])
  35 add_project_arguments(config_host['QEMU_CXXFLAGS'].split(),
  36                       native: false, language: 'cpp')
  37 add_project_link_arguments(config_host['QEMU_LDFLAGS'].split(),
  38                            native: false, language: ['c', 'cpp', 'objc'])
  39 add_project_arguments(config_host['QEMU_INCLUDES'].split(),
  40                       language: ['c', 'cpp', 'objc'])
  41
  42 python = import('python').find_installation()
  43
  44 link_language = meson.get_external_property('link_language', 'cpp')
  45 if link_language == 'cpp'
  46   add_languages('cpp', required: true, native: false)
  47 endif
  48 if host_machine.system() == 'darwin'
  49   add_languages('objc', required: false, native: false)
  50 endif
  51
  52 if 'SPARSE_CFLAGS' in config_host
  53   run_target('sparse',
  54              command: [find_program('scripts/check_sparse.py'),
  55                        config_host['SPARSE_CFLAGS'].split(),
  56                        'compile_commands.json'])
  57 endif
  58
  59 configure_file(input: files('scripts/ninjatool.py'),
  60                output: 'ninjatool',
  61                configuration: config_host)
  62
  63 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
  64 supported_cpus = ['ppc', 'ppc64', 's390x', 'sparc64', 'riscv32', 'riscv64', 'x86', 'x86_64',
  65   'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
  66
  67 cpu = host_machine.cpu_family()
  68 targetos = host_machine.system()
  69
  70 m = cc.find_library('m', required: false)
  71 util = cc.find_library('util', required: false)
  72 winmm = []
  73 socket = []
  74 version_res = []
  75 coref = []
  76 iokit = []
  77 cocoa = []
  78 hvf = []
  79 if targetos == 'windows'
  80   socket = cc.find_library('ws2_32')
  81   winmm = cc.find_library('winmm')
  82
  83   win = import('windows')
  84   version_res = win.compile_resources('version.rc',
  85                                       depend_files: files('pc-bios/qemu-nsis.ico'),
  86                                       include_directories: include_directories('.'))
  87 elif targetos == 'darwin'
  88   coref = dependency('appleframeworks', modules: 'CoreFoundation')
  89   iokit = dependency('appleframeworks', modules: 'IOKit')
  90   cocoa = dependency('appleframeworks', modules: 'Cocoa')
  91   hvf = dependency('appleframeworks', modules: 'Hypervisor')
  92 elif targetos == 'sunos'
  93   socket = [cc.find_library('socket'),
  94             cc.find_library('nsl'),
  95             cc.find_library('resolv')]
  96 elif targetos == 'haiku'
  97   socket = [cc.find_library('posix_error_mapper'),
  98             cc.find_library('network'),
  99             cc.find_library('bsd')]
 100 endif
 101 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
 102                           link_args: config_host['GLIB_LIBS'].split())
 103 gio = not_found
 104 if 'CONFIG_GIO' in config_host
 105   gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
 106                            link_args: config_host['GIO_LIBS'].split())
 107 endif
 108 lttng = not_found
 109 if 'CONFIG_TRACE_UST' in config_host
 110   lttng = declare_dependency(link_args: config_host['LTTNG_UST_LIBS'].split())
 111 endif
 112 urcubp = not_found
 113 if 'CONFIG_TRACE_UST' in config_host
 114   urcubp = declare_dependency(link_args: config_host['URCU_BP_LIBS'].split())
 115 endif
 116 nettle = not_found
 117 if 'CONFIG_NETTLE' in config_host
 118   nettle = declare_dependency(compile_args: config_host['NETTLE_CFLAGS'].split(),
 119                               link_args: config_host['NETTLE_LIBS'].split())
 120 endif
 121 gnutls = not_found
 122 if 'CONFIG_GNUTLS' in config_host
 123   gnutls = declare_dependency(compile_args: config_host['GNUTLS_CFLAGS'].split(),
 124                               link_args: config_host['GNUTLS_LIBS'].split())
 125 endif
 126 pixman = not_found
 127 if have_system or have_tools
 128   pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
 129                       static: enable_static)
 130 endif
 131 pam = not_found
 132 if 'CONFIG_AUTH_PAM' in config_host
 133   pam = cc.find_library('pam')
 134 endif
 135 libaio = cc.find_library('aio', required: false)
 136 zlib = not_found
 137 if 'CONFIG_ZLIB' in config_host
 138   zlib = declare_dependency(compile_args: config_host['ZLIB_CFLAGS'].split(),
 139                             link_args: config_host['ZLIB_LIBS'].split())
 140 endif
 141 linux_io_uring = not_found
 142 if 'CONFIG_LINUX_IO_URING' in config_host
 143   linux_io_uring = declare_dependency(compile_args: config_host['LINUX_IO_URING_CFLAGS'].split(),
 144                                       link_args: config_host['LINUX_IO_URING_LIBS'].split())
 145 endif
 146 libxml2 = not_found
 147 if 'CONFIG_LIBXML2' in config_host
 148   libxml2 = declare_dependency(compile_args: config_host['LIBXML2_CFLAGS'].split(),
 149                                link_args: config_host['LIBXML2_LIBS'].split())
 150 endif
 151 libnfs = not_found
 152 if 'CONFIG_LIBNFS' in config_host
 153   libnfs = declare_dependency(link_args: config_host['LIBNFS_LIBS'].split())
 154 endif
 155 libattr = not_found
 156 if 'CONFIG_ATTR' in config_host
 157   libattr = declare_dependency(link_args: config_host['LIBATTR_LIBS'].split())
 158 endif
 159 seccomp = not_found
 160 if 'CONFIG_SECCOMP' in config_host
 161   seccomp = declare_dependency(compile_args: config_host['SECCOMP_CFLAGS'].split(),
 162                                link_args: config_host['SECCOMP_LIBS'].split())
 163 endif
 164 libcap_ng = not_found
 165 if 'CONFIG_LIBCAP_NG' in config_host
 166   libcap_ng = declare_dependency(link_args: config_host['LIBCAP_NG_LIBS'].split())
 167 endif
 168 if get_option('xkbcommon').auto() and not have_system and not have_tools
 169   xkbcommon = not_found
 170 else
 171   xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
 172                          static: enable_static)
 173 endif
 174 slirp = not_found
 175 if config_host.has_key('CONFIG_SLIRP')
 176   slirp = declare_dependency(compile_args: config_host['SLIRP_CFLAGS'].split(),
 177                              link_args: config_host['SLIRP_LIBS'].split())
 178 endif
 179 vde = not_found
 180 if config_host.has_key('CONFIG_VDE')
 181   vde = declare_dependency(link_args: config_host['VDE_LIBS'].split())
 182 endif
 183 pulse = not_found
 184 if 'CONFIG_LIBPULSE' in config_host
 185   pulse = declare_dependency(compile_args: config_host['PULSE_CFLAGS'].split(),
 186                              link_args: config_host['PULSE_LIBS'].split())
 187 endif
 188 alsa = not_found
 189 if 'CONFIG_ALSA' in config_host
 190   alsa = declare_dependency(compile_args: config_host['ALSA_CFLAGS'].split(),
 191                             link_args: config_host['ALSA_LIBS'].split())
 192 endif
 193 jack = not_found
 194 if 'CONFIG_LIBJACK' in config_host
 195   jack = declare_dependency(link_args: config_host['JACK_LIBS'].split())
 196 endif
 197 spice = not_found
 198 if 'CONFIG_SPICE' in config_host
 199   spice = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split(),
 200                              link_args: config_host['SPICE_LIBS'].split())
 201 endif
 202 rt = cc.find_library('rt', required: false)
 203 libmpathpersist = not_found
 204 if config_host.has_key('CONFIG_MPATH')
 205   libmpathpersist = cc.find_library('mpathpersist')
 206 endif
 207 libiscsi = not_found
 208 if 'CONFIG_LIBISCSI' in config_host
 209   libiscsi = declare_dependency(compile_args: config_host['LIBISCSI_CFLAGS'].split(),
 210                                 link_args: config_host['LIBISCSI_LIBS'].split())
 211 endif
 212 zstd = not_found
 213 if 'CONFIG_ZSTD' in config_host
 214   zstd = declare_dependency(compile_args: config_host['ZSTD_CFLAGS'].split(),
 215                             link_args: config_host['ZSTD_LIBS'].split())
 216 endif
 217 gbm = not_found
 218 if 'CONFIG_GBM' in config_host
 219   gbm = declare_dependency(compile_args: config_host['GBM_CFLAGS'].split(),
 220                            link_args: config_host['GBM_LIBS'].split())
 221 endif
 222 virgl = not_found
 223 if 'CONFIG_VIRGL' in config_host
 224   virgl = declare_dependency(compile_args: config_host['VIRGL_CFLAGS'].split(),
 225                              link_args: config_host['VIRGL_LIBS'].split())
 226 endif
 227 curl = not_found
 228 if 'CONFIG_CURL' in config_host
 229   curl = declare_dependency(compile_args: config_host['CURL_CFLAGS'].split(),
 230                             link_args: config_host['CURL_LIBS'].split())
 231 endif
 232 libudev = not_found
 233 if 'CONFIG_LIBUDEV' in config_host
 234   libudev = declare_dependency(link_args: config_host['LIBUDEV_LIBS'].split())
 235 endif
 236 brlapi = not_found
 237 if 'CONFIG_BRLAPI' in config_host
 238   brlapi = declare_dependency(link_args: config_host['BRLAPI_LIBS'].split())
 239 endif
 240
 241 sdl = not_found
 242 if have_system
 243   sdl = dependency('sdl2', required: get_option('sdl'), static: enable_static)
 244   sdl_image = not_found
 245 endif
 246 if sdl.found()
 247   # work around 2.0.8 bug
 248   sdl = declare_dependency(compile_args: '-Wno-undef',
 249                            dependencies: sdl)
 250   sdl_image = dependency('sdl-image', required: get_option('sdl_image'),
 251                          static: enable_static)
 252 else
 253   if get_option('sdl_image').enabled()
 254     error('sdl-image required, but SDL was @0@',
 255           get_option('sdl').disabled() ? 'disabled' : 'not found')
 256   endif
 257   sdl_image = not_found
 258 endif
 259
 260 rbd = not_found
 261 if 'CONFIG_RBD' in config_host
 262   rbd = declare_dependency(link_args: config_host['RBD_LIBS'].split())
 263 endif
 264 glusterfs = not_found
 265 if 'CONFIG_GLUSTERFS' in config_host
 266   glusterfs = declare_dependency(compile_args: config_host['GLUSTERFS_CFLAGS'].split(),
 267                                  link_args: config_host['GLUSTERFS_LIBS'].split())
 268 endif
 269 libssh = not_found
 270 if 'CONFIG_LIBSSH' in config_host
 271   libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
 272                               link_args: config_host['LIBSSH_LIBS'].split())
 273 endif
 274 libbzip2 = not_found
 275 if 'CONFIG_BZIP2' in config_host
 276   libbzip2 = declare_dependency(link_args: config_host['BZIP2_LIBS'].split())
 277 endif
 278 liblzfse = not_found
 279 if 'CONFIG_LZFSE' in config_host
 280   liblzfse = declare_dependency(link_args: config_host['LZFSE_LIBS'].split())
 281 endif
 282 oss = not_found
 283 if 'CONFIG_AUDIO_OSS' in config_host
 284   oss = declare_dependency(link_args: config_host['OSS_LIBS'].split())
 285 endif
 286 dsound = not_found
 287 if 'CONFIG_AUDIO_DSOUND' in config_host
 288   dsound = declare_dependency(link_args: config_host['DSOUND_LIBS'].split())
 289 endif
 290 coreaudio = not_found
 291 if 'CONFIG_AUDIO_COREAUDIO' in config_host
 292   coreaudio = declare_dependency(link_args: config_host['COREAUDIO_LIBS'].split())
 293 endif
 294 opengl = not_found
 295 if 'CONFIG_OPENGL' in config_host
 296   opengl = declare_dependency(link_args: config_host['OPENGL_LIBS'].split())
 297 else
 298 endif
 299 gtk = not_found
 300 if 'CONFIG_GTK' in config_host
 301   gtk = declare_dependency(compile_args: config_host['GTK_CFLAGS'].split(),
 302                               link_args: config_host['GTK_LIBS'].split())
 303 endif
 304 vte = not_found
 305 if 'CONFIG_VTE' in config_host
 306   vte = declare_dependency(compile_args: config_host['VTE_CFLAGS'].split(),
 307                            link_args: config_host['VTE_LIBS'].split())
 308 endif
 309 x11 = not_found
 310 if 'CONFIG_X11' in config_host
 311   x11 = declare_dependency(compile_args: config_host['X11_CFLAGS'].split(),
 312                            link_args: config_host['X11_LIBS'].split())
 313 endif
 314 curses = not_found
 315 if 'CONFIG_CURSES' in config_host
 316   curses = declare_dependency(compile_args: config_host['CURSES_CFLAGS'].split(),
 317                               link_args: config_host['CURSES_LIBS'].split())
 318 endif
 319 iconv = not_found
 320 if 'CONFIG_ICONV' in config_host
 321   iconv = declare_dependency(compile_args: config_host['ICONV_CFLAGS'].split(),
 322                              link_args: config_host['ICONV_LIBS'].split())
 323 endif
 324 gio = not_found
 325 if 'CONFIG_GIO' in config_host
 326   gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
 327                            link_args: config_host['GIO_LIBS'].split())
 328 endif
 329 vnc = not_found
 330 png = not_found
 331 jpeg = not_found
 332 sasl = not_found
 333 if get_option('vnc').enabled()
 334   vnc = declare_dependency() # dummy dependency
 335   png = dependency('libpng', required: get_option('vnc_png'),
 336                    static: enable_static)
 337   jpeg = cc.find_library('jpeg', has_headers: ['jpeglib.h'],
 338                          required: get_option('vnc_jpeg'),
 339                          static: enable_static)
 340   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
 341                          required: get_option('vnc_sasl'),
 342                          static: enable_static)
 343   if sasl.found()
 344     sasl = declare_dependency(dependencies: sasl,
 345                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
 346   endif
 347 endif
 348 fdt = not_found
 349 if 'CONFIG_FDT' in config_host
 350   fdt = declare_dependency(compile_args: config_host['FDT_CFLAGS'].split(),
 351                            link_args: config_host['FDT_LIBS'].split())
 352 endif
 353 snappy = not_found
 354 if 'CONFIG_SNAPPY' in config_host
 355   snappy = declare_dependency(link_args: config_host['SNAPPY_LIBS'].split())
 356 endif
 357 lzo = not_found
 358 if 'CONFIG_LZO' in config_host
 359   lzo = declare_dependency(link_args: config_host['LZO_LIBS'].split())
 360 endif
 361 rdma = not_found
 362 if 'CONFIG_RDMA' in config_host
 363   rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
 364 endif
 365 numa = not_found
 366 if 'CONFIG_NUMA' in config_host
 367   numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
 368 endif
 369 xen = not_found
 370 if 'CONFIG_XEN_BACKEND' in config_host
 371   xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
 372                            link_args: config_host['XEN_LIBS'].split())
 373 endif
 374 cacard = not_found
 375 if 'CONFIG_SMARTCARD' in config_host
 376   cacard = declare_dependency(compile_args: config_host['SMARTCARD_CFLAGS'].split(),
 377                               link_args: config_host['SMARTCARD_LIBS'].split())
 378 endif
 379 usbredir = not_found
 380 if 'CONFIG_USB_REDIR' in config_host
 381   usbredir = declare_dependency(compile_args: config_host['USB_REDIR_CFLAGS'].split(),
 382                                 link_args: config_host['USB_REDIR_LIBS'].split())
 383 endif
 384 libusb = not_found
 385 if 'CONFIG_USB_LIBUSB' in config_host
 386   libusb = declare_dependency(compile_args: config_host['LIBUSB_CFLAGS'].split(),
 387                               link_args: config_host['LIBUSB_LIBS'].split())
 388 endif
 389 capstone = not_found
 390 if 'CONFIG_CAPSTONE' in config_host
 391   capstone = declare_dependency(compile_args: config_host['CAPSTONE_CFLAGS'].split(),
 392                                 link_args: config_host['CAPSTONE_LIBS'].split())
 393 endif
 394 libpmem = not_found
 395 if 'CONFIG_LIBPMEM' in config_host
 396   libpmem = declare_dependency(compile_args: config_host['LIBPMEM_CFLAGS'].split(),
 397                                link_args: config_host['LIBPMEM_LIBS'].split())
 398 endif
 399 libdaxctl = not_found
 400 if 'CONFIG_LIBDAXCTL' in config_host
 401   libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split())
 402 endif
 403
 404 # Create config-host.h
 405
 406 config_host_data.set('CONFIG_SDL', sdl.found())
 407 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
 408 config_host_data.set('CONFIG_VNC', vnc.found())
 409 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
 410 config_host_data.set('CONFIG_VNC_PNG', png.found())
 411 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
 412 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
 413 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
 414 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
 415 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
 416 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
 417
 418 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
 419 strings = ['HOST_DSOSUF', 'CONFIG_IASL', 'qemu_confdir', 'qemu_datadir',
 420            'qemu_moddir', 'qemu_localstatedir', 'qemu_helperdir', 'qemu_localedir',
 421            'qemu_icondir', 'qemu_desktopdir', 'qemu_firmwarepath']
 422 foreach k, v: config_host
 423   if arrays.contains(k)
 424     if v != ''
 425       v = '"' + '", "'.join(v.split()) + '", '
 426     endif
 427     config_host_data.set(k, v)
 428   elif k == 'ARCH'
 429     config_host_data.set('HOST_' + v.to_upper(), 1)
 430   elif strings.contains(k)
 431     if not k.startswith('CONFIG_')
 432       k = 'CONFIG_' + k.to_upper()
 433     endif
 434     config_host_data.set_quoted(k, v)
 435   elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
 436     config_host_data.set(k, v == 'y' ? 1 : v)
 437   endif
 438 endforeach
 439 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
 440
 441 minikconf = find_program('scripts/minikconf.py')
 442 config_devices_mak_list = []
 443 config_devices_h = {}
 444 config_target_h = {}
 445 config_target_mak = {}
 446 kconfig_external_symbols = [
 447   'CONFIG_KVM',
 448   'CONFIG_XEN',
 449   'CONFIG_TPM',
 450   'CONFIG_SPICE',
 451   'CONFIG_IVSHMEM',
 452   'CONFIG_OPENGL',
 453   'CONFIG_X11',
 454   'CONFIG_VHOST_USER',
 455   'CONFIG_VHOST_KERNEL',
 456   'CONFIG_VIRTFS',
 457   'CONFIG_LINUX',
 458   'CONFIG_PVRDMA',
 459 ]
 460 ignored = ['TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_DIRS']
 461 foreach target : target_dirs
 462   config_target = keyval.load(meson.current_build_dir() / target / 'config-target.mak')
 463
 464   config_target_data = configuration_data()
 465   foreach k, v: config_target
 466     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
 467       # do nothing
 468     elif ignored.contains(k)
 469       # do nothing
 470     elif k == 'TARGET_BASE_ARCH'
 471       config_target_data.set('TARGET_' + v.to_upper(), 1)
 472     elif k == 'TARGET_NAME'
 473       config_target_data.set_quoted(k, v)
 474     elif v == 'y'
 475       config_target_data.set(k, 1)
 476     else
 477       config_target_data.set(k, v)
 478     endif
 479   endforeach
 480   config_target_h += {target: configure_file(output: target + '-config-target.h',
 481                                                configuration: config_target_data)}
 482
 483   if target.endswith('-softmmu')
 484     base_kconfig = []
 485     foreach sym : kconfig_external_symbols
 486       if sym in config_target or sym in config_host
 487         base_kconfig += '@0@=y'.format(sym)
 488       endif
 489     endforeach
 490
 491     config_devices_mak = target + '-config-devices.mak'
 492     config_devices_mak = configure_file(
 493       input: ['default-configs' / target + '.mak', 'Kconfig'],
 494       output: config_devices_mak,
 495       depfile: config_devices_mak + '.d',
 496       capture: true,
 497       command: [minikconf, config_host['CONFIG_MINIKCONF_MODE'],
 498                 config_devices_mak, '@DEPFILE@', '@INPUT@',
 499                 base_kconfig])
 500
 501     config_devices_data = configuration_data()
 502     config_devices = keyval.load(config_devices_mak)
 503     foreach k, v: config_devices
 504       config_devices_data.set(k, 1)
 505     endforeach
 506     config_devices_mak_list += config_devices_mak
 507     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
 508                                                 configuration: config_devices_data)}
 509     config_target += config_devices
 510   endif
 511   config_target_mak += {target: config_target}
 512 endforeach
 513
 514 grepy = find_program('scripts/grepy.sh')
 515 # This configuration is used to build files that are shared by
 516 # multiple binaries, and then extracted out of the "common"
 517 # static_library target.
 518 #
 519 # We do not use all_sources()/all_dependencies(), because it would
 520 # build literally all source files, including devices only used by
 521 # targets that are not built for this compilation.  The CONFIG_ALL
 522 # pseudo symbol replaces it.
 523
 524 if have_system
 525   config_all_devices_mak = configure_file(
 526     output: 'config-all-devices.mak',
 527     input: config_devices_mak_list,
 528     capture: true,
 529     command: [grepy, '@INPUT@'],
 530   )
 531   config_all_devices = keyval.load(config_all_devices_mak)
 532 else
 533   config_all_devices = {}
 534 endif
 535 config_all = config_all_devices
 536 config_all += config_host
 537 config_all += config_all_disas
 538 config_all += {
 539   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
 540   'CONFIG_SOFTMMU': have_system,
 541   'CONFIG_USER_ONLY': have_user,
 542   'CONFIG_ALL': true,
 543 }
 544
 545 # Generators
 546
 547 hxtool = find_program('scripts/hxtool')
 548 shaderinclude = find_program('scripts/shaderinclude.pl')
 549 qapi_gen = find_program('scripts/qapi-gen.py')
 550 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
 551                      meson.source_root() / 'scripts/qapi/commands.py',
 552                      meson.source_root() / 'scripts/qapi/common.py',
 553                      meson.source_root() / 'scripts/qapi/doc.py',
 554                      meson.source_root() / 'scripts/qapi/error.py',
 555                      meson.source_root() / 'scripts/qapi/events.py',
 556                      meson.source_root() / 'scripts/qapi/expr.py',
 557                      meson.source_root() / 'scripts/qapi/gen.py',
 558                      meson.source_root() / 'scripts/qapi/introspect.py',
 559                      meson.source_root() / 'scripts/qapi/parser.py',
 560                      meson.source_root() / 'scripts/qapi/schema.py',
 561                      meson.source_root() / 'scripts/qapi/source.py',
 562                      meson.source_root() / 'scripts/qapi/types.py',
 563                      meson.source_root() / 'scripts/qapi/visit.py',
 564                      meson.source_root() / 'scripts/qapi/common.py',
 565                      meson.source_root() / 'scripts/qapi/doc.py',
 566                      meson.source_root() / 'scripts/qapi-gen.py'
 567 ]
 568
 569 tracetool = [
 570   python, files('scripts/tracetool.py'),
 571    '--backend=' + config_host['TRACE_BACKENDS']
 572 ]
 573
 574 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
 575                     meson.current_source_dir(),
 576                     config_host['PKGVERSION'], meson.project_version()]
 577 qemu_version = custom_target('qemu-version.h',
 578                              output: 'qemu-version.h',
 579                              command: qemu_version_cmd,
 580                              capture: true,
 581                              build_by_default: true,
 582                              build_always_stale: true)
 583 genh += qemu_version
 584
 585 hxdep = []
 586 hx_headers = [
 587   ['qemu-options.hx', 'qemu-options.def'],
 588   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
 589 ]
 590 if have_system
 591   hx_headers += [
 592     ['hmp-commands.hx', 'hmp-commands.h'],
 593     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
 594   ]
 595 endif
 596 foreach d : hx_headers
 597   hxdep += custom_target(d[1],
 598                 input: files(d[0]),
 599                 output: d[1],
 600                 capture: true,
 601                 build_by_default: true, # to be removed when added to a target
 602                 command: [hxtool, '-h', '@INPUT0@'])
 603 endforeach
 604 genh += hxdep
 605
 606 # Collect sourcesets.
 607
 608 util_ss = ss.source_set()
 609 stub_ss = ss.source_set()
 610 trace_ss = ss.source_set()
 611 block_ss = ss.source_set()
 612 blockdev_ss = ss.source_set()
 613 qmp_ss = ss.source_set()
 614 common_ss = ss.source_set()
 615 softmmu_ss = ss.source_set()
 616 user_ss = ss.source_set()
 617 bsd_user_ss = ss.source_set()
 618 linux_user_ss = ss.source_set()
 619 specific_ss = ss.source_set()
 620 specific_fuzz_ss = ss.source_set()
 621
 622 modules = {}
 623 hw_arch = {}
 624 target_arch = {}
 625 target_softmmu_arch = {}
 626
 627 ###############
 628 # Trace files #
 629 ###############
 630
 631 # TODO: add each directory to the subdirs from its own meson.build, once
 632 # we have those
 633 trace_events_subdirs = [
 634   'accel/kvm',
 635   'accel/tcg',
 636   'crypto',
 637   'monitor',
 638 ]
 639 if have_user
 640   trace_events_subdirs += [ 'linux-user' ]
 641 endif
 642 if have_block
 643   trace_events_subdirs += [
 644     'authz',
 645     'block',
 646     'io',
 647     'nbd',
 648     'scsi',
 649   ]
 650 endif
 651 if have_system
 652   trace_events_subdirs += [
 653     'audio',
 654     'backends',
 655     'backends/tpm',
 656     'chardev',
 657     'hw/9pfs',
 658     'hw/acpi',
 659     'hw/alpha',
 660     'hw/arm',
 661     'hw/audio',
 662     'hw/block',
 663     'hw/block/dataplane',
 664     'hw/char',
 665     'hw/display',
 666     'hw/dma',
 667     'hw/hppa',
 668     'hw/hyperv',
 669     'hw/i2c',
 670     'hw/i386',
 671     'hw/i386/xen',
 672     'hw/ide',
 673     'hw/input',
 674     'hw/intc',
 675     'hw/isa',
 676     'hw/mem',
 677     'hw/mips',
 678     'hw/misc',
 679     'hw/misc/macio',
 680     'hw/net',
 681     'hw/nvram',
 682     'hw/pci',
 683     'hw/pci-host',
 684     'hw/ppc',
 685     'hw/rdma',
 686     'hw/rdma/vmw',
 687     'hw/rtc',
 688     'hw/s390x',
 689     'hw/scsi',
 690     'hw/sd',
 691     'hw/sparc',
 692     'hw/sparc64',
 693     'hw/ssi',
 694     'hw/timer',
 695     'hw/tpm',
 696     'hw/usb',
 697     'hw/vfio',
 698     'hw/virtio',
 699     'hw/watchdog',
 700     'hw/xen',
 701     'hw/gpio',
 702     'hw/riscv',
 703     'migration',
 704     'net',
 705     'ui',
 706   ]
 707 endif
 708 trace_events_subdirs += [
 709   'hw/core',
 710   'qapi',
 711   'qom',
 712   'target/arm',
 713   'target/hppa',
 714   'target/i386',
 715   'target/mips',
 716   'target/ppc',
 717   'target/riscv',
 718   'target/s390x',
 719   'target/sparc',
 720   'util',
 721 ]
 722
 723 subdir('qapi')
 724 subdir('qobject')
 725 subdir('stubs')
 726 subdir('trace')
 727 subdir('util')
 728 subdir('qom')
 729 subdir('authz')
 730 subdir('crypto')
 731 subdir('ui')
 732
 733
 734 if enable_modules
 735   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
 736   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
 737 endif
 738
 739 # Build targets from sourcesets
 740
 741 stub_ss = stub_ss.apply(config_all, strict: false)
 742
 743 util_ss.add_all(trace_ss)
 744 util_ss = util_ss.apply(config_all, strict: false)
 745 libqemuutil = static_library('qemuutil',
 746                              sources: util_ss.sources() + stub_ss.sources() + genh,
 747                              dependencies: [util_ss.dependencies(), m, glib, socket])
 748 qemuutil = declare_dependency(link_with: libqemuutil,
 749                               sources: genh + version_res)
 750
 751 decodetree = generator(find_program('scripts/decodetree.py'),
 752                        output: 'decode-@BASENAME@.c.inc',
 753                        arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
 754
 755 subdir('audio')
 756 subdir('io')
 757 subdir('chardev')
 758 subdir('fsdev')
 759 subdir('libdecnumber')
 760 subdir('target')
 761 subdir('dump')
 762
 763 block_ss.add(files(
 764   'block.c',
 765   'blockjob.c',
 766   'job.c',
 767   'qemu-io-cmds.c',
 768 ))
 769 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
 770
 771 subdir('nbd')
 772 subdir('scsi')
 773 subdir('block')
 774
 775 blockdev_ss.add(files(
 776   'blockdev.c',
 777   'blockdev-nbd.c',
 778   'iothread.c',
 779   'job-qmp.c',
 780 ))
 781
 782 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
 783 # os-win32.c does not
 784 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
 785 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
 786
 787 softmmu_ss.add_all(blockdev_ss)
 788 softmmu_ss.add(files(
 789   'bootdevice.c',
 790   'dma-helpers.c',
 791   'qdev-monitor.c',
 792 ), sdl)
 793
 794 softmmu_ss.add(when: 'CONFIG_TPM', if_true: files('tpm.c'))
 795 softmmu_ss.add(when: 'CONFIG_SECCOMP', if_true: [files('qemu-seccomp.c'), seccomp])
 796 softmmu_ss.add(when: ['CONFIG_FDT', fdt],  if_true: [files('device_tree.c')])
 797
 798 common_ss.add(files('cpus-common.c'))
 799
 800 subdir('softmmu')
 801
 802 specific_ss.add(files('disas.c', 'exec.c', 'gdbstub.c'), capstone, libpmem, libdaxctl)
 803 specific_ss.add(files('exec-vary.c'))
 804 specific_ss.add(when: 'CONFIG_TCG', if_true: files(
 805   'fpu/softfloat.c',
 806   'tcg/optimize.c',
 807   'tcg/tcg-common.c',
 808   'tcg/tcg-op-gvec.c',
 809   'tcg/tcg-op-vec.c',
 810   'tcg/tcg-op.c',
 811   'tcg/tcg.c',
 812 ))
 813 specific_ss.add(when: 'CONFIG_TCG_INTERPRETER', if_true: files('disas/tci.c', 'tcg/tci.c'))
 814
 815 subdir('backends')
 816 subdir('disas')
 817 subdir('migration')
 818 subdir('monitor')
 819 subdir('net')
 820 subdir('replay')
 821 subdir('hw')
 822 subdir('accel')
 823 subdir('plugins')
 824 subdir('bsd-user')
 825 subdir('linux-user')
 826
 827 bsd_user_ss.add(files('gdbstub.c'))
 828 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
 829
 830 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
 831 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
 832
 833 # needed for fuzzing binaries
 834 subdir('tests/qtest/libqos')
 835 subdir('tests/qtest/fuzz')
 836
 837 block_mods = []
 838 softmmu_mods = []
 839 foreach d, list : modules
 840   foreach m, module_ss : list
 841     if enable_modules and targetos != 'windows'
 842       module_ss = module_ss.apply(config_host, strict: false)
 843       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
 844                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
 845       if d == 'block'
 846         block_mods += sl
 847       else
 848         softmmu_mods += sl
 849       endif
 850     else
 851       if d == 'block'
 852         block_ss.add_all(module_ss)
 853       else
 854         softmmu_ss.add_all(module_ss)
 855       endif
 856     endif
 857   endforeach
 858 endforeach
 859
 860 nm = find_program('nm')
 861 undefsym = find_program('scripts/undefsym.sh')
 862 block_syms = custom_target('block.syms', output: 'block.syms',
 863                              input: [libqemuutil, block_mods],
 864                              capture: true,
 865                              command: [undefsym, nm, '@INPUT@'])
 866 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
 867                              input: [libqemuutil, softmmu_mods],
 868                              capture: true,
 869                              command: [undefsym, nm, '@INPUT@'])
 870
 871 block_ss = block_ss.apply(config_host, strict: false)
 872 libblock = static_library('block', block_ss.sources() + genh,
 873                           dependencies: block_ss.dependencies(),
 874                           link_depends: block_syms,
 875                           name_suffix: 'fa',
 876                           build_by_default: false)
 877
 878 block = declare_dependency(link_whole: [libblock],
 879                            link_args: '@block.syms',
 880                            dependencies: [crypto, io])
 881
 882 qmp_ss = qmp_ss.apply(config_host, strict: false)
 883 libqmp = static_library('qmp', qmp_ss.sources() + genh,
 884                         dependencies: qmp_ss.dependencies(),
 885                         name_suffix: 'fa',
 886                         build_by_default: false)
 887
 888 qmp = declare_dependency(link_whole: [libqmp])
 889
 890 foreach m : block_mods + softmmu_mods
 891   shared_module(m.name(),
 892                 name_prefix: '',
 893                 link_whole: m,
 894                 install: true,
 895                 install_dir: config_host['qemu_moddir'])
 896 endforeach
 897
 898 softmmu_ss.add(authz, block, chardev, crypto, io, qmp)
 899 common_ss.add(qom, qemuutil)
 900
 901 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
 902 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
 903
 904 common_all = common_ss.apply(config_all, strict: false)
 905 common_all = static_library('common',
 906                             build_by_default: false,
 907                             sources: common_all.sources() + genh,
 908                             dependencies: common_all.dependencies(),
 909                             name_suffix: 'fa')
 910
 911 feature_to_c = find_program('scripts/feature_to_c.sh')
 912
 913 emulators = []
 914 foreach target : target_dirs
 915   config_target = config_target_mak[target]
 916   target_name = config_target['TARGET_NAME']
 917   arch = config_target['TARGET_BASE_ARCH']
 918   arch_srcs = [config_target_h[target]]
 919   arch_deps = []
 920   c_args = ['-DNEED_CPU_H',
 921             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
 922             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
 923   link_args = []
 924
 925   config_target += config_host
 926   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
 927   if targetos == 'linux'
 928     target_inc += include_directories('linux-headers', is_system: true)
 929   endif
 930   if target.endswith('-softmmu')
 931     qemu_target_name = 'qemu-system-' + target_name
 932     target_type='system'
 933     t = target_softmmu_arch[arch].apply(config_target, strict: false)
 934     arch_srcs += t.sources()
 935     arch_deps += t.dependencies()
 936
 937     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
 938     hw = hw_arch[hw_dir].apply(config_target, strict: false)
 939     arch_srcs += hw.sources()
 940     arch_deps += hw.dependencies()
 941
 942     arch_srcs += config_devices_h[target]
 943     link_args += ['@block.syms', '@qemu.syms']
 944   else
 945     abi = config_target['TARGET_ABI_DIR']
 946     target_type='user'
 947     qemu_target_name = 'qemu-' + target_name
 948     if 'CONFIG_LINUX_USER' in config_target
 949       base_dir = 'linux-user'
 950       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
 951     else
 952       base_dir = 'bsd-user'
 953     endif
 954     target_inc += include_directories(
 955       base_dir,
 956       base_dir / abi,
 957     )
 958     if 'CONFIG_LINUX_USER' in config_target
 959       dir = base_dir / abi
 960       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
 961       if config_target.has_key('TARGET_SYSTBL_ABI')
 962         arch_srcs += \
 963           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
 964                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
 965       endif
 966     endif
 967   endif
 968
 969   if 'TARGET_XML_FILES' in config_target
 970     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
 971                                 output: target + '-gdbstub-xml.c',
 972                                 input: files(config_target['TARGET_XML_FILES'].split()),
 973                                 command: [feature_to_c, '@INPUT@'],
 974                                 capture: true)
 975     arch_srcs += gdbstub_xml
 976   endif
 977
 978   t = target_arch[arch].apply(config_target, strict: false)
 979   arch_srcs += t.sources()
 980   arch_deps += t.dependencies()
 981
 982   target_common = common_ss.apply(config_target, strict: false)
 983   objects = common_all.extract_objects(target_common.sources())
 984   deps = target_common.dependencies()
 985
 986   target_specific = specific_ss.apply(config_target, strict: false)
 987   arch_srcs += target_specific.sources()
 988   arch_deps += target_specific.dependencies()
 989
 990   lib = static_library('qemu-' + target,
 991                  sources: arch_srcs + genh,
 992                  dependencies: arch_deps,
 993                  objects: objects,
 994                  include_directories: target_inc,
 995                  c_args: c_args,
 996                  build_by_default: false,
 997                  name_suffix: 'fa')
 998
 999   if target.endswith('-softmmu')
1000     execs = [{
1001       'name': 'qemu-system-' + target_name,
1002       'gui': false,
1003       'sources': files('softmmu/main.c'),
1004       'dependencies': []
1005     }]
1006     if targetos == 'windows' and (sdl.found() or gtk.found())
1007       execs += [{
1008         'name': 'qemu-system-' + target_name + 'w',
1009         'gui': true,
1010         'sources': files('softmmu/main.c'),
1011         'dependencies': []
1012       }]
1013     endif
1014     if config_host.has_key('CONFIG_FUZZ')
1015       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
1016       execs += [{
1017         'name': 'qemu-fuzz-' + target_name,
1018         'gui': false,
1019         'sources': specific_fuzz.sources(),
1020         'dependencies': specific_fuzz.dependencies(),
1021         'link_depends': [files('tests/qtest/fuzz/fork_fuzz.ld')],
1022       }]
1023     endif
1024   else
1025     execs = [{
1026       'name': 'qemu-' + target_name,
1027       'gui': false,
1028       'sources': [],
1029       'dependencies': []
1030     }]
1031   endif
1032   foreach exe: execs
1033     emulators += executable(exe['name'], exe['sources'],
1034                install: true,
1035                c_args: c_args,
1036                dependencies: arch_deps + deps + exe['dependencies'],
1037                objects: lib.extract_all_objects(recursive: true),
1038                link_language: link_language,
1039                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
1040                link_args: link_args,
1041                gui_app: exe['gui'])
1042
1043     if 'CONFIG_TRACE_SYSTEMTAP' in config_host
1044       foreach stp: [
1045         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
1046         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
1047         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
1048         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
1049       ]
1050         custom_target(exe['name'] + stp['ext'],
1051                       input: trace_events_all,
1052                       output: exe['name'] + stp['ext'],
1053                       capture: true,
1054                       install: stp['install'],
1055                       install_dir: config_host['qemu_datadir'] / '../systemtap/tapset',
1056                       command: [
1057                         tracetool, '--group=all', '--format=' + stp['fmt'],
1058                         '--binary=' + stp['bin'],
1059                         '--target-name=' + target_name,
1060                         '--target-type=' + target_type,
1061                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
1062                         '@INPUT@',
1063                       ])
1064       endforeach
1065     endif
1066   endforeach
1067 endforeach
1068
1069 # Other build targets
1070
1071 if 'CONFIG_PLUGIN' in config_host
1072   install_headers('include/qemu/qemu-plugin.h')
1073 endif
1074
1075 if 'CONFIG_GUEST_AGENT' in config_host
1076   subdir('qga')
1077 endif
1078
1079 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
1080 # when we don't build tools or system
1081 if xkbcommon.found()
1082   # used for the update-keymaps target, so include rules even if !have_tools
1083   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
1084                            dependencies: [qemuutil, xkbcommon], install: have_tools)
1085 endif
1086
1087 qemu_block_tools = []
1088 if have_tools
1089   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
1090              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
1091   qemu_io = executable('qemu-io', files('qemu-io.c'),
1092              dependencies: [block, qemuutil], install: true)
1093   qemu_block_tools += [qemu_img, qemu_io]
1094   if targetos != 'windows'
1095     qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
1096                dependencies: [block, qemuutil], install: true)
1097     qemu_block_tools += [qemu_nbd]
1098   endif
1099
1100   subdir('storage-daemon')
1101   subdir('contrib/rdmacm-mux')
1102   subdir('contrib/elf2dmp')
1103
1104   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
1105              dependencies: qemuutil,
1106              install: true)
1107
1108   if 'CONFIG_VHOST_USER' in config_host
1109     subdir('contrib/libvhost-user')
1110     subdir('contrib/vhost-user-blk')
1111     subdir('contrib/vhost-user-gpu')
1112     subdir('contrib/vhost-user-input')
1113     subdir('contrib/vhost-user-scsi')
1114   endif
1115
1116   if targetos == 'linux'
1117     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
1118                dependencies: [qemuutil, libcap_ng],
1119                install: true,
1120                install_dir: get_option('libexecdir'))
1121
1122     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
1123                dependencies: [authz, crypto, io, qom, qemuutil,
1124                               libcap_ng, libudev, libmpathpersist],
1125                install: true)
1126   endif
1127
1128   if 'CONFIG_IVSHMEM' in config_host
1129     subdir('contrib/ivshmem-client')
1130     subdir('contrib/ivshmem-server')
1131   endif
1132 endif
1133
1134 subdir('tools')
1135 subdir('pc-bios')
1136 subdir('tests')
1137 subdir('docs')
1138 if 'CONFIG_GTK' in config_host
1139   subdir('po')
1140 endif
1141
1142 if build_docs
1143   makeinfo = find_program('makeinfo', required: build_docs)
1144
1145   docs_inc = [
1146     '-I', meson.current_source_dir(),
1147     '-I', meson.current_build_dir() / 'docs',
1148     '-I', '@OUTDIR@',
1149   ]
1150
1151   version_texi = configure_file(output: 'version.texi',
1152                               input: 'version.texi.in',
1153                               configuration: {'VERSION': meson.project_version(),
1154                                               'qemu_confdir': config_host['qemu_confdir']})
1155
1156   texi = {
1157     'qemu-qmp-ref': ['docs/interop/qemu-qmp-ref.texi', qapi_doc_texi, version_texi],
1158   }
1159   if 'CONFIG_GUEST_AGENT' in config_host
1160     texi += {'qemu-ga-ref': ['docs/interop/qemu-ga-ref.texi', qga_qapi_doc_texi, version_texi]}
1161   endif
1162
1163   if makeinfo.found()
1164     cmd = [
1165       'env', 'LC_ALL=C', makeinfo, '--no-split', '--number-sections', docs_inc,
1166       '@INPUT0@', '-o', '@OUTPUT@',
1167     ]
1168     foreach ext, args: {
1169         'info': [],
1170         'html': ['--no-headers', '--html'],
1171         'txt': ['--no-headers', '--plaintext'],
1172     }
1173       t = []
1174       foreach doc, input: texi
1175         output = doc + '.' + ext
1176         t += custom_target(output,
1177                       input: input,
1178                       output: output,
1179                       install: true,
1180                       install_dir: config_host['qemu_docdir'] / 'interop',
1181                       command: cmd + args)
1182       endforeach
1183       alias_target(ext, t)
1184     endforeach
1185   endif
1186
1187   texi2pdf = find_program('texi2pdf', required: false)
1188
1189   if texi2pdf.found()
1190     pdfs = []
1191     foreach doc, input: texi
1192       output = doc + '.pdf'
1193       pdfs += custom_target(output,
1194                     input: input,
1195                     output: output,
1196                     command: [texi2pdf, '-q', docs_inc, '@INPUT0@', '-o', '@OUTPUT@'],
1197                     build_by_default: false)
1198     endforeach
1199     alias_target('pdf', pdfs)
1200   endif
1201
1202   texi2pod = find_program('scripts/texi2pod.pl')
1203   pod2man = find_program('pod2man', required: build_docs)
1204
1205   if pod2man.found()
1206     foreach doc, input: texi
1207       man = doc + '.7'
1208       pod = custom_target(man + '.pod',
1209                           input: input,
1210                           output: man + '.pod',
1211                           command: [texi2pod,
1212                                     '-DVERSION="' + meson.project_version() + '"',
1213                                     '-DCONFDIR="' + config_host['qemu_confdir'] + '"',
1214                                     '@INPUT0@', '@OUTPUT@'])
1215       man = custom_target(man,
1216                           input: pod,
1217                           output: man,
1218                           capture: true,
1219                           install: true,
1220                           install_dir: config_host['mandir'] / 'man7',
1221                           command: [pod2man, '--utf8', '--section=7', '--center=" "',
1222                                     '--release=" "', '@INPUT@'])
1223     endforeach
1224   endif
1225 endif
1226
1227 summary_info = {}
1228 summary_info += {'Install prefix':    config_host['prefix']}
1229 summary_info += {'BIOS directory':    config_host['qemu_datadir']}
1230 summary_info += {'firmware path':     config_host['qemu_firmwarepath']}
1231 summary_info += {'binary directory':  config_host['bindir']}
1232 summary_info += {'library directory': config_host['libdir']}
1233 summary_info += {'module directory':  config_host['qemu_moddir']}
1234 summary_info += {'libexec directory': config_host['libexecdir']}
1235 summary_info += {'include directory': config_host['includedir']}
1236 summary_info += {'config directory':  config_host['sysconfdir']}
1237 if targetos != 'windows'
1238   summary_info += {'local state directory': config_host['qemu_localstatedir']}
1239   summary_info += {'Manual directory':      config_host['mandir']}
1240 else
1241   summary_info += {'local state directory': 'queried at runtime'}
1242 endif
1243 summary_info += {'Build directory':   meson.current_build_dir()}
1244 summary_info += {'Source path':       meson.current_source_dir()}
1245 summary_info += {'GIT binary':        config_host['GIT']}
1246 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
1247 summary_info += {'C compiler':        meson.get_compiler('c').cmd_array()[0]}
1248 summary_info += {'Host C compiler':   meson.get_compiler('c', native: true).cmd_array()[0]}
1249 if link_language == 'cpp'
1250   summary_info += {'C++ compiler':      meson.get_compiler('cpp').cmd_array()[0]}
1251 else
1252   summary_info += {'C++ compiler':      false}
1253 endif
1254 if targetos == 'darwin'
1255   summary_info += {'Objective-C compiler': meson.get_compiler('objc').cmd_array()[0]}
1256 endif
1257 summary_info += {'ARFLAGS':           config_host['ARFLAGS']}
1258 summary_info += {'CFLAGS':            config_host['CFLAGS']}
1259 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
1260 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
1261 summary_info += {'make':              config_host['MAKE']}
1262 summary_info += {'install':           config_host['INSTALL']}
1263 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
1264 summary_info += {'sphinx-build':      config_host['SPHINX_BUILD']}
1265 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
1266 # TODO: add back version
1267 summary_info += {'slirp support':     config_host.has_key('CONFIG_SLIRP')}
1268 if config_host.has_key('CONFIG_SLIRP')
1269   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
1270 endif
1271 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
1272 if config_host.has_key('CONFIG_MODULES')
1273   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
1274 endif
1275 summary_info += {'host CPU':          cpu}
1276 summary_info += {'host endianness':   build_machine.endian()}
1277 summary_info += {'target list':       config_host['TARGET_DIRS']}
1278 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
1279 summary_info += {'sparse enabled':    meson.get_compiler('c').cmd_array().contains('cgcc')}
1280 summary_info += {'strip binaries':    get_option('strip')}
1281 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
1282 summary_info += {'static build':      config_host.has_key('CONFIG_TOOLS')}
1283 if targetos == 'darwin'
1284   summary_info += {'Cocoa support': config_host.has_key('CONFIG_COCOA')}
1285 endif
1286 # TODO: add back version
1287 summary_info += {'SDL support':       sdl.found()}
1288 summary_info += {'SDL image support': sdl_image.found()}
1289 # TODO: add back version
1290 summary_info += {'GTK support':       config_host.has_key('CONFIG_GTK')}
1291 summary_info += {'GTK GL support':    config_host.has_key('CONFIG_GTK_GL')}
1292 summary_info += {'pixman':            pixman.found()}
1293 # TODO: add back version
1294 summary_info += {'VTE support':       config_host.has_key('CONFIG_VTE')}
1295 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
1296 summary_info += {'GNUTLS support':    config_host.has_key('CONFIG_GNUTLS')}
1297 # TODO: add back version
1298 summary_info += {'libgcrypt':         config_host.has_key('CONFIG_GCRYPT')}
1299 if config_host.has_key('CONFIG_GCRYPT')
1300    summary_info += {'  hmac':            config_host.has_key('CONFIG_GCRYPT_HMAC')}
1301    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
1302 endif
1303 # TODO: add back version
1304 summary_info += {'nettle':            config_host.has_key('CONFIG_NETTLE')}
1305 if config_host.has_key('CONFIG_NETTLE')
1306    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
1307 endif
1308 summary_info += {'libtasn1':          config_host.has_key('CONFIG_TASN1')}
1309 summary_info += {'PAM':               config_host.has_key('CONFIG_AUTH_PAM')}
1310 summary_info += {'iconv support':     config_host.has_key('CONFIG_ICONV')}
1311 summary_info += {'curses support':    config_host.has_key('CONFIG_CURSES')}
1312 # TODO: add back version
1313 summary_info += {'virgl support':     config_host.has_key('CONFIG_VIRGL')}
1314 summary_info += {'curl support':      config_host.has_key('CONFIG_CURL')}
1315 summary_info += {'mingw32 support':   targetos == 'windows'}
1316 summary_info += {'Audio drivers':     config_host['CONFIG_AUDIO_DRIVERS']}
1317 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
1318 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
1319 summary_info += {'VirtFS support':    config_host.has_key('CONFIG_VIRTFS')}
1320 summary_info += {'Multipath support': config_host.has_key('CONFIG_MPATH')}
1321 summary_info += {'VNC support':       vnc.found()}
1322 if vnc.found()
1323   summary_info += {'VNC SASL support':  sasl.found()}
1324   summary_info += {'VNC JPEG support':  jpeg.found()}
1325   summary_info += {'VNC PNG support':   png.found()}
1326 endif
1327 summary_info += {'xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
1328 if config_host.has_key('CONFIG_XEN_BACKEND')
1329   summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
1330 endif
1331 summary_info += {'brlapi support':    config_host.has_key('CONFIG_BRLAPI')}
1332 summary_info += {'Documentation':     config_host.has_key('BUILD_DOCS')}
1333 summary_info += {'PIE':               get_option('b_pie')}
1334 summary_info += {'vde support':       config_host.has_key('CONFIG_VDE')}
1335 summary_info += {'netmap support':    config_host.has_key('CONFIG_NETMAP')}
1336 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
1337 summary_info += {'Linux io_uring support': config_host.has_key('CONFIG_LINUX_IO_URING')}
1338 summary_info += {'ATTR/XATTR support': config_host.has_key('CONFIG_ATTR')}
1339 summary_info += {'Install blobs':     config_host.has_key('INSTALL_BLOBS')}
1340 # TODO: add back KVM/HAX/HVF/WHPX/TCG
1341 #summary_info += {'KVM support':       have_kvm'}
1342 #summary_info += {'HAX support':       have_hax'}
1343 #summary_info += {'HVF support':       have_hvf'}
1344 #summary_info += {'WHPX support':      have_whpx'}
1345 #summary_info += {'TCG support':       have_tcg'}
1346 #if get_option('tcg')
1347 #  summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
1348 #  summary_info += {'TCG interpreter':   config_host.has_key('CONFIG_TCG_INTERPRETER')}
1349 #endif
1350 summary_info += {'malloc trim support': config_host.has_key('CONFIG_MALLOC_TRIM')}
1351 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
1352 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
1353 summary_info += {'fdt support':       config_host.has_key('CONFIG_FDT')}
1354 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
1355 summary_info += {'preadv support':    config_host.has_key('CONFIG_PREADV')}
1356 summary_info += {'fdatasync':         config_host.has_key('CONFIG_FDATASYNC')}
1357 summary_info += {'madvise':           config_host.has_key('CONFIG_MADVISE')}
1358 summary_info += {'posix_madvise':     config_host.has_key('CONFIG_POSIX_MADVISE')}
1359 summary_info += {'posix_memalign':    config_host.has_key('CONFIG_POSIX_MEMALIGN')}
1360 summary_info += {'libcap-ng support': config_host.has_key('CONFIG_LIBCAP_NG')}
1361 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
1362 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
1363 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
1364 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
1365 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_KERNEL')}
1366 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
1367 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
1368 summary_info += {'Trace backends':    config_host['TRACE_BACKENDS']}
1369 if config_host['TRACE_BACKENDS'].split().contains('simple')
1370   summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
1371 endif
1372 # TODO: add back protocol and server version
1373 summary_info += {'spice support':     config_host.has_key('CONFIG_SPICE')}
1374 summary_info += {'rbd support':       config_host.has_key('CONFIG_RBD')}
1375 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
1376 summary_info += {'smartcard support': config_host.has_key('CONFIG_SMARTCARD')}
1377 summary_info += {'libusb':            config_host.has_key('CONFIG_USB_LIBUSB')}
1378 summary_info += {'usb net redir':     config_host.has_key('CONFIG_USB_REDIR')}
1379 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
1380 summary_info += {'OpenGL dmabufs':    config_host.has_key('CONFIG_OPENGL_DMABUF')}
1381 summary_info += {'libiscsi support':  config_host.has_key('CONFIG_LIBISCSI')}
1382 summary_info += {'libnfs support':    config_host.has_key('CONFIG_LIBNFS')}
1383 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
1384 if targetos == 'windows'
1385   if 'WIN_SDK' in config_host
1386     summary_info += {'Windows SDK':       config_host['WIN_SDK']}
1387   endif
1388   summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
1389   summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
1390   summary_info += {'QGA MSI support':   config_host.has_key('CONFIG_QGA_MSI_ENABLED')}
1391 endif
1392 summary_info += {'seccomp support':   config_host.has_key('CONFIG_SECCOMP')}
1393 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
1394 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
1395 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
1396 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
1397 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
1398 summary_info += {'GlusterFS support': config_host.has_key('CONFIG_GLUSTERFS')}
1399 summary_info += {'gcov':              get_option('b_coverage')}
1400 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
1401 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
1402 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
1403 summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
1404 summary_info += {'lzo support':       config_host.has_key('CONFIG_LZO')}
1405 summary_info += {'snappy support':    config_host.has_key('CONFIG_SNAPPY')}
1406 summary_info += {'bzip2 support':     config_host.has_key('CONFIG_BZIP2')}
1407 summary_info += {'lzfse support':     config_host.has_key('CONFIG_LZFSE')}
1408 summary_info += {'zstd support':      config_host.has_key('CONFIG_ZSTD')}
1409 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
1410 summary_info += {'libxml2':           config_host.has_key('CONFIG_LIBXML2')}
1411 summary_info += {'tcmalloc support':  config_host.has_key('CONFIG_TCMALLOC')}
1412 summary_info += {'jemalloc support':  config_host.has_key('CONFIG_JEMALLOC')}
1413 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
1414 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
1415 summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
1416 summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
1417 summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
1418 summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
1419 summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
1420 summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
1421 summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
1422 summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
1423 summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
1424 summary_info += {'sheepdog support':  config_host.has_key('CONFIG_SHEEPDOG')}
1425 summary_info += {'capstone':          config_host.has_key('CONFIG_CAPSTONE')}
1426 summary_info += {'libpmem support':   config_host.has_key('CONFIG_LIBPMEM')}
1427 summary_info += {'libdaxctl support': config_host.has_key('CONFIG_LIBDAXCTL')}
1428 summary_info += {'libudev':           config_host.has_key('CONFIG_LIBUDEV')}
1429 summary_info += {'default devices':   config_host['CONFIG_MINIKCONF_MODE'] == '--defconfig'}
1430 summary_info += {'plugin support':    config_host.has_key('CONFIG_PLUGIN')}
1431 summary_info += {'fuzzing support':   config_host.has_key('CONFIG_FUZZ')}
1432 if config_host.has_key('HAVE_GDB_BIN')
1433   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
1434 endif
1435 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
1436 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
1437 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
1438 summary(summary_info, bool_yn: true)
1439
1440 if not supported_cpus.contains(cpu)
1441   message()
1442   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
1443   message()
1444   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
1445   message('The QEMU project intends to remove support for this host CPU in')
1446   message('a future release if nobody volunteers to maintain it and to')
1447   message('provide a build host for our continuous integration setup.')
1448   message('configure has succeeded and you can continue to build, but')
1449   message('if you care about QEMU on this platform you should contact')
1450   message('us upstream at qemu-devel@nongnu.org.')
1451 endif
1452
1453 if not supported_oses.contains(targetos)
1454   message()
1455   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
1456   message()
1457   message('Host OS ' + targetos + 'support is not currently maintained.')
1458   message('The QEMU project intends to remove support for this host OS in')
1459   message('a future release if nobody volunteers to maintain it and to')
1460   message('provide a build host for our continuous integration setup.')
1461   message('configure has succeeded and you can continue to build, but')
1462   message('if you care about QEMU on this platform you should contact')
1463   message('us upstream at qemu-devel@nongnu.org.')
1464 endif