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 keyutils = dependency('libkeyutils', required: false,
 419                       method: 'pkg-config', static: enable_static)
 420
 421 has_gettid = cc.has_function('gettid')
 422
 423 # Create config-host.h
 424
 425 config_host_data.set('CONFIG_SDL', sdl.found())
 426 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
 427 config_host_data.set('CONFIG_VNC', vnc.found())
 428 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
 429 config_host_data.set('CONFIG_VNC_PNG', png.found())
 430 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
 431 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
 432 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
 433 config_host_data.set('CONFIG_GETTID', has_gettid)
 434 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
 435 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
 436 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
 437 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
 438
 439 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
 440 strings = ['HOST_DSOSUF', 'CONFIG_IASL', 'qemu_confdir', 'qemu_datadir',
 441            'qemu_moddir', 'qemu_localstatedir', 'qemu_helperdir', 'qemu_localedir',
 442            'qemu_icondir', 'qemu_desktopdir', 'qemu_firmwarepath']
 443 foreach k, v: config_host
 444   if arrays.contains(k)
 445     if v != ''
 446       v = '"' + '", "'.join(v.split()) + '", '
 447     endif
 448     config_host_data.set(k, v)
 449   elif k == 'ARCH'
 450     config_host_data.set('HOST_' + v.to_upper(), 1)
 451   elif strings.contains(k)
 452     if not k.startswith('CONFIG_')
 453       k = 'CONFIG_' + k.to_upper()
 454     endif
 455     config_host_data.set_quoted(k, v)
 456   elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
 457     config_host_data.set(k, v == 'y' ? 1 : v)
 458   endif
 459 endforeach
 460 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
 461
 462 minikconf = find_program('scripts/minikconf.py')
 463 config_devices_mak_list = []
 464 config_devices_h = {}
 465 config_target_h = {}
 466 config_target_mak = {}
 467 kconfig_external_symbols = [
 468   'CONFIG_KVM',
 469   'CONFIG_XEN',
 470   'CONFIG_TPM',
 471   'CONFIG_SPICE',
 472   'CONFIG_IVSHMEM',
 473   'CONFIG_OPENGL',
 474   'CONFIG_X11',
 475   'CONFIG_VHOST_USER',
 476   'CONFIG_VHOST_KERNEL',
 477   'CONFIG_VIRTFS',
 478   'CONFIG_LINUX',
 479   'CONFIG_PVRDMA',
 480 ]
 481 ignored = ['TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_DIRS']
 482 foreach target : target_dirs
 483   config_target = keyval.load(meson.current_build_dir() / target / 'config-target.mak')
 484
 485   config_target_data = configuration_data()
 486   foreach k, v: config_target
 487     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
 488       # do nothing
 489     elif ignored.contains(k)
 490       # do nothing
 491     elif k == 'TARGET_BASE_ARCH'
 492       config_target_data.set('TARGET_' + v.to_upper(), 1)
 493     elif k == 'TARGET_NAME'
 494       config_target_data.set_quoted(k, v)
 495     elif v == 'y'
 496       config_target_data.set(k, 1)
 497     else
 498       config_target_data.set(k, v)
 499     endif
 500   endforeach
 501   config_target_h += {target: configure_file(output: target + '-config-target.h',
 502                                                configuration: config_target_data)}
 503
 504   if target.endswith('-softmmu')
 505     base_kconfig = []
 506     foreach sym : kconfig_external_symbols
 507       if sym in config_target or sym in config_host
 508         base_kconfig += '@0@=y'.format(sym)
 509       endif
 510     endforeach
 511
 512     config_devices_mak = target + '-config-devices.mak'
 513     config_devices_mak = configure_file(
 514       input: ['default-configs' / target + '.mak', 'Kconfig'],
 515       output: config_devices_mak,
 516       depfile: config_devices_mak + '.d',
 517       capture: true,
 518       command: [minikconf, config_host['CONFIG_MINIKCONF_MODE'],
 519                 config_devices_mak, '@DEPFILE@', '@INPUT@',
 520                 base_kconfig])
 521
 522     config_devices_data = configuration_data()
 523     config_devices = keyval.load(config_devices_mak)
 524     foreach k, v: config_devices
 525       config_devices_data.set(k, 1)
 526     endforeach
 527     config_devices_mak_list += config_devices_mak
 528     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
 529                                                 configuration: config_devices_data)}
 530     config_target += config_devices
 531   endif
 532   config_target_mak += {target: config_target}
 533 endforeach
 534
 535 grepy = find_program('scripts/grepy.sh')
 536 # This configuration is used to build files that are shared by
 537 # multiple binaries, and then extracted out of the "common"
 538 # static_library target.
 539 #
 540 # We do not use all_sources()/all_dependencies(), because it would
 541 # build literally all source files, including devices only used by
 542 # targets that are not built for this compilation.  The CONFIG_ALL
 543 # pseudo symbol replaces it.
 544
 545 if have_system
 546   config_all_devices_mak = configure_file(
 547     output: 'config-all-devices.mak',
 548     input: config_devices_mak_list,
 549     capture: true,
 550     command: [grepy, '@INPUT@'],
 551   )
 552   config_all_devices = keyval.load(config_all_devices_mak)
 553 else
 554   config_all_devices = {}
 555 endif
 556 config_all = config_all_devices
 557 config_all += config_host
 558 config_all += config_all_disas
 559 config_all += {
 560   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
 561   'CONFIG_SOFTMMU': have_system,
 562   'CONFIG_USER_ONLY': have_user,
 563   'CONFIG_ALL': true,
 564 }
 565
 566 # Generators
 567
 568 hxtool = find_program('scripts/hxtool')
 569 shaderinclude = find_program('scripts/shaderinclude.pl')
 570 qapi_gen = find_program('scripts/qapi-gen.py')
 571 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
 572                      meson.source_root() / 'scripts/qapi/commands.py',
 573                      meson.source_root() / 'scripts/qapi/common.py',
 574                      meson.source_root() / 'scripts/qapi/doc.py',
 575                      meson.source_root() / 'scripts/qapi/error.py',
 576                      meson.source_root() / 'scripts/qapi/events.py',
 577                      meson.source_root() / 'scripts/qapi/expr.py',
 578                      meson.source_root() / 'scripts/qapi/gen.py',
 579                      meson.source_root() / 'scripts/qapi/introspect.py',
 580                      meson.source_root() / 'scripts/qapi/parser.py',
 581                      meson.source_root() / 'scripts/qapi/schema.py',
 582                      meson.source_root() / 'scripts/qapi/source.py',
 583                      meson.source_root() / 'scripts/qapi/types.py',
 584                      meson.source_root() / 'scripts/qapi/visit.py',
 585                      meson.source_root() / 'scripts/qapi/common.py',
 586                      meson.source_root() / 'scripts/qapi/doc.py',
 587                      meson.source_root() / 'scripts/qapi-gen.py'
 588 ]
 589
 590 tracetool = [
 591   python, files('scripts/tracetool.py'),
 592    '--backend=' + config_host['TRACE_BACKENDS']
 593 ]
 594
 595 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
 596                     meson.current_source_dir(),
 597                     config_host['PKGVERSION'], meson.project_version()]
 598 qemu_version = custom_target('qemu-version.h',
 599                              output: 'qemu-version.h',
 600                              command: qemu_version_cmd,
 601                              capture: true,
 602                              build_by_default: true,
 603                              build_always_stale: true)
 604 genh += qemu_version
 605
 606 hxdep = []
 607 hx_headers = [
 608   ['qemu-options.hx', 'qemu-options.def'],
 609   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
 610 ]
 611 if have_system
 612   hx_headers += [
 613     ['hmp-commands.hx', 'hmp-commands.h'],
 614     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
 615   ]
 616 endif
 617 foreach d : hx_headers
 618   hxdep += custom_target(d[1],
 619                 input: files(d[0]),
 620                 output: d[1],
 621                 capture: true,
 622                 build_by_default: true, # to be removed when added to a target
 623                 command: [hxtool, '-h', '@INPUT0@'])
 624 endforeach
 625 genh += hxdep
 626
 627 # Collect sourcesets.
 628
 629 util_ss = ss.source_set()
 630 stub_ss = ss.source_set()
 631 trace_ss = ss.source_set()
 632 block_ss = ss.source_set()
 633 blockdev_ss = ss.source_set()
 634 qmp_ss = ss.source_set()
 635 common_ss = ss.source_set()
 636 softmmu_ss = ss.source_set()
 637 user_ss = ss.source_set()
 638 bsd_user_ss = ss.source_set()
 639 linux_user_ss = ss.source_set()
 640 specific_ss = ss.source_set()
 641 specific_fuzz_ss = ss.source_set()
 642
 643 modules = {}
 644 hw_arch = {}
 645 target_arch = {}
 646 target_softmmu_arch = {}
 647
 648 ###############
 649 # Trace files #
 650 ###############
 651
 652 # TODO: add each directory to the subdirs from its own meson.build, once
 653 # we have those
 654 trace_events_subdirs = [
 655   'accel/kvm',
 656   'accel/tcg',
 657   'crypto',
 658   'monitor',
 659 ]
 660 if have_user
 661   trace_events_subdirs += [ 'linux-user' ]
 662 endif
 663 if have_block
 664   trace_events_subdirs += [
 665     'authz',
 666     'block',
 667     'io',
 668     'nbd',
 669     'scsi',
 670   ]
 671 endif
 672 if have_system
 673   trace_events_subdirs += [
 674     'audio',
 675     'backends',
 676     'backends/tpm',
 677     'chardev',
 678     'hw/9pfs',
 679     'hw/acpi',
 680     'hw/alpha',
 681     'hw/arm',
 682     'hw/audio',
 683     'hw/block',
 684     'hw/block/dataplane',
 685     'hw/char',
 686     'hw/display',
 687     'hw/dma',
 688     'hw/hppa',
 689     'hw/hyperv',
 690     'hw/i2c',
 691     'hw/i386',
 692     'hw/i386/xen',
 693     'hw/ide',
 694     'hw/input',
 695     'hw/intc',
 696     'hw/isa',
 697     'hw/mem',
 698     'hw/mips',
 699     'hw/misc',
 700     'hw/misc/macio',
 701     'hw/net',
 702     'hw/nvram',
 703     'hw/pci',
 704     'hw/pci-host',
 705     'hw/ppc',
 706     'hw/rdma',
 707     'hw/rdma/vmw',
 708     'hw/rtc',
 709     'hw/s390x',
 710     'hw/scsi',
 711     'hw/sd',
 712     'hw/sparc',
 713     'hw/sparc64',
 714     'hw/ssi',
 715     'hw/timer',
 716     'hw/tpm',
 717     'hw/usb',
 718     'hw/vfio',
 719     'hw/virtio',
 720     'hw/watchdog',
 721     'hw/xen',
 722     'hw/gpio',
 723     'hw/riscv',
 724     'migration',
 725     'net',
 726     'ui',
 727   ]
 728 endif
 729 trace_events_subdirs += [
 730   'hw/core',
 731   'qapi',
 732   'qom',
 733   'target/arm',
 734   'target/hppa',
 735   'target/i386',
 736   'target/mips',
 737   'target/ppc',
 738   'target/riscv',
 739   'target/s390x',
 740   'target/sparc',
 741   'util',
 742 ]
 743
 744 subdir('qapi')
 745 subdir('qobject')
 746 subdir('stubs')
 747 subdir('trace')
 748 subdir('util')
 749 subdir('qom')
 750 subdir('authz')
 751 subdir('crypto')
 752 subdir('ui')
 753
 754
 755 if enable_modules
 756   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
 757   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
 758 endif
 759
 760 # Build targets from sourcesets
 761
 762 stub_ss = stub_ss.apply(config_all, strict: false)
 763
 764 util_ss.add_all(trace_ss)
 765 util_ss = util_ss.apply(config_all, strict: false)
 766 libqemuutil = static_library('qemuutil',
 767                              sources: util_ss.sources() + stub_ss.sources() + genh,
 768                              dependencies: [util_ss.dependencies(), m, glib, socket])
 769 qemuutil = declare_dependency(link_with: libqemuutil,
 770                               sources: genh + version_res)
 771
 772 decodetree = generator(find_program('scripts/decodetree.py'),
 773                        output: 'decode-@BASENAME@.c.inc',
 774                        arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
 775
 776 subdir('audio')
 777 subdir('io')
 778 subdir('chardev')
 779 subdir('fsdev')
 780 subdir('libdecnumber')
 781 subdir('target')
 782 subdir('dump')
 783
 784 block_ss.add(files(
 785   'block.c',
 786   'blockjob.c',
 787   'job.c',
 788   'qemu-io-cmds.c',
 789 ))
 790 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
 791
 792 subdir('nbd')
 793 subdir('scsi')
 794 subdir('block')
 795
 796 blockdev_ss.add(files(
 797   'blockdev.c',
 798   'blockdev-nbd.c',
 799   'iothread.c',
 800   'job-qmp.c',
 801 ))
 802
 803 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
 804 # os-win32.c does not
 805 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
 806 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
 807
 808 softmmu_ss.add_all(blockdev_ss)
 809 softmmu_ss.add(files(
 810   'bootdevice.c',
 811   'dma-helpers.c',
 812   'qdev-monitor.c',
 813 ), sdl)
 814
 815 softmmu_ss.add(when: 'CONFIG_TPM', if_true: files('tpm.c'))
 816 softmmu_ss.add(when: 'CONFIG_SECCOMP', if_true: [files('qemu-seccomp.c'), seccomp])
 817 softmmu_ss.add(when: ['CONFIG_FDT', fdt],  if_true: [files('device_tree.c')])
 818
 819 common_ss.add(files('cpus-common.c'))
 820
 821 subdir('softmmu')
 822
 823 specific_ss.add(files('disas.c', 'exec.c', 'gdbstub.c'), capstone, libpmem, libdaxctl)
 824 specific_ss.add(files('exec-vary.c'))
 825 specific_ss.add(when: 'CONFIG_TCG', if_true: files(
 826   'fpu/softfloat.c',
 827   'tcg/optimize.c',
 828   'tcg/tcg-common.c',
 829   'tcg/tcg-op-gvec.c',
 830   'tcg/tcg-op-vec.c',
 831   'tcg/tcg-op.c',
 832   'tcg/tcg.c',
 833 ))
 834 specific_ss.add(when: 'CONFIG_TCG_INTERPRETER', if_true: files('disas/tci.c', 'tcg/tci.c'))
 835
 836 subdir('backends')
 837 subdir('disas')
 838 subdir('migration')
 839 subdir('monitor')
 840 subdir('net')
 841 subdir('replay')
 842 subdir('hw')
 843 subdir('accel')
 844 subdir('plugins')
 845 subdir('bsd-user')
 846 subdir('linux-user')
 847
 848 bsd_user_ss.add(files('gdbstub.c'))
 849 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
 850
 851 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
 852 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
 853
 854 # needed for fuzzing binaries
 855 subdir('tests/qtest/libqos')
 856 subdir('tests/qtest/fuzz')
 857
 858 block_mods = []
 859 softmmu_mods = []
 860 foreach d, list : modules
 861   foreach m, module_ss : list
 862     if enable_modules and targetos != 'windows'
 863       module_ss = module_ss.apply(config_host, strict: false)
 864       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
 865                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
 866       if d == 'block'
 867         block_mods += sl
 868       else
 869         softmmu_mods += sl
 870       endif
 871     else
 872       if d == 'block'
 873         block_ss.add_all(module_ss)
 874       else
 875         softmmu_ss.add_all(module_ss)
 876       endif
 877     endif
 878   endforeach
 879 endforeach
 880
 881 nm = find_program('nm')
 882 undefsym = find_program('scripts/undefsym.sh')
 883 block_syms = custom_target('block.syms', output: 'block.syms',
 884                              input: [libqemuutil, block_mods],
 885                              capture: true,
 886                              command: [undefsym, nm, '@INPUT@'])
 887 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
 888                              input: [libqemuutil, softmmu_mods],
 889                              capture: true,
 890                              command: [undefsym, nm, '@INPUT@'])
 891
 892 block_ss = block_ss.apply(config_host, strict: false)
 893 libblock = static_library('block', block_ss.sources() + genh,
 894                           dependencies: block_ss.dependencies(),
 895                           link_depends: block_syms,
 896                           name_suffix: 'fa',
 897                           build_by_default: false)
 898
 899 block = declare_dependency(link_whole: [libblock],
 900                            link_args: '@block.syms',
 901                            dependencies: [crypto, io])
 902
 903 qmp_ss = qmp_ss.apply(config_host, strict: false)
 904 libqmp = static_library('qmp', qmp_ss.sources() + genh,
 905                         dependencies: qmp_ss.dependencies(),
 906                         name_suffix: 'fa',
 907                         build_by_default: false)
 908
 909 qmp = declare_dependency(link_whole: [libqmp])
 910
 911 foreach m : block_mods + softmmu_mods
 912   shared_module(m.name(),
 913                 name_prefix: '',
 914                 link_whole: m,
 915                 install: true,
 916                 install_dir: config_host['qemu_moddir'])
 917 endforeach
 918
 919 softmmu_ss.add(authz, block, chardev, crypto, io, qmp)
 920 common_ss.add(qom, qemuutil)
 921
 922 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
 923 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
 924
 925 common_all = common_ss.apply(config_all, strict: false)
 926 common_all = static_library('common',
 927                             build_by_default: false,
 928                             sources: common_all.sources() + genh,
 929                             dependencies: common_all.dependencies(),
 930                             name_suffix: 'fa')
 931
 932 feature_to_c = find_program('scripts/feature_to_c.sh')
 933
 934 emulators = []
 935 foreach target : target_dirs
 936   config_target = config_target_mak[target]
 937   target_name = config_target['TARGET_NAME']
 938   arch = config_target['TARGET_BASE_ARCH']
 939   arch_srcs = [config_target_h[target]]
 940   arch_deps = []
 941   c_args = ['-DNEED_CPU_H',
 942             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
 943             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
 944   link_args = []
 945
 946   config_target += config_host
 947   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
 948   if targetos == 'linux'
 949     target_inc += include_directories('linux-headers', is_system: true)
 950   endif
 951   if target.endswith('-softmmu')
 952     qemu_target_name = 'qemu-system-' + target_name
 953     target_type='system'
 954     t = target_softmmu_arch[arch].apply(config_target, strict: false)
 955     arch_srcs += t.sources()
 956     arch_deps += t.dependencies()
 957
 958     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
 959     hw = hw_arch[hw_dir].apply(config_target, strict: false)
 960     arch_srcs += hw.sources()
 961     arch_deps += hw.dependencies()
 962
 963     arch_srcs += config_devices_h[target]
 964     link_args += ['@block.syms', '@qemu.syms']
 965   else
 966     abi = config_target['TARGET_ABI_DIR']
 967     target_type='user'
 968     qemu_target_name = 'qemu-' + target_name
 969     if 'CONFIG_LINUX_USER' in config_target
 970       base_dir = 'linux-user'
 971       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
 972     else
 973       base_dir = 'bsd-user'
 974     endif
 975     target_inc += include_directories(
 976       base_dir,
 977       base_dir / abi,
 978     )
 979     if 'CONFIG_LINUX_USER' in config_target
 980       dir = base_dir / abi
 981       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
 982       if config_target.has_key('TARGET_SYSTBL_ABI')
 983         arch_srcs += \
 984           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
 985                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
 986       endif
 987     endif
 988   endif
 989
 990   if 'TARGET_XML_FILES' in config_target
 991     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
 992                                 output: target + '-gdbstub-xml.c',
 993                                 input: files(config_target['TARGET_XML_FILES'].split()),
 994                                 command: [feature_to_c, '@INPUT@'],
 995                                 capture: true)
 996     arch_srcs += gdbstub_xml
 997   endif
 998
 999   t = target_arch[arch].apply(config_target, strict: false)
