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