meson.build

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