1000   arch_srcs += t.sources()
1001   arch_deps += t.dependencies()
1002
1003   target_common = common_ss.apply(config_target, strict: false)
1004   objects = common_all.extract_objects(target_common.sources())
1005   deps = target_common.dependencies()
1006
1007   target_specific = specific_ss.apply(config_target, strict: false)
1008   arch_srcs += target_specific.sources()
1009   arch_deps += target_specific.dependencies()
1010
1011   lib = static_library('qemu-' + target,
1012                  sources: arch_srcs + genh,
1013                  dependencies: arch_deps,
1014                  objects: objects,
1015                  include_directories: target_inc,
1016                  c_args: c_args,
1017                  build_by_default: false,
1018                  name_suffix: 'fa')
1019
1020   if target.endswith('-softmmu')
1021     execs = [{
1022       'name': 'qemu-system-' + target_name,
1023       'gui': false,
1024       'sources': files('softmmu/main.c'),
1025       'dependencies': []
1026     }]
1027     if targetos == 'windows' and (sdl.found() or gtk.found())
1028       execs += [{
1029         'name': 'qemu-system-' + target_name + 'w',
1030         'gui': true,
1031         'sources': files('softmmu/main.c'),
1032         'dependencies': []
1033       }]
1034     endif
1035     if config_host.has_key('CONFIG_FUZZ')
1036       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
1037       execs += [{
1038         'name': 'qemu-fuzz-' + target_name,
1039         'gui': false,
1040         'sources': specific_fuzz.sources(),
1041         'dependencies': specific_fuzz.dependencies(),
1042         'link_depends': [files('tests/qtest/fuzz/fork_fuzz.ld')],
1043       }]
1044     endif
1045   else
1046     execs = [{
1047       'name': 'qemu-' + target_name,
1048       'gui': false,
1049       'sources': [],
1050       'dependencies': []
1051     }]
1052   endif
1053   foreach exe: execs
1054     emulators += executable(exe['name'], exe['sources'],
1055                install: true,
1056                c_args: c_args,
1057                dependencies: arch_deps + deps + exe['dependencies'],
1058                objects: lib.extract_all_objects(recursive: true),
1059                link_language: link_language,
1060                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
1061                link_args: link_args,
1062                gui_app: exe['gui'])
1063
1064     if 'CONFIG_TRACE_SYSTEMTAP' in config_host
1065       foreach stp: [
1066         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
1067         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
1068         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
1069         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
1070       ]
1071         custom_target(exe['name'] + stp['ext'],
1072                       input: trace_events_all,
1073                       output: exe['name'] + stp['ext'],
1074                       capture: true,
1075                       install: stp['install'],
1076                       install_dir: qemu_datadir / '../systemtap/tapset',
1077                       command: [
1078                         tracetool, '--group=all', '--format=' + stp['fmt'],
1079                         '--binary=' + stp['bin'],
1080                         '--target-name=' + target_name,
1081                         '--target-type=' + target_type,
1082                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
1083                         '@INPUT@',
1084                       ])
1085       endforeach
1086     endif
1087   endforeach
1088 endforeach
1089
1090 # Other build targets
1091
1092 if 'CONFIG_PLUGIN' in config_host
1093   install_headers('include/qemu/qemu-plugin.h')
1094 endif
1095
1096 if 'CONFIG_GUEST_AGENT' in config_host
1097   subdir('qga')
1098 endif
1099
1100 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
1101 # when we don't build tools or system
1102 if xkbcommon.found()
1103   # used for the update-keymaps target, so include rules even if !have_tools
1104   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
1105                            dependencies: [qemuutil, xkbcommon], install: have_tools)
1106 endif
1107
1108 qemu_block_tools = []
1109 if have_tools
1110   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
1111              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
1112   qemu_io = executable('qemu-io', files('qemu-io.c'),
1113              dependencies: [block, qemuutil], install: true)
1114   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
1115                dependencies: [block, qemuutil], install: true)
1116
1117   subdir('storage-daemon')
1118   subdir('contrib/rdmacm-mux')
1119   subdir('contrib/elf2dmp')
1120
1121   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
1122              dependencies: qemuutil,
1123              install: true)
1124
1125   if 'CONFIG_VHOST_USER' in config_host
1126     subdir('contrib/libvhost-user')
1127     subdir('contrib/vhost-user-blk')
1128     subdir('contrib/vhost-user-gpu')
1129     subdir('contrib/vhost-user-input')
1130     subdir('contrib/vhost-user-scsi')
1131   endif
1132
1133   if targetos == 'linux'
1134     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
1135                dependencies: [qemuutil, libcap_ng],
1136                install: true,
1137                install_dir: get_option('libexecdir'))
1138
1139     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
1140                dependencies: [authz, crypto, io, qom, qemuutil,
1141                               libcap_ng, libudev, libmpathpersist],
1142                install: true)
1143   endif
1144
1145   if 'CONFIG_IVSHMEM' in config_host
1146     subdir('contrib/ivshmem-client')
1147     subdir('contrib/ivshmem-server')
1148   endif
1149 endif
1150
1151 subdir('scripts')
1152 subdir('tools')
1153 subdir('pc-bios')
1154 subdir('tests')
1155 subdir('docs')
1156 if 'CONFIG_GTK' in config_host
1157   subdir('po')
1158 endif
1159
1160 if build_docs
1161   makeinfo = find_program('makeinfo', required: build_docs)
1162
1163   docs_inc = [
1164     '-I', meson.current_source_dir(),
1165     '-I', meson.current_build_dir() / 'docs',
1166     '-I', '@OUTDIR@',
1167   ]
1168
1169   version_texi = configure_file(output: 'version.texi',
1170                               input: 'version.texi.in',
1171                               configuration: {'VERSION': meson.project_version(),
1172                                               'qemu_confdir': config_host['qemu_confdir']})
1173
1174   texi = {
1175     'qemu-qmp-ref': ['docs/interop/qemu-qmp-ref.texi', qapi_doc_texi, version_texi],
1176   }
1177   if 'CONFIG_GUEST_AGENT' in config_host
1178     texi += {'qemu-ga-ref': ['docs/interop/qemu-ga-ref.texi', qga_qapi_doc_texi, version_texi]}
1179   endif
1180
1181   if makeinfo.found()
1182     cmd = [
1183       'env', 'LC_ALL=C', makeinfo, '--no-split', '--number-sections', docs_inc,
1184       '@INPUT0@', '-o', '@OUTPUT@',
1185     ]
1186     foreach ext, args: {
1187         'info': [],
1188         'html': ['--no-headers', '--html'],
1189         'txt': ['--no-headers', '--plaintext'],
1190     }
1191       t = []
1192       foreach doc, input: texi
1193         output = doc + '.' + ext
1194         t += custom_target(output,
1195                       input: input,
1196                       output: output,
1197                       install: true,
1198                       install_dir: qemu_docdir / 'interop',
1199                       command: cmd + args)
1200       endforeach
1201       alias_target(ext, t)
1202     endforeach
1203   endif
1204
1205   texi2pdf = find_program('texi2pdf', required: false)
1206
1207   if texi2pdf.found()
1208     pdfs = []
1209     foreach doc, input: texi
1210       output = doc + '.pdf'
1211       pdfs += custom_target(output,
1212                     input: input,
1213                     output: output,
1214                     command: [texi2pdf, '-q', docs_inc, '@INPUT0@', '-o', '@OUTPUT@'],
1215                     build_by_default: false)
1216     endforeach
1217     alias_target('pdf', pdfs)
1218   endif
1219
1220   texi2pod = find_program('scripts/texi2pod.pl')
1221   pod2man = find_program('pod2man', required: build_docs)
1222
1223   if pod2man.found()
1224     foreach doc, input: texi
1225       man = doc + '.7'
1226       pod = custom_target(man + '.pod',
1227                           input: input,
1228                           output: man + '.pod',
1229                           command: [texi2pod,
1230                                     '-DVERSION="' + meson.project_version() + '"',
1231                                     '-DCONFDIR="' + config_host['qemu_confdir'] + '"',
1232                                     '@INPUT0@', '@OUTPUT@'])
1233       man = custom_target(man,
1234                           input: pod,
1235                           output: man,
1236                           capture: true,
1237                           install: true,
1238                           install_dir: get_option('mandir') / 'man7',
1239                           command: [pod2man, '--utf8', '--section=7', '--center=" "',
1240                                     '--release=" "', '@INPUT@'])
1241     endforeach
1242   endif
1243 endif
1244
1245 if host_machine.system() == 'windows'
1246   nsis_cmd = [
1247     find_program('scripts/nsis.py'),
1248     '@OUTPUT@',
1249     get_option('prefix'),
1250     meson.current_source_dir(),
1251     host_machine.cpu_family(),
1252     '--',
1253     '-DDISPLAYVERSION=' + meson.project_version(),
1254   ]
1255   if build_docs
1256     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
1257   endif
1258   if 'CONFIG_GTK' in config_host
1259     nsis_cmd += '-DCONFIG_GTK=y'
1260   endif
1261
1262   nsis = custom_target('nsis',
1263                        output: 'qemu-setup-' + meson.project_version() + '.exe',
1264                        input: files('qemu.nsi'),
1265                        build_always_stale: true,
1266                        command: nsis_cmd + ['@INPUT@'])
1267   alias_target('installer', nsis)
1268 endif
1269
1270 summary_info = {}
1271 summary_info += {'Install prefix':    config_host['prefix']}
1272 summary_info += {'BIOS directory':    config_host['qemu_datadir']}
1273 summary_info += {'firmware path':     config_host['qemu_firmwarepath']}
1274 summary_info += {'binary directory':  config_host['bindir']}
1275 summary_info += {'library directory': config_host['libdir']}
1276 summary_info += {'module directory':  config_host['qemu_moddir']}
1277 summary_info += {'libexec directory': config_host['libexecdir']}
1278 summary_info += {'include directory': config_host['includedir']}
1279 summary_info += {'config directory':  config_host['sysconfdir']}
1280 if targetos != 'windows'
1281   summary_info += {'local state directory': config_host['qemu_localstatedir']}
1282   summary_info += {'Manual directory':      get_option('mandir')}
1283 else
1284   summary_info += {'local state directory': 'queried at runtime'}
1285 endif
1286 summary_info += {'Doc directory':     get_option('docdir')}
1287 summary_info += {'Build directory':   meson.current_build_dir()}
1288 summary_info += {'Source path':       meson.current_source_dir()}
1289 summary_info += {'GIT binary':        config_host['GIT']}
1290 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
1291 summary_info += {'C compiler':        meson.get_compiler('c').cmd_array()[0]}
1292 summary_info += {'Host C compiler':   meson.get_compiler('c', native: true).cmd_array()[0]}
1293 if link_language == 'cpp'
1294   summary_info += {'C++ compiler':      meson.get_compiler('cpp').cmd_array()[0]}
1295 else
1296   summary_info += {'C++ compiler':      false}
1297 endif
1298 if targetos == 'darwin'
1299   summary_info += {'Objective-C compiler': meson.get_compiler('objc').cmd_array()[0]}
1300 endif
1301 summary_info += {'ARFLAGS':           config_host['ARFLAGS']}
1302 summary_info += {'CFLAGS':            config_host['CFLAGS']}
1303 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
1304 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
1305 summary_info += {'make':              config_host['MAKE']}
1306 summary_info += {'install':           config_host['INSTALL']}
1307 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
1308 summary_info += {'sphinx-build':      config_host['SPHINX_BUILD']}
1309 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
1310 # TODO: add back version
1311 summary_info += {'slirp support':     config_host.has_key('CONFIG_SLIRP')}
1312 if config_host.has_key('CONFIG_SLIRP')
1313   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
1314 endif
1315 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
1316 if config_host.has_key('CONFIG_MODULES')
1317   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
1318 endif
1319 summary_info += {'host CPU':          cpu}
1320 summary_info += {'host endianness':   build_machine.endian()}
1321 summary_info += {'target list':       config_host['TARGET_DIRS']}
1322 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
1323 summary_info += {'sparse enabled':    meson.get_compiler('c').cmd_array().contains('cgcc')}
1324 summary_info += {'strip binaries':    get_option('strip')}
1325 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
1326 summary_info += {'static build':      config_host.has_key('CONFIG_TOOLS')}
1327 if targetos == 'darwin'
1328   summary_info += {'Cocoa support': config_host.has_key('CONFIG_COCOA')}
1329 endif
1330 # TODO: add back version
1331 summary_info += {'SDL support':       sdl.found()}
1332 summary_info += {'SDL image support': sdl_image.found()}
1333 # TODO: add back version
1334 summary_info += {'GTK support':       config_host.has_key('CONFIG_GTK')}
1335 summary_info += {'GTK GL support':    config_host.has_key('CONFIG_GTK_GL')}
1336 summary_info += {'pixman':            pixman.found()}
1337 # TODO: add back version
1338 summary_info += {'VTE support':       config_host.has_key('CONFIG_VTE')}
1339 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
1340 summary_info += {'GNUTLS support':    config_host.has_key('CONFIG_GNUTLS')}
1341 # TODO: add back version
1342 summary_info += {'libgcrypt':         config_host.has_key('CONFIG_GCRYPT')}
1343 if config_host.has_key('CONFIG_GCRYPT')
1344    summary_info += {'  hmac':            config_host.has_key('CONFIG_GCRYPT_HMAC')}
1345    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
1346 endif
1347 # TODO: add back version
1348 summary_info += {'nettle':            config_host.has_key('CONFIG_NETTLE')}
1349 if config_host.has_key('CONFIG_NETTLE')
1350    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
1351 endif
1352 summary_info += {'libtasn1':          config_host.has_key('CONFIG_TASN1')}
1353 summary_info += {'PAM':               config_host.has_key('CONFIG_AUTH_PAM')}
1354 summary_info += {'iconv support':     config_host.has_key('CONFIG_ICONV')}
1355 summary_info += {'curses support':    config_host.has_key('CONFIG_CURSES')}
1356 # TODO: add back version
1357 summary_info += {'virgl support':     config_host.has_key('CONFIG_VIRGL')}
1358 summary_info += {'curl support':      config_host.has_key('CONFIG_CURL')}
1359 summary_info += {'mingw32 support':   targetos == 'windows'}
1360 summary_info += {'Audio drivers':     config_host['CONFIG_AUDIO_DRIVERS']}
1361 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
1362 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
1363 summary_info += {'VirtFS support':    config_host.has_key('CONFIG_VIRTFS')}
1364 summary_info += {'Multipath support': config_host.has_key('CONFIG_MPATH')}
1365 summary_info += {'VNC support':       vnc.found()}
1366 if vnc.found()
1367   summary_info += {'VNC SASL support':  sasl.found()}
1368   summary_info += {'VNC JPEG support':  jpeg.found()}
1369   summary_info += {'VNC PNG support':   png.found()}
1370 endif
1371 summary_info += {'xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
1372 if config_host.has_key('CONFIG_XEN_BACKEND')
1373   summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
1374 endif
1375 summary_info += {'brlapi support':    config_host.has_key('CONFIG_BRLAPI')}
1376 summary_info += {'Documentation':     config_host.has_key('BUILD_DOCS')}
1377 summary_info += {'PIE':               get_option('b_pie')}
1378 summary_info += {'vde support':       config_host.has_key('CONFIG_VDE')}
1379 summary_info += {'netmap support':    config_host.has_key('CONFIG_NETMAP')}
1380 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
1381 summary_info += {'Linux io_uring support': config_host.has_key('CONFIG_LINUX_IO_URING')}
1382 summary_info += {'ATTR/XATTR support': config_host.has_key('CONFIG_ATTR')}
1383 summary_info += {'Install blobs':     config_host.has_key('INSTALL_BLOBS')}
1384 # TODO: add back KVM/HAX/HVF/WHPX/TCG
1385 #summary_info += {'KVM support':       have_kvm'}
1386 #summary_info += {'HAX support':       have_hax'}
1387 #summary_info += {'HVF support':       have_hvf'}
1388 #summary_info += {'WHPX support':      have_whpx'}
1389 #summary_info += {'TCG support':       have_tcg'}
1390 #if get_option('tcg')
1391 #  summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
1392 #  summary_info += {'TCG interpreter':   config_host.has_key('CONFIG_TCG_INTERPRETER')}
1393 #endif
1394 summary_info += {'malloc trim support': config_host.has_key('CONFIG_MALLOC_TRIM')}
1395 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
1396 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
1397 summary_info += {'fdt support':       config_host.has_key('CONFIG_FDT')}
1398 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
1399 summary_info += {'preadv support':    config_host.has_key('CONFIG_PREADV')}
1400 summary_info += {'fdatasync':         config_host.has_key('CONFIG_FDATASYNC')}
1401 summary_info += {'madvise':           config_host.has_key('CONFIG_MADVISE')}
1402 summary_info += {'posix_madvise':     config_host.has_key('CONFIG_POSIX_MADVISE')}
1403 summary_info += {'posix_memalign':    config_host.has_key('CONFIG_POSIX_MEMALIGN')}
1404 summary_info += {'libcap-ng support': config_host.has_key('CONFIG_LIBCAP_NG')}
1405 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
1406 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
1407 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
1408 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
1409 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_KERNEL')}
1410 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
1411 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
1412 summary_info += {'Trace backends':    config_host['TRACE_BACKENDS']}
1413 if config_host['TRACE_BACKENDS'].split().contains('simple')
1414   summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
1415 endif
1416 # TODO: add back protocol and server version
1417 summary_info += {'spice support':     config_host.has_key('CONFIG_SPICE')}
1418 summary_info += {'rbd support':       config_host.has_key('CONFIG_RBD')}
1419 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
1420 summary_info += {'smartcard support': config_host.has_key('CONFIG_SMARTCARD')}
1421 summary_info += {'U2F support':       u2f.found()}
1422 summary_info += {'libusb':            config_host.has_key('CONFIG_USB_LIBUSB')}
1423 summary_info += {'usb net redir':     config_host.has_key('CONFIG_USB_REDIR')}
1424 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
1425 summary_info += {'OpenGL dmabufs':    config_host.has_key('CONFIG_OPENGL_DMABUF')}
1426 summary_info += {'libiscsi support':  config_host.has_key('CONFIG_LIBISCSI')}
1427 summary_info += {'libnfs support':    config_host.has_key('CONFIG_LIBNFS')}
1428 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
1429 if targetos == 'windows'
1430   if 'WIN_SDK' in config_host
1431     summary_info += {'Windows SDK':       config_host['WIN_SDK']}
1432   endif
1433   summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
1434   summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
1435   summary_info += {'QGA MSI support':   config_host.has_key('CONFIG_QGA_MSI_ENABLED')}
1436 endif
1437 summary_info += {'seccomp support':   config_host.has_key('CONFIG_SECCOMP')}
1438 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
1439 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
1440 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
1441 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
1442 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
1443 summary_info += {'GlusterFS support': config_host.has_key('CONFIG_GLUSTERFS')}
1444 summary_info += {'gcov':              get_option('b_coverage')}
1445 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
1446 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
1447 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
1448 summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
1449 summary_info += {'lzo support':       config_host.has_key('CONFIG_LZO')}
1450 summary_info += {'snappy support':    config_host.has_key('CONFIG_SNAPPY')}
1451 summary_info += {'bzip2 support':     config_host.has_key('CONFIG_BZIP2')}
1452 summary_info += {'lzfse support':     config_host.has_key('CONFIG_LZFSE')}
1453 summary_info += {'zstd support':      config_host.has_key('CONFIG_ZSTD')}
1454 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
1455 summary_info += {'libxml2':           config_host.has_key('CONFIG_LIBXML2')}
1456 summary_info += {'tcmalloc support':  config_host.has_key('CONFIG_TCMALLOC')}
1457 summary_info += {'jemalloc support':  config_host.has_key('CONFIG_JEMALLOC')}
1458 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
1459 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
1460 summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
1461 summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
1462 summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
1463 summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
1464 summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
1465 summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
1466 summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
1467 summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
1468 summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
1469 summary_info += {'sheepdog support':  config_host.has_key('CONFIG_SHEEPDOG')}
1470 summary_info += {'capstone':          config_host.has_key('CONFIG_CAPSTONE')}
1471 summary_info += {'libpmem support':   config_host.has_key('CONFIG_LIBPMEM')}
1472 summary_info += {'libdaxctl support': config_host.has_key('CONFIG_LIBDAXCTL')}
1473 summary_info += {'libudev':           config_host.has_key('CONFIG_LIBUDEV')}
1474 summary_info += {'default devices':   config_host['CONFIG_MINIKCONF_MODE'] == '--defconfig'}
1475 summary_info += {'plugin support':    config_host.has_key('CONFIG_PLUGIN')}
1476 summary_info += {'fuzzing support':   config_host.has_key('CONFIG_FUZZ')}
1477 if config_host.has_key('HAVE_GDB_BIN')
1478   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
1479 endif
1480 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
1481 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
1482 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
1483 summary(summary_info, bool_yn: true)
1484
1485 if not supported_cpus.contains(cpu)
1486   message()
1487   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
1488   message()
1489   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
1490   message('The QEMU project intends to remove support for this host CPU in')
1491   message('a future release if nobody volunteers to maintain it and to')
1492   message('provide a build host for our continuous integration setup.')
1493   message('configure has succeeded and you can continue to build, but')
1494   message('if you care about QEMU on this platform you should contact')
1495   message('us upstream at qemu-devel@nongnu.org.')
1496 endif
1497
1498 if not supported_oses.contains(targetos)
1499   message()
1500   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
1501   message()
1502   message('Host OS ' + targetos + 'support is not currently maintained.')
1503   message('The QEMU project intends to remove support for this host OS in')
1504   message('a future release if nobody volunteers to maintain it and to')
1505   message('provide a build host for our continuous integration setup.')
1506   message('configure has succeeded and you can continue to build, but')
1507   message('if you care about QEMU on this platform you should contact')
1508   message('us upstream at qemu-devel@nongnu.org.')
1509 endif