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