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