]> git.proxmox.com Git - mirror_qemu.git/blob - meson.build
Merge remote-tracking branch 'remotes/kraxel/tags/seabios-20220307-pull-request'...
[mirror_qemu.git] / meson.build
1 project('qemu', ['c'], meson_version: '>=0.59.3',
2 default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
3 'b_staticpic=false', 'stdsplit=false'],
4 version: files('VERSION'))
5
6 add_test_setup('quick', exclude_suites: ['block', 'slow', 'thorough'], is_default: true)
7 add_test_setup('slow', exclude_suites: ['block', 'thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
8 add_test_setup('thorough', exclude_suites: ['block'], env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
9
10 not_found = dependency('', required: false)
11 keyval = import('keyval')
12 ss = import('sourceset')
13 fs = import('fs')
14
15 sh = find_program('sh')
16 cc = meson.get_compiler('c')
17 config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
18 enable_modules = 'CONFIG_MODULES' in config_host
19 enable_static = 'CONFIG_STATIC' in config_host
20
21 # Allow both shared and static libraries unless --enable-static
22 static_kwargs = enable_static ? {'static': true} : {}
23
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'
30
31 if get_option('qemu_suffix').startswith('/')
32 error('qemu_suffix cannot start with a /')
33 endif
34
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')
39
40 qemu_desktopdir = get_option('datadir') / 'applications'
41 qemu_icondir = get_option('datadir') / 'icons'
42
43 config_host_data = configuration_data()
44 genh = []
45 qapi_trace_events = []
46
47 bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']
48 supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
49 supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv', 'x86', 'x86_64',
50 'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc', 'sparc64']
51
52 cpu = host_machine.cpu_family()
53
54 # Unify riscv* to a single family.
55 if cpu in ['riscv32', 'riscv64']
56 cpu = 'riscv'
57 endif
58
59 targetos = host_machine.system()
60
61 target_dirs = config_host['TARGET_DIRS'].split()
62 have_linux_user = false
63 have_bsd_user = false
64 have_system = false
65 foreach target : target_dirs
66 have_linux_user = have_linux_user or target.endswith('linux-user')
67 have_bsd_user = have_bsd_user or target.endswith('bsd-user')
68 have_system = have_system or target.endswith('-softmmu')
69 endforeach
70 have_user = have_linux_user or have_bsd_user
71 have_tools = get_option('tools') \
72 .disable_auto_if(not have_system) \
73 .allowed()
74 have_ga = get_option('guest_agent') \
75 .disable_auto_if(not have_system and not have_tools) \
76 .require(targetos in ['sunos', 'linux', 'windows'],
77 error_message: 'unsupported OS for QEMU guest agent') \
78 .allowed()
79 have_block = have_system or have_tools
80
81 python = import('python').find_installation()
82
83 if cpu not in supported_cpus
84 host_arch = 'unknown'
85 elif cpu == 'x86'
86 host_arch = 'i386'
87 elif cpu == 'mips64'
88 host_arch = 'mips'
89 else
90 host_arch = cpu
91 endif
92
93 if cpu in ['x86', 'x86_64']
94 kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
95 elif cpu == 'aarch64'
96 kvm_targets = ['aarch64-softmmu']
97 elif cpu == 's390x'
98 kvm_targets = ['s390x-softmmu']
99 elif cpu in ['ppc', 'ppc64']
100 kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
101 elif cpu in ['mips', 'mips64']
102 kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
103 elif cpu in ['riscv']
104 kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu']
105 else
106 kvm_targets = []
107 endif
108
109 kvm_targets_c = '""'
110 if get_option('kvm').allowed() and targetos == 'linux'
111 kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
112 endif
113 config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
114
115 accelerator_targets = { 'CONFIG_KVM': kvm_targets }
116
117 if cpu in ['aarch64']
118 accelerator_targets += {
119 'CONFIG_HVF': ['aarch64-softmmu']
120 }
121 endif
122
123 if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
124 # i386 emulator provides xenpv machine type for multiple architectures
125 accelerator_targets += {
126 'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
127 }
128 endif
129 if cpu in ['x86', 'x86_64']
130 accelerator_targets += {
131 'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
132 'CONFIG_HVF': ['x86_64-softmmu'],
133 'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
134 'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
135 }
136 endif
137
138 modular_tcg = []
139 # Darwin does not support references to thread-local variables in modules
140 if targetos != 'darwin'
141 modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
142 endif
143
144 edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
145 unpack_edk2_blobs = false
146 foreach target : edk2_targets
147 if target in target_dirs
148 bzip2 = find_program('bzip2', required: get_option('install_blobs'))
149 unpack_edk2_blobs = bzip2.found()
150 break
151 endif
152 endforeach
153
154 dtrace = not_found
155 stap = not_found
156 if 'dtrace' in get_option('trace_backends')
157 dtrace = find_program('dtrace', required: true)
158 stap = find_program('stap', required: false)
159 if stap.found()
160 # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
161 # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
162 # instead. QEMU --enable-modules depends on this because the SystemTap
163 # semaphores are linked into the main binary and not the module's shared
164 # object.
165 add_global_arguments('-DSTAP_SDT_V2',
166 native: false, language: ['c', 'cpp', 'objc'])
167 endif
168 endif
169
170 ##################
171 # Compiler flags #
172 ##################
173
174 qemu_cflags = config_host['QEMU_CFLAGS'].split()
175 qemu_cxxflags = config_host['QEMU_CXXFLAGS'].split()
176 qemu_ldflags = config_host['QEMU_LDFLAGS'].split()
177
178 if get_option('gprof')
179 qemu_cflags += ['-p']
180 qemu_cxxflags += ['-p']
181 qemu_ldflags += ['-p']
182 endif
183
184 # Specify linker-script with add_project_link_arguments so that it is not placed
185 # within a linker --start-group/--end-group pair
186 if get_option('fuzzing')
187 add_project_link_arguments(['-Wl,-T,',
188 (meson.current_source_dir() / 'tests/qtest/fuzz/fork_fuzz.ld')],
189 native: false, language: ['c', 'cpp', 'objc'])
190
191 # Specify a filter to only instrument code that is directly related to
192 # virtual-devices.
193 configure_file(output: 'instrumentation-filter',
194 input: 'scripts/oss-fuzz/instrumentation-filter-template',
195 copy: true)
196 add_global_arguments(
197 cc.get_supported_arguments('-fsanitize-coverage-allowlist=instrumentation-filter'),
198 native: false, language: ['c', 'cpp', 'objc'])
199
200 if get_option('fuzzing_engine') == ''
201 # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
202 # compiled code. To build non-fuzzer binaries with --enable-fuzzing, link
203 # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
204 # unable to bind the fuzzer-related callbacks added by instrumentation.
205 add_global_arguments('-fsanitize=fuzzer-no-link',
206 native: false, language: ['c', 'cpp', 'objc'])
207 add_global_link_arguments('-fsanitize=fuzzer-no-link',
208 native: false, language: ['c', 'cpp', 'objc'])
209 # For the actual fuzzer binaries, we need to link against the libfuzzer
210 # library. They need to be configurable, to support OSS-Fuzz
211 fuzz_exe_ldflags = ['-fsanitize=fuzzer']
212 else
213 # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
214 # the needed CFLAGS have already been provided
215 fuzz_exe_ldflags = get_option('fuzzing_engine').split()
216 endif
217 endif
218
219 add_global_arguments(qemu_cflags, native: false, language: ['c', 'objc'])
220 add_global_arguments(qemu_cxxflags, native: false, language: ['cpp'])
221 add_global_link_arguments(qemu_ldflags, native: false, language: ['c', 'cpp', 'objc'])
222
223 if targetos == 'linux'
224 add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
225 '-isystem', 'linux-headers',
226 language: ['c', 'cpp'])
227 endif
228
229 add_project_arguments('-iquote', '.',
230 '-iquote', meson.current_source_dir(),
231 '-iquote', meson.current_source_dir() / 'include',
232 '-iquote', meson.current_source_dir() / 'disas/libvixl',
233 language: ['c', 'cpp', 'objc'])
234
235 link_language = meson.get_external_property('link_language', 'cpp')
236 if link_language == 'cpp'
237 add_languages('cpp', required: true, native: false)
238 cxx = meson.get_compiler('cpp')
239 linker = cxx
240 else
241 linker = cc
242 endif
243 if host_machine.system() == 'darwin'
244 add_languages('objc', required: false, native: false)
245 endif
246
247 sparse = find_program('cgcc', required: get_option('sparse'))
248 if sparse.found()
249 run_target('sparse',
250 command: [find_program('scripts/check_sparse.py'),
251 'compile_commands.json', sparse.full_path(), '-Wbitwise',
252 '-Wno-transparent-union', '-Wno-old-initializer',
253 '-Wno-non-pointer-null'])
254 endif
255
256 ###########################################
257 # Target-specific checks and dependencies #
258 ###########################################
259
260 # Fuzzing
261 if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
262 not cc.links('''
263 #include <stdint.h>
264 #include <sys/types.h>
265 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
266 int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
267 ''',
268 args: ['-Werror', '-fsanitize=fuzzer'])
269 error('Your compiler does not support -fsanitize=fuzzer')
270 endif
271
272 # Tracing backends
273 if 'ftrace' in get_option('trace_backends') and targetos != 'linux'
274 error('ftrace is supported only on Linux')
275 endif
276 if 'syslog' in get_option('trace_backends') and not cc.compiles('''
277 #include <syslog.h>
278 int main(void) {
279 openlog("qemu", LOG_PID, LOG_DAEMON);
280 syslog(LOG_INFO, "configure");
281 return 0;
282 }''')
283 error('syslog is not supported on this system')
284 endif
285
286 # Miscellaneous Linux-only features
287 get_option('mpath') \
288 .require(targetos == 'linux', error_message: 'Multipath is supported only on Linux')
289
290 multiprocess_allowed = get_option('multiprocess') \
291 .require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
292 .allowed()
293
294 have_tpm = get_option('tpm') \
295 .require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
296 .allowed()
297
298 # Target-specific libraries and flags
299 libm = cc.find_library('m', required: false)
300 threads = dependency('threads')
301 util = cc.find_library('util', required: false)
302 winmm = []
303 socket = []
304 version_res = []
305 coref = []
306 iokit = []
307 emulator_link_args = []
308 nvmm =not_found
309 hvf = not_found
310 midl = not_found
311 widl = not_found
312 host_dsosuf = '.so'
313 if targetos == 'windows'
314 midl = find_program('midl', required: false)
315 widl = find_program('widl', required: false)
316 socket = cc.find_library('ws2_32')
317 winmm = cc.find_library('winmm')
318
319 win = import('windows')
320 version_res = win.compile_resources('version.rc',
321 depend_files: files('pc-bios/qemu-nsis.ico'),
322 include_directories: include_directories('.'))
323 host_dsosuf = '.dll'
324 elif targetos == 'darwin'
325 coref = dependency('appleframeworks', modules: 'CoreFoundation')
326 iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
327 host_dsosuf = '.dylib'
328 elif targetos == 'sunos'
329 socket = [cc.find_library('socket'),
330 cc.find_library('nsl'),
331 cc.find_library('resolv')]
332 elif targetos == 'haiku'
333 socket = [cc.find_library('posix_error_mapper'),
334 cc.find_library('network'),
335 cc.find_library('bsd')]
336 elif targetos == 'openbsd'
337 if get_option('tcg').allowed() and target_dirs.length() > 0
338 # Disable OpenBSD W^X if available
339 emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
340 endif
341 endif
342
343 # Target-specific configuration of accelerators
344 accelerators = []
345 if get_option('kvm').allowed() and targetos == 'linux'
346 accelerators += 'CONFIG_KVM'
347 endif
348 if get_option('xen').allowed() and 'CONFIG_XEN_BACKEND' in config_host
349 accelerators += 'CONFIG_XEN'
350 have_xen_pci_passthrough = get_option('xen_pci_passthrough').allowed() and targetos == 'linux'
351 else
352 have_xen_pci_passthrough = false
353 endif
354 if get_option('whpx').allowed() and targetos == 'windows'
355 if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
356 error('WHPX requires 64-bit host')
357 elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
358 cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
359 accelerators += 'CONFIG_WHPX'
360 endif
361 endif
362 if get_option('hvf').allowed()
363 hvf = dependency('appleframeworks', modules: 'Hypervisor',
364 required: get_option('hvf'))
365 if hvf.found()
366 accelerators += 'CONFIG_HVF'
367 endif
368 endif
369 if get_option('hax').allowed()
370 if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
371 accelerators += 'CONFIG_HAX'
372 endif
373 endif
374 if targetos == 'netbsd'
375 nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
376 if nvmm.found()
377 accelerators += 'CONFIG_NVMM'
378 endif
379 endif
380
381 tcg_arch = host_arch
382 if get_option('tcg').allowed()
383 if host_arch == 'unknown'
384 if get_option('tcg_interpreter')
385 warning('Unsupported CPU @0@, will use TCG with TCI (slow)'.format(cpu))
386 else
387 error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
388 endif
389 elif get_option('tcg_interpreter')
390 warning('Use of the TCG interpreter is not recommended on this host')
391 warning('architecture. There is a native TCG execution backend available')
392 warning('which provides substantially better performance and reliability.')
393 warning('It is strongly recommended to remove the --enable-tcg-interpreter')
394 warning('configuration option on this architecture to use the native')
395 warning('backend.')
396 endif
397 if get_option('tcg_interpreter')
398 tcg_arch = 'tci'
399 elif host_arch == 'sparc64'
400 tcg_arch = 'sparc'
401 elif host_arch == 'x86_64'
402 tcg_arch = 'i386'
403 elif host_arch == 'ppc64'
404 tcg_arch = 'ppc'
405 endif
406 add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
407 language: ['c', 'cpp', 'objc'])
408
409 accelerators += 'CONFIG_TCG'
410 config_host += { 'CONFIG_TCG': 'y' }
411 endif
412
413 if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
414 error('KVM not available on this platform')
415 endif
416 if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
417 error('HVF not available on this platform')
418 endif
419 if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
420 error('NVMM not available on this platform')
421 endif
422 if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
423 error('WHPX not available on this platform')
424 endif
425 if not have_xen_pci_passthrough and get_option('xen_pci_passthrough').enabled()
426 if 'CONFIG_XEN' in accelerators
427 error('Xen PCI passthrough not available on this platform')
428 else
429 error('Xen PCI passthrough requested but Xen not enabled')
430 endif
431 endif
432
433 ################
434 # Dependencies #
435 ################
436
437 # The path to glib.h is added to all compilation commands. This was
438 # grandfathered in from the QEMU Makefiles.
439 add_project_arguments(config_host['GLIB_CFLAGS'].split(),
440 native: false, language: ['c', 'cpp', 'objc'])
441 glib = declare_dependency(compile_args: config_host['GLIB_CFLAGS'].split(),
442 link_args: config_host['GLIB_LIBS'].split(),
443 version: config_host['GLIB_VERSION'])
444 # override glib dep with the configure results (for subprojects)
445 meson.override_dependency('glib-2.0', glib)
446
447 gio = not_found
448 if 'CONFIG_GIO' in config_host
449 gio = declare_dependency(compile_args: config_host['GIO_CFLAGS'].split(),
450 link_args: config_host['GIO_LIBS'].split(),
451 version: config_host['GLIB_VERSION'])
452 endif
453 lttng = not_found
454 if 'ust' in get_option('trace_backends')
455 lttng = dependency('lttng-ust', required: true, method: 'pkg-config',
456 kwargs: static_kwargs)
457 endif
458 pixman = not_found
459 if have_system or have_tools
460 pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
461 method: 'pkg-config', kwargs: static_kwargs)
462 endif
463 zlib = dependency('zlib', required: true, kwargs: static_kwargs)
464
465 libaio = not_found
466 if not get_option('linux_aio').auto() or have_block
467 libaio = cc.find_library('aio', has_headers: ['libaio.h'],
468 required: get_option('linux_aio'),
469 kwargs: static_kwargs)
470 endif
471 linux_io_uring = not_found
472 if not get_option('linux_io_uring').auto() or have_block
473 linux_io_uring = dependency('liburing', version: '>=0.3',
474 required: get_option('linux_io_uring'),
475 method: 'pkg-config', kwargs: static_kwargs)
476 endif
477 libnfs = not_found
478 if not get_option('libnfs').auto() or have_block
479 libnfs = dependency('libnfs', version: '>=1.9.3',
480 required: get_option('libnfs'),
481 method: 'pkg-config', kwargs: static_kwargs)
482 endif
483
484 libattr_test = '''
485 #include <stddef.h>
486 #include <sys/types.h>
487 #ifdef CONFIG_LIBATTR
488 #include <attr/xattr.h>
489 #else
490 #include <sys/xattr.h>
491 #endif
492 int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
493
494 libattr = not_found
495 have_old_libattr = false
496 if get_option('attr').allowed()
497 if cc.links(libattr_test)
498 libattr = declare_dependency()
499 else
500 libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
501 required: get_option('attr'),
502 kwargs: static_kwargs)
503 if libattr.found() and not \
504 cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
505 libattr = not_found
506 if get_option('attr').enabled()
507 error('could not link libattr')
508 else
509 warning('could not link libattr, disabling')
510 endif
511 else
512 have_old_libattr = libattr.found()
513 endif
514 endif
515 endif
516
517 cocoa = dependency('appleframeworks', modules: 'Cocoa', required: get_option('cocoa'))
518 if cocoa.found() and get_option('sdl').enabled()
519 error('Cocoa and SDL cannot be enabled at the same time')
520 endif
521 if cocoa.found() and get_option('gtk').enabled()
522 error('Cocoa and GTK+ cannot be enabled at the same time')
523 endif
524
525 seccomp = not_found
526 if not get_option('seccomp').auto() or have_system or have_tools
527 seccomp = dependency('libseccomp', version: '>=2.3.0',
528 required: get_option('seccomp'),
529 method: 'pkg-config', kwargs: static_kwargs)
530 endif
531
532 libcap_ng = not_found
533 if not get_option('cap_ng').auto() or have_system or have_tools
534 libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
535 required: get_option('cap_ng'),
536 kwargs: static_kwargs)
537 endif
538 if libcap_ng.found() and not cc.links('''
539 #include <cap-ng.h>
540 int main(void)
541 {
542 capng_capability_to_name(CAPNG_EFFECTIVE);
543 return 0;
544 }''', dependencies: libcap_ng)
545 libcap_ng = not_found
546 if get_option('cap_ng').enabled()
547 error('could not link libcap-ng')
548 else
549 warning('could not link libcap-ng, disabling')
550 endif
551 endif
552
553 if get_option('xkbcommon').auto() and not have_system and not have_tools
554 xkbcommon = not_found
555 else
556 xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
557 method: 'pkg-config', kwargs: static_kwargs)
558 endif
559
560 vde = not_found
561 if not get_option('vde').auto() or have_system or have_tools
562 vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
563 required: get_option('vde'),
564 kwargs: static_kwargs)
565 endif
566 if vde.found() and not cc.links('''
567 #include <libvdeplug.h>
568 int main(void)
569 {
570 struct vde_open_args a = {0, 0, 0};
571 char s[] = "";
572 vde_open(s, s, &a);
573 return 0;
574 }''', dependencies: vde)
575 vde = not_found
576 if get_option('cap_ng').enabled()
577 error('could not link libvdeplug')
578 else
579 warning('could not link libvdeplug, disabling')
580 endif
581 endif
582
583 pulse = not_found
584 if not get_option('pa').auto() or (targetos == 'linux' and have_system)
585 pulse = dependency('libpulse', required: get_option('pa'),
586 method: 'pkg-config', kwargs: static_kwargs)
587 endif
588 alsa = not_found
589 if not get_option('alsa').auto() or (targetos == 'linux' and have_system)
590 alsa = dependency('alsa', required: get_option('alsa'),
591 method: 'pkg-config', kwargs: static_kwargs)
592 endif
593 jack = not_found
594 if not get_option('jack').auto() or have_system
595 jack = dependency('jack', required: get_option('jack'),
596 method: 'pkg-config', kwargs: static_kwargs)
597 endif
598
599 spice_protocol = not_found
600 if not get_option('spice_protocol').auto() or have_system
601 spice_protocol = dependency('spice-protocol', version: '>=0.12.3',
602 required: get_option('spice_protocol'),
603 method: 'pkg-config', kwargs: static_kwargs)
604 endif
605 spice = not_found
606 if not get_option('spice').auto() or have_system
607 spice = dependency('spice-server', version: '>=0.12.5',
608 required: get_option('spice'),
609 method: 'pkg-config', kwargs: static_kwargs)
610 endif
611 spice_headers = spice.partial_dependency(compile_args: true, includes: true)
612
613 rt = cc.find_library('rt', required: false)
614
615 libiscsi = not_found
616 if not get_option('libiscsi').auto() or have_block
617 libiscsi = dependency('libiscsi', version: '>=1.9.0',
618 required: get_option('libiscsi'),
619 method: 'pkg-config', kwargs: static_kwargs)
620 endif
621 zstd = not_found
622 if not get_option('zstd').auto() or have_block
623 zstd = dependency('libzstd', version: '>=1.4.0',
624 required: get_option('zstd'),
625 method: 'pkg-config', kwargs: static_kwargs)
626 endif
627 virgl = not_found
628
629 have_vhost_user_gpu = have_tools and targetos == 'linux' and pixman.found()
630 if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu
631 virgl = dependency('virglrenderer',
632 method: 'pkg-config',
633 required: get_option('virglrenderer'),
634 kwargs: static_kwargs)
635 endif
636 curl = not_found
637 if not get_option('curl').auto() or have_block
638 curl = dependency('libcurl', version: '>=7.29.0',
639 method: 'pkg-config',
640 required: get_option('curl'),
641 kwargs: static_kwargs)
642 endif
643 libudev = not_found
644 if targetos == 'linux' and (have_system or have_tools)
645 libudev = dependency('libudev',
646 method: 'pkg-config',
647 required: get_option('libudev'),
648 kwargs: static_kwargs)
649 endif
650
651 mpathlibs = [libudev]
652 mpathpersist = not_found
653 mpathpersist_new_api = false
654 if targetos == 'linux' and have_tools and get_option('mpath').allowed()
655 mpath_test_source_new = '''
656 #include <libudev.h>
657 #include <mpath_persist.h>
658 unsigned mpath_mx_alloc_len = 1024;
659 int logsink;
660 static struct config *multipath_conf;
661 extern struct udev *udev;
662 extern struct config *get_multipath_config(void);
663 extern void put_multipath_config(struct config *conf);
664 struct udev *udev;
665 struct config *get_multipath_config(void) { return multipath_conf; }
666 void put_multipath_config(struct config *conf) { }
667 int main(void) {
668 udev = udev_new();
669 multipath_conf = mpath_lib_init();
670 return 0;
671 }'''
672 mpath_test_source_old = '''
673 #include <libudev.h>
674 #include <mpath_persist.h>
675 unsigned mpath_mx_alloc_len = 1024;
676 int logsink;
677 int main(void) {
678 struct udev *udev = udev_new();
679 mpath_lib_init(udev);
680 return 0;
681 }'''
682 libmpathpersist = cc.find_library('mpathpersist',
683 required: get_option('mpath'),
684 kwargs: static_kwargs)
685 if libmpathpersist.found()
686 mpathlibs += libmpathpersist
687 if enable_static
688 mpathlibs += cc.find_library('devmapper',
689 required: get_option('mpath'),
690 kwargs: static_kwargs)
691 endif
692 mpathlibs += cc.find_library('multipath',
693 required: get_option('mpath'),
694 kwargs: static_kwargs)
695 foreach lib: mpathlibs
696 if not lib.found()
697 mpathlibs = []
698 break
699 endif
700 endforeach
701 if mpathlibs.length() == 0
702 msg = 'Dependencies missing for libmpathpersist'
703 elif cc.links(mpath_test_source_new, dependencies: mpathlibs)
704 mpathpersist = declare_dependency(dependencies: mpathlibs)
705 mpathpersist_new_api = true
706 elif cc.links(mpath_test_source_old, dependencies: mpathlibs)
707 mpathpersist = declare_dependency(dependencies: mpathlibs)
708 else
709 msg = 'Cannot detect libmpathpersist API'
710 endif
711 if not mpathpersist.found()
712 if get_option('mpath').enabled()
713 error(msg)
714 else
715 warning(msg + ', disabling')
716 endif
717 endif
718 endif
719 endif
720
721 iconv = not_found
722 curses = not_found
723 if have_system and get_option('curses').allowed()
724 curses_test = '''
725 #if defined(__APPLE__) || defined(__OpenBSD__)
726 #define _XOPEN_SOURCE_EXTENDED 1
727 #endif
728 #include <locale.h>
729 #include <curses.h>
730 #include <wchar.h>
731 int main(void) {
732 wchar_t wch = L'w';
733 setlocale(LC_ALL, "");
734 resize_term(0, 0);
735 addwstr(L"wide chars\n");
736 addnwstr(&wch, 1);
737 add_wch(WACS_DEGREE);
738 return 0;
739 }'''
740
741 curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
742 foreach curses_dep : curses_dep_list
743 if not curses.found()
744 curses = dependency(curses_dep,
745 required: false,
746 method: 'pkg-config',
747 kwargs: static_kwargs)
748 endif
749 endforeach
750 msg = get_option('curses').enabled() ? 'curses library not found' : ''
751 curses_compile_args = ['-DNCURSES_WIDECHAR=1']
752 if curses.found()
753 if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
754 curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses])
755 else
756 msg = 'curses package not usable'
757 curses = not_found
758 endif
759 endif
760 if not curses.found()
761 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
762 if targetos != 'windows' and not has_curses_h
763 message('Trying with /usr/include/ncursesw')
764 curses_compile_args += ['-I/usr/include/ncursesw']
765 has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
766 endif
767 if has_curses_h
768 curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
769 foreach curses_libname : curses_libname_list
770 libcurses = cc.find_library(curses_libname,
771 required: false,
772 kwargs: static_kwargs)
773 if libcurses.found()
774 if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
775 curses = declare_dependency(compile_args: curses_compile_args,
776 dependencies: [libcurses])
777 break
778 else
779 msg = 'curses library not usable'
780 endif
781 endif
782 endforeach
783 endif
784 endif
785 if get_option('iconv').allowed()
786 foreach link_args : [ ['-liconv'], [] ]
787 # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
788 # We need to use libiconv if available because mixing libiconv's headers with
789 # the system libc does not work.
790 # However, without adding glib to the dependencies -L/usr/local/lib will not be
791 # included in the command line and libiconv will not be found.
792 if cc.links('''
793 #include <iconv.h>
794 int main(void) {
795 iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
796 return conv != (iconv_t) -1;
797 }''', args: config_host['GLIB_CFLAGS'].split() + config_host['GLIB_LIBS'].split() + link_args)
798 iconv = declare_dependency(link_args: link_args, dependencies: glib)
799 break
800 endif
801 endforeach
802 endif
803 if curses.found() and not iconv.found()
804 if get_option('iconv').enabled()
805 error('iconv not available')
806 endif
807 msg = 'iconv required for curses UI but not available'
808 curses = not_found
809 endif
810 if not curses.found() and msg != ''
811 if get_option('curses').enabled()
812 error(msg)
813 else
814 warning(msg + ', disabling')
815 endif
816 endif
817 endif
818
819 brlapi = not_found
820 if not get_option('brlapi').auto() or have_system
821 brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
822 required: get_option('brlapi'),
823 kwargs: static_kwargs)
824 if brlapi.found() and not cc.links('''
825 #include <brlapi.h>
826 #include <stddef.h>
827 int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
828 brlapi = not_found
829 if get_option('brlapi').enabled()
830 error('could not link brlapi')
831 else
832 warning('could not link brlapi, disabling')
833 endif
834 endif
835 endif
836
837 sdl = not_found
838 if not get_option('sdl').auto() or (have_system and not cocoa.found())
839 sdl = dependency('sdl2', required: get_option('sdl'), kwargs: static_kwargs)
840 sdl_image = not_found
841 endif
842 if sdl.found()
843 # work around 2.0.8 bug
844 sdl = declare_dependency(compile_args: '-Wno-undef',
845 dependencies: sdl)
846 sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
847 method: 'pkg-config', kwargs: static_kwargs)
848 else
849 if get_option('sdl_image').enabled()
850 error('sdl-image required, but SDL was @0@'.format(
851 get_option('sdl').disabled() ? 'disabled' : 'not found'))
852 endif
853 sdl_image = not_found
854 endif
855
856 rbd = not_found
857 if not get_option('rbd').auto() or have_block
858 librados = cc.find_library('rados', required: get_option('rbd'),
859 kwargs: static_kwargs)
860 librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
861 required: get_option('rbd'),
862 kwargs: static_kwargs)
863 if librados.found() and librbd.found()
864 if cc.links('''
865 #include <stdio.h>
866 #include <rbd/librbd.h>
867 int main(void) {
868 rados_t cluster;
869 rados_create(&cluster, NULL);
870 #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
871 #error
872 #endif
873 return 0;
874 }''', dependencies: [librbd, librados])
875 rbd = declare_dependency(dependencies: [librbd, librados])
876 elif get_option('rbd').enabled()
877 error('librbd >= 1.12.0 required')
878 else
879 warning('librbd >= 1.12.0 not found, disabling')
880 endif
881 endif
882 endif
883
884 glusterfs = not_found
885 glusterfs_ftruncate_has_stat = false
886 glusterfs_iocb_has_stat = false
887 if not get_option('glusterfs').auto() or have_block
888 glusterfs = dependency('glusterfs-api', version: '>=3',
889 required: get_option('glusterfs'),
890 method: 'pkg-config', kwargs: static_kwargs)
891 if glusterfs.found()
892 glusterfs_ftruncate_has_stat = cc.links('''
893 #include <glusterfs/api/glfs.h>
894
895 int
896 main(void)
897 {
898 /* new glfs_ftruncate() passes two additional args */
899 return glfs_ftruncate(NULL, 0, NULL, NULL);
900 }
901 ''', dependencies: glusterfs)
902 glusterfs_iocb_has_stat = cc.links('''
903 #include <glusterfs/api/glfs.h>
904
905 /* new glfs_io_cbk() passes two additional glfs_stat structs */
906 static void
907 glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
908 {}
909
910 int
911 main(void)
912 {
913 glfs_io_cbk iocb = &glusterfs_iocb;
914 iocb(NULL, 0 , NULL, NULL, NULL);
915 return 0;
916 }
917 ''', dependencies: glusterfs)
918 endif
919 endif
920
921 libssh = not_found
922 if not get_option('libssh').auto() or have_block
923 libssh = dependency('libssh', version: '>=0.8.7',
924 method: 'pkg-config',
925 required: get_option('libssh'),
926 kwargs: static_kwargs)
927 endif
928
929 libbzip2 = not_found
930 if not get_option('bzip2').auto() or have_block
931 libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
932 required: get_option('bzip2'),
933 kwargs: static_kwargs)
934 if libbzip2.found() and not cc.links('''
935 #include <bzlib.h>
936 int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
937 libbzip2 = not_found
938 if get_option('bzip2').enabled()
939 error('could not link libbzip2')
940 else
941 warning('could not link libbzip2, disabling')
942 endif
943 endif
944 endif
945
946 liblzfse = not_found
947 if not get_option('lzfse').auto() or have_block
948 liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
949 required: get_option('lzfse'),
950 kwargs: static_kwargs)
951 endif
952 if liblzfse.found() and not cc.links('''
953 #include <lzfse.h>
954 int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
955 liblzfse = not_found
956 if get_option('lzfse').enabled()
957 error('could not link liblzfse')
958 else
959 warning('could not link liblzfse, disabling')
960 endif
961 endif
962
963 oss = not_found
964 if get_option('oss').allowed() and have_system
965 if not cc.has_header('sys/soundcard.h')
966 # not found
967 elif targetos == 'netbsd'
968 oss = cc.find_library('ossaudio', required: get_option('oss'),
969 kwargs: static_kwargs)
970 else
971 oss = declare_dependency()
972 endif
973
974 if not oss.found()
975 if get_option('oss').enabled()
976 error('OSS not found')
977 endif
978 endif
979 endif
980 dsound = not_found
981 if not get_option('dsound').auto() or (targetos == 'windows' and have_system)
982 if cc.has_header('dsound.h')
983 dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
984 endif
985
986 if not dsound.found()
987 if get_option('dsound').enabled()
988 error('DirectSound not found')
989 endif
990 endif
991 endif
992
993 coreaudio = not_found
994 if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system)
995 coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
996 required: get_option('coreaudio'))
997 endif
998
999 opengl = not_found
1000 if 'CONFIG_OPENGL' in config_host
1001 opengl = declare_dependency(compile_args: config_host['OPENGL_CFLAGS'].split(),
1002 link_args: config_host['OPENGL_LIBS'].split())
1003 endif
1004 gbm = not_found
1005 if (have_system or have_tools) and (virgl.found() or opengl.found())
1006 gbm = dependency('gbm', method: 'pkg-config', required: false,
1007 kwargs: static_kwargs)
1008 endif
1009 have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and gbm.found()
1010
1011 gnutls = not_found
1012 gnutls_crypto = not_found
1013 if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
1014 # For general TLS support our min gnutls matches
1015 # that implied by our platform support matrix
1016 #
1017 # For the crypto backends, we look for a newer
1018 # gnutls:
1019 #
1020 # Version 3.6.8 is needed to get XTS
1021 # Version 3.6.13 is needed to get PBKDF
1022 # Version 3.6.14 is needed to get HW accelerated XTS
1023 #
1024 # If newer enough gnutls isn't available, we can
1025 # still use a different crypto backend to satisfy
1026 # the platform support requirements
1027 gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
1028 method: 'pkg-config',
1029 required: false,
1030 kwargs: static_kwargs)
1031 if gnutls_crypto.found()
1032 gnutls = gnutls_crypto
1033 else
1034 # Our min version if all we need is TLS
1035 gnutls = dependency('gnutls', version: '>=3.5.18',
1036 method: 'pkg-config',
1037 required: get_option('gnutls'),
1038 kwargs: static_kwargs)
1039 endif
1040 endif
1041
1042 # We prefer use of gnutls for crypto, unless the options
1043 # explicitly asked for nettle or gcrypt.
1044 #
1045 # If gnutls isn't available for crypto, then we'll prefer
1046 # gcrypt over nettle for performance reasons.
1047 gcrypt = not_found
1048 nettle = not_found
1049 xts = 'none'
1050
1051 if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1052 error('Only one of gcrypt & nettle can be enabled')
1053 endif
1054
1055 # Explicit nettle/gcrypt request, so ignore gnutls for crypto
1056 if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1057 gnutls_crypto = not_found
1058 endif
1059
1060 if not gnutls_crypto.found()
1061 if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1062 gcrypt = dependency('libgcrypt', version: '>=1.8',
1063 method: 'config-tool',
1064 required: get_option('gcrypt'),
1065 kwargs: static_kwargs)
1066 # Debian has removed -lgpg-error from libgcrypt-config
1067 # as it "spreads unnecessary dependencies" which in
1068 # turn breaks static builds...
1069 if gcrypt.found() and enable_static
1070 gcrypt = declare_dependency(dependencies: [
1071 gcrypt,
1072 cc.find_library('gpg-error', required: true, kwargs: static_kwargs)])
1073 endif
1074 endif
1075 if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1076 nettle = dependency('nettle', version: '>=3.4',
1077 method: 'pkg-config',
1078 required: get_option('nettle'),
1079 kwargs: static_kwargs)
1080 if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1081 xts = 'private'
1082 endif
1083 endif
1084 endif
1085
1086 gtk = not_found
1087 gtkx11 = not_found
1088 vte = not_found
1089 if not get_option('gtk').auto() or (have_system and not cocoa.found())
1090 gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1091 method: 'pkg-config',
1092 required: get_option('gtk'),
1093 kwargs: static_kwargs)
1094 if gtk.found()
1095 gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1096 method: 'pkg-config',
1097 required: false,
1098 kwargs: static_kwargs)
1099 gtk = declare_dependency(dependencies: [gtk, gtkx11])
1100
1101 if not get_option('vte').auto() or have_system
1102 vte = dependency('vte-2.91',
1103 method: 'pkg-config',
1104 required: get_option('vte'),
1105 kwargs: static_kwargs)
1106 endif
1107 endif
1108 endif
1109
1110 x11 = not_found
1111 if gtkx11.found()
1112 x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found(),
1113 kwargs: static_kwargs)
1114 endif
1115 vnc = not_found
1116 png = not_found
1117 jpeg = not_found
1118 sasl = not_found
1119 if get_option('vnc').allowed() and have_system
1120 vnc = declare_dependency() # dummy dependency
1121 png = dependency('libpng', required: get_option('vnc_png'),
1122 method: 'pkg-config', kwargs: static_kwargs)
1123 jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1124 method: 'pkg-config', kwargs: static_kwargs)
1125 sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1126 required: get_option('vnc_sasl'),
1127 kwargs: static_kwargs)
1128 if sasl.found()
1129 sasl = declare_dependency(dependencies: sasl,
1130 compile_args: '-DSTRUCT_IOVEC_DEFINED')
1131 endif
1132 endif
1133
1134 pam = not_found
1135 if not get_option('auth_pam').auto() or have_system
1136 pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1137 required: get_option('auth_pam'),
1138 kwargs: static_kwargs)
1139 endif
1140 if pam.found() and not cc.links('''
1141 #include <stddef.h>
1142 #include <security/pam_appl.h>
1143 int main(void) {
1144 const char *service_name = "qemu";
1145 const char *user = "frank";
1146 const struct pam_conv pam_conv = { 0 };
1147 pam_handle_t *pamh = NULL;
1148 pam_start(service_name, user, &pam_conv, &pamh);
1149 return 0;
1150 }''', dependencies: pam)
1151 pam = not_found
1152 if get_option('auth_pam').enabled()
1153 error('could not link libpam')
1154 else
1155 warning('could not link libpam, disabling')
1156 endif
1157 endif
1158
1159 snappy = not_found
1160 if not get_option('snappy').auto() or have_system
1161 snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1162 required: get_option('snappy'),
1163 kwargs: static_kwargs)
1164 endif
1165 if snappy.found() and not linker.links('''
1166 #include <snappy-c.h>
1167 int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1168 snappy = not_found
1169 if get_option('snappy').enabled()
1170 error('could not link libsnappy')
1171 else
1172 warning('could not link libsnappy, disabling')
1173 endif
1174 endif
1175
1176 lzo = not_found
1177 if not get_option('lzo').auto() or have_system
1178 lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1179 required: get_option('lzo'),
1180 kwargs: static_kwargs)
1181 endif
1182 if lzo.found() and not cc.links('''
1183 #include <lzo/lzo1x.h>
1184 int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1185 lzo = not_found
1186 if get_option('lzo').enabled()
1187 error('could not link liblzo2')
1188 else
1189 warning('could not link liblzo2, disabling')
1190 endif
1191 endif
1192
1193 numa = not_found
1194 if not get_option('numa').auto() or have_system or have_tools
1195 numa = cc.find_library('numa', has_headers: ['numa.h'],
1196 required: get_option('numa'),
1197 kwargs: static_kwargs)
1198 endif
1199 if numa.found() and not cc.links('''
1200 #include <numa.h>
1201 int main(void) { return numa_available(); }
1202 ''', dependencies: numa)
1203 numa = not_found
1204 if get_option('numa').enabled()
1205 error('could not link numa')
1206 else
1207 warning('could not link numa, disabling')
1208 endif
1209 endif
1210
1211 rdma = not_found
1212 if 'CONFIG_RDMA' in config_host
1213 rdma = declare_dependency(link_args: config_host['RDMA_LIBS'].split())
1214 endif
1215 xen = not_found
1216 if 'CONFIG_XEN_BACKEND' in config_host
1217 xen = declare_dependency(compile_args: config_host['XEN_CFLAGS'].split(),
1218 link_args: config_host['XEN_LIBS'].split())
1219 endif
1220 cacard = not_found
1221 if not get_option('smartcard').auto() or have_system
1222 cacard = dependency('libcacard', required: get_option('smartcard'),
1223 version: '>=2.5.1', method: 'pkg-config',
1224 kwargs: static_kwargs)
1225 endif
1226 u2f = not_found
1227 if have_system
1228 u2f = dependency('u2f-emu', required: get_option('u2f'),
1229 method: 'pkg-config',
1230 kwargs: static_kwargs)
1231 endif
1232 usbredir = not_found
1233 if not get_option('usb_redir').auto() or have_system
1234 usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1235 version: '>=0.6', method: 'pkg-config',
1236 kwargs: static_kwargs)
1237 endif
1238 libusb = not_found
1239 if not get_option('libusb').auto() or have_system
1240 libusb = dependency('libusb-1.0', required: get_option('libusb'),
1241 version: '>=1.0.13', method: 'pkg-config',
1242 kwargs: static_kwargs)
1243 endif
1244
1245 libpmem = not_found
1246 if not get_option('libpmem').auto() or have_system
1247 libpmem = dependency('libpmem', required: get_option('libpmem'),
1248 method: 'pkg-config', kwargs: static_kwargs)
1249 endif
1250 libdaxctl = not_found
1251 if not get_option('libdaxctl').auto() or have_system
1252 libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1253 version: '>=57', method: 'pkg-config',
1254 kwargs: static_kwargs)
1255 endif
1256 tasn1 = not_found
1257 if gnutls.found()
1258 tasn1 = dependency('libtasn1',
1259 method: 'pkg-config',
1260 kwargs: static_kwargs)
1261 endif
1262 keyutils = dependency('libkeyutils', required: false,
1263 method: 'pkg-config', kwargs: static_kwargs)
1264
1265 has_gettid = cc.has_function('gettid')
1266
1267 # libselinux
1268 selinux = dependency('libselinux',
1269 required: get_option('selinux'),
1270 method: 'pkg-config', kwargs: static_kwargs)
1271
1272 # Malloc tests
1273
1274 malloc = []
1275 if get_option('malloc') == 'system'
1276 has_malloc_trim = \
1277 get_option('malloc_trim').allowed() and \
1278 cc.links('''#include <malloc.h>
1279 int main(void) { malloc_trim(0); return 0; }''')
1280 else
1281 has_malloc_trim = false
1282 malloc = cc.find_library(get_option('malloc'), required: true)
1283 endif
1284 if not has_malloc_trim and get_option('malloc_trim').enabled()
1285 if get_option('malloc') == 'system'
1286 error('malloc_trim not available on this platform.')
1287 else
1288 error('malloc_trim not available with non-libc memory allocator')
1289 endif
1290 endif
1291
1292 # Check whether the glibc provides statx()
1293
1294 gnu_source_prefix = '''
1295 #ifndef _GNU_SOURCE
1296 #define _GNU_SOURCE
1297 #endif
1298 '''
1299 statx_test = gnu_source_prefix + '''
1300 #include <sys/stat.h>
1301 int main(void) {
1302 struct statx statxbuf;
1303 statx(0, "", 0, STATX_BASIC_STATS, &statxbuf);
1304 return 0;
1305 }'''
1306
1307 has_statx = cc.links(statx_test)
1308
1309 # Check whether statx() provides mount ID information
1310
1311 statx_mnt_id_test = gnu_source_prefix + '''
1312 #include <sys/stat.h>
1313 int main(void) {
1314 struct statx statxbuf;
1315 statx(0, "", 0, STATX_BASIC_STATS | STATX_MNT_ID, &statxbuf);
1316 return statxbuf.stx_mnt_id;
1317 }'''
1318
1319 has_statx_mnt_id = cc.links(statx_mnt_id_test)
1320
1321 have_vhost_user_blk_server = get_option('vhost_user_blk_server') \
1322 .require(targetos == 'linux',
1323 error_message: 'vhost_user_blk_server requires linux') \
1324 .require('CONFIG_VHOST_USER' in config_host,
1325 error_message: 'vhost_user_blk_server requires vhost-user support') \
1326 .disable_auto_if(not have_system) \
1327 .allowed()
1328
1329 if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1330 error('Cannot enable fuse-lseek while fuse is disabled')
1331 endif
1332
1333 fuse = dependency('fuse3', required: get_option('fuse'),
1334 version: '>=3.1', method: 'pkg-config',
1335 kwargs: static_kwargs)
1336
1337 fuse_lseek = not_found
1338 if get_option('fuse_lseek').allowed()
1339 if fuse.version().version_compare('>=3.8')
1340 # Dummy dependency
1341 fuse_lseek = declare_dependency()
1342 elif get_option('fuse_lseek').enabled()
1343 if fuse.found()
1344 error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1345 else
1346 error('fuse-lseek requires libfuse, which was not found')
1347 endif
1348 endif
1349 endif
1350
1351 # libbpf
1352 libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1353 if libbpf.found() and not cc.links('''
1354 #include <bpf/libbpf.h>
1355 int main(void)
1356 {
1357 bpf_object__destroy_skeleton(NULL);
1358 return 0;
1359 }''', dependencies: libbpf)
1360 libbpf = not_found
1361 if get_option('bpf').enabled()
1362 error('libbpf skeleton test failed')
1363 else
1364 warning('libbpf skeleton test failed, disabling')
1365 endif
1366 endif
1367
1368 #################
1369 # config-host.h #
1370 #################
1371
1372 audio_drivers_selected = []
1373 if have_system
1374 audio_drivers_available = {
1375 'alsa': alsa.found(),
1376 'coreaudio': coreaudio.found(),
1377 'dsound': dsound.found(),
1378 'jack': jack.found(),
1379 'oss': oss.found(),
1380 'pa': pulse.found(),
1381 'sdl': sdl.found(),
1382 }
1383 foreach k, v: audio_drivers_available
1384 config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
1385 endforeach
1386
1387 # Default to native drivers first, OSS second, SDL third
1388 audio_drivers_priority = \
1389 [ 'pa', 'coreaudio', 'dsound', 'oss' ] + \
1390 (targetos == 'linux' ? [] : [ 'sdl' ])
1391 audio_drivers_default = []
1392 foreach k: audio_drivers_priority
1393 if audio_drivers_available[k]
1394 audio_drivers_default += k
1395 endif
1396 endforeach
1397
1398 foreach k: get_option('audio_drv_list')
1399 if k == 'default'
1400 audio_drivers_selected += audio_drivers_default
1401 elif not audio_drivers_available[k]
1402 error('Audio driver "@0@" not available.'.format(k))
1403 else
1404 audio_drivers_selected += k
1405 endif
1406 endforeach
1407 endif
1408 config_host_data.set('CONFIG_AUDIO_DRIVERS',
1409 '"' + '", "'.join(audio_drivers_selected) + '", ')
1410
1411 if get_option('cfi')
1412 cfi_flags=[]
1413 # Check for dependency on LTO
1414 if not get_option('b_lto')
1415 error('Selected Control-Flow Integrity but LTO is disabled')
1416 endif
1417 if config_host.has_key('CONFIG_MODULES')
1418 error('Selected Control-Flow Integrity is not compatible with modules')
1419 endif
1420 # Check for cfi flags. CFI requires LTO so we can't use
1421 # get_supported_arguments, but need a more complex "compiles" which allows
1422 # custom arguments
1423 if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1424 args: ['-flto', '-fsanitize=cfi-icall'] )
1425 cfi_flags += '-fsanitize=cfi-icall'
1426 else
1427 error('-fsanitize=cfi-icall is not supported by the compiler')
1428 endif
1429 if cc.compiles('int main () { return 0; }',
1430 name: '-fsanitize-cfi-icall-generalize-pointers',
1431 args: ['-flto', '-fsanitize=cfi-icall',
1432 '-fsanitize-cfi-icall-generalize-pointers'] )
1433 cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1434 else
1435 error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1436 endif
1437 if get_option('cfi_debug')
1438 if cc.compiles('int main () { return 0; }',
1439 name: '-fno-sanitize-trap=cfi-icall',
1440 args: ['-flto', '-fsanitize=cfi-icall',
1441 '-fno-sanitize-trap=cfi-icall'] )
1442 cfi_flags += '-fno-sanitize-trap=cfi-icall'
1443 else
1444 error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1445 endif
1446 endif
1447 add_global_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1448 add_global_link_arguments(cfi_flags, native: false, language: ['c', 'cpp', 'objc'])
1449 endif
1450
1451 have_host_block_device = (targetos != 'darwin' or
1452 cc.has_header('IOKit/storage/IOMedia.h'))
1453
1454 # FIXME enable_modules shouldn't be necessary, but: https://github.com/mesonbuild/meson/issues/8333
1455 dbus_display = get_option('dbus_display') \
1456 .require(gio.version().version_compare('>=2.64'),
1457 error_message: '-display dbus requires glib>=2.64') \
1458 .require(enable_modules,
1459 error_message: '-display dbus requires --enable-modules') \
1460 .require(config_host.has_key('GDBUS_CODEGEN'),
1461 error_message: '-display dbus requires gdbus-codegen') \
1462 .allowed()
1463
1464 have_virtfs = get_option('virtfs') \
1465 .require(targetos == 'linux' or targetos == 'darwin',
1466 error_message: 'virtio-9p (virtfs) requires Linux or macOS') \
1467 .require(targetos == 'linux' or cc.has_function('pthread_fchdir_np'),
1468 error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \
1469 .require(targetos == 'darwin' or (libattr.found() and libcap_ng.found()),
1470 error_message: 'virtio-9p (virtfs) on Linux requires libcap-ng-devel and libattr-devel') \
1471 .disable_auto_if(not have_tools and not have_system) \
1472 .allowed()
1473
1474 have_virtfs_proxy_helper = targetos != 'darwin' and have_virtfs and have_tools
1475
1476 foreach k : get_option('trace_backends')
1477 config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
1478 endforeach
1479 config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
1480 if get_option('iasl') != ''
1481 config_host_data.set_quoted('CONFIG_IASL', get_option('iasl'))
1482 endif
1483 config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
1484 config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
1485 config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
1486 config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
1487 config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
1488 config_host_data.set_quoted('CONFIG_QEMU_FIRMWAREPATH', get_option('qemu_firmwarepath'))
1489 config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
1490 config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
1491 config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
1492 config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
1493 config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
1494 config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
1495
1496 have_slirp_smbd = get_option('slirp_smbd') \
1497 .require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \
1498 .allowed()
1499 if have_slirp_smbd
1500 smbd_path = get_option('smbd')
1501 if smbd_path == ''
1502 smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
1503 endif
1504 config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
1505 endif
1506
1507 config_host_data.set('HOST_' + host_arch.to_upper(), 1)
1508
1509 config_host_data.set('CONFIG_ATTR', libattr.found())
1510 config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
1511 config_host_data.set('CONFIG_BRLAPI', brlapi.found())
1512 config_host_data.set('CONFIG_COCOA', cocoa.found())
1513 config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
1514 config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
1515 config_host_data.set('CONFIG_LIBUDEV', libudev.found())
1516 config_host_data.set('CONFIG_LZO', lzo.found())
1517 config_host_data.set('CONFIG_MPATH', mpathpersist.found())
1518 config_host_data.set('CONFIG_MPATH_NEW_API', mpathpersist_new_api)
1519 config_host_data.set('CONFIG_CURL', curl.found())
1520 config_host_data.set('CONFIG_CURSES', curses.found())
1521 config_host_data.set('CONFIG_GBM', gbm.found())
1522 config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
1523 if glusterfs.found()
1524 config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
1525 config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
1526 config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
1527 config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
1528 config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
1529 config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
1530 endif
1531 config_host_data.set('CONFIG_GTK', gtk.found())
1532 config_host_data.set('CONFIG_VTE', vte.found())
1533 config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
1534 config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
1535 config_host_data.set('CONFIG_EBPF', libbpf.found())
1536 config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
1537 config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
1538 config_host_data.set('CONFIG_LIBNFS', libnfs.found())
1539 config_host_data.set('CONFIG_LIBSSH', libssh.found())
1540 config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
1541 config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
1542 config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
1543 config_host_data.set('CONFIG_NUMA', numa.found())
1544 config_host_data.set('CONFIG_PROFILER', get_option('profiler'))
1545 config_host_data.set('CONFIG_RBD', rbd.found())
1546 config_host_data.set('CONFIG_SDL', sdl.found())
1547 config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
1548 config_host_data.set('CONFIG_SECCOMP', seccomp.found())
1549 config_host_data.set('CONFIG_SNAPPY', snappy.found())
1550 config_host_data.set('CONFIG_TPM', have_tpm)
1551 config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
1552 config_host_data.set('CONFIG_VDE', vde.found())
1553 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
1554 config_host_data.set('CONFIG_VNC', vnc.found())
1555 config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
1556 config_host_data.set('CONFIG_VNC_PNG', png.found())
1557 config_host_data.set('CONFIG_VNC_SASL', sasl.found())
1558 config_host_data.set('CONFIG_VIRTFS', have_virtfs)
1559 config_host_data.set('CONFIG_VTE', vte.found())
1560 config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
1561 config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
1562 config_host_data.set('CONFIG_GETTID', has_gettid)
1563 config_host_data.set('CONFIG_GNUTLS', gnutls.found())
1564 config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
1565 config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
1566 config_host_data.set('CONFIG_NETTLE', nettle.found())
1567 config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
1568 config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
1569 config_host_data.set('CONFIG_STATX', has_statx)
1570 config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
1571 config_host_data.set('CONFIG_ZSTD', zstd.found())
1572 config_host_data.set('CONFIG_FUSE', fuse.found())
1573 config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
1574 config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
1575 if spice_protocol.found()
1576 config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
1577 config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
1578 config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
1579 endif
1580 config_host_data.set('CONFIG_SPICE', spice.found())
1581 config_host_data.set('CONFIG_X11', x11.found())
1582 config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
1583 config_host_data.set('CONFIG_CFI', get_option('cfi'))
1584 config_host_data.set('CONFIG_SELINUX', selinux.found())
1585 config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
1586 config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
1587 config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
1588 config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
1589
1590 config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
1591 config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
1592 config_host_data.set('HOST_WORDS_BIGENDIAN', host_machine.endian() == 'big')
1593
1594 have_coroutine_pool = get_option('coroutine_pool')
1595 if get_option('debug_stack_usage') and have_coroutine_pool
1596 message('Disabling coroutine pool to measure stack usage')
1597 have_coroutine_pool = false
1598 endif
1599 config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
1600 config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
1601 config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
1602 config_host_data.set('CONFIG_GPROF', get_option('gprof'))
1603 config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
1604 config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
1605 config_host_data.set('CONFIG_REPLICATION', get_option('live_block_migration').allowed())
1606
1607 # has_header
1608 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
1609 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
1610 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
1611 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
1612 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
1613 config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
1614 config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
1615 config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
1616 config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
1617
1618 # has_function
1619 config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
1620 config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
1621 config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
1622 config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
1623 config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
1624 config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign'))
1625 config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
1626 config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
1627 config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
1628 config_host_data.set('CONFIG_SEM_TIMEDWAIT', cc.has_function('sem_timedwait', dependencies: threads))
1629 config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
1630 config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
1631 config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
1632 config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
1633 config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
1634 config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
1635 config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
1636 config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
1637 config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
1638 if rdma.found()
1639 config_host_data.set('HAVE_IBV_ADVISE_MR',
1640 cc.has_function('ibv_advise_mr',
1641 args: config_host['RDMA_LIBS'].split(),
1642 prefix: '#include <infiniband/verbs.h>'))
1643 endif
1644
1645 # has_header_symbol
1646 config_host_data.set('CONFIG_BYTESWAP_H',
1647 cc.has_header_symbol('byteswap.h', 'bswap_32'))
1648 config_host_data.set('CONFIG_EPOLL_CREATE1',
1649 cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
1650 config_host_data.set('CONFIG_HAS_ENVIRON',
1651 cc.has_header_symbol('unistd.h', 'environ', prefix: gnu_source_prefix))
1652 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
1653 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
1654 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
1655 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
1656 cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
1657 config_host_data.set('CONFIG_FIEMAP',
1658 cc.has_header('linux/fiemap.h') and
1659 cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
1660 config_host_data.set('CONFIG_GETRANDOM',
1661 cc.has_function('getrandom') and
1662 cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
1663 config_host_data.set('CONFIG_INOTIFY',
1664 cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
1665 config_host_data.set('CONFIG_INOTIFY1',
1666 cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
1667 config_host_data.set('CONFIG_MACHINE_BSWAP_H',
1668 cc.has_header_symbol('machine/bswap.h', 'bswap32',
1669 prefix: '''#include <sys/endian.h>
1670 #include <sys/types.h>'''))
1671 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
1672 cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
1673 config_host_data.set('CONFIG_RTNETLINK',
1674 cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
1675 config_host_data.set('CONFIG_SYSMACROS',
1676 cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1677 config_host_data.set('HAVE_OPTRESET',
1678 cc.has_header_symbol('getopt.h', 'optreset'))
1679 config_host_data.set('HAVE_IPPROTO_MPTCP',
1680 cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
1681
1682 # has_member
1683 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
1684 cc.has_member('struct sigevent', 'sigev_notify_thread_id',
1685 prefix: '#include <signal.h>'))
1686 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
1687 cc.has_member('struct stat', 'st_atim',
1688 prefix: '#include <sys/stat.h>'))
1689
1690 # has_type
1691 config_host_data.set('CONFIG_IOVEC',
1692 cc.has_type('struct iovec',
1693 prefix: '#include <sys/uio.h>'))
1694 config_host_data.set('HAVE_UTMPX',
1695 cc.has_type('struct utmpx',
1696 prefix: '#include <utmpx.h>'))
1697
1698 config_host_data.set('CONFIG_EVENTFD', cc.links('''
1699 #include <sys/eventfd.h>
1700 int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
1701 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
1702 #include <unistd.h>
1703 int main(void) {
1704 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
1705 return fdatasync(0);
1706 #else
1707 #error Not supported
1708 #endif
1709 }'''))
1710 config_host_data.set('CONFIG_MADVISE', cc.links(gnu_source_prefix + '''
1711 #include <sys/types.h>
1712 #include <sys/mman.h>
1713 #include <stddef.h>
1714 int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }'''))
1715 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
1716 #include <sys/mman.h>
1717 int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
1718 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
1719 #include <fcntl.h>
1720 #if !defined(AT_EMPTY_PATH)
1721 # error missing definition
1722 #else
1723 int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
1724 #endif'''))
1725 config_host_data.set('CONFIG_PIPE2', cc.links(gnu_source_prefix + '''
1726 #include <unistd.h>
1727 #include <fcntl.h>
1728
1729 int main(void)
1730 {
1731 int pipefd[2];
1732 return pipe2(pipefd, O_CLOEXEC);
1733 }'''))
1734 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
1735 #include <sys/mman.h>
1736 #include <stddef.h>
1737 int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
1738
1739 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
1740 #include <pthread.h>
1741
1742 static void *f(void *p) { return NULL; }
1743 int main(void)
1744 {
1745 pthread_t thread;
1746 pthread_create(&thread, 0, f, 0);
1747 pthread_setname_np(thread, "QEMU");
1748 return 0;
1749 }''', dependencies: threads))
1750 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
1751 #include <pthread.h>
1752
1753 static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
1754 int main(void)
1755 {
1756 pthread_t thread;
1757 pthread_create(&thread, 0, f, 0);
1758 return 0;
1759 }''', dependencies: threads))
1760
1761 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
1762 #include <sys/signalfd.h>
1763 #include <stddef.h>
1764 int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
1765 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
1766 #include <unistd.h>
1767 #include <fcntl.h>
1768 #include <limits.h>
1769
1770 int main(void)
1771 {
1772 int len, fd = 0;
1773 len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
1774 splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
1775 return 0;
1776 }'''))
1777
1778 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
1779 #include <sys/mman.h>
1780 int main(int argc, char *argv[]) {
1781 return mlockall(MCL_FUTURE);
1782 }'''))
1783
1784 have_l2tpv3 = false
1785 if get_option('l2tpv3').allowed() and have_system
1786 have_l2tpv3 = cc.has_type('struct mmsghdr',
1787 prefix: gnu_source_prefix + '''
1788 #include <sys/socket.h>
1789 #include <linux/ip.h>''')
1790 endif
1791 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
1792
1793 have_netmap = false
1794 if get_option('netmap').allowed() and have_system
1795 have_netmap = cc.compiles('''
1796 #include <inttypes.h>
1797 #include <net/if.h>
1798 #include <net/netmap.h>
1799 #include <net/netmap_user.h>
1800 #if (NETMAP_API < 11) || (NETMAP_API > 15)
1801 #error
1802 #endif
1803 int main(void) { return 0; }''')
1804 if not have_netmap and get_option('netmap').enabled()
1805 error('Netmap headers not available')
1806 endif
1807 endif
1808 config_host_data.set('CONFIG_NETMAP', have_netmap)
1809
1810 # Work around a system header bug with some kernel/XFS header
1811 # versions where they both try to define 'struct fsxattr':
1812 # xfs headers will not try to redefine structs from linux headers
1813 # if this macro is set.
1814 config_host_data.set('HAVE_FSXATTR', cc.links('''
1815 #include <linux/fs.h>
1816 struct fsxattr foo;
1817 int main(void) {
1818 return 0;
1819 }'''))
1820
1821 # Some versions of Mac OS X incorrectly define SIZE_MAX
1822 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
1823 #include <stdint.h>
1824 #include <stdio.h>
1825 int main(int argc, char *argv[]) {
1826 return printf("%zu", SIZE_MAX);
1827 }''', args: ['-Werror']))
1828
1829 # See if 64-bit atomic operations are supported.
1830 # Note that without __atomic builtins, we can only
1831 # assume atomic loads/stores max at pointer size.
1832 config_host_data.set('CONFIG_ATOMIC64', cc.links('''
1833 #include <stdint.h>
1834 int main(void)
1835 {
1836 uint64_t x = 0, y = 0;
1837 y = __atomic_load_n(&x, __ATOMIC_RELAXED);
1838 __atomic_store_n(&x, y, __ATOMIC_RELAXED);
1839 __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
1840 __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
1841 __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
1842 return 0;
1843 }'''))
1844
1845 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
1846 #include <sys/auxv.h>
1847 int main(void) {
1848 return getauxval(AT_HWCAP) == 0;
1849 }'''))
1850
1851 have_cpuid_h = cc.links('''
1852 #include <cpuid.h>
1853 int main(void) {
1854 unsigned a, b, c, d;
1855 unsigned max = __get_cpuid_max(0, 0);
1856
1857 if (max >= 1) {
1858 __cpuid(1, a, b, c, d);
1859 }
1860
1861 if (max >= 7) {
1862 __cpuid_count(7, 0, a, b, c, d);
1863 }
1864
1865 return 0;
1866 }''')
1867 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
1868
1869 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
1870 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
1871 .require(cc.links('''
1872 #pragma GCC push_options
1873 #pragma GCC target("avx2")
1874 #include <cpuid.h>
1875 #include <immintrin.h>
1876 static int bar(void *a) {
1877 __m256i x = *(__m256i *)a;
1878 return _mm256_testz_si256(x, x);
1879 }
1880 int main(int argc, char *argv[]) { return bar(argv[0]); }
1881 '''), error_message: 'AVX2 not available').allowed())
1882
1883 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
1884 .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
1885 .require(cc.links('''
1886 #pragma GCC push_options
1887 #pragma GCC target("avx512f")
1888 #include <cpuid.h>
1889 #include <immintrin.h>
1890 static int bar(void *a) {
1891 __m512i x = *(__m512i *)a;
1892 return _mm512_test_epi64_mask(x, x);
1893 }
1894 int main(int argc, char *argv[]) { return bar(argv[0]); }
1895 '''), error_message: 'AVX512F not available').allowed())
1896
1897 if get_option('membarrier').disabled()
1898 have_membarrier = false
1899 elif targetos == 'windows'
1900 have_membarrier = true
1901 elif targetos == 'linux'
1902 have_membarrier = cc.compiles('''
1903 #include <linux/membarrier.h>
1904 #include <sys/syscall.h>
1905 #include <unistd.h>
1906 #include <stdlib.h>
1907 int main(void) {
1908 syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
1909 syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
1910 exit(0);
1911 }''')
1912 endif
1913 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
1914 .require(have_membarrier, error_message: 'membarrier system call not available') \
1915 .allowed())
1916
1917 have_afalg = get_option('crypto_afalg') \
1918 .require(cc.compiles(gnu_source_prefix + '''
1919 #include <errno.h>
1920 #include <sys/types.h>
1921 #include <sys/socket.h>
1922 #include <linux/if_alg.h>
1923 int main(void) {
1924 int sock;
1925 sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
1926 return sock;
1927 }
1928 '''), error_message: 'AF_ALG requested but could not be detected').allowed()
1929 config_host_data.set('CONFIG_AF_ALG', have_afalg)
1930
1931 config_host_data.set('CONFIG_AF_VSOCK', cc.compiles(gnu_source_prefix + '''
1932 #include <errno.h>
1933 #include <sys/types.h>
1934 #include <sys/socket.h>
1935 #if !defined(AF_VSOCK)
1936 # error missing AF_VSOCK flag
1937 #endif
1938 #include <linux/vm_sockets.h>
1939 int main(void) {
1940 int sock, ret;
1941 struct sockaddr_vm svm;
1942 socklen_t len = sizeof(svm);
1943 sock = socket(AF_VSOCK, SOCK_STREAM, 0);
1944 ret = getpeername(sock, (struct sockaddr *)&svm, &len);
1945 if ((ret == -1) && (errno == ENOTCONN)) {
1946 return 0;
1947 }
1948 return -1;
1949 }'''))
1950
1951 have_vss = false
1952 if targetos == 'windows' and link_language == 'cpp'
1953 have_vss = cxx.compiles('''
1954 #define __MIDL_user_allocate_free_DEFINED__
1955 #include <inc/win2003/vss.h>
1956 int main(void) { return VSS_CTX_BACKUP; }''')
1957 endif
1958
1959 have_ntddscsi = false
1960 if targetos == 'windows'
1961 have_ntddscsi = cc.compiles('''
1962 #include <windows.h>
1963 #include <ntddscsi.h>
1964 int main(void) {
1965 #if !defined(IOCTL_SCSI_GET_ADDRESS)
1966 #error Missing required ioctl definitions
1967 #endif
1968 SCSI_ADDRESS addr = { .Lun = 0, .TargetId = 0, .PathId = 0 };
1969 return addr.Lun;
1970 }
1971 ''')
1972 endif
1973 config_host_data.set('HAVE_NTDDSCSI', have_ntddscsi)
1974
1975 ignored = ['CONFIG_QEMU_INTERP_PREFIX', # actually per-target
1976 'HAVE_GDB_BIN']
1977 arrays = ['CONFIG_BDRV_RW_WHITELIST', 'CONFIG_BDRV_RO_WHITELIST']
1978 foreach k, v: config_host
1979 if ignored.contains(k)
1980 # do nothing
1981 elif arrays.contains(k)
1982 if v != ''
1983 v = '"' + '", "'.join(v.split()) + '", '
1984 endif
1985 config_host_data.set(k, v)
1986 elif k.startswith('CONFIG_')
1987 config_host_data.set(k, v == 'y' ? 1 : v)
1988 endif
1989 endforeach
1990
1991 ########################
1992 # Target configuration #
1993 ########################
1994
1995 minikconf = find_program('scripts/minikconf.py')
1996 config_all = {}
1997 config_all_devices = {}
1998 config_all_disas = {}
1999 config_devices_mak_list = []
2000 config_devices_h = {}
2001 config_target_h = {}
2002 config_target_mak = {}
2003
2004 disassemblers = {
2005 'alpha' : ['CONFIG_ALPHA_DIS'],
2006 'arm' : ['CONFIG_ARM_DIS'],
2007 'avr' : ['CONFIG_AVR_DIS'],
2008 'cris' : ['CONFIG_CRIS_DIS'],
2009 'hexagon' : ['CONFIG_HEXAGON_DIS'],
2010 'hppa' : ['CONFIG_HPPA_DIS'],
2011 'i386' : ['CONFIG_I386_DIS'],
2012 'x86_64' : ['CONFIG_I386_DIS'],
2013 'm68k' : ['CONFIG_M68K_DIS'],
2014 'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2015 'mips' : ['CONFIG_MIPS_DIS'],
2016 'nios2' : ['CONFIG_NIOS2_DIS'],
2017 'or1k' : ['CONFIG_OPENRISC_DIS'],
2018 'ppc' : ['CONFIG_PPC_DIS'],
2019 'riscv' : ['CONFIG_RISCV_DIS'],
2020 'rx' : ['CONFIG_RX_DIS'],
2021 's390' : ['CONFIG_S390_DIS'],
2022 'sh4' : ['CONFIG_SH4_DIS'],
2023 'sparc' : ['CONFIG_SPARC_DIS'],
2024 'xtensa' : ['CONFIG_XTENSA_DIS'],
2025 }
2026 if link_language == 'cpp'
2027 disassemblers += {
2028 'aarch64' : [ 'CONFIG_ARM_A64_DIS'],
2029 'arm' : [ 'CONFIG_ARM_DIS', 'CONFIG_ARM_A64_DIS'],
2030 'mips' : [ 'CONFIG_MIPS_DIS', 'CONFIG_NANOMIPS_DIS'],
2031 }
2032 endif
2033
2034 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2035 host_kconfig = \
2036 (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2037 (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2038 (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2039 (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2040 ('CONFIG_OPENGL' in config_host ? ['CONFIG_OPENGL=y'] : []) + \
2041 (x11.found() ? ['CONFIG_X11=y'] : []) + \
2042 ('CONFIG_VHOST_USER' in config_host ? ['CONFIG_VHOST_USER=y'] : []) + \
2043 ('CONFIG_VHOST_VDPA' in config_host ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2044 ('CONFIG_VHOST_KERNEL' in config_host ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2045 (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2046 ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2047 ('CONFIG_PVRDMA' in config_host ? ['CONFIG_PVRDMA=y'] : []) + \
2048 (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : [])
2049
2050 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2051
2052 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2053 actual_target_dirs = []
2054 fdt_required = []
2055 foreach target : target_dirs
2056 config_target = { 'TARGET_NAME': target.split('-')[0] }
2057 if target.endswith('linux-user')
2058 if targetos != 'linux'
2059 if default_targets
2060 continue
2061 endif
2062 error('Target @0@ is only available on a Linux host'.format(target))
2063 endif
2064 config_target += { 'CONFIG_LINUX_USER': 'y' }
2065 elif target.endswith('bsd-user')
2066 if 'CONFIG_BSD' not in config_host
2067 if default_targets
2068 continue
2069 endif
2070 error('Target @0@ is only available on a BSD host'.format(target))
2071 endif
2072 config_target += { 'CONFIG_BSD_USER': 'y' }
2073 elif target.endswith('softmmu')
2074 config_target += { 'CONFIG_SOFTMMU': 'y' }
2075 endif
2076 if target.endswith('-user')
2077 config_target += {
2078 'CONFIG_USER_ONLY': 'y',
2079 'CONFIG_QEMU_INTERP_PREFIX':
2080 config_host['CONFIG_QEMU_INTERP_PREFIX'].format(config_target['TARGET_NAME'])
2081 }
2082 endif
2083
2084 accel_kconfig = []
2085 foreach sym: accelerators
2086 if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2087 config_target += { sym: 'y' }
2088 config_all += { sym: 'y' }
2089 if sym == 'CONFIG_TCG' and tcg_arch == 'tci'
2090 config_target += { 'CONFIG_TCG_INTERPRETER': 'y' }
2091 elif sym == 'CONFIG_XEN' and have_xen_pci_passthrough
2092 config_target += { 'CONFIG_XEN_PCI_PASSTHROUGH': 'y' }
2093 endif
2094 if target in modular_tcg
2095 config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2096 else
2097 config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2098 endif
2099 accel_kconfig += [ sym + '=y' ]
2100 endif
2101 endforeach
2102 if accel_kconfig.length() == 0
2103 if default_targets
2104 continue
2105 endif
2106 error('No accelerator available for target @0@'.format(target))
2107 endif
2108
2109 actual_target_dirs += target
2110 config_target += keyval.load('configs/targets' / target + '.mak')
2111 config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2112
2113 if 'TARGET_NEED_FDT' in config_target
2114 fdt_required += target
2115 endif
2116
2117 # Add default keys
2118 if 'TARGET_BASE_ARCH' not in config_target
2119 config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2120 endif
2121 if 'TARGET_ABI_DIR' not in config_target
2122 config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2123 endif
2124
2125 foreach k, v: disassemblers
2126 if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2127 foreach sym: v
2128 config_target += { sym: 'y' }
2129 config_all_disas += { sym: 'y' }
2130 endforeach
2131 endif
2132 endforeach
2133
2134 config_target_data = configuration_data()
2135 foreach k, v: config_target
2136 if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2137 # do nothing
2138 elif ignored.contains(k)
2139 # do nothing
2140 elif k == 'TARGET_BASE_ARCH'
2141 # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2142 # not used to select files from sourcesets.
2143 config_target_data.set('TARGET_' + v.to_upper(), 1)
2144 elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2145 config_target_data.set_quoted(k, v)
2146 elif v == 'y'
2147 config_target_data.set(k, 1)
2148 else
2149 config_target_data.set(k, v)
2150 endif
2151 endforeach
2152 config_target_data.set('QEMU_ARCH',
2153 'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2154 config_target_h += {target: configure_file(output: target + '-config-target.h',
2155 configuration: config_target_data)}
2156
2157 if target.endswith('-softmmu')
2158 config_input = meson.get_external_property(target, 'default')
2159 config_devices_mak = target + '-config-devices.mak'
2160 config_devices_mak = configure_file(
2161 input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2162 output: config_devices_mak,
2163 depfile: config_devices_mak + '.d',
2164 capture: true,
2165 command: [minikconf,
2166 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2167 config_devices_mak, '@DEPFILE@', '@INPUT@',
2168 host_kconfig, accel_kconfig,
2169 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2170
2171 config_devices_data = configuration_data()
2172 config_devices = keyval.load(config_devices_mak)
2173 foreach k, v: config_devices
2174 config_devices_data.set(k, 1)
2175 endforeach
2176 config_devices_mak_list += config_devices_mak
2177 config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2178 configuration: config_devices_data)}
2179 config_target += config_devices
2180 config_all_devices += config_devices
2181 endif
2182 config_target_mak += {target: config_target}
2183 endforeach
2184 target_dirs = actual_target_dirs
2185
2186 # This configuration is used to build files that are shared by
2187 # multiple binaries, and then extracted out of the "common"
2188 # static_library target.
2189 #
2190 # We do not use all_sources()/all_dependencies(), because it would
2191 # build literally all source files, including devices only used by
2192 # targets that are not built for this compilation. The CONFIG_ALL
2193 # pseudo symbol replaces it.
2194
2195 config_all += config_all_devices
2196 config_all += config_host
2197 config_all += config_all_disas
2198 config_all += {
2199 'CONFIG_XEN': config_host.has_key('CONFIG_XEN_BACKEND'),
2200 'CONFIG_SOFTMMU': have_system,
2201 'CONFIG_USER_ONLY': have_user,
2202 'CONFIG_ALL': true,
2203 }
2204
2205 target_configs_h = []
2206 foreach target: target_dirs
2207 target_configs_h += config_target_h[target]
2208 target_configs_h += config_devices_h.get(target, [])
2209 endforeach
2210 genh += custom_target('config-poison.h',
2211 input: [target_configs_h],
2212 output: 'config-poison.h',
2213 capture: true,
2214 command: [find_program('scripts/make-config-poison.sh'),
2215 target_configs_h])
2216
2217 ##############
2218 # Submodules #
2219 ##############
2220
2221 capstone = not_found
2222 capstone_opt = get_option('capstone')
2223 if capstone_opt in ['enabled', 'auto', 'system']
2224 have_internal = fs.exists(meson.current_source_dir() / 'capstone/Makefile')
2225 capstone = dependency('capstone', version: '>=4.0',
2226 kwargs: static_kwargs, method: 'pkg-config',
2227 required: capstone_opt == 'system' or
2228 capstone_opt == 'enabled' and not have_internal)
2229
2230 # Some versions of capstone have broken pkg-config file
2231 # that reports a wrong -I path, causing the #include to
2232 # fail later. If the system has such a broken version
2233 # do not use it.
2234 if capstone.found() and not cc.compiles('#include <capstone.h>',
2235 dependencies: [capstone])
2236 capstone = not_found
2237 if capstone_opt == 'system'
2238 error('system capstone requested, it does not appear to work')
2239 endif
2240 endif
2241
2242 if capstone.found()
2243 capstone_opt = 'system'
2244 elif have_internal
2245 capstone_opt = 'internal'
2246 else
2247 capstone_opt = 'disabled'
2248 endif
2249 endif
2250 if capstone_opt == 'internal'
2251 capstone_data = configuration_data()
2252 capstone_data.set('CAPSTONE_USE_SYS_DYN_MEM', '1')
2253
2254 capstone_files = files(
2255 'capstone/cs.c',
2256 'capstone/MCInst.c',
2257 'capstone/MCInstrDesc.c',
2258 'capstone/MCRegisterInfo.c',
2259 'capstone/SStream.c',
2260 'capstone/utils.c'
2261 )
2262
2263 if 'CONFIG_ARM_DIS' in config_all_disas
2264 capstone_data.set('CAPSTONE_HAS_ARM', '1')
2265 capstone_files += files(
2266 'capstone/arch/ARM/ARMDisassembler.c',
2267 'capstone/arch/ARM/ARMInstPrinter.c',
2268 'capstone/arch/ARM/ARMMapping.c',
2269 'capstone/arch/ARM/ARMModule.c'
2270 )
2271 endif
2272
2273 # FIXME: This config entry currently depends on a c++ compiler.
2274 # Which is needed for building libvixl, but not for capstone.
2275 if 'CONFIG_ARM_A64_DIS' in config_all_disas
2276 capstone_data.set('CAPSTONE_HAS_ARM64', '1')
2277 capstone_files += files(
2278 'capstone/arch/AArch64/AArch64BaseInfo.c',
2279 'capstone/arch/AArch64/AArch64Disassembler.c',
2280 'capstone/arch/AArch64/AArch64InstPrinter.c',
2281 'capstone/arch/AArch64/AArch64Mapping.c',
2282 'capstone/arch/AArch64/AArch64Module.c'
2283 )
2284 endif
2285
2286 if 'CONFIG_PPC_DIS' in config_all_disas
2287 capstone_data.set('CAPSTONE_HAS_POWERPC', '1')
2288 capstone_files += files(
2289 'capstone/arch/PowerPC/PPCDisassembler.c',
2290 'capstone/arch/PowerPC/PPCInstPrinter.c',
2291 'capstone/arch/PowerPC/PPCMapping.c',
2292 'capstone/arch/PowerPC/PPCModule.c'
2293 )
2294 endif
2295
2296 if 'CONFIG_S390_DIS' in config_all_disas
2297 capstone_data.set('CAPSTONE_HAS_SYSZ', '1')
2298 capstone_files += files(
2299 'capstone/arch/SystemZ/SystemZDisassembler.c',
2300 'capstone/arch/SystemZ/SystemZInstPrinter.c',
2301 'capstone/arch/SystemZ/SystemZMapping.c',
2302 'capstone/arch/SystemZ/SystemZModule.c',
2303 'capstone/arch/SystemZ/SystemZMCTargetDesc.c'
2304 )
2305 endif
2306
2307 if 'CONFIG_I386_DIS' in config_all_disas
2308 capstone_data.set('CAPSTONE_HAS_X86', 1)
2309 capstone_files += files(
2310 'capstone/arch/X86/X86Disassembler.c',
2311 'capstone/arch/X86/X86DisassemblerDecoder.c',
2312 'capstone/arch/X86/X86ATTInstPrinter.c',
2313 'capstone/arch/X86/X86IntelInstPrinter.c',
2314 'capstone/arch/X86/X86InstPrinterCommon.c',
2315 'capstone/arch/X86/X86Mapping.c',
2316 'capstone/arch/X86/X86Module.c'
2317 )
2318 endif
2319
2320 configure_file(output: 'capstone-defs.h', configuration: capstone_data)
2321
2322 capstone_cargs = [
2323 # FIXME: There does not seem to be a way to completely replace the c_args
2324 # that come from add_project_arguments() -- we can only add to them.
2325 # So: disable all warnings with a big hammer.
2326 '-Wno-error', '-w',
2327
2328 # Include all configuration defines via a header file, which will wind up
2329 # as a dependency on the object file, and thus changes here will result
2330 # in a rebuild.
2331 '-include', 'capstone-defs.h'
2332 ]
2333
2334 libcapstone = static_library('capstone',
2335 build_by_default: false,
2336 sources: capstone_files,
2337 c_args: capstone_cargs,
2338 include_directories: 'capstone/include')
2339 capstone = declare_dependency(link_with: libcapstone,
2340 include_directories: 'capstone/include/capstone')
2341 endif
2342
2343 slirp = not_found
2344 slirp_opt = 'disabled'
2345 if have_system
2346 slirp_opt = get_option('slirp')
2347 if slirp_opt in ['enabled', 'auto', 'system']
2348 have_internal = fs.exists(meson.current_source_dir() / 'slirp/meson.build')
2349 slirp = dependency('slirp', kwargs: static_kwargs,
2350 method: 'pkg-config',
2351 required: slirp_opt == 'system' or
2352 slirp_opt == 'enabled' and not have_internal)
2353 if slirp.found()
2354 slirp_opt = 'system'
2355 elif have_internal
2356 slirp_opt = 'internal'
2357 else
2358 slirp_opt = 'disabled'
2359 endif
2360 endif
2361 if slirp_opt == 'internal'
2362 slirp_deps = []
2363 if targetos == 'windows'
2364 slirp_deps = cc.find_library('iphlpapi')
2365 elif targetos == 'darwin'
2366 slirp_deps = cc.find_library('resolv')
2367 endif
2368 slirp_conf = configuration_data()
2369 slirp_conf.set('SLIRP_MAJOR_VERSION', meson.project_version().split('.')[0])
2370 slirp_conf.set('SLIRP_MINOR_VERSION', meson.project_version().split('.')[1])
2371 slirp_conf.set('SLIRP_MICRO_VERSION', meson.project_version().split('.')[2])
2372 slirp_conf.set_quoted('SLIRP_VERSION_STRING', meson.project_version())
2373 slirp_cargs = ['-DG_LOG_DOMAIN="Slirp"']
2374 slirp_files = [
2375 'slirp/src/arp_table.c',
2376 'slirp/src/bootp.c',
2377 'slirp/src/cksum.c',
2378 'slirp/src/dhcpv6.c',
2379 'slirp/src/dnssearch.c',
2380 'slirp/src/if.c',
2381 'slirp/src/ip6_icmp.c',
2382 'slirp/src/ip6_input.c',
2383 'slirp/src/ip6_output.c',
2384 'slirp/src/ip_icmp.c',
2385 'slirp/src/ip_input.c',
2386 'slirp/src/ip_output.c',
2387 'slirp/src/mbuf.c',
2388 'slirp/src/misc.c',
2389 'slirp/src/ncsi.c',
2390 'slirp/src/ndp_table.c',
2391 'slirp/src/sbuf.c',
2392 'slirp/src/slirp.c',
2393 'slirp/src/socket.c',
2394 'slirp/src/state.c',
2395 'slirp/src/stream.c',
2396 'slirp/src/tcp_input.c',
2397 'slirp/src/tcp_output.c',
2398 'slirp/src/tcp_subr.c',
2399 'slirp/src/tcp_timer.c',
2400 'slirp/src/tftp.c',
2401 'slirp/src/udp.c',
2402 'slirp/src/udp6.c',
2403 'slirp/src/util.c',
2404 'slirp/src/version.c',
2405 'slirp/src/vmstate.c',
2406 ]
2407
2408 configure_file(
2409 input : 'slirp/src/libslirp-version.h.in',
2410 output : 'libslirp-version.h',
2411 configuration: slirp_conf)
2412
2413 slirp_inc = include_directories('slirp', 'slirp/src')
2414 libslirp = static_library('slirp',
2415 build_by_default: false,
2416 sources: slirp_files,
2417 c_args: slirp_cargs,
2418 include_directories: slirp_inc)
2419 slirp = declare_dependency(link_with: libslirp,
2420 dependencies: slirp_deps,
2421 include_directories: slirp_inc)
2422 endif
2423 endif
2424
2425 # For CFI, we need to compile slirp as a static library together with qemu.
2426 # This is because we register slirp functions as callbacks for QEMU Timers.
2427 # When using a system-wide shared libslirp, the type information for the
2428 # callback is missing and the timer call produces a false positive with CFI.
2429 #
2430 # Now that slirp_opt has been defined, check if the selected slirp is compatible
2431 # with control-flow integrity.
2432 if get_option('cfi') and slirp_opt == 'system'
2433 error('Control-Flow Integrity is not compatible with system-wide slirp.' \
2434 + ' Please configure with --enable-slirp=git')
2435 endif
2436
2437 fdt = not_found
2438 if have_system
2439 fdt_opt = get_option('fdt')
2440 if fdt_opt in ['enabled', 'auto', 'system']
2441 have_internal = fs.exists(meson.current_source_dir() / 'dtc/libfdt/Makefile.libfdt')
2442 fdt = cc.find_library('fdt', kwargs: static_kwargs,
2443 required: fdt_opt == 'system' or
2444 fdt_opt == 'enabled' and not have_internal)
2445 if fdt.found() and cc.links('''
2446 #include <libfdt.h>
2447 #include <libfdt_env.h>
2448 int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
2449 dependencies: fdt)
2450 fdt_opt = 'system'
2451 elif fdt_opt == 'system'
2452 error('system libfdt requested, but it is too old (1.5.1 or newer required)')
2453 elif have_internal
2454 fdt_opt = 'internal'
2455 else
2456 fdt_opt = 'disabled'
2457 fdt = not_found
2458 endif
2459 endif
2460 if fdt_opt == 'internal'
2461 fdt_files = files(
2462 'dtc/libfdt/fdt.c',
2463 'dtc/libfdt/fdt_ro.c',
2464 'dtc/libfdt/fdt_wip.c',
2465 'dtc/libfdt/fdt_sw.c',
2466 'dtc/libfdt/fdt_rw.c',
2467 'dtc/libfdt/fdt_strerror.c',
2468 'dtc/libfdt/fdt_empty_tree.c',
2469 'dtc/libfdt/fdt_addresses.c',
2470 'dtc/libfdt/fdt_overlay.c',
2471 'dtc/libfdt/fdt_check.c',
2472 )
2473
2474 fdt_inc = include_directories('dtc/libfdt')
2475 libfdt = static_library('fdt',
2476 build_by_default: false,
2477 sources: fdt_files,
2478 include_directories: fdt_inc)
2479 fdt = declare_dependency(link_with: libfdt,
2480 include_directories: fdt_inc)
2481 endif
2482 else
2483 fdt_opt = 'disabled'
2484 endif
2485 if not fdt.found() and fdt_required.length() > 0
2486 error('fdt not available but required by targets ' + ', '.join(fdt_required))
2487 endif
2488
2489 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
2490 config_host_data.set('CONFIG_FDT', fdt.found())
2491 config_host_data.set('CONFIG_SLIRP', slirp.found())
2492
2493 #####################
2494 # Generated sources #
2495 #####################
2496
2497 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
2498
2499 hxtool = find_program('scripts/hxtool')
2500 shaderinclude = find_program('scripts/shaderinclude.pl')
2501 qapi_gen = find_program('scripts/qapi-gen.py')
2502 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
2503 meson.current_source_dir() / 'scripts/qapi/commands.py',
2504 meson.current_source_dir() / 'scripts/qapi/common.py',
2505 meson.current_source_dir() / 'scripts/qapi/error.py',
2506 meson.current_source_dir() / 'scripts/qapi/events.py',
2507 meson.current_source_dir() / 'scripts/qapi/expr.py',
2508 meson.current_source_dir() / 'scripts/qapi/gen.py',
2509 meson.current_source_dir() / 'scripts/qapi/introspect.py',
2510 meson.current_source_dir() / 'scripts/qapi/parser.py',
2511 meson.current_source_dir() / 'scripts/qapi/schema.py',
2512 meson.current_source_dir() / 'scripts/qapi/source.py',
2513 meson.current_source_dir() / 'scripts/qapi/types.py',
2514 meson.current_source_dir() / 'scripts/qapi/visit.py',
2515 meson.current_source_dir() / 'scripts/qapi/common.py',
2516 meson.current_source_dir() / 'scripts/qapi-gen.py'
2517 ]
2518
2519 tracetool = [
2520 python, files('scripts/tracetool.py'),
2521 '--backend=' + ','.join(get_option('trace_backends'))
2522 ]
2523 tracetool_depends = files(
2524 'scripts/tracetool/backend/log.py',
2525 'scripts/tracetool/backend/__init__.py',
2526 'scripts/tracetool/backend/dtrace.py',
2527 'scripts/tracetool/backend/ftrace.py',
2528 'scripts/tracetool/backend/simple.py',
2529 'scripts/tracetool/backend/syslog.py',
2530 'scripts/tracetool/backend/ust.py',
2531 'scripts/tracetool/format/ust_events_c.py',
2532 'scripts/tracetool/format/ust_events_h.py',
2533 'scripts/tracetool/format/__init__.py',
2534 'scripts/tracetool/format/d.py',
2535 'scripts/tracetool/format/simpletrace_stap.py',
2536 'scripts/tracetool/format/c.py',
2537 'scripts/tracetool/format/h.py',
2538 'scripts/tracetool/format/log_stap.py',
2539 'scripts/tracetool/format/stap.py',
2540 'scripts/tracetool/__init__.py',
2541 'scripts/tracetool/transform.py',
2542 'scripts/tracetool/vcpu.py'
2543 )
2544
2545 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
2546 meson.current_source_dir(),
2547 config_host['PKGVERSION'], meson.project_version()]
2548 qemu_version = custom_target('qemu-version.h',
2549 output: 'qemu-version.h',
2550 command: qemu_version_cmd,
2551 capture: true,
2552 build_by_default: true,
2553 build_always_stale: true)
2554 genh += qemu_version
2555
2556 hxdep = []
2557 hx_headers = [
2558 ['qemu-options.hx', 'qemu-options.def'],
2559 ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
2560 ]
2561 if have_system
2562 hx_headers += [
2563 ['hmp-commands.hx', 'hmp-commands.h'],
2564 ['hmp-commands-info.hx', 'hmp-commands-info.h'],
2565 ]
2566 endif
2567 foreach d : hx_headers
2568 hxdep += custom_target(d[1],
2569 input: files(d[0]),
2570 output: d[1],
2571 capture: true,
2572 build_by_default: true, # to be removed when added to a target
2573 command: [hxtool, '-h', '@INPUT0@'])
2574 endforeach
2575 genh += hxdep
2576
2577 ###################
2578 # Collect sources #
2579 ###################
2580
2581 authz_ss = ss.source_set()
2582 blockdev_ss = ss.source_set()
2583 block_ss = ss.source_set()
2584 chardev_ss = ss.source_set()
2585 common_ss = ss.source_set()
2586 crypto_ss = ss.source_set()
2587 hwcore_ss = ss.source_set()
2588 io_ss = ss.source_set()
2589 qmp_ss = ss.source_set()
2590 qom_ss = ss.source_set()
2591 softmmu_ss = ss.source_set()
2592 specific_fuzz_ss = ss.source_set()
2593 specific_ss = ss.source_set()
2594 stub_ss = ss.source_set()
2595 trace_ss = ss.source_set()
2596 user_ss = ss.source_set()
2597 util_ss = ss.source_set()
2598
2599 # accel modules
2600 qtest_module_ss = ss.source_set()
2601 tcg_module_ss = ss.source_set()
2602
2603 modules = {}
2604 target_modules = {}
2605 hw_arch = {}
2606 target_arch = {}
2607 target_softmmu_arch = {}
2608 target_user_arch = {}
2609
2610 ###############
2611 # Trace files #
2612 ###############
2613
2614 # TODO: add each directory to the subdirs from its own meson.build, once
2615 # we have those
2616 trace_events_subdirs = [
2617 'crypto',
2618 'qapi',
2619 'qom',
2620 'monitor',
2621 'util',
2622 ]
2623 if have_linux_user
2624 trace_events_subdirs += [ 'linux-user' ]
2625 endif
2626 if have_bsd_user
2627 trace_events_subdirs += [ 'bsd-user' ]
2628 endif
2629 if have_block
2630 trace_events_subdirs += [
2631 'authz',
2632 'block',
2633 'io',
2634 'nbd',
2635 'scsi',
2636 ]
2637 endif
2638 if have_system
2639 trace_events_subdirs += [
2640 'accel/kvm',
2641 'audio',
2642 'backends',
2643 'backends/tpm',
2644 'chardev',
2645 'ebpf',
2646 'hw/9pfs',
2647 'hw/acpi',
2648 'hw/adc',
2649 'hw/alpha',
2650 'hw/arm',
2651 'hw/audio',
2652 'hw/block',
2653 'hw/block/dataplane',
2654 'hw/char',
2655 'hw/display',
2656 'hw/dma',
2657 'hw/hppa',
2658 'hw/hyperv',
2659 'hw/i2c',
2660 'hw/i386',
2661 'hw/i386/xen',
2662 'hw/ide',
2663 'hw/input',
2664 'hw/intc',
2665 'hw/isa',
2666 'hw/mem',
2667 'hw/mips',
2668 'hw/misc',
2669 'hw/misc/macio',
2670 'hw/net',
2671 'hw/net/can',
2672 'hw/nubus',
2673 'hw/nvme',
2674 'hw/nvram',
2675 'hw/pci',
2676 'hw/pci-host',
2677 'hw/ppc',
2678 'hw/rdma',
2679 'hw/rdma/vmw',
2680 'hw/rtc',
2681 'hw/s390x',
2682 'hw/scsi',
2683 'hw/sd',
2684 'hw/sh4',
2685 'hw/sparc',
2686 'hw/sparc64',
2687 'hw/ssi',
2688 'hw/timer',
2689 'hw/tpm',
2690 'hw/usb',
2691 'hw/vfio',
2692 'hw/virtio',
2693 'hw/watchdog',
2694 'hw/xen',
2695 'hw/gpio',
2696 'migration',
2697 'net',
2698 'softmmu',
2699 'ui',
2700 'hw/remote',
2701 ]
2702 endif
2703 if have_system or have_user
2704 trace_events_subdirs += [
2705 'accel/tcg',
2706 'hw/core',
2707 'target/arm',
2708 'target/arm/hvf',
2709 'target/hppa',
2710 'target/i386',
2711 'target/i386/kvm',
2712 'target/mips/tcg',
2713 'target/nios2',
2714 'target/ppc',
2715 'target/riscv',
2716 'target/s390x',
2717 'target/s390x/kvm',
2718 'target/sparc',
2719 ]
2720 endif
2721
2722 vhost_user = not_found
2723 if 'CONFIG_VHOST_USER' in config_host
2724 libvhost_user = subproject('libvhost-user')
2725 vhost_user = libvhost_user.get_variable('vhost_user_dep')
2726 endif
2727
2728 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
2729 # that is filled in by qapi/.
2730 subdir('qapi')
2731 subdir('qobject')
2732 subdir('stubs')
2733 subdir('trace')
2734 subdir('util')
2735 subdir('qom')
2736 subdir('authz')
2737 subdir('crypto')
2738 subdir('ui')
2739
2740
2741 if enable_modules
2742 libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
2743 modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
2744 endif
2745
2746 stub_ss = stub_ss.apply(config_all, strict: false)
2747
2748 util_ss.add_all(trace_ss)
2749 util_ss = util_ss.apply(config_all, strict: false)
2750 libqemuutil = static_library('qemuutil',
2751 sources: util_ss.sources() + stub_ss.sources() + genh,
2752 dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
2753 qemuutil = declare_dependency(link_with: libqemuutil,
2754 sources: genh + version_res)
2755
2756 if have_system or have_user
2757 decodetree = generator(find_program('scripts/decodetree.py'),
2758 output: 'decode-@BASENAME@.c.inc',
2759 arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
2760 subdir('libdecnumber')
2761 subdir('target')
2762 endif
2763
2764 subdir('audio')
2765 subdir('io')
2766 subdir('chardev')
2767 subdir('fsdev')
2768 subdir('dump')
2769
2770 if have_block
2771 block_ss.add(files(
2772 'block.c',
2773 'blockjob.c',
2774 'job.c',
2775 'qemu-io-cmds.c',
2776 ))
2777 if config_host_data.get('CONFIG_REPLICATION')
2778 block_ss.add(files('replication.c'))
2779 endif
2780
2781 subdir('nbd')
2782 subdir('scsi')
2783 subdir('block')
2784
2785 blockdev_ss.add(files(
2786 'blockdev.c',
2787 'blockdev-nbd.c',
2788 'iothread.c',
2789 'job-qmp.c',
2790 ), gnutls)
2791
2792 # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
2793 # os-win32.c does not
2794 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
2795 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
2796 endif
2797
2798 common_ss.add(files('cpus-common.c'))
2799
2800 subdir('softmmu')
2801
2802 common_ss.add(capstone)
2803 specific_ss.add(files('cpu.c', 'disas.c', 'gdbstub.c'), capstone)
2804
2805 # Work around a gcc bug/misfeature wherein constant propagation looks
2806 # through an alias:
2807 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
2808 # to guess that a const variable is always zero. Without lto, this is
2809 # impossible, as the alias is restricted to page-vary-common.c. Indeed,
2810 # without lto, not even the alias is required -- we simply use different
2811 # declarations in different compilation units.
2812 pagevary = files('page-vary-common.c')
2813 if get_option('b_lto')
2814 pagevary_flags = ['-fno-lto']
2815 if get_option('cfi')
2816 pagevary_flags += '-fno-sanitize=cfi-icall'
2817 endif
2818 pagevary = static_library('page-vary-common', sources: pagevary,
2819 c_args: pagevary_flags)
2820 pagevary = declare_dependency(link_with: pagevary)
2821 endif
2822 common_ss.add(pagevary)
2823 specific_ss.add(files('page-vary.c'))
2824
2825 subdir('backends')
2826 subdir('disas')
2827 subdir('migration')
2828 subdir('monitor')
2829 subdir('net')
2830 subdir('replay')
2831 subdir('semihosting')
2832 subdir('hw')
2833 subdir('tcg')
2834 subdir('fpu')
2835 subdir('accel')
2836 subdir('plugins')
2837 subdir('ebpf')
2838
2839 common_user_inc = []
2840
2841 subdir('common-user')
2842 subdir('bsd-user')
2843 subdir('linux-user')
2844
2845 # needed for fuzzing binaries
2846 subdir('tests/qtest/libqos')
2847 subdir('tests/qtest/fuzz')
2848
2849 # accel modules
2850 tcg_real_module_ss = ss.source_set()
2851 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
2852 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
2853 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
2854 'tcg': tcg_real_module_ss }}
2855
2856 ########################
2857 # Library dependencies #
2858 ########################
2859
2860 modinfo_collect = find_program('scripts/modinfo-collect.py')
2861 modinfo_generate = find_program('scripts/modinfo-generate.py')
2862 modinfo_files = []
2863
2864 block_mods = []
2865 softmmu_mods = []
2866 foreach d, list : modules
2867 foreach m, module_ss : list
2868 if enable_modules and targetos != 'windows'
2869 module_ss = module_ss.apply(config_all, strict: false)
2870 sl = static_library(d + '-' + m, [genh, module_ss.sources()],
2871 dependencies: [modulecommon, module_ss.dependencies()], pic: true)
2872 if d == 'block'
2873 block_mods += sl
2874 else
2875 softmmu_mods += sl
2876 endif
2877 if module_ss.sources() != []
2878 # FIXME: Should use sl.extract_all_objects(recursive: true) as
2879 # input. Sources can be used multiple times but objects are
2880 # unique when it comes to lookup in compile_commands.json.
2881 # Depnds on a mesion version with
2882 # https://github.com/mesonbuild/meson/pull/8900
2883 modinfo_files += custom_target(d + '-' + m + '.modinfo',
2884 output: d + '-' + m + '.modinfo',
2885 input: module_ss.sources() + genh,
2886 capture: true,
2887 command: [modinfo_collect, module_ss.sources()])
2888 endif
2889 else
2890 if d == 'block'
2891 block_ss.add_all(module_ss)
2892 else
2893 softmmu_ss.add_all(module_ss)
2894 endif
2895 endif
2896 endforeach
2897 endforeach
2898
2899 foreach d, list : target_modules
2900 foreach m, module_ss : list
2901 if enable_modules and targetos != 'windows'
2902 foreach target : target_dirs
2903 if target.endswith('-softmmu')
2904 config_target = config_target_mak[target]
2905 config_target += config_host
2906 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
2907 c_args = ['-DNEED_CPU_H',
2908 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
2909 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
2910 target_module_ss = module_ss.apply(config_target, strict: false)
2911 if target_module_ss.sources() != []
2912 module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
2913 sl = static_library(module_name,
2914 [genh, target_module_ss.sources()],
2915 dependencies: [modulecommon, target_module_ss.dependencies()],
2916 include_directories: target_inc,
2917 c_args: c_args,
2918 pic: true)
2919 softmmu_mods += sl
2920 # FIXME: Should use sl.extract_all_objects(recursive: true) too.
2921 modinfo_files += custom_target(module_name + '.modinfo',
2922 output: module_name + '.modinfo',
2923 input: target_module_ss.sources() + genh,
2924 capture: true,
2925 command: [modinfo_collect, '--target', target, target_module_ss.sources()])
2926 endif
2927 endif
2928 endforeach
2929 else
2930 specific_ss.add_all(module_ss)
2931 endif
2932 endforeach
2933 endforeach
2934
2935 if enable_modules
2936 modinfo_src = custom_target('modinfo.c',
2937 output: 'modinfo.c',
2938 input: modinfo_files,
2939 command: [modinfo_generate, '@INPUT@'],
2940 capture: true)
2941 modinfo_lib = static_library('modinfo', modinfo_src)
2942 modinfo_dep = declare_dependency(link_whole: modinfo_lib)
2943 softmmu_ss.add(modinfo_dep)
2944 endif
2945
2946 nm = find_program('nm')
2947 undefsym = find_program('scripts/undefsym.py')
2948 block_syms = custom_target('block.syms', output: 'block.syms',
2949 input: [libqemuutil, block_mods],
2950 capture: true,
2951 command: [undefsym, nm, '@INPUT@'])
2952 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
2953 input: [libqemuutil, softmmu_mods],
2954 capture: true,
2955 command: [undefsym, nm, '@INPUT@'])
2956
2957 qom_ss = qom_ss.apply(config_host, strict: false)
2958 libqom = static_library('qom', qom_ss.sources() + genh,
2959 dependencies: [qom_ss.dependencies()],
2960 name_suffix: 'fa')
2961
2962 qom = declare_dependency(link_whole: libqom)
2963
2964 authz_ss = authz_ss.apply(config_host, strict: false)
2965 libauthz = static_library('authz', authz_ss.sources() + genh,
2966 dependencies: [authz_ss.dependencies()],
2967 name_suffix: 'fa',
2968 build_by_default: false)
2969
2970 authz = declare_dependency(link_whole: libauthz,
2971 dependencies: qom)
2972
2973 crypto_ss = crypto_ss.apply(config_host, strict: false)
2974 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
2975 dependencies: [crypto_ss.dependencies()],
2976 name_suffix: 'fa',
2977 build_by_default: false)
2978
2979 crypto = declare_dependency(link_whole: libcrypto,
2980 dependencies: [authz, qom])
2981
2982 io_ss = io_ss.apply(config_host, strict: false)
2983 libio = static_library('io', io_ss.sources() + genh,
2984 dependencies: [io_ss.dependencies()],
2985 link_with: libqemuutil,
2986 name_suffix: 'fa',
2987 build_by_default: false)
2988
2989 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
2990
2991 libmigration = static_library('migration', sources: migration_files + genh,
2992 name_suffix: 'fa',
2993 build_by_default: false)
2994 migration = declare_dependency(link_with: libmigration,
2995 dependencies: [zlib, qom, io])
2996 softmmu_ss.add(migration)
2997
2998 block_ss = block_ss.apply(config_host, strict: false)
2999 libblock = static_library('block', block_ss.sources() + genh,
3000 dependencies: block_ss.dependencies(),
3001 link_depends: block_syms,
3002 name_suffix: 'fa',
3003 build_by_default: false)
3004
3005 block = declare_dependency(link_whole: [libblock],
3006 link_args: '@block.syms',
3007 dependencies: [crypto, io])
3008
3009 blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3010 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3011 dependencies: blockdev_ss.dependencies(),
3012 name_suffix: 'fa',
3013 build_by_default: false)
3014
3015 blockdev = declare_dependency(link_whole: [libblockdev],
3016 dependencies: [block])
3017
3018 qmp_ss = qmp_ss.apply(config_host, strict: false)
3019 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3020 dependencies: qmp_ss.dependencies(),
3021 name_suffix: 'fa',
3022 build_by_default: false)
3023
3024 qmp = declare_dependency(link_whole: [libqmp])
3025
3026 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3027 name_suffix: 'fa',
3028 dependencies: [gnutls],
3029 build_by_default: false)
3030
3031 chardev = declare_dependency(link_whole: libchardev)
3032
3033 hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3034 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3035 name_suffix: 'fa',
3036 build_by_default: false)
3037 hwcore = declare_dependency(link_whole: libhwcore)
3038 common_ss.add(hwcore)
3039
3040 ###########
3041 # Targets #
3042 ###########
3043
3044 emulator_modules = []
3045 foreach m : block_mods + softmmu_mods
3046 emulator_modules += shared_module(m.name(),
3047 build_by_default: true,
3048 name_prefix: '',
3049 link_whole: m,
3050 install: true,
3051 install_dir: qemu_moddir)
3052 endforeach
3053
3054 softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3055 common_ss.add(qom, qemuutil)
3056
3057 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3058 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3059
3060 common_all = common_ss.apply(config_all, strict: false)
3061 common_all = static_library('common',
3062 build_by_default: false,
3063 sources: common_all.sources() + genh,
3064 include_directories: common_user_inc,
3065 implicit_include_directories: false,
3066 dependencies: common_all.dependencies(),
3067 name_suffix: 'fa')
3068
3069 feature_to_c = find_program('scripts/feature_to_c.sh')
3070
3071 emulators = {}
3072 foreach target : target_dirs
3073 config_target = config_target_mak[target]
3074 target_name = config_target['TARGET_NAME']
3075 target_base_arch = config_target['TARGET_BASE_ARCH']
3076 arch_srcs = [config_target_h[target]]
3077 arch_deps = []
3078 c_args = ['-DNEED_CPU_H',
3079 '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3080 '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3081 link_args = emulator_link_args
3082
3083 config_target += config_host
3084 target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3085 if targetos == 'linux'
3086 target_inc += include_directories('linux-headers', is_system: true)
3087 endif
3088 if target.endswith('-softmmu')
3089 qemu_target_name = 'qemu-system-' + target_name
3090 target_type='system'
3091 t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3092 arch_srcs += t.sources()
3093 arch_deps += t.dependencies()
3094
3095 hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3096 hw = hw_arch[hw_dir].apply(config_target, strict: false)
3097 arch_srcs += hw.sources()
3098 arch_deps += hw.dependencies()
3099
3100 arch_srcs += config_devices_h[target]
3101 link_args += ['@block.syms', '@qemu.syms']
3102 else
3103 abi = config_target['TARGET_ABI_DIR']
3104 target_type='user'
3105 target_inc += common_user_inc
3106 qemu_target_name = 'qemu-' + target_name
3107 if target_base_arch in target_user_arch
3108 t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3109 arch_srcs += t.sources()
3110 arch_deps += t.dependencies()
3111 endif
3112 if 'CONFIG_LINUX_USER' in config_target
3113 base_dir = 'linux-user'
3114 endif
3115 if 'CONFIG_BSD_USER' in config_target
3116 base_dir = 'bsd-user'
3117 target_inc += include_directories('bsd-user/' / targetos)
3118 target_inc += include_directories('bsd-user/host/' / host_arch)
3119 dir = base_dir / abi
3120 arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3121 endif
3122 target_inc += include_directories(
3123 base_dir,
3124 base_dir / abi,
3125 )
3126 if 'CONFIG_LINUX_USER' in config_target
3127 dir = base_dir / abi
3128 arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3129 if config_target.has_key('TARGET_SYSTBL_ABI')
3130 arch_srcs += \
3131 syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3132 extra_args : config_target['TARGET_SYSTBL_ABI'])
3133 endif
3134 endif
3135 endif
3136
3137 if 'TARGET_XML_FILES' in config_target
3138 gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3139 output: target + '-gdbstub-xml.c',
3140 input: files(config_target['TARGET_XML_FILES'].split()),
3141 command: [feature_to_c, '@INPUT@'],
3142 capture: true)
3143 arch_srcs += gdbstub_xml
3144 endif
3145
3146 t = target_arch[target_base_arch].apply(config_target, strict: false)
3147 arch_srcs += t.sources()
3148 arch_deps += t.dependencies()
3149
3150 target_common = common_ss.apply(config_target, strict: false)
3151 objects = common_all.extract_objects(target_common.sources())
3152 deps = target_common.dependencies()
3153
3154 target_specific = specific_ss.apply(config_target, strict: false)
3155 arch_srcs += target_specific.sources()
3156 arch_deps += target_specific.dependencies()
3157
3158 lib = static_library('qemu-' + target,
3159 sources: arch_srcs + genh,
3160 dependencies: arch_deps,
3161 objects: objects,
3162 include_directories: target_inc,
3163 c_args: c_args,
3164 build_by_default: false,
3165 name_suffix: 'fa')
3166
3167 if target.endswith('-softmmu')
3168 execs = [{
3169 'name': 'qemu-system-' + target_name,
3170 'win_subsystem': 'console',
3171 'sources': files('softmmu/main.c'),
3172 'dependencies': []
3173 }]
3174 if targetos == 'windows' and (sdl.found() or gtk.found())
3175 execs += [{
3176 'name': 'qemu-system-' + target_name + 'w',
3177 'win_subsystem': 'windows',
3178 'sources': files('softmmu/main.c'),
3179 'dependencies': []
3180 }]
3181 endif
3182 if get_option('fuzzing')
3183 specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3184 execs += [{
3185 'name': 'qemu-fuzz-' + target_name,
3186 'win_subsystem': 'console',
3187 'sources': specific_fuzz.sources(),
3188 'dependencies': specific_fuzz.dependencies(),
3189 }]
3190 endif
3191 else
3192 execs = [{
3193 'name': 'qemu-' + target_name,
3194 'win_subsystem': 'console',
3195 'sources': [],
3196 'dependencies': []
3197 }]
3198 endif
3199 foreach exe: execs
3200 exe_name = exe['name']
3201 if targetos == 'darwin'
3202 exe_name += '-unsigned'
3203 endif
3204
3205 emulator = executable(exe_name, exe['sources'],
3206 install: true,
3207 c_args: c_args,
3208 dependencies: arch_deps + deps + exe['dependencies'],
3209 objects: lib.extract_all_objects(recursive: true),
3210 link_language: link_language,
3211 link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3212 link_args: link_args,
3213 win_subsystem: exe['win_subsystem'])
3214
3215 if targetos == 'darwin'
3216 icon = 'pc-bios/qemu.rsrc'
3217 build_input = [emulator, files(icon)]
3218 install_input = [
3219 get_option('bindir') / exe_name,
3220 meson.current_source_dir() / icon
3221 ]
3222 if 'CONFIG_HVF' in config_target
3223 entitlements = 'accel/hvf/entitlements.plist'
3224 build_input += files(entitlements)
3225 install_input += meson.current_source_dir() / entitlements
3226 endif
3227
3228 entitlement = find_program('scripts/entitlement.sh')
3229 emulators += {exe['name'] : custom_target(exe['name'],
3230 input: build_input,
3231 output: exe['name'],
3232 command: [entitlement, '@OUTPUT@', '@INPUT@'])
3233 }
3234
3235 meson.add_install_script(entitlement, '--install',
3236 get_option('bindir') / exe['name'],
3237 install_input)
3238 else
3239 emulators += {exe['name']: emulator}
3240 endif
3241
3242 if stap.found()
3243 foreach stp: [
3244 {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3245 {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3246 {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3247 {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3248 ]
3249 custom_target(exe['name'] + stp['ext'],
3250 input: trace_events_all,
3251 output: exe['name'] + stp['ext'],
3252 install: stp['install'],
3253 install_dir: get_option('datadir') / 'systemtap/tapset',
3254 command: [
3255 tracetool, '--group=all', '--format=' + stp['fmt'],
3256 '--binary=' + stp['bin'],
3257 '--target-name=' + target_name,
3258 '--target-type=' + target_type,
3259 '--probe-prefix=qemu.' + target_type + '.' + target_name,
3260 '@INPUT@', '@OUTPUT@'
3261 ],
3262 depend_files: tracetool_depends)
3263 endforeach
3264 endif
3265 endforeach
3266 endforeach
3267
3268 # Other build targets
3269
3270 if 'CONFIG_PLUGIN' in config_host
3271 install_headers('include/qemu/qemu-plugin.h')
3272 endif
3273
3274 subdir('qga')
3275
3276 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3277 # when we don't build tools or system
3278 if xkbcommon.found()
3279 # used for the update-keymaps target, so include rules even if !have_tools
3280 qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3281 dependencies: [qemuutil, xkbcommon], install: have_tools)
3282 endif
3283
3284 if have_tools
3285 qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3286 dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3287 qemu_io = executable('qemu-io', files('qemu-io.c'),
3288 dependencies: [block, qemuutil], install: true)
3289 qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3290 dependencies: [blockdev, qemuutil, gnutls, selinux],
3291 install: true)
3292
3293 subdir('storage-daemon')
3294 subdir('contrib/rdmacm-mux')
3295 subdir('contrib/elf2dmp')
3296
3297 executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3298 dependencies: qemuutil,
3299 install: true)
3300
3301 if 'CONFIG_VHOST_USER' in config_host
3302 subdir('contrib/vhost-user-blk')
3303 subdir('contrib/vhost-user-gpu')
3304 subdir('contrib/vhost-user-input')
3305 subdir('contrib/vhost-user-scsi')
3306 endif
3307
3308 if targetos == 'linux'
3309 executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3310 dependencies: [qemuutil, libcap_ng],
3311 install: true,
3312 install_dir: get_option('libexecdir'))
3313
3314 executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3315 dependencies: [authz, crypto, io, qom, qemuutil,
3316 libcap_ng, mpathpersist],
3317 install: true)
3318 endif
3319
3320 if have_ivshmem
3321 subdir('contrib/ivshmem-client')
3322 subdir('contrib/ivshmem-server')
3323 endif
3324 endif
3325
3326 subdir('scripts')
3327 subdir('tools')
3328 subdir('pc-bios')
3329 subdir('docs')
3330 subdir('tests')
3331 if gtk.found()
3332 subdir('po')
3333 endif
3334
3335 if host_machine.system() == 'windows'
3336 nsis_cmd = [
3337 find_program('scripts/nsis.py'),
3338 '@OUTPUT@',
3339 get_option('prefix'),
3340 meson.current_source_dir(),
3341 host_machine.cpu(),
3342 '--',
3343 '-DDISPLAYVERSION=' + meson.project_version(),
3344 ]
3345 if build_docs
3346 nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3347 endif
3348 if gtk.found()
3349 nsis_cmd += '-DCONFIG_GTK=y'
3350 endif
3351
3352 nsis = custom_target('nsis',
3353 output: 'qemu-setup-' + meson.project_version() + '.exe',
3354 input: files('qemu.nsi'),
3355 build_always_stale: true,
3356 command: nsis_cmd + ['@INPUT@'])
3357 alias_target('installer', nsis)
3358 endif
3359
3360 #########################
3361 # Configuration summary #
3362 #########################
3363
3364 # Directories
3365 summary_info = {}
3366 summary_info += {'Install prefix': get_option('prefix')}
3367 summary_info += {'BIOS directory': qemu_datadir}
3368 summary_info += {'firmware path': get_option('qemu_firmwarepath')}
3369 summary_info += {'binary directory': get_option('bindir')}
3370 summary_info += {'library directory': get_option('libdir')}
3371 summary_info += {'module directory': qemu_moddir}
3372 summary_info += {'libexec directory': get_option('libexecdir')}
3373 summary_info += {'include directory': get_option('includedir')}
3374 summary_info += {'config directory': get_option('sysconfdir')}
3375 if targetos != 'windows'
3376 summary_info += {'local state directory': get_option('localstatedir')}
3377 summary_info += {'Manual directory': get_option('mandir')}
3378 else
3379 summary_info += {'local state directory': 'queried at runtime'}
3380 endif
3381 summary_info += {'Doc directory': get_option('docdir')}
3382 summary_info += {'Build directory': meson.current_build_dir()}
3383 summary_info += {'Source path': meson.current_source_dir()}
3384 summary_info += {'GIT submodules': config_host['GIT_SUBMODULES']}
3385 summary(summary_info, bool_yn: true, section: 'Directories')
3386
3387 # Host binaries
3388 summary_info = {}
3389 summary_info += {'git': config_host['GIT']}
3390 summary_info += {'make': config_host['MAKE']}
3391 summary_info += {'python': '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
3392 summary_info += {'sphinx-build': sphinx_build}
3393 if config_host.has_key('HAVE_GDB_BIN')
3394 summary_info += {'gdb': config_host['HAVE_GDB_BIN']}
3395 endif
3396 if get_option('iasl') != ''
3397 summary_info += {'iasl': get_option('iasl')}
3398 else
3399 summary_info += {'iasl': false}
3400 endif
3401 summary_info += {'genisoimage': config_host['GENISOIMAGE']}
3402 if targetos == 'windows' and have_ga
3403 summary_info += {'wixl': wixl}
3404 endif
3405 if slirp_opt != 'disabled' and have_system
3406 summary_info += {'smbd': have_slirp_smbd ? smbd_path : false}
3407 endif
3408 summary(summary_info, bool_yn: true, section: 'Host binaries')
3409
3410 # Configurable features
3411 summary_info = {}
3412 summary_info += {'Documentation': build_docs}
3413 summary_info += {'system-mode emulation': have_system}
3414 summary_info += {'user-mode emulation': have_user}
3415 summary_info += {'block layer': have_block}
3416 summary_info += {'Install blobs': get_option('install_blobs')}
3417 summary_info += {'module support': config_host.has_key('CONFIG_MODULES')}
3418 if config_host.has_key('CONFIG_MODULES')
3419 summary_info += {'alternative module path': config_host.has_key('CONFIG_MODULE_UPGRADES')}
3420 endif
3421 summary_info += {'fuzzing support': get_option('fuzzing')}
3422 if have_system
3423 summary_info += {'Audio drivers': ' '.join(audio_drivers_selected)}
3424 endif
3425 summary_info += {'Trace backends': ','.join(get_option('trace_backends'))}
3426 if 'simple' in get_option('trace_backends')
3427 summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
3428 endif
3429 summary_info += {'D-Bus display': dbus_display}
3430 summary_info += {'QOM debugging': get_option('qom_cast_debug')}
3431 summary_info += {'vhost-kernel support': config_host.has_key('CONFIG_VHOST_KERNEL')}
3432 summary_info += {'vhost-net support': config_host.has_key('CONFIG_VHOST_NET')}
3433 summary_info += {'vhost-crypto support': config_host.has_key('CONFIG_VHOST_CRYPTO')}
3434 summary_info += {'vhost-scsi support': config_host.has_key('CONFIG_VHOST_SCSI')}
3435 summary_info += {'vhost-vsock support': config_host.has_key('CONFIG_VHOST_VSOCK')}
3436 summary_info += {'vhost-user support': config_host.has_key('CONFIG_VHOST_USER')}
3437 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
3438 summary_info += {'vhost-user-fs support': config_host.has_key('CONFIG_VHOST_USER_FS')}
3439 summary_info += {'vhost-vdpa support': config_host.has_key('CONFIG_VHOST_VDPA')}
3440 summary_info += {'build guest agent': have_ga}
3441 summary(summary_info, bool_yn: true, section: 'Configurable features')
3442
3443 # Compilation information
3444 summary_info = {}
3445 summary_info += {'host CPU': cpu}
3446 summary_info += {'host endianness': build_machine.endian()}
3447 summary_info += {'C compiler': ' '.join(meson.get_compiler('c').cmd_array())}
3448 summary_info += {'Host C compiler': ' '.join(meson.get_compiler('c', native: true).cmd_array())}
3449 if link_language == 'cpp'
3450 summary_info += {'C++ compiler': ' '.join(meson.get_compiler('cpp').cmd_array())}
3451 else
3452 summary_info += {'C++ compiler': false}
3453 endif
3454 if targetos == 'darwin'
3455 summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
3456 endif
3457 summary_info += {'CFLAGS': ' '.join(get_option('c_args')
3458 + ['-O' + get_option('optimization')]
3459 + (get_option('debug') ? ['-g'] : []))}
3460 if link_language == 'cpp'
3461 summary_info += {'CXXFLAGS': ' '.join(get_option('cpp_args')
3462 + ['-O' + get_option('optimization')]
3463 + (get_option('debug') ? ['-g'] : []))}
3464 endif
3465 link_args = get_option(link_language + '_link_args')
3466 if link_args.length() > 0
3467 summary_info += {'LDFLAGS': ' '.join(link_args)}
3468 endif
3469 summary_info += {'QEMU_CFLAGS': config_host['QEMU_CFLAGS']}
3470 summary_info += {'QEMU_LDFLAGS': config_host['QEMU_LDFLAGS']}
3471 summary_info += {'profiler': get_option('profiler')}
3472 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
3473 summary_info += {'PIE': get_option('b_pie')}
3474 summary_info += {'static build': config_host.has_key('CONFIG_STATIC')}
3475 summary_info += {'malloc trim support': has_malloc_trim}
3476 summary_info += {'membarrier': have_membarrier}
3477 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
3478 summary_info += {'mutex debugging': get_option('debug_mutex')}
3479 summary_info += {'memory allocator': get_option('malloc')}
3480 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
3481 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
3482 summary_info += {'gprof enabled': get_option('gprof')}
3483 summary_info += {'gcov': get_option('b_coverage')}
3484 summary_info += {'thread sanitizer': config_host.has_key('CONFIG_TSAN')}
3485 summary_info += {'CFI support': get_option('cfi')}
3486 if get_option('cfi')
3487 summary_info += {'CFI debug support': get_option('cfi_debug')}
3488 endif
3489 summary_info += {'strip binaries': get_option('strip')}
3490 summary_info += {'sparse': sparse}
3491 summary_info += {'mingw32 support': targetos == 'windows'}
3492
3493 # snarf the cross-compilation information for tests
3494 foreach target: target_dirs
3495 tcg_mak = meson.current_build_dir() / 'tests/tcg' / 'config-' + target + '.mak'
3496 if fs.exists(tcg_mak)
3497 config_cross_tcg = keyval.load(tcg_mak)
3498 target = config_cross_tcg['TARGET_NAME']
3499 compiler = ''
3500 if 'DOCKER_CROSS_CC_GUEST' in config_cross_tcg
3501 summary_info += {target + ' tests': config_cross_tcg['DOCKER_CROSS_CC_GUEST'] +
3502 ' via ' + config_cross_tcg['DOCKER_IMAGE']}
3503 elif 'CROSS_CC_GUEST' in config_cross_tcg
3504 summary_info += {target + ' tests'
3505 : config_cross_tcg['CROSS_CC_GUEST'] }
3506 endif
3507 endif
3508 endforeach
3509
3510 summary(summary_info, bool_yn: true, section: 'Compilation')
3511
3512 # Targets and accelerators
3513 summary_info = {}
3514 if have_system
3515 summary_info += {'KVM support': config_all.has_key('CONFIG_KVM')}
3516 summary_info += {'HAX support': config_all.has_key('CONFIG_HAX')}
3517 summary_info += {'HVF support': config_all.has_key('CONFIG_HVF')}
3518 summary_info += {'WHPX support': config_all.has_key('CONFIG_WHPX')}
3519 summary_info += {'NVMM support': config_all.has_key('CONFIG_NVMM')}
3520 summary_info += {'Xen support': config_host.has_key('CONFIG_XEN_BACKEND')}
3521 if config_host.has_key('CONFIG_XEN_BACKEND')
3522 summary_info += {'xen ctrl version': config_host['CONFIG_XEN_CTRL_INTERFACE_VERSION']}
3523 endif
3524 endif
3525 summary_info += {'TCG support': config_all.has_key('CONFIG_TCG')}
3526 if config_all.has_key('CONFIG_TCG')
3527 if get_option('tcg_interpreter')
3528 summary_info += {'TCG backend': 'TCI (TCG with bytecode interpreter, slow)'}
3529 else
3530 summary_info += {'TCG backend': 'native (@0@)'.format(cpu)}
3531 endif
3532 summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
3533 summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
3534 endif
3535 summary_info += {'target list': ' '.join(target_dirs)}
3536 if have_system
3537 summary_info += {'default devices': get_option('default_devices')}
3538 summary_info += {'out of process emulation': multiprocess_allowed}
3539 endif
3540 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
3541
3542 # Block layer
3543 summary_info = {}
3544 summary_info += {'coroutine backend': config_host['CONFIG_COROUTINE_BACKEND']}
3545 summary_info += {'coroutine pool': have_coroutine_pool}
3546 if have_block
3547 summary_info += {'Block whitelist (rw)': config_host['CONFIG_BDRV_RW_WHITELIST']}
3548 summary_info += {'Block whitelist (ro)': config_host['CONFIG_BDRV_RO_WHITELIST']}
3549 summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
3550 summary_info += {'VirtFS support': have_virtfs}
3551 summary_info += {'build virtiofs daemon': have_virtiofsd}
3552 summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
3553 summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
3554 summary_info += {'bochs support': get_option('bochs').allowed()}
3555 summary_info += {'cloop support': get_option('cloop').allowed()}
3556 summary_info += {'dmg support': get_option('dmg').allowed()}
3557 summary_info += {'qcow v1 support': get_option('qcow1').allowed()}
3558 summary_info += {'vdi support': get_option('vdi').allowed()}
3559 summary_info += {'vvfat support': get_option('vvfat').allowed()}
3560 summary_info += {'qed support': get_option('qed').allowed()}
3561 summary_info += {'parallels support': get_option('parallels').allowed()}
3562 summary_info += {'FUSE exports': fuse}
3563 endif
3564 summary(summary_info, bool_yn: true, section: 'Block layer support')
3565
3566 # Crypto
3567 summary_info = {}
3568 summary_info += {'TLS priority': config_host['CONFIG_TLS_PRIORITY']}
3569 summary_info += {'GNUTLS support': gnutls}
3570 if gnutls.found()
3571 summary_info += {' GNUTLS crypto': gnutls_crypto.found()}
3572 endif
3573 summary_info += {'libgcrypt': gcrypt}
3574 summary_info += {'nettle': nettle}
3575 if nettle.found()
3576 summary_info += {' XTS': xts != 'private'}
3577 endif
3578 summary_info += {'AF_ALG support': have_afalg}
3579 summary_info += {'rng-none': get_option('rng_none')}
3580 summary_info += {'Linux keyring': config_host.has_key('CONFIG_SECRET_KEYRING')}
3581 summary(summary_info, bool_yn: true, section: 'Crypto')
3582
3583 # Libraries
3584 summary_info = {}
3585 if targetos == 'darwin'
3586 summary_info += {'Cocoa support': cocoa}
3587 endif
3588 summary_info += {'SDL support': sdl}
3589 summary_info += {'SDL image support': sdl_image}
3590 summary_info += {'GTK support': gtk}
3591 summary_info += {'pixman': pixman}
3592 summary_info += {'VTE support': vte}
3593 summary_info += {'slirp support': slirp_opt == 'internal' ? slirp_opt : slirp}
3594 summary_info += {'libtasn1': tasn1}
3595 summary_info += {'PAM': pam}
3596 summary_info += {'iconv support': iconv}
3597 summary_info += {'curses support': curses}
3598 summary_info += {'virgl support': virgl}
3599 summary_info += {'curl support': curl}
3600 summary_info += {'Multipath support': mpathpersist}
3601 summary_info += {'VNC support': vnc}
3602 if vnc.found()
3603 summary_info += {'VNC SASL support': sasl}
3604 summary_info += {'VNC JPEG support': jpeg}
3605 summary_info += {'VNC PNG support': png}
3606 endif
3607 if targetos not in ['darwin', 'haiku', 'windows']
3608 summary_info += {'OSS support': oss}
3609 elif targetos == 'darwin'
3610 summary_info += {'CoreAudio support': coreaudio}
3611 elif targetos == 'windows'
3612 summary_info += {'DirectSound support': dsound}
3613 endif
3614 if targetos == 'linux'
3615 summary_info += {'ALSA support': alsa}
3616 summary_info += {'PulseAudio support': pulse}
3617 endif
3618 summary_info += {'JACK support': jack}
3619 summary_info += {'brlapi support': brlapi}
3620 summary_info += {'vde support': vde}
3621 summary_info += {'netmap support': have_netmap}
3622 summary_info += {'l2tpv3 support': have_l2tpv3}
3623 summary_info += {'Linux AIO support': libaio}
3624 summary_info += {'Linux io_uring support': linux_io_uring}
3625 summary_info += {'ATTR/XATTR support': libattr}
3626 summary_info += {'RDMA support': config_host.has_key('CONFIG_RDMA')}
3627 summary_info += {'PVRDMA support': config_host.has_key('CONFIG_PVRDMA')}
3628 summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt}
3629 summary_info += {'libcap-ng support': libcap_ng}
3630 summary_info += {'bpf support': libbpf}
3631 summary_info += {'spice protocol support': spice_protocol}
3632 if spice_protocol.found()
3633 summary_info += {' spice server support': spice}
3634 endif
3635 summary_info += {'rbd support': rbd}
3636 summary_info += {'smartcard support': cacard}
3637 summary_info += {'U2F support': u2f}
3638 summary_info += {'libusb': libusb}
3639 summary_info += {'usb net redir': usbredir}
3640 summary_info += {'OpenGL support': config_host.has_key('CONFIG_OPENGL')}
3641 summary_info += {'GBM': gbm}
3642 summary_info += {'libiscsi support': libiscsi}
3643 summary_info += {'libnfs support': libnfs}
3644 if targetos == 'windows'
3645 if have_ga
3646 summary_info += {'QGA VSS support': have_qga_vss}
3647 summary_info += {'QGA w32 disk info': have_ntddscsi}
3648 endif
3649 endif
3650 summary_info += {'seccomp support': seccomp}
3651 summary_info += {'GlusterFS support': glusterfs}
3652 summary_info += {'TPM support': have_tpm}
3653 summary_info += {'libssh support': libssh}
3654 summary_info += {'lzo support': lzo}
3655 summary_info += {'snappy support': snappy}
3656 summary_info += {'bzip2 support': libbzip2}
3657 summary_info += {'lzfse support': liblzfse}
3658 summary_info += {'zstd support': zstd}
3659 summary_info += {'NUMA host support': numa}
3660 summary_info += {'capstone': capstone_opt == 'internal' ? capstone_opt : capstone}
3661 summary_info += {'libpmem support': libpmem}
3662 summary_info += {'libdaxctl support': libdaxctl}
3663 summary_info += {'libudev': libudev}
3664 # Dummy dependency, keep .found()
3665 summary_info += {'FUSE lseek': fuse_lseek.found()}
3666 summary_info += {'selinux': selinux}
3667 summary(summary_info, bool_yn: true, section: 'Dependencies')
3668
3669 if not supported_cpus.contains(cpu)
3670 message()
3671 warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
3672 message()
3673 message('CPU host architecture ' + cpu + ' support is not currently maintained.')
3674 message('The QEMU project intends to remove support for this host CPU in')
3675 message('a future release if nobody volunteers to maintain it and to')
3676 message('provide a build host for our continuous integration setup.')
3677 message('configure has succeeded and you can continue to build, but')
3678 message('if you care about QEMU on this platform you should contact')
3679 message('us upstream at qemu-devel@nongnu.org.')
3680 endif
3681
3682 if not supported_oses.contains(targetos)
3683 message()
3684 warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
3685 message()
3686 message('Host OS ' + targetos + 'support is not currently maintained.')
3687 message('The QEMU project intends to remove support for this host OS in')
3688 message('a future release if nobody volunteers to maintain it and to')
3689 message('provide a build host for our continuous integration setup.')
3690 message('configure has succeeded and you can continue to build, but')
3691 message('if you care about QEMU on this platform you should contact')
3692 message('us upstream at qemu-devel@nongnu.org.')
3693 endif