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