meson.build

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