hw/arm/raspi: fix CPRMAN base address
[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 fs = import('fs')
14
15 sh = find_program('sh')
16 cc = meson.get_compiler('c')
17 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
18 enable_modules = 'CONFIG_MODULES' in config_host
19 enable_static = 'CONFIG_STATIC' in config_host
20
21 # Temporary directory used for files created while
22 # configure runs. Since it is in the build directory
23 # we can safely blow away any previous version of it
24 # (and we need not jump through hoops to try to delete
25 # it when configure exits.)
26 tmpdir = meson.current_build_dir() / 'meson-private/temp'
27
28 if get_option('qemu_suffix').startswith('/')
29   error('qemu_suffix cannot start with a /')
30 endif
31
32 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
33 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
34 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
35 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
36
37 qemu_desktopdir = get_option('datadir') / 'applications'
38 qemu_icondir = get_option('datadir') / 'icons'
39
40 config_host_data = configuration_data()
41 genh = []
42
43 target_dirs = config_host['TARGET_DIRS'].split()
44 have_user = false
45 have_system = false
46 foreach target : target_dirs
47   have_user = have_user or target.endswith('-user')
48   have_system = have_system or target.endswith('-softmmu')
49 endforeach
50 have_tools = 'CONFIG_TOOLS' in config_host
51 have_block = have_system or have_tools
52
53 python = import('python').find_installation()
54
55 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
56 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
57   'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
58
59 cpu = host_machine.cpu_family()
60 targetos = host_machine.system()
61
62 if cpu in ['x86', 'x86_64']
63   kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
64 elif cpu == 'aarch64'
65   kvm_targets = ['aarch64-softmmu']
66 elif cpu == 's390x'
67   kvm_targets = ['s390x-softmmu']
68 elif cpu in ['ppc', 'ppc64']
69   kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
70 elif cpu in ['mips', 'mips64']
71   kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
72 else
73   kvm_targets = []
74 endif
75
76 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
77 if cpu in ['x86', 'x86_64']
78   accelerator_targets += {
79     'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
80     'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
81     'CONFIG_HVF': ['x86_64-softmmu'],
82     'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
83   }
84 endif
85
86 ##################
87 # Compiler flags #
88 ##################
89
90 # Specify linker-script with add_project_link_arguments so that it is not placed
91 # within a linker --start-group/--end-group pair
92 if 'CONFIG_FUZZ' in config_host
93    add_project_link_arguments(['-Wl,-T,',
94                                (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
95                               native: false, language: ['c', 'cpp', 'objc'])
96 endif
97
98 add_project_arguments(config_host['QEMU_CFLAGS'].split(),
99                       native: false, language: ['c', 'objc'])
100 add_project_arguments(config_host['QEMU_CXXFLAGS'].split(),
101                       native: false, language: 'cpp')
102 add_project_link_arguments(config_host['QEMU_LDFLAGS'].split(),
103                            native: false, language: ['c', 'cpp', 'objc'])
104
105 if targetos == 'linux'
106   add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
107                         '-isystem', 'linux-headers',
108                         language: ['c', 'cpp'])
109 endif
110
111 if 'CONFIG_TCG_INTERPRETER' in config_host
112   tcg_arch = 'tci'
113 elif config_host['ARCH'] == 'sparc64'
114   tcg_arch = 'sparc'
115 elif config_host['ARCH'] == 's390x'
116   tcg_arch = 's390'
117 elif config_host['ARCH'] in ['x86_64', 'x32']
118   tcg_arch = 'i386'
119 elif config_host['ARCH'] == 'ppc64'
120   tcg_arch = 'ppc'
121 elif config_host['ARCH'] in ['riscv32', 'riscv64']
122   tcg_arch = 'riscv'
123 else
124   tcg_arch = config_host['ARCH']
125 endif
126 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
127                       '-iquote', '.',
128                       '-iquote', meson.current_source_dir(),
129                       '-iquote', meson.current_source_dir() / 'accel/tcg',
130                       '-iquote', meson.current_source_dir() / 'include',
131                       '-iquote', meson.current_source_dir() / 'disas/libvixl',
132                       language: ['c', 'cpp', 'objc'])
133
134 link_language = meson.get_external_property('link_language', 'cpp')
135 if link_language == 'cpp'
136   add_languages('cpp', required: true, native: false)
137 endif
138 if host_machine.system() == 'darwin'
139   add_languages('objc', required: false, native: false)
140 endif
141
142 sparse = find_program('cgcc', required: get_option('sparse'))
143 if sparse.found()
144   run_target('sparse',
145              command: [find_program('scripts/check_sparse.py'),
146                        'compile_commands.json', sparse.full_path(), '-Wbitwise',
147                        '-Wno-transparent-union', '-Wno-old-initializer',
148                        '-Wno-non-pointer-null'])
149 endif
150
151 ###########################################
152 # Target-specific checks and dependencies #
153 ###########################################
154
155 if targetos != 'linux' and get_option('mpath').enabled()
156   error('Multipath is supported only on Linux')
157 endif
158
159 m = cc.find_library('m', required: false)
160 util = cc.find_library('util', required: false)
161 winmm = []
162 socket = []
163 version_res = []
164 coref = []
165 iokit = []
166 emulator_link_args = []
167 cocoa = not_found
168 hvf = not_found
169 if targetos == 'windows'
170   socket = cc.find_library('ws2_32')
171   winmm = cc.find_library('winmm')
172
173   win = import('windows')
174   version_res = win.compile_resources('version.rc',
175                                       depend_files: files('pc-bios/qemu-nsis.ico'),
176                                       include_directories: include_directories('.'))
177 elif targetos == 'darwin'
178   coref = dependency('appleframeworks', modules: 'CoreFoundation')
179   iokit = dependency('appleframeworks', modules: 'IOKit')
180   cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
181 elif targetos == 'sunos'
182   socket = [cc.find_library('socket'),
183             cc.find_library('nsl'),
184             cc.find_library('resolv')]
185 elif targetos == 'haiku'
186   socket = [cc.find_library('posix_error_mapper'),
187             cc.find_library('network'),
188             cc.find_library('bsd')]
189 elif targetos == 'openbsd'
190   if not get_option('tcg').disabled() and target_dirs.length() > 0
191     # Disable OpenBSD W^X if available
192     emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
193   endif
194 endif
195
196 accelerators = []
197 if not get_option('kvm').disabled() and targetos == 'linux'
198   accelerators += 'CONFIG_KVM'
199 endif
200 if not get_option('xen').disabled() and 'CONFIG_XEN_BACKEND' in config_host
201   accelerators += 'CONFIG_XEN'
202   have_xen_pci_passthrough = not get_option('xen_pci_passthrough').disabled() and targetos == 'linux'
203 else
204   have_xen_pci_passthrough = false
205 endif
206 if not get_option('whpx').disabled() and targetos == 'windows'
207   if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
208     error('WHPX requires 64-bit host')
209   elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
210        cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
211     accelerators += 'CONFIG_WHPX'
212   endif
213 endif
214 if not get_option('hvf').disabled()
215   hvf = dependency('appleframeworks', modules: 'Hypervisor',
216                    required: get_option('hvf'))
217   if hvf.found()
218     accelerators += 'CONFIG_HVF'
219   endif
220 endif
221 if not get_option('hax').disabled()
222   if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
223     accelerators += 'CONFIG_HAX'
224   endif
225 endif
226 if not get_option('tcg').disabled()
227   if cpu not in supported_cpus
228     if 'CONFIG_TCG_INTERPRETER' in config_host
229       warning('Unsupported CPU @0@, will use TCG with TCI (experimental)'.format(cpu))
230     else
231       error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
232     endif
233   endif
234   accelerators += 'CONFIG_TCG'
235   config_host += { 'CONFIG_TCG': 'y' }
236 endif
237
238 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
239   error('KVM not available on this platform')
240 endif
241 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
242   error('HVF not available on this platform')
243 endif
244 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
245   error('WHPX not available on this platform')
246 endif
247 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
248   if 'CONFIG_XEN' in accelerators
249     error('Xen PCI passthrough not available on this platform')
250   else
251     error('Xen PCI passthrough requested but Xen not enabled')
252   endif
253 endif
254 if not cocoa.found() and get_option('cocoa').enabled()
255   error('Cocoa not available on this platform')
256 endif
257
258 ################
259 # Dependencies #
260 ################
261
262 # The path to glib.h is added to all compilation commands.  This was
263 # grandfathered in from the QEMU Makefiles.
264 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
265                       native: false, language: ['c', 'cpp', 'objc'])
266 glib = declare_dependency(link_args: config_host['GLIB_LIBS'].split())
267 gio = not_found
268 if 'CONFIG_GIO' in config_host
269   gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
270                            link_args: config_host['GIO_LIBS'].split())
271 endif
272 lttng = not_found
273 if 'CONFIG_TRACE_UST' in config_host
274   lttng = declare_dependency(link_args: config_host['LTTNG_UST_LIBS'].split())
275 endif
276 urcubp = not_found
277 if 'CONFIG_TRACE_UST' in config_host
278   urcubp = declare_dependency(link_args: config_host['URCU_BP_LIBS'].split())
279 endif
280 gcrypt = not_found
281 if 'CONFIG_GCRYPT' in config_host
282   gcrypt = declare_dependency(compile_args: config_host['GCRYPT_CFLAGS'].split(),
283                               link_args: config_host['GCRYPT_LIBS'].split())
284 endif
285 nettle = not_found
286 if 'CONFIG_NETTLE' in config_host
287   nettle = declare_dependency(compile_args: config_host['NETTLE_CFLAGS'].split(),
288                               link_args: config_host['NETTLE_LIBS'].split())
289 endif
290 gnutls = not_found
291 if 'CONFIG_GNUTLS' in config_host
292   gnutls = declare_dependency(compile_args: config_host['GNUTLS_CFLAGS'].split(),
293                               link_args: config_host['GNUTLS_LIBS'].split())
294 endif
295 pixman = not_found
296 if have_system or have_tools
297   pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
298                       method: 'pkg-config', static: enable_static)
299 endif
300 pam = not_found
301 if 'CONFIG_AUTH_PAM' in config_host
302   pam = cc.find_library('pam')
303 endif
304 libaio = cc.find_library('aio', required: false)
305 zlib = dependency('zlib', required: true, static: enable_static)
306 linux_io_uring = not_found
307 if 'CONFIG_LINUX_IO_URING' in config_host
308   linux_io_uring = declare_dependency(compile_args: config_host['LINUX_IO_URING_CFLAGS'].split(),
309                                       link_args: config_host['LINUX_IO_URING_LIBS'].split())
310 endif
311 libxml2 = not_found
312 if 'CONFIG_LIBXML2' in config_host
313   libxml2 = declare_dependency(compile_args: config_host['LIBXML2_CFLAGS'].split(),
314                                link_args: config_host['LIBXML2_LIBS'].split())
315 endif
316 libnfs = not_found
317 if 'CONFIG_LIBNFS' in config_host
318   libnfs = declare_dependency(link_args: config_host['LIBNFS_LIBS'].split())
319 endif
320 libattr = not_found
321 if 'CONFIG_ATTR' in config_host
322   libattr = declare_dependency(link_args: config_host['LIBATTR_LIBS'].split())
323 endif
324 seccomp = not_found
325 if 'CONFIG_SECCOMP' in config_host
326   seccomp = declare_dependency(compile_args: config_host['SECCOMP_CFLAGS'].split(),
327                                link_args: config_host['SECCOMP_LIBS'].split())
328 endif
329 libcap_ng = not_found
330 if 'CONFIG_LIBCAP_NG' in config_host
331   libcap_ng = declare_dependency(link_args: config_host['LIBCAP_NG_LIBS'].split())
332 endif
333 if get_option('xkbcommon').auto() and not have_system and not have_tools
334   xkbcommon = not_found
335 else
336   xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
337                          method: 'pkg-config', static: enable_static)
338 endif
339 vde = not_found
340 if config_host.has_key('CONFIG_VDE')
341   vde = declare_dependency(link_args: config_host['VDE_LIBS'].split())
342 endif
343 pulse = not_found
344 if 'CONFIG_LIBPULSE' in config_host
345   pulse = declare_dependency(compile_args: config_host['PULSE_CFLAGS'].split(),
346                              link_args: config_host['PULSE_LIBS'].split())
347 endif
348 alsa = not_found
349 if 'CONFIG_ALSA' in config_host
350   alsa = declare_dependency(compile_args: config_host['ALSA_CFLAGS'].split(),
351                             link_args: config_host['ALSA_LIBS'].split())
352 endif
353 jack = not_found
354 if 'CONFIG_LIBJACK' in config_host
355   jack = declare_dependency(link_args: config_host['JACK_LIBS'].split())
356 endif
357 spice = not_found
358 spice_headers = not_found
359 if 'CONFIG_SPICE' in config_host
360   spice = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split(),
361                              link_args: config_host['SPICE_LIBS'].split())
362   spice_headers = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split())
363 endif
364 rt = cc.find_library('rt', required: false)
365 libdl = not_found
366 if 'CONFIG_PLUGIN' in config_host
367   libdl = cc.find_library('dl', required: true)
368 endif
369 libiscsi = not_found
370 if 'CONFIG_LIBISCSI' in config_host
371   libiscsi = declare_dependency(compile_args: config_host['LIBISCSI_CFLAGS'].split(),
372                                 link_args: config_host['LIBISCSI_LIBS'].split())
373 endif
374 zstd = not_found
375 if 'CONFIG_ZSTD' in config_host
376   zstd = declare_dependency(compile_args: config_host['ZSTD_CFLAGS'].split(),
377                             link_args: config_host['ZSTD_LIBS'].split())
378 endif
379 gbm = not_found
380 if 'CONFIG_GBM' in config_host
381   gbm = declare_dependency(compile_args: config_host['GBM_CFLAGS'].split(),
382                            link_args: config_host['GBM_LIBS'].split())
383 endif
384 virgl = not_found
385 if 'CONFIG_VIRGL' in config_host
386   virgl = declare_dependency(compile_args: config_host['VIRGL_CFLAGS'].split(),
387                              link_args: config_host['VIRGL_LIBS'].split())
388 endif
389 curl = not_found
390 if 'CONFIG_CURL' in config_host
391   curl = declare_dependency(compile_args: config_host['CURL_CFLAGS'].split(),
392                             link_args: config_host['CURL_LIBS'].split())
393 endif
394 libudev = not_found
395 if targetos == 'linux' and (have_system or have_tools)
396   libudev = dependency('libudev',
397                        required: get_option('libudev'),
398                        static: enable_static)
399 endif
400
401 mpathlibs = [libudev]
402 mpathpersist = not_found
403 mpathpersist_new_api = false
404 if targetos == 'linux' and have_tools and not get_option('mpath').disabled()
405   mpath_test_source_new = '''
406     #include <libudev.h>
407     #include <mpath_persist.h>
408     unsigned mpath_mx_alloc_len = 1024;
409     int logsink;
410     static struct config *multipath_conf;
411     extern struct udev *udev;
412     extern struct config *get_multipath_config(void);
413     extern void put_multipath_config(struct config *conf);
414     struct udev *udev;
415     struct config *get_multipath_config(void) { return multipath_conf; }
416     void put_multipath_config(struct config *conf) { }
417     int main(void) {
418         udev = udev_new();
419         multipath_conf = mpath_lib_init();
420         return 0;
421     }'''
422   mpath_test_source_old = '''
423       #include <libudev.h>
424       #include <mpath_persist.h>
425       unsigned mpath_mx_alloc_len = 1024;
426       int logsink;
427       int main(void) {
428           struct udev *udev = udev_new();
429           mpath_lib_init(udev);
430           return 0;
431       }'''
432   libmpathpersist = cc.find_library('mpathpersist',
433                                     required: get_option('mpath'),
434                                     static: enable_static)
435   if libmpathpersist.found()
436     mpathlibs += libmpathpersist
437     if enable_static
438       mpathlibs += cc.find_library('devmapper',
439                                      required: get_option('mpath'),
440                                      static: enable_static)
441     endif
442     mpathlibs += cc.find_library('multipath',
443                                  required: get_option('mpath'),
444                                  static: enable_static)
445     foreach lib: mpathlibs
446       if not lib.found()
447         mpathlibs = []
448         break
449       endif
450     endforeach
451     if mpathlibs.length() == 0
452       msg = 'Dependencies missing for libmpathpersist'
453     elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
454       mpathpersist = declare_dependency(dependencies: mpathlibs)
455       mpathpersist_new_api = true
456     elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
457       mpathpersist = declare_dependency(dependencies: mpathlibs)
458     else
459       msg = 'Cannot detect libmpathpersist API'
460     endif
461     if not mpathpersist.found()
462       if get_option('mpath').enabled()
463         error(msg)
464       else
465         warning(msg + ', disabling')
466       endif
467     endif
468   endif
469 endif
470
471 iconv = not_found
472 curses = not_found
473 if have_system and not get_option('curses').disabled()
474   curses_test = '''
475     #include <locale.h>
476     #include <curses.h>
477     #include <wchar.h>
478     int main(void) {
479       wchar_t wch = L'w';
480       setlocale(LC_ALL, "");
481       resize_term(0, 0);
482       addwstr(L"wide chars\n");
483       addnwstr(&wch, 1);
484       add_wch(WACS_DEGREE);
485       return 0;
486     }'''
487
488   curses = dependency((targetos == 'windows' ? 'ncurses' : 'ncursesw'),
489                       required: false,
490                       method: 'pkg-config',
491                       static: enable_static)
492   msg = get_option('curses').enabled() ? 'curses library not found' : ''
493   if curses.found()
494     if cc.links(curses_test, dependencies: [curses])
495       curses = declare_dependency(compile_args: '-DNCURSES_WIDECHAR', dependencies: [curses])
496     else
497       msg = 'curses package not usable'
498       curses = not_found
499     endif
500   endif
501   if not curses.found()
502     curses_compile_args = ['-DNCURSES_WIDECHAR']
503     has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
504     if targetos != 'windows' and not has_curses_h
505       message('Trying with /usr/include/ncursesw')
506       curses_compile_args += ['-I/usr/include/ncursesw']
507       has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
508     endif
509     if has_curses_h
510       curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
511       foreach curses_libname : curses_libname_list
512         libcurses = cc.find_library(curses_libname,
513                                     required: false,
514                                     static: enable_static)
515         if libcurses.found()
516           if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
517             curses = declare_dependency(compile_args: curses_compile_args,
518                                         dependencies: [libcurses])
519             break
520           else
521             msg = 'curses library not usable'
522           endif
523         endif
524       endforeach
525     endif
526   endif
527   if not get_option('iconv').disabled()
528     foreach link_args : [ ['-liconv'], [] ]
529       # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
530       # We need to use libiconv if available because mixing libiconv's headers with
531       # the system libc does not work.
532       # However, without adding glib to the dependencies -L/usr/local/lib will not be
533       # included in the command line and libiconv will not be found.
534       if cc.links('''
535         #include <iconv.h>
536         int main(void) {
537           iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
538           return conv != (iconv_t) -1;
539         }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
540         iconv = declare_dependency(link_args: link_args, dependencies: glib)
541         break
542       endif
543     endforeach
544   endif
545   if curses.found() and not iconv.found()
546     if get_option('iconv').enabled()
547       error('iconv not available')
548     endif
549     msg = 'iconv required for curses UI but not available'
550     curses = not_found
551   endif
552   if not curses.found() and msg != ''
553     if get_option('curses').enabled()
554       error(msg)
555     else
556       warning(msg + ', disabling')
557     endif
558   endif
559 endif
560
561 brlapi = not_found
562 if 'CONFIG_BRLAPI' in config_host
563   brlapi = declare_dependency(link_args: config_host['BRLAPI_LIBS'].split())
564 endif
565
566 sdl = not_found
567 if have_system
568   sdl = dependency('sdl2', required: get_option('sdl'), static: enable_static)
569   sdl_image = not_found
570 endif
571 if sdl.found()
572   # work around 2.0.8 bug
573   sdl = declare_dependency(compile_args: '-Wno-undef',
574                            dependencies: sdl)
575   sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
576                          method: 'pkg-config', static: enable_static)
577 else
578   if get_option('sdl_image').enabled()
579     error('sdl-image required, but SDL was @0@'.format(
580           get_option('sdl').disabled() ? 'disabled' : 'not found'))
581   endif
582   sdl_image = not_found
583 endif
584
585 rbd = not_found
586 if 'CONFIG_RBD' in config_host
587   rbd = declare_dependency(link_args: config_host['RBD_LIBS'].split())
588 endif
589 glusterfs = not_found
590 if 'CONFIG_GLUSTERFS' in config_host
591   glusterfs = declare_dependency(compile_args: config_host['GLUSTERFS_CFLAGS'].split(),
592                                  link_args: config_host['GLUSTERFS_LIBS'].split())
593 endif
594 libssh = not_found
595 if 'CONFIG_LIBSSH' in config_host
596   libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
597                               link_args: config_host['LIBSSH_LIBS'].split())
598 endif
599 libbzip2 = not_found
600 if 'CONFIG_BZIP2' in config_host
601   libbzip2 = declare_dependency(link_args: config_host['BZIP2_LIBS'].split())
602 endif
603 liblzfse = not_found
604 if 'CONFIG_LZFSE' in config_host
605   liblzfse = declare_dependency(link_args: config_host['LZFSE_LIBS'].split())
606 endif
607 oss = not_found
608 if 'CONFIG_AUDIO_OSS' in config_host
609   oss = declare_dependency(link_args: config_host['OSS_LIBS'].split())
610 endif
611 dsound = not_found
612 if 'CONFIG_AUDIO_DSOUND' in config_host
613   dsound = declare_dependency(link_args: config_host['DSOUND_LIBS'].split())
614 endif
615 coreaudio = not_found
616 if 'CONFIG_AUDIO_COREAUDIO' in config_host
617   coreaudio = declare_dependency(link_args: config_host['COREAUDIO_LIBS'].split())
618 endif
619 opengl = not_found
620 if 'CONFIG_OPENGL' in config_host
621   opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
622                               link_args: config_host['OPENGL_LIBS'].split())
623 endif
624 gtk = not_found
625 if 'CONFIG_GTK' in config_host
626   gtk = declare_dependency(compile_args: config_host['GTK_CFLAGS'].split(),
627                               link_args: config_host['GTK_LIBS'].split())
628 endif
629 vte = not_found
630 if 'CONFIG_VTE' in config_host
631   vte = declare_dependency(compile_args: config_host['VTE_CFLAGS'].split(),
632                            link_args: config_host['VTE_LIBS'].split())
633 endif
634 x11 = not_found
635 if 'CONFIG_X11' in config_host
636   x11 = declare_dependency(compile_args: config_host['X11_CFLAGS'].split(),
637                            link_args: config_host['X11_LIBS'].split())
638 endif
639 vnc = not_found
640 png = not_found
641 jpeg = not_found
642 sasl = not_found
643 if get_option('vnc').enabled()
644   vnc = declare_dependency() # dummy dependency
645   png = dependency('libpng', required: get_option('vnc_png'),
646                    method: 'pkg-config', static: enable_static)
647   jpeg = cc.find_library('jpeg', has_headers: ['jpeglib.h'],
648                          required: get_option('vnc_jpeg'),
649                          static: enable_static)
650   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
651                          required: get_option('vnc_sasl'),
652                          static: enable_static)
653   if sasl.found()
654     sasl = declare_dependency(dependencies: sasl,
655                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
656   endif
657 endif
658 snappy = not_found
659 if 'CONFIG_SNAPPY' in config_host
660   snappy = declare_dependency(link_args: config_host['SNAPPY_LIBS'].split())
661 endif
662 lzo = not_found
663 if 'CONFIG_LZO' in config_host
664   lzo = declare_dependency(link_args: config_host['LZO_LIBS'].split())
665 endif
666 rdma = not_found
667 if 'CONFIG_RDMA' in config_host
668   rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
669 endif
670 numa = not_found
671 if 'CONFIG_NUMA' in config_host
672   numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
673 endif
674 xen = not_found
675 if 'CONFIG_XEN_BACKEND' in config_host
676   xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
677                            link_args: config_host['XEN_LIBS'].split())
678 endif
679 cacard = not_found
680 if 'CONFIG_SMARTCARD' in config_host
681   cacard = declare_dependency(compile_args: config_host['SMARTCARD_CFLAGS'].split(),
682                               link_args: config_host['SMARTCARD_LIBS'].split())
683 endif
684 u2f = not_found
685 if have_system
686   u2f = dependency('u2f-emu', required: get_option('u2f'),
687                    method: 'pkg-config',
688                    static: enable_static)
689 endif
690 usbredir = not_found
691 if 'CONFIG_USB_REDIR' in config_host
692   usbredir = declare_dependency(compile_args: config_host['USB_REDIR_CFLAGS'].split(),
693                                 link_args: config_host['USB_REDIR_LIBS'].split())
694 endif
695 libusb = not_found
696 if 'CONFIG_USB_LIBUSB' in config_host
697   libusb = declare_dependency(compile_args: config_host['LIBUSB_CFLAGS'].split(),
698                               link_args: config_host['LIBUSB_LIBS'].split())
699 endif
700 libpmem = not_found
701 if 'CONFIG_LIBPMEM' in config_host
702   libpmem = declare_dependency(compile_args: config_host['LIBPMEM_CFLAGS'].split(),
703                                link_args: config_host['LIBPMEM_LIBS'].split())
704 endif
705 libdaxctl = not_found
706 if 'CONFIG_LIBDAXCTL' in config_host
707   libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split())
708 endif
709 tasn1 = not_found
710 if 'CONFIG_TASN1' in config_host
711   tasn1 = declare_dependency(compile_args: config_host['TASN1_CFLAGS'].split(),
712                              link_args: config_host['TASN1_LIBS'].split())
713 endif
714 keyutils = dependency('libkeyutils', required: false,
715                       method: 'pkg-config', static: enable_static)
716
717 has_gettid = cc.has_function('gettid')
718
719 # Malloc tests
720
721 malloc = []
722 if get_option('malloc') == 'system'
723   has_malloc_trim = \
724     not get_option('malloc_trim').disabled() and \
725     cc.links('''#include <malloc.h>
726                 int main(void) { malloc_trim(0); return 0; }''')
727 else
728   has_malloc_trim = false
729   malloc = cc.find_library(get_option('malloc'), required: true)
730 endif
731 if not has_malloc_trim and get_option('malloc_trim').enabled()
732   if get_option('malloc') == 'system'
733     error('malloc_trim not available on this platform.')
734   else
735     error('malloc_trim not available with non-libc memory allocator')
736   endif
737 endif
738
739 #################
740 # config-host.h #
741 #################
742
743 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
744 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
745 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
746 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
747 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
748 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
749 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
750 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
751 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
752 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
753 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
754 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
755
756 config_host_data.set('CONFIG_COCOA', cocoa.found())
757 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
758 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
759 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
760 config_host_data.set('CONFIG_CURSES', curses.found())
761 config_host_data.set('CONFIG_SDL', sdl.found())
762 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
763 config_host_data.set('CONFIG_VNC', vnc.found())
764 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
765 config_host_data.set('CONFIG_VNC_PNG', png.found())
766 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
767 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
768 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
769 config_host_data.set('CONFIG_GETTID', has_gettid)
770 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
771 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
772 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
773 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
774 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
775
776 ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target
777 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
778 strings = ['HOST_DSOSUF', 'CONFIG_IASL']
779 foreach k, v: config_host
780   if ignored.contains(k)
781     # do nothing
782   elif arrays.contains(k)
783     if v != ''
784       v = '"' + '", "'.join(v.split()) + '", '
785     endif
786     config_host_data.set(k, v)
787   elif k == 'ARCH'
788     config_host_data.set('HOST_' + v.to_upper(), 1)
789   elif strings.contains(k)
790     if not k.startswith('CONFIG_')
791       k = 'CONFIG_' + k.to_upper()
792     endif
793     config_host_data.set_quoted(k, v)
794   elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
795     config_host_data.set(k, v == 'y' ? 1 : v)
796   endif
797 endforeach
798
799 ########################
800 # Target configuration #
801 ########################
802
803 minikconf = find_program('scripts/minikconf.py')
804 config_all = {}
805 config_all_devices = {}
806 config_all_disas = {}
807 config_devices_mak_list = []
808 config_devices_h = {}
809 config_target_h = {}
810 config_target_mak = {}
811
812 disassemblers = {
813   'alpha' : ['CONFIG_ALPHA_DIS'],
814   'arm' : ['CONFIG_ARM_DIS'],
815   'avr' : ['CONFIG_AVR_DIS'],
816   'cris' : ['CONFIG_CRIS_DIS'],
817   'hppa' : ['CONFIG_HPPA_DIS'],
818   'i386' : ['CONFIG_I386_DIS'],
819   'x86_64' : ['CONFIG_I386_DIS'],
820   'x32' : ['CONFIG_I386_DIS'],
821   'lm32' : ['CONFIG_LM32_DIS'],
822   'm68k' : ['CONFIG_M68K_DIS'],
823   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
824   'mips' : ['CONFIG_MIPS_DIS'],
825   'moxie' : ['CONFIG_MOXIE_DIS'],
826   'nios2' : ['CONFIG_NIOS2_DIS'],
827   'or1k' : ['CONFIG_OPENRISC_DIS'],
828   'ppc' : ['CONFIG_PPC_DIS'],
829   'riscv' : ['CONFIG_RISCV_DIS'],
830   'rx' : ['CONFIG_RX_DIS'],
831   's390' : ['CONFIG_S390_DIS'],
832   'sh4' : ['CONFIG_SH4_DIS'],
833   'sparc' : ['CONFIG_SPARC_DIS'],
834   'xtensa' : ['CONFIG_XTENSA_DIS'],
835 }
836 if link_language == 'cpp'
837   disassemblers += {
838     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
839     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
840     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
841   }
842 endif
843
844 kconfig_external_symbols = [
845   'CONFIG_KVM',
846   'CONFIG_XEN',
847   'CONFIG_TPM',
848   'CONFIG_SPICE',
849   'CONFIG_IVSHMEM',
850   'CONFIG_OPENGL',
851   'CONFIG_X11',
852   'CONFIG_VHOST_USER',
853   'CONFIG_VHOST_VDPA',
854   'CONFIG_VHOST_KERNEL',
855   'CONFIG_VIRTFS',
856   'CONFIG_LINUX',
857   'CONFIG_PVRDMA',
858 ]
859 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
860
861 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
862 actual_target_dirs = []
863 fdt_required = []
864 foreach target : target_dirs
865   config_target = { 'TARGET_NAME': target.split('-')[0] }
866   if target.endswith('linux-user')
867     if targetos != 'linux'
868       if default_targets
869         continue
870       endif
871       error('Target @0@ is only available on a Linux host'.format(target))
872     endif
873     config_target += { 'CONFIG_LINUX_USER': 'y' }
874   elif target.endswith('bsd-user')
875     if 'CONFIG_BSD' not in config_host
876       if default_targets
877         continue
878       endif
879       error('Target @0@ is only available on a BSD host'.format(target))
880     endif
881     config_target += { 'CONFIG_BSD_USER': 'y' }
882   elif target.endswith('softmmu')
883     config_target += { 'CONFIG_SOFTMMU': 'y' }
884   endif
885   if target.endswith('-user')
886     config_target += {
887       'CONFIG_USER_ONLY': 'y',
888       'CONFIG_QEMU_INTERP_PREFIX':
889         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
890     }
891   endif
892
893   have_accel = false
894   foreach sym: accelerators
895     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
896       config_target += { sym: 'y' }
897       config_all += { sym: 'y' }
898       if sym == 'CONFIG_XEN' and have_xen_pci_passthrough
899         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
900       endif
901       have_accel = true
902     endif
903   endforeach
904   if not have_accel
905     if default_targets
906       continue
907     endif
908     error('No accelerator available for target @0@'.format(target))
909   endif
910
911   actual_target_dirs += target
912   config_target += keyval.load('default-configs/targets' / target + '.mak')
913   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
914
915   if 'TARGET_NEED_FDT' in config_target
916     fdt_required += target
917   endif
918
919   # Add default keys
920   if 'TARGET_BASE_ARCH' not in config_target
921     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
922   endif
923   if 'TARGET_ABI_DIR' not in config_target
924     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
925   endif
926
927   foreach k, v: disassemblers
928     if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
929       foreach sym: v
930         config_target += { sym: 'y' }
931         config_all_disas += { sym: 'y' }
932       endforeach
933     endif
934   endforeach
935
936   config_target_data = configuration_data()
937   foreach k, v: config_target
938     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
939       # do nothing
940     elif ignored.contains(k)
941       # do nothing
942     elif k == 'TARGET_BASE_ARCH'
943       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
944       # not used to select files from sourcesets.
945       config_target_data.set('TARGET_' + v.to_upper(), 1)
946     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
947       config_target_data.set_quoted(k, v)
948     elif v == 'y'
949       config_target_data.set(k, 1)
950     else
951       config_target_data.set(k, v)
952     endif
953   endforeach
954   config_target_h += {target: configure_file(output: target + '-config-target.h',
955                                                configuration: config_target_data)}
956
957   if target.endswith('-softmmu')
958     base_kconfig = []
959     foreach sym : kconfig_external_symbols
960       if sym in config_target or sym in config_host
961         base_kconfig += '@0@=y'.format(sym)
962       endif
963     endforeach
964
965     config_devices_mak = target + '-config-devices.mak'
966     config_devices_mak = configure_file(
967       input: ['default-configs/devices' / target + '.mak', 'Kconfig'],
968       output: config_devices_mak,
969       depfile: config_devices_mak + '.d',
970       capture: true,
971       command: [minikconf, config_host['CONFIG_MINIKCONF_MODE'],
972                 config_devices_mak, '@DEPFILE@', '@INPUT@',
973                 base_kconfig])
974
975     config_devices_data = configuration_data()
976     config_devices = keyval.load(config_devices_mak)
977     foreach k, v: config_devices
978       config_devices_data.set(k, 1)
979     endforeach
980     config_devices_mak_list += config_devices_mak
981     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
982                                                 configuration: config_devices_data)}
983     config_target += config_devices
984     config_all_devices += config_devices
985   endif
986   config_target_mak += {target: config_target}
987 endforeach
988 target_dirs = actual_target_dirs
989
990 # This configuration is used to build files that are shared by
991 # multiple binaries, and then extracted out of the "common"
992 # static_library target.
993 #
994 # We do not use all_sources()/all_dependencies(), because it would
995 # build literally all source files, including devices only used by
996 # targets that are not built for this compilation.  The CONFIG_ALL
997 # pseudo symbol replaces it.
998
999 config_all += config_all_devices
1000 config_all += config_host
1001 config_all += config_all_disas
1002 config_all += {
1003   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
1004   'CONFIG_SOFTMMU': have_system,
1005   'CONFIG_USER_ONLY': have_user,
1006   'CONFIG_ALL': true,
1007 }
1008
1009 ##############
1010 # Submodules #
1011 ##############
1012
1013 capstone = not_found
1014 capstone_opt = get_option('capstone')
1015 if capstone_opt in ['enabled', 'auto', 'system']
1016   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
1017   capstone = dependency('capstone', version: '>=4.0',
1018                         static: enable_static, method: 'pkg-config',
1019                         required: capstone_opt == 'system' or
1020                                   capstone_opt == 'enabled' and not have_internal)
1021   if capstone.found()
1022     capstone_opt = 'system'
1023   elif have_internal
1024     capstone_opt = 'internal'
1025   else
1026     capstone_opt = 'disabled'
1027   endif
1028 endif
1029 if capstone_opt == 'internal'
1030   capstone_data = configuration_data()
1031   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
1032
1033   capstone_files = files(
1034     'capstone/cs.c',
1035     'capstone/MCInst.c',
1036     'capstone/MCInstrDesc.c',
1037     'capstone/MCRegisterInfo.c',
1038     'capstone/SStream.c',
1039     'capstone/utils.c'
1040   )
1041
1042   if 'CONFIG_ARM_DIS' in config_all_disas
1043     capstone_data.set('CAPSTONE_HAS_ARM', '1')
1044     capstone_files += files(
1045       'capstone/arch/ARM/ARMDisassembler.c',
1046       'capstone/arch/ARM/ARMInstPrinter.c',
1047       'capstone/arch/ARM/ARMMapping.c',
1048       'capstone/arch/ARM/ARMModule.c'
1049     )
1050   endif
1051
1052   # FIXME: This config entry currently depends on a c++ compiler.
1053   # Which is needed for building libvixl, but not for capstone.
1054   if 'CONFIG_ARM_A64_DIS' in config_all_disas
1055     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
1056     capstone_files += files(
1057       'capstone/arch/AArch64/AArch64BaseInfo.c',
1058       'capstone/arch/AArch64/AArch64Disassembler.c',
1059       'capstone/arch/AArch64/AArch64InstPrinter.c',
1060       'capstone/arch/AArch64/AArch64Mapping.c',
1061       'capstone/arch/AArch64/AArch64Module.c'
1062     )
1063   endif
1064
1065   if 'CONFIG_PPC_DIS' in config_all_disas
1066     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
1067     capstone_files += files(
1068       'capstone/arch/PowerPC/PPCDisassembler.c',
1069       'capstone/arch/PowerPC/PPCInstPrinter.c',
1070       'capstone/arch/PowerPC/PPCMapping.c',
1071       'capstone/arch/PowerPC/PPCModule.c'
1072     )
1073   endif
1074
1075   if 'CONFIG_S390_DIS' in config_all_disas
1076     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
1077     capstone_files += files(
1078       'capstone/arch/SystemZ/SystemZDisassembler.c',
1079       'capstone/arch/SystemZ/SystemZInstPrinter.c',
1080       'capstone/arch/SystemZ/SystemZMapping.c',
1081       'capstone/arch/SystemZ/SystemZModule.c',
1082       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
1083     )
1084   endif
1085
1086   if 'CONFIG_I386_DIS' in config_all_disas
1087     capstone_data.set('CAPSTONE_HAS_X86', 1)
1088     capstone_files += files(
1089       'capstone/arch/X86/X86Disassembler.c',
1090       'capstone/arch/X86/X86DisassemblerDecoder.c',
1091       'capstone/arch/X86/X86ATTInstPrinter.c',
1092       'capstone/arch/X86/X86IntelInstPrinter.c',
1093       'capstone/arch/X86/X86InstPrinterCommon.c',
1094       'capstone/arch/X86/X86Mapping.c',
1095       'capstone/arch/X86/X86Module.c'
1096     )
1097   endif
1098
1099   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
1100
1101   capstone_cargs = [
1102     # FIXME: There does not seem to be a way to completely replace the c_args
1103     # that come from add_project_arguments() -- we can only add to them.
1104     # So: disable all warnings with a big hammer.
1105     '-Wno-error', '-w',
1106
1107     # Include all configuration defines via a header file, which will wind up
1108     # as a dependency on the object file, and thus changes here will result
1109     # in a rebuild.
1110     '-include', 'capstone-defs.h'
1111   ]
1112
1113   libcapstone = static_library('capstone',
1114                                sources: capstone_files,
1115                                c_args: capstone_cargs,
1116                                include_directories: 'capstone/include')
1117   capstone = declare_dependency(link_with: libcapstone,
1118                                 include_directories: 'capstone/include/capstone')
1119 endif
1120
1121 slirp = not_found
1122 slirp_opt = 'disabled'
1123 if have_system
1124   slirp_opt = get_option('slirp')
1125   if slirp_opt in ['enabled', 'auto', 'system']
1126     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
1127     slirp = dependency('slirp', static: enable_static,
1128                        method: 'pkg-config',
1129                        required: slirp_opt == 'system' or
1130                                  slirp_opt == 'enabled' and not have_internal)
1131     if slirp.found()
1132       slirp_opt = 'system'
1133     elif have_internal
1134       slirp_opt = 'internal'
1135     else
1136       slirp_opt = 'disabled'
1137     endif
1138   endif
1139   if slirp_opt == 'internal'
1140     slirp_deps = []
1141     if targetos == 'windows'
1142       slirp_deps = cc.find_library('iphlpapi')
1143     endif
1144     slirp_conf = configuration_data()
1145     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
1146     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
1147     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
1148     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
1149     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
1150     slirp_files = [
1151       'slirp/src/arp_table.c',
1152       'slirp/src/bootp.c',
1153       'slirp/src/cksum.c',
1154       'slirp/src/dhcpv6.c',
1155       'slirp/src/dnssearch.c',
1156       'slirp/src/if.c',
1157       'slirp/src/ip6_icmp.c',
1158       'slirp/src/ip6_input.c',
1159       'slirp/src/ip6_output.c',
1160       'slirp/src/ip_icmp.c',
1161       'slirp/src/ip_input.c',
1162       'slirp/src/ip_output.c',
1163       'slirp/src/mbuf.c',
1164       'slirp/src/misc.c',
1165       'slirp/src/ncsi.c',
1166       'slirp/src/ndp_table.c',
1167       'slirp/src/sbuf.c',
1168       'slirp/src/slirp.c',
1169       'slirp/src/socket.c',
1170       'slirp/src/state.c',
1171       'slirp/src/stream.c',
1172       'slirp/src/tcp_input.c',
1173       'slirp/src/tcp_output.c',
1174       'slirp/src/tcp_subr.c',
1175       'slirp/src/tcp_timer.c',
1176       'slirp/src/tftp.c',
1177       'slirp/src/udp.c',
1178       'slirp/src/udp6.c',
1179       'slirp/src/util.c',
1180       'slirp/src/version.c',
1181       'slirp/src/vmstate.c',
1182     ]
1183
1184     configure_file(
1185       input : 'slirp/src/libslirp-version.h.in',
1186       output : 'libslirp-version.h',
1187       configuration: slirp_conf)
1188
1189     slirp_inc = include_directories('slirp', 'slirp/src')
1190     libslirp = static_library('slirp',
1191                               sources: slirp_files,
1192                               c_args: slirp_cargs,
1193                               include_directories: slirp_inc)
1194     slirp = declare_dependency(link_with: libslirp,
1195                                dependencies: slirp_deps,
1196                                include_directories: slirp_inc)
1197   endif
1198 endif
1199
1200 fdt = not_found
1201 fdt_opt = get_option('fdt')
1202 if have_system
1203   if fdt_opt in ['enabled', 'auto', 'system']
1204     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
1205     fdt = cc.find_library('fdt', static: enable_static,
1206                           required: fdt_opt == 'system' or
1207                                     fdt_opt == 'enabled' and not have_internal)
1208     if fdt.found() and cc.links('''
1209        #include <libfdt.h>
1210        #include <libfdt_env.h>
1211        int main(void) { fdt_check_full(NULL, 0); return 0; }''',
1212          dependencies: fdt)
1213       fdt_opt = 'system'
1214     elif have_internal
1215       fdt_opt = 'internal'
1216     else
1217       fdt_opt = 'disabled'
1218     endif
1219   endif
1220   if fdt_opt == 'internal'
1221     fdt_files = files(
1222       'dtc/libfdt/fdt.c',
1223       'dtc/libfdt/fdt_ro.c',
1224       'dtc/libfdt/fdt_wip.c',
1225       'dtc/libfdt/fdt_sw.c',
1226       'dtc/libfdt/fdt_rw.c',
1227       'dtc/libfdt/fdt_strerror.c',
1228       'dtc/libfdt/fdt_empty_tree.c',
1229       'dtc/libfdt/fdt_addresses.c',
1230       'dtc/libfdt/fdt_overlay.c',
1231       'dtc/libfdt/fdt_check.c',
1232     )
1233
1234     fdt_inc = include_directories('dtc/libfdt')
1235     libfdt = static_library('fdt',
1236                             sources: fdt_files,
1237                             include_directories: fdt_inc)
1238     fdt = declare_dependency(link_with: libfdt,
1239                              include_directories: fdt_inc)
1240   endif
1241 endif
1242 if not fdt.found() and fdt_required.length() > 0
1243   error('fdt not available but required by targets ' + ', '.join(fdt_required))
1244 endif
1245
1246 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
1247 config_host_data.set('CONFIG_FDT', fdt.found())
1248 config_host_data.set('CONFIG_SLIRP', slirp.found())
1249
1250 #####################
1251 # Generated sources #
1252 #####################
1253
1254 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
1255
1256 hxtool = find_program('scripts/hxtool')
1257 shaderinclude = find_program('scripts/shaderinclude.pl')
1258 qapi_gen = find_program('scripts/qapi-gen.py')
1259 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
1260                      meson.source_root() / 'scripts/qapi/commands.py',
1261                      meson.source_root() / 'scripts/qapi/common.py',
1262                      meson.source_root() / 'scripts/qapi/error.py',
1263                      meson.source_root() / 'scripts/qapi/events.py',
1264                      meson.source_root() / 'scripts/qapi/expr.py',
1265                      meson.source_root() / 'scripts/qapi/gen.py',
1266                      meson.source_root() / 'scripts/qapi/introspect.py',
1267                      meson.source_root() / 'scripts/qapi/parser.py',
1268                      meson.source_root() / 'scripts/qapi/schema.py',
1269                      meson.source_root() / 'scripts/qapi/source.py',
1270                      meson.source_root() / 'scripts/qapi/types.py',
1271                      meson.source_root() / 'scripts/qapi/visit.py',
1272                      meson.source_root() / 'scripts/qapi/common.py',
1273                      meson.source_root() / 'scripts/qapi-gen.py'
1274 ]
1275
1276 tracetool = [
1277   python, files('scripts/tracetool.py'),
1278    '--backend=' + config_host['TRACE_BACKENDS']
1279 ]
1280
1281 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
1282                     meson.current_source_dir(),
1283                     config_host['PKGVERSION'], meson.project_version()]
1284 qemu_version = custom_target('qemu-version.h',
1285                              output: 'qemu-version.h',
1286                              command: qemu_version_cmd,
1287                              capture: true,
1288                              build_by_default: true,
1289                              build_always_stale: true)
1290 genh += qemu_version
1291
1292 hxdep = []
1293 hx_headers = [
1294   ['qemu-options.hx', 'qemu-options.def'],
1295   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
1296 ]
1297 if have_system
1298   hx_headers += [
1299     ['hmp-commands.hx', 'hmp-commands.h'],
1300     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
1301   ]
1302 endif
1303 foreach d : hx_headers
1304   hxdep += custom_target(d[1],
1305                 input: files(d[0]),
1306                 output: d[1],
1307                 capture: true,
1308                 build_by_default: true, # to be removed when added to a target
1309                 command: [hxtool, '-h', '@INPUT0@'])
1310 endforeach
1311 genh += hxdep
1312
1313 ###################
1314 # Collect sources #
1315 ###################
1316
1317 authz_ss = ss.source_set()
1318 blockdev_ss = ss.source_set()
1319 block_ss = ss.source_set()
1320 bsd_user_ss = ss.source_set()
1321 chardev_ss = ss.source_set()
1322 common_ss = ss.source_set()
1323 crypto_ss = ss.source_set()
1324 io_ss = ss.source_set()
1325 linux_user_ss = ss.source_set()
1326 qmp_ss = ss.source_set()
1327 qom_ss = ss.source_set()
1328 softmmu_ss = ss.source_set()
1329 specific_fuzz_ss = ss.source_set()
1330 specific_ss = ss.source_set()
1331 stub_ss = ss.source_set()
1332 trace_ss = ss.source_set()
1333 user_ss = ss.source_set()
1334 util_ss = ss.source_set()
1335
1336 modules = {}
1337 hw_arch = {}
1338 target_arch = {}
1339 target_softmmu_arch = {}
1340
1341 ###############
1342 # Trace files #
1343 ###############
1344
1345 # TODO: add each directory to the subdirs from its own meson.build, once
1346 # we have those
1347 trace_events_subdirs = [
1348   'accel/kvm',
1349   'accel/tcg',
1350   'crypto',
1351   'monitor',
1352 ]
1353 if have_user
1354   trace_events_subdirs += [ 'linux-user' ]
1355 endif
1356 if have_block
1357   trace_events_subdirs += [
1358     'authz',
1359     'block',
1360     'io',
1361     'nbd',
1362     'scsi',
1363   ]
1364 endif
1365 if have_system
1366   trace_events_subdirs += [
1367     'audio',
1368     'backends',
1369     'backends/tpm',
1370     'chardev',
1371     'hw/9pfs',
1372     'hw/acpi',
1373     'hw/alpha',
1374     'hw/arm',
1375     'hw/audio',
1376     'hw/block',
1377     'hw/block/dataplane',
1378     'hw/char',
1379     'hw/display',
1380     'hw/dma',
1381     'hw/hppa',
1382     'hw/hyperv',
1383     'hw/i2c',
1384     'hw/i386',
1385     'hw/i386/xen',
1386     'hw/ide',
1387     'hw/input',
1388     'hw/intc',
1389     'hw/isa',
1390     'hw/mem',
1391     'hw/mips',
1392     'hw/misc',
1393     'hw/misc/macio',
1394     'hw/net',
1395     'hw/nvram',
1396     'hw/pci',
1397     'hw/pci-host',
1398     'hw/ppc',
1399     'hw/rdma',
1400     'hw/rdma/vmw',
1401     'hw/rtc',
1402     'hw/s390x',
1403     'hw/scsi',
1404     'hw/sd',
1405     'hw/sparc',
1406     'hw/sparc64',
1407     'hw/ssi',
1408     'hw/timer',
1409     'hw/tpm',
1410     'hw/usb',
1411     'hw/vfio',
1412     'hw/virtio',
1413     'hw/watchdog',
1414     'hw/xen',
1415     'hw/gpio',
1416     'migration',
1417     'net',
1418     'softmmu',
1419     'ui',
1420   ]
1421 endif
1422 trace_events_subdirs += [
1423   'hw/core',
1424   'qapi',
1425   'qom',
1426   'target/arm',
1427   'target/hppa',
1428   'target/i386',
1429   'target/mips',
1430   'target/ppc',
1431   'target/riscv',
1432   'target/s390x',
1433   'target/sparc',
1434   'util',
1435 ]
1436
1437 vhost_user = not_found
1438 if 'CONFIG_VHOST_USER' in config_host
1439   subdir('contrib/libvhost-user')
1440 endif
1441
1442 subdir('qapi')
1443 subdir('qobject')
1444 subdir('stubs')
1445 subdir('trace')
1446 subdir('util')
1447 subdir('qom')
1448 subdir('authz')
1449 subdir('crypto')
1450 subdir('ui')
1451
1452
1453 if enable_modules
1454   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
1455   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
1456 endif
1457
1458 stub_ss = stub_ss.apply(config_all, strict: false)
1459
1460 util_ss.add_all(trace_ss)
1461 util_ss = util_ss.apply(config_all, strict: false)
1462 libqemuutil = static_library('qemuutil',
1463                              sources: util_ss.sources() + stub_ss.sources() + genh,
1464                              dependencies: [util_ss.dependencies(), m, glib, socket, malloc])
1465 qemuutil = declare_dependency(link_with: libqemuutil,
1466                               sources: genh + version_res)
1467
1468 decodetree = generator(find_program('scripts/decodetree.py'),
1469                        output: 'decode-@BASENAME@.c.inc',
1470                        arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
1471
1472 subdir('audio')
1473 subdir('io')
1474 subdir('chardev')
1475 subdir('fsdev')
1476 subdir('libdecnumber')
1477 subdir('target')
1478 subdir('dump')
1479
1480 block_ss.add(files(
1481   'block.c',
1482   'blockjob.c',
1483   'job.c',
1484   'qemu-io-cmds.c',
1485 ))
1486 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
1487
1488 subdir('nbd')
1489 subdir('scsi')
1490 subdir('block')
1491
1492 blockdev_ss.add(files(
1493   'blockdev.c',
1494   'blockdev-nbd.c',
1495   'iothread.c',
1496   'job-qmp.c',
1497 ))
1498
1499 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
1500 # os-win32.c does not
1501 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
1502 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
1503
1504 common_ss.add(files('cpus-common.c'))
1505
1506 subdir('softmmu')
1507
1508 common_ss.add(capstone)
1509 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
1510 specific_ss.add(files('exec-vary.c'))
1511 specific_ss.add(when: 'CONFIG_TCG', if_true: files(
1512   'fpu/softfloat.c',
1513   'tcg/optimize.c',
1514   'tcg/tcg-common.c',
1515   'tcg/tcg-op-gvec.c',
1516   'tcg/tcg-op-vec.c',
1517   'tcg/tcg-op.c',
1518   'tcg/tcg.c',
1519 ))
1520 specific_ss.add(when: 'CONFIG_TCG_INTERPRETER', if_true: files('disas/tci.c', 'tcg/tci.c'))
1521
1522 subdir('backends')
1523 subdir('disas')
1524 subdir('migration')
1525 subdir('monitor')
1526 subdir('net')
1527 subdir('replay')
1528 subdir('hw')
1529 subdir('accel')
1530 subdir('plugins')
1531 subdir('bsd-user')
1532 subdir('linux-user')
1533
1534 bsd_user_ss.add(files('gdbstub.c'))
1535 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
1536
1537 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
1538 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
1539
1540 # needed for fuzzing binaries
1541 subdir('tests/qtest/libqos')
1542 subdir('tests/qtest/fuzz')
1543
1544 ########################
1545 # Library dependencies #
1546 ########################
1547
1548 block_mods = []
1549 softmmu_mods = []
1550 foreach d, list : modules
1551   foreach m, module_ss : list
1552     if enable_modules and targetos != 'windows'
1553       module_ss = module_ss.apply(config_all, strict: false)
1554       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
1555                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
1556       if d == 'block'
1557         block_mods += sl
1558       else
1559         softmmu_mods += sl
1560       endif
1561     else
1562       if d == 'block'
1563         block_ss.add_all(module_ss)
1564       else
1565         softmmu_ss.add_all(module_ss)
1566       endif
1567     endif
1568   endforeach
1569 endforeach
1570
1571 nm = find_program('nm')
1572 undefsym = find_program('scripts/undefsym.py')
1573 block_syms = custom_target('block.syms', output: 'block.syms',
1574                              input: [libqemuutil, block_mods],
1575                              capture: true,
1576                              command: [undefsym, nm, '@INPUT@'])
1577 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
1578                              input: [libqemuutil, softmmu_mods],
1579                              capture: true,
1580                              command: [undefsym, nm, '@INPUT@'])
1581
1582 qom_ss = qom_ss.apply(config_host, strict: false)
1583 libqom = static_library('qom', qom_ss.sources() + genh,
1584                         dependencies: [qom_ss.dependencies()],
1585                         name_suffix: 'fa')
1586
1587 qom = declare_dependency(link_whole: libqom)
1588
1589 authz_ss = authz_ss.apply(config_host, strict: false)
1590 libauthz = static_library('authz', authz_ss.sources() + genh,
1591                           dependencies: [authz_ss.dependencies()],
1592                           name_suffix: 'fa',
1593                           build_by_default: false)
1594
1595 authz = declare_dependency(link_whole: libauthz,
1596                            dependencies: qom)
1597
1598 crypto_ss = crypto_ss.apply(config_host, strict: false)
1599 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
1600                            dependencies: [crypto_ss.dependencies()],
1601                            name_suffix: 'fa',
1602                            build_by_default: false)
1603
1604 crypto = declare_dependency(link_whole: libcrypto,
1605                             dependencies: [authz, qom])
1606
1607 io_ss = io_ss.apply(config_host, strict: false)
1608 libio = static_library('io', io_ss.sources() + genh,
1609                        dependencies: [io_ss.dependencies()],
1610                        link_with: libqemuutil,
1611                        name_suffix: 'fa',
1612                        build_by_default: false)
1613
1614 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
1615
1616 libmigration = static_library('migration', sources: migration_files + genh,
1617                               name_suffix: 'fa',
1618                               build_by_default: false)
1619 migration = declare_dependency(link_with: libmigration,
1620                                dependencies: [zlib, qom, io])
1621 softmmu_ss.add(migration)
1622
1623 block_ss = block_ss.apply(config_host, strict: false)
1624 libblock = static_library('block', block_ss.sources() + genh,
1625                           dependencies: block_ss.dependencies(),
1626                           link_depends: block_syms,
1627                           name_suffix: 'fa',
1628                           build_by_default: false)
1629
1630 block = declare_dependency(link_whole: [libblock],
1631                            link_args: '@block.syms',
1632                            dependencies: [crypto, io])
1633
1634 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
1635 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
1636                              dependencies: blockdev_ss.dependencies(),
1637                              name_suffix: 'fa',
1638                              build_by_default: false)
1639
1640 blockdev = declare_dependency(link_whole: [libblockdev],
1641                               dependencies: [block])
1642
1643 qmp_ss = qmp_ss.apply(config_host, strict: false)
1644 libqmp = static_library('qmp', qmp_ss.sources() + genh,
1645                         dependencies: qmp_ss.dependencies(),
1646                         name_suffix: 'fa',
1647                         build_by_default: false)
1648
1649 qmp = declare_dependency(link_whole: [libqmp])
1650
1651 libchardev = static_library('chardev', chardev_ss.sources() + genh,
1652                             name_suffix: 'fa',
1653                             build_by_default: false)
1654
1655 chardev = declare_dependency(link_whole: libchardev)
1656
1657 libhwcore = static_library('hwcore', sources: hwcore_files + genh,
1658                            name_suffix: 'fa',
1659                            build_by_default: false)
1660 hwcore = declare_dependency(link_whole: libhwcore)
1661 common_ss.add(hwcore)
1662
1663 ###########
1664 # Targets #
1665 ###########
1666
1667 foreach m : block_mods + softmmu_mods
1668   shared_module(m.name(),
1669                 name_prefix: '',
1670                 link_whole: m,
1671                 install: true,
1672                 install_dir: qemu_moddir)
1673 endforeach
1674
1675 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
1676 common_ss.add(qom, qemuutil)
1677
1678 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
1679 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
1680
1681 common_all = common_ss.apply(config_all, strict: false)
1682 common_all = static_library('common',
1683                             build_by_default: false,
1684                             sources: common_all.sources() + genh,
1685                             dependencies: common_all.dependencies(),
1686                             name_suffix: 'fa')
1687
1688 feature_to_c = find_program('scripts/feature_to_c.sh')
1689
1690 emulators = {}
1691 foreach target : target_dirs
1692   config_target = config_target_mak[target]
1693   target_name = config_target['TARGET_NAME']
1694   arch = config_target['TARGET_BASE_ARCH']
1695   arch_srcs = [config_target_h[target]]
1696   arch_deps = []
1697   c_args = ['-DNEED_CPU_H',
1698             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
1699             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
1700   link_args = emulator_link_args
1701
1702   config_target += config_host
1703   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
1704   if targetos == 'linux'
1705     target_inc += include_directories('linux-headers', is_system: true)
1706   endif
1707   if target.endswith('-softmmu')
1708     qemu_target_name = 'qemu-system-' + target_name
1709     target_type='system'
1710     t = target_softmmu_arch[arch].apply(config_target, strict: false)
1711     arch_srcs += t.sources()
1712     arch_deps += t.dependencies()
1713
1714     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
1715     hw = hw_arch[hw_dir].apply(config_target, strict: false)
1716     arch_srcs += hw.sources()
1717     arch_deps += hw.dependencies()
1718
1719     arch_srcs += config_devices_h[target]
1720     link_args += ['@block.syms', '@qemu.syms']
1721   else
1722     abi = config_target['TARGET_ABI_DIR']
1723     target_type='user'
1724     qemu_target_name = 'qemu-' + target_name
1725     if 'CONFIG_LINUX_USER' in config_target
1726       base_dir = 'linux-user'
1727       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
1728     else
1729       base_dir = 'bsd-user'
1730     endif
1731     target_inc += include_directories(
1732       base_dir,
1733       base_dir / abi,
1734     )
1735     if 'CONFIG_LINUX_USER' in config_target
1736       dir = base_dir / abi
1737       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
1738       if config_target.has_key('TARGET_SYSTBL_ABI')
1739         arch_srcs += \
1740           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
1741                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
1742       endif
1743     endif
1744   endif
1745
1746   if 'TARGET_XML_FILES' in config_target
1747     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
1748                                 output: target + '-gdbstub-xml.c',
1749                                 input: files(config_target['TARGET_XML_FILES'].split()),
1750                                 command: [feature_to_c, '@INPUT@'],
1751                                 capture: true)
1752     arch_srcs += gdbstub_xml
1753   endif
1754
1755   t = target_arch[arch].apply(config_target, strict: false)
1756   arch_srcs += t.sources()
1757   arch_deps += t.dependencies()
1758
1759   target_common = common_ss.apply(config_target, strict: false)
1760   objects = common_all.extract_objects(target_common.sources())
1761   deps = target_common.dependencies()
1762
1763   target_specific = specific_ss.apply(config_target, strict: false)
1764   arch_srcs += target_specific.sources()
1765   arch_deps += target_specific.dependencies()
1766
1767   lib = static_library('qemu-' + target,
1768                  sources: arch_srcs + genh,
1769                  dependencies: arch_deps,
1770                  objects: objects,
1771                  include_directories: target_inc,
1772                  c_args: c_args,
1773                  build_by_default: false,
1774                  name_suffix: 'fa')
1775
1776   if target.endswith('-softmmu')
1777     execs = [{
1778       'name': 'qemu-system-' + target_name,
1779       'gui': false,
1780       'sources': files('softmmu/main.c'),
1781       'dependencies': []
1782     }]
1783     if targetos == 'windows' and (sdl.found() or gtk.found())
1784       execs += [{
1785         'name': 'qemu-system-' + target_name + 'w',
1786         'gui': true,
1787         'sources': files('softmmu/main.c'),
1788         'dependencies': []
1789       }]
1790     endif
1791     if config_host.has_key('CONFIG_FUZZ')
1792       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
1793       execs += [{
1794         'name': 'qemu-fuzz-' + target_name,
1795         'gui': false,
1796         'sources': specific_fuzz.sources(),
1797         'dependencies': specific_fuzz.dependencies(),
1798       }]
1799     endif
1800   else
1801     execs = [{
1802       'name': 'qemu-' + target_name,
1803       'gui': false,
1804       'sources': [],
1805       'dependencies': []
1806     }]
1807   endif
1808   foreach exe: execs
1809     emulators += {exe['name']:
1810          executable(exe['name'], exe['sources'],
1811                install: true,
1812                c_args: c_args,
1813                dependencies: arch_deps + deps + exe['dependencies'],
1814                objects: lib.extract_all_objects(recursive: true),
1815                link_language: link_language,
1816                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
1817                link_args: link_args,
1818                gui_app: exe['gui'])
1819     }
1820
1821     if 'CONFIG_TRACE_SYSTEMTAP' in config_host
1822       foreach stp: [
1823         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
1824         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
1825         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
1826         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
1827       ]
1828         custom_target(exe['name'] + stp['ext'],
1829                       input: trace_events_all,
1830                       output: exe['name'] + stp['ext'],
1831                       capture: true,
1832                       install: stp['install'],
1833                       install_dir: get_option('datadir') / 'systemtap/tapset',
1834                       command: [
1835                         tracetool, '--group=all', '--format=' + stp['fmt'],
1836                         '--binary=' + stp['bin'],
1837                         '--target-name=' + target_name,
1838                         '--target-type=' + target_type,
1839                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
1840                         '@INPUT@',
1841                       ])
1842       endforeach
1843     endif
1844   endforeach
1845 endforeach
1846
1847 # Other build targets
1848
1849 if 'CONFIG_PLUGIN' in config_host
1850   install_headers('include/qemu/qemu-plugin.h')
1851 endif
1852
1853 if 'CONFIG_GUEST_AGENT' in config_host
1854   subdir('qga')
1855 endif
1856
1857 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
1858 # when we don't build tools or system
1859 if xkbcommon.found()
1860   # used for the update-keymaps target, so include rules even if !have_tools
1861   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
1862                            dependencies: [qemuutil, xkbcommon], install: have_tools)
1863 endif
1864
1865 if have_tools
1866   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
1867              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
1868   qemu_io = executable('qemu-io', files('qemu-io.c'),
1869              dependencies: [block, qemuutil], install: true)
1870   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
1871                dependencies: [blockdev, qemuutil], install: true)
1872
1873   subdir('storage-daemon')
1874   subdir('contrib/rdmacm-mux')
1875   subdir('contrib/elf2dmp')
1876
1877   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
1878              dependencies: qemuutil,
1879              install: true)
1880
1881   if 'CONFIG_VHOST_USER' in config_host
1882     subdir('contrib/vhost-user-blk')
1883     subdir('contrib/vhost-user-gpu')
1884     subdir('contrib/vhost-user-input')
1885     subdir('contrib/vhost-user-scsi')
1886   endif
1887
1888   if targetos == 'linux'
1889     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
1890                dependencies: [qemuutil, libcap_ng],
1891                install: true,
1892                install_dir: get_option('libexecdir'))
1893
1894     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
1895                dependencies: [authz, crypto, io, qom, qemuutil,
1896                               libcap_ng, mpathpersist],
1897                install: true)
1898   endif
1899
1900   if 'CONFIG_IVSHMEM' in config_host
1901     subdir('contrib/ivshmem-client')
1902     subdir('contrib/ivshmem-server')
1903   endif
1904 endif
1905
1906 subdir('scripts')
1907 subdir('tools')
1908 subdir('pc-bios')
1909 subdir('docs')
1910 subdir('tests')
1911 if 'CONFIG_GTK' in config_host
1912   subdir('po')
1913 endif
1914
1915 if host_machine.system() == 'windows'
1916   nsis_cmd = [
1917     find_program('scripts/nsis.py'),
1918     '@OUTPUT@',
1919     get_option('prefix'),
1920     meson.current_source_dir(),
1921     host_machine.cpu_family(),
1922     '--',
1923     '-DDISPLAYVERSION=' + meson.project_version(),
1924   ]
1925   if build_docs
1926     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
1927   endif
1928   if 'CONFIG_GTK' in config_host
1929     nsis_cmd += '-DCONFIG_GTK=y'
1930   endif
1931
1932   nsis = custom_target('nsis',
1933                        output: 'qemu-setup-' + meson.project_version() + '.exe',
1934                        input: files('qemu.nsi'),
1935                        build_always_stale: true,
1936                        command: nsis_cmd + ['@INPUT@'])
1937   alias_target('installer', nsis)
1938 endif
1939
1940 #########################
1941 # Configuration summary #
1942 #########################
1943
1944 summary_info = {}
1945 summary_info += {'Install prefix':    get_option('prefix')}
1946 summary_info += {'BIOS directory':    qemu_datadir}
1947 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
1948 summary_info += {'binary directory':  get_option('bindir')}
1949 summary_info += {'library directory': get_option('libdir')}
1950 summary_info += {'module directory':  qemu_moddir}
1951 summary_info += {'libexec directory': get_option('libexecdir')}
1952 summary_info += {'include directory': get_option('includedir')}
1953 summary_info += {'config directory':  get_option('sysconfdir')}
1954 if targetos != 'windows'
1955   summary_info += {'local state directory': get_option('localstatedir')}
1956   summary_info += {'Manual directory':      get_option('mandir')}
1957 else
1958   summary_info += {'local state directory': 'queried at runtime'}
1959 endif
1960 summary_info += {'Doc directory':     get_option('docdir')}
1961 summary_info += {'Build directory':   meson.current_build_dir()}
1962 summary_info += {'Source path':       meson.current_source_dir()}
1963 summary_info += {'GIT binary':        config_host['GIT']}
1964 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
1965 summary_info += {'C compiler':        meson.get_compiler('c').cmd_array()[0]}
1966 summary_info += {'Host C compiler':   meson.get_compiler('c', native: true).cmd_array()[0]}
1967 if link_language == 'cpp'
1968   summary_info += {'C++ compiler':      meson.get_compiler('cpp').cmd_array()[0]}
1969 else
1970   summary_info += {'C++ compiler':      false}
1971 endif
1972 if targetos == 'darwin'
1973   summary_info += {'Objective-C compiler': meson.get_compiler('objc').cmd_array()[0]}
1974 endif
1975 summary_info += {'ARFLAGS':           config_host['ARFLAGS']}
1976 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
1977                                                + ['-O' + get_option('optimization')]
1978                                                + (get_option('debug') ? ['-g'] : []))}
1979 if link_language == 'cpp'
1980   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
1981                                                + ['-O' + get_option('optimization')]
1982                                                + (get_option('debug') ? ['-g'] : []))}
1983 endif
1984 link_args = get_option(link_language + '_link_args')
1985 if link_args.length() > 0
1986   summary_info += {'LDFLAGS':         ' '.join(link_args)}
1987 endif
1988 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
1989 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
1990 summary_info += {'make':              config_host['MAKE']}
1991 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
1992 summary_info += {'sphinx-build':      sphinx_build.found()}
1993 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
1994 # TODO: add back version
1995 summary_info += {'slirp support':     slirp_opt == 'disabled' ? false : slirp_opt}
1996 if slirp_opt != 'disabled'
1997   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
1998 endif
1999 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
2000 if config_host.has_key('CONFIG_MODULES')
2001   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
2002 endif
2003 summary_info += {'host CPU':          cpu}
2004 summary_info += {'host endianness':   build_machine.endian()}
2005 summary_info += {'target list':       ' '.join(target_dirs)}
2006 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
2007 summary_info += {'sparse enabled':    sparse.found()}
2008 summary_info += {'strip binaries':    get_option('strip')}
2009 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
2010 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
2011 if targetos == 'darwin'
2012   summary_info += {'Cocoa support': config_host.has_key('CONFIG_COCOA')}
2013 endif
2014 # TODO: add back version
2015 summary_info += {'SDL support':       sdl.found()}
2016 summary_info += {'SDL image support': sdl_image.found()}
2017 # TODO: add back version
2018 summary_info += {'GTK support':       config_host.has_key('CONFIG_GTK')}
2019 summary_info += {'GTK GL support':    config_host.has_key('CONFIG_GTK_GL')}
2020 summary_info += {'pixman':            pixman.found()}
2021 # TODO: add back version
2022 summary_info += {'VTE support':       config_host.has_key('CONFIG_VTE')}
2023 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
2024 summary_info += {'GNUTLS support':    config_host.has_key('CONFIG_GNUTLS')}
2025 # TODO: add back version
2026 summary_info += {'libgcrypt':         config_host.has_key('CONFIG_GCRYPT')}
2027 if config_host.has_key('CONFIG_GCRYPT')
2028    summary_info += {'  hmac':            config_host.has_key('CONFIG_GCRYPT_HMAC')}
2029    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
2030 endif
2031 # TODO: add back version
2032 summary_info += {'nettle':            config_host.has_key('CONFIG_NETTLE')}
2033 if config_host.has_key('CONFIG_NETTLE')
2034    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
2035 endif
2036 summary_info += {'libtasn1':          config_host.has_key('CONFIG_TASN1')}
2037 summary_info += {'PAM':               config_host.has_key('CONFIG_AUTH_PAM')}
2038 summary_info += {'iconv support':     iconv.found()}
2039 summary_info += {'curses support':    curses.found()}
2040 # TODO: add back version
2041 summary_info += {'virgl support':     config_host.has_key('CONFIG_VIRGL')}
2042 summary_info += {'curl support':      config_host.has_key('CONFIG_CURL')}
2043 summary_info += {'mingw32 support':   targetos == 'windows'}
2044 summary_info += {'Audio drivers':     config_host['CONFIG_AUDIO_DRIVERS']}
2045 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
2046 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
2047 summary_info += {'VirtFS support':    config_host.has_key('CONFIG_VIRTFS')}
2048 summary_info += {'Multipath support': mpathpersist.found()}
2049 summary_info += {'VNC support':       vnc.found()}
2050 if vnc.found()
2051   summary_info += {'VNC SASL support':  sasl.found()}
2052   summary_info += {'VNC JPEG support':  jpeg.found()}
2053   summary_info += {'VNC PNG support':   png.found()}
2054 endif
2055 summary_info += {'xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
2056 if config_host.has_key('CONFIG_XEN_BACKEND')
2057   summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
2058 endif
2059 summary_info += {'brlapi support':    config_host.has_key('CONFIG_BRLAPI')}
2060 summary_info += {'Documentation':     build_docs}
2061 summary_info += {'PIE':               get_option('b_pie')}
2062 summary_info += {'vde support':       config_host.has_key('CONFIG_VDE')}
2063 summary_info += {'netmap support':    config_host.has_key('CONFIG_NETMAP')}
2064 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
2065 summary_info += {'Linux io_uring support': config_host.has_key('CONFIG_LINUX_IO_URING')}
2066 summary_info += {'ATTR/XATTR support': config_host.has_key('CONFIG_ATTR')}
2067 summary_info += {'Install blobs':     get_option('install_blobs')}
2068 summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
2069 summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
2070 summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
2071 summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
2072 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
2073 if config_all.has_key('CONFIG_TCG')
2074   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
2075   summary_info += {'TCG interpreter':   config_host.has_key('CONFIG_TCG_INTERPRETER')}
2076 endif
2077 summary_info += {'malloc trim support': has_malloc_trim}
2078 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
2079 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
2080 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
2081 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
2082 summary_info += {'preadv support':    config_host.has_key('CONFIG_PREADV')}
2083 summary_info += {'fdatasync':         config_host.has_key('CONFIG_FDATASYNC')}
2084 summary_info += {'madvise':           config_host.has_key('CONFIG_MADVISE')}
2085 summary_info += {'posix_madvise':     config_host.has_key('CONFIG_POSIX_MADVISE')}
2086 summary_info += {'posix_memalign':    config_host.has_key('CONFIG_POSIX_MEMALIGN')}
2087 summary_info += {'libcap-ng support': config_host.has_key('CONFIG_LIBCAP_NG')}
2088 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
2089 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
2090 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
2091 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
2092 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_KERNEL')}
2093 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
2094 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
2095 summary_info += {'Trace backends':    config_host['TRACE_BACKENDS']}
2096 if config_host['TRACE_BACKENDS'].split().contains('simple')
2097   summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
2098 endif
2099 # TODO: add back protocol and server version
2100 summary_info += {'spice support':     config_host.has_key('CONFIG_SPICE')}
2101 summary_info += {'rbd support':       config_host.has_key('CONFIG_RBD')}
2102 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
2103 summary_info += {'smartcard support': config_host.has_key('CONFIG_SMARTCARD')}
2104 summary_info += {'U2F support':       u2f.found()}
2105 summary_info += {'libusb':            config_host.has_key('CONFIG_USB_LIBUSB')}
2106 summary_info += {'usb net redir':     config_host.has_key('CONFIG_USB_REDIR')}
2107 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
2108 summary_info += {'OpenGL dmabufs':    config_host.has_key('CONFIG_OPENGL_DMABUF')}
2109 summary_info += {'libiscsi support':  config_host.has_key('CONFIG_LIBISCSI')}
2110 summary_info += {'libnfs support':    config_host.has_key('CONFIG_LIBNFS')}
2111 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
2112 if targetos == 'windows'
2113   if 'WIN_SDK' in config_host
2114     summary_info += {'Windows SDK':       config_host['WIN_SDK']}
2115   endif
2116   summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
2117   summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
2118   summary_info += {'QGA MSI support':   config_host.has_key('CONFIG_QGA_MSI')}
2119 endif
2120 summary_info += {'seccomp support':   config_host.has_key('CONFIG_SECCOMP')}
2121 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
2122 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
2123 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
2124 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
2125 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
2126 summary_info += {'GlusterFS support': config_host.has_key('CONFIG_GLUSTERFS')}
2127 summary_info += {'gcov':              get_option('b_coverage')}
2128 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
2129 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
2130 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
2131 summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
2132 summary_info += {'lzo support':       config_host.has_key('CONFIG_LZO')}
2133 summary_info += {'snappy support':    config_host.has_key('CONFIG_SNAPPY')}
2134 summary_info += {'bzip2 support':     config_host.has_key('CONFIG_BZIP2')}
2135 summary_info += {'lzfse support':     config_host.has_key('CONFIG_LZFSE')}
2136 summary_info += {'zstd support':      config_host.has_key('CONFIG_ZSTD')}
2137 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
2138 summary_info += {'libxml2':           config_host.has_key('CONFIG_LIBXML2')}
2139 summary_info += {'memory allocator':  get_option('malloc')}
2140 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
2141 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
2142 summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
2143 summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
2144 summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
2145 summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
2146 summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
2147 summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
2148 summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
2149 summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
2150 summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
2151 summary_info += {'sheepdog support':  config_host.has_key('CONFIG_SHEEPDOG')}
2152 summary_info += {'capstone':          capstone_opt == 'disabled' ? false : capstone_opt}
2153 summary_info += {'libpmem support':   config_host.has_key('CONFIG_LIBPMEM')}
2154 summary_info += {'libdaxctl support': config_host.has_key('CONFIG_LIBDAXCTL')}
2155 summary_info += {'libudev':           libudev.found()}
2156 summary_info += {'default devices':   config_host['CONFIG_MINIKCONF_MODE'] == '--defconfig'}
2157 summary_info += {'plugin support':    config_host.has_key('CONFIG_PLUGIN')}
2158 summary_info += {'fuzzing support':   config_host.has_key('CONFIG_FUZZ')}
2159 if config_host.has_key('HAVE_GDB_BIN')
2160   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
2161 endif
2162 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
2163 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
2164 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
2165 summary(summary_info, bool_yn: true)
2166
2167 if not supported_cpus.contains(cpu)
2168   message()
2169   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
2170   message()
2171   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
2172   message('The QEMU project intends to remove support for this host CPU in')
2173   message('a future release if nobody volunteers to maintain it and to')
2174   message('provide a build host for our continuous integration setup.')
2175   message('configure has succeeded and you can continue to build, but')
2176   message('if you care about QEMU on this platform you should contact')
2177   message('us upstream at qemu-devel@nongnu.org.')
2178 endif
2179
2180 if not supported_oses.contains(targetos)
2181   message()
2182   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
2183   message()
2184   message('Host OS ' + targetos + 'support is not currently maintained.')
2185   message('The QEMU project intends to remove support for this host OS in')
2186   message('a future release if nobody volunteers to maintain it and to')
2187   message('provide a build host for our continuous integration setup.')
2188   message('configure has succeeded and you can continue to build, but')
2189   message('if you care about QEMU on this platform you should contact')
2190   message('us upstream at qemu-devel@nongnu.org.')
2191 endif