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