xref: /openbmc/qemu/meson.build (revision d2dfe0b5)
1project('qemu', ['c'], meson_version: '>=0.63.0',
2        default_options: ['warning_level=1', 'c_std=gnu11', 'cpp_std=gnu++11', 'b_colorout=auto',
3                          'b_staticpic=false', 'stdsplit=false', 'optimization=2', 'b_pie=true'],
4        version: files('VERSION'))
5
6add_test_setup('quick', exclude_suites: ['slow', 'thorough'], is_default: true)
7add_test_setup('slow', exclude_suites: ['thorough'], env: ['G_TEST_SLOW=1', 'SPEED=slow'])
8add_test_setup('thorough', env: ['G_TEST_SLOW=1', 'SPEED=thorough'])
9
10meson.add_postconf_script(find_program('scripts/symlink-install-tree.py'))
11
12not_found = dependency('', required: false)
13keyval = import('keyval')
14ss = import('sourceset')
15fs = import('fs')
16
17targetos = host_machine.system()
18sh = find_program('sh')
19config_host = keyval.load(meson.current_build_dir() / 'config-host.mak')
20
21cc = meson.get_compiler('c')
22all_languages = ['c']
23if add_languages('cpp', required: false, native: false)
24  all_languages += ['cpp']
25  cxx = meson.get_compiler('cpp')
26endif
27if targetos == 'darwin' and \
28   add_languages('objc', required: get_option('cocoa'), native: false)
29  all_languages += ['objc']
30  objc = meson.get_compiler('objc')
31endif
32
33# Temporary directory used for files created while
34# configure runs. Since it is in the build directory
35# we can safely blow away any previous version of it
36# (and we need not jump through hoops to try to delete
37# it when configure exits.)
38tmpdir = meson.current_build_dir() / 'meson-private/temp'
39
40if get_option('qemu_suffix').startswith('/')
41  error('qemu_suffix cannot start with a /')
42endif
43
44qemu_confdir = get_option('sysconfdir') / get_option('qemu_suffix')
45qemu_datadir = get_option('datadir') / get_option('qemu_suffix')
46qemu_docdir = get_option('docdir') / get_option('qemu_suffix')
47qemu_moddir = get_option('libdir') / get_option('qemu_suffix')
48
49qemu_desktopdir = get_option('datadir') / 'applications'
50qemu_icondir = get_option('datadir') / 'icons'
51
52config_host_data = configuration_data()
53genh = []
54qapi_trace_events = []
55
56bsd_oses = ['gnu/kfreebsd', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'darwin']
57supported_oses = ['windows', 'freebsd', 'netbsd', 'openbsd', 'darwin', 'sunos', 'linux']
58supported_cpus = ['ppc', 'ppc64', 's390x', 'riscv', 'x86', 'x86_64',
59  'arm', 'aarch64', 'loongarch64', 'mips', 'mips64', 'sparc64']
60
61cpu = host_machine.cpu_family()
62
63# Unify riscv* to a single family.
64if cpu in ['riscv32', 'riscv64']
65  cpu = 'riscv'
66endif
67
68target_dirs = config_host['TARGET_DIRS'].split()
69have_linux_user = false
70have_bsd_user = false
71have_system = false
72foreach target : target_dirs
73  have_linux_user = have_linux_user or target.endswith('linux-user')
74  have_bsd_user = have_bsd_user or target.endswith('bsd-user')
75  have_system = have_system or target.endswith('-softmmu')
76endforeach
77have_user = have_linux_user or have_bsd_user
78have_tools = get_option('tools') \
79  .disable_auto_if(not have_system) \
80  .allowed()
81have_ga = get_option('guest_agent') \
82  .disable_auto_if(not have_system and not have_tools) \
83  .require(targetos in ['sunos', 'linux', 'windows', 'freebsd', 'netbsd', 'openbsd'],
84           error_message: 'unsupported OS for QEMU guest agent') \
85  .allowed()
86enable_modules = get_option('modules') \
87  .require(targetos != 'windows',
88           error_message: 'Modules are not available for Windows') \
89  .require(not get_option('prefer_static'),
90           error_message: 'Modules are incompatible with static linking') \
91  .allowed()
92have_block = have_system or have_tools
93
94python = import('python').find_installation()
95
96if cpu not in supported_cpus
97  host_arch = 'unknown'
98elif cpu == 'x86'
99  host_arch = 'i386'
100elif cpu == 'mips64'
101  host_arch = 'mips'
102else
103  host_arch = cpu
104endif
105
106if cpu in ['x86', 'x86_64']
107  kvm_targets = ['i386-softmmu', 'x86_64-softmmu']
108elif cpu == 'aarch64'
109  kvm_targets = ['aarch64-softmmu']
110elif cpu == 's390x'
111  kvm_targets = ['s390x-softmmu']
112elif cpu in ['ppc', 'ppc64']
113  kvm_targets = ['ppc-softmmu', 'ppc64-softmmu']
114elif cpu in ['mips', 'mips64']
115  kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu']
116elif cpu in ['riscv']
117  kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu']
118else
119  kvm_targets = []
120endif
121
122kvm_targets_c = '""'
123if get_option('kvm').allowed() and targetos == 'linux'
124  kvm_targets_c = '"' + '" ,"'.join(kvm_targets) + '"'
125endif
126config_host_data.set('CONFIG_KVM_TARGETS', kvm_targets_c)
127
128accelerator_targets = { 'CONFIG_KVM': kvm_targets }
129
130if cpu in ['aarch64']
131  accelerator_targets += {
132    'CONFIG_HVF': ['aarch64-softmmu']
133  }
134endif
135
136if cpu in ['x86', 'x86_64', 'arm', 'aarch64']
137  # i386 emulator provides xenpv machine type for multiple architectures
138  accelerator_targets += {
139    'CONFIG_XEN': ['i386-softmmu', 'x86_64-softmmu'],
140  }
141endif
142if cpu in ['x86', 'x86_64']
143  accelerator_targets += {
144    'CONFIG_HAX': ['i386-softmmu', 'x86_64-softmmu'],
145    'CONFIG_HVF': ['x86_64-softmmu'],
146    'CONFIG_NVMM': ['i386-softmmu', 'x86_64-softmmu'],
147    'CONFIG_WHPX': ['i386-softmmu', 'x86_64-softmmu'],
148  }
149endif
150
151modular_tcg = []
152# Darwin does not support references to thread-local variables in modules
153if targetos != 'darwin'
154  modular_tcg = ['i386-softmmu', 'x86_64-softmmu']
155endif
156
157edk2_targets = [ 'arm-softmmu', 'aarch64-softmmu', 'i386-softmmu', 'x86_64-softmmu' ]
158unpack_edk2_blobs = false
159foreach target : edk2_targets
160  if target in target_dirs
161    bzip2 = find_program('bzip2', required: get_option('install_blobs'))
162    unpack_edk2_blobs = bzip2.found()
163    break
164  endif
165endforeach
166
167dtrace = not_found
168stap = not_found
169if 'dtrace' in get_option('trace_backends')
170  dtrace = find_program('dtrace', required: true)
171  stap = find_program('stap', required: false)
172  if stap.found()
173    # Workaround to avoid dtrace(1) producing a file with 'hidden' symbol
174    # visibility. Define STAP_SDT_V2 to produce 'default' symbol visibility
175    # instead. QEMU --enable-modules depends on this because the SystemTap
176    # semaphores are linked into the main binary and not the module's shared
177    # object.
178    add_global_arguments('-DSTAP_SDT_V2',
179                         native: false, language: all_languages)
180  endif
181endif
182
183if get_option('iasl') == ''
184  iasl = find_program('iasl', required: false)
185else
186  iasl = find_program(get_option('iasl'), required: true)
187endif
188
189##################
190# Compiler flags #
191##################
192
193foreach lang : all_languages
194  compiler = meson.get_compiler(lang)
195  if compiler.get_id() == 'gcc' and compiler.version().version_compare('>=7.4')
196    # ok
197  elif compiler.get_id() == 'clang' and compiler.compiles('''
198      #ifdef __apple_build_version__
199      # if __clang_major__ < 12 || (__clang_major__ == 12 && __clang_minor__ < 0)
200      #  error You need at least XCode Clang v12.0 to compile QEMU
201      # endif
202      #else
203      # if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)
204      #  error You need at least Clang v10.0 to compile QEMU
205      # endif
206      #endif''')
207    # ok
208  else
209    error('You either need GCC v7.4 or Clang v10.0 (or XCode Clang v12.0) to compile QEMU')
210  endif
211endforeach
212
213# default flags for all hosts
214# We use -fwrapv to tell the compiler that we require a C dialect where
215# left shift of signed integers is well defined and has the expected
216# 2s-complement style results. (Both clang and gcc agree that it
217# provides these semantics.)
218
219qemu_common_flags = [
220  '-D_GNU_SOURCE', '-D_FILE_OFFSET_BITS=64', '-D_LARGEFILE_SOURCE',
221  '-fno-strict-aliasing', '-fno-common', '-fwrapv' ]
222qemu_cflags = []
223qemu_ldflags = []
224
225if targetos == 'darwin'
226  # Disable attempts to use ObjectiveC features in os/object.h since they
227  # won't work when we're compiling with gcc as a C compiler.
228  qemu_common_flags += '-DOS_OBJECT_USE_OBJC=0'
229elif targetos == 'solaris'
230  # needed for CMSG_ macros in sys/socket.h
231  qemu_common_flags += '-D_XOPEN_SOURCE=600'
232  # needed for TIOCWIN* defines in termios.h
233  qemu_common_flags += '-D__EXTENSIONS__'
234elif targetos == 'haiku'
235  qemu_common_flags += ['-DB_USE_POSITIVE_POSIX_ERRORS', '-D_BSD_SOURCE', '-fPIC']
236endif
237
238# __sync_fetch_and_and requires at least -march=i486. Many toolchains
239# use i686 as default anyway, but for those that don't, an explicit
240# specification is necessary
241if host_arch == 'i386' and not cc.links('''
242  static int sfaa(int *ptr)
243  {
244    return __sync_fetch_and_and(ptr, 0);
245  }
246
247  int main(void)
248  {
249    int val = 42;
250    val = __sync_val_compare_and_swap(&val, 0, 1);
251    sfaa(&val);
252    return val;
253  }''')
254  qemu_common_flags = ['-march=i486'] + qemu_common_flags
255endif
256
257if get_option('gprof')
258  qemu_common_flags += ['-p']
259  qemu_ldflags += ['-p']
260endif
261
262if get_option('prefer_static')
263  qemu_ldflags += get_option('b_pie') ? '-static-pie' : '-static'
264endif
265
266# Meson currently only handles pie as a boolean for now, so if the user
267# has explicitly disabled PIE we need to extend our cflags.
268#
269# -no-pie is supposedly a linker flag that has no effect on the compiler
270# command line, but some distros, that didn't quite know what they were
271# doing, made local changes to gcc's specs file that turned it into
272# a compiler command-line flag.
273#
274# What about linker flags?  For a static build, no PIE is implied by -static
275# which we added above (and if it's not because of the same specs patching,
276# there's nothing we can do: compilation will fail, report a bug to your
277# distro and do not use --disable-pie in the meanwhile).  For dynamic linking,
278# instead, we can't add -no-pie because it overrides -shared: the linker then
279# tries to build an executable instead of a shared library and fails.  So
280# don't add -no-pie anywhere and cross fingers. :(
281if not get_option('b_pie')
282  qemu_common_flags += cc.get_supported_arguments('-fno-pie', '-no-pie')
283endif
284
285if not get_option('stack_protector').disabled()
286  stack_protector_probe = '''
287    int main(int argc, char *argv[])
288    {
289      char arr[64], *p = arr, *c = argv[argc - 1];
290      while (*c) {
291          *p++ = *c++;
292      }
293      return 0;
294    }'''
295  have_stack_protector = false
296  foreach arg : ['-fstack-protector-strong', '-fstack-protector-all']
297    # We need to check both a compile and a link, since some compiler
298    # setups fail only on a .c->.o compile and some only at link time
299    if cc.compiles(stack_protector_probe, args: ['-Werror', arg]) and \
300       cc.links(stack_protector_probe, args: ['-Werror', arg])
301      have_stack_protector = true
302      qemu_cflags += arg
303      qemu_ldflags += arg
304      break
305    endif
306  endforeach
307  get_option('stack_protector') \
308    .require(have_stack_protector, error_message: 'Stack protector not supported')
309endif
310
311coroutine_backend = get_option('coroutine_backend')
312ucontext_probe = '''
313  #include <ucontext.h>
314  #ifdef __stub_makecontext
315  #error Ignoring glibc stub makecontext which will always fail
316  #endif
317  int main(void) { makecontext(0, 0, 0); return 0; }'''
318
319# On Windows the only valid backend is the Windows specific one.
320# For POSIX prefer ucontext, but it's not always possible. The fallback
321# is sigcontext.
322supported_backends = []
323if targetos == 'windows'
324  supported_backends += ['windows']
325else
326  if targetos != 'darwin' and cc.links(ucontext_probe)
327    supported_backends += ['ucontext']
328  endif
329  supported_backends += ['sigaltstack']
330endif
331
332if coroutine_backend == 'auto'
333  coroutine_backend = supported_backends[0]
334elif coroutine_backend not in supported_backends
335  error('"@0@" backend requested but not available.  Available backends: @1@' \
336        .format(coroutine_backend, ', '.join(supported_backends)))
337endif
338
339# Compiles if SafeStack *not* enabled
340safe_stack_probe = '''
341  int main(void)
342  {
343  #if defined(__has_feature)
344  #if __has_feature(safe_stack)
345  #error SafeStack Enabled
346  #endif
347  #endif
348      return 0;
349  }'''
350if get_option('safe_stack') != not cc.compiles(safe_stack_probe)
351  safe_stack_arg = get_option('safe_stack') ? '-fsanitize=safe-stack' : '-fno-sanitize=safe-stack'
352  if get_option('safe_stack') != not cc.compiles(safe_stack_probe, args: safe_stack_arg)
353    error(get_option('safe_stack') \
354          ? 'SafeStack not supported by your compiler' \
355          : 'Cannot disable SafeStack')
356  endif
357  qemu_cflags += safe_stack_arg
358  qemu_ldflags += safe_stack_arg
359endif
360if get_option('safe_stack') and coroutine_backend != 'ucontext'
361  error('SafeStack is only supported with the ucontext coroutine backend')
362endif
363
364if get_option('sanitizers')
365  if cc.has_argument('-fsanitize=address')
366    qemu_cflags = ['-fsanitize=address'] + qemu_cflags
367    qemu_ldflags = ['-fsanitize=address'] + qemu_ldflags
368  endif
369
370  # Detect static linking issue with ubsan - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84285
371  if cc.links('int main(int argc, char **argv) { return argc + 1; }',
372              args: [qemu_ldflags, '-fsanitize=undefined'])
373    qemu_cflags = ['-fsanitize=undefined'] + qemu_cflags
374    qemu_ldflags = ['-fsanitize=undefined'] + qemu_ldflags
375  endif
376endif
377
378# Thread sanitizer is, for now, much noisier than the other sanitizers;
379# keep it separate until that is not the case.
380if get_option('tsan')
381  if get_option('sanitizers')
382    error('TSAN is not supported with other sanitizers')
383  endif
384  if not cc.has_function('__tsan_create_fiber',
385                         args: '-fsanitize=thread',
386                         prefix: '#include <sanitizer/tsan_interface.h>')
387    error('Cannot enable TSAN due to missing fiber annotation interface')
388  endif
389  qemu_cflags = ['-fsanitize=thread'] + qemu_cflags
390  qemu_ldflags = ['-fsanitize=thread'] + qemu_ldflags
391endif
392
393# Detect support for PT_GNU_RELRO + DT_BIND_NOW.
394# The combination is known as "full relro", because .got.plt is read-only too.
395qemu_ldflags += cc.get_supported_link_arguments('-Wl,-z,relro', '-Wl,-z,now')
396
397if targetos == 'windows'
398  qemu_ldflags += cc.get_supported_link_arguments('-Wl,--no-seh', '-Wl,--nxcompat')
399  qemu_ldflags += cc.get_supported_link_arguments('-Wl,--dynamicbase', '-Wl,--high-entropy-va')
400endif
401
402# Exclude --warn-common with TSan to suppress warnings from the TSan libraries.
403if targetos != 'sunos' and not get_option('tsan')
404  qemu_ldflags += cc.get_supported_link_arguments('-Wl,--warn-common')
405endif
406
407if get_option('fuzzing')
408  # Specify a filter to only instrument code that is directly related to
409  # virtual-devices.
410  configure_file(output: 'instrumentation-filter',
411                 input: 'scripts/oss-fuzz/instrumentation-filter-template',
412                 copy: true)
413
414  if cc.compiles('int main () { return 0; }',
415                  name: '-fsanitize-coverage-allowlist=/dev/null',
416                 args: ['-fsanitize-coverage-allowlist=/dev/null',
417                        '-fsanitize-coverage=trace-pc'] )
418    qemu_common_flags += ['-fsanitize-coverage-allowlist=instrumentation-filter']
419  endif
420
421  if get_option('fuzzing_engine') == ''
422    # Add CFLAGS to tell clang to add fuzzer-related instrumentation to all the
423    # compiled code.  To build non-fuzzer binaries with --enable-fuzzing, link
424    # everything with fsanitize=fuzzer-no-link. Otherwise, the linker will be
425    # unable to bind the fuzzer-related callbacks added by instrumentation.
426    qemu_common_flags += ['-fsanitize=fuzzer-no-link']
427    qemu_ldflags += ['-fsanitize=fuzzer-no-link']
428    # For the actual fuzzer binaries, we need to link against the libfuzzer
429    # library. They need to be configurable, to support OSS-Fuzz
430    fuzz_exe_ldflags = ['-fsanitize=fuzzer']
431  else
432    # LIB_FUZZING_ENGINE was set; assume we are running on OSS-Fuzz, and
433    # the needed CFLAGS have already been provided
434    fuzz_exe_ldflags = get_option('fuzzing_engine').split()
435  endif
436endif
437
438add_global_arguments(qemu_common_flags, native: false, language: all_languages)
439add_global_link_arguments(qemu_ldflags, native: false, language: all_languages)
440
441# Collect warnings that we want to enable
442
443warn_flags = [
444  '-Wundef',
445  '-Wwrite-strings',
446  '-Wmissing-prototypes',
447  '-Wstrict-prototypes',
448  '-Wredundant-decls',
449  '-Wold-style-declaration',
450  '-Wold-style-definition',
451  '-Wtype-limits',
452  '-Wformat-security',
453  '-Wformat-y2k',
454  '-Winit-self',
455  '-Wignored-qualifiers',
456  '-Wempty-body',
457  '-Wnested-externs',
458  '-Wendif-labels',
459  '-Wexpansion-to-defined',
460  '-Wimplicit-fallthrough=2',
461  '-Wmissing-format-attribute',
462  '-Wno-initializer-overrides',
463  '-Wno-missing-include-dirs',
464  '-Wno-shift-negative-value',
465  '-Wno-string-plus-int',
466  '-Wno-typedef-redefinition',
467  '-Wno-tautological-type-limit-compare',
468  '-Wno-psabi',
469  '-Wno-gnu-variable-sized-type-not-at-end',
470]
471
472if targetos != 'darwin'
473  warn_flags += ['-Wthread-safety']
474endif
475
476# Check that the C++ compiler exists and works with the C compiler.
477link_language = 'c'
478linker = cc
479qemu_cxxflags = []
480if 'cpp' in all_languages
481  qemu_cxxflags = ['-D__STDC_LIMIT_MACROS', '-D__STDC_CONSTANT_MACROS', '-D__STDC_FORMAT_MACROS'] + qemu_cflags
482  if cxx.links(files('scripts/main.c'), args: qemu_cflags)
483    link_language = 'cpp'
484    linker = cxx
485  else
486    message('C++ compiler does not work with C compiler')
487    message('Disabling C++-specific optional code')
488  endif
489endif
490
491# clang does not support glibc + FORTIFY_SOURCE (is it still true?)
492if get_option('optimization') != '0' and targetos == 'linux'
493  if cc.get_id() == 'gcc'
494    qemu_cflags += ['-U_FORTIFY_SOURCE', '-D_FORTIFY_SOURCE=2']
495  endif
496  if 'cpp' in all_languages and cxx.get_id() == 'gcc'
497    qemu_cxxflags += ['-U_FORTIFY_SOURCE', '-D_FORTIFY_SOURCE=2']
498  endif
499endif
500
501add_project_arguments(qemu_cflags, native: false, language: 'c')
502add_project_arguments(cc.get_supported_arguments(warn_flags), native: false, language: 'c')
503if 'cpp' in all_languages
504  add_project_arguments(qemu_cxxflags, native: false, language: 'cpp')
505  add_project_arguments(cxx.get_supported_arguments(warn_flags), native: false, language: 'cpp')
506endif
507if 'objc' in all_languages
508  # Note sanitizer flags are not applied to Objective-C sources!
509  add_project_arguments(objc.get_supported_arguments(warn_flags), native: false, language: 'objc')
510endif
511if targetos == 'linux'
512  add_project_arguments('-isystem', meson.current_source_dir() / 'linux-headers',
513                        '-isystem', 'linux-headers',
514                        language: all_languages)
515endif
516
517add_project_arguments('-iquote', '.',
518                      '-iquote', meson.current_source_dir(),
519                      '-iquote', meson.current_source_dir() / 'include',
520                      language: all_languages)
521
522# If a host-specific include directory exists, list that first...
523host_include = meson.current_source_dir() / 'host/include/'
524if fs.is_dir(host_include / host_arch)
525  add_project_arguments('-iquote', host_include / host_arch,
526                        language: all_languages)
527endif
528# ... followed by the generic fallback.
529add_project_arguments('-iquote', host_include / 'generic',
530                      language: all_languages)
531
532sparse = find_program('cgcc', required: get_option('sparse'))
533if sparse.found()
534  run_target('sparse',
535             command: [find_program('scripts/check_sparse.py'),
536                       'compile_commands.json', sparse.full_path(), '-Wbitwise',
537                       '-Wno-transparent-union', '-Wno-old-initializer',
538                       '-Wno-non-pointer-null'])
539endif
540
541###########################################
542# Target-specific checks and dependencies #
543###########################################
544
545# Fuzzing
546if get_option('fuzzing') and get_option('fuzzing_engine') == '' and \
547    not cc.links('''
548          #include <stdint.h>
549          #include <sys/types.h>
550          int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
551          int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { return 0; }
552        ''',
553        args: ['-Werror', '-fsanitize=fuzzer'])
554  error('Your compiler does not support -fsanitize=fuzzer')
555endif
556
557# Tracing backends
558if 'ftrace' in get_option('trace_backends') and targetos != 'linux'
559  error('ftrace is supported only on Linux')
560endif
561if 'syslog' in get_option('trace_backends') and not cc.compiles('''
562    #include <syslog.h>
563    int main(void) {
564        openlog("qemu", LOG_PID, LOG_DAEMON);
565        syslog(LOG_INFO, "configure");
566        return 0;
567    }''')
568  error('syslog is not supported on this system')
569endif
570
571# Miscellaneous Linux-only features
572get_option('mpath') \
573  .require(targetos == 'linux', error_message: 'Multipath is supported only on Linux')
574
575multiprocess_allowed = get_option('multiprocess') \
576  .require(targetos == 'linux', error_message: 'Multiprocess QEMU is supported only on Linux') \
577  .allowed()
578
579vfio_user_server_allowed = get_option('vfio_user_server') \
580  .require(targetos == 'linux', error_message: 'vfio-user server is supported only on Linux') \
581  .allowed()
582
583have_tpm = get_option('tpm') \
584  .require(targetos != 'windows', error_message: 'TPM emulation only available on POSIX systems') \
585  .allowed()
586
587# vhost
588have_vhost_user = get_option('vhost_user') \
589  .disable_auto_if(targetos != 'linux') \
590  .require(targetos != 'windows',
591           error_message: 'vhost-user is not available on Windows').allowed()
592have_vhost_vdpa = get_option('vhost_vdpa') \
593  .require(targetos == 'linux',
594           error_message: 'vhost-vdpa is only available on Linux').allowed()
595have_vhost_kernel = get_option('vhost_kernel') \
596  .require(targetos == 'linux',
597           error_message: 'vhost-kernel is only available on Linux').allowed()
598have_vhost_user_crypto = get_option('vhost_crypto') \
599  .require(have_vhost_user,
600           error_message: 'vhost-crypto requires vhost-user to be enabled').allowed()
601
602have_vhost = have_vhost_user or have_vhost_vdpa or have_vhost_kernel
603
604have_vhost_net_user = have_vhost_user and get_option('vhost_net').allowed()
605have_vhost_net_vdpa = have_vhost_vdpa and get_option('vhost_net').allowed()
606have_vhost_net_kernel = have_vhost_kernel and get_option('vhost_net').allowed()
607have_vhost_net = have_vhost_net_kernel or have_vhost_net_user or have_vhost_net_vdpa
608
609# Target-specific libraries and flags
610libm = cc.find_library('m', required: false)
611threads = dependency('threads')
612util = cc.find_library('util', required: false)
613winmm = []
614socket = []
615version_res = []
616coref = []
617iokit = []
618emulator_link_args = []
619nvmm =not_found
620hvf = not_found
621midl = not_found
622widl = not_found
623pathcch = not_found
624host_dsosuf = '.so'
625if targetos == 'windows'
626  midl = find_program('midl', required: false)
627  widl = find_program('widl', required: false)
628  pathcch = cc.find_library('pathcch')
629  socket = cc.find_library('ws2_32')
630  winmm = cc.find_library('winmm')
631
632  win = import('windows')
633  version_res = win.compile_resources('version.rc',
634                                      depend_files: files('pc-bios/qemu-nsis.ico'),
635                                      include_directories: include_directories('.'))
636  host_dsosuf = '.dll'
637elif targetos == 'darwin'
638  coref = dependency('appleframeworks', modules: 'CoreFoundation')
639  iokit = dependency('appleframeworks', modules: 'IOKit', required: false)
640  host_dsosuf = '.dylib'
641elif targetos == 'sunos'
642  socket = [cc.find_library('socket'),
643            cc.find_library('nsl'),
644            cc.find_library('resolv')]
645elif targetos == 'haiku'
646  socket = [cc.find_library('posix_error_mapper'),
647            cc.find_library('network'),
648            cc.find_library('bsd')]
649elif targetos == 'openbsd'
650  if get_option('tcg').allowed() and target_dirs.length() > 0
651    # Disable OpenBSD W^X if available
652    emulator_link_args = cc.get_supported_link_arguments('-Wl,-z,wxneeded')
653  endif
654endif
655
656# Target-specific configuration of accelerators
657accelerators = []
658if get_option('kvm').allowed() and targetos == 'linux'
659  accelerators += 'CONFIG_KVM'
660endif
661if get_option('whpx').allowed() and targetos == 'windows'
662  if get_option('whpx').enabled() and host_machine.cpu() != 'x86_64'
663    error('WHPX requires 64-bit host')
664  elif cc.has_header('WinHvPlatform.h', required: get_option('whpx')) and \
665       cc.has_header('WinHvEmulation.h', required: get_option('whpx'))
666    accelerators += 'CONFIG_WHPX'
667  endif
668endif
669if get_option('hvf').allowed()
670  hvf = dependency('appleframeworks', modules: 'Hypervisor',
671                   required: get_option('hvf'))
672  if hvf.found()
673    accelerators += 'CONFIG_HVF'
674  endif
675endif
676if get_option('hax').allowed()
677  if get_option('hax').enabled() or targetos in ['windows', 'darwin', 'netbsd']
678    accelerators += 'CONFIG_HAX'
679  endif
680endif
681if targetos == 'netbsd'
682  nvmm = cc.find_library('nvmm', required: get_option('nvmm'))
683  if nvmm.found()
684    accelerators += 'CONFIG_NVMM'
685  endif
686endif
687
688tcg_arch = host_arch
689if get_option('tcg').allowed()
690  if host_arch == 'unknown'
691    if get_option('tcg_interpreter')
692      warning('Unsupported CPU @0@, will use TCG with TCI (slow)'.format(cpu))
693    else
694      error('Unsupported CPU @0@, try --enable-tcg-interpreter'.format(cpu))
695    endif
696  elif get_option('tcg_interpreter')
697    warning('Use of the TCG interpreter is not recommended on this host')
698    warning('architecture. There is a native TCG execution backend available')
699    warning('which provides substantially better performance and reliability.')
700    warning('It is strongly recommended to remove the --enable-tcg-interpreter')
701    warning('configuration option on this architecture to use the native')
702    warning('backend.')
703  endif
704  if get_option('tcg_interpreter')
705    tcg_arch = 'tci'
706    config_host += { 'CONFIG_TCG_INTERPRETER': 'y' }
707  elif host_arch == 'x86_64'
708    tcg_arch = 'i386'
709  elif host_arch == 'ppc64'
710    tcg_arch = 'ppc'
711  endif
712  add_project_arguments('-iquote', meson.current_source_dir() / 'tcg' / tcg_arch,
713                        language: all_languages)
714
715  accelerators += 'CONFIG_TCG'
716  config_host += { 'CONFIG_TCG': 'y' }
717endif
718
719if 'CONFIG_KVM' not in accelerators and get_option('kvm').enabled()
720  error('KVM not available on this platform')
721endif
722if 'CONFIG_HVF' not in accelerators and get_option('hvf').enabled()
723  error('HVF not available on this platform')
724endif
725if 'CONFIG_NVMM' not in accelerators and get_option('nvmm').enabled()
726  error('NVMM not available on this platform')
727endif
728if 'CONFIG_WHPX' not in accelerators and get_option('whpx').enabled()
729  error('WHPX not available on this platform')
730endif
731
732################
733# Dependencies #
734################
735
736# When bumping glib minimum version, please check also whether to increase
737# the _WIN32_WINNT setting in osdep.h according to the value from glib
738glib_req_ver = '>=2.56.0'
739glib_pc = dependency('glib-2.0', version: glib_req_ver, required: true,
740                    method: 'pkg-config')
741glib_cflags = []
742if enable_modules
743  gmodule = dependency('gmodule-export-2.0', version: glib_req_ver, required: true,
744                       method: 'pkg-config')
745elif config_host.has_key('CONFIG_PLUGIN')
746  gmodule = dependency('gmodule-no-export-2.0', version: glib_req_ver, required: true,
747                       method: 'pkg-config')
748else
749  gmodule = not_found
750endif
751
752# This workaround is required due to a bug in pkg-config file for glib as it
753# doesn't define GLIB_STATIC_COMPILATION for pkg-config --static
754if targetos == 'windows' and get_option('prefer_static')
755  glib_cflags += ['-DGLIB_STATIC_COMPILATION']
756endif
757
758# Sanity check that the current size_t matches the
759# size that glib thinks it should be. This catches
760# problems on multi-arch where people try to build
761# 32-bit QEMU while pointing at 64-bit glib headers
762
763if not cc.compiles('''
764  #include <glib.h>
765  #include <unistd.h>
766
767  #define QEMU_BUILD_BUG_ON(x) \
768  typedef char qemu_build_bug_on[(x)?-1:1] __attribute__((unused));
769
770  int main(void) {
771     QEMU_BUILD_BUG_ON(sizeof(size_t) != GLIB_SIZEOF_SIZE_T);
772     return 0;
773  }''', dependencies: glib_pc, args: glib_cflags)
774  error('''sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T.
775        You probably need to set PKG_CONFIG_LIBDIR" to point
776        to the right pkg-config files for your build target.''')
777endif
778
779# Silence clang warnings triggered by glib < 2.57.2
780if not cc.compiles('''
781  #include <glib.h>
782  typedef struct Foo {
783    int i;
784  } Foo;
785  static void foo_free(Foo *f)
786  {
787    g_free(f);
788  }
789  G_DEFINE_AUTOPTR_CLEANUP_FUNC(Foo, foo_free)
790  int main(void) { return 0; }''', dependencies: glib_pc, args: ['-Wunused-function', '-Werror'])
791  glib_cflags += cc.get_supported_arguments('-Wno-unused-function')
792endif
793glib = declare_dependency(dependencies: [glib_pc, gmodule],
794                          compile_args: glib_cflags,
795                          version: glib_pc.version())
796
797# Check whether glib has gslice, which we have to avoid for correctness.
798# TODO: remove this check and the corresponding workaround (qtree) when
799# the minimum supported glib is >= 2.75.3
800glib_has_gslice = glib.version().version_compare('<2.75.3')
801
802# override glib dep to include the above refinements
803meson.override_dependency('glib-2.0', glib)
804
805# The path to glib.h is added to all compilation commands.
806add_project_dependencies(glib.partial_dependency(compile_args: true, includes: true),
807                         native: false, language: all_languages)
808
809gio = not_found
810gdbus_codegen = not_found
811gdbus_codegen_error = '@0@ requires gdbus-codegen, please install libgio'
812if not get_option('gio').auto() or have_system
813  gio = dependency('gio-2.0', required: get_option('gio'),
814                   method: 'pkg-config')
815  if gio.found() and not cc.links('''
816    #include <gio/gio.h>
817    int main(void)
818    {
819      g_dbus_proxy_new_sync(0, 0, 0, 0, 0, 0, 0, 0);
820      return 0;
821    }''', dependencies: [glib, gio])
822    if get_option('gio').enabled()
823      error('The installed libgio is broken for static linking')
824    endif
825    gio = not_found
826  endif
827  if gio.found()
828    gdbus_codegen = find_program(gio.get_variable('gdbus_codegen'),
829                                 required: get_option('gio'))
830    gio_unix = dependency('gio-unix-2.0', required: get_option('gio'),
831                          method: 'pkg-config')
832    gio = declare_dependency(dependencies: [gio, gio_unix],
833                             version: gio.version())
834  endif
835endif
836if gdbus_codegen.found() and get_option('cfi')
837  gdbus_codegen = not_found
838  gdbus_codegen_error = '@0@ uses gdbus-codegen, which does not support control flow integrity'
839endif
840
841lttng = not_found
842if 'ust' in get_option('trace_backends')
843  lttng = dependency('lttng-ust', required: true, version: '>= 2.1',
844                     method: 'pkg-config')
845endif
846pixman = not_found
847if have_system or have_tools
848  pixman = dependency('pixman-1', required: have_system, version:'>=0.21.8',
849                      method: 'pkg-config')
850endif
851zlib = dependency('zlib', required: true)
852
853libaio = not_found
854if not get_option('linux_aio').auto() or have_block
855  libaio = cc.find_library('aio', has_headers: ['libaio.h'],
856                           required: get_option('linux_aio'))
857endif
858
859linux_io_uring_test = '''
860  #include <liburing.h>
861  #include <linux/errqueue.h>
862
863  int main(void) { return 0; }'''
864
865linux_io_uring = not_found
866if not get_option('linux_io_uring').auto() or have_block
867  linux_io_uring = dependency('liburing', version: '>=0.3',
868                              required: get_option('linux_io_uring'),
869                              method: 'pkg-config')
870  if not cc.links(linux_io_uring_test)
871    linux_io_uring = not_found
872  endif
873endif
874
875libnfs = not_found
876if not get_option('libnfs').auto() or have_block
877  libnfs = dependency('libnfs', version: '>=1.9.3',
878                      required: get_option('libnfs'),
879                      method: 'pkg-config')
880endif
881
882libattr_test = '''
883  #include <stddef.h>
884  #include <sys/types.h>
885  #ifdef CONFIG_LIBATTR
886  #include <attr/xattr.h>
887  #else
888  #include <sys/xattr.h>
889  #endif
890  int main(void) { getxattr(NULL, NULL, NULL, 0); setxattr(NULL, NULL, NULL, 0, 0); return 0; }'''
891
892libattr = not_found
893have_old_libattr = false
894if get_option('attr').allowed()
895  if cc.links(libattr_test)
896    libattr = declare_dependency()
897  else
898    libattr = cc.find_library('attr', has_headers: ['attr/xattr.h'],
899                              required: get_option('attr'))
900    if libattr.found() and not \
901      cc.links(libattr_test, dependencies: libattr, args: '-DCONFIG_LIBATTR')
902      libattr = not_found
903      if get_option('attr').enabled()
904        error('could not link libattr')
905      else
906        warning('could not link libattr, disabling')
907      endif
908    else
909      have_old_libattr = libattr.found()
910    endif
911  endif
912endif
913
914cocoa = dependency('appleframeworks', modules: ['Cocoa', 'CoreVideo'],
915                   required: get_option('cocoa'))
916
917vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet'))
918if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h',
919                                              'VMNET_BRIDGED_MODE',
920                                              dependencies: vmnet)
921  vmnet = not_found
922  if get_option('vmnet').enabled()
923    error('vmnet.framework API is outdated')
924  else
925    warning('vmnet.framework API is outdated, disabling')
926  endif
927endif
928
929seccomp = not_found
930seccomp_has_sysrawrc = false
931if not get_option('seccomp').auto() or have_system or have_tools
932  seccomp = dependency('libseccomp', version: '>=2.3.0',
933                       required: get_option('seccomp'),
934                       method: 'pkg-config')
935  if seccomp.found()
936    seccomp_has_sysrawrc = cc.has_header_symbol('seccomp.h',
937                                                'SCMP_FLTATR_API_SYSRAWRC',
938                                                dependencies: seccomp)
939  endif
940endif
941
942libcap_ng = not_found
943if not get_option('cap_ng').auto() or have_system or have_tools
944  libcap_ng = cc.find_library('cap-ng', has_headers: ['cap-ng.h'],
945                              required: get_option('cap_ng'))
946endif
947if libcap_ng.found() and not cc.links('''
948   #include <cap-ng.h>
949   int main(void)
950   {
951     capng_capability_to_name(CAPNG_EFFECTIVE);
952     return 0;
953   }''', dependencies: libcap_ng)
954  libcap_ng = not_found
955  if get_option('cap_ng').enabled()
956    error('could not link libcap-ng')
957  else
958    warning('could not link libcap-ng, disabling')
959  endif
960endif
961
962if get_option('xkbcommon').auto() and not have_system and not have_tools
963  xkbcommon = not_found
964else
965  xkbcommon = dependency('xkbcommon', required: get_option('xkbcommon'),
966                         method: 'pkg-config')
967endif
968
969slirp = not_found
970if not get_option('slirp').auto() or have_system
971  slirp = dependency('slirp', required: get_option('slirp'),
972                     method: 'pkg-config')
973  # slirp < 4.7 is incompatible with CFI support in QEMU.  This is because
974  # it passes function pointers within libslirp as callbacks for timers.
975  # When using a system-wide shared libslirp, the type information for the
976  # callback is missing and the timer call produces a false positive with CFI.
977  # Do not use the "version" keyword argument to produce a better error.
978  # with control-flow integrity.
979  if get_option('cfi') and slirp.found() and slirp.version().version_compare('<4.7')
980    if get_option('slirp').enabled()
981      error('Control-Flow Integrity requires libslirp 4.7.')
982    else
983      warning('Cannot use libslirp since Control-Flow Integrity requires libslirp >= 4.7.')
984      slirp = not_found
985    endif
986  endif
987endif
988
989vde = not_found
990if not get_option('vde').auto() or have_system or have_tools
991  vde = cc.find_library('vdeplug', has_headers: ['libvdeplug.h'],
992                           required: get_option('vde'))
993endif
994if vde.found() and not cc.links('''
995   #include <libvdeplug.h>
996   int main(void)
997   {
998     struct vde_open_args a = {0, 0, 0};
999     char s[] = "";
1000     vde_open(s, s, &a);
1001     return 0;
1002   }''', dependencies: vde)
1003  vde = not_found
1004  if get_option('cap_ng').enabled()
1005    error('could not link libvdeplug')
1006  else
1007    warning('could not link libvdeplug, disabling')
1008  endif
1009endif
1010
1011pulse = not_found
1012if not get_option('pa').auto() or (targetos == 'linux' and have_system)
1013  pulse = dependency('libpulse', required: get_option('pa'),
1014                     method: 'pkg-config')
1015endif
1016alsa = not_found
1017if not get_option('alsa').auto() or (targetos == 'linux' and have_system)
1018  alsa = dependency('alsa', required: get_option('alsa'),
1019                    method: 'pkg-config')
1020endif
1021jack = not_found
1022if not get_option('jack').auto() or have_system
1023  jack = dependency('jack', required: get_option('jack'),
1024                    method: 'pkg-config')
1025endif
1026pipewire = not_found
1027if not get_option('pipewire').auto() or (targetos == 'linux' and have_system)
1028  pipewire = dependency('libpipewire-0.3', version: '>=0.3.60',
1029                    required: get_option('pipewire'),
1030                    method: 'pkg-config')
1031endif
1032sndio = not_found
1033if not get_option('sndio').auto() or have_system
1034  sndio = dependency('sndio', required: get_option('sndio'),
1035                    method: 'pkg-config')
1036endif
1037
1038spice_protocol = not_found
1039if not get_option('spice_protocol').auto() or have_system
1040  spice_protocol = dependency('spice-protocol', version: '>=0.14.0',
1041                              required: get_option('spice_protocol'),
1042                              method: 'pkg-config')
1043endif
1044spice = not_found
1045if not get_option('spice').auto() or have_system
1046  spice = dependency('spice-server', version: '>=0.14.0',
1047                     required: get_option('spice'),
1048                     method: 'pkg-config')
1049endif
1050spice_headers = spice.partial_dependency(compile_args: true, includes: true)
1051
1052rt = cc.find_library('rt', required: false)
1053
1054libiscsi = not_found
1055if not get_option('libiscsi').auto() or have_block
1056  libiscsi = dependency('libiscsi', version: '>=1.9.0',
1057                         required: get_option('libiscsi'),
1058                         method: 'pkg-config')
1059endif
1060zstd = not_found
1061if not get_option('zstd').auto() or have_block
1062  zstd = dependency('libzstd', version: '>=1.4.0',
1063                    required: get_option('zstd'),
1064                    method: 'pkg-config')
1065endif
1066virgl = not_found
1067
1068have_vhost_user_gpu = have_tools and targetos == 'linux' and pixman.found()
1069if not get_option('virglrenderer').auto() or have_system or have_vhost_user_gpu
1070  virgl = dependency('virglrenderer',
1071                     method: 'pkg-config',
1072                     required: get_option('virglrenderer'))
1073endif
1074blkio = not_found
1075if not get_option('blkio').auto() or have_block
1076  blkio = dependency('blkio',
1077                     method: 'pkg-config',
1078                     required: get_option('blkio'))
1079endif
1080curl = not_found
1081if not get_option('curl').auto() or have_block
1082  curl = dependency('libcurl', version: '>=7.29.0',
1083                    method: 'pkg-config',
1084                    required: get_option('curl'))
1085endif
1086libudev = not_found
1087if targetos == 'linux' and (have_system or have_tools)
1088  libudev = dependency('libudev',
1089                       method: 'pkg-config',
1090                       required: get_option('libudev'))
1091endif
1092
1093mpathlibs = [libudev]
1094mpathpersist = not_found
1095if targetos == 'linux' and have_tools and get_option('mpath').allowed()
1096  mpath_test_source = '''
1097    #include <libudev.h>
1098    #include <mpath_persist.h>
1099    unsigned mpath_mx_alloc_len = 1024;
1100    int logsink;
1101    static struct config *multipath_conf;
1102    extern struct udev *udev;
1103    extern struct config *get_multipath_config(void);
1104    extern void put_multipath_config(struct config *conf);
1105    struct udev *udev;
1106    struct config *get_multipath_config(void) { return multipath_conf; }
1107    void put_multipath_config(struct config *conf) { }
1108    int main(void) {
1109        udev = udev_new();
1110        multipath_conf = mpath_lib_init();
1111        return 0;
1112    }'''
1113  libmpathpersist = cc.find_library('mpathpersist',
1114                                    required: get_option('mpath'))
1115  if libmpathpersist.found()
1116    mpathlibs += libmpathpersist
1117    if get_option('prefer_static')
1118      mpathlibs += cc.find_library('devmapper',
1119                                     required: get_option('mpath'))
1120    endif
1121    mpathlibs += cc.find_library('multipath',
1122                                 required: get_option('mpath'))
1123    foreach lib: mpathlibs
1124      if not lib.found()
1125        mpathlibs = []
1126        break
1127      endif
1128    endforeach
1129    if mpathlibs.length() == 0
1130      msg = 'Dependencies missing for libmpathpersist'
1131    elif cc.links(mpath_test_source, dependencies: mpathlibs)
1132      mpathpersist = declare_dependency(dependencies: mpathlibs)
1133    else
1134      msg = 'Cannot detect libmpathpersist API'
1135    endif
1136    if not mpathpersist.found()
1137      if get_option('mpath').enabled()
1138        error(msg)
1139      else
1140        warning(msg + ', disabling')
1141      endif
1142    endif
1143  endif
1144endif
1145
1146iconv = not_found
1147curses = not_found
1148if have_system and get_option('curses').allowed()
1149  curses_test = '''
1150    #if defined(__APPLE__) || defined(__OpenBSD__)
1151    #define _XOPEN_SOURCE_EXTENDED 1
1152    #endif
1153    #include <locale.h>
1154    #include <curses.h>
1155    #include <wchar.h>
1156    int main(void) {
1157      wchar_t wch = L'w';
1158      setlocale(LC_ALL, "");
1159      resize_term(0, 0);
1160      addwstr(L"wide chars\n");
1161      addnwstr(&wch, 1);
1162      add_wch(WACS_DEGREE);
1163      return 0;
1164    }'''
1165
1166  curses_dep_list = targetos == 'windows' ? ['ncurses', 'ncursesw'] : ['ncursesw']
1167  curses = dependency(curses_dep_list,
1168                      required: false,
1169                      method: 'pkg-config')
1170  msg = get_option('curses').enabled() ? 'curses library not found' : ''
1171  curses_compile_args = ['-DNCURSES_WIDECHAR=1']
1172  if curses.found()
1173    if cc.links(curses_test, args: curses_compile_args, dependencies: [curses])
1174      curses = declare_dependency(compile_args: curses_compile_args, dependencies: [curses],
1175                                  version: curses.version())
1176    else
1177      msg = 'curses package not usable'
1178      curses = not_found
1179    endif
1180  endif
1181  if not curses.found()
1182    has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
1183    if targetos != 'windows' and not has_curses_h
1184      message('Trying with /usr/include/ncursesw')
1185      curses_compile_args += ['-I/usr/include/ncursesw']
1186      has_curses_h = cc.has_header('curses.h', args: curses_compile_args)
1187    endif
1188    if has_curses_h
1189      curses_libname_list = (targetos == 'windows' ? ['pdcurses'] : ['ncursesw', 'cursesw'])
1190      foreach curses_libname : curses_libname_list
1191        libcurses = cc.find_library(curses_libname,
1192                                    required: false)
1193        if libcurses.found()
1194          if cc.links(curses_test, args: curses_compile_args, dependencies: libcurses)
1195            curses = declare_dependency(compile_args: curses_compile_args,
1196                                        dependencies: [libcurses])
1197            break
1198          else
1199            msg = 'curses library not usable'
1200          endif
1201        endif
1202      endforeach
1203    endif
1204  endif
1205  if get_option('iconv').allowed()
1206    foreach link_args : [ ['-liconv'], [] ]
1207      # Programs will be linked with glib and this will bring in libiconv on FreeBSD.
1208      # We need to use libiconv if available because mixing libiconv's headers with
1209      # the system libc does not work.
1210      # However, without adding glib to the dependencies -L/usr/local/lib will not be
1211      # included in the command line and libiconv will not be found.
1212      if cc.links('''
1213        #include <iconv.h>
1214        int main(void) {
1215          iconv_t conv = iconv_open("WCHAR_T", "UCS-2");
1216          return conv != (iconv_t) -1;
1217        }''', args: link_args, dependencies: glib)
1218        iconv = declare_dependency(link_args: link_args, dependencies: glib)
1219        break
1220      endif
1221    endforeach
1222  endif
1223  if curses.found() and not iconv.found()
1224    if get_option('iconv').enabled()
1225      error('iconv not available')
1226    endif
1227    msg = 'iconv required for curses UI but not available'
1228    curses = not_found
1229  endif
1230  if not curses.found() and msg != ''
1231    if get_option('curses').enabled()
1232      error(msg)
1233    else
1234      warning(msg + ', disabling')
1235    endif
1236  endif
1237endif
1238
1239brlapi = not_found
1240if not get_option('brlapi').auto() or have_system
1241  brlapi = cc.find_library('brlapi', has_headers: ['brlapi.h'],
1242                         required: get_option('brlapi'))
1243  if brlapi.found() and not cc.links('''
1244     #include <brlapi.h>
1245     #include <stddef.h>
1246     int main(void) { return brlapi__openConnection (NULL, NULL, NULL); }''', dependencies: brlapi)
1247    brlapi = not_found
1248    if get_option('brlapi').enabled()
1249      error('could not link brlapi')
1250    else
1251      warning('could not link brlapi, disabling')
1252    endif
1253  endif
1254endif
1255
1256sdl = not_found
1257if not get_option('sdl').auto() or have_system
1258  sdl = dependency('sdl2', required: get_option('sdl'))
1259  sdl_image = not_found
1260endif
1261if sdl.found()
1262  # Some versions of SDL have problems with -Wundef
1263  if not cc.compiles('''
1264                     #include <SDL.h>
1265                     #include <SDL_syswm.h>
1266                     int main(int argc, char *argv[]) { return 0; }
1267                     ''', dependencies: sdl, args: '-Werror=undef')
1268    sdl = declare_dependency(compile_args: '-Wno-undef',
1269                             dependencies: sdl,
1270                             version: sdl.version())
1271  endif
1272  sdl_image = dependency('SDL2_image', required: get_option('sdl_image'),
1273                         method: 'pkg-config')
1274else
1275  if get_option('sdl_image').enabled()
1276    error('sdl-image required, but SDL was @0@'.format(
1277          get_option('sdl').disabled() ? 'disabled' : 'not found'))
1278  endif
1279  sdl_image = not_found
1280endif
1281
1282rbd = not_found
1283if not get_option('rbd').auto() or have_block
1284  librados = cc.find_library('rados', required: get_option('rbd'))
1285  librbd = cc.find_library('rbd', has_headers: ['rbd/librbd.h'],
1286                           required: get_option('rbd'))
1287  if librados.found() and librbd.found()
1288    if cc.links('''
1289      #include <stdio.h>
1290      #include <rbd/librbd.h>
1291      int main(void) {
1292        rados_t cluster;
1293        rados_create(&cluster, NULL);
1294        #if LIBRBD_VERSION_CODE < LIBRBD_VERSION(1, 12, 0)
1295        #error
1296        #endif
1297        return 0;
1298      }''', dependencies: [librbd, librados])
1299      rbd = declare_dependency(dependencies: [librbd, librados])
1300    elif get_option('rbd').enabled()
1301      error('librbd >= 1.12.0 required')
1302    else
1303      warning('librbd >= 1.12.0 not found, disabling')
1304    endif
1305  endif
1306endif
1307
1308glusterfs = not_found
1309glusterfs_ftruncate_has_stat = false
1310glusterfs_iocb_has_stat = false
1311if not get_option('glusterfs').auto() or have_block
1312  glusterfs = dependency('glusterfs-api', version: '>=3',
1313                         required: get_option('glusterfs'),
1314                         method: 'pkg-config')
1315  if glusterfs.found()
1316    glusterfs_ftruncate_has_stat = cc.links('''
1317      #include <glusterfs/api/glfs.h>
1318
1319      int
1320      main(void)
1321      {
1322          /* new glfs_ftruncate() passes two additional args */
1323          return glfs_ftruncate(NULL, 0, NULL, NULL);
1324      }
1325    ''', dependencies: glusterfs)
1326    glusterfs_iocb_has_stat = cc.links('''
1327      #include <glusterfs/api/glfs.h>
1328
1329      /* new glfs_io_cbk() passes two additional glfs_stat structs */
1330      static void
1331      glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
1332      {}
1333
1334      int
1335      main(void)
1336      {
1337          glfs_io_cbk iocb = &glusterfs_iocb;
1338          iocb(NULL, 0 , NULL, NULL, NULL);
1339          return 0;
1340      }
1341    ''', dependencies: glusterfs)
1342  endif
1343endif
1344
1345libssh = not_found
1346if not get_option('libssh').auto() or have_block
1347  libssh = dependency('libssh', version: '>=0.8.7',
1348                    method: 'pkg-config',
1349                    required: get_option('libssh'))
1350endif
1351
1352libbzip2 = not_found
1353if not get_option('bzip2').auto() or have_block
1354  libbzip2 = cc.find_library('bz2', has_headers: ['bzlib.h'],
1355                             required: get_option('bzip2'))
1356  if libbzip2.found() and not cc.links('''
1357     #include <bzlib.h>
1358     int main(void) { BZ2_bzlibVersion(); return 0; }''', dependencies: libbzip2)
1359    libbzip2 = not_found
1360    if get_option('bzip2').enabled()
1361      error('could not link libbzip2')
1362    else
1363      warning('could not link libbzip2, disabling')
1364    endif
1365  endif
1366endif
1367
1368liblzfse = not_found
1369if not get_option('lzfse').auto() or have_block
1370  liblzfse = cc.find_library('lzfse', has_headers: ['lzfse.h'],
1371                             required: get_option('lzfse'))
1372endif
1373if liblzfse.found() and not cc.links('''
1374   #include <lzfse.h>
1375   int main(void) { lzfse_decode_scratch_size(); return 0; }''', dependencies: liblzfse)
1376  liblzfse = not_found
1377  if get_option('lzfse').enabled()
1378    error('could not link liblzfse')
1379  else
1380    warning('could not link liblzfse, disabling')
1381  endif
1382endif
1383
1384oss = not_found
1385if get_option('oss').allowed() and have_system
1386  if not cc.has_header('sys/soundcard.h')
1387    # not found
1388  elif targetos == 'netbsd'
1389    oss = cc.find_library('ossaudio', required: get_option('oss'))
1390  else
1391    oss = declare_dependency()
1392  endif
1393
1394  if not oss.found()
1395    if get_option('oss').enabled()
1396      error('OSS not found')
1397    endif
1398  endif
1399endif
1400dsound = not_found
1401if not get_option('dsound').auto() or (targetos == 'windows' and have_system)
1402  if cc.has_header('dsound.h')
1403    dsound = declare_dependency(link_args: ['-lole32', '-ldxguid'])
1404  endif
1405
1406  if not dsound.found()
1407    if get_option('dsound').enabled()
1408      error('DirectSound not found')
1409    endif
1410  endif
1411endif
1412
1413coreaudio = not_found
1414if not get_option('coreaudio').auto() or (targetos == 'darwin' and have_system)
1415  coreaudio = dependency('appleframeworks', modules: 'CoreAudio',
1416                         required: get_option('coreaudio'))
1417endif
1418
1419opengl = not_found
1420if not get_option('opengl').auto() or have_system or have_vhost_user_gpu
1421  epoxy = dependency('epoxy', method: 'pkg-config',
1422                      required: get_option('opengl'))
1423  if cc.has_header('epoxy/egl.h', dependencies: epoxy)
1424    opengl = epoxy
1425  elif get_option('opengl').enabled()
1426    error('epoxy/egl.h not found')
1427  endif
1428endif
1429gbm = not_found
1430if (have_system or have_tools) and (virgl.found() or opengl.found())
1431  gbm = dependency('gbm', method: 'pkg-config', required: false)
1432endif
1433have_vhost_user_gpu = have_vhost_user_gpu and virgl.found() and opengl.found() and gbm.found()
1434
1435gnutls = not_found
1436gnutls_crypto = not_found
1437if get_option('gnutls').enabled() or (get_option('gnutls').auto() and have_system)
1438  # For general TLS support our min gnutls matches
1439  # that implied by our platform support matrix
1440  #
1441  # For the crypto backends, we look for a newer
1442  # gnutls:
1443  #
1444  #   Version 3.6.8  is needed to get XTS
1445  #   Version 3.6.13 is needed to get PBKDF
1446  #   Version 3.6.14 is needed to get HW accelerated XTS
1447  #
1448  # If newer enough gnutls isn't available, we can
1449  # still use a different crypto backend to satisfy
1450  # the platform support requirements
1451  gnutls_crypto = dependency('gnutls', version: '>=3.6.14',
1452                             method: 'pkg-config',
1453                             required: false)
1454  if gnutls_crypto.found()
1455    gnutls = gnutls_crypto
1456  else
1457    # Our min version if all we need is TLS
1458    gnutls = dependency('gnutls', version: '>=3.5.18',
1459                        method: 'pkg-config',
1460                        required: get_option('gnutls'))
1461  endif
1462endif
1463
1464# We prefer use of gnutls for crypto, unless the options
1465# explicitly asked for nettle or gcrypt.
1466#
1467# If gnutls isn't available for crypto, then we'll prefer
1468# gcrypt over nettle for performance reasons.
1469gcrypt = not_found
1470nettle = not_found
1471hogweed = not_found
1472xts = 'none'
1473
1474if get_option('nettle').enabled() and get_option('gcrypt').enabled()
1475  error('Only one of gcrypt & nettle can be enabled')
1476endif
1477
1478# Explicit nettle/gcrypt request, so ignore gnutls for crypto
1479if get_option('nettle').enabled() or get_option('gcrypt').enabled()
1480  gnutls_crypto = not_found
1481endif
1482
1483if not gnutls_crypto.found()
1484  if (not get_option('gcrypt').auto() or have_system) and not get_option('nettle').enabled()
1485    gcrypt = dependency('libgcrypt', version: '>=1.8',
1486                        method: 'config-tool',
1487                        required: get_option('gcrypt'))
1488    # Debian has removed -lgpg-error from libgcrypt-config
1489    # as it "spreads unnecessary dependencies" which in
1490    # turn breaks static builds...
1491    if gcrypt.found() and get_option('prefer_static')
1492      gcrypt = declare_dependency(dependencies:
1493        [gcrypt,
1494         cc.find_library('gpg-error', required: true)],
1495        version: gcrypt.version())
1496    endif
1497  endif
1498  if (not get_option('nettle').auto() or have_system) and not gcrypt.found()
1499    nettle = dependency('nettle', version: '>=3.4',
1500                        method: 'pkg-config',
1501                        required: get_option('nettle'))
1502    if nettle.found() and not cc.has_header('nettle/xts.h', dependencies: nettle)
1503      xts = 'private'
1504    endif
1505  endif
1506endif
1507
1508gmp = dependency('gmp', required: false, method: 'pkg-config')
1509if nettle.found() and gmp.found()
1510  hogweed = dependency('hogweed', version: '>=3.4',
1511                       method: 'pkg-config',
1512                       required: get_option('nettle'))
1513endif
1514
1515
1516gtk = not_found
1517gtkx11 = not_found
1518vte = not_found
1519have_gtk_clipboard = get_option('gtk_clipboard').enabled()
1520
1521if not get_option('gtk').auto() or have_system
1522  gtk = dependency('gtk+-3.0', version: '>=3.22.0',
1523                   method: 'pkg-config',
1524                   required: get_option('gtk'))
1525  if gtk.found()
1526    gtkx11 = dependency('gtk+-x11-3.0', version: '>=3.22.0',
1527                        method: 'pkg-config',
1528                        required: false)
1529    gtk = declare_dependency(dependencies: [gtk, gtkx11],
1530                             version: gtk.version())
1531
1532    if not get_option('vte').auto() or have_system
1533      vte = dependency('vte-2.91',
1534                       method: 'pkg-config',
1535                       required: get_option('vte'))
1536    endif
1537  elif have_gtk_clipboard
1538    error('GTK clipboard requested, but GTK not found')
1539  endif
1540endif
1541
1542x11 = not_found
1543if gtkx11.found()
1544  x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found())
1545endif
1546png = not_found
1547if get_option('png').allowed() and have_system
1548   png = dependency('libpng', version: '>=1.6.34', required: get_option('png'),
1549                    method: 'pkg-config')
1550endif
1551vnc = not_found
1552jpeg = not_found
1553sasl = not_found
1554if get_option('vnc').allowed() and have_system
1555  vnc = declare_dependency() # dummy dependency
1556  jpeg = dependency('libjpeg', required: get_option('vnc_jpeg'),
1557                    method: 'pkg-config')
1558  sasl = cc.find_library('sasl2', has_headers: ['sasl/sasl.h'],
1559                         required: get_option('vnc_sasl'))
1560  if sasl.found()
1561    sasl = declare_dependency(dependencies: sasl,
1562                              compile_args: '-DSTRUCT_IOVEC_DEFINED')
1563  endif
1564endif
1565
1566pam = not_found
1567if not get_option('auth_pam').auto() or have_system
1568  pam = cc.find_library('pam', has_headers: ['security/pam_appl.h'],
1569                        required: get_option('auth_pam'))
1570endif
1571if pam.found() and not cc.links('''
1572   #include <stddef.h>
1573   #include <security/pam_appl.h>
1574   int main(void) {
1575     const char *service_name = "qemu";
1576     const char *user = "frank";
1577     const struct pam_conv pam_conv = { 0 };
1578     pam_handle_t *pamh = NULL;
1579     pam_start(service_name, user, &pam_conv, &pamh);
1580     return 0;
1581   }''', dependencies: pam)
1582  pam = not_found
1583  if get_option('auth_pam').enabled()
1584    error('could not link libpam')
1585  else
1586    warning('could not link libpam, disabling')
1587  endif
1588endif
1589
1590snappy = not_found
1591if not get_option('snappy').auto() or have_system
1592  snappy = cc.find_library('snappy', has_headers: ['snappy-c.h'],
1593                           required: get_option('snappy'))
1594endif
1595if snappy.found() and not linker.links('''
1596   #include <snappy-c.h>
1597   int main(void) { snappy_max_compressed_length(4096); return 0; }''', dependencies: snappy)
1598  snappy = not_found
1599  if get_option('snappy').enabled()
1600    error('could not link libsnappy')
1601  else
1602    warning('could not link libsnappy, disabling')
1603  endif
1604endif
1605
1606lzo = not_found
1607if not get_option('lzo').auto() or have_system
1608  lzo = cc.find_library('lzo2', has_headers: ['lzo/lzo1x.h'],
1609                        required: get_option('lzo'))
1610endif
1611if lzo.found() and not cc.links('''
1612   #include <lzo/lzo1x.h>
1613   int main(void) { lzo_version(); return 0; }''', dependencies: lzo)
1614  lzo = not_found
1615  if get_option('lzo').enabled()
1616    error('could not link liblzo2')
1617  else
1618    warning('could not link liblzo2, disabling')
1619  endif
1620endif
1621
1622numa = not_found
1623if not get_option('numa').auto() or have_system or have_tools
1624  numa = cc.find_library('numa', has_headers: ['numa.h'],
1625                              required: get_option('numa'))
1626endif
1627if numa.found() and not cc.links('''
1628   #include <numa.h>
1629   int main(void) { return numa_available(); }
1630   ''', dependencies: numa)
1631  numa = not_found
1632  if get_option('numa').enabled()
1633    error('could not link numa')
1634  else
1635    warning('could not link numa, disabling')
1636  endif
1637endif
1638
1639rdma = not_found
1640if not get_option('rdma').auto() or have_system
1641  libumad = cc.find_library('ibumad', required: get_option('rdma'))
1642  rdma_libs = [cc.find_library('rdmacm', has_headers: ['rdma/rdma_cma.h'],
1643                               required: get_option('rdma')),
1644               cc.find_library('ibverbs', required: get_option('rdma')),
1645               libumad]
1646  rdma = declare_dependency(dependencies: rdma_libs)
1647  foreach lib: rdma_libs
1648    if not lib.found()
1649      rdma = not_found
1650    endif
1651  endforeach
1652endif
1653
1654xen = not_found
1655if get_option('xen').enabled() or (get_option('xen').auto() and have_system)
1656  xencontrol = dependency('xencontrol', required: false,
1657                          method: 'pkg-config')
1658  if xencontrol.found()
1659    xen_pc = declare_dependency(version: xencontrol.version(),
1660      dependencies: [
1661        xencontrol,
1662        # disabler: true makes xen_pc.found() return false if any is not found
1663        dependency('xenstore', required: false,
1664                   method: 'pkg-config',
1665                   disabler: true),
1666        dependency('xenforeignmemory', required: false,
1667                   method: 'pkg-config',
1668                   disabler: true),
1669        dependency('xengnttab', required: false,
1670                   method: 'pkg-config',
1671                   disabler: true),
1672        dependency('xenevtchn', required: false,
1673                   method: 'pkg-config',
1674                   disabler: true),
1675        dependency('xendevicemodel', required: false,
1676                   method: 'pkg-config',
1677                   disabler: true),
1678        # optional, no "disabler: true"
1679        dependency('xentoolcore', required: false,
1680                   method: 'pkg-config')])
1681    if xen_pc.found()
1682      xen = xen_pc
1683    endif
1684  endif
1685  if not xen.found()
1686    xen_tests = [ '4.11.0', '4.10.0', '4.9.0', '4.8.0', '4.7.1', '4.6.0', '4.5.0', '4.2.0' ]
1687    xen_libs = {
1688      '4.11.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
1689      '4.10.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn', 'xentoolcore' ],
1690      '4.9.0': [ 'xenstore', 'xenctrl', 'xendevicemodel', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
1691      '4.8.0': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
1692      '4.7.1': [ 'xenstore', 'xenctrl', 'xenforeignmemory', 'xengnttab', 'xenevtchn' ],
1693      '4.6.0': [ 'xenstore', 'xenctrl' ],
1694      '4.5.0': [ 'xenstore', 'xenctrl' ],
1695      '4.2.0': [ 'xenstore', 'xenctrl' ],
1696    }
1697    xen_deps = {}
1698    foreach ver: xen_tests
1699      # cache the various library tests to avoid polluting the logs
1700      xen_test_deps = []
1701      foreach l: xen_libs[ver]
1702        if l not in xen_deps
1703          xen_deps += { l: cc.find_library(l, required: false) }
1704        endif
1705        xen_test_deps += xen_deps[l]
1706      endforeach
1707
1708      # Use -D to pick just one of the test programs in scripts/xen-detect.c
1709      xen_version = ver.split('.')
1710      xen_ctrl_version = xen_version[0] + \
1711        ('0' + xen_version[1]).substring(-2) + \
1712        ('0' + xen_version[2]).substring(-2)
1713      if cc.links(files('scripts/xen-detect.c'),
1714                  args: '-DCONFIG_XEN_CTRL_INTERFACE_VERSION=' + xen_ctrl_version,
1715                  dependencies: xen_test_deps)
1716        xen = declare_dependency(version: ver, dependencies: xen_test_deps)
1717        break
1718      endif
1719    endforeach
1720  endif
1721  if xen.found()
1722    accelerators += 'CONFIG_XEN'
1723  elif get_option('xen').enabled()
1724    error('could not compile and link Xen test program')
1725  endif
1726endif
1727have_xen_pci_passthrough = get_option('xen_pci_passthrough') \
1728  .require(xen.found(),
1729           error_message: 'Xen PCI passthrough requested but Xen not enabled') \
1730  .require(targetos == 'linux',
1731           error_message: 'Xen PCI passthrough not available on this platform') \
1732  .allowed()
1733
1734
1735cacard = not_found
1736if not get_option('smartcard').auto() or have_system
1737  cacard = dependency('libcacard', required: get_option('smartcard'),
1738                      version: '>=2.5.1', method: 'pkg-config')
1739endif
1740u2f = not_found
1741if have_system
1742  u2f = dependency('u2f-emu', required: get_option('u2f'),
1743                   method: 'pkg-config')
1744endif
1745canokey = not_found
1746if have_system
1747  canokey = dependency('canokey-qemu', required: get_option('canokey'),
1748                   method: 'pkg-config')
1749endif
1750usbredir = not_found
1751if not get_option('usb_redir').auto() or have_system
1752  usbredir = dependency('libusbredirparser-0.5', required: get_option('usb_redir'),
1753                        version: '>=0.6', method: 'pkg-config')
1754endif
1755libusb = not_found
1756if not get_option('libusb').auto() or have_system
1757  libusb = dependency('libusb-1.0', required: get_option('libusb'),
1758                      version: '>=1.0.13', method: 'pkg-config')
1759endif
1760
1761libpmem = not_found
1762if not get_option('libpmem').auto() or have_system
1763  libpmem = dependency('libpmem', required: get_option('libpmem'),
1764                       method: 'pkg-config')
1765endif
1766libdaxctl = not_found
1767if not get_option('libdaxctl').auto() or have_system
1768  libdaxctl = dependency('libdaxctl', required: get_option('libdaxctl'),
1769                         version: '>=57', method: 'pkg-config')
1770endif
1771tasn1 = not_found
1772if gnutls.found()
1773  tasn1 = dependency('libtasn1',
1774                     method: 'pkg-config')
1775endif
1776keyutils = dependency('libkeyutils', required: false,
1777                      method: 'pkg-config')
1778
1779has_gettid = cc.has_function('gettid')
1780
1781# libselinux
1782selinux = dependency('libselinux',
1783                     required: get_option('selinux'),
1784                     method: 'pkg-config')
1785
1786# Malloc tests
1787
1788malloc = []
1789if get_option('malloc') == 'system'
1790  has_malloc_trim = \
1791    get_option('malloc_trim').allowed() and \
1792    cc.has_function('malloc_trim', prefix: '#include <malloc.h>')
1793else
1794  has_malloc_trim = false
1795  malloc = cc.find_library(get_option('malloc'), required: true)
1796endif
1797if not has_malloc_trim and get_option('malloc_trim').enabled()
1798  if get_option('malloc') == 'system'
1799    error('malloc_trim not available on this platform.')
1800  else
1801    error('malloc_trim not available with non-libc memory allocator')
1802  endif
1803endif
1804
1805gnu_source_prefix = '''
1806  #ifndef _GNU_SOURCE
1807  #define _GNU_SOURCE
1808  #endif
1809'''
1810
1811# Check whether the glibc provides STATX_BASIC_STATS
1812
1813has_statx = cc.has_header_symbol('sys/stat.h', 'STATX_BASIC_STATS', prefix: gnu_source_prefix)
1814
1815# Check whether statx() provides mount ID information
1816
1817has_statx_mnt_id = cc.has_header_symbol('sys/stat.h', 'STATX_MNT_ID', prefix: gnu_source_prefix)
1818
1819have_vhost_user_blk_server = get_option('vhost_user_blk_server') \
1820  .require(targetos == 'linux',
1821           error_message: 'vhost_user_blk_server requires linux') \
1822  .require(have_vhost_user,
1823           error_message: 'vhost_user_blk_server requires vhost-user support') \
1824  .disable_auto_if(not have_tools and not have_system) \
1825  .allowed()
1826
1827if get_option('fuse').disabled() and get_option('fuse_lseek').enabled()
1828  error('Cannot enable fuse-lseek while fuse is disabled')
1829endif
1830
1831fuse = dependency('fuse3', required: get_option('fuse'),
1832                  version: '>=3.1', method: 'pkg-config')
1833
1834fuse_lseek = not_found
1835if get_option('fuse_lseek').allowed()
1836  if fuse.version().version_compare('>=3.8')
1837    # Dummy dependency
1838    fuse_lseek = declare_dependency()
1839  elif get_option('fuse_lseek').enabled()
1840    if fuse.found()
1841      error('fuse-lseek requires libfuse >=3.8, found ' + fuse.version())
1842    else
1843      error('fuse-lseek requires libfuse, which was not found')
1844    endif
1845  endif
1846endif
1847
1848have_libvduse = (targetos == 'linux')
1849if get_option('libvduse').enabled()
1850    if targetos != 'linux'
1851        error('libvduse requires linux')
1852    endif
1853elif get_option('libvduse').disabled()
1854    have_libvduse = false
1855endif
1856
1857have_vduse_blk_export = (have_libvduse and targetos == 'linux')
1858if get_option('vduse_blk_export').enabled()
1859    if targetos != 'linux'
1860        error('vduse_blk_export requires linux')
1861    elif not have_libvduse
1862        error('vduse_blk_export requires libvduse support')
1863    endif
1864elif get_option('vduse_blk_export').disabled()
1865    have_vduse_blk_export = false
1866endif
1867
1868# libbpf
1869libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config')
1870if libbpf.found() and not cc.links('''
1871   #include <bpf/libbpf.h>
1872   int main(void)
1873   {
1874     bpf_object__destroy_skeleton(NULL);
1875     return 0;
1876   }''', dependencies: libbpf)
1877  libbpf = not_found
1878  if get_option('bpf').enabled()
1879    error('libbpf skeleton test failed')
1880  else
1881    warning('libbpf skeleton test failed, disabling')
1882  endif
1883endif
1884
1885# libdw
1886libdw = not_found
1887if not get_option('libdw').auto() or \
1888        (not get_option('prefer_static') and (have_system or have_user))
1889    libdw = dependency('libdw',
1890                       method: 'pkg-config',
1891                       required: get_option('libdw'))
1892endif
1893
1894#################
1895# config-host.h #
1896#################
1897
1898audio_drivers_selected = []
1899if have_system
1900  audio_drivers_available = {
1901    'alsa': alsa.found(),
1902    'coreaudio': coreaudio.found(),
1903    'dsound': dsound.found(),
1904    'jack': jack.found(),
1905    'oss': oss.found(),
1906    'pa': pulse.found(),
1907    'pipewire': pipewire.found(),
1908    'sdl': sdl.found(),
1909    'sndio': sndio.found(),
1910  }
1911  foreach k, v: audio_drivers_available
1912    config_host_data.set('CONFIG_AUDIO_' + k.to_upper(), v)
1913  endforeach
1914
1915  # Default to native drivers first, OSS second, SDL third
1916  audio_drivers_priority = \
1917    [ 'pa', 'coreaudio', 'dsound', 'sndio', 'oss' ] + \
1918    (targetos == 'linux' ? [] : [ 'sdl' ])
1919  audio_drivers_default = []
1920  foreach k: audio_drivers_priority
1921    if audio_drivers_available[k]
1922      audio_drivers_default += k
1923    endif
1924  endforeach
1925
1926  foreach k: get_option('audio_drv_list')
1927    if k == 'default'
1928      audio_drivers_selected += audio_drivers_default
1929    elif not audio_drivers_available[k]
1930      error('Audio driver "@0@" not available.'.format(k))
1931    else
1932      audio_drivers_selected += k
1933    endif
1934  endforeach
1935endif
1936config_host_data.set('CONFIG_AUDIO_DRIVERS',
1937                     '"' + '", "'.join(audio_drivers_selected) + '", ')
1938
1939if get_option('cfi')
1940  cfi_flags=[]
1941  # Check for dependency on LTO
1942  if not get_option('b_lto')
1943    error('Selected Control-Flow Integrity but LTO is disabled')
1944  endif
1945  if enable_modules
1946    error('Selected Control-Flow Integrity is not compatible with modules')
1947  endif
1948  # Check for cfi flags. CFI requires LTO so we can't use
1949  # get_supported_arguments, but need a more complex "compiles" which allows
1950  # custom arguments
1951  if cc.compiles('int main () { return 0; }', name: '-fsanitize=cfi-icall',
1952                 args: ['-flto', '-fsanitize=cfi-icall'] )
1953    cfi_flags += '-fsanitize=cfi-icall'
1954  else
1955    error('-fsanitize=cfi-icall is not supported by the compiler')
1956  endif
1957  if cc.compiles('int main () { return 0; }',
1958                 name: '-fsanitize-cfi-icall-generalize-pointers',
1959                 args: ['-flto', '-fsanitize=cfi-icall',
1960                        '-fsanitize-cfi-icall-generalize-pointers'] )
1961    cfi_flags += '-fsanitize-cfi-icall-generalize-pointers'
1962  else
1963    error('-fsanitize-cfi-icall-generalize-pointers is not supported by the compiler')
1964  endif
1965  if get_option('cfi_debug')
1966    if cc.compiles('int main () { return 0; }',
1967                   name: '-fno-sanitize-trap=cfi-icall',
1968                   args: ['-flto', '-fsanitize=cfi-icall',
1969                          '-fno-sanitize-trap=cfi-icall'] )
1970      cfi_flags += '-fno-sanitize-trap=cfi-icall'
1971    else
1972      error('-fno-sanitize-trap=cfi-icall is not supported by the compiler')
1973    endif
1974  endif
1975  add_global_arguments(cfi_flags, native: false, language: all_languages)
1976  add_global_link_arguments(cfi_flags, native: false, language: all_languages)
1977endif
1978
1979have_host_block_device = (targetos != 'darwin' or
1980    cc.has_header('IOKit/storage/IOMedia.h'))
1981
1982dbus_display = get_option('dbus_display') \
1983  .require(gio.version().version_compare('>=2.64'),
1984           error_message: '-display dbus requires glib>=2.64') \
1985  .require(gdbus_codegen.found(),
1986           error_message: gdbus_codegen_error.format('-display dbus')) \
1987  .require(targetos != 'windows',
1988           error_message: '-display dbus is not available on Windows') \
1989  .allowed()
1990
1991have_virtfs = get_option('virtfs') \
1992    .require(targetos == 'linux' or targetos == 'darwin',
1993             error_message: 'virtio-9p (virtfs) requires Linux or macOS') \
1994    .require(targetos == 'linux' or cc.has_function('pthread_fchdir_np'),
1995             error_message: 'virtio-9p (virtfs) on macOS requires the presence of pthread_fchdir_np') \
1996    .require(targetos == 'darwin' or libattr.found(),
1997             error_message: 'virtio-9p (virtfs) on Linux requires libattr-devel') \
1998    .disable_auto_if(not have_tools and not have_system) \
1999    .allowed()
2000
2001have_virtfs_proxy_helper = get_option('virtfs_proxy_helper') \
2002    .require(targetos != 'darwin', error_message: 'the virtfs proxy helper is incompatible with macOS') \
2003    .require(have_virtfs, error_message: 'the virtfs proxy helper requires that virtfs is enabled') \
2004    .disable_auto_if(not have_tools) \
2005    .require(libcap_ng.found(), error_message: 'the virtfs proxy helper requires libcap-ng') \
2006    .allowed()
2007
2008if get_option('block_drv_ro_whitelist') == ''
2009  config_host_data.set('CONFIG_BDRV_RO_WHITELIST', '')
2010else
2011  config_host_data.set('CONFIG_BDRV_RO_WHITELIST',
2012        '"' + get_option('block_drv_ro_whitelist').replace(',', '", "') + '", ')
2013endif
2014if get_option('block_drv_rw_whitelist') == ''
2015  config_host_data.set('CONFIG_BDRV_RW_WHITELIST', '')
2016else
2017  config_host_data.set('CONFIG_BDRV_RW_WHITELIST',
2018        '"' + get_option('block_drv_rw_whitelist').replace(',', '", "') + '", ')
2019endif
2020
2021foreach k : get_option('trace_backends')
2022  config_host_data.set('CONFIG_TRACE_' + k.to_upper(), true)
2023endforeach
2024config_host_data.set_quoted('CONFIG_TRACE_FILE', get_option('trace_file'))
2025config_host_data.set_quoted('CONFIG_TLS_PRIORITY', get_option('tls_priority'))
2026if iasl.found()
2027  config_host_data.set_quoted('CONFIG_IASL', iasl.full_path())
2028endif
2029config_host_data.set_quoted('CONFIG_BINDIR', get_option('prefix') / get_option('bindir'))
2030config_host_data.set_quoted('CONFIG_PREFIX', get_option('prefix'))
2031config_host_data.set_quoted('CONFIG_QEMU_CONFDIR', get_option('prefix') / qemu_confdir)
2032config_host_data.set_quoted('CONFIG_QEMU_DATADIR', get_option('prefix') / qemu_datadir)
2033config_host_data.set_quoted('CONFIG_QEMU_DESKTOPDIR', get_option('prefix') / qemu_desktopdir)
2034
2035qemu_firmwarepath = ''
2036foreach k : get_option('qemu_firmwarepath')
2037  qemu_firmwarepath += '"' + get_option('prefix') / k + '", '
2038endforeach
2039config_host_data.set('CONFIG_QEMU_FIRMWAREPATH', qemu_firmwarepath)
2040
2041config_host_data.set_quoted('CONFIG_QEMU_HELPERDIR', get_option('prefix') / get_option('libexecdir'))
2042config_host_data.set_quoted('CONFIG_QEMU_ICONDIR', get_option('prefix') / qemu_icondir)
2043config_host_data.set_quoted('CONFIG_QEMU_LOCALEDIR', get_option('prefix') / get_option('localedir'))
2044config_host_data.set_quoted('CONFIG_QEMU_LOCALSTATEDIR', get_option('prefix') / get_option('localstatedir'))
2045config_host_data.set_quoted('CONFIG_QEMU_MODDIR', get_option('prefix') / qemu_moddir)
2046config_host_data.set_quoted('CONFIG_SYSCONFDIR', get_option('prefix') / get_option('sysconfdir'))
2047
2048if enable_modules
2049  config_host_data.set('CONFIG_STAMP', run_command(
2050      meson.current_source_dir() / 'scripts/qemu-stamp.py',
2051      meson.project_version(), get_option('pkgversion'), '--',
2052      meson.current_source_dir() / 'configure',
2053      capture: true, check: true).stdout().strip())
2054endif
2055
2056have_slirp_smbd = get_option('slirp_smbd') \
2057  .require(targetos != 'windows', error_message: 'Host smbd not supported on this platform.') \
2058  .allowed()
2059if have_slirp_smbd
2060  smbd_path = get_option('smbd')
2061  if smbd_path == ''
2062    smbd_path = (targetos == 'solaris' ? '/usr/sfw/sbin/smbd' : '/usr/sbin/smbd')
2063  endif
2064  config_host_data.set_quoted('CONFIG_SMBD_COMMAND', smbd_path)
2065endif
2066
2067config_host_data.set('HOST_' + host_arch.to_upper(), 1)
2068
2069if get_option('module_upgrades') and not enable_modules
2070  error('Cannot enable module-upgrades as modules are not enabled')
2071endif
2072config_host_data.set('CONFIG_MODULE_UPGRADES', get_option('module_upgrades'))
2073
2074config_host_data.set('CONFIG_ATTR', libattr.found())
2075config_host_data.set('CONFIG_BDRV_WHITELIST_TOOLS', get_option('block_drv_whitelist_in_tools'))
2076config_host_data.set('CONFIG_BRLAPI', brlapi.found())
2077config_host_data.set('CONFIG_COCOA', cocoa.found())
2078config_host_data.set('CONFIG_FUZZ', get_option('fuzzing'))
2079config_host_data.set('CONFIG_GCOV', get_option('b_coverage'))
2080config_host_data.set('CONFIG_LIBUDEV', libudev.found())
2081config_host_data.set('CONFIG_LZO', lzo.found())
2082config_host_data.set('CONFIG_MPATH', mpathpersist.found())
2083config_host_data.set('CONFIG_BLKIO', blkio.found())
2084if blkio.found()
2085  config_host_data.set('CONFIG_BLKIO_VHOST_VDPA_FD',
2086                       blkio.version().version_compare('>=1.3.0'))
2087endif
2088config_host_data.set('CONFIG_CURL', curl.found())
2089config_host_data.set('CONFIG_CURSES', curses.found())
2090config_host_data.set('CONFIG_GBM', gbm.found())
2091config_host_data.set('CONFIG_GIO', gio.found())
2092config_host_data.set('CONFIG_GLUSTERFS', glusterfs.found())
2093if glusterfs.found()
2094  config_host_data.set('CONFIG_GLUSTERFS_XLATOR_OPT', glusterfs.version().version_compare('>=4'))
2095  config_host_data.set('CONFIG_GLUSTERFS_DISCARD', glusterfs.version().version_compare('>=5'))
2096  config_host_data.set('CONFIG_GLUSTERFS_FALLOCATE', glusterfs.version().version_compare('>=6'))
2097  config_host_data.set('CONFIG_GLUSTERFS_ZEROFILL', glusterfs.version().version_compare('>=6'))
2098  config_host_data.set('CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT', glusterfs_ftruncate_has_stat)
2099  config_host_data.set('CONFIG_GLUSTERFS_IOCB_HAS_STAT', glusterfs_iocb_has_stat)
2100endif
2101config_host_data.set('CONFIG_GTK', gtk.found())
2102config_host_data.set('CONFIG_VTE', vte.found())
2103config_host_data.set('CONFIG_GTK_CLIPBOARD', have_gtk_clipboard)
2104config_host_data.set('CONFIG_HEXAGON_IDEF_PARSER', get_option('hexagon_idef_parser'))
2105config_host_data.set('CONFIG_LIBATTR', have_old_libattr)
2106config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found())
2107config_host_data.set('CONFIG_EBPF', libbpf.found())
2108config_host_data.set('CONFIG_LIBDAXCTL', libdaxctl.found())
2109config_host_data.set('CONFIG_LIBISCSI', libiscsi.found())
2110config_host_data.set('CONFIG_LIBNFS', libnfs.found())
2111config_host_data.set('CONFIG_LIBSSH', libssh.found())
2112config_host_data.set('CONFIG_LINUX_AIO', libaio.found())
2113config_host_data.set('CONFIG_LINUX_IO_URING', linux_io_uring.found())
2114config_host_data.set('CONFIG_LIBPMEM', libpmem.found())
2115config_host_data.set('CONFIG_MODULES', enable_modules)
2116config_host_data.set('CONFIG_NUMA', numa.found())
2117if numa.found()
2118  config_host_data.set('HAVE_NUMA_HAS_PREFERRED_MANY',
2119                       cc.has_function('numa_has_preferred_many',
2120                                       dependencies: numa))
2121endif
2122config_host_data.set('CONFIG_OPENGL', opengl.found())
2123config_host_data.set('CONFIG_PROFILER', get_option('profiler'))
2124config_host_data.set('CONFIG_RBD', rbd.found())
2125config_host_data.set('CONFIG_RDMA', rdma.found())
2126config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
2127config_host_data.set('CONFIG_SDL', sdl.found())
2128config_host_data.set('CONFIG_SDL_IMAGE', sdl_image.found())
2129config_host_data.set('CONFIG_SECCOMP', seccomp.found())
2130if seccomp.found()
2131  config_host_data.set('CONFIG_SECCOMP_SYSRAWRC', seccomp_has_sysrawrc)
2132endif
2133config_host_data.set('CONFIG_SNAPPY', snappy.found())
2134config_host_data.set('CONFIG_TPM', have_tpm)
2135config_host_data.set('CONFIG_TSAN', get_option('tsan'))
2136config_host_data.set('CONFIG_USB_LIBUSB', libusb.found())
2137config_host_data.set('CONFIG_VDE', vde.found())
2138config_host_data.set('CONFIG_VHOST_NET', have_vhost_net)
2139config_host_data.set('CONFIG_VHOST_NET_USER', have_vhost_net_user)
2140config_host_data.set('CONFIG_VHOST_NET_VDPA', have_vhost_net_vdpa)
2141config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
2142config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
2143config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
2144config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
2145config_host_data.set('CONFIG_VMNET', vmnet.found())
2146config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
2147config_host_data.set('CONFIG_VDUSE_BLK_EXPORT', have_vduse_blk_export)
2148config_host_data.set('CONFIG_PNG', png.found())
2149config_host_data.set('CONFIG_VNC', vnc.found())
2150config_host_data.set('CONFIG_VNC_JPEG', jpeg.found())
2151config_host_data.set('CONFIG_VNC_SASL', sasl.found())
2152config_host_data.set('CONFIG_VIRTFS', have_virtfs)
2153config_host_data.set('CONFIG_VTE', vte.found())
2154config_host_data.set('CONFIG_XKBCOMMON', xkbcommon.found())
2155config_host_data.set('CONFIG_KEYUTILS', keyutils.found())
2156config_host_data.set('CONFIG_GETTID', has_gettid)
2157config_host_data.set('CONFIG_GNUTLS', gnutls.found())
2158config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found())
2159config_host_data.set('CONFIG_TASN1', tasn1.found())
2160config_host_data.set('CONFIG_GCRYPT', gcrypt.found())
2161config_host_data.set('CONFIG_NETTLE', nettle.found())
2162config_host_data.set('CONFIG_HOGWEED', hogweed.found())
2163config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts == 'private')
2164config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim)
2165config_host_data.set('CONFIG_STATX', has_statx)
2166config_host_data.set('CONFIG_STATX_MNT_ID', has_statx_mnt_id)
2167config_host_data.set('CONFIG_ZSTD', zstd.found())
2168config_host_data.set('CONFIG_FUSE', fuse.found())
2169config_host_data.set('CONFIG_FUSE_LSEEK', fuse_lseek.found())
2170config_host_data.set('CONFIG_SPICE_PROTOCOL', spice_protocol.found())
2171if spice_protocol.found()
2172config_host_data.set('CONFIG_SPICE_PROTOCOL_MAJOR', spice_protocol.version().split('.')[0])
2173config_host_data.set('CONFIG_SPICE_PROTOCOL_MINOR', spice_protocol.version().split('.')[1])
2174config_host_data.set('CONFIG_SPICE_PROTOCOL_MICRO', spice_protocol.version().split('.')[2])
2175endif
2176config_host_data.set('CONFIG_SPICE', spice.found())
2177config_host_data.set('CONFIG_X11', x11.found())
2178config_host_data.set('CONFIG_DBUS_DISPLAY', dbus_display)
2179config_host_data.set('CONFIG_CFI', get_option('cfi'))
2180config_host_data.set('CONFIG_SELINUX', selinux.found())
2181config_host_data.set('CONFIG_XEN_BACKEND', xen.found())
2182config_host_data.set('CONFIG_LIBDW', libdw.found())
2183if xen.found()
2184  # protect from xen.version() having less than three components
2185  xen_version = xen.version().split('.') + ['0', '0']
2186  xen_ctrl_version = xen_version[0] + \
2187    ('0' + xen_version[1]).substring(-2) + \
2188    ('0' + xen_version[2]).substring(-2)
2189  config_host_data.set('CONFIG_XEN_CTRL_INTERFACE_VERSION', xen_ctrl_version)
2190endif
2191config_host_data.set('QEMU_VERSION', '"@0@"'.format(meson.project_version()))
2192config_host_data.set('QEMU_VERSION_MAJOR', meson.project_version().split('.')[0])
2193config_host_data.set('QEMU_VERSION_MINOR', meson.project_version().split('.')[1])
2194config_host_data.set('QEMU_VERSION_MICRO', meson.project_version().split('.')[2])
2195
2196config_host_data.set_quoted('CONFIG_HOST_DSOSUF', host_dsosuf)
2197config_host_data.set('HAVE_HOST_BLOCK_DEVICE', have_host_block_device)
2198
2199have_coroutine_pool = get_option('coroutine_pool')
2200if get_option('debug_stack_usage') and have_coroutine_pool
2201  message('Disabling coroutine pool to measure stack usage')
2202  have_coroutine_pool = false
2203endif
2204config_host_data.set10('CONFIG_COROUTINE_POOL', have_coroutine_pool)
2205config_host_data.set('CONFIG_DEBUG_GRAPH_LOCK', get_option('debug_graph_lock'))
2206config_host_data.set('CONFIG_DEBUG_MUTEX', get_option('debug_mutex'))
2207config_host_data.set('CONFIG_DEBUG_STACK_USAGE', get_option('debug_stack_usage'))
2208config_host_data.set('CONFIG_GPROF', get_option('gprof'))
2209config_host_data.set('CONFIG_LIVE_BLOCK_MIGRATION', get_option('live_block_migration').allowed())
2210config_host_data.set('CONFIG_QOM_CAST_DEBUG', get_option('qom_cast_debug'))
2211config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed())
2212
2213# has_header
2214config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
2215config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
2216config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
2217config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
2218config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
2219config_host_data.set('HAVE_PTY_H', cc.has_header('pty.h'))
2220config_host_data.set('HAVE_SYS_DISK_H', cc.has_header('sys/disk.h'))
2221config_host_data.set('HAVE_SYS_IOCCOM_H', cc.has_header('sys/ioccom.h'))
2222config_host_data.set('HAVE_SYS_KCOV_H', cc.has_header('sys/kcov.h'))
2223if targetos == 'windows'
2224  config_host_data.set('HAVE_AFUNIX_H', cc.has_header('afunix.h'))
2225endif
2226
2227# has_function
2228config_host_data.set('CONFIG_CLOSE_RANGE', cc.has_function('close_range'))
2229config_host_data.set('CONFIG_ACCEPT4', cc.has_function('accept4'))
2230config_host_data.set('CONFIG_CLOCK_ADJTIME', cc.has_function('clock_adjtime'))
2231config_host_data.set('CONFIG_DUP3', cc.has_function('dup3'))
2232config_host_data.set('CONFIG_FALLOCATE', cc.has_function('fallocate'))
2233config_host_data.set('CONFIG_POSIX_FALLOCATE', cc.has_function('posix_fallocate'))
2234# Note that we need to specify prefix: here to avoid incorrectly
2235# thinking that Windows has posix_memalign()
2236config_host_data.set('CONFIG_POSIX_MEMALIGN', cc.has_function('posix_memalign', prefix: '#include <stdlib.h>'))
2237config_host_data.set('CONFIG_ALIGNED_MALLOC', cc.has_function('_aligned_malloc'))
2238config_host_data.set('CONFIG_VALLOC', cc.has_function('valloc'))
2239config_host_data.set('CONFIG_MEMALIGN', cc.has_function('memalign'))
2240config_host_data.set('CONFIG_PPOLL', cc.has_function('ppoll'))
2241config_host_data.set('CONFIG_PREADV', cc.has_function('preadv', prefix: '#include <sys/uio.h>'))
2242config_host_data.set('CONFIG_PTHREAD_FCHDIR_NP', cc.has_function('pthread_fchdir_np'))
2243config_host_data.set('CONFIG_SENDFILE', cc.has_function('sendfile'))
2244config_host_data.set('CONFIG_SETNS', cc.has_function('setns') and cc.has_function('unshare'))
2245config_host_data.set('CONFIG_SYNCFS', cc.has_function('syncfs'))
2246config_host_data.set('CONFIG_SYNC_FILE_RANGE', cc.has_function('sync_file_range'))
2247config_host_data.set('CONFIG_TIMERFD', cc.has_function('timerfd_create'))
2248config_host_data.set('HAVE_COPY_FILE_RANGE', cc.has_function('copy_file_range'))
2249config_host_data.set('HAVE_GETIFADDRS', cc.has_function('getifaddrs'))
2250config_host_data.set('HAVE_GLIB_WITH_SLICE_ALLOCATOR', glib_has_gslice)
2251config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
2252config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
2253config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
2254if rbd.found()
2255  config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
2256                       cc.has_function('rbd_namespace_exists',
2257                                       dependencies: rbd,
2258                                       prefix: '#include <rbd/librbd.h>'))
2259endif
2260if rdma.found()
2261  config_host_data.set('HAVE_IBV_ADVISE_MR',
2262                       cc.has_function('ibv_advise_mr',
2263                                       dependencies: rdma,
2264                                       prefix: '#include <infiniband/verbs.h>'))
2265endif
2266
2267have_asan_fiber = false
2268if get_option('sanitizers') and \
2269   not cc.has_function('__sanitizer_start_switch_fiber',
2270                         args: '-fsanitize=address',
2271                         prefix: '#include <sanitizer/asan_interface.h>')
2272  warning('Missing ASAN due to missing fiber annotation interface')
2273  warning('Without code annotation, the report may be inferior.')
2274else
2275  have_asan_fiber = true
2276endif
2277config_host_data.set('CONFIG_ASAN_IFACE_FIBER', have_asan_fiber)
2278
2279# has_header_symbol
2280config_host_data.set('CONFIG_BLKZONED',
2281                     cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE'))
2282config_host_data.set('CONFIG_EPOLL_CREATE1',
2283                     cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
2284config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
2285                     cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
2286                     cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
2287config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
2288                     cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
2289config_host_data.set('CONFIG_FIEMAP',
2290                     cc.has_header('linux/fiemap.h') and
2291                     cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
2292config_host_data.set('CONFIG_GETRANDOM',
2293                     cc.has_function('getrandom') and
2294                     cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
2295config_host_data.set('CONFIG_INOTIFY',
2296                     cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
2297config_host_data.set('CONFIG_INOTIFY1',
2298                     cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
2299config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
2300                     cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
2301config_host_data.set('CONFIG_RTNETLINK',
2302                     cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
2303config_host_data.set('CONFIG_SYSMACROS',
2304                     cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
2305config_host_data.set('HAVE_OPTRESET',
2306                     cc.has_header_symbol('getopt.h', 'optreset'))
2307config_host_data.set('HAVE_IPPROTO_MPTCP',
2308                     cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
2309
2310# has_member
2311config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
2312                     cc.has_member('struct sigevent', 'sigev_notify_thread_id',
2313                                   prefix: '#include <signal.h>'))
2314config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
2315                     cc.has_member('struct stat', 'st_atim',
2316                                   prefix: '#include <sys/stat.h>'))
2317config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY',
2318                     cc.has_member('struct blk_zone', 'capacity',
2319                                   prefix: '#include <linux/blkzoned.h>'))
2320
2321# has_type
2322config_host_data.set('CONFIG_IOVEC',
2323                     cc.has_type('struct iovec',
2324                                 prefix: '#include <sys/uio.h>'))
2325config_host_data.set('HAVE_UTMPX',
2326                     cc.has_type('struct utmpx',
2327                                 prefix: '#include <utmpx.h>'))
2328
2329config_host_data.set('CONFIG_EVENTFD', cc.links('''
2330  #include <sys/eventfd.h>
2331  int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
2332config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
2333  #include <unistd.h>
2334  int main(void) {
2335  #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
2336  return fdatasync(0);
2337  #else
2338  #error Not supported
2339  #endif
2340  }'''))
2341
2342has_madvise = cc.links(gnu_source_prefix + '''
2343  #include <sys/types.h>
2344  #include <sys/mman.h>
2345  #include <stddef.h>
2346  int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
2347missing_madvise_proto = false
2348if has_madvise
2349  # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
2350  # but forget to prototype it. In this case, has_madvise will be true (the
2351  # test program links despite a compile warning). To detect the
2352  # missing-prototype case, we try again with a definitely-bogus prototype.
2353  # This will only compile if the system headers don't provide the prototype;
2354  # otherwise the conflicting prototypes will cause a compiler error.
2355  missing_madvise_proto = cc.links(gnu_source_prefix + '''
2356    #include <sys/types.h>
2357    #include <sys/mman.h>
2358    #include <stddef.h>
2359    extern int madvise(int);
2360    int main(void) { return madvise(0); }''')
2361endif
2362config_host_data.set('CONFIG_MADVISE', has_madvise)
2363config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
2364
2365config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
2366  #include <sys/mman.h>
2367  int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
2368config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
2369  #include <fcntl.h>
2370  #if !defined(AT_EMPTY_PATH)
2371  # error missing definition
2372  #else
2373  int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
2374  #endif'''))
2375config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
2376  #include <sys/mman.h>
2377  #include <stddef.h>
2378  int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
2379
2380config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
2381  #include <pthread.h>
2382
2383  static void *f(void *p) { return NULL; }
2384  int main(void)
2385  {
2386    pthread_t thread;
2387    pthread_create(&thread, 0, f, 0);
2388    pthread_setname_np(thread, "QEMU");
2389    return 0;
2390  }''', dependencies: threads))
2391config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
2392  #include <pthread.h>
2393
2394  static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
2395  int main(void)
2396  {
2397    pthread_t thread;
2398    pthread_create(&thread, 0, f, 0);
2399    return 0;
2400  }''', dependencies: threads))
2401config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + '''
2402  #include <pthread.h>
2403  #include <pthread_np.h>
2404
2405  static void *f(void *p) { return NULL; }
2406  int main(void)
2407  {
2408    pthread_t thread;
2409    pthread_create(&thread, 0, f, 0);
2410    pthread_set_name_np(thread, "QEMU");
2411    return 0;
2412  }''', dependencies: threads))
2413config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
2414  #include <pthread.h>
2415  #include <time.h>
2416
2417  int main(void)
2418  {
2419    pthread_condattr_t attr
2420    pthread_condattr_init(&attr);
2421    pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
2422    return 0;
2423  }''', dependencies: threads))
2424config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + '''
2425  #include <pthread.h>
2426
2427  static void *f(void *p) { return NULL; }
2428  int main(void)
2429  {
2430    int setsize = CPU_ALLOC_SIZE(64);
2431    pthread_t thread;
2432    cpu_set_t *cpuset;
2433    pthread_create(&thread, 0, f, 0);
2434    cpuset = CPU_ALLOC(64);
2435    CPU_ZERO_S(setsize, cpuset);
2436    pthread_setaffinity_np(thread, setsize, cpuset);
2437    pthread_getaffinity_np(thread, setsize, cpuset);
2438    CPU_FREE(cpuset);
2439    return 0;
2440  }''', dependencies: threads))
2441config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
2442  #include <sys/signalfd.h>
2443  #include <stddef.h>
2444  int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
2445config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
2446  #include <unistd.h>
2447  #include <fcntl.h>
2448  #include <limits.h>
2449
2450  int main(void)
2451  {
2452    int len, fd = 0;
2453    len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
2454    splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
2455    return 0;
2456  }'''))
2457
2458config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
2459  #include <sys/mman.h>
2460  int main(void) {
2461    return mlockall(MCL_FUTURE);
2462  }'''))
2463
2464have_l2tpv3 = false
2465if get_option('l2tpv3').allowed() and have_system
2466  have_l2tpv3 = cc.has_type('struct mmsghdr',
2467    prefix: gnu_source_prefix + '''
2468      #include <sys/socket.h>
2469      #include <linux/ip.h>''')
2470endif
2471config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
2472
2473have_netmap = false
2474if get_option('netmap').allowed() and have_system
2475  have_netmap = cc.compiles('''
2476    #include <inttypes.h>
2477    #include <net/if.h>
2478    #include <net/netmap.h>
2479    #include <net/netmap_user.h>
2480    #if (NETMAP_API < 11) || (NETMAP_API > 15)
2481    #error
2482    #endif
2483    int main(void) { return 0; }''')
2484  if not have_netmap and get_option('netmap').enabled()
2485    error('Netmap headers not available')
2486  endif
2487endif
2488config_host_data.set('CONFIG_NETMAP', have_netmap)
2489
2490# Work around a system header bug with some kernel/XFS header
2491# versions where they both try to define 'struct fsxattr':
2492# xfs headers will not try to redefine structs from linux headers
2493# if this macro is set.
2494config_host_data.set('HAVE_FSXATTR', cc.links('''
2495  #include <linux/fs.h>
2496  struct fsxattr foo;
2497  int main(void) {
2498    return 0;
2499  }'''))
2500
2501# Some versions of Mac OS X incorrectly define SIZE_MAX
2502config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
2503    #include <stdint.h>
2504    #include <stdio.h>
2505    int main(void) {
2506        return printf("%zu", SIZE_MAX);
2507    }''', args: ['-Werror']))
2508
2509# See if 64-bit atomic operations are supported.
2510# Note that without __atomic builtins, we can only
2511# assume atomic loads/stores max at pointer size.
2512config_host_data.set('CONFIG_ATOMIC64', cc.links('''
2513  #include <stdint.h>
2514  int main(void)
2515  {
2516    uint64_t x = 0, y = 0;
2517    y = __atomic_load_n(&x, __ATOMIC_RELAXED);
2518    __atomic_store_n(&x, y, __ATOMIC_RELAXED);
2519    __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2520    __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
2521    __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
2522    return 0;
2523  }'''))
2524
2525has_int128_type = cc.compiles('''
2526  __int128_t a;
2527  __uint128_t b;
2528  int main(void) { b = a; }''')
2529config_host_data.set('CONFIG_INT128_TYPE', has_int128_type)
2530
2531has_int128 = has_int128_type and cc.links('''
2532  __int128_t a;
2533  __uint128_t b;
2534  int main (void) {
2535    a = a + b;
2536    b = a * b;
2537    a = a * a;
2538    return 0;
2539  }''')
2540config_host_data.set('CONFIG_INT128', has_int128)
2541
2542if has_int128_type
2543  # "do we have 128-bit atomics which are handled inline and specifically not
2544  # via libatomic". The reason we can't use libatomic is documented in the
2545  # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
2546  # We only care about these operations on 16-byte aligned pointers, so
2547  # force 16-byte alignment of the pointer, which may be greater than
2548  # __alignof(unsigned __int128) for the host.
2549  atomic_test_128 = '''
2550    int main(int ac, char **av) {
2551      __uint128_t *p = __builtin_assume_aligned(av[ac - 1], 16);
2552      p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED);
2553      __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED);
2554      __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2555      return 0;
2556    }'''
2557  has_atomic128 = cc.links(atomic_test_128)
2558
2559  config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
2560
2561  if not has_atomic128
2562    # Even with __builtin_assume_aligned, the above test may have failed
2563    # without optimization enabled.  Try again with optimizations locally
2564    # enabled for the function.  See
2565    #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389
2566    has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128)
2567    config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt)
2568
2569    if not has_atomic128_opt
2570      config_host_data.set('CONFIG_CMPXCHG128', cc.links('''
2571        int main(void)
2572        {
2573          __uint128_t x = 0, y = 0;
2574          __sync_val_compare_and_swap_16(&x, y, x);
2575          return 0;
2576        }
2577      '''))
2578    endif
2579  endif
2580endif
2581
2582config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
2583  #include <sys/auxv.h>
2584  int main(void) {
2585    return getauxval(AT_HWCAP) == 0;
2586  }'''))
2587
2588config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles('''
2589  #include <linux/usbdevice_fs.h>
2590
2591  #ifndef USBDEVFS_GET_CAPABILITIES
2592  #error "USBDEVFS_GET_CAPABILITIES undefined"
2593  #endif
2594
2595  #ifndef USBDEVFS_DISCONNECT_CLAIM
2596  #error "USBDEVFS_DISCONNECT_CLAIM undefined"
2597  #endif
2598
2599  int main(void) { return 0; }'''))
2600
2601have_keyring = get_option('keyring') \
2602  .require(targetos == 'linux', error_message: 'keyring is only available on Linux') \
2603  .require(cc.compiles('''
2604    #include <errno.h>
2605    #include <asm/unistd.h>
2606    #include <linux/keyctl.h>
2607    #include <sys/syscall.h>
2608    #include <unistd.h>
2609    int main(void) {
2610        return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0);
2611    }'''), error_message: 'keyctl syscall not available on this system').allowed()
2612config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring)
2613
2614have_cpuid_h = cc.links('''
2615  #include <cpuid.h>
2616  int main(void) {
2617    unsigned a, b, c, d;
2618    unsigned max = __get_cpuid_max(0, 0);
2619
2620    if (max >= 1) {
2621        __cpuid(1, a, b, c, d);
2622    }
2623
2624    if (max >= 7) {
2625        __cpuid_count(7, 0, a, b, c, d);
2626    }
2627
2628    return 0;
2629  }''')
2630config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
2631
2632config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
2633  .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
2634  .require(cc.links('''
2635    #include <cpuid.h>
2636    #include <immintrin.h>
2637    static int __attribute__((target("avx2"))) bar(void *a) {
2638      __m256i x = *(__m256i *)a;
2639      return _mm256_testz_si256(x, x);
2640    }
2641    int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2642  '''), error_message: 'AVX2 not available').allowed())
2643
2644config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
2645  .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
2646  .require(cc.links('''
2647    #include <cpuid.h>
2648    #include <immintrin.h>
2649    static int __attribute__((target("avx512f"))) bar(void *a) {
2650      __m512i x = *(__m512i *)a;
2651      return _mm512_test_epi64_mask(x, x);
2652    }
2653    int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2654  '''), error_message: 'AVX512F not available').allowed())
2655
2656config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \
2657  .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \
2658  .require(cc.links('''
2659    #include <cpuid.h>
2660    #include <immintrin.h>
2661    static int __attribute__((target("avx512bw"))) bar(void *a) {
2662      __m512i *x = a;
2663      __m512i res= _mm512_abs_epi8(*x);
2664      return res[1];
2665    }
2666    int main(int argc, char *argv[]) { return bar(argv[0]); }
2667  '''), error_message: 'AVX512BW not available').allowed())
2668
2669have_pvrdma = get_option('pvrdma') \
2670  .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \
2671  .require(cc.compiles(gnu_source_prefix + '''
2672    #include <sys/mman.h>
2673    int main(void)
2674    {
2675      char buf = 0;
2676      void *addr = &buf;
2677      addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED);
2678
2679      return 0;
2680    }'''), error_message: 'PVRDMA requires mremap').allowed()
2681
2682if have_pvrdma
2683  config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links('''
2684    #include <infiniband/verbs.h>
2685    int main(void)
2686    {
2687      struct ibv_mr *mr;
2688      struct ibv_pd *pd = NULL;
2689      size_t length = 10;
2690      uint64_t iova = 0;
2691      int access = 0;
2692      void *addr = NULL;
2693
2694      mr = ibv_reg_mr_iova(pd, addr, length, iova, access);
2695      ibv_dereg_mr(mr);
2696      return 0;
2697    }'''))
2698endif
2699
2700if get_option('membarrier').disabled()
2701  have_membarrier = false
2702elif targetos == 'windows'
2703  have_membarrier = true
2704elif targetos == 'linux'
2705  have_membarrier = cc.compiles('''
2706    #include <linux/membarrier.h>
2707    #include <sys/syscall.h>
2708    #include <unistd.h>
2709    #include <stdlib.h>
2710    int main(void) {
2711        syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
2712        syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
2713        exit(0);
2714    }''')
2715endif
2716config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
2717  .require(have_membarrier, error_message: 'membarrier system call not available') \
2718  .allowed())
2719
2720have_afalg = get_option('crypto_afalg') \
2721  .require(cc.compiles(gnu_source_prefix + '''
2722    #include <errno.h>
2723    #include <sys/types.h>
2724    #include <sys/socket.h>
2725    #include <linux/if_alg.h>
2726    int main(void) {
2727      int sock;
2728      sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
2729      return sock;
2730    }
2731  '''), error_message: 'AF_ALG requested but could not be detected').allowed()
2732config_host_data.set('CONFIG_AF_ALG', have_afalg)
2733
2734config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
2735  'linux/vm_sockets.h', 'AF_VSOCK',
2736  prefix: '#include <sys/socket.h>',
2737))
2738
2739have_vss = false
2740have_vss_sdk = false # old xp/2003 SDK
2741if targetos == 'windows' and link_language == 'cpp'
2742  have_vss = cxx.compiles('''
2743    #define __MIDL_user_allocate_free_DEFINED__
2744    #include <vss.h>
2745    int main(void) { return VSS_CTX_BACKUP; }''')
2746  have_vss_sdk = cxx.has_header('vscoordint.h')
2747endif
2748config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2749
2750foreach k, v: config_host
2751  if k.startswith('CONFIG_')
2752    config_host_data.set(k, v == 'y' ? 1 : v)
2753  endif
2754endforeach
2755
2756# Older versions of MinGW do not import _lock_file and _unlock_file properly.
2757# This was fixed for v6.0.0 with commit b48e3ac8969d.
2758if targetos == 'windows'
2759  config_host_data.set('HAVE__LOCK_FILE', cc.links('''
2760    #include <stdio.h>
2761    int main(void) {
2762      _lock_file(NULL);
2763      _unlock_file(NULL);
2764      return 0;
2765    }''', name: '_lock_file and _unlock_file'))
2766endif
2767
2768if targetos == 'windows'
2769  mingw_has_setjmp_longjmp = cc.links('''
2770    #include <setjmp.h>
2771    int main(void) {
2772      /*
2773       * These functions are not available in setjmp header, but may be
2774       * available at link time, from libmingwex.a.
2775       */
2776      extern int __mingw_setjmp(jmp_buf);
2777      extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int);
2778      jmp_buf env;
2779      __mingw_setjmp(env);
2780      __mingw_longjmp(env, 0);
2781    }
2782  ''', name: 'mingw setjmp and longjmp')
2783
2784  if cpu == 'aarch64' and not mingw_has_setjmp_longjmp
2785    error('mingw must provide setjmp/longjmp for windows-arm64')
2786  endif
2787endif
2788
2789########################
2790# Target configuration #
2791########################
2792
2793minikconf = find_program('scripts/minikconf.py')
2794config_all = {}
2795config_all_devices = {}
2796config_all_disas = {}
2797config_devices_mak_list = []
2798config_devices_h = {}
2799config_target_h = {}
2800config_target_mak = {}
2801
2802disassemblers = {
2803  'alpha' : ['CONFIG_ALPHA_DIS'],
2804  'avr' : ['CONFIG_AVR_DIS'],
2805  'cris' : ['CONFIG_CRIS_DIS'],
2806  'hexagon' : ['CONFIG_HEXAGON_DIS'],
2807  'hppa' : ['CONFIG_HPPA_DIS'],
2808  'i386' : ['CONFIG_I386_DIS'],
2809  'x86_64' : ['CONFIG_I386_DIS'],
2810  'm68k' : ['CONFIG_M68K_DIS'],
2811  'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2812  'mips' : ['CONFIG_MIPS_DIS'],
2813  'nios2' : ['CONFIG_NIOS2_DIS'],
2814  'or1k' : ['CONFIG_OPENRISC_DIS'],
2815  'ppc' : ['CONFIG_PPC_DIS'],
2816  'riscv' : ['CONFIG_RISCV_DIS'],
2817  'rx' : ['CONFIG_RX_DIS'],
2818  's390' : ['CONFIG_S390_DIS'],
2819  'sh4' : ['CONFIG_SH4_DIS'],
2820  'sparc' : ['CONFIG_SPARC_DIS'],
2821  'xtensa' : ['CONFIG_XTENSA_DIS'],
2822  'loongarch' : ['CONFIG_LOONGARCH_DIS'],
2823}
2824
2825have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2826host_kconfig = \
2827  (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2828  (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2829  (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2830  (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2831  (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
2832  (x11.found() ? ['CONFIG_X11=y'] : []) + \
2833  (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
2834  (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2835  (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2836  (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2837  ('CONFIG_LINUX' in config_host ? ['CONFIG_LINUX=y'] : []) + \
2838  (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
2839  (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
2840  (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : [])
2841
2842ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2843
2844default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2845actual_target_dirs = []
2846fdt_required = []
2847foreach target : target_dirs
2848  config_target = { 'TARGET_NAME': target.split('-')[0] }
2849  if target.endswith('linux-user')
2850    if targetos != 'linux'
2851      if default_targets
2852        continue
2853      endif
2854      error('Target @0@ is only available on a Linux host'.format(target))
2855    endif
2856    config_target += { 'CONFIG_LINUX_USER': 'y' }
2857  elif target.endswith('bsd-user')
2858    if 'CONFIG_BSD' not in config_host
2859      if default_targets
2860        continue
2861      endif
2862      error('Target @0@ is only available on a BSD host'.format(target))
2863    endif
2864    config_target += { 'CONFIG_BSD_USER': 'y' }
2865  elif target.endswith('softmmu')
2866    config_target += { 'CONFIG_SOFTMMU': 'y' }
2867  endif
2868  if target.endswith('-user')
2869    config_target += {
2870      'CONFIG_USER_ONLY': 'y',
2871      'CONFIG_QEMU_INTERP_PREFIX':
2872        get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
2873    }
2874  endif
2875
2876  accel_kconfig = []
2877  foreach sym: accelerators
2878    if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2879      config_target += { sym: 'y' }
2880      config_all += { sym: 'y' }
2881      if target in modular_tcg
2882        config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2883      else
2884        config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2885      endif
2886      accel_kconfig += [ sym + '=y' ]
2887    endif
2888  endforeach
2889  if accel_kconfig.length() == 0
2890    if default_targets
2891      continue
2892    endif
2893    error('No accelerator available for target @0@'.format(target))
2894  endif
2895
2896  actual_target_dirs += target
2897  config_target += keyval.load('configs/targets' / target + '.mak')
2898  config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2899
2900  if 'TARGET_NEED_FDT' in config_target
2901    fdt_required += target
2902  endif
2903
2904  # Add default keys
2905  if 'TARGET_BASE_ARCH' not in config_target
2906    config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2907  endif
2908  if 'TARGET_ABI_DIR' not in config_target
2909    config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2910  endif
2911  if 'TARGET_BIG_ENDIAN' not in config_target
2912    config_target += {'TARGET_BIG_ENDIAN': 'n'}
2913  endif
2914
2915  foreach k, v: disassemblers
2916    if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2917      foreach sym: v
2918        config_target += { sym: 'y' }
2919        config_all_disas += { sym: 'y' }
2920      endforeach
2921    endif
2922  endforeach
2923
2924  config_target_data = configuration_data()
2925  foreach k, v: config_target
2926    if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2927      # do nothing
2928    elif ignored.contains(k)
2929      # do nothing
2930    elif k == 'TARGET_BASE_ARCH'
2931      # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2932      # not used to select files from sourcesets.
2933      config_target_data.set('TARGET_' + v.to_upper(), 1)
2934    elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2935      config_target_data.set_quoted(k, v)
2936    elif v == 'y'
2937      config_target_data.set(k, 1)
2938    elif v == 'n'
2939      config_target_data.set(k, 0)
2940    else
2941      config_target_data.set(k, v)
2942    endif
2943  endforeach
2944  config_target_data.set('QEMU_ARCH',
2945                         'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
2946  config_target_h += {target: configure_file(output: target + '-config-target.h',
2947                                               configuration: config_target_data)}
2948
2949  if target.endswith('-softmmu')
2950    config_input = meson.get_external_property(target, 'default')
2951    config_devices_mak = target + '-config-devices.mak'
2952    config_devices_mak = configure_file(
2953      input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
2954      output: config_devices_mak,
2955      depfile: config_devices_mak + '.d',
2956      capture: true,
2957      command: [minikconf,
2958                get_option('default_devices') ? '--defconfig' : '--allnoconfig',
2959                config_devices_mak, '@DEPFILE@', '@INPUT@',
2960                host_kconfig, accel_kconfig,
2961                'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
2962
2963    config_devices_data = configuration_data()
2964    config_devices = keyval.load(config_devices_mak)
2965    foreach k, v: config_devices
2966      config_devices_data.set(k, 1)
2967    endforeach
2968    config_devices_mak_list += config_devices_mak
2969    config_devices_h += {target: configure_file(output: target + '-config-devices.h',
2970                                                configuration: config_devices_data)}
2971    config_target += config_devices
2972    config_all_devices += config_devices
2973  endif
2974  config_target_mak += {target: config_target}
2975endforeach
2976target_dirs = actual_target_dirs
2977
2978# This configuration is used to build files that are shared by
2979# multiple binaries, and then extracted out of the "common"
2980# static_library target.
2981#
2982# We do not use all_sources()/all_dependencies(), because it would
2983# build literally all source files, including devices only used by
2984# targets that are not built for this compilation.  The CONFIG_ALL
2985# pseudo symbol replaces it.
2986
2987config_all += config_all_devices
2988config_all += config_host
2989config_all += config_all_disas
2990config_all += {
2991  'CONFIG_XEN': xen.found(),
2992  'CONFIG_SOFTMMU': have_system,
2993  'CONFIG_USER_ONLY': have_user,
2994  'CONFIG_ALL': true,
2995}
2996
2997target_configs_h = []
2998foreach target: target_dirs
2999  target_configs_h += config_target_h[target]
3000  target_configs_h += config_devices_h.get(target, [])
3001endforeach
3002genh += custom_target('config-poison.h',
3003                      input: [target_configs_h],
3004                      output: 'config-poison.h',
3005                      capture: true,
3006                      command: [find_program('scripts/make-config-poison.sh'),
3007                                target_configs_h])
3008
3009##############
3010# Submodules #
3011##############
3012
3013capstone = not_found
3014if not get_option('capstone').auto() or have_system or have_user
3015  capstone = dependency('capstone', version: '>=3.0.5',
3016                        method: 'pkg-config',
3017                        required: get_option('capstone'))
3018
3019  # Some versions of capstone have broken pkg-config file
3020  # that reports a wrong -I path, causing the #include to
3021  # fail later. If the system has such a broken version
3022  # do not use it.
3023  if capstone.found() and not cc.compiles('#include <capstone.h>',
3024                                          dependencies: [capstone])
3025    capstone = not_found
3026    if get_option('capstone').enabled()
3027      error('capstone requested, but it does not appear to work')
3028    endif
3029  endif
3030endif
3031
3032libvfio_user_dep = not_found
3033if have_system and vfio_user_server_allowed
3034  libvfio_user_proj = subproject('libvfio-user', required: true)
3035  libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep')
3036endif
3037
3038fdt = not_found
3039fdt_opt = get_option('fdt')
3040if fdt_required.length() > 0 or fdt_opt == 'enabled'
3041  if fdt_opt == 'disabled'
3042    error('fdt disabled but required by targets ' + ', '.join(fdt_required))
3043  endif
3044
3045  if fdt_opt in ['enabled', 'auto', 'system']
3046    fdt = cc.find_library('fdt', required: fdt_opt == 'system')
3047    if fdt.found() and cc.links('''
3048       #include <libfdt.h>
3049       #include <libfdt_env.h>
3050       int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
3051         dependencies: fdt)
3052      fdt_opt = 'system'
3053    elif fdt_opt == 'system'
3054       error('system libfdt requested, but it is too old (1.5.1 or newer required)')
3055    else
3056      fdt_opt = 'internal'
3057      fdt = not_found
3058    endif
3059  endif
3060  if not fdt.found()
3061    assert(fdt_opt == 'internal')
3062    libfdt_proj = subproject('dtc', required: true,
3063                             default_options: ['tools=false',  'yaml=disabled',
3064                                               'python=disabled', 'default_library=static'])
3065    fdt = libfdt_proj.get_variable('libfdt_dep')
3066  endif
3067else
3068  fdt_opt = 'disabled'
3069endif
3070
3071config_host_data.set('CONFIG_CAPSTONE', capstone.found())
3072config_host_data.set('CONFIG_FDT', fdt.found())
3073config_host_data.set('CONFIG_SLIRP', slirp.found())
3074
3075#####################
3076# Generated sources #
3077#####################
3078
3079genh += configure_file(output: 'config-host.h', configuration: config_host_data)
3080
3081hxtool = find_program('scripts/hxtool')
3082shaderinclude = find_program('scripts/shaderinclude.py')
3083qapi_gen = find_program('scripts/qapi-gen.py')
3084qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
3085                     meson.current_source_dir() / 'scripts/qapi/commands.py',
3086                     meson.current_source_dir() / 'scripts/qapi/common.py',
3087                     meson.current_source_dir() / 'scripts/qapi/error.py',
3088                     meson.current_source_dir() / 'scripts/qapi/events.py',
3089                     meson.current_source_dir() / 'scripts/qapi/expr.py',
3090                     meson.current_source_dir() / 'scripts/qapi/gen.py',
3091                     meson.current_source_dir() / 'scripts/qapi/introspect.py',
3092                     meson.current_source_dir() / 'scripts/qapi/main.py',
3093                     meson.current_source_dir() / 'scripts/qapi/parser.py',
3094                     meson.current_source_dir() / 'scripts/qapi/schema.py',
3095                     meson.current_source_dir() / 'scripts/qapi/source.py',
3096                     meson.current_source_dir() / 'scripts/qapi/types.py',
3097                     meson.current_source_dir() / 'scripts/qapi/visit.py',
3098                     meson.current_source_dir() / 'scripts/qapi-gen.py'
3099]
3100
3101tracetool = [
3102  python, files('scripts/tracetool.py'),
3103   '--backend=' + ','.join(get_option('trace_backends'))
3104]
3105tracetool_depends = files(
3106  'scripts/tracetool/backend/log.py',
3107  'scripts/tracetool/backend/__init__.py',
3108  'scripts/tracetool/backend/dtrace.py',
3109  'scripts/tracetool/backend/ftrace.py',
3110  'scripts/tracetool/backend/simple.py',
3111  'scripts/tracetool/backend/syslog.py',
3112  'scripts/tracetool/backend/ust.py',
3113  'scripts/tracetool/format/ust_events_c.py',
3114  'scripts/tracetool/format/ust_events_h.py',
3115  'scripts/tracetool/format/__init__.py',
3116  'scripts/tracetool/format/d.py',
3117  'scripts/tracetool/format/simpletrace_stap.py',
3118  'scripts/tracetool/format/c.py',
3119  'scripts/tracetool/format/h.py',
3120  'scripts/tracetool/format/log_stap.py',
3121  'scripts/tracetool/format/stap.py',
3122  'scripts/tracetool/__init__.py',
3123  'scripts/tracetool/vcpu.py'
3124)
3125
3126qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
3127                    meson.current_source_dir(),
3128                    get_option('pkgversion'), meson.project_version()]
3129qemu_version = custom_target('qemu-version.h',
3130                             output: 'qemu-version.h',
3131                             command: qemu_version_cmd,
3132                             capture: true,
3133                             build_by_default: true,
3134                             build_always_stale: true)
3135genh += qemu_version
3136
3137hxdep = []
3138hx_headers = [
3139  ['qemu-options.hx', 'qemu-options.def'],
3140  ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
3141]
3142if have_system
3143  hx_headers += [
3144    ['hmp-commands.hx', 'hmp-commands.h'],
3145    ['hmp-commands-info.hx', 'hmp-commands-info.h'],
3146  ]
3147endif
3148foreach d : hx_headers
3149  hxdep += custom_target(d[1],
3150                input: files(d[0]),
3151                output: d[1],
3152                capture: true,
3153                build_by_default: true, # to be removed when added to a target
3154                command: [hxtool, '-h', '@INPUT0@'])
3155endforeach
3156genh += hxdep
3157
3158###################
3159# Collect sources #
3160###################
3161
3162authz_ss = ss.source_set()
3163blockdev_ss = ss.source_set()
3164block_ss = ss.source_set()
3165chardev_ss = ss.source_set()
3166common_ss = ss.source_set()
3167crypto_ss = ss.source_set()
3168hwcore_ss = ss.source_set()
3169io_ss = ss.source_set()
3170qmp_ss = ss.source_set()
3171qom_ss = ss.source_set()
3172softmmu_ss = ss.source_set()
3173specific_fuzz_ss = ss.source_set()
3174specific_ss = ss.source_set()
3175stub_ss = ss.source_set()
3176trace_ss = ss.source_set()
3177user_ss = ss.source_set()
3178util_ss = ss.source_set()
3179
3180# accel modules
3181qtest_module_ss = ss.source_set()
3182tcg_module_ss = ss.source_set()
3183
3184modules = {}
3185target_modules = {}
3186hw_arch = {}
3187target_arch = {}
3188target_softmmu_arch = {}
3189target_user_arch = {}
3190
3191###############
3192# Trace files #
3193###############
3194
3195# TODO: add each directory to the subdirs from its own meson.build, once
3196# we have those
3197trace_events_subdirs = [
3198  'crypto',
3199  'qapi',
3200  'qom',
3201  'monitor',
3202  'util',
3203  'gdbstub',
3204]
3205if have_linux_user
3206  trace_events_subdirs += [ 'linux-user' ]
3207endif
3208if have_bsd_user
3209  trace_events_subdirs += [ 'bsd-user' ]
3210endif
3211if have_block
3212  trace_events_subdirs += [
3213    'authz',
3214    'block',
3215    'io',
3216    'nbd',
3217    'scsi',
3218  ]
3219endif
3220if have_system
3221  trace_events_subdirs += [
3222    'accel/kvm',
3223    'audio',
3224    'backends',
3225    'backends/tpm',
3226    'chardev',
3227    'ebpf',
3228    'hw/9pfs',
3229    'hw/acpi',
3230    'hw/adc',
3231    'hw/alpha',
3232    'hw/arm',
3233    'hw/audio',
3234    'hw/block',
3235    'hw/block/dataplane',
3236    'hw/char',
3237    'hw/display',
3238    'hw/dma',
3239    'hw/hyperv',
3240    'hw/i2c',
3241    'hw/i386',
3242    'hw/i386/xen',
3243    'hw/i386/kvm',
3244    'hw/ide',
3245    'hw/input',
3246    'hw/intc',
3247    'hw/isa',
3248    'hw/mem',
3249    'hw/mips',
3250    'hw/misc',
3251    'hw/misc/macio',
3252    'hw/net',
3253    'hw/net/can',
3254    'hw/nubus',
3255    'hw/nvme',
3256    'hw/nvram',
3257    'hw/pci',
3258    'hw/pci-host',
3259    'hw/ppc',
3260    'hw/rdma',
3261    'hw/rdma/vmw',
3262    'hw/rtc',
3263    'hw/s390x',
3264    'hw/scsi',
3265    'hw/sd',
3266    'hw/sh4',
3267    'hw/sparc',
3268    'hw/sparc64',
3269    'hw/ssi',
3270    'hw/timer',
3271    'hw/tpm',
3272    'hw/usb',
3273    'hw/vfio',
3274    'hw/virtio',
3275    'hw/watchdog',
3276    'hw/xen',
3277    'hw/gpio',
3278    'migration',
3279    'net',
3280    'softmmu',
3281    'ui',
3282    'hw/remote',
3283  ]
3284endif
3285if have_system or have_user
3286  trace_events_subdirs += [
3287    'accel/tcg',
3288    'hw/core',
3289    'target/arm',
3290    'target/arm/hvf',
3291    'target/hppa',
3292    'target/i386',
3293    'target/i386/kvm',
3294    'target/mips/tcg',
3295    'target/nios2',
3296    'target/ppc',
3297    'target/riscv',
3298    'target/s390x',
3299    'target/s390x/kvm',
3300    'target/sparc',
3301  ]
3302endif
3303
3304vhost_user = not_found
3305if targetos == 'linux' and have_vhost_user
3306  libvhost_user = subproject('libvhost-user')
3307  vhost_user = libvhost_user.get_variable('vhost_user_dep')
3308endif
3309
3310libvduse = not_found
3311if have_libvduse
3312  libvduse_proj = subproject('libvduse')
3313  libvduse = libvduse_proj.get_variable('libvduse_dep')
3314endif
3315
3316# NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3317# that is filled in by qapi/.
3318subdir('qapi')
3319subdir('qobject')
3320subdir('stubs')
3321subdir('trace')
3322subdir('util')
3323subdir('qom')
3324subdir('authz')
3325subdir('crypto')
3326subdir('ui')
3327subdir('hw')
3328subdir('gdbstub')
3329
3330if enable_modules
3331  libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3332  modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3333endif
3334
3335qom_ss = qom_ss.apply(config_host, strict: false)
3336libqom = static_library('qom', qom_ss.sources() + genh,
3337                        dependencies: [qom_ss.dependencies()],
3338                        name_suffix: 'fa')
3339qom = declare_dependency(link_whole: libqom)
3340
3341event_loop_base = files('event-loop-base.c')
3342event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
3343                                 build_by_default: true)
3344event_loop_base = declare_dependency(link_whole: event_loop_base,
3345                                     dependencies: [qom])
3346
3347stub_ss = stub_ss.apply(config_all, strict: false)
3348
3349util_ss.add_all(trace_ss)
3350util_ss = util_ss.apply(config_all, strict: false)
3351libqemuutil = static_library('qemuutil',
3352                             sources: util_ss.sources() + stub_ss.sources() + genh,
3353                             dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3354qemuutil = declare_dependency(link_with: libqemuutil,
3355                              sources: genh + version_res,
3356                              dependencies: [event_loop_base])
3357
3358if have_system or have_user
3359  decodetree = generator(find_program('scripts/decodetree.py'),
3360                         output: 'decode-@BASENAME@.c.inc',
3361                         arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3362  subdir('libdecnumber')
3363  subdir('target')
3364endif
3365
3366subdir('audio')
3367subdir('io')
3368subdir('chardev')
3369subdir('fsdev')
3370subdir('dump')
3371
3372if have_block
3373  block_ss.add(files(
3374    'block.c',
3375    'blockjob.c',
3376    'job.c',
3377    'qemu-io-cmds.c',
3378  ))
3379  if config_host_data.get('CONFIG_REPLICATION')
3380    block_ss.add(files('replication.c'))
3381  endif
3382
3383  subdir('nbd')
3384  subdir('scsi')
3385  subdir('block')
3386
3387  blockdev_ss.add(files(
3388    'blockdev.c',
3389    'blockdev-nbd.c',
3390    'iothread.c',
3391    'job-qmp.c',
3392  ), gnutls)
3393
3394  # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3395  # os-win32.c does not
3396  blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
3397  softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
3398endif
3399
3400common_ss.add(files('cpus-common.c'))
3401specific_ss.add(files('cpu.c'))
3402
3403subdir('softmmu')
3404
3405# Work around a gcc bug/misfeature wherein constant propagation looks
3406# through an alias:
3407#   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3408# to guess that a const variable is always zero.  Without lto, this is
3409# impossible, as the alias is restricted to page-vary-common.c.  Indeed,
3410# without lto, not even the alias is required -- we simply use different
3411# declarations in different compilation units.
3412pagevary = files('page-vary-common.c')
3413if get_option('b_lto')
3414  pagevary_flags = ['-fno-lto']
3415  if get_option('cfi')
3416    pagevary_flags += '-fno-sanitize=cfi-icall'
3417  endif
3418  pagevary = static_library('page-vary-common', sources: pagevary + genh,
3419                            c_args: pagevary_flags)
3420  pagevary = declare_dependency(link_with: pagevary)
3421endif
3422common_ss.add(pagevary)
3423specific_ss.add(files('page-vary.c'))
3424
3425subdir('backends')
3426subdir('disas')
3427subdir('migration')
3428subdir('monitor')
3429subdir('net')
3430subdir('replay')
3431subdir('semihosting')
3432subdir('stats')
3433subdir('tcg')
3434subdir('fpu')
3435subdir('accel')
3436subdir('plugins')
3437subdir('ebpf')
3438
3439common_user_inc = []
3440
3441subdir('common-user')
3442subdir('bsd-user')
3443subdir('linux-user')
3444
3445# needed for fuzzing binaries
3446subdir('tests/qtest/libqos')
3447subdir('tests/qtest/fuzz')
3448
3449# accel modules
3450tcg_real_module_ss = ss.source_set()
3451tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3452specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3453target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3454                                'tcg': tcg_real_module_ss }}
3455
3456########################
3457# Library dependencies #
3458########################
3459
3460modinfo_collect = find_program('scripts/modinfo-collect.py')
3461modinfo_generate = find_program('scripts/modinfo-generate.py')
3462modinfo_files = []
3463
3464block_mods = []
3465softmmu_mods = []
3466foreach d, list : modules
3467  if not (d == 'block' ? have_block : have_system)
3468    continue
3469  endif
3470
3471  foreach m, module_ss : list
3472    if enable_modules
3473      module_ss = module_ss.apply(config_all, strict: false)
3474      sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3475                          dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3476      if d == 'block'
3477        block_mods += sl
3478      else
3479        softmmu_mods += sl
3480      endif
3481      if module_ss.sources() != []
3482        # FIXME: Should use sl.extract_all_objects(recursive: true) as
3483        # input. Sources can be used multiple times but objects are
3484        # unique when it comes to lookup in compile_commands.json.
3485        # Depnds on a mesion version with
3486        # https://github.com/mesonbuild/meson/pull/8900
3487        modinfo_files += custom_target(d + '-' + m + '.modinfo',
3488                                       output: d + '-' + m + '.modinfo',
3489                                       input: module_ss.sources() + genh,
3490                                       capture: true,
3491                                       command: [modinfo_collect, module_ss.sources()])
3492      endif
3493    else
3494      if d == 'block'
3495        block_ss.add_all(module_ss)
3496      else
3497        softmmu_ss.add_all(module_ss)
3498      endif
3499    endif
3500  endforeach
3501endforeach
3502
3503foreach d, list : target_modules
3504  foreach m, module_ss : list
3505    if enable_modules
3506      foreach target : target_dirs
3507        if target.endswith('-softmmu')
3508          config_target = config_target_mak[target]
3509          config_target += config_host
3510          target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3511          c_args = ['-DNEED_CPU_H',
3512                    '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3513                    '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3514          target_module_ss = module_ss.apply(config_target, strict: false)
3515          if target_module_ss.sources() != []
3516            module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3517            sl = static_library(module_name,
3518                                [genh, target_module_ss.sources()],
3519                                dependencies: [modulecommon, target_module_ss.dependencies()],
3520                                include_directories: target_inc,
3521                                c_args: c_args,
3522                                pic: true)
3523            softmmu_mods += sl
3524            # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3525            modinfo_files += custom_target(module_name + '.modinfo',
3526                                           output: module_name + '.modinfo',
3527                                           input: target_module_ss.sources() + genh,
3528                                           capture: true,
3529                                           command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3530          endif
3531        endif
3532      endforeach
3533    else
3534      specific_ss.add_all(module_ss)
3535    endif
3536  endforeach
3537endforeach
3538
3539if enable_modules
3540  foreach target : target_dirs
3541    if target.endswith('-softmmu')
3542      config_target = config_target_mak[target]
3543      config_devices_mak = target + '-config-devices.mak'
3544      modinfo_src = custom_target('modinfo-' + target + '.c',
3545                                  output: 'modinfo-' + target + '.c',
3546                                  input: modinfo_files,
3547                                  command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3548                                  capture: true)
3549
3550      modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3551      modinfo_dep = declare_dependency(link_with: modinfo_lib)
3552
3553      arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3554      hw_arch[arch].add(modinfo_dep)
3555    endif
3556  endforeach
3557endif
3558
3559nm = find_program('nm')
3560undefsym = find_program('scripts/undefsym.py')
3561block_syms = custom_target('block.syms', output: 'block.syms',
3562                             input: [libqemuutil, block_mods],
3563                             capture: true,
3564                             command: [undefsym, nm, '@INPUT@'])
3565qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3566                             input: [libqemuutil, softmmu_mods],
3567                             capture: true,
3568                             command: [undefsym, nm, '@INPUT@'])
3569
3570authz_ss = authz_ss.apply(config_host, strict: false)
3571libauthz = static_library('authz', authz_ss.sources() + genh,
3572                          dependencies: [authz_ss.dependencies()],
3573                          name_suffix: 'fa',
3574                          build_by_default: false)
3575
3576authz = declare_dependency(link_whole: libauthz,
3577                           dependencies: qom)
3578
3579crypto_ss = crypto_ss.apply(config_host, strict: false)
3580libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3581                           dependencies: [crypto_ss.dependencies()],
3582                           name_suffix: 'fa',
3583                           build_by_default: false)
3584
3585crypto = declare_dependency(link_whole: libcrypto,
3586                            dependencies: [authz, qom])
3587
3588io_ss = io_ss.apply(config_host, strict: false)
3589libio = static_library('io', io_ss.sources() + genh,
3590                       dependencies: [io_ss.dependencies()],
3591                       link_with: libqemuutil,
3592                       name_suffix: 'fa',
3593                       build_by_default: false)
3594
3595io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3596
3597libmigration = static_library('migration', sources: migration_files + genh,
3598                              name_suffix: 'fa',
3599                              build_by_default: false)
3600migration = declare_dependency(link_with: libmigration,
3601                               dependencies: [zlib, qom, io])
3602softmmu_ss.add(migration)
3603
3604block_ss = block_ss.apply(config_host, strict: false)
3605libblock = static_library('block', block_ss.sources() + genh,
3606                          dependencies: block_ss.dependencies(),
3607                          link_depends: block_syms,
3608                          name_suffix: 'fa',
3609                          build_by_default: false)
3610
3611block = declare_dependency(link_whole: [libblock],
3612                           link_args: '@block.syms',
3613                           dependencies: [crypto, io])
3614
3615blockdev_ss = blockdev_ss.apply(config_host, strict: false)
3616libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3617                             dependencies: blockdev_ss.dependencies(),
3618                             name_suffix: 'fa',
3619                             build_by_default: false)
3620
3621blockdev = declare_dependency(link_whole: [libblockdev],
3622                              dependencies: [block, event_loop_base])
3623
3624qmp_ss = qmp_ss.apply(config_host, strict: false)
3625libqmp = static_library('qmp', qmp_ss.sources() + genh,
3626                        dependencies: qmp_ss.dependencies(),
3627                        name_suffix: 'fa',
3628                        build_by_default: false)
3629
3630qmp = declare_dependency(link_whole: [libqmp])
3631
3632libchardev = static_library('chardev', chardev_ss.sources() + genh,
3633                            name_suffix: 'fa',
3634                            dependencies: chardev_ss.dependencies(),
3635                            build_by_default: false)
3636
3637chardev = declare_dependency(link_whole: libchardev)
3638
3639hwcore_ss = hwcore_ss.apply(config_host, strict: false)
3640libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3641                           name_suffix: 'fa',
3642                           build_by_default: false)
3643hwcore = declare_dependency(link_whole: libhwcore)
3644common_ss.add(hwcore)
3645
3646###########
3647# Targets #
3648###########
3649
3650emulator_modules = []
3651foreach m : block_mods + softmmu_mods
3652  emulator_modules += shared_module(m.name(),
3653                build_by_default: true,
3654                name_prefix: '',
3655                link_whole: m,
3656                install: true,
3657                install_dir: qemu_moddir)
3658endforeach
3659if emulator_modules.length() > 0
3660  alias_target('modules', emulator_modules)
3661endif
3662
3663softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3664common_ss.add(qom, qemuutil)
3665
3666common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
3667common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3668
3669common_all = common_ss.apply(config_all, strict: false)
3670common_all = static_library('common',
3671                            build_by_default: false,
3672                            sources: common_all.sources() + genh,
3673                            include_directories: common_user_inc,
3674                            implicit_include_directories: false,
3675                            dependencies: common_all.dependencies(),
3676                            name_suffix: 'fa')
3677
3678feature_to_c = find_program('scripts/feature_to_c.sh')
3679
3680if targetos == 'darwin'
3681  entitlement = find_program('scripts/entitlement.sh')
3682endif
3683
3684emulators = {}
3685foreach target : target_dirs
3686  config_target = config_target_mak[target]
3687  target_name = config_target['TARGET_NAME']
3688  target_base_arch = config_target['TARGET_BASE_ARCH']
3689  arch_srcs = [config_target_h[target]]
3690  arch_deps = []
3691  c_args = ['-DNEED_CPU_H',
3692            '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3693            '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3694  link_args = emulator_link_args
3695
3696  config_target += config_host
3697  target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3698  if targetos == 'linux'
3699    target_inc += include_directories('linux-headers', is_system: true)
3700  endif
3701  if target.endswith('-softmmu')
3702    target_type='system'
3703    t = target_softmmu_arch[target_base_arch].apply(config_target, strict: false)
3704    arch_srcs += t.sources()
3705    arch_deps += t.dependencies()
3706
3707    hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3708    hw = hw_arch[hw_dir].apply(config_target, strict: false)
3709    arch_srcs += hw.sources()
3710    arch_deps += hw.dependencies()
3711
3712    arch_srcs += config_devices_h[target]
3713    link_args += ['@block.syms', '@qemu.syms']
3714  else
3715    abi = config_target['TARGET_ABI_DIR']
3716    target_type='user'
3717    target_inc += common_user_inc
3718    if target_base_arch in target_user_arch
3719      t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3720      arch_srcs += t.sources()
3721      arch_deps += t.dependencies()
3722    endif
3723    if 'CONFIG_LINUX_USER' in config_target
3724      base_dir = 'linux-user'
3725    endif
3726    if 'CONFIG_BSD_USER' in config_target
3727      base_dir = 'bsd-user'
3728      target_inc += include_directories('bsd-user/' / targetos)
3729      target_inc += include_directories('bsd-user/host/' / host_arch)
3730      dir = base_dir / abi
3731      arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3732    endif
3733    target_inc += include_directories(
3734      base_dir,
3735      base_dir / abi,
3736    )
3737    if 'CONFIG_LINUX_USER' in config_target
3738      dir = base_dir / abi
3739      arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3740      if config_target.has_key('TARGET_SYSTBL_ABI')
3741        arch_srcs += \
3742          syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3743                                             extra_args : config_target['TARGET_SYSTBL_ABI'])
3744      endif
3745    endif
3746  endif
3747
3748  if 'TARGET_XML_FILES' in config_target
3749    gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3750                                output: target + '-gdbstub-xml.c',
3751                                input: files(config_target['TARGET_XML_FILES'].split()),
3752                                command: [feature_to_c, '@INPUT@'],
3753                                capture: true)
3754    arch_srcs += gdbstub_xml
3755  endif
3756
3757  t = target_arch[target_base_arch].apply(config_target, strict: false)
3758  arch_srcs += t.sources()
3759  arch_deps += t.dependencies()
3760
3761  target_common = common_ss.apply(config_target, strict: false)
3762  objects = common_all.extract_objects(target_common.sources())
3763  deps = target_common.dependencies()
3764
3765  target_specific = specific_ss.apply(config_target, strict: false)
3766  arch_srcs += target_specific.sources()
3767  arch_deps += target_specific.dependencies()
3768
3769  lib = static_library('qemu-' + target,
3770                 sources: arch_srcs + genh,
3771                 dependencies: arch_deps,
3772                 objects: objects,
3773                 include_directories: target_inc,
3774                 c_args: c_args,
3775                 build_by_default: false,
3776                 name_suffix: 'fa')
3777
3778  if target.endswith('-softmmu')
3779    execs = [{
3780      'name': 'qemu-system-' + target_name,
3781      'win_subsystem': 'console',
3782      'sources': files('softmmu/main.c'),
3783      'dependencies': []
3784    }]
3785    if targetos == 'windows' and (sdl.found() or gtk.found())
3786      execs += [{
3787        'name': 'qemu-system-' + target_name + 'w',
3788        'win_subsystem': 'windows',
3789        'sources': files('softmmu/main.c'),
3790        'dependencies': []
3791      }]
3792    endif
3793    if get_option('fuzzing')
3794      specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3795      execs += [{
3796        'name': 'qemu-fuzz-' + target_name,
3797        'win_subsystem': 'console',
3798        'sources': specific_fuzz.sources(),
3799        'dependencies': specific_fuzz.dependencies(),
3800      }]
3801    endif
3802  else
3803    execs = [{
3804      'name': 'qemu-' + target_name,
3805      'win_subsystem': 'console',
3806      'sources': [],
3807      'dependencies': []
3808    }]
3809  endif
3810  foreach exe: execs
3811    exe_name = exe['name']
3812    if targetos == 'darwin'
3813      exe_name += '-unsigned'
3814    endif
3815
3816    emulator = executable(exe_name, exe['sources'],
3817               install: true,
3818               c_args: c_args,
3819               dependencies: arch_deps + deps + exe['dependencies'],
3820               objects: lib.extract_all_objects(recursive: true),
3821               link_language: link_language,
3822               link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3823               link_args: link_args,
3824               win_subsystem: exe['win_subsystem'])
3825
3826    if targetos == 'darwin'
3827      icon = 'pc-bios/qemu.rsrc'
3828      build_input = [emulator, files(icon)]
3829      install_input = [
3830        get_option('bindir') / exe_name,
3831        meson.current_source_dir() / icon
3832      ]
3833      if 'CONFIG_HVF' in config_target
3834        entitlements = 'accel/hvf/entitlements.plist'
3835        build_input += files(entitlements)
3836        install_input += meson.current_source_dir() / entitlements
3837      endif
3838
3839      emulators += {exe['name'] : custom_target(exe['name'],
3840                   input: build_input,
3841                   output: exe['name'],
3842                   command: [entitlement, '@OUTPUT@', '@INPUT@'])
3843      }
3844
3845      meson.add_install_script(entitlement, '--install',
3846                               get_option('bindir') / exe['name'],
3847                               install_input)
3848    else
3849      emulators += {exe['name']: emulator}
3850    endif
3851
3852    if stap.found()
3853      foreach stp: [
3854        {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3855        {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3856        {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3857        {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3858      ]
3859        custom_target(exe['name'] + stp['ext'],
3860                      input: trace_events_all,
3861                      output: exe['name'] + stp['ext'],
3862                      install: stp['install'],
3863                      install_dir: get_option('datadir') / 'systemtap/tapset',
3864                      command: [
3865                        tracetool, '--group=all', '--format=' + stp['fmt'],
3866                        '--binary=' + stp['bin'],
3867                        '--target-name=' + target_name,
3868                        '--target-type=' + target_type,
3869                        '--probe-prefix=qemu.' + target_type + '.' + target_name,
3870                        '@INPUT@', '@OUTPUT@'
3871                      ],
3872                      depend_files: tracetool_depends)
3873      endforeach
3874    endif
3875  endforeach
3876endforeach
3877
3878# Other build targets
3879
3880if 'CONFIG_PLUGIN' in config_host
3881  install_headers('include/qemu/qemu-plugin.h')
3882endif
3883
3884subdir('qga')
3885
3886# Don't build qemu-keymap if xkbcommon is not explicitly enabled
3887# when we don't build tools or system
3888if xkbcommon.found()
3889  # used for the update-keymaps target, so include rules even if !have_tools
3890  qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3891                           dependencies: [qemuutil, xkbcommon], install: have_tools)
3892endif
3893
3894if have_tools
3895  qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3896             dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3897  qemu_io = executable('qemu-io', files('qemu-io.c'),
3898             dependencies: [block, qemuutil], install: true)
3899  qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3900               dependencies: [blockdev, qemuutil, gnutls, selinux],
3901               install: true)
3902
3903  subdir('storage-daemon')
3904  subdir('contrib/rdmacm-mux')
3905  subdir('contrib/elf2dmp')
3906
3907  executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3908             dependencies: qemuutil,
3909             install: true)
3910
3911  if have_vhost_user
3912    subdir('contrib/vhost-user-blk')
3913    subdir('contrib/vhost-user-gpu')
3914    subdir('contrib/vhost-user-input')
3915    subdir('contrib/vhost-user-scsi')
3916  endif
3917
3918  if targetos == 'linux'
3919    executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3920               dependencies: [qemuutil, libcap_ng],
3921               install: true,
3922               install_dir: get_option('libexecdir'))
3923
3924    executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3925               dependencies: [authz, crypto, io, qom, qemuutil,
3926                              libcap_ng, mpathpersist],
3927               install: true)
3928  endif
3929
3930  if have_ivshmem
3931    subdir('contrib/ivshmem-client')
3932    subdir('contrib/ivshmem-server')
3933  endif
3934endif
3935
3936subdir('scripts')
3937subdir('tools')
3938subdir('pc-bios')
3939subdir('docs')
3940subdir('tests')
3941if gtk.found()
3942  subdir('po')
3943endif
3944
3945if host_machine.system() == 'windows'
3946  nsis_cmd = [
3947    find_program('scripts/nsis.py'),
3948    '@OUTPUT@',
3949    get_option('prefix'),
3950    meson.current_source_dir(),
3951    glib_pc.get_variable('bindir'),
3952    host_machine.cpu(),
3953    '--',
3954    '-DDISPLAYVERSION=' + meson.project_version(),
3955  ]
3956  if build_docs
3957    nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
3958  endif
3959  if gtk.found()
3960    nsis_cmd += '-DCONFIG_GTK=y'
3961  endif
3962
3963  nsis = custom_target('nsis',
3964                       output: 'qemu-setup-' + meson.project_version() + '.exe',
3965                       input: files('qemu.nsi'),
3966                       build_always_stale: true,
3967                       command: nsis_cmd + ['@INPUT@'])
3968  alias_target('installer', nsis)
3969endif
3970
3971#########################
3972# Configuration summary #
3973#########################
3974
3975# Build environment
3976summary_info = {}
3977summary_info += {'Build directory':   meson.current_build_dir()}
3978summary_info += {'Source path':       meson.current_source_dir()}
3979summary_info += {'GIT submodules':    config_host['GIT_SUBMODULES']}
3980summary_info += {'Download dependencies': get_option('wrap_mode') != 'nodownload'}
3981summary(summary_info, bool_yn: true, section: 'Build environment')
3982
3983# Directories
3984summary_info += {'Install prefix':    get_option('prefix')}
3985summary_info += {'BIOS directory':    qemu_datadir}
3986pathsep = targetos == 'windows' ? ';' : ':'
3987summary_info += {'firmware path':     pathsep.join(get_option('qemu_firmwarepath'))}
3988summary_info += {'binary directory':  get_option('prefix') / get_option('bindir')}
3989summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
3990summary_info += {'module directory':  qemu_moddir}
3991summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
3992summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
3993summary_info += {'config directory':  get_option('prefix') / get_option('sysconfdir')}
3994if targetos != 'windows'
3995  summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
3996  summary_info += {'Manual directory':      get_option('prefix') / get_option('mandir')}
3997else
3998  summary_info += {'local state directory': 'queried at runtime'}
3999endif
4000summary_info += {'Doc directory':     get_option('prefix') / get_option('docdir')}
4001summary(summary_info, bool_yn: true, section: 'Directories')
4002
4003# Host binaries
4004summary_info = {}
4005summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
4006summary_info += {'sphinx-build':      sphinx_build}
4007if config_host.has_key('HAVE_GDB_BIN')
4008  summary_info += {'gdb':             config_host['HAVE_GDB_BIN']}
4009endif
4010summary_info += {'iasl':              iasl}
4011summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
4012if targetos == 'windows' and have_ga
4013  summary_info += {'wixl':            wixl}
4014endif
4015if slirp.found() and have_system
4016  summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
4017endif
4018summary(summary_info, bool_yn: true, section: 'Host binaries')
4019
4020# Configurable features
4021summary_info = {}
4022summary_info += {'Documentation':     build_docs}
4023summary_info += {'system-mode emulation': have_system}
4024summary_info += {'user-mode emulation': have_user}
4025summary_info += {'block layer':       have_block}
4026summary_info += {'Install blobs':     get_option('install_blobs')}
4027summary_info += {'module support':    enable_modules}
4028if enable_modules
4029  summary_info += {'alternative module path': get_option('module_upgrades')}
4030endif
4031summary_info += {'fuzzing support':   get_option('fuzzing')}
4032if have_system
4033  summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
4034endif
4035summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
4036if 'simple' in get_option('trace_backends')
4037  summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
4038endif
4039summary_info += {'D-Bus display':     dbus_display}
4040summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
4041summary_info += {'vhost-kernel support': have_vhost_kernel}
4042summary_info += {'vhost-net support': have_vhost_net}
4043summary_info += {'vhost-user support': have_vhost_user}
4044summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
4045summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
4046summary_info += {'vhost-vdpa support': have_vhost_vdpa}
4047summary_info += {'build guest agent': have_ga}
4048summary(summary_info, bool_yn: true, section: 'Configurable features')
4049
4050# Compilation information
4051summary_info = {}
4052summary_info += {'host CPU':          cpu}
4053summary_info += {'host endianness':   build_machine.endian()}
4054summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
4055summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
4056if link_language == 'cpp'
4057  summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
4058else
4059  summary_info += {'C++ compiler':      false}
4060endif
4061if targetos == 'darwin'
4062  summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
4063endif
4064option_cflags = (get_option('debug') ? ['-g'] : [])
4065if get_option('optimization') != 'plain'
4066  option_cflags += ['-O' + get_option('optimization')]
4067endif
4068summary_info += {'CFLAGS':            ' '.join(get_option('c_args') + option_cflags)}
4069if link_language == 'cpp'
4070  summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args') + option_cflags)}
4071endif
4072if targetos == 'darwin'
4073  summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args') + option_cflags)}
4074endif
4075link_args = get_option(link_language + '_link_args')
4076if link_args.length() > 0
4077  summary_info += {'LDFLAGS':         ' '.join(link_args)}
4078endif
4079summary_info += {'QEMU_CFLAGS':       ' '.join(qemu_common_flags + qemu_cflags)}
4080if 'cpp' in all_languages
4081  summary_info += {'QEMU_CXXFLAGS':     ' '.join(qemu_common_flags + qemu_cxxflags)}
4082endif
4083if 'objc' in all_languages
4084  summary_info += {'QEMU_OBJCFLAGS':    ' '.join(qemu_common_flags)}
4085endif
4086summary_info += {'QEMU_LDFLAGS':      ' '.join(qemu_ldflags)}
4087summary_info += {'profiler':          get_option('profiler')}
4088summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
4089summary_info += {'PIE':               get_option('b_pie')}
4090summary_info += {'static build':      config_host.has_key('CONFIG_STATIC')}
4091summary_info += {'malloc trim support': has_malloc_trim}
4092summary_info += {'membarrier':        have_membarrier}
4093summary_info += {'debug graph lock':  get_option('debug_graph_lock')}
4094summary_info += {'debug stack usage': get_option('debug_stack_usage')}
4095summary_info += {'mutex debugging':   get_option('debug_mutex')}
4096summary_info += {'memory allocator':  get_option('malloc')}
4097summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
4098summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')}
4099summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
4100if get_option('gprof')
4101  gprof_info = 'YES (deprecated)'
4102else
4103  gprof_info = get_option('gprof')
4104endif
4105summary_info += {'gprof':             gprof_info}
4106summary_info += {'gcov':              get_option('b_coverage')}
4107summary_info += {'thread sanitizer':  get_option('tsan')}
4108summary_info += {'CFI support':       get_option('cfi')}
4109if get_option('cfi')
4110  summary_info += {'CFI debug support': get_option('cfi_debug')}
4111endif
4112summary_info += {'strip binaries':    get_option('strip')}
4113summary_info += {'sparse':            sparse}
4114summary_info += {'mingw32 support':   targetos == 'windows'}
4115summary(summary_info, bool_yn: true, section: 'Compilation')
4116
4117# snarf the cross-compilation information for tests
4118summary_info = {}
4119have_cross = false
4120foreach target: target_dirs
4121  tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak'
4122  if fs.exists(tcg_mak)
4123    config_cross_tcg = keyval.load(tcg_mak)
4124    if 'CC' in config_cross_tcg
4125      summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
4126      have_cross = true
4127    endif
4128  endif
4129endforeach
4130if have_cross
4131  summary(summary_info, bool_yn: true, section: 'Cross compilers')
4132endif
4133
4134# Targets and accelerators
4135summary_info = {}
4136if have_system
4137  summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
4138  summary_info += {'HAX support':       config_all.has_key('CONFIG_HAX')}
4139  summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
4140  summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
4141  summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
4142  summary_info += {'Xen support':       xen.found()}
4143  if xen.found()
4144    summary_info += {'xen ctrl version':  xen.version()}
4145  endif
4146  summary_info += {'Xen emulation':     config_all.has_key('CONFIG_XEN_EMU')}
4147endif
4148summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
4149if config_all.has_key('CONFIG_TCG')
4150  if get_option('tcg_interpreter')
4151    summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
4152  else
4153    summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
4154  endif
4155  summary_info += {'TCG plugins': config_host.has_key('CONFIG_PLUGIN')}
4156  summary_info += {'TCG debug enabled': config_host.has_key('CONFIG_DEBUG_TCG')}
4157endif
4158summary_info += {'target list':       ' '.join(target_dirs)}
4159if have_system
4160  summary_info += {'default devices':   get_option('default_devices')}
4161  summary_info += {'out of process emulation': multiprocess_allowed}
4162  summary_info += {'vfio-user server': vfio_user_server_allowed}
4163endif
4164summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
4165
4166# Block layer
4167summary_info = {}
4168summary_info += {'coroutine backend': coroutine_backend}
4169summary_info += {'coroutine pool':    have_coroutine_pool}
4170if have_block
4171  summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
4172  summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
4173  summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
4174  summary_info += {'VirtFS (9P) support':    have_virtfs}
4175  summary_info += {'VirtFS (9P) Proxy Helper support': have_virtfs_proxy_helper}
4176  summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
4177  summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
4178  summary_info += {'bochs support':     get_option('bochs').allowed()}
4179  summary_info += {'cloop support':     get_option('cloop').allowed()}
4180  summary_info += {'dmg support':       get_option('dmg').allowed()}
4181  summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
4182  summary_info += {'vdi support':       get_option('vdi').allowed()}
4183  summary_info += {'vhdx support':      get_option('vhdx').allowed()}
4184  summary_info += {'vmdk support':      get_option('vmdk').allowed()}
4185  summary_info += {'vpc support':       get_option('vpc').allowed()}
4186  summary_info += {'vvfat support':     get_option('vvfat').allowed()}
4187  summary_info += {'qed support':       get_option('qed').allowed()}
4188  summary_info += {'parallels support': get_option('parallels').allowed()}
4189  summary_info += {'FUSE exports':      fuse}
4190  summary_info += {'VDUSE block exports': have_vduse_blk_export}
4191endif
4192summary(summary_info, bool_yn: true, section: 'Block layer support')
4193
4194# Crypto
4195summary_info = {}
4196summary_info += {'TLS priority':      get_option('tls_priority')}
4197summary_info += {'GNUTLS support':    gnutls}
4198if gnutls.found()
4199  summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
4200endif
4201summary_info += {'libgcrypt':         gcrypt}
4202summary_info += {'nettle':            nettle}
4203if nettle.found()
4204   summary_info += {'  XTS':             xts != 'private'}
4205endif
4206summary_info += {'AF_ALG support':    have_afalg}
4207summary_info += {'rng-none':          get_option('rng_none')}
4208summary_info += {'Linux keyring':     have_keyring}
4209summary(summary_info, bool_yn: true, section: 'Crypto')
4210
4211# UI
4212summary_info = {}
4213if targetos == 'darwin'
4214  summary_info += {'Cocoa support':           cocoa}
4215endif
4216summary_info += {'SDL support':       sdl}
4217summary_info += {'SDL image support': sdl_image}
4218summary_info += {'GTK support':       gtk}
4219summary_info += {'pixman':            pixman}
4220summary_info += {'VTE support':       vte}
4221summary_info += {'PNG support':       png}
4222summary_info += {'VNC support':       vnc}
4223if vnc.found()
4224  summary_info += {'VNC SASL support':  sasl}
4225  summary_info += {'VNC JPEG support':  jpeg}
4226endif
4227summary_info += {'spice protocol support': spice_protocol}
4228if spice_protocol.found()
4229  summary_info += {'  spice server support': spice}
4230endif
4231summary_info += {'curses support':    curses}
4232summary_info += {'brlapi support':    brlapi}
4233summary(summary_info, bool_yn: true, section: 'User interface')
4234
4235# Audio backends
4236summary_info = {}
4237if targetos not in ['darwin', 'haiku', 'windows']
4238  summary_info += {'OSS support':     oss}
4239  summary_info += {'sndio support':   sndio}
4240elif targetos == 'darwin'
4241  summary_info += {'CoreAudio support': coreaudio}
4242elif targetos == 'windows'
4243  summary_info += {'DirectSound support': dsound}
4244endif
4245if targetos == 'linux'
4246  summary_info += {'ALSA support':    alsa}
4247  summary_info += {'PulseAudio support': pulse}
4248endif
4249summary_info += {'Pipewire support':  pipewire}
4250summary_info += {'JACK support':      jack}
4251summary(summary_info, bool_yn: true, section: 'Audio backends')
4252
4253# Network backends
4254summary_info = {}
4255if targetos == 'darwin'
4256  summary_info += {'vmnet.framework support': vmnet}
4257endif
4258summary_info += {'slirp support':     slirp}
4259summary_info += {'vde support':       vde}
4260summary_info += {'netmap support':    have_netmap}
4261summary_info += {'l2tpv3 support':    have_l2tpv3}
4262summary(summary_info, bool_yn: true, section: 'Network backends')
4263
4264# Libraries
4265summary_info = {}
4266summary_info += {'libtasn1':          tasn1}
4267summary_info += {'PAM':               pam}
4268summary_info += {'iconv support':     iconv}
4269summary_info += {'virgl support':     virgl}
4270summary_info += {'blkio support':     blkio}
4271summary_info += {'curl support':      curl}
4272summary_info += {'Multipath support': mpathpersist}
4273summary_info += {'Linux AIO support': libaio}
4274summary_info += {'Linux io_uring support': linux_io_uring}
4275summary_info += {'ATTR/XATTR support': libattr}
4276summary_info += {'RDMA support':      rdma}
4277summary_info += {'PVRDMA support':    have_pvrdma}
4278summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
4279summary_info += {'libcap-ng support': libcap_ng}
4280summary_info += {'bpf support':       libbpf}
4281summary_info += {'rbd support':       rbd}
4282summary_info += {'smartcard support': cacard}
4283summary_info += {'U2F support':       u2f}
4284summary_info += {'libusb':            libusb}
4285summary_info += {'usb net redir':     usbredir}
4286summary_info += {'OpenGL support (epoxy)': opengl}
4287summary_info += {'GBM':               gbm}
4288summary_info += {'libiscsi support':  libiscsi}
4289summary_info += {'libnfs support':    libnfs}
4290if targetos == 'windows'
4291  if have_ga
4292    summary_info += {'QGA VSS support':   have_qga_vss}
4293  endif
4294endif
4295summary_info += {'seccomp support':   seccomp}
4296summary_info += {'GlusterFS support': glusterfs}
4297summary_info += {'TPM support':       have_tpm}
4298summary_info += {'libssh support':    libssh}
4299summary_info += {'lzo support':       lzo}
4300summary_info += {'snappy support':    snappy}
4301summary_info += {'bzip2 support':     libbzip2}
4302summary_info += {'lzfse support':     liblzfse}
4303summary_info += {'zstd support':      zstd}
4304summary_info += {'NUMA host support': numa}
4305summary_info += {'capstone':          capstone}
4306summary_info += {'libpmem support':   libpmem}
4307summary_info += {'libdaxctl support': libdaxctl}
4308summary_info += {'libudev':           libudev}
4309# Dummy dependency, keep .found()
4310summary_info += {'FUSE lseek':        fuse_lseek.found()}
4311summary_info += {'selinux':           selinux}
4312summary_info += {'libdw':             libdw}
4313summary(summary_info, bool_yn: true, section: 'Dependencies')
4314
4315if not supported_cpus.contains(cpu)
4316  message()
4317  warning('SUPPORT FOR THIS HOST CPU WILL GO AWAY IN FUTURE RELEASES!')
4318  message()
4319  message('CPU host architecture ' + cpu + ' support is not currently maintained.')
4320  message('The QEMU project intends to remove support for this host CPU in')
4321  message('a future release if nobody volunteers to maintain it and to')
4322  message('provide a build host for our continuous integration setup.')
4323  message('configure has succeeded and you can continue to build, but')
4324  message('if you care about QEMU on this platform you should contact')
4325  message('us upstream at qemu-devel@nongnu.org.')
4326endif
4327
4328if not supported_oses.contains(targetos)
4329  message()
4330  warning('WARNING: SUPPORT FOR THIS HOST OS WILL GO AWAY IN FUTURE RELEASES!')
4331  message()
4332  message('Host OS ' + targetos + 'support is not currently maintained.')
4333  message('The QEMU project intends to remove support for this host OS in')
4334  message('a future release if nobody volunteers to maintain it and to')
4335  message('provide a build host for our continuous integration setup.')
4336  message('configure has succeeded and you can continue to build, but')
4337  message('if you care about QEMU on this platform you should contact')
4338  message('us upstream at qemu-devel@nongnu.org.')
4339endif
4340