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