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