vt82c686: Log superio_cfg unimplemented accesses
[qemu/ar7.git] / meson.build
blob05a67c20d937378c1daed73905fab59015851650
1 project('qemu', ['c'], meson_version: '>=0.55.0',
2         default_options: ['warning_level=1', 'c_std=gnu99', 'cpp_std=gnu++11', 'b_colorout=auto'] +
3                          (meson.version().version_compare('>=0.56.0') ? [ 'b_staticpic=false' ] : []),
4         version: run_command('head', meson.source_root() / 'VERSION').stdout().strip())
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')
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
21 # Allow both shared and static libraries unless --enable-static
22 static_kwargs = enable_static ? {'static': true} : {}
24 # Temporary directory used for files created while
25 # configure runs. Since it is in the build directory
26 # we can safely blow away any previous version of it
27 # (and we need not jump through hoops to try to delete
28 # it when configure exits.)
29 tmpdir = meson.current_build_dir() / 'meson-private/temp'
31 if get_option('qemu_suffix').startswith('/')
32   error('qemu_suffix cannot start with a /')
33 endif
35 qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
36 qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
37 qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
38 qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
40 qemu_desktopdir = get_option('datadir') / 'applications'
41 qemu_icondir = get_option('datadir') / 'icons'
43 config_host_data = configuration_data()
44 genh = []
46 target_dirs = config_host['TARGET_DIRS'].split()
47 have_user = false
48 have_system = false
49 foreach target : target_dirs
50   have_user = have_user or target.endswith('-user')
51   have_system = have_system or target.endswith('-softmmu')
52 endforeach
53 have_tools = 'CONFIG_TOOLS' in config_host
54 have_block = have_system or have_tools
56 python = import('python').find_installation()
58 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
59 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv32', 'riscv64', 'x86', 'x86_64',
60   'arm', 'aarch64', 'mips', 'mips64', 'sparc', 'sparc64']
62 cpu = host_machine.cpu_family()
63 targetos = host_machine.system()
65 if cpu in ['x86', 'x86_64']
66   kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
67 elif cpu == 'aarch64'
68   kvm_targets = ['aarch64-softmmu']
69 elif cpu == 's390x'
70   kvm_targets = ['s390x-softmmu']
71 elif cpu in ['ppc', 'ppc64']
72   kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
73 elif cpu in ['mips', 'mips64']
74   kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
75 else
76   kvm_targets = []
77 endif
79 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
80 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
81   # i368 emulator provides xenpv machine type for multiple architectures
82   accelerator_targets += {
83     'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
84   }
85 endif
86 if cpu in ['x86', 'x86_64']
87   accelerator_targets += {
88     'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
89     'CONFIG_HVF': ['x86_64-softmmu'],
90     'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
91   }
92 endif
94 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
95 install_edk2_blobs = false
96 if get_option('install_blobs')
97   foreach target : target_dirs
98     install_edk2_blobs = install_edk2_blobs or target in edk2_targets
99   endforeach
100 endif
102 bzip2 = find_program('bzip2', required: install_edk2_blobs)
104 ##################
105 # Compiler flags #
106 ##################
108 # Specify linker-script with add_project_link_arguments so that it is not placed
109 # within a linker --start-group/--end-group pair
110 if 'CONFIG_FUZZ' in config_host
111    add_project_link_arguments(['-Wl,-T,',
112                                (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
113                               native: false, language: ['c', 'cpp', 'objc'])
114 endif
116 add_global_arguments(config_host['QEMU_CFLAGS'].split(),
117                      native: false, language: ['c', 'objc'])
118 add_global_arguments(config_host['QEMU_CXXFLAGS'].split(),
119                      native: false, language: 'cpp')
120 add_global_link_arguments(config_host['QEMU_LDFLAGS'].split(),
121                           native: false, language: ['c', 'cpp', 'objc'])
123 if targetos == 'linux'
124   add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
125                         '-isystem', 'linux-headers',
126                         language: ['c', 'cpp'])
127 endif
129 add_project_arguments('-iquote', '.',
130                       '-iquote', meson.current_source_dir(),
131                       '-iquote', meson.current_source_dir() / 'include',
132                       '-iquote', meson.current_source_dir() / 'disas/libvixl',
133                       language: ['c', 'cpp', 'objc'])
135 link_language = meson.get_external_property('link_language', 'cpp')
136 if link_language == 'cpp'
137   add_languages('cpp', required: true, native: false)
138 endif
139 if host_machine.system() == 'darwin'
140   add_languages('objc', required: false, native: false)
141 endif
143 sparse = find_program('cgcc', required: get_option('sparse'))
144 if sparse.found()
145   run_target('sparse',
146              command: [find_program('scripts/check_sparse.py'),
147                        'compile_commands.json', sparse.full_path(), '-Wbitwise',
148                        '-Wno-transparent-union', '-Wno-old-initializer',
149                        '-Wno-non-pointer-null'])
150 endif
152 ###########################################
153 # Target-specific checks and dependencies #
154 ###########################################
156 if targetos != 'linux' and get_option('mpath').enabled()
157   error('Multipath is supported only on Linux')
158 endif
160 m = cc.find_library('m', required: false)
161 util = cc.find_library('util', required: false)
162 winmm = []
163 socket = []
164 version_res = []
165 coref = []
166 iokit = []
167 emulator_link_args = []
168 hvf = not_found
169 if targetos == 'windows'
170   socket = cc.find_library('ws2_32')
171   winmm = cc.find_library('winmm')
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 elif targetos == 'sunos'
181   socket = [cc.find_library('socket'),
182             cc.find_library('nsl'),
183             cc.find_library('resolv')]
184 elif targetos == 'haiku'
185   socket = [cc.find_library('posix_error_mapper'),
186             cc.find_library('network'),
187             cc.find_library('bsd')]
188 elif targetos == 'openbsd'
189   if not get_option('tcg').disabled() and target_dirs.length() > 0
190     # Disable OpenBSD W^X if available
191     emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
192   endif
193 endif
195 accelerators = []
196 if not get_option('kvm').disabled() and targetos == 'linux'
197   accelerators += 'CONFIG_KVM'
198 endif
199 if not get_option('xen').disabled() and 'CONFIG_XEN_BACKEND' in config_host
200   accelerators += 'CONFIG_XEN'
201   have_xen_pci_passthrough = not get_option('xen_pci_passthrough').disabled() and targetos == 'linux'
202 else
203   have_xen_pci_passthrough = false
204 endif
205 if not get_option('whpx').disabled() and targetos == 'windows'
206   if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
207     error('WHPX requires 64-bit host')
208   elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
209        cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
210     accelerators += 'CONFIG_WHPX'
211   endif
212 endif
213 if not get_option('hvf').disabled()
214   hvf = dependency('appleframeworks', modules: 'Hypervisor',
215                    required: get_option('hvf'))
216   if hvf.found()
217     accelerators += 'CONFIG_HVF'
218   endif
219 endif
220 if not get_option('hax').disabled()
221   if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
222     accelerators += 'CONFIG_HAX'
223   endif
224 endif
226 tcg_arch = config_host['ARCH']
227 if not get_option('tcg').disabled()
228   if cpu not in supported_cpus
229     if get_option('tcg_interpreter')
230       warning('Unsupported CPU @0@, will use TCG with TCI (experimental and slow)'.format(cpu))
231     else
232       error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
233     endif
234   elif get_option('tcg_interpreter')
235     warning('Use of the TCG interpretor is not recommended on this host')
236     warning('architecture. There is a native TCG execution backend available')
237     warning('which provides substantially better performance and reliability.')
238     warning('It is strongly recommended to remove the --enable-tcg-interpreter')
239     warning('configuration option on this architecture to use the native')
240     warning('backend.')
241   endif
242   if get_option('tcg_interpreter')
243     tcg_arch = 'tci'
244   elif config_host['ARCH'] == 'sparc64'
245     tcg_arch = 'sparc'
246   elif config_host['ARCH'] == 's390x'
247     tcg_arch = 's390'
248   elif config_host['ARCH'] in ['x86_64', 'x32']
249     tcg_arch = 'i386'
250   elif config_host['ARCH'] == 'ppc64'
251     tcg_arch = 'ppc'
252   elif config_host['ARCH'] in ['riscv32', 'riscv64']
253     tcg_arch = 'riscv'
254   endif
255   add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
256                         '-iquote', meson.current_source_dir() / 'accel/tcg',
257                         language: ['c', 'cpp', 'objc'])
259   accelerators += 'CONFIG_TCG'
260   config_host += { 'CONFIG_TCG': 'y' }
261 endif
263 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
264   error('KVM not available on this platform')
265 endif
266 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
267   error('HVF not available on this platform')
268 endif
269 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
270   error('WHPX not available on this platform')
271 endif
272 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
273   if 'CONFIG_XEN' in accelerators
274     error('Xen PCI passthrough not available on this platform')
275   else
276     error('Xen PCI passthrough requested but Xen not enabled')
277   endif
278 endif
280 ################
281 # Dependencies #
282 ################
284 # The path to glib.h is added to all compilation commands.  This was
285 # grandfathered in from the QEMU Makefiles.
286 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
287                       native: false, language: ['c', 'cpp', 'objc'])
288 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
289                           link_args: config_host['GLIB_LIBS'].split())
290 # override glib dep with the configure results (for subprojects)
291 meson.override_dependency('glib-2.0', glib)
293 gio = not_found
294 if 'CONFIG_GIO' in config_host
295   gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
296                            link_args: config_host['GIO_LIBS'].split())
297 endif
298 lttng = not_found
299 if 'CONFIG_TRACE_UST' in config_host
300   lttng = declare_dependency(link_args: config_host['LTTNG_UST_LIBS'].split())
301 endif
302 urcubp = not_found
303 if 'CONFIG_TRACE_UST' in config_host
304   urcubp = declare_dependency(link_args: config_host['URCU_BP_LIBS'].split())
305 endif
306 gcrypt = not_found
307 if 'CONFIG_GCRYPT' in config_host
308   gcrypt = declare_dependency(compile_args: config_host['GCRYPT_CFLAGS'].split(),
309                               link_args: config_host['GCRYPT_LIBS'].split())
310 endif
311 nettle = not_found
312 if 'CONFIG_NETTLE' in config_host
313   nettle = declare_dependency(compile_args: config_host['NETTLE_CFLAGS'].split(),
314                               link_args: config_host['NETTLE_LIBS'].split())
315 endif
316 gnutls = not_found
317 if 'CONFIG_GNUTLS' in config_host
318   gnutls = declare_dependency(compile_args: config_host['GNUTLS_CFLAGS'].split(),
319                               link_args: config_host['GNUTLS_LIBS'].split())
320 endif
321 pixman = not_found
322 if have_system or have_tools
323   pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
324                       method: 'pkg-config', kwargs: static_kwargs)
325 endif
326 pam = not_found
327 if 'CONFIG_AUTH_PAM' in config_host
328   pam = cc.find_library('pam')
329 endif
330 libaio = cc.find_library('aio', required: false)
331 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
332 linux_io_uring = not_found
333 if 'CONFIG_LINUX_IO_URING' in config_host
334   linux_io_uring = declare_dependency(compile_args: config_host['LINUX_IO_URING_CFLAGS'].split(),
335                                       link_args: config_host['LINUX_IO_URING_LIBS'].split())
336 endif
337 libxml2 = not_found
338 if 'CONFIG_LIBXML2' in config_host
339   libxml2 = declare_dependency(compile_args: config_host['LIBXML2_CFLAGS'].split(),
340                                link_args: config_host['LIBXML2_LIBS'].split())
341 endif
342 libnfs = not_found
343 if not get_option('libnfs').auto() or have_block
344   libnfs = dependency('libnfs', version: '>=1.9.3',
345                       required: get_option('libnfs'),
346                       method: 'pkg-config', kwargs: static_kwargs)
347 endif
349 libattr_test = '''
350   #include <stddef.h>
351   #include <sys/types.h>
352   #ifdef CONFIG_LIBATTR
353   #include <attr/xattr.h>
354   #else
355   #include <sys/xattr.h>
356   #endif
357   int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
359 libattr = not_found
360 have_old_libattr = false
361 if not get_option('attr').disabled()
362   if cc.links(libattr_test)
363     libattr = declare_dependency()
364   else
365     libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
366                               required: get_option('attr'),
367                               kwargs: static_kwargs)
368     if libattr.found() and not \
369       cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
370       libattr = not_found
371       if get_option('attr').enabled()
372         error('could not link libattr')
373       else
374         warning('could not link libattr, disabling')
375       endif
376     else
377       have_old_libattr = libattr.found()
378     endif
379   endif
380 endif
382 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
383 if cocoa.found() and get_option('sdl').enabled()
384   error('Cocoa and SDL cannot be enabled at the same time')
385 endif
386 if cocoa.found() and get_option('gtk').enabled()
387   error('Cocoa and GTK+ cannot be enabled at the same time')
388 endif
390 seccomp = not_found
391 if not get_option('seccomp').auto() or have_system or have_tools
392   seccomp = dependency('libseccomp', version: '>=2.3.0',
393                        required: get_option('seccomp'),
394                        method: 'pkg-config', kwargs: static_kwargs)
395 endif
397 libcap_ng = not_found
398 if not get_option('cap_ng').auto() or have_system or have_tools
399   libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
400                               required: get_option('cap_ng'),
401                               kwargs: static_kwargs)
402 endif
403 if libcap_ng.found() and not cc.links('''
404    #include <cap-ng.h>
405    int main(void)
406    {
407      capng_capability_to_name(CAPNG_EFFECTIVE);
408      return 0;
409    }''', dependencies: libcap_ng)
410   libcap_ng = not_found
411   if get_option('cap_ng').enabled()
412     error('could not link libcap-ng')
413   else
414     warning('could not link libcap-ng, disabling')
415   endif
416 endif
418 if get_option('xkbcommon').auto() and not have_system and not have_tools
419   xkbcommon = not_found
420 else
421   xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
422                          method: 'pkg-config', kwargs: static_kwargs)
423 endif
424 vde = not_found
425 if config_host.has_key('CONFIG_VDE')
426   vde = declare_dependency(link_args: config_host['VDE_LIBS'].split())
427 endif
428 pulse = not_found
429 if 'CONFIG_LIBPULSE' in config_host
430   pulse = declare_dependency(compile_args: config_host['PULSE_CFLAGS'].split(),
431                              link_args: config_host['PULSE_LIBS'].split())
432 endif
433 alsa = not_found
434 if 'CONFIG_ALSA' in config_host
435   alsa = declare_dependency(compile_args: config_host['ALSA_CFLAGS'].split(),
436                             link_args: config_host['ALSA_LIBS'].split())
437 endif
438 jack = not_found
439 if 'CONFIG_LIBJACK' in config_host
440   jack = declare_dependency(link_args: config_host['JACK_LIBS'].split())
441 endif
442 spice = not_found
443 spice_headers = not_found
444 if 'CONFIG_SPICE' in config_host
445   spice = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split(),
446                              link_args: config_host['SPICE_LIBS'].split())
447   spice_headers = declare_dependency(compile_args: config_host['SPICE_CFLAGS'].split())
448 endif
449 rt = cc.find_library('rt', required: false)
450 libdl = not_found
451 if 'CONFIG_PLUGIN' in config_host
452   libdl = cc.find_library('dl', required: true)
453 endif
454 libiscsi = not_found
455 if not get_option('libiscsi').auto() or have_block
456   libiscsi = dependency('libiscsi', version: '>=1.9.0',
457                          required: get_option('libiscsi'),
458                          method: 'pkg-config', kwargs: static_kwargs)
459 endif
460 zstd = not_found
461 if not get_option('zstd').auto() or have_block
462   zstd = dependency('libzstd', version: '>=1.4.0',
463                     required: get_option('zstd'),
464                     method: 'pkg-config', kwargs: static_kwargs)
465 endif
466 gbm = not_found
467 if 'CONFIG_GBM' in config_host
468   gbm = declare_dependency(compile_args: config_host['GBM_CFLAGS'].split(),
469                            link_args: config_host['GBM_LIBS'].split())
470 endif
471 virgl = not_found
472 if 'CONFIG_VIRGL' in config_host
473   virgl = declare_dependency(compile_args: config_host['VIRGL_CFLAGS'].split(),
474                              link_args: config_host['VIRGL_LIBS'].split())
475 endif
476 curl = not_found
477 if not get_option('curl').auto() or have_block
478   curl = dependency('libcurl', version: '>=7.29.0',
479                     method: 'pkg-config',
480                     required: get_option('curl'),
481                     kwargs: static_kwargs)
482 endif
483 libudev = not_found
484 if targetos == 'linux' and (have_system or have_tools)
485   libudev = dependency('libudev',
486                        method: 'pkg-config',
487                        required: get_option('libudev'),
488                        kwargs: static_kwargs)
489 endif
491 mpathlibs = [libudev]
492 mpathpersist = not_found
493 mpathpersist_new_api = false
494 if targetos == 'linux' and have_tools and not get_option('mpath').disabled()
495   mpath_test_source_new = '''
496     #include <libudev.h>
497     #include <mpath_persist.h>
498     unsigned mpath_mx_alloc_len = 1024;
499     int logsink;
500     static struct config *multipath_conf;
501     extern struct udev *udev;
502     extern struct config *get_multipath_config(void);
503     extern void put_multipath_config(struct config *conf);
504     struct udev *udev;
505     struct config *get_multipath_config(void) { return multipath_conf; }
506     void put_multipath_config(struct config *conf) { }
507     int main(void) {
508         udev = udev_new();
509         multipath_conf = mpath_lib_init();
510         return 0;
511     }'''
512   mpath_test_source_old = '''
513       #include <libudev.h>
514       #include <mpath_persist.h>
515       unsigned mpath_mx_alloc_len = 1024;
516       int logsink;
517       int main(void) {
518           struct udev *udev = udev_new();
519           mpath_lib_init(udev);
520           return 0;
521       }'''
522   libmpathpersist = cc.find_library('mpathpersist',
523                                     required: get_option('mpath'),
524                                     kwargs: static_kwargs)
525   if libmpathpersist.found()
526     mpathlibs += libmpathpersist
527     if enable_static
528       mpathlibs += cc.find_library('devmapper',
529                                      required: get_option('mpath'),
530                                      kwargs: static_kwargs)
531     endif
532     mpathlibs += cc.find_library('multipath',
533                                  required: get_option('mpath'),
534                                  kwargs: static_kwargs)
535     foreach lib: mpathlibs
536       if not lib.found()
537         mpathlibs = []
538         break
539       endif
540     endforeach
541     if mpathlibs.length() == 0
542       msg = 'Dependencies missing for libmpathpersist'
543     elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
544       mpathpersist = declare_dependency(dependencies: mpathlibs)
545       mpathpersist_new_api = true
546     elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
547       mpathpersist = declare_dependency(dependencies: mpathlibs)
548     else
549       msg = 'Cannot detect libmpathpersist API'
550     endif
551     if not mpathpersist.found()
552       if get_option('mpath').enabled()
553         error(msg)
554       else
555         warning(msg + ', disabling')
556       endif
557     endif
558   endif
559 endif
561 iconv = not_found
562 curses = not_found
563 if have_system and not get_option('curses').disabled()
564   curses_test = '''
565     #include <locale.h>
566     #include <curses.h>
567     #include <wchar.h>
568     int main(void) {
569       wchar_t wch = L'w';
570       setlocale(LC_ALL, "");
571       resize_term(0, 0);
572       addwstr(L"wide chars\n");
573       addnwstr(&wch, 1);
574       add_wch(WACS_DEGREE);
575       return 0;
576     }'''
578   curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
579   foreach curses_dep : curses_dep_list
580     if not curses.found()
581       curses = dependency(curses_dep,
582                           required: false,
583                           method: 'pkg-config',
584                           kwargs: static_kwargs)
585     endif
586   endforeach
587   msg = get_option('curses').enabled() ? 'curses library not found' : ''
588   curses_compile_args = ['-DNCURSES_WIDECHAR']
589   if curses.found()
590     if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
591       curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
592     else
593       msg = 'curses package not usable'
594       curses = not_found
595     endif
596   endif
597   if not curses.found()
598     has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
599     if targetos != 'windows' and not has_curses_h
600       message('Trying with /usr/include/ncursesw')
601       curses_compile_args += ['-I/usr/include/ncursesw']
602       has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
603     endif
604     if has_curses_h
605       curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
606       foreach curses_libname : curses_libname_list
607         libcurses = cc.find_library(curses_libname,
608                                     required: false,
609                                     kwargs: static_kwargs)
610         if libcurses.found()
611           if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
612             curses = declare_dependency(compile_args: curses_compile_args,
613                                         dependencies: [libcurses])
614             break
615           else
616             msg = 'curses library not usable'
617           endif
618         endif
619       endforeach
620     endif
621   endif
622   if not get_option('iconv').disabled()
623     foreach link_args : [ ['-liconv'], [] ]
624       # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
625       # We need to use libiconv if available because mixing libiconv's headers with
626       # the system libc does not work.
627       # However, without adding glib to the dependencies -L/usr/local/lib will not be
628       # included in the command line and libiconv will not be found.
629       if cc.links('''
630         #include <iconv.h>
631         int main(void) {
632           iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
633           return conv != (iconv_t) -1;
634         }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
635         iconv = declare_dependency(link_args: link_args, dependencies: glib)
636         break
637       endif
638     endforeach
639   endif
640   if curses.found() and not iconv.found()
641     if get_option('iconv').enabled()
642       error('iconv not available')
643     endif
644     msg = 'iconv required for curses UI but not available'
645     curses = not_found
646   endif
647   if not curses.found() and msg != ''
648     if get_option('curses').enabled()
649       error(msg)
650     else
651       warning(msg + ', disabling')
652     endif
653   endif
654 endif
656 brlapi = not_found
657 if not get_option('brlapi').auto() or have_system
658   brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
659                          required: get_option('brlapi'),
660                          kwargs: static_kwargs)
661   if brlapi.found() and not cc.links('''
662      #include <brlapi.h>
663      #include <stddef.h>
664      int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
665     brlapi = not_found
666     if get_option('brlapi').enabled()
667       error('could not link brlapi')
668     else
669       warning('could not link brlapi, disabling')
670     endif
671   endif
672 endif
674 sdl = not_found
675 if not get_option('sdl').auto() or (have_system and not cocoa.found())
676   sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
677   sdl_image = not_found
678 endif
679 if sdl.found()
680   # work around 2.0.8 bug
681   sdl = declare_dependency(compile_args: '-Wno-undef',
682                            dependencies: sdl)
683   sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
684                          method: 'pkg-config', kwargs: static_kwargs)
685 else
686   if get_option('sdl_image').enabled()
687     error('sdl-image required, but SDL was @0@'.format(
688           get_option('sdl').disabled() ? 'disabled' : 'not found'))
689   endif
690   sdl_image = not_found
691 endif
693 rbd = not_found
694 if not get_option('rbd').auto() or have_block
695   librados = cc.find_library('rados', required: get_option('rbd'),
696                              kwargs: static_kwargs)
697   librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
698                            required: get_option('rbd'),
699                            kwargs: static_kwargs)
700   if librados.found() and librbd.found()
701     if cc.links('''
702       #include <stdio.h>
703       #include <rbd/librbd.h>
704       int main(void) {
705         rados_t cluster;
706         rados_create(&cluster, NULL);
707         return 0;
708       }''', dependencies: [librbd, librados])
709       rbd = declare_dependency(dependencies: [librbd, librados])
710     elif get_option('rbd').enabled()
711       error('could not link librados')
712     else
713       warning('could not link librados, disabling')
714     endif
715   endif
716 endif
718 glusterfs = not_found
719 glusterfs_ftruncate_has_stat = false
720 glusterfs_iocb_has_stat = false
721 if not get_option('glusterfs').auto() or have_block
722   glusterfs = dependency('glusterfs-api', version: '>=3',
723                          required: get_option('glusterfs'),
724                          method: 'pkg-config', kwargs: static_kwargs)
725   if glusterfs.found()
726     glusterfs_ftruncate_has_stat = cc.links('''
727       #include <glusterfs/api/glfs.h>
729       int
730       main(void)
731       {
732           /* new glfs_ftruncate() passes two additional args */
733           return glfs_ftruncate(NULL, 0, NULL, NULL);
734       }
735     ''', dependencies: glusterfs)
736     glusterfs_iocb_has_stat = cc.links('''
737       #include <glusterfs/api/glfs.h>
739       /* new glfs_io_cbk() passes two additional glfs_stat structs */
740       static void
741       glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
742       {}
744       int
745       main(void)
746       {
747           glfs_io_cbk iocb = &glusterfs_iocb;
748           iocb(NULL, 0 , NULL, NULL, NULL);
749           return 0;
750       }
751     ''', dependencies: glusterfs)
752   endif
753 endif
754 libssh = not_found
755 if 'CONFIG_LIBSSH' in config_host
756   libssh = declare_dependency(compile_args: config_host['LIBSSH_CFLAGS'].split(),
757                               link_args: config_host['LIBSSH_LIBS'].split())
758 endif
759 libbzip2 = not_found
760 if not get_option('bzip2').auto() or have_block
761   libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
762                              required: get_option('bzip2'),
763                              kwargs: static_kwargs)
764   if libbzip2.found() and not cc.links('''
765      #include <bzlib.h>
766      int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
767     libbzip2 = not_found
768     if get_option('bzip2').enabled()
769       error('could not link libbzip2')
770     else
771       warning('could not link libbzip2, disabling')
772     endif
773   endif
774 endif
776 liblzfse = not_found
777 if not get_option('lzfse').auto() or have_block
778   liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
779                              required: get_option('lzfse'),
780                              kwargs: static_kwargs)
781 endif
782 if liblzfse.found() and not cc.links('''
783    #include <lzfse.h>
784    int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
785   liblzfse = not_found
786   if get_option('lzfse').enabled()
787     error('could not link liblzfse')
788   else
789     warning('could not link liblzfse, disabling')
790   endif
791 endif
793 oss = not_found
794 if 'CONFIG_AUDIO_OSS' in config_host
795   oss = declare_dependency(link_args: config_host['OSS_LIBS'].split())
796 endif
797 dsound = not_found
798 if 'CONFIG_AUDIO_DSOUND' in config_host
799   dsound = declare_dependency(link_args: config_host['DSOUND_LIBS'].split())
800 endif
801 coreaudio = not_found
802 if 'CONFIG_AUDIO_COREAUDIO' in config_host
803   coreaudio = declare_dependency(link_args: config_host['COREAUDIO_LIBS'].split())
804 endif
805 opengl = not_found
806 if 'CONFIG_OPENGL' in config_host
807   opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
808                               link_args: config_host['OPENGL_LIBS'].split())
809 endif
811 gtk = not_found
812 gtkx11 = not_found
813 if not get_option('gtk').auto() or (have_system and not cocoa.found())
814   gtk = dependency('gtk+-3.0', version: '>=3.22.0',
815                    method: 'pkg-config',
816                    required: get_option('gtk'),
817                    kwargs: static_kwargs)
818   if gtk.found()
819     gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
820                         method: 'pkg-config',
821                         required: false,
822                         kwargs: static_kwargs)
823     gtk = declare_dependency(dependencies: [gtk, gtkx11])
824   endif
825 endif
827 vte = not_found
828 if 'CONFIG_VTE' in config_host
829   vte = declare_dependency(compile_args: config_host['VTE_CFLAGS'].split(),
830                            link_args: config_host['VTE_LIBS'].split())
831 endif
832 x11 = not_found
833 if gtkx11.found() or 'lm32-softmmu' in target_dirs
834   x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
835                    kwargs: static_kwargs)
836 endif
837 vnc = not_found
838 png = not_found
839 jpeg = not_found
840 sasl = not_found
841 if get_option('vnc').enabled()
842   vnc = declare_dependency() # dummy dependency
843   png = dependency('libpng', required: get_option('vnc_png'),
844                    method: 'pkg-config', kwargs: static_kwargs)
845   jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
846                     method: 'pkg-config', kwargs: static_kwargs)
847   sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
848                          required: get_option('vnc_sasl'),
849                          kwargs: static_kwargs)
850   if sasl.found()
851     sasl = declare_dependency(dependencies: sasl,
852                               compile_args: '-DSTRUCT_IOVEC_DEFINED')
853   endif
854 endif
856 snappy = not_found
857 if not get_option('snappy').auto() or have_system
858   snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
859                            required: get_option('snappy'),
860                            kwargs: static_kwargs)
861 endif
862 if snappy.found() and not cc.links('''
863    #include <snappy-c.h>
864    int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
865   snappy = not_found
866   if get_option('snappy').enabled()
867     error('could not link libsnappy')
868   else
869     warning('could not link libsnappy, disabling')
870   endif
871 endif
873 lzo = not_found
874 if not get_option('lzo').auto() or have_system
875   lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
876                         required: get_option('lzo'),
877                         kwargs: static_kwargs)
878 endif
879 if lzo.found() and not cc.links('''
880    #include <lzo/lzo1x.h>
881    int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
882   lzo = not_found
883   if get_option('lzo').enabled()
884     error('could not link liblzo2')
885   else
886     warning('could not link liblzo2, disabling')
887   endif
888 endif
890 rdma = not_found
891 if 'CONFIG_RDMA' in config_host
892   rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
893 endif
894 numa = not_found
895 if 'CONFIG_NUMA' in config_host
896   numa = declare_dependency(link_args: config_host['NUMA_LIBS'].split())
897 endif
898 xen = not_found
899 if 'CONFIG_XEN_BACKEND' in config_host
900   xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
901                            link_args: config_host['XEN_LIBS'].split())
902 endif
903 cacard = not_found
904 if 'CONFIG_SMARTCARD' in config_host
905   cacard = declare_dependency(compile_args: config_host['SMARTCARD_CFLAGS'].split(),
906                               link_args: config_host['SMARTCARD_LIBS'].split())
907 endif
908 u2f = not_found
909 if have_system
910   u2f = dependency('u2f-emu', required: get_option('u2f'),
911                    method: 'pkg-config',
912                    kwargs: static_kwargs)
913 endif
914 usbredir = not_found
915 if 'CONFIG_USB_REDIR' in config_host
916   usbredir = declare_dependency(compile_args: config_host['USB_REDIR_CFLAGS'].split(),
917                                 link_args: config_host['USB_REDIR_LIBS'].split())
918 endif
919 libusb = not_found
920 if 'CONFIG_USB_LIBUSB' in config_host
921   libusb = declare_dependency(compile_args: config_host['LIBUSB_CFLAGS'].split(),
922                               link_args: config_host['LIBUSB_LIBS'].split())
923 endif
924 libpmem = not_found
925 if 'CONFIG_LIBPMEM' in config_host
926   libpmem = declare_dependency(compile_args: config_host['LIBPMEM_CFLAGS'].split(),
927                                link_args: config_host['LIBPMEM_LIBS'].split())
928 endif
929 libdaxctl = not_found
930 if 'CONFIG_LIBDAXCTL' in config_host
931   libdaxctl = declare_dependency(link_args: config_host['LIBDAXCTL_LIBS'].split())
932 endif
933 tasn1 = not_found
934 if 'CONFIG_TASN1' in config_host
935   tasn1 = declare_dependency(compile_args: config_host['TASN1_CFLAGS'].split(),
936                              link_args: config_host['TASN1_LIBS'].split())
937 endif
938 keyutils = dependency('libkeyutils', required: false,
939                       method: 'pkg-config', kwargs: static_kwargs)
941 has_gettid = cc.has_function('gettid')
943 # Malloc tests
945 malloc = []
946 if get_option('malloc') == 'system'
947   has_malloc_trim = \
948     not get_option('malloc_trim').disabled() and \
949     cc.links('''#include <malloc.h>
950                 int main(void) { malloc_trim(0); return 0; }''')
951 else
952   has_malloc_trim = false
953   malloc = cc.find_library(get_option('malloc'), required: true)
954 endif
955 if not has_malloc_trim and get_option('malloc_trim').enabled()
956   if get_option('malloc') == 'system'
957     error('malloc_trim not available on this platform.')
958   else
959     error('malloc_trim not available with non-libc memory allocator')
960   endif
961 endif
963 # Check whether the glibc provides statx()
965 statx_test = '''
966   #ifndef _GNU_SOURCE
967   #define _GNU_SOURCE
968   #endif
969   #include <sys/stat.h>
970   int main(void) {
971     struct statx statxbuf;
972     statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
973     return 0;
974   }'''
976 has_statx = cc.links(statx_test)
978 have_vhost_user_blk_server = (targetos == 'linux' and
979     'CONFIG_VHOST_USER' in config_host)
981 if get_option('vhost_user_blk_server').enabled()
982     if targetos != 'linux'
983         error('vhost_user_blk_server requires linux')
984     elif 'CONFIG_VHOST_USER' not in config_host
985         error('vhost_user_blk_server requires vhost-user support')
986     endif
987 elif get_option('vhost_user_blk_server').disabled() or not have_system
988     have_vhost_user_blk_server = false
989 endif
992 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
993   error('Cannot enable fuse-lseek while fuse is disabled')
994 endif
996 fuse = dependency('fuse3', required: get_option('fuse'),
997                   version: '>=3.1', method: 'pkg-config',
998                   kwargs: static_kwargs)
1000 fuse_lseek = not_found
1001 if not get_option('fuse_lseek').disabled()
1002   if fuse.version().version_compare('>=3.8')
1003     # Dummy dependency
1004     fuse_lseek = declare_dependency()
1005   elif get_option('fuse_lseek').enabled()
1006     if fuse.found()
1007       error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1008     else
1009       error('fuse-lseek requires libfuse, which was not found')
1010     endif
1011   endif
1012 endif
1014 if get_option('cfi')
1015   cfi_flags=[]
1016   # Check for dependency on LTO
1017   if not get_option('b_lto')
1018     error('Selected Control-Flow Integrity but LTO is disabled')
1019   endif
1020   if config_host.has_key('CONFIG_MODULES')
1021     error('Selected Control-Flow Integrity is not compatible with modules')
1022   endif
1023   # Check for cfi flags. CFI requires LTO so we can't use
1024   # get_supported_arguments, but need a more complex "compiles" which allows
1025   # custom arguments
1026   if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1027                  args: ['-flto', '-fsanitize=cfi-icall'] )
1028     cfi_flags += '-fsanitize=cfi-icall'
1029   else
1030     error('-fsanitize=cfi-icall is not supported by the compiler')
1031   endif
1032   if cc.compiles('int main () { return 0; }',
1033                  name: '-fsanitize-cfi-icall-generalize-pointers',
1034                  args: ['-flto', '-fsanitize=cfi-icall',
1035                         '-fsanitize-cfi-icall-generalize-pointers'] )
1036     cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1037   else
1038     error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1039   endif
1040   if get_option('cfi_debug')
1041     if cc.compiles('int main () { return 0; }',
1042                    name: '-fno-sanitize-trap=cfi-icall',
1043                    args: ['-flto', '-fsanitize=cfi-icall',
1044                           '-fno-sanitize-trap=cfi-icall'] )
1045       cfi_flags += '-fno-sanitize-trap=cfi-icall'
1046     else
1047       error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1048     endif
1049   endif
1050   add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1051   add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1052 endif
1054 #################
1055 # config-host.h #
1056 #################
1058 have_virtfs = (targetos == 'linux' and
1059     have_system and
1060     libattr.found() and
1061     libcap_ng.found())
1063 have_virtfs_proxy_helper = have_virtfs and have_tools
1065 if get_option('virtfs').enabled()
1066   if not have_virtfs
1067     if targetos != 'linux'
1068       error('virtio-9p (virtfs) requires Linux')
1069     elif not libcap_ng.found() or not libattr.found()
1070       error('virtio-9p (virtfs) requires libcap-ng-devel and libattr-devel')
1071     elif not have_system
1072       error('virtio-9p (virtfs) needs system emulation support')
1073     endif
1074   endif
1075 elif get_option('virtfs').disabled()
1076   have_virtfs = false
1077 endif
1079 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1080 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1081 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1082 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1083 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1084 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1085 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1086 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1087 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1088 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1089 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1090 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1092 config_host_data.set('CONFIG_ATTR', libattr.found())
1093 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1094 config_host_data.set('CONFIG_COCOA', cocoa.found())
1095 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1096 config_host_data.set('CONFIG_LZO', lzo.found())
1097 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1098 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1099 config_host_data.set('CONFIG_CURL', curl.found())
1100 config_host_data.set('CONFIG_CURSES', curses.found())
1101 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1102 if glusterfs.found()
1103   config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1104   config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1105   config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1106   config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1107   config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1108   config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1109 endif
1110 config_host_data.set('CONFIG_GTK', gtk.found())
1111 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1112 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1113 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1114 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1115 config_host_data.set('CONFIG_RBD', rbd.found())
1116 config_host_data.set('CONFIG_SDL', sdl.found())
1117 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1118 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1119 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1120 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1121 config_host_data.set('CONFIG_VNC', vnc.found())
1122 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1123 config_host_data.set('CONFIG_VNC_PNG', png.found())
1124 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1125 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1126 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1127 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1128 config_host_data.set('CONFIG_GETTID', has_gettid)
1129 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1130 config_host_data.set('CONFIG_STATX', has_statx)
1131 config_host_data.set('CONFIG_ZSTD', zstd.found())
1132 config_host_data.set('CONFIG_FUSE', fuse.found())
1133 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1134 config_host_data.set('CONFIG_X11', x11.found())
1135 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1136 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1137 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1138 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1139 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1141 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1142 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1143 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1144 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1145 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1146 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1148 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1150 ignored = ['CONFIG_QEMU_INTERP_PREFIX'] # actually per-target
1151 arrays = ['CONFIG_AUDIO_DRIVERS', 'CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1152 strings = ['HOST_DSOSUF', 'CONFIG_IASL']
1153 foreach k, v: config_host
1154   if ignored.contains(k)
1155     # do nothing
1156   elif arrays.contains(k)
1157     if v != ''
1158       v = '"' + '", "'.join(v.split()) + '", '
1159     endif
1160     config_host_data.set(k, v)
1161   elif k == 'ARCH'
1162     config_host_data.set('HOST_' + v.to_upper(), 1)
1163   elif strings.contains(k)
1164     if not k.startswith('CONFIG_')
1165       k = 'CONFIG_' + k.to_upper()
1166     endif
1167     config_host_data.set_quoted(k, v)
1168   elif k.startswith('CONFIG_') or k.startswith('HAVE_') or k.startswith('HOST_')
1169     config_host_data.set(k, v == 'y' ? 1 : v)
1170   endif
1171 endforeach
1173 ########################
1174 # Target configuration #
1175 ########################
1177 minikconf = find_program('scripts/minikconf.py')
1178 config_all = {}
1179 config_all_devices = {}
1180 config_all_disas = {}
1181 config_devices_mak_list = []
1182 config_devices_h = {}
1183 config_target_h = {}
1184 config_target_mak = {}
1186 disassemblers = {
1187   'alpha' : ['CONFIG_ALPHA_DIS'],
1188   'arm' : ['CONFIG_ARM_DIS'],
1189   'avr' : ['CONFIG_AVR_DIS'],
1190   'cris' : ['CONFIG_CRIS_DIS'],
1191   'hexagon' : ['CONFIG_HEXAGON_DIS'],
1192   'hppa' : ['CONFIG_HPPA_DIS'],
1193   'i386' : ['CONFIG_I386_DIS'],
1194   'x86_64' : ['CONFIG_I386_DIS'],
1195   'x32' : ['CONFIG_I386_DIS'],
1196   'lm32' : ['CONFIG_LM32_DIS'],
1197   'm68k' : ['CONFIG_M68K_DIS'],
1198   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
1199   'mips' : ['CONFIG_MIPS_DIS'],
1200   'moxie' : ['CONFIG_MOXIE_DIS'],
1201   'nios2' : ['CONFIG_NIOS2_DIS'],
1202   'or1k' : ['CONFIG_OPENRISC_DIS'],
1203   'ppc' : ['CONFIG_PPC_DIS'],
1204   'riscv' : ['CONFIG_RISCV_DIS'],
1205   'rx' : ['CONFIG_RX_DIS'],
1206   's390' : ['CONFIG_S390_DIS'],
1207   'sh4' : ['CONFIG_SH4_DIS'],
1208   'sparc' : ['CONFIG_SPARC_DIS'],
1209   'xtensa' : ['CONFIG_XTENSA_DIS'],
1211 if link_language == 'cpp'
1212   disassemblers += {
1213     'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
1214     'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
1215     'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
1216   }
1217 endif
1219 host_kconfig = \
1220   ('CONFIG_TPM' in config_host ? ['CONFIG_TPM=y'] : []) + \
1221   ('CONFIG_SPICE' in config_host ? ['CONFIG_SPICE=y'] : []) + \
1222   ('CONFIG_IVSHMEM' in config_host ? ['CONFIG_IVSHMEM=y'] : []) + \
1223   ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
1224   (x11.found() ? ['CONFIG_X11=y'] : []) + \
1225   ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
1226   ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
1227   ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
1228   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
1229   ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
1230   ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
1231   ('CONFIG_MULTIPROCESS_ALLOWED' in config_host ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
1233 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
1235 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
1236 actual_target_dirs = []
1237 fdt_required = []
1238 foreach target : target_dirs
1239   config_target = { 'TARGET_NAME': target.split('-')[0] }
1240   if target.endswith('linux-user')
1241     if targetos != 'linux'
1242       if default_targets
1243         continue
1244       endif
1245       error('Target @0@ is only available on a Linux host'.format(target))
1246     endif
1247     config_target += { 'CONFIG_LINUX_USER': 'y' }
1248   elif target.endswith('bsd-user')
1249     if 'CONFIG_BSD' not in config_host
1250       if default_targets
1251         continue
1252       endif
1253       error('Target @0@ is only available on a BSD host'.format(target))
1254     endif
1255     config_target += { 'CONFIG_BSD_USER': 'y' }
1256   elif target.endswith('softmmu')
1257     config_target += { 'CONFIG_SOFTMMU': 'y' }
1258   endif
1259   if target.endswith('-user')
1260     config_target += {
1261       'CONFIG_USER_ONLY': 'y',
1262       'CONFIG_QEMU_INTERP_PREFIX':
1263         config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
1264     }
1265   endif
1267   accel_kconfig = []
1268   foreach sym: accelerators
1269     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
1270       config_target += { sym: 'y' }
1271       config_all += { sym: 'y' }
1272       if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
1273         config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
1274       elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
1275         config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
1276       endif
1277       accel_kconfig += [ sym + '=y' ]
1278     endif
1279   endforeach
1280   if accel_kconfig.length() == 0
1281     if default_targets
1282       continue
1283     endif
1284     error('No accelerator available for target @0@'.format(target))
1285   endif
1287   actual_target_dirs += target
1288   config_target += keyval.load('default-configs/targets' / target + '.mak')
1289   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
1291   if 'TARGET_NEED_FDT' in config_target
1292     fdt_required += target
1293   endif
1295   # Add default keys
1296   if 'TARGET_BASE_ARCH' not in config_target
1297     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
1298   endif
1299   if 'TARGET_ABI_DIR' not in config_target
1300     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
1301   endif
1303   foreach k, v: disassemblers
1304     if config_host['ARCH'].startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
1305       foreach sym: v
1306         config_target += { sym: 'y' }
1307         config_all_disas += { sym: 'y' }
1308       endforeach
1309     endif
1310   endforeach
1312   config_target_data = configuration_data()
1313   foreach k, v: config_target
1314     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
1315       # do nothing
1316     elif ignored.contains(k)
1317       # do nothing
1318     elif k == 'TARGET_BASE_ARCH'
1319       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
1320       # not used to select files from sourcesets.
1321       config_target_data.set('TARGET_' + v.to_upper(), 1)
1322     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
1323       config_target_data.set_quoted(k, v)
1324     elif v == 'y'
1325       config_target_data.set(k, 1)
1326     else
1327       config_target_data.set(k, v)
1328     endif
1329   endforeach
1330   config_target_h += {target: configure_file(output: target + '-config-target.h',
1331                                                configuration: config_target_data)}
1333   if target.endswith('-softmmu')
1334     config_devices_mak = target + '-config-devices.mak'
1335     config_devices_mak = configure_file(
1336       input: ['default-configs/devices' / target + '.mak', 'Kconfig'],
1337       output: config_devices_mak,
1338       depfile: config_devices_mak + '.d',
1339       capture: true,
1340       command: [minikconf,
1341                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
1342                 config_devices_mak, '@DEPFILE@', '@INPUT@',
1343                 host_kconfig, accel_kconfig])
1345     config_devices_data = configuration_data()
1346     config_devices = keyval.load(config_devices_mak)
1347     foreach k, v: config_devices
1348       config_devices_data.set(k, 1)
1349     endforeach
1350     config_devices_mak_list += config_devices_mak
1351     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
1352                                                 configuration: config_devices_data)}
1353     config_target += config_devices
1354     config_all_devices += config_devices
1355   endif
1356   config_target_mak += {target: config_target}
1357 endforeach
1358 target_dirs = actual_target_dirs
1360 # This configuration is used to build files that are shared by
1361 # multiple binaries, and then extracted out of the "common"
1362 # static_library target.
1364 # We do not use all_sources()/all_dependencies(), because it would
1365 # build literally all source files, including devices only used by
1366 # targets that are not built for this compilation.  The CONFIG_ALL
1367 # pseudo symbol replaces it.
1369 config_all += config_all_devices
1370 config_all += config_host
1371 config_all += config_all_disas
1372 config_all += {
1373   'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
1374   'CONFIG_SOFTMMU': have_system,
1375   'CONFIG_USER_ONLY': have_user,
1376   'CONFIG_ALL': true,
1379 ##############
1380 # Submodules #
1381 ##############
1383 capstone = not_found
1384 capstone_opt = get_option('capstone')
1385 if capstone_opt in ['enabled', 'auto', 'system']
1386   have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
1387   capstone = dependency('capstone', version: '>=4.0',
1388                         kwargs: static_kwargs, method: 'pkg-config',
1389                         required: capstone_opt == 'system' or
1390                                   capstone_opt == 'enabled' and not have_internal)
1391   if capstone.found()
1392     capstone_opt = 'system'
1393   elif have_internal
1394     capstone_opt = 'internal'
1395   else
1396     capstone_opt = 'disabled'
1397   endif
1398 endif
1399 if capstone_opt == 'internal'
1400   capstone_data = configuration_data()
1401   capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
1403   capstone_files = files(
1404     'capstone/cs.c',
1405     'capstone/MCInst.c',
1406     'capstone/MCInstrDesc.c',
1407     'capstone/MCRegisterInfo.c',
1408     'capstone/SStream.c',
1409     'capstone/utils.c'
1410   )
1412   if 'CONFIG_ARM_DIS' in config_all_disas
1413     capstone_data.set('CAPSTONE_HAS_ARM', '1')
1414     capstone_files += files(
1415       'capstone/arch/ARM/ARMDisassembler.c',
1416       'capstone/arch/ARM/ARMInstPrinter.c',
1417       'capstone/arch/ARM/ARMMapping.c',
1418       'capstone/arch/ARM/ARMModule.c'
1419     )
1420   endif
1422   # FIXME: This config entry currently depends on a c++ compiler.
1423   # Which is needed for building libvixl, but not for capstone.
1424   if 'CONFIG_ARM_A64_DIS' in config_all_disas
1425     capstone_data.set('CAPSTONE_HAS_ARM64', '1')
1426     capstone_files += files(
1427       'capstone/arch/AArch64/AArch64BaseInfo.c',
1428       'capstone/arch/AArch64/AArch64Disassembler.c',
1429       'capstone/arch/AArch64/AArch64InstPrinter.c',
1430       'capstone/arch/AArch64/AArch64Mapping.c',
1431       'capstone/arch/AArch64/AArch64Module.c'
1432     )
1433   endif
1435   if 'CONFIG_PPC_DIS' in config_all_disas
1436     capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
1437     capstone_files += files(
1438       'capstone/arch/PowerPC/PPCDisassembler.c',
1439       'capstone/arch/PowerPC/PPCInstPrinter.c',
1440       'capstone/arch/PowerPC/PPCMapping.c',
1441       'capstone/arch/PowerPC/PPCModule.c'
1442     )
1443   endif
1445   if 'CONFIG_S390_DIS' in config_all_disas
1446     capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
1447     capstone_files += files(
1448       'capstone/arch/SystemZ/SystemZDisassembler.c',
1449       'capstone/arch/SystemZ/SystemZInstPrinter.c',
1450       'capstone/arch/SystemZ/SystemZMapping.c',
1451       'capstone/arch/SystemZ/SystemZModule.c',
1452       'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
1453     )
1454   endif
1456   if 'CONFIG_I386_DIS' in config_all_disas
1457     capstone_data.set('CAPSTONE_HAS_X86', 1)
1458     capstone_files += files(
1459       'capstone/arch/X86/X86Disassembler.c',
1460       'capstone/arch/X86/X86DisassemblerDecoder.c',
1461       'capstone/arch/X86/X86ATTInstPrinter.c',
1462       'capstone/arch/X86/X86IntelInstPrinter.c',
1463       'capstone/arch/X86/X86InstPrinterCommon.c',
1464       'capstone/arch/X86/X86Mapping.c',
1465       'capstone/arch/X86/X86Module.c'
1466     )
1467   endif
1469   configure_file(output: 'capstone-defs.h', configuration: capstone_data)
1471   capstone_cargs = [
1472     # FIXME: There does not seem to be a way to completely replace the c_args
1473     # that come from add_project_arguments() -- we can only add to them.
1474     # So: disable all warnings with a big hammer.
1475     '-Wno-error', '-w',
1477     # Include all configuration defines via a header file, which will wind up
1478     # as a dependency on the object file, and thus changes here will result
1479     # in a rebuild.
1480     '-include', 'capstone-defs.h'
1481   ]
1483   libcapstone = static_library('capstone',
1484                                build_by_default: false,
1485                                sources: capstone_files,
1486                                c_args: capstone_cargs,
1487                                include_directories: 'capstone/include')
1488   capstone = declare_dependency(link_with: libcapstone,
1489                                 include_directories: 'capstone/include/capstone')
1490 endif
1492 slirp = not_found
1493 slirp_opt = 'disabled'
1494 if have_system
1495   slirp_opt = get_option('slirp')
1496   if slirp_opt in ['enabled', 'auto', 'system']
1497     have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
1498     slirp = dependency('slirp', kwargs: static_kwargs,
1499                        method: 'pkg-config',
1500                        required: slirp_opt == 'system' or
1501                                  slirp_opt == 'enabled' and not have_internal)
1502     if slirp.found()
1503       slirp_opt = 'system'
1504     elif have_internal
1505       slirp_opt = 'internal'
1506     else
1507       slirp_opt = 'disabled'
1508     endif
1509   endif
1510   if slirp_opt == 'internal'
1511     slirp_deps = []
1512     if targetos == 'windows'
1513       slirp_deps = cc.find_library('iphlpapi')
1514     endif
1515     slirp_conf = configuration_data()
1516     slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
1517     slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
1518     slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
1519     slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
1520     slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
1521     slirp_files = [
1522       'slirp/src/arp_table.c',
1523       'slirp/src/bootp.c',
1524       'slirp/src/cksum.c',
1525       'slirp/src/dhcpv6.c',
1526       'slirp/src/dnssearch.c',
1527       'slirp/src/if.c',
1528       'slirp/src/ip6_icmp.c',
1529       'slirp/src/ip6_input.c',
1530       'slirp/src/ip6_output.c',
1531       'slirp/src/ip_icmp.c',
1532       'slirp/src/ip_input.c',
1533       'slirp/src/ip_output.c',
1534       'slirp/src/mbuf.c',
1535       'slirp/src/misc.c',
1536       'slirp/src/ncsi.c',
1537       'slirp/src/ndp_table.c',
1538       'slirp/src/sbuf.c',
1539       'slirp/src/slirp.c',
1540       'slirp/src/socket.c',
1541       'slirp/src/state.c',
1542       'slirp/src/stream.c',
1543       'slirp/src/tcp_input.c',
1544       'slirp/src/tcp_output.c',
1545       'slirp/src/tcp_subr.c',
1546       'slirp/src/tcp_timer.c',
1547       'slirp/src/tftp.c',
1548       'slirp/src/udp.c',
1549       'slirp/src/udp6.c',
1550       'slirp/src/util.c',
1551       'slirp/src/version.c',
1552       'slirp/src/vmstate.c',
1553     ]
1555     configure_file(
1556       input : 'slirp/src/libslirp-version.h.in',
1557       output : 'libslirp-version.h',
1558       configuration: slirp_conf)
1560     slirp_inc = include_directories('slirp', 'slirp/src')
1561     libslirp = static_library('slirp',
1562                               build_by_default: false,
1563                               sources: slirp_files,
1564                               c_args: slirp_cargs,
1565                               include_directories: slirp_inc)
1566     slirp = declare_dependency(link_with: libslirp,
1567                                dependencies: slirp_deps,
1568                                include_directories: slirp_inc)
1569   endif
1570 endif
1572 fdt = not_found
1573 fdt_opt = get_option('fdt')
1574 if have_system
1575   if fdt_opt in ['enabled', 'auto', 'system']
1576     have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
1577     fdt = cc.find_library('fdt', kwargs: static_kwargs,
1578                           required: fdt_opt == 'system' or
1579                                     fdt_opt == 'enabled' and not have_internal)
1580     if fdt.found() and cc.links('''
1581        #include <libfdt.h>
1582        #include <libfdt_env.h>
1583        int main(void) { fdt_check_full(NULL, 0); return 0; }''',
1584          dependencies: fdt)
1585       fdt_opt = 'system'
1586     elif have_internal
1587       fdt_opt = 'internal'
1588     else
1589       fdt_opt = 'disabled'
1590     endif
1591   endif
1592   if fdt_opt == 'internal'
1593     fdt_files = files(
1594       'dtc/libfdt/fdt.c',
1595       'dtc/libfdt/fdt_ro.c',
1596       'dtc/libfdt/fdt_wip.c',
1597       'dtc/libfdt/fdt_sw.c',
1598       'dtc/libfdt/fdt_rw.c',
1599       'dtc/libfdt/fdt_strerror.c',
1600       'dtc/libfdt/fdt_empty_tree.c',
1601       'dtc/libfdt/fdt_addresses.c',
1602       'dtc/libfdt/fdt_overlay.c',
1603       'dtc/libfdt/fdt_check.c',
1604     )
1606     fdt_inc = include_directories('dtc/libfdt')
1607     libfdt = static_library('fdt',
1608                             build_by_default: false,
1609                             sources: fdt_files,
1610                             include_directories: fdt_inc)
1611     fdt = declare_dependency(link_with: libfdt,
1612                              include_directories: fdt_inc)
1613   endif
1614 endif
1615 if not fdt.found() and fdt_required.length() > 0
1616   error('fdt not available but required by targets ' + ', '.join(fdt_required))
1617 endif
1619 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
1620 config_host_data.set('CONFIG_FDT', fdt.found())
1621 config_host_data.set('CONFIG_SLIRP', slirp.found())
1623 #####################
1624 # Generated sources #
1625 #####################
1627 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
1629 hxtool = find_program('scripts/hxtool')
1630 shaderinclude = find_program('scripts/shaderinclude.pl')
1631 qapi_gen = find_program('scripts/qapi-gen.py')
1632 qapi_gen_depends = [ meson.source_root() / 'scripts/qapi/__init__.py',
1633                      meson.source_root() / 'scripts/qapi/commands.py',
1634                      meson.source_root() / 'scripts/qapi/common.py',
1635                      meson.source_root() / 'scripts/qapi/error.py',
1636                      meson.source_root() / 'scripts/qapi/events.py',
1637                      meson.source_root() / 'scripts/qapi/expr.py',
1638                      meson.source_root() / 'scripts/qapi/gen.py',
1639                      meson.source_root() / 'scripts/qapi/introspect.py',
1640                      meson.source_root() / 'scripts/qapi/parser.py',
1641                      meson.source_root() / 'scripts/qapi/schema.py',
1642                      meson.source_root() / 'scripts/qapi/source.py',
1643                      meson.source_root() / 'scripts/qapi/types.py',
1644                      meson.source_root() / 'scripts/qapi/visit.py',
1645                      meson.source_root() / 'scripts/qapi/common.py',
1646                      meson.source_root() / 'scripts/qapi-gen.py'
1649 tracetool = [
1650   python, files('scripts/tracetool.py'),
1651    '--backend=' + config_host['TRACE_BACKENDS']
1653 tracetool_depends = files(
1654   'scripts/tracetool/backend/log.py',
1655   'scripts/tracetool/backend/__init__.py',
1656   'scripts/tracetool/backend/dtrace.py',
1657   'scripts/tracetool/backend/ftrace.py',
1658   'scripts/tracetool/backend/simple.py',
1659   'scripts/tracetool/backend/syslog.py',
1660   'scripts/tracetool/backend/ust.py',
1661   'scripts/tracetool/format/tcg_h.py',
1662   'scripts/tracetool/format/ust_events_c.py',
1663   'scripts/tracetool/format/ust_events_h.py',
1664   'scripts/tracetool/format/__init__.py',
1665   'scripts/tracetool/format/d.py',
1666   'scripts/tracetool/format/tcg_helper_c.py',
1667   'scripts/tracetool/format/simpletrace_stap.py',
1668   'scripts/tracetool/format/c.py',
1669   'scripts/tracetool/format/h.py',
1670   'scripts/tracetool/format/tcg_helper_h.py',
1671   'scripts/tracetool/format/log_stap.py',
1672   'scripts/tracetool/format/stap.py',
1673   'scripts/tracetool/format/tcg_helper_wrapper_h.py',
1674   'scripts/tracetool/__init__.py',
1675   'scripts/tracetool/transform.py',
1676   'scripts/tracetool/vcpu.py'
1679 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
1680                     meson.current_source_dir(),
1681                     config_host['PKGVERSION'], meson.project_version()]
1682 qemu_version = custom_target('qemu-version.h',
1683                              output: 'qemu-version.h',
1684                              command: qemu_version_cmd,
1685                              capture: true,
1686                              build_by_default: true,
1687                              build_always_stale: true)
1688 genh += qemu_version
1690 hxdep = []
1691 hx_headers = [
1692   ['qemu-options.hx', 'qemu-options.def'],
1693   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
1695 if have_system
1696   hx_headers += [
1697     ['hmp-commands.hx', 'hmp-commands.h'],
1698     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
1699   ]
1700 endif
1701 foreach d : hx_headers
1702   hxdep += custom_target(d[1],
1703                 input: files(d[0]),
1704                 output: d[1],
1705                 capture: true,
1706                 build_by_default: true, # to be removed when added to a target
1707                 command: [hxtool, '-h', '@INPUT0@'])
1708 endforeach
1709 genh += hxdep
1711 ###################
1712 # Collect sources #
1713 ###################
1715 authz_ss = ss.source_set()
1716 blockdev_ss = ss.source_set()
1717 block_ss = ss.source_set()
1718 bsd_user_ss = ss.source_set()
1719 chardev_ss = ss.source_set()
1720 common_ss = ss.source_set()
1721 crypto_ss = ss.source_set()
1722 io_ss = ss.source_set()
1723 linux_user_ss = ss.source_set()
1724 qmp_ss = ss.source_set()
1725 qom_ss = ss.source_set()
1726 softmmu_ss = ss.source_set()
1727 specific_fuzz_ss = ss.source_set()
1728 specific_ss = ss.source_set()
1729 stub_ss = ss.source_set()
1730 trace_ss = ss.source_set()
1731 user_ss = ss.source_set()
1732 util_ss = ss.source_set()
1734 modules = {}
1735 hw_arch = {}
1736 target_arch = {}
1737 target_softmmu_arch = {}
1739 ###############
1740 # Trace files #
1741 ###############
1743 # TODO: add each directory to the subdirs from its own meson.build, once
1744 # we have those
1745 trace_events_subdirs = [
1746   'crypto',
1747   'qapi',
1748   'qom',
1749   'monitor',
1750   'util',
1752 if have_user
1753   trace_events_subdirs += [ 'linux-user' ]
1754 endif
1755 if have_block
1756   trace_events_subdirs += [
1757     'authz',
1758     'block',
1759     'io',
1760     'nbd',
1761     'scsi',
1762   ]
1763 endif
1764 if have_system
1765   trace_events_subdirs += [
1766     'accel/kvm',
1767     'audio',
1768     'backends',
1769     'backends/tpm',
1770     'chardev',
1771     'hw/9pfs',
1772     'hw/acpi',
1773     'hw/adc',
1774     'hw/alpha',
1775     'hw/arm',
1776     'hw/audio',
1777     'hw/block',
1778     'hw/block/dataplane',
1779     'hw/char',
1780     'hw/display',
1781     'hw/dma',
1782     'hw/hppa',
1783     'hw/hyperv',
1784     'hw/i2c',
1785     'hw/i386',
1786     'hw/i386/xen',
1787     'hw/ide',
1788     'hw/input',
1789     'hw/intc',
1790     'hw/isa',
1791     'hw/mem',
1792     'hw/mips',
1793     'hw/misc',
1794     'hw/misc/macio',
1795     'hw/net',
1796     'hw/net/can',
1797     'hw/nvram',
1798     'hw/pci',
1799     'hw/pci-host',
1800     'hw/ppc',
1801     'hw/rdma',
1802     'hw/rdma/vmw',
1803     'hw/rtc',
1804     'hw/s390x',
1805     'hw/scsi',
1806     'hw/sd',
1807     'hw/sparc',
1808     'hw/sparc64',
1809     'hw/ssi',
1810     'hw/timer',
1811     'hw/tpm',
1812     'hw/usb',
1813     'hw/vfio',
1814     'hw/virtio',
1815     'hw/watchdog',
1816     'hw/xen',
1817     'hw/gpio',
1818     'migration',
1819     'net',
1820     'softmmu',
1821     'ui',
1822     'hw/remote',
1823   ]
1824 endif
1825 if have_system or have_user
1826   trace_events_subdirs += [
1827     'accel/tcg',
1828     'hw/core',
1829     'target/arm',
1830     'target/hppa',
1831     'target/i386',
1832     'target/i386/kvm',
1833     'target/mips',
1834     'target/ppc',
1835     'target/riscv',
1836     'target/s390x',
1837     'target/sparc',
1838   ]
1839 endif
1841 vhost_user = not_found
1842 if 'CONFIG_VHOST_USER' in config_host
1843   libvhost_user = subproject('libvhost-user')
1844   vhost_user = libvhost_user.get_variable('vhost_user_dep')
1845 endif
1847 subdir('qapi')
1848 subdir('qobject')
1849 subdir('stubs')
1850 subdir('trace')
1851 subdir('util')
1852 subdir('qom')
1853 subdir('authz')
1854 subdir('crypto')
1855 subdir('ui')
1858 if enable_modules
1859   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
1860   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
1861 endif
1863 stub_ss = stub_ss.apply(config_all, strict: false)
1865 util_ss.add_all(trace_ss)
1866 util_ss = util_ss.apply(config_all, strict: false)
1867 libqemuutil = static_library('qemuutil',
1868                              sources: util_ss.sources() + stub_ss.sources() + genh,
1869                              dependencies: [util_ss.dependencies(), m, glib, socket, malloc])
1870 qemuutil = declare_dependency(link_with: libqemuutil,
1871                               sources: genh + version_res)
1873 if have_system or have_user
1874   decodetree = generator(find_program('scripts/decodetree.py'),
1875                          output: 'decode-@BASENAME@.c.inc',
1876                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
1877   subdir('libdecnumber')
1878   subdir('target')
1879 endif
1881 subdir('audio')
1882 subdir('io')
1883 subdir('chardev')
1884 subdir('fsdev')
1885 subdir('dump')
1887 if have_block
1888   block_ss.add(files(
1889     'block.c',
1890     'blockjob.c',
1891     'job.c',
1892     'qemu-io-cmds.c',
1893   ))
1894   block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
1896   subdir('nbd')
1897   subdir('scsi')
1898   subdir('block')
1900   blockdev_ss.add(files(
1901     'blockdev.c',
1902     'blockdev-nbd.c',
1903     'iothread.c',
1904     'job-qmp.c',
1905   ), gnutls)
1907   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
1908   # os-win32.c does not
1909   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
1910   softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
1911 endif
1913 common_ss.add(files('cpus-common.c'))
1915 subdir('softmmu')
1917 common_ss.add(capstone)
1918 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
1919 specific_ss.add(files('exec-vary.c'))
1920 specific_ss.add(when: 'CONFIG_TCG', if_true: files(
1921   'fpu/softfloat.c',
1922   'tcg/optimize.c',
1923   'tcg/tcg-common.c',
1924   'tcg/tcg-op-gvec.c',
1925   'tcg/tcg-op-vec.c',
1926   'tcg/tcg-op.c',
1927   'tcg/tcg.c',
1929 specific_ss.add(when: 'CONFIG_TCG_INTERPRETER', if_true: files('disas/tci.c', 'tcg/tci.c'))
1931 subdir('backends')
1932 subdir('disas')
1933 subdir('migration')
1934 subdir('monitor')
1935 subdir('net')
1936 subdir('replay')
1937 subdir('hw')
1938 subdir('accel')
1939 subdir('plugins')
1940 subdir('bsd-user')
1941 subdir('linux-user')
1943 bsd_user_ss.add(files('gdbstub.c'))
1944 specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss)
1946 linux_user_ss.add(files('gdbstub.c', 'thunk.c'))
1947 specific_ss.add_all(when: 'CONFIG_LINUX_USER', if_true: linux_user_ss)
1949 # needed for fuzzing binaries
1950 subdir('tests/qtest/libqos')
1951 subdir('tests/qtest/fuzz')
1953 ########################
1954 # Library dependencies #
1955 ########################
1957 block_mods = []
1958 softmmu_mods = []
1959 foreach d, list : modules
1960   foreach m, module_ss : list
1961     if enable_modules and targetos != 'windows'
1962       module_ss = module_ss.apply(config_all, strict: false)
1963       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
1964                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
1965       if d == 'block'
1966         block_mods += sl
1967       else
1968         softmmu_mods += sl
1969       endif
1970     else
1971       if d == 'block'
1972         block_ss.add_all(module_ss)
1973       else
1974         softmmu_ss.add_all(module_ss)
1975       endif
1976     endif
1977   endforeach
1978 endforeach
1980 nm = find_program('nm')
1981 undefsym = find_program('scripts/undefsym.py')
1982 block_syms = custom_target('block.syms', output: 'block.syms',
1983                              input: [libqemuutil, block_mods],
1984                              capture: true,
1985                              command: [undefsym, nm, '@INPUT@'])
1986 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
1987                              input: [libqemuutil, softmmu_mods],
1988                              capture: true,
1989                              command: [undefsym, nm, '@INPUT@'])
1991 qom_ss = qom_ss.apply(config_host, strict: false)
1992 libqom = static_library('qom', qom_ss.sources() + genh,
1993                         dependencies: [qom_ss.dependencies()],
1994                         name_suffix: 'fa')
1996 qom = declare_dependency(link_whole: libqom)
1998 authz_ss = authz_ss.apply(config_host, strict: false)
1999 libauthz = static_library('authz', authz_ss.sources() + genh,
2000                           dependencies: [authz_ss.dependencies()],
2001                           name_suffix: 'fa',
2002                           build_by_default: false)
2004 authz = declare_dependency(link_whole: libauthz,
2005                            dependencies: qom)
2007 crypto_ss = crypto_ss.apply(config_host, strict: false)
2008 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2009                            dependencies: [crypto_ss.dependencies()],
2010                            name_suffix: 'fa',
2011                            build_by_default: false)
2013 crypto = declare_dependency(link_whole: libcrypto,
2014                             dependencies: [authz, qom])
2016 io_ss = io_ss.apply(config_host, strict: false)
2017 libio = static_library('io', io_ss.sources() + genh,
2018                        dependencies: [io_ss.dependencies()],
2019                        link_with: libqemuutil,
2020                        name_suffix: 'fa',
2021                        build_by_default: false)
2023 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
2025 libmigration = static_library('migration', sources: migration_files + genh,
2026                               name_suffix: 'fa',
2027                               build_by_default: false)
2028 migration = declare_dependency(link_with: libmigration,
2029                                dependencies: [zlib, qom, io])
2030 softmmu_ss.add(migration)
2032 block_ss = block_ss.apply(config_host, strict: false)
2033 libblock = static_library('block', block_ss.sources() + genh,
2034                           dependencies: block_ss.dependencies(),
2035                           link_depends: block_syms,
2036                           name_suffix: 'fa',
2037                           build_by_default: false)
2039 block = declare_dependency(link_whole: [libblock],
2040                            link_args: '@block.syms',
2041                            dependencies: [crypto, io])
2043 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
2044 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
2045                              dependencies: blockdev_ss.dependencies(),
2046                              name_suffix: 'fa',
2047                              build_by_default: false)
2049 blockdev = declare_dependency(link_whole: [libblockdev],
2050                               dependencies: [block])
2052 qmp_ss = qmp_ss.apply(config_host, strict: false)
2053 libqmp = static_library('qmp', qmp_ss.sources() + genh,
2054                         dependencies: qmp_ss.dependencies(),
2055                         name_suffix: 'fa',
2056                         build_by_default: false)
2058 qmp = declare_dependency(link_whole: [libqmp])
2060 libchardev = static_library('chardev', chardev_ss.sources() + genh,
2061                             name_suffix: 'fa',
2062                             dependencies: [gnutls],
2063                             build_by_default: false)
2065 chardev = declare_dependency(link_whole: libchardev)
2067 libhwcore = static_library('hwcore', sources: hwcore_files + genh,
2068                            name_suffix: 'fa',
2069                            build_by_default: false)
2070 hwcore = declare_dependency(link_whole: libhwcore)
2071 common_ss.add(hwcore)
2073 ###########
2074 # Targets #
2075 ###########
2077 foreach m : block_mods + softmmu_mods
2078   shared_module(m.name(),
2079                 name_prefix: '',
2080                 link_whole: m,
2081                 install: true,
2082                 install_dir: qemu_moddir)
2083 endforeach
2085 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
2086 common_ss.add(qom, qemuutil)
2088 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
2089 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
2091 common_all = common_ss.apply(config_all, strict: false)
2092 common_all = static_library('common',
2093                             build_by_default: false,
2094                             sources: common_all.sources() + genh,
2095                             dependencies: common_all.dependencies(),
2096                             name_suffix: 'fa')
2098 feature_to_c = find_program('scripts/feature_to_c.sh')
2100 emulators = {}
2101 foreach target : target_dirs
2102   config_target = config_target_mak[target]
2103   target_name = config_target['TARGET_NAME']
2104   arch = config_target['TARGET_BASE_ARCH']
2105   arch_srcs = [config_target_h[target]]
2106   arch_deps = []
2107   c_args = ['-DNEED_CPU_H',
2108             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2109             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2110   link_args = emulator_link_args
2112   config_target += config_host
2113   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2114   if targetos == 'linux'
2115     target_inc += include_directories('linux-headers', is_system: true)
2116   endif
2117   if target.endswith('-softmmu')
2118     qemu_target_name = 'qemu-system-' + target_name
2119     target_type='system'
2120     t = target_softmmu_arch[arch].apply(config_target, strict: false)
2121     arch_srcs += t.sources()
2122     arch_deps += t.dependencies()
2124     hw_dir = target_name == 'sparc64' ? 'sparc64' : arch
2125     hw = hw_arch[hw_dir].apply(config_target, strict: false)
2126     arch_srcs += hw.sources()
2127     arch_deps += hw.dependencies()
2129     arch_srcs += config_devices_h[target]
2130     link_args += ['@block.syms', '@qemu.syms']
2131   else
2132     abi = config_target['TARGET_ABI_DIR']
2133     target_type='user'
2134     qemu_target_name = 'qemu-' + target_name
2135     if 'CONFIG_LINUX_USER' in config_target
2136       base_dir = 'linux-user'
2137       target_inc += include_directories('linux-user/host/' / config_host['ARCH'])
2138     else
2139       base_dir = 'bsd-user'
2140       target_inc += include_directories('bsd-user/freebsd')
2141     endif
2142     target_inc += include_directories(
2143       base_dir,
2144       base_dir / abi,
2145     )
2146     if 'CONFIG_LINUX_USER' in config_target
2147       dir = base_dir / abi
2148       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
2149       if config_target.has_key('TARGET_SYSTBL_ABI')
2150         arch_srcs += \
2151           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
2152                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
2153       endif
2154     endif
2155   endif
2157   if 'TARGET_XML_FILES' in config_target
2158     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
2159                                 output: target + '-gdbstub-xml.c',
2160                                 input: files(config_target['TARGET_XML_FILES'].split()),
2161                                 command: [feature_to_c, '@INPUT@'],
2162                                 capture: true)
2163     arch_srcs += gdbstub_xml
2164   endif
2166   t = target_arch[arch].apply(config_target, strict: false)
2167   arch_srcs += t.sources()
2168   arch_deps += t.dependencies()
2170   target_common = common_ss.apply(config_target, strict: false)
2171   objects = common_all.extract_objects(target_common.sources())
2172   deps = target_common.dependencies()
2174   target_specific = specific_ss.apply(config_target, strict: false)
2175   arch_srcs += target_specific.sources()
2176   arch_deps += target_specific.dependencies()
2178   lib = static_library('qemu-' + target,
2179                  sources: arch_srcs + genh,
2180                  dependencies: arch_deps,
2181                  objects: objects,
2182                  include_directories: target_inc,
2183                  c_args: c_args,
2184                  build_by_default: false,
2185                  name_suffix: 'fa')
2187   if target.endswith('-softmmu')
2188     execs = [{
2189       'name': 'qemu-system-' + target_name,
2190       'gui': false,
2191       'sources': files('softmmu/main.c'),
2192       'dependencies': []
2193     }]
2194     if targetos == 'windows' and (sdl.found() or gtk.found())
2195       execs += [{
2196         'name': 'qemu-system-' + target_name + 'w',
2197         'gui': true,
2198         'sources': files('softmmu/main.c'),
2199         'dependencies': []
2200       }]
2201     endif
2202     if config_host.has_key('CONFIG_FUZZ')
2203       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
2204       execs += [{
2205         'name': 'qemu-fuzz-' + target_name,
2206         'gui': false,
2207         'sources': specific_fuzz.sources(),
2208         'dependencies': specific_fuzz.dependencies(),
2209       }]
2210     endif
2211   else
2212     execs = [{
2213       'name': 'qemu-' + target_name,
2214       'gui': false,
2215       'sources': [],
2216       'dependencies': []
2217     }]
2218   endif
2219   foreach exe: execs
2220     exe_name = exe['name']
2221     exe_sign = 'CONFIG_HVF' in config_target
2222     if exe_sign
2223       exe_name += '-unsigned'
2224     endif
2226     emulator = executable(exe_name, exe['sources'],
2227                install: not exe_sign,
2228                c_args: c_args,
2229                dependencies: arch_deps + deps + exe['dependencies'],
2230                objects: lib.extract_all_objects(recursive: true),
2231                link_language: link_language,
2232                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
2233                link_args: link_args,
2234                gui_app: exe['gui'])
2236     if exe_sign
2237       emulators += {exe['name'] : custom_target(exe['name'],
2238                    install: true,
2239                    install_dir: get_option('bindir'),
2240                    depends: emulator,
2241                    output: exe['name'],
2242                    command: [
2243                      meson.current_source_dir() / 'scripts/entitlement.sh',
2244                      meson.current_build_dir() / exe_name,
2245                      meson.current_build_dir() / exe['name'],
2246                      meson.current_source_dir() / 'accel/hvf/entitlements.plist'
2247                    ])
2248       }
2249     else
2250       emulators += {exe['name']: emulator}
2251     endif
2253     if 'CONFIG_TRACE_SYSTEMTAP' in config_host
2254       foreach stp: [
2255         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
2256         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
2257         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
2258         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
2259       ]
2260         custom_target(exe['name'] + stp['ext'],
2261                       input: trace_events_all,
2262                       output: exe['name'] + stp['ext'],
2263                       install: stp['install'],
2264                       install_dir: get_option('datadir') / 'systemtap/tapset',
2265                       command: [
2266                         tracetool, '--group=all', '--format=' + stp['fmt'],
2267                         '--binary=' + stp['bin'],
2268                         '--target-name=' + target_name,
2269                         '--target-type=' + target_type,
2270                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
2271                         '@INPUT@', '@OUTPUT@'
2272                       ],
2273                       depend_files: tracetool_depends)
2274       endforeach
2275     endif
2276   endforeach
2277 endforeach
2279 # Other build targets
2281 if 'CONFIG_PLUGIN' in config_host
2282   install_headers('include/qemu/qemu-plugin.h')
2283 endif
2285 if 'CONFIG_GUEST_AGENT' in config_host
2286   subdir('qga')
2287 elif get_option('guest_agent_msi').enabled()
2288   error('Guest agent MSI requested, but the guest agent is not being built')
2289 endif
2291 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
2292 # when we don't build tools or system
2293 if xkbcommon.found()
2294   # used for the update-keymaps target, so include rules even if !have_tools
2295   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
2296                            dependencies: [qemuutil, xkbcommon], install: have_tools)
2297 endif
2299 if have_tools
2300   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
2301              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
2302   qemu_io = executable('qemu-io', files('qemu-io.c'),
2303              dependencies: [block, qemuutil], install: true)
2304   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
2305                dependencies: [blockdev, qemuutil, gnutls], install: true)
2307   subdir('storage-daemon')
2308   subdir('contrib/rdmacm-mux')
2309   subdir('contrib/elf2dmp')
2311   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
2312              dependencies: qemuutil,
2313              install: true)
2315   if 'CONFIG_VHOST_USER' in config_host
2316     subdir('contrib/vhost-user-blk')
2317     subdir('contrib/vhost-user-gpu')
2318     subdir('contrib/vhost-user-input')
2319     subdir('contrib/vhost-user-scsi')
2320   endif
2322   if targetos == 'linux'
2323     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
2324                dependencies: [qemuutil, libcap_ng],
2325                install: true,
2326                install_dir: get_option('libexecdir'))
2328     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
2329                dependencies: [authz, crypto, io, qom, qemuutil,
2330                               libcap_ng, mpathpersist],
2331                install: true)
2332   endif
2334   if 'CONFIG_IVSHMEM' in config_host
2335     subdir('contrib/ivshmem-client')
2336     subdir('contrib/ivshmem-server')
2337   endif
2338 endif
2340 subdir('scripts')
2341 subdir('tools')
2342 subdir('pc-bios')
2343 subdir('docs')
2344 subdir('tests')
2345 if gtk.found()
2346   subdir('po')
2347 endif
2349 if host_machine.system() == 'windows'
2350   nsis_cmd = [
2351     find_program('scripts/nsis.py'),
2352     '@OUTPUT@',
2353     get_option('prefix'),
2354     meson.current_source_dir(),
2355     host_machine.cpu(),
2356     '--',
2357     '-DDISPLAYVERSION=' + meson.project_version(),
2358   ]
2359   if build_docs
2360     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
2361   endif
2362   if gtk.found()
2363     nsis_cmd += '-DCONFIG_GTK=y'
2364   endif
2366   nsis = custom_target('nsis',
2367                        output: 'qemu-setup-' + meson.project_version() + '.exe',
2368                        input: files('qemu.nsi'),
2369                        build_always_stale: true,
2370                        command: nsis_cmd + ['@INPUT@'])
2371   alias_target('installer', nsis)
2372 endif
2374 #########################
2375 # Configuration summary #
2376 #########################
2378 # Directories
2379 summary_info = {}
2380 summary_info += {'Install prefix':    get_option('prefix')}
2381 summary_info += {'BIOS directory':    qemu_datadir}
2382 summary_info += {'firmware path':     get_option('qemu_firmwarepath')}
2383 summary_info += {'binary directory':  get_option('bindir')}
2384 summary_info += {'library directory': get_option('libdir')}
2385 summary_info += {'module directory':  qemu_moddir}
2386 summary_info += {'libexec directory': get_option('libexecdir')}
2387 summary_info += {'include directory': get_option('includedir')}
2388 summary_info += {'config directory':  get_option('sysconfdir')}
2389 if targetos != 'windows'
2390   summary_info += {'local state directory': get_option('localstatedir')}
2391   summary_info += {'Manual directory':      get_option('mandir')}
2392 else
2393   summary_info += {'local state directory': 'queried at runtime'}
2394 endif
2395 summary_info += {'Doc directory':     get_option('docdir')}
2396 summary_info += {'Build directory':   meson.current_build_dir()}
2397 summary_info += {'Source path':       meson.current_source_dir()}
2398 summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
2399 summary(summary_info, bool_yn: true, section: 'Directories')
2401 # Host binaries
2402 summary_info = {}
2403 summary_info += {'git':               config_host['GIT']}
2404 summary_info += {'make':              config_host['MAKE']}
2405 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
2406 summary_info += {'sphinx-build':      sphinx_build.found()}
2407 if config_host.has_key('HAVE_GDB_BIN')
2408   summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
2409 endif
2410 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
2411 if targetos == 'windows' and config_host.has_key('CONFIG_GUEST_AGENT')
2412   summary_info += {'wixl':            wixl.found() ? wixl.full_path() : false}
2413 endif
2414 if slirp_opt != 'disabled'
2415   summary_info += {'smbd':            config_host['CONFIG_SMBD_COMMAND']}
2416 endif
2417 summary(summary_info, bool_yn: true, section: 'Host binaries')
2419 # Configurable features
2420 summary_info = {}
2421 summary_info += {'Documentation':     build_docs}
2422 summary_info += {'system-mode emulation': have_system}
2423 summary_info += {'user-mode emulation': have_user}
2424 summary_info += {'block layer':       have_block}
2425 summary_info += {'Install blobs':     get_option('install_blobs')}
2426 summary_info += {'module support':    config_host.has_key('CONFIG_MODULES')}
2427 if config_host.has_key('CONFIG_MODULES')
2428   summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
2429 endif
2430 summary_info += {'plugin support':    config_host.has_key('CONFIG_PLUGIN')}
2431 summary_info += {'fuzzing support':   config_host.has_key('CONFIG_FUZZ')}
2432 if have_system
2433   summary_info += {'Audio drivers':     config_host['CONFIG_AUDIO_DRIVERS']}
2434 endif
2435 summary_info += {'Trace backends':    config_host['TRACE_BACKENDS']}
2436 if config_host['TRACE_BACKENDS'].split().contains('simple')
2437   summary_info += {'Trace output file': config_host['CONFIG_TRACE_FILE'] + '-<pid>'}
2438 endif
2439 summary_info += {'QOM debugging':     config_host.has_key('CONFIG_QOM_CAST_DEBUG')}
2440 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
2441 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
2442 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
2443 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
2444 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
2445 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
2446 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
2447 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
2448 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
2449 summary_info += {'build guest agent': config_host.has_key('CONFIG_GUEST_AGENT')}
2450 summary(summary_info, bool_yn: true, section: 'Configurable features')
2452 # Compilation information
2453 summary_info = {}
2454 summary_info += {'host CPU':          cpu}
2455 summary_info += {'host endianness':   build_machine.endian()}
2456 summary_info += {'C compiler':        meson.get_compiler('c').cmd_array()[0]}
2457 summary_info += {'Host C compiler':   meson.get_compiler('c', native: true).cmd_array()[0]}
2458 if link_language == 'cpp'
2459   summary_info += {'C++ compiler':      meson.get_compiler('cpp').cmd_array()[0]}
2460 else
2461   summary_info += {'C++ compiler':      false}
2462 endif
2463 if targetos == 'darwin'
2464   summary_info += {'Objective-C compiler': meson.get_compiler('objc').cmd_array()[0]}
2465 endif
2466 if targetos == 'windows'
2467   if 'WIN_SDK' in config_host
2468     summary_info += {'Windows SDK':   config_host['WIN_SDK']}
2469   endif
2470 endif
2471 summary_info += {'ARFLAGS':           config_host['ARFLAGS']}
2472 summary_info += {'CFLAGS':            ' '.join(get_option('c_args')
2473                                                + ['-O' + get_option('optimization')]
2474                                                + (get_option('debug') ? ['-g'] : []))}
2475 if link_language == 'cpp'
2476   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args')
2477                                                + ['-O' + get_option('optimization')]
2478                                                + (get_option('debug') ? ['-g'] : []))}
2479 endif
2480 link_args = get_option(link_language + '_link_args')
2481 if link_args.length() > 0
2482   summary_info += {'LDFLAGS':         ' '.join(link_args)}
2483 endif
2484 summary_info += {'QEMU_CFLAGS':       config_host['QEMU_CFLAGS']}
2485 summary_info += {'QEMU_LDFLAGS':      config_host['QEMU_LDFLAGS']}
2486 summary_info += {'profiler':          config_host.has_key('CONFIG_PROFILER')}
2487 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
2488 summary_info += {'PIE':               get_option('b_pie')}
2489 summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
2490 summary_info += {'malloc trim support': has_malloc_trim}
2491 summary_info += {'membarrier':        config_host.has_key('CONFIG_MEMBARRIER')}
2492 summary_info += {'preadv support':    config_host_data.get('CONFIG_PREADV')}
2493 summary_info += {'fdatasync':         config_host.has_key('CONFIG_FDATASYNC')}
2494 summary_info += {'madvise':           config_host.has_key('CONFIG_MADVISE')}
2495 summary_info += {'posix_madvise':     config_host.has_key('CONFIG_POSIX_MADVISE')}
2496 summary_info += {'posix_memalign':    config_host.has_key('CONFIG_POSIX_MEMALIGN')}
2497 summary_info += {'debug stack usage': config_host.has_key('CONFIG_DEBUG_STACK_USAGE')}
2498 summary_info += {'mutex debugging':   config_host.has_key('CONFIG_DEBUG_MUTEX')}
2499 summary_info += {'memory allocator':  get_option('malloc')}
2500 summary_info += {'avx2 optimization': config_host.has_key('CONFIG_AVX2_OPT')}
2501 summary_info += {'avx512f optimization': config_host.has_key('CONFIG_AVX512F_OPT')}
2502 summary_info += {'gprof enabled':     config_host.has_key('CONFIG_GPROF')}
2503 summary_info += {'gcov':              get_option('b_coverage')}
2504 summary_info += {'thread sanitizer':  config_host.has_key('CONFIG_TSAN')}
2505 summary_info += {'CFI support':       get_option('cfi')}
2506 if get_option('cfi')
2507   summary_info += {'CFI debug support': get_option('cfi_debug')}
2508 endif
2509 summary_info += {'strip binaries':    get_option('strip')}
2510 summary_info += {'sparse':            sparse.found() ? sparse.full_path() : false}
2511 summary_info += {'mingw32 support':   targetos == 'windows'}
2512 summary(summary_info, bool_yn: true, section: 'Compilation')
2514 # Targets and accelerators
2515 summary_info = {}
2516 if have_system
2517   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
2518   summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
2519   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
2520   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
2521   summary_info += {'Xen support':       config_host.has_key('CONFIG_XEN_BACKEND')}
2522   if config_host.has_key('CONFIG_XEN_BACKEND')
2523     summary_info += {'xen ctrl version':  config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
2524   endif
2525 endif
2526 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
2527 if config_all.has_key('CONFIG_TCG')
2528   if get_option('tcg_interpreter')
2529     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, experimental and slow)'}
2530   else
2531     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
2532   endif
2533   summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
2534 endif
2535 summary_info += {'target list':       ' '.join(target_dirs)}
2536 if have_system
2537   summary_info += {'default devices':   get_option('default_devices')}
2538 endif
2539 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
2541 # Block layer
2542 summary_info = {}
2543 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
2544 summary_info += {'coroutine pool':    config_host['CONFIG_COROUTINE_POOL'] == '1'}
2545 if have_block
2546   summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
2547   summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
2548   summary_info += {'VirtFS support':    have_virtfs}
2549   summary_info += {'build virtiofs daemon': have_virtiofsd}
2550   summary_info += {'Live block migration': config_host.has_key('CONFIG_LIVE_BLOCK_MIGRATION')}
2551   summary_info += {'replication support': config_host.has_key('CONFIG_REPLICATION')}
2552   summary_info += {'bochs support':     config_host.has_key('CONFIG_BOCHS')}
2553   summary_info += {'cloop support':     config_host.has_key('CONFIG_CLOOP')}
2554   summary_info += {'dmg support':       config_host.has_key('CONFIG_DMG')}
2555   summary_info += {'qcow v1 support':   config_host.has_key('CONFIG_QCOW1')}
2556   summary_info += {'vdi support':       config_host.has_key('CONFIG_VDI')}
2557   summary_info += {'vvfat support':     config_host.has_key('CONFIG_VVFAT')}
2558   summary_info += {'qed support':       config_host.has_key('CONFIG_QED')}
2559   summary_info += {'parallels support': config_host.has_key('CONFIG_PARALLELS')}
2560   summary_info += {'sheepdog support':  config_host.has_key('CONFIG_SHEEPDOG')}
2561   summary_info += {'FUSE exports':      fuse.found()}
2562 endif
2563 summary(summary_info, bool_yn: true, section: 'Block layer support')
2565 # Crypto
2566 summary_info = {}
2567 summary_info += {'TLS priority':      config_host['CONFIG_TLS_PRIORITY']}
2568 summary_info += {'GNUTLS support':    config_host.has_key('CONFIG_GNUTLS')}
2569 # TODO: add back version
2570 summary_info += {'libgcrypt':         config_host.has_key('CONFIG_GCRYPT')}
2571 if config_host.has_key('CONFIG_GCRYPT')
2572    summary_info += {'  hmac':            config_host.has_key('CONFIG_GCRYPT_HMAC')}
2573    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
2574 endif
2575 # TODO: add back version
2576 summary_info += {'nettle':            config_host.has_key('CONFIG_NETTLE')}
2577 if config_host.has_key('CONFIG_NETTLE')
2578    summary_info += {'  XTS':             not config_host.has_key('CONFIG_QEMU_PRIVATE_XTS')}
2579 endif
2580 summary_info += {'crypto afalg':      config_host.has_key('CONFIG_AF_ALG')}
2581 summary_info += {'rng-none':          config_host.has_key('CONFIG_RNG_NONE')}
2582 summary_info += {'Linux keyring':     config_host.has_key('CONFIG_SECRET_KEYRING')}
2583 summary(summary_info, bool_yn: true, section: 'Crypto')
2585 # Libraries
2586 summary_info = {}
2587 if targetos == 'darwin'
2588   summary_info += {'Cocoa support':   cocoa.found()}
2589 endif
2590 # TODO: add back version
2591 summary_info += {'SDL support':       sdl.found()}
2592 summary_info += {'SDL image support': sdl_image.found()}
2593 # TODO: add back version
2594 summary_info += {'GTK support':       gtk.found()}
2595 summary_info += {'pixman':            pixman.found()}
2596 # TODO: add back version
2597 summary_info += {'VTE support':       config_host.has_key('CONFIG_VTE')}
2598 # TODO: add back version
2599 summary_info += {'slirp support':     slirp_opt == 'disabled' ? false : slirp_opt}
2600 summary_info += {'libtasn1':          config_host.has_key('CONFIG_TASN1')}
2601 summary_info += {'PAM':               config_host.has_key('CONFIG_AUTH_PAM')}
2602 summary_info += {'iconv support':     iconv.found()}
2603 summary_info += {'curses support':    curses.found()}
2604 # TODO: add back version
2605 summary_info += {'virgl support':     config_host.has_key('CONFIG_VIRGL')}
2606 summary_info += {'curl support':      curl.found()}
2607 summary_info += {'Multipath support': mpathpersist.found()}
2608 summary_info += {'VNC support':       vnc.found()}
2609 if vnc.found()
2610   summary_info += {'VNC SASL support':  sasl.found()}
2611   summary_info += {'VNC JPEG support':  jpeg.found()}
2612   summary_info += {'VNC PNG support':   png.found()}
2613 endif
2614 summary_info += {'brlapi support':    brlapi.found()}
2615 summary_info += {'vde support':       config_host.has_key('CONFIG_VDE')}
2616 summary_info += {'netmap support':    config_host.has_key('CONFIG_NETMAP')}
2617 summary_info += {'Linux AIO support': config_host.has_key('CONFIG_LINUX_AIO')}
2618 summary_info += {'Linux io_uring support': config_host.has_key('CONFIG_LINUX_IO_URING')}
2619 summary_info += {'ATTR/XATTR support': libattr.found()}
2620 summary_info += {'RDMA support':      config_host.has_key('CONFIG_RDMA')}
2621 summary_info += {'PVRDMA support':    config_host.has_key('CONFIG_PVRDMA')}
2622 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
2623 summary_info += {'libcap-ng support': libcap_ng.found()}
2624 # TODO: add back protocol and server version
2625 summary_info += {'spice support':     config_host.has_key('CONFIG_SPICE')}
2626 summary_info += {'rbd support':       rbd.found()}
2627 summary_info += {'xfsctl support':    config_host.has_key('CONFIG_XFS')}
2628 summary_info += {'smartcard support': config_host.has_key('CONFIG_SMARTCARD')}
2629 summary_info += {'U2F support':       u2f.found()}
2630 summary_info += {'libusb':            config_host.has_key('CONFIG_USB_LIBUSB')}
2631 summary_info += {'usb net redir':     config_host.has_key('CONFIG_USB_REDIR')}
2632 summary_info += {'OpenGL support':    config_host.has_key('CONFIG_OPENGL')}
2633 summary_info += {'OpenGL dmabufs':    config_host.has_key('CONFIG_OPENGL_DMABUF')}
2634 summary_info += {'libiscsi support':  libiscsi.found()}
2635 summary_info += {'libnfs support':    libnfs.found()}
2636 if targetos == 'windows'
2637   if config_host.has_key('CONFIG_GUEST_AGENT')
2638     summary_info += {'QGA VSS support':   config_host.has_key('CONFIG_QGA_VSS')}
2639     summary_info += {'QGA w32 disk info': config_host.has_key('CONFIG_QGA_NTDDSCSI')}
2640   endif
2641 endif
2642 summary_info += {'seccomp support':   seccomp.found()}
2643 summary_info += {'GlusterFS support': glusterfs.found()}
2644 summary_info += {'TPM support':       config_host.has_key('CONFIG_TPM')}
2645 summary_info += {'libssh support':    config_host.has_key('CONFIG_LIBSSH')}
2646 summary_info += {'lzo support':       lzo.found()}
2647 summary_info += {'snappy support':    snappy.found()}
2648 summary_info += {'bzip2 support':     libbzip2.found()}
2649 summary_info += {'lzfse support':     liblzfse.found()}
2650 summary_info += {'zstd support':      zstd.found()}
2651 summary_info += {'NUMA host support': config_host.has_key('CONFIG_NUMA')}
2652 summary_info += {'libxml2':           config_host.has_key('CONFIG_LIBXML2')}
2653 summary_info += {'capstone':          capstone_opt == 'disabled' ? false : capstone_opt}
2654 summary_info += {'libpmem support':   config_host.has_key('CONFIG_LIBPMEM')}
2655 summary_info += {'libdaxctl support': config_host.has_key('CONFIG_LIBDAXCTL')}
2656 summary_info += {'libudev':           libudev.found()}
2657 summary_info += {'FUSE lseek':        fuse_lseek.found()}
2658 summary_info += {'Multiprocess QEMU': config_host.has_key('CONFIG_MULTIPROCESS_ALLOWED')}
2659 summary(summary_info, bool_yn: true, section: 'Dependencies')
2661 if not supported_cpus.contains(cpu)
2662   message()
2663   warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
2664   message()
2665   message('CPU host architecture ' + cpu + ' support is not currently maintained.')
2666   message('The QEMU project intends to remove support for this host CPU in')
2667   message('a future release if nobody volunteers to maintain it and to')
2668   message('provide a build host for our continuous integration setup.')
2669   message('configure has succeeded and you can continue to build, but')
2670   message('if you care about QEMU on this platform you should contact')
2671   message('us upstream at qemu-devel@nongnu.org.')
2672 endif
2674 if not supported_oses.contains(targetos)
2675   message()
2676   warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
2677   message()
2678   message('Host OS ' + targetos + 'support is not currently maintained.')
2679   message('The QEMU project intends to remove support for this host OS in')
2680   message('a future release if nobody volunteers to maintain it and to')
2681   message('provide a build host for our continuous integration setup.')
2682   message('configure has succeeded and you can continue to build, but')
2683   message('if you care about QEMU on this platform you should contact')
2684   message('us upstream at qemu-devel@nongnu.org.')
2685 endif