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