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 config_host_data.set('HAVE_GETLOADAVG_FUNCTION', cc.has_function('getloadavg', prefix: '#include <stdlib.h>'))
2297 if rbd.found()
2298   config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
2299                        cc.has_function('rbd_namespace_exists',
2300                                        dependencies: rbd,
2301                                        prefix: '#include <rbd/librbd.h>'))
2302 endif
2303 if rdma.found()
2304   config_host_data.set('HAVE_IBV_ADVISE_MR',
2305                        cc.has_function('ibv_advise_mr',
2306                                        dependencies: rdma,
2307                                        prefix: '#include <infiniband/verbs.h>'))
2308 endif
2309
2310 have_asan_fiber = false
2311 if get_option('sanitizers') and \
2312    not cc.has_function('__sanitizer_start_switch_fiber',
2313                          args: '-fsanitize=address',
2314                          prefix: '#include <sanitizer/asan_interface.h>')
2315   warning('Missing ASAN due to missing fiber annotation interface')
2316   warning('Without code annotation, the report may be inferior.')
2317 else
2318   have_asan_fiber = true
2319 endif
2320 config_host_data.set('CONFIG_ASAN_IFACE_FIBER', have_asan_fiber)
2321
2322 # has_header_symbol
2323 config_host_data.set('CONFIG_BLKZONED',
2324                      cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE'))
2325 config_host_data.set('CONFIG_EPOLL_CREATE1',
2326                      cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))
2327 config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',
2328                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_PUNCH_HOLE') and
2329                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_KEEP_SIZE'))
2330 config_host_data.set('CONFIG_FALLOCATE_ZERO_RANGE',
2331                      cc.has_header_symbol('linux/falloc.h', 'FALLOC_FL_ZERO_RANGE'))
2332 config_host_data.set('CONFIG_FIEMAP',
2333                      cc.has_header('linux/fiemap.h') and
2334                      cc.has_header_symbol('linux/fs.h', 'FS_IOC_FIEMAP'))
2335 config_host_data.set('CONFIG_GETRANDOM',
2336                      cc.has_function('getrandom') and
2337                      cc.has_header_symbol('sys/random.h', 'GRND_NONBLOCK'))
2338 config_host_data.set('CONFIG_INOTIFY',
2339                      cc.has_header_symbol('sys/inotify.h', 'inotify_init'))
2340 config_host_data.set('CONFIG_INOTIFY1',
2341                      cc.has_header_symbol('sys/inotify.h', 'inotify_init1'))
2342 config_host_data.set('CONFIG_PRCTL_PR_SET_TIMERSLACK',
2343                      cc.has_header_symbol('sys/prctl.h', 'PR_SET_TIMERSLACK'))
2344 config_host_data.set('CONFIG_RTNETLINK',
2345                      cc.has_header_symbol('linux/rtnetlink.h', 'IFLA_PROTO_DOWN'))
2346 config_host_data.set('CONFIG_SYSMACROS',
2347                      cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
2348 config_host_data.set('HAVE_OPTRESET',
2349                      cc.has_header_symbol('getopt.h', 'optreset'))
2350 config_host_data.set('HAVE_IPPROTO_MPTCP',
2351                      cc.has_header_symbol('netinet/in.h', 'IPPROTO_MPTCP'))
2352
2353 # has_member
2354 config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
2355                      cc.has_member('struct sigevent', 'sigev_notify_thread_id',
2356                                    prefix: '#include <signal.h>'))
2357 config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
2358                      cc.has_member('struct stat', 'st_atim',
2359                                    prefix: '#include <sys/stat.h>'))
2360 config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY',
2361                      cc.has_member('struct blk_zone', 'capacity',
2362                                    prefix: '#include <linux/blkzoned.h>'))
2363
2364 # has_type
2365 config_host_data.set('CONFIG_IOVEC',
2366                      cc.has_type('struct iovec',
2367                                  prefix: '#include <sys/uio.h>'))
2368 config_host_data.set('HAVE_UTMPX',
2369                      cc.has_type('struct utmpx',
2370                                  prefix: '#include <utmpx.h>'))
2371
2372 config_host_data.set('CONFIG_EVENTFD', cc.links('''
2373   #include <sys/eventfd.h>
2374   int main(void) { return eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); }'''))
2375 config_host_data.set('CONFIG_FDATASYNC', cc.links(gnu_source_prefix + '''
2376   #include <unistd.h>
2377   int main(void) {
2378   #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
2379   return fdatasync(0);
2380   #else
2381   #error Not supported
2382   #endif
2383   }'''))
2384
2385 has_madvise = cc.links(gnu_source_prefix + '''
2386   #include <sys/types.h>
2387   #include <sys/mman.h>
2388   #include <stddef.h>
2389   int main(void) { return madvise(NULL, 0, MADV_DONTNEED); }''')
2390 missing_madvise_proto = false
2391 if has_madvise
2392   # Some platforms (illumos and Solaris before Solaris 11) provide madvise()
2393   # but forget to prototype it. In this case, has_madvise will be true (the
2394   # test program links despite a compile warning). To detect the
2395   # missing-prototype case, we try again with a definitely-bogus prototype.
2396   # This will only compile if the system headers don't provide the prototype;
2397   # otherwise the conflicting prototypes will cause a compiler error.
2398   missing_madvise_proto = cc.links(gnu_source_prefix + '''
2399     #include <sys/types.h>
2400     #include <sys/mman.h>
2401     #include <stddef.h>
2402     extern int madvise(int);
2403     int main(void) { return madvise(0); }''')
2404 endif
2405 config_host_data.set('CONFIG_MADVISE', has_madvise)
2406 config_host_data.set('HAVE_MADVISE_WITHOUT_PROTOTYPE', missing_madvise_proto)
2407
2408 config_host_data.set('CONFIG_MEMFD', cc.links(gnu_source_prefix + '''
2409   #include <sys/mman.h>
2410   int main(void) { return memfd_create("foo", MFD_ALLOW_SEALING); }'''))
2411 config_host_data.set('CONFIG_OPEN_BY_HANDLE', cc.links(gnu_source_prefix + '''
2412   #include <fcntl.h>
2413   #if !defined(AT_EMPTY_PATH)
2414   # error missing definition
2415   #else
2416   int main(void) { struct file_handle fh; return open_by_handle_at(0, &fh, 0); }
2417   #endif'''))
2418 config_host_data.set('CONFIG_POSIX_MADVISE', cc.links(gnu_source_prefix + '''
2419   #include <sys/mman.h>
2420   #include <stddef.h>
2421   int main(void) { return posix_madvise(NULL, 0, POSIX_MADV_DONTNEED); }'''))
2422
2423 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_W_TID', cc.links(gnu_source_prefix + '''
2424   #include <pthread.h>
2425
2426   static void *f(void *p) { return NULL; }
2427   int main(void)
2428   {
2429     pthread_t thread;
2430     pthread_create(&thread, 0, f, 0);
2431     pthread_setname_np(thread, "QEMU");
2432     return 0;
2433   }''', dependencies: threads))
2434 config_host_data.set('CONFIG_PTHREAD_SETNAME_NP_WO_TID', cc.links(gnu_source_prefix + '''
2435   #include <pthread.h>
2436
2437   static void *f(void *p) { pthread_setname_np("QEMU"); return NULL; }
2438   int main(void)
2439   {
2440     pthread_t thread;
2441     pthread_create(&thread, 0, f, 0);
2442     return 0;
2443   }''', dependencies: threads))
2444 config_host_data.set('CONFIG_PTHREAD_SET_NAME_NP', cc.links(gnu_source_prefix + '''
2445   #include <pthread.h>
2446   #include <pthread_np.h>
2447
2448   static void *f(void *p) { return NULL; }
2449   int main(void)
2450   {
2451     pthread_t thread;
2452     pthread_create(&thread, 0, f, 0);
2453     pthread_set_name_np(thread, "QEMU");
2454     return 0;
2455   }''', dependencies: threads))
2456 config_host_data.set('CONFIG_PTHREAD_CONDATTR_SETCLOCK', cc.links(gnu_source_prefix + '''
2457   #include <pthread.h>
2458   #include <time.h>
2459
2460   int main(void)
2461   {
2462     pthread_condattr_t attr
2463     pthread_condattr_init(&attr);
2464     pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
2465     return 0;
2466   }''', dependencies: threads))
2467 config_host_data.set('CONFIG_PTHREAD_AFFINITY_NP', cc.links(gnu_source_prefix + '''
2468   #include <pthread.h>
2469
2470   static void *f(void *p) { return NULL; }
2471   int main(void)
2472   {
2473     int setsize = CPU_ALLOC_SIZE(64);
2474     pthread_t thread;
2475     cpu_set_t *cpuset;
2476     pthread_create(&thread, 0, f, 0);
2477     cpuset = CPU_ALLOC(64);
2478     CPU_ZERO_S(setsize, cpuset);
2479     pthread_setaffinity_np(thread, setsize, cpuset);
2480     pthread_getaffinity_np(thread, setsize, cpuset);
2481     CPU_FREE(cpuset);
2482     return 0;
2483   }''', dependencies: threads))
2484 config_host_data.set('CONFIG_SIGNALFD', cc.links(gnu_source_prefix + '''
2485   #include <sys/signalfd.h>
2486   #include <stddef.h>
2487   int main(void) { return signalfd(-1, NULL, SFD_CLOEXEC); }'''))
2488 config_host_data.set('CONFIG_SPLICE', cc.links(gnu_source_prefix + '''
2489   #include <unistd.h>
2490   #include <fcntl.h>
2491   #include <limits.h>
2492
2493   int main(void)
2494   {
2495     int len, fd = 0;
2496     len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
2497     splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
2498     return 0;
2499   }'''))
2500
2501 config_host_data.set('HAVE_MLOCKALL', cc.links(gnu_source_prefix + '''
2502   #include <sys/mman.h>
2503   int main(void) {
2504     return mlockall(MCL_FUTURE);
2505   }'''))
2506
2507 have_l2tpv3 = false
2508 if get_option('l2tpv3').allowed() and have_system
2509   have_l2tpv3 = cc.has_type('struct mmsghdr',
2510     prefix: gnu_source_prefix + '''
2511       #include <sys/socket.h>
2512       #include <linux/ip.h>''')
2513 endif
2514 config_host_data.set('CONFIG_L2TPV3', have_l2tpv3)
2515
2516 have_netmap = false
2517 if get_option('netmap').allowed() and have_system
2518   have_netmap = cc.compiles('''
2519     #include <inttypes.h>
2520     #include <net/if.h>
2521     #include <net/netmap.h>
2522     #include <net/netmap_user.h>
2523     #if (NETMAP_API < 11) || (NETMAP_API > 15)
2524     #error
2525     #endif
2526     int main(void) { return 0; }''')
2527   if not have_netmap and get_option('netmap').enabled()
2528     error('Netmap headers not available')
2529   endif
2530 endif
2531 config_host_data.set('CONFIG_NETMAP', have_netmap)
2532
2533 # Work around a system header bug with some kernel/XFS header
2534 # versions where they both try to define 'struct fsxattr':
2535 # xfs headers will not try to redefine structs from linux headers
2536 # if this macro is set.
2537 config_host_data.set('HAVE_FSXATTR', cc.links('''
2538   #include <linux/fs.h>
2539   struct fsxattr foo;
2540   int main(void) {
2541     return 0;
2542   }'''))
2543
2544 # Some versions of Mac OS X incorrectly define SIZE_MAX
2545 config_host_data.set('HAVE_BROKEN_SIZE_MAX', not cc.compiles('''
2546     #include <stdint.h>
2547     #include <stdio.h>
2548     int main(void) {
2549         return printf("%zu", SIZE_MAX);
2550     }''', args: ['-Werror']))
2551
2552 # See if 64-bit atomic operations are supported.
2553 # Note that without __atomic builtins, we can only
2554 # assume atomic loads/stores max at pointer size.
2555 config_host_data.set('CONFIG_ATOMIC64', cc.links('''
2556   #include <stdint.h>
2557   int main(void)
2558   {
2559     uint64_t x = 0, y = 0;
2560     y = __atomic_load_n(&x, __ATOMIC_RELAXED);
2561     __atomic_store_n(&x, y, __ATOMIC_RELAXED);
2562     __atomic_compare_exchange_n(&x, &y, x, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2563     __atomic_exchange_n(&x, y, __ATOMIC_RELAXED);
2564     __atomic_fetch_add(&x, y, __ATOMIC_RELAXED);
2565     return 0;
2566   }'''))
2567
2568 has_int128_type = cc.compiles('''
2569   __int128_t a;
2570   __uint128_t b;
2571   int main(void) { b = a; }''')
2572 config_host_data.set('CONFIG_INT128_TYPE', has_int128_type)
2573
2574 has_int128 = has_int128_type and cc.links('''
2575   __int128_t a;
2576   __uint128_t b;
2577   int main (void) {
2578     a = a + b;
2579     b = a * b;
2580     a = a * a;
2581     return 0;
2582   }''')
2583 config_host_data.set('CONFIG_INT128', has_int128)
2584
2585 if has_int128_type
2586   # "do we have 128-bit atomics which are handled inline and specifically not
2587   # via libatomic". The reason we can't use libatomic is documented in the
2588   # comment starting "GCC is a house divided" in include/qemu/atomic128.h.
2589   # We only care about these operations on 16-byte aligned pointers, so
2590   # force 16-byte alignment of the pointer, which may be greater than
2591   # __alignof(unsigned __int128) for the host.
2592   atomic_test_128 = '''
2593     int main(int ac, char **av) {
2594       __uint128_t *p = __builtin_assume_aligned(av[ac - 1], 16);
2595       p[1] = __atomic_load_n(&p[0], __ATOMIC_RELAXED);
2596       __atomic_store_n(&p[2], p[3], __ATOMIC_RELAXED);
2597       __atomic_compare_exchange_n(&p[4], &p[5], p[6], 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
2598       return 0;
2599     }'''
2600   has_atomic128 = cc.links(atomic_test_128)
2601
2602   config_host_data.set('CONFIG_ATOMIC128', has_atomic128)
2603
2604   if not has_atomic128
2605     # Even with __builtin_assume_aligned, the above test may have failed
2606     # without optimization enabled.  Try again with optimizations locally
2607     # enabled for the function.  See
2608     #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107389
2609     has_atomic128_opt = cc.links('__attribute__((optimize("O1")))' + atomic_test_128)
2610     config_host_data.set('CONFIG_ATOMIC128_OPT', has_atomic128_opt)
2611
2612     if not has_atomic128_opt
2613       config_host_data.set('CONFIG_CMPXCHG128', cc.links('''
2614         int main(void)
2615         {
2616           __uint128_t x = 0, y = 0;
2617           __sync_val_compare_and_swap_16(&x, y, x);
2618           return 0;
2619         }
2620       '''))
2621     endif
2622   endif
2623 endif
2624
2625 config_host_data.set('CONFIG_GETAUXVAL', cc.links(gnu_source_prefix + '''
2626   #include <sys/auxv.h>
2627   int main(void) {
2628     return getauxval(AT_HWCAP) == 0;
2629   }'''))
2630
2631 config_host_data.set('CONFIG_USBFS', have_linux_user and cc.compiles('''
2632   #include <linux/usbdevice_fs.h>
2633
2634   #ifndef USBDEVFS_GET_CAPABILITIES
2635   #error "USBDEVFS_GET_CAPABILITIES undefined"
2636   #endif
2637
2638   #ifndef USBDEVFS_DISCONNECT_CLAIM
2639   #error "USBDEVFS_DISCONNECT_CLAIM undefined"
2640   #endif
2641
2642   int main(void) { return 0; }'''))
2643
2644 have_keyring = get_option('keyring') \
2645   .require(targetos == 'linux', error_message: 'keyring is only available on Linux') \
2646   .require(cc.compiles('''
2647     #include <errno.h>
2648     #include <asm/unistd.h>
2649     #include <linux/keyctl.h>
2650     #include <sys/syscall.h>
2651     #include <unistd.h>
2652     int main(void) {
2653         return syscall(__NR_keyctl, KEYCTL_READ, 0, NULL, NULL, 0);
2654     }'''), error_message: 'keyctl syscall not available on this system').allowed()
2655 config_host_data.set('CONFIG_SECRET_KEYRING', have_keyring)
2656
2657 have_cpuid_h = cc.links('''
2658   #include <cpuid.h>
2659   int main(void) {
2660     unsigned a, b, c, d;
2661     unsigned max = __get_cpuid_max(0, 0);
2662
2663     if (max >= 1) {
2664         __cpuid(1, a, b, c, d);
2665     }
2666
2667     if (max >= 7) {
2668         __cpuid_count(7, 0, a, b, c, d);
2669     }
2670
2671     return 0;
2672   }''')
2673 config_host_data.set('CONFIG_CPUID_H', have_cpuid_h)
2674
2675 config_host_data.set('CONFIG_AVX2_OPT', get_option('avx2') \
2676   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX2') \
2677   .require(cc.links('''
2678     #include <cpuid.h>
2679     #include <immintrin.h>
2680     static int __attribute__((target("avx2"))) bar(void *a) {
2681       __m256i x = *(__m256i *)a;
2682       return _mm256_testz_si256(x, x);
2683     }
2684     int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2685   '''), error_message: 'AVX2 not available').allowed())
2686
2687 config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \
2688   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512F') \
2689   .require(cc.links('''
2690     #include <cpuid.h>
2691     #include <immintrin.h>
2692     static int __attribute__((target("avx512f"))) bar(void *a) {
2693       __m512i x = *(__m512i *)a;
2694       return _mm512_test_epi64_mask(x, x);
2695     }
2696     int main(int argc, char *argv[]) { return bar(argv[argc - 1]); }
2697   '''), error_message: 'AVX512F not available').allowed())
2698
2699 config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \
2700   .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \
2701   .require(cc.links('''
2702     #include <cpuid.h>
2703     #include <immintrin.h>
2704     static int __attribute__((target("avx512bw"))) bar(void *a) {
2705       __m512i *x = a;
2706       __m512i res= _mm512_abs_epi8(*x);
2707       return res[1];
2708     }
2709     int main(int argc, char *argv[]) { return bar(argv[0]); }
2710   '''), error_message: 'AVX512BW not available').allowed())
2711
2712 # For both AArch64 and AArch32, detect if builtins are available.
2713 config_host_data.set('CONFIG_ARM_AES_BUILTIN', cc.compiles('''
2714     #include <arm_neon.h>
2715     #ifndef __ARM_FEATURE_AES
2716     __attribute__((target("+crypto")))
2717     #endif
2718     void foo(uint8x16_t *p) { *p = vaesmcq_u8(*p); }
2719   '''))
2720
2721 have_pvrdma = get_option('pvrdma') \
2722   .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \
2723   .require(cc.compiles(gnu_source_prefix + '''
2724     #include <sys/mman.h>
2725     int main(void)
2726     {
2727       char buf = 0;
2728       void *addr = &buf;
2729       addr = mremap(addr, 0, 1, MREMAP_MAYMOVE | MREMAP_FIXED);
2730
2731       return 0;
2732     }'''), error_message: 'PVRDMA requires mremap').allowed()
2733
2734 if have_pvrdma
2735   config_host_data.set('LEGACY_RDMA_REG_MR', not cc.links('''
2736     #include <infiniband/verbs.h>
2737     int main(void)
2738     {
2739       struct ibv_mr *mr;
2740       struct ibv_pd *pd = NULL;
2741       size_t length = 10;
2742       uint64_t iova = 0;
2743       int access = 0;
2744       void *addr = NULL;
2745
2746       mr = ibv_reg_mr_iova(pd, addr, length, iova, access);
2747       ibv_dereg_mr(mr);
2748       return 0;
2749     }'''))
2750 endif
2751
2752 if get_option('membarrier').disabled()
2753   have_membarrier = false
2754 elif targetos == 'windows'
2755   have_membarrier = true
2756 elif targetos == 'linux'
2757   have_membarrier = cc.compiles('''
2758     #include <linux/membarrier.h>
2759     #include <sys/syscall.h>
2760     #include <unistd.h>
2761     #include <stdlib.h>
2762     int main(void) {
2763         syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0);
2764         syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0);
2765         exit(0);
2766     }''')
2767 endif
2768 config_host_data.set('CONFIG_MEMBARRIER', get_option('membarrier') \
2769   .require(have_membarrier, error_message: 'membarrier system call not available') \
2770   .allowed())
2771
2772 have_afalg = get_option('crypto_afalg') \
2773   .require(cc.compiles(gnu_source_prefix + '''
2774     #include <errno.h>
2775     #include <sys/types.h>
2776     #include <sys/socket.h>
2777     #include <linux/if_alg.h>
2778     int main(void) {
2779       int sock;
2780       sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
2781       return sock;
2782     }
2783   '''), error_message: 'AF_ALG requested but could not be detected').allowed()
2784 config_host_data.set('CONFIG_AF_ALG', have_afalg)
2785
2786 config_host_data.set('CONFIG_AF_VSOCK', cc.has_header_symbol(
2787   'linux/vm_sockets.h', 'AF_VSOCK',
2788   prefix: '#include <sys/socket.h>',
2789 ))
2790
2791 have_vss = false
2792 have_vss_sdk = false # old xp/2003 SDK
2793 if targetos == 'windows' and 'cpp' in all_languages
2794   have_vss = cxx.compiles('''
2795     #define __MIDL_user_allocate_free_DEFINED__
2796     #include <vss.h>
2797     int main(void) { return VSS_CTX_BACKUP; }''')
2798   have_vss_sdk = cxx.has_header('vscoordint.h')
2799 endif
2800 config_host_data.set('HAVE_VSS_SDK', have_vss_sdk)
2801
2802 # Older versions of MinGW do not import _lock_file and _unlock_file properly.
2803 # This was fixed for v6.0.0 with commit b48e3ac8969d.
2804 if targetos == 'windows'
2805   config_host_data.set('HAVE__LOCK_FILE', cc.links('''
2806     #include <stdio.h>
2807     int main(void) {
2808       _lock_file(NULL);
2809       _unlock_file(NULL);
2810       return 0;
2811     }''', name: '_lock_file and _unlock_file'))
2812 endif
2813
2814 if targetos == 'windows'
2815   mingw_has_setjmp_longjmp = cc.links('''
2816     #include <setjmp.h>
2817     int main(void) {
2818       /*
2819        * These functions are not available in setjmp header, but may be
2820        * available at link time, from libmingwex.a.
2821        */
2822       extern int __mingw_setjmp(jmp_buf);
2823       extern void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int);
2824       jmp_buf env;
2825       __mingw_setjmp(env);
2826       __mingw_longjmp(env, 0);
2827     }
2828   ''', name: 'mingw setjmp and longjmp')
2829
2830   if cpu == 'aarch64' and not mingw_has_setjmp_longjmp
2831     error('mingw must provide setjmp/longjmp for windows-arm64')
2832   endif
2833 endif
2834
2835 ########################
2836 # Target configuration #
2837 ########################
2838
2839 minikconf = find_program('scripts/minikconf.py')
2840 config_targetos = {
2841   (targetos == 'windows' ? 'CONFIG_WIN32' : 'CONFIG_POSIX'): 'y'
2842 }
2843 if targetos == 'darwin'
2844   config_targetos += {'CONFIG_DARWIN': 'y'}
2845 elif targetos == 'linux'
2846   config_targetos += {'CONFIG_LINUX': 'y'}
2847 endif
2848 if targetos in bsd_oses
2849   config_targetos += {'CONFIG_BSD': 'y'}
2850 endif
2851
2852 config_all = {}
2853 config_all_devices = {}
2854 config_all_disas = {}
2855 config_devices_mak_list = []
2856 config_devices_h = {}
2857 config_target_h = {}
2858 config_target_mak = {}
2859
2860 disassemblers = {
2861   'alpha' : ['CONFIG_ALPHA_DIS'],
2862   'avr' : ['CONFIG_AVR_DIS'],
2863   'cris' : ['CONFIG_CRIS_DIS'],
2864   'hexagon' : ['CONFIG_HEXAGON_DIS'],
2865   'hppa' : ['CONFIG_HPPA_DIS'],
2866   'i386' : ['CONFIG_I386_DIS'],
2867   'x86_64' : ['CONFIG_I386_DIS'],
2868   'm68k' : ['CONFIG_M68K_DIS'],
2869   'microblaze' : ['CONFIG_MICROBLAZE_DIS'],
2870   'mips' : ['CONFIG_MIPS_DIS'],
2871   'nios2' : ['CONFIG_NIOS2_DIS'],
2872   'or1k' : ['CONFIG_OPENRISC_DIS'],
2873   'ppc' : ['CONFIG_PPC_DIS'],
2874   'riscv' : ['CONFIG_RISCV_DIS'],
2875   'rx' : ['CONFIG_RX_DIS'],
2876   's390' : ['CONFIG_S390_DIS'],
2877   'sh4' : ['CONFIG_SH4_DIS'],
2878   'sparc' : ['CONFIG_SPARC_DIS'],
2879   'xtensa' : ['CONFIG_XTENSA_DIS'],
2880   'loongarch' : ['CONFIG_LOONGARCH_DIS'],
2881 }
2882
2883 have_ivshmem = config_host_data.get('CONFIG_EVENTFD')
2884 host_kconfig = \
2885   (get_option('fuzzing') ? ['CONFIG_FUZZ=y'] : []) + \
2886   (have_tpm ? ['CONFIG_TPM=y'] : []) + \
2887   (pixman.found() ? ['CONFIG_PIXMAN=y'] : []) + \
2888   (spice.found() ? ['CONFIG_SPICE=y'] : []) + \
2889   (have_ivshmem ? ['CONFIG_IVSHMEM=y'] : []) + \
2890   (opengl.found() ? ['CONFIG_OPENGL=y'] : []) + \
2891   (x11.found() ? ['CONFIG_X11=y'] : []) + \
2892   (have_vhost_user ? ['CONFIG_VHOST_USER=y'] : []) + \
2893   (have_vhost_vdpa ? ['CONFIG_VHOST_VDPA=y'] : []) + \
2894   (have_vhost_kernel ? ['CONFIG_VHOST_KERNEL=y'] : []) + \
2895   (have_virtfs ? ['CONFIG_VIRTFS=y'] : []) + \
2896   (targetos == 'linux' ? ['CONFIG_LINUX=y'] : []) + \
2897   (have_pvrdma ? ['CONFIG_PVRDMA=y'] : []) + \
2898   (multiprocess_allowed ? ['CONFIG_MULTIPROCESS_ALLOWED=y'] : []) + \
2899   (vfio_user_server_allowed ? ['CONFIG_VFIO_USER_SERVER_ALLOWED=y'] : []) + \
2900   (hv_balloon ? ['CONFIG_HV_BALLOON_POSSIBLE=y'] : [])
2901
2902 ignored = [ 'TARGET_XML_FILES', 'TARGET_ABI_DIR', 'TARGET_ARCH' ]
2903
2904 default_targets = 'CONFIG_DEFAULT_TARGETS' in config_host
2905 actual_target_dirs = []
2906 fdt_required = []
2907 foreach target : target_dirs
2908   config_target = { 'TARGET_NAME': target.split('-')[0] }
2909   if target.endswith('linux-user')
2910     if targetos != 'linux'
2911       if default_targets
2912         continue
2913       endif
2914       error('Target @0@ is only available on a Linux host'.format(target))
2915     endif
2916     config_target += { 'CONFIG_LINUX_USER': 'y' }
2917   elif target.endswith('bsd-user')
2918     if targetos not in bsd_oses
2919       if default_targets
2920         continue
2921       endif
2922       error('Target @0@ is only available on a BSD host'.format(target))
2923     endif
2924     config_target += { 'CONFIG_BSD_USER': 'y' }
2925   elif target.endswith('softmmu')
2926     config_target += { 'CONFIG_SYSTEM_ONLY': 'y' }
2927     config_target += { 'CONFIG_SOFTMMU': 'y' }
2928   endif
2929   if target.endswith('-user')
2930     config_target += {
2931       'CONFIG_USER_ONLY': 'y',
2932       'CONFIG_QEMU_INTERP_PREFIX':
2933         get_option('interp_prefix').replace('%M', config_target['TARGET_NAME'])
2934     }
2935   endif
2936
2937   accel_kconfig = []
2938   foreach sym: accelerators
2939     if sym == 'CONFIG_TCG' or target in accelerator_targets.get(sym, [])
2940       config_target += { sym: 'y' }
2941       config_all += { sym: 'y' }
2942       if target in modular_tcg
2943         config_target += { 'CONFIG_TCG_MODULAR': 'y' }
2944       else
2945         config_target += { 'CONFIG_TCG_BUILTIN': 'y' }
2946       endif
2947       accel_kconfig += [ sym + '=y' ]
2948     endif
2949   endforeach
2950   if accel_kconfig.length() == 0
2951     if default_targets
2952       continue
2953     endif
2954     error('No accelerator available for target @0@'.format(target))
2955   endif
2956
2957   actual_target_dirs += target
2958   config_target += keyval.load('configs/targets' / target + '.mak')
2959   config_target += { 'TARGET_' + config_target['TARGET_ARCH'].to_upper(): 'y' }
2960
2961   if 'TARGET_NEED_FDT' in config_target
2962     fdt_required += target
2963   endif
2964
2965   # Add default keys
2966   if 'TARGET_BASE_ARCH' not in config_target
2967     config_target += {'TARGET_BASE_ARCH': config_target['TARGET_ARCH']}
2968   endif
2969   if 'TARGET_ABI_DIR' not in config_target
2970     config_target += {'TARGET_ABI_DIR': config_target['TARGET_ARCH']}
2971   endif
2972   if 'TARGET_BIG_ENDIAN' not in config_target
2973     config_target += {'TARGET_BIG_ENDIAN': 'n'}
2974   endif
2975
2976   foreach k, v: disassemblers
2977     if host_arch.startswith(k) or config_target['TARGET_BASE_ARCH'].startswith(k)
2978       foreach sym: v
2979         config_target += { sym: 'y' }
2980         config_all_disas += { sym: 'y' }
2981       endforeach
2982     endif
2983   endforeach
2984
2985   config_target_data = configuration_data()
2986   foreach k, v: config_target
2987     if not k.startswith('TARGET_') and not k.startswith('CONFIG_')
2988       # do nothing
2989     elif ignored.contains(k)
2990       # do nothing
2991     elif k == 'TARGET_BASE_ARCH'
2992       # Note that TARGET_BASE_ARCH ends up in config-target.h but it is
2993       # not used to select files from sourcesets.
2994       config_target_data.set('TARGET_' + v.to_upper(), 1)
2995     elif k == 'TARGET_NAME' or k == 'CONFIG_QEMU_INTERP_PREFIX'
2996       config_target_data.set_quoted(k, v)
2997     elif v == 'y'
2998       config_target_data.set(k, 1)
2999     elif v == 'n'
3000       config_target_data.set(k, 0)
3001     else
3002       config_target_data.set(k, v)
3003     endif
3004   endforeach
3005   config_target_data.set('QEMU_ARCH',
3006                          'QEMU_ARCH_' + config_target['TARGET_BASE_ARCH'].to_upper())
3007   config_target_h += {target: configure_file(output: target + '-config-target.h',
3008                                                configuration: config_target_data)}
3009
3010   if target.endswith('-softmmu')
3011     config_input = meson.get_external_property(target, 'default')
3012     config_devices_mak = target + '-config-devices.mak'
3013     config_devices_mak = configure_file(
3014       input: ['configs/devices' / target / config_input + '.mak', 'Kconfig'],
3015       output: config_devices_mak,
3016       depfile: config_devices_mak + '.d',
3017       capture: true,
3018       command: [minikconf,
3019                 get_option('default_devices') ? '--defconfig' : '--allnoconfig',
3020                 config_devices_mak, '@DEPFILE@', '@INPUT@',
3021                 host_kconfig, accel_kconfig,
3022                 'CONFIG_' + config_target['TARGET_ARCH'].to_upper() + '=y'])
3023
3024     config_devices_data = configuration_data()
3025     config_devices = keyval.load(config_devices_mak)
3026     foreach k, v: config_devices
3027       config_devices_data.set(k, 1)
3028     endforeach
3029     config_devices_mak_list += config_devices_mak
3030     config_devices_h += {target: configure_file(output: target + '-config-devices.h',
3031                                                 configuration: config_devices_data)}
3032     config_target += config_devices
3033     config_all_devices += config_devices
3034   endif
3035   config_target_mak += {target: config_target}
3036 endforeach
3037 target_dirs = actual_target_dirs
3038
3039 # This configuration is used to build files that are shared by
3040 # multiple binaries, and then extracted out of the "common"
3041 # static_library target.
3042 #
3043 # We do not use all_sources()/all_dependencies(), because it would
3044 # build literally all source files, including devices only used by
3045 # targets that are not built for this compilation.  The CONFIG_ALL
3046 # pseudo symbol replaces it.
3047
3048 config_all += config_all_devices
3049 config_all += config_targetos
3050 config_all += config_all_disas
3051 config_all += {
3052   'CONFIG_XEN': xen.found(),
3053   'CONFIG_SYSTEM_ONLY': have_system,
3054   'CONFIG_USER_ONLY': have_user,
3055   'CONFIG_ALL': true,
3056 }
3057
3058 target_configs_h = []
3059 foreach target: target_dirs
3060   target_configs_h += config_target_h[target]
3061   target_configs_h += config_devices_h.get(target, [])
3062 endforeach
3063 genh += custom_target('config-poison.h',
3064                       input: [target_configs_h],
3065                       output: 'config-poison.h',
3066                       capture: true,
3067                       command: [find_program('scripts/make-config-poison.sh'),
3068                                 target_configs_h])
3069
3070 ##############
3071 # Submodules #
3072 ##############
3073
3074 capstone = not_found
3075 if not get_option('capstone').auto() or have_system or have_user
3076   capstone = dependency('capstone', version: '>=3.0.5',
3077                         method: 'pkg-config',
3078                         required: get_option('capstone'))
3079
3080   # Some versions of capstone have broken pkg-config file
3081   # that reports a wrong -I path, causing the #include to
3082   # fail later. If the system has such a broken version
3083   # do not use it.
3084   if capstone.found() and not cc.compiles('#include <capstone.h>',
3085                                           dependencies: [capstone])
3086     capstone = not_found
3087     if get_option('capstone').enabled()
3088       error('capstone requested, but it does not appear to work')
3089     endif
3090   endif
3091 endif
3092
3093 libvfio_user_dep = not_found
3094 if have_system and vfio_user_server_allowed
3095   libvfio_user_proj = subproject('libvfio-user', required: true)
3096   libvfio_user_dep = libvfio_user_proj.get_variable('libvfio_user_dep')
3097 endif
3098
3099 fdt = not_found
3100 fdt_opt = get_option('fdt')
3101 if fdt_required.length() > 0 or fdt_opt == 'enabled'
3102   if fdt_opt == 'disabled'
3103     error('fdt disabled but required by targets ' + ', '.join(fdt_required))
3104   endif
3105
3106   if fdt_opt in ['enabled', 'auto', 'system']
3107     if get_option('wrap_mode') == 'nodownload'
3108       fdt_opt = 'system'
3109     endif
3110     fdt = cc.find_library('fdt', required: fdt_opt == 'system')
3111     if fdt.found() and cc.links('''
3112        #include <libfdt.h>
3113        #include <libfdt_env.h>
3114        int main(void) { fdt_find_max_phandle(NULL, NULL); return 0; }''',
3115          dependencies: fdt)
3116       fdt_opt = 'system'
3117     elif fdt_opt == 'system'
3118        error('system libfdt requested, but it is too old (1.5.1 or newer required)')
3119     else
3120       fdt_opt = 'internal'
3121       fdt = not_found
3122     endif
3123   endif
3124   if not fdt.found()
3125     assert(fdt_opt == 'internal')
3126     libfdt_proj = subproject('dtc', required: true,
3127                              default_options: ['tools=false',  'yaml=disabled',
3128                                                'python=disabled', 'default_library=static'])
3129     fdt = libfdt_proj.get_variable('libfdt_dep')
3130   endif
3131 else
3132   fdt_opt = 'disabled'
3133 endif
3134
3135 config_host_data.set('CONFIG_CAPSTONE', capstone.found())
3136 config_host_data.set('CONFIG_FDT', fdt.found())
3137 config_host_data.set('CONFIG_SLIRP', slirp.found())
3138
3139 #####################
3140 # Generated sources #
3141 #####################
3142
3143 genh += configure_file(output: 'config-host.h', configuration: config_host_data)
3144
3145 hxtool = find_program('scripts/hxtool')
3146 shaderinclude = find_program('scripts/shaderinclude.py')
3147 qapi_gen = find_program('scripts/qapi-gen.py')
3148 qapi_gen_depends = [ meson.current_source_dir() / 'scripts/qapi/__init__.py',
3149                      meson.current_source_dir() / 'scripts/qapi/commands.py',
3150                      meson.current_source_dir() / 'scripts/qapi/common.py',
3151                      meson.current_source_dir() / 'scripts/qapi/error.py',
3152                      meson.current_source_dir() / 'scripts/qapi/events.py',
3153                      meson.current_source_dir() / 'scripts/qapi/expr.py',
3154                      meson.current_source_dir() / 'scripts/qapi/gen.py',
3155                      meson.current_source_dir() / 'scripts/qapi/introspect.py',
3156                      meson.current_source_dir() / 'scripts/qapi/main.py',
3157                      meson.current_source_dir() / 'scripts/qapi/parser.py',
3158                      meson.current_source_dir() / 'scripts/qapi/schema.py',
3159                      meson.current_source_dir() / 'scripts/qapi/source.py',
3160                      meson.current_source_dir() / 'scripts/qapi/types.py',
3161                      meson.current_source_dir() / 'scripts/qapi/visit.py',
3162                      meson.current_source_dir() / 'scripts/qapi-gen.py'
3163 ]
3164
3165 tracetool = [
3166   python, files('scripts/tracetool.py'),
3167    '--backend=' + ','.join(get_option('trace_backends'))
3168 ]
3169 tracetool_depends = files(
3170   'scripts/tracetool/backend/log.py',
3171   'scripts/tracetool/backend/__init__.py',
3172   'scripts/tracetool/backend/dtrace.py',
3173   'scripts/tracetool/backend/ftrace.py',
3174   'scripts/tracetool/backend/simple.py',
3175   'scripts/tracetool/backend/syslog.py',
3176   'scripts/tracetool/backend/ust.py',
3177   'scripts/tracetool/format/ust_events_c.py',
3178   'scripts/tracetool/format/ust_events_h.py',
3179   'scripts/tracetool/format/__init__.py',
3180   'scripts/tracetool/format/d.py',
3181   'scripts/tracetool/format/simpletrace_stap.py',
3182   'scripts/tracetool/format/c.py',
3183   'scripts/tracetool/format/h.py',
3184   'scripts/tracetool/format/log_stap.py',
3185   'scripts/tracetool/format/stap.py',
3186   'scripts/tracetool/__init__.py',
3187   'scripts/tracetool/vcpu.py'
3188 )
3189
3190 qemu_version_cmd = [find_program('scripts/qemu-version.sh'),
3191                     meson.current_source_dir(),
3192                     get_option('pkgversion'), meson.project_version()]
3193 qemu_version = custom_target('qemu-version.h',
3194                              output: 'qemu-version.h',
3195                              command: qemu_version_cmd,
3196                              capture: true,
3197                              build_by_default: true,
3198                              build_always_stale: true)
3199 genh += qemu_version
3200
3201 hxdep = []
3202 hx_headers = [
3203   ['qemu-options.hx', 'qemu-options.def'],
3204   ['qemu-img-cmds.hx', 'qemu-img-cmds.h'],
3205 ]
3206 if have_system
3207   hx_headers += [
3208     ['hmp-commands.hx', 'hmp-commands.h'],
3209     ['hmp-commands-info.hx', 'hmp-commands-info.h'],
3210   ]
3211 endif
3212 foreach d : hx_headers
3213   hxdep += custom_target(d[1],
3214                 input: files(d[0]),
3215                 output: d[1],
3216                 capture: true,
3217                 command: [hxtool, '-h', '@INPUT0@'])
3218 endforeach
3219 genh += hxdep
3220
3221 ###################
3222 # Collect sources #
3223 ###################
3224
3225 authz_ss = ss.source_set()
3226 blockdev_ss = ss.source_set()
3227 block_ss = ss.source_set()
3228 chardev_ss = ss.source_set()
3229 common_ss = ss.source_set()
3230 crypto_ss = ss.source_set()
3231 hwcore_ss = ss.source_set()
3232 io_ss = ss.source_set()
3233 qmp_ss = ss.source_set()
3234 qom_ss = ss.source_set()
3235 system_ss = ss.source_set()
3236 specific_fuzz_ss = ss.source_set()
3237 specific_ss = ss.source_set()
3238 stub_ss = ss.source_set()
3239 trace_ss = ss.source_set()
3240 user_ss = ss.source_set()
3241 util_ss = ss.source_set()
3242
3243 # accel modules
3244 qtest_module_ss = ss.source_set()
3245 tcg_module_ss = ss.source_set()
3246
3247 modules = {}
3248 target_modules = {}
3249 hw_arch = {}
3250 target_arch = {}
3251 target_system_arch = {}
3252 target_user_arch = {}
3253
3254 ###############
3255 # Trace files #
3256 ###############
3257
3258 # TODO: add each directory to the subdirs from its own meson.build, once
3259 # we have those
3260 trace_events_subdirs = [
3261   'crypto',
3262   'qapi',
3263   'qom',
3264   'monitor',
3265   'util',
3266   'gdbstub',
3267 ]
3268 if have_linux_user
3269   trace_events_subdirs += [ 'linux-user' ]
3270 endif
3271 if have_bsd_user
3272   trace_events_subdirs += [ 'bsd-user' ]
3273 endif
3274 if have_block
3275   trace_events_subdirs += [
3276     'authz',
3277     'block',
3278     'io',
3279     'nbd',
3280     'scsi',
3281   ]
3282 endif
3283 if have_system
3284   trace_events_subdirs += [
3285     'accel/kvm',
3286     'audio',
3287     'backends',
3288     'backends/tpm',
3289     'chardev',
3290     'ebpf',
3291     'hw/9pfs',
3292     'hw/acpi',
3293     'hw/adc',
3294     'hw/alpha',
3295     'hw/arm',
3296     'hw/audio',
3297     'hw/block',
3298     'hw/block/dataplane',
3299     'hw/char',
3300     'hw/display',
3301     'hw/dma',
3302     'hw/hyperv',
3303     'hw/i2c',
3304     'hw/i386',
3305     'hw/i386/xen',
3306     'hw/i386/kvm',
3307     'hw/ide',
3308     'hw/input',
3309     'hw/intc',
3310     'hw/isa',
3311     'hw/mem',
3312     'hw/mips',
3313     'hw/misc',
3314     'hw/misc/macio',
3315     'hw/net',
3316     'hw/net/can',
3317     'hw/nubus',
3318     'hw/nvme',
3319     'hw/nvram',
3320     'hw/pci',
3321     'hw/pci-host',
3322     'hw/ppc',
3323     'hw/rdma',
3324     'hw/rdma/vmw',
3325     'hw/rtc',
3326     'hw/s390x',
3327     'hw/scsi',
3328     'hw/sd',
3329     'hw/sh4',
3330     'hw/sparc',
3331     'hw/sparc64',
3332     'hw/ssi',
3333     'hw/timer',
3334     'hw/tpm',
3335     'hw/ufs',
3336     'hw/usb',
3337     'hw/vfio',
3338     'hw/virtio',
3339     'hw/watchdog',
3340     'hw/xen',
3341     'hw/gpio',
3342     'migration',
3343     'net',
3344     'system',
3345     'ui',
3346     'hw/remote',
3347   ]
3348 endif
3349 if have_system or have_user
3350   trace_events_subdirs += [
3351     'accel/tcg',
3352     'hw/core',
3353     'target/arm',
3354     'target/arm/hvf',
3355     'target/hppa',
3356     'target/i386',
3357     'target/i386/kvm',
3358     'target/mips/tcg',
3359     'target/nios2',
3360     'target/ppc',
3361     'target/riscv',
3362     'target/s390x',
3363     'target/s390x/kvm',
3364     'target/sparc',
3365   ]
3366 endif
3367
3368 vhost_user = not_found
3369 if targetos == 'linux' and have_vhost_user
3370   libvhost_user = subproject('libvhost-user')
3371   vhost_user = libvhost_user.get_variable('vhost_user_dep')
3372 endif
3373
3374 libvduse = not_found
3375 if have_libvduse
3376   libvduse_proj = subproject('libvduse')
3377   libvduse = libvduse_proj.get_variable('libvduse_dep')
3378 endif
3379
3380 # NOTE: the trace/ subdirectory needs the qapi_trace_events variable
3381 # that is filled in by qapi/.
3382 subdir('qapi')
3383 subdir('qobject')
3384 subdir('stubs')
3385 subdir('trace')
3386 subdir('util')
3387 subdir('qom')
3388 subdir('authz')
3389 subdir('crypto')
3390 subdir('ui')
3391 subdir('hw')
3392 subdir('gdbstub')
3393
3394 if enable_modules
3395   libmodulecommon = static_library('module-common', files('module-common.c') + genh, pic: true, c_args: '-DBUILD_DSO')
3396   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
3397 endif
3398
3399 qom_ss = qom_ss.apply(config_targetos, strict: false)
3400 libqom = static_library('qom', qom_ss.sources() + genh,
3401                         dependencies: [qom_ss.dependencies()],
3402                         name_suffix: 'fa',
3403                         build_by_default: false)
3404 qom = declare_dependency(link_whole: libqom)
3405
3406 event_loop_base = files('event-loop-base.c')
3407 event_loop_base = static_library('event-loop-base',
3408                                  sources: event_loop_base + genh,
3409                                  name_suffix: 'fa',
3410                                  build_by_default: false)
3411 event_loop_base = declare_dependency(link_whole: event_loop_base,
3412                                      dependencies: [qom])
3413
3414 stub_ss = stub_ss.apply(config_all, strict: false)
3415
3416 util_ss.add_all(trace_ss)
3417 util_ss = util_ss.apply(config_all, strict: false)
3418 libqemuutil = static_library('qemuutil',
3419                              build_by_default: false,
3420                              sources: util_ss.sources() + stub_ss.sources() + genh,
3421                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
3422 qemuutil = declare_dependency(link_with: libqemuutil,
3423                               sources: genh + version_res,
3424                               dependencies: [event_loop_base])
3425
3426 if have_system or have_user
3427   decodetree = generator(find_program('scripts/decodetree.py'),
3428                          output: 'decode-@BASENAME@.c.inc',
3429                          arguments: ['@INPUT@', '@EXTRA_ARGS@', '-o', '@OUTPUT@'])
3430   subdir('libdecnumber')
3431   subdir('target')
3432 endif
3433
3434 subdir('audio')
3435 subdir('io')
3436 subdir('chardev')
3437 subdir('fsdev')
3438 subdir('dump')
3439
3440 if have_block
3441   block_ss.add(files(
3442     'block.c',
3443     'blockjob.c',
3444     'job.c',
3445     'qemu-io-cmds.c',
3446   ))
3447   if config_host_data.get('CONFIG_REPLICATION')
3448     block_ss.add(files('replication.c'))
3449   endif
3450
3451   subdir('nbd')
3452   subdir('scsi')
3453   subdir('block')
3454
3455   blockdev_ss.add(files(
3456     'blockdev.c',
3457     'blockdev-nbd.c',
3458     'iothread.c',
3459     'job-qmp.c',
3460   ), gnutls)
3461
3462   # os-posix.c contains POSIX-specific functions used by qemu-storage-daemon,
3463   # os-win32.c does not
3464   blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
3465   system_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
3466 endif
3467
3468 common_ss.add(files('cpu-common.c'))
3469 specific_ss.add(files('cpu-target.c'))
3470
3471 subdir('system')
3472
3473 # Work around a gcc bug/misfeature wherein constant propagation looks
3474 # through an alias:
3475 #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99696
3476 # to guess that a const variable is always zero.  Without lto, this is
3477 # impossible, as the alias is restricted to page-vary-common.c.  Indeed,
3478 # without lto, not even the alias is required -- we simply use different
3479 # declarations in different compilation units.
3480 pagevary = files('page-vary-common.c')
3481 if get_option('b_lto')
3482   pagevary_flags = ['-fno-lto']
3483   if get_option('cfi')
3484     pagevary_flags += '-fno-sanitize=cfi-icall'
3485   endif
3486   pagevary = static_library('page-vary-common', sources: pagevary + genh,
3487                             c_args: pagevary_flags)
3488   pagevary = declare_dependency(link_with: pagevary)
3489 endif
3490 common_ss.add(pagevary)
3491 specific_ss.add(files('page-vary-target.c'))
3492
3493 subdir('backends')
3494 subdir('disas')
3495 subdir('migration')
3496 subdir('monitor')
3497 subdir('net')
3498 subdir('replay')
3499 subdir('semihosting')
3500 subdir('stats')
3501 subdir('tcg')
3502 subdir('fpu')
3503 subdir('accel')
3504 subdir('plugins')
3505 subdir('ebpf')
3506
3507 common_user_inc = []
3508
3509 subdir('common-user')
3510 subdir('bsd-user')
3511 subdir('linux-user')
3512
3513 # needed for fuzzing binaries
3514 subdir('tests/qtest/libqos')
3515 subdir('tests/qtest/fuzz')
3516
3517 # accel modules
3518 tcg_real_module_ss = ss.source_set()
3519 tcg_real_module_ss.add_all(when: 'CONFIG_TCG_MODULAR', if_true: tcg_module_ss)
3520 specific_ss.add_all(when: 'CONFIG_TCG_BUILTIN', if_true: tcg_module_ss)
3521 target_modules += { 'accel' : { 'qtest': qtest_module_ss,
3522                                 'tcg': tcg_real_module_ss }}
3523
3524 ########################
3525 # Library dependencies #
3526 ########################
3527
3528 modinfo_collect = find_program('scripts/modinfo-collect.py')
3529 modinfo_generate = find_program('scripts/modinfo-generate.py')
3530 modinfo_files = []
3531
3532 block_mods = []
3533 system_mods = []
3534 foreach d, list : modules
3535   if not (d == 'block' ? have_block : have_system)
3536     continue
3537   endif
3538
3539   foreach m, module_ss : list
3540     if enable_modules
3541       module_ss = module_ss.apply(config_all, strict: false)
3542       sl = static_library(d + '-' + m, [genh, module_ss.sources()],
3543                           dependencies: [modulecommon, module_ss.dependencies()], pic: true)
3544       if d == 'block'
3545         block_mods += sl
3546       else
3547         system_mods += sl
3548       endif
3549       if module_ss.sources() != []
3550         # FIXME: Should use sl.extract_all_objects(recursive: true) as
3551         # input. Sources can be used multiple times but objects are
3552         # unique when it comes to lookup in compile_commands.json.
3553         # Depnds on a mesion version with
3554         # https://github.com/mesonbuild/meson/pull/8900
3555         modinfo_files += custom_target(d + '-' + m + '.modinfo',
3556                                        output: d + '-' + m + '.modinfo',
3557                                        input: module_ss.sources() + genh,
3558                                        capture: true,
3559                                        command: [modinfo_collect, module_ss.sources()])
3560       endif
3561     else
3562       if d == 'block'
3563         block_ss.add_all(module_ss)
3564       else
3565         system_ss.add_all(module_ss)
3566       endif
3567     endif
3568   endforeach
3569 endforeach
3570
3571 foreach d, list : target_modules
3572   foreach m, module_ss : list
3573     if enable_modules
3574       foreach target : target_dirs
3575         if target.endswith('-softmmu')
3576           config_target = config_target_mak[target]
3577           config_target += config_targetos
3578           target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3579           c_args = ['-DNEED_CPU_H',
3580                     '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3581                     '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3582           target_module_ss = module_ss.apply(config_target, strict: false)
3583           if target_module_ss.sources() != []
3584             module_name = d + '-' + m + '-' + config_target['TARGET_NAME']
3585             sl = static_library(module_name,
3586                                 [genh, target_module_ss.sources()],
3587                                 dependencies: [modulecommon, target_module_ss.dependencies()],
3588                                 include_directories: target_inc,
3589                                 c_args: c_args,
3590                                 pic: true)
3591             system_mods += sl
3592             # FIXME: Should use sl.extract_all_objects(recursive: true) too.
3593             modinfo_files += custom_target(module_name + '.modinfo',
3594                                            output: module_name + '.modinfo',
3595                                            input: target_module_ss.sources() + genh,
3596                                            capture: true,
3597                                            command: [modinfo_collect, '--target', target, target_module_ss.sources()])
3598           endif
3599         endif
3600       endforeach
3601     else
3602       specific_ss.add_all(module_ss)
3603     endif
3604   endforeach
3605 endforeach
3606
3607 if enable_modules
3608   foreach target : target_dirs
3609     if target.endswith('-softmmu')
3610       config_target = config_target_mak[target]
3611       config_devices_mak = target + '-config-devices.mak'
3612       modinfo_src = custom_target('modinfo-' + target + '.c',
3613                                   output: 'modinfo-' + target + '.c',
3614                                   input: modinfo_files,
3615                                   command: [modinfo_generate, '--devices', config_devices_mak, '@INPUT@'],
3616                                   capture: true)
3617
3618       modinfo_lib = static_library('modinfo-' + target + '.c', modinfo_src)
3619       modinfo_dep = declare_dependency(link_with: modinfo_lib)
3620
3621       arch = config_target['TARGET_NAME'] == 'sparc64' ? 'sparc64' : config_target['TARGET_BASE_ARCH']
3622       hw_arch[arch].add(modinfo_dep)
3623     endif
3624   endforeach
3625 endif
3626
3627 nm = find_program('nm')
3628 undefsym = find_program('scripts/undefsym.py')
3629 block_syms = custom_target('block.syms', output: 'block.syms',
3630                              input: [libqemuutil, block_mods],
3631                              capture: true,
3632                              command: [undefsym, nm, '@INPUT@'])
3633 qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
3634                              input: [libqemuutil, system_mods],
3635                              capture: true,
3636                              command: [undefsym, nm, '@INPUT@'])
3637
3638 authz_ss = authz_ss.apply(config_targetos, strict: false)
3639 libauthz = static_library('authz', authz_ss.sources() + genh,
3640                           dependencies: [authz_ss.dependencies()],
3641                           name_suffix: 'fa',
3642                           build_by_default: false)
3643
3644 authz = declare_dependency(link_whole: libauthz,
3645                            dependencies: qom)
3646
3647 crypto_ss = crypto_ss.apply(config_targetos, strict: false)
3648 libcrypto = static_library('crypto', crypto_ss.sources() + genh,
3649                            dependencies: [crypto_ss.dependencies()],
3650                            name_suffix: 'fa',
3651                            build_by_default: false)
3652
3653 crypto = declare_dependency(link_whole: libcrypto,
3654                             dependencies: [authz, qom])
3655
3656 io_ss = io_ss.apply(config_targetos, strict: false)
3657 libio = static_library('io', io_ss.sources() + genh,
3658                        dependencies: [io_ss.dependencies()],
3659                        link_with: libqemuutil,
3660                        name_suffix: 'fa',
3661                        build_by_default: false)
3662
3663 io = declare_dependency(link_whole: libio, dependencies: [crypto, qom])
3664
3665 libmigration = static_library('migration', sources: migration_files + genh,
3666                               name_suffix: 'fa',
3667                               build_by_default: false)
3668 migration = declare_dependency(link_with: libmigration,
3669                                dependencies: [zlib, qom, io])
3670 system_ss.add(migration)
3671
3672 block_ss = block_ss.apply(config_targetos, strict: false)
3673 libblock = static_library('block', block_ss.sources() + genh,
3674                           dependencies: block_ss.dependencies(),
3675                           link_depends: block_syms,
3676                           name_suffix: 'fa',
3677                           build_by_default: false)
3678
3679 block = declare_dependency(link_whole: [libblock],
3680                            link_args: '@block.syms',
3681                            dependencies: [crypto, io])
3682
3683 blockdev_ss = blockdev_ss.apply(config_targetos, strict: false)
3684 libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
3685                              dependencies: blockdev_ss.dependencies(),
3686                              name_suffix: 'fa',
3687                              build_by_default: false)
3688
3689 blockdev = declare_dependency(link_whole: [libblockdev],
3690                               dependencies: [block, event_loop_base])
3691
3692 qmp_ss = qmp_ss.apply(config_targetos, strict: false)
3693 libqmp = static_library('qmp', qmp_ss.sources() + genh,
3694                         dependencies: qmp_ss.dependencies(),
3695                         name_suffix: 'fa',
3696                         build_by_default: false)
3697
3698 qmp = declare_dependency(link_whole: [libqmp])
3699
3700 libchardev = static_library('chardev', chardev_ss.sources() + genh,
3701                             name_suffix: 'fa',
3702                             dependencies: chardev_ss.dependencies(),
3703                             build_by_default: false)
3704
3705 chardev = declare_dependency(link_whole: libchardev)
3706
3707 hwcore_ss = hwcore_ss.apply(config_targetos, strict: false)
3708 libhwcore = static_library('hwcore', sources: hwcore_ss.sources() + genh,
3709                            name_suffix: 'fa',
3710                            build_by_default: false)
3711 hwcore = declare_dependency(link_whole: libhwcore)
3712 common_ss.add(hwcore)
3713
3714 ###########
3715 # Targets #
3716 ###########
3717
3718 emulator_modules = []
3719 foreach m : block_mods + system_mods
3720   emulator_modules += shared_module(m.name(),
3721                 build_by_default: true,
3722                 name_prefix: '',
3723                 link_whole: m,
3724                 install: true,
3725                 install_dir: qemu_moddir)
3726 endforeach
3727 if emulator_modules.length() > 0
3728   alias_target('modules', emulator_modules)
3729 endif
3730
3731 system_ss.add(authz, blockdev, chardev, crypto, io, qmp)
3732 common_ss.add(qom, qemuutil)
3733
3734 common_ss.add_all(when: 'CONFIG_SYSTEM_ONLY', if_true: [system_ss])
3735 common_ss.add_all(when: 'CONFIG_USER_ONLY', if_true: user_ss)
3736
3737 common_all = common_ss.apply(config_all, strict: false)
3738 common_all = static_library('common',
3739                             build_by_default: false,
3740                             sources: common_all.sources() + genh,
3741                             include_directories: common_user_inc,
3742                             implicit_include_directories: false,
3743                             dependencies: common_all.dependencies(),
3744                             name_suffix: 'fa')
3745
3746 feature_to_c = find_program('scripts/feature_to_c.py')
3747
3748 if targetos == 'darwin'
3749   entitlement = find_program('scripts/entitlement.sh')
3750 endif
3751
3752 emulators = {}
3753 foreach target : target_dirs
3754   config_target = config_target_mak[target]
3755   target_name = config_target['TARGET_NAME']
3756   target_base_arch = config_target['TARGET_BASE_ARCH']
3757   arch_srcs = [config_target_h[target]]
3758   arch_deps = []
3759   c_args = ['-DNEED_CPU_H',
3760             '-DCONFIG_TARGET="@0@-config-target.h"'.format(target),
3761             '-DCONFIG_DEVICES="@0@-config-devices.h"'.format(target)]
3762   link_args = emulator_link_args
3763
3764   config_target += config_targetos
3765   target_inc = [include_directories('target' / config_target['TARGET_BASE_ARCH'])]
3766   if targetos == 'linux'
3767     target_inc += include_directories('linux-headers', is_system: true)
3768   endif
3769   if target.endswith('-softmmu')
3770     target_type='system'
3771     t = target_system_arch[target_base_arch].apply(config_target, strict: false)
3772     arch_srcs += t.sources()
3773     arch_deps += t.dependencies()
3774
3775     hw_dir = target_name == 'sparc64' ? 'sparc64' : target_base_arch
3776     hw = hw_arch[hw_dir].apply(config_target, strict: false)
3777     arch_srcs += hw.sources()
3778     arch_deps += hw.dependencies()
3779
3780     arch_srcs += config_devices_h[target]
3781     link_args += ['@block.syms', '@qemu.syms']
3782   else
3783     abi = config_target['TARGET_ABI_DIR']
3784     target_type='user'
3785     target_inc += common_user_inc
3786     if target_base_arch in target_user_arch
3787       t = target_user_arch[target_base_arch].apply(config_target, strict: false)
3788       arch_srcs += t.sources()
3789       arch_deps += t.dependencies()
3790     endif
3791     if 'CONFIG_LINUX_USER' in config_target
3792       base_dir = 'linux-user'
3793     endif
3794     if 'CONFIG_BSD_USER' in config_target
3795       base_dir = 'bsd-user'
3796       target_inc += include_directories('bsd-user/' / targetos)
3797       target_inc += include_directories('bsd-user/host/' / host_arch)
3798       dir = base_dir / abi
3799       arch_srcs += files(dir / 'signal.c', dir / 'target_arch_cpu.c')
3800     endif
3801     target_inc += include_directories(
3802       base_dir,
3803       base_dir / abi,
3804     )
3805     if 'CONFIG_LINUX_USER' in config_target
3806       dir = base_dir / abi
3807       arch_srcs += files(dir / 'signal.c', dir / 'cpu_loop.c')
3808       if config_target.has_key('TARGET_SYSTBL_ABI')
3809         arch_srcs += \
3810           syscall_nr_generators[abi].process(base_dir / abi / config_target['TARGET_SYSTBL'],
3811                                              extra_args : config_target['TARGET_SYSTBL_ABI'])
3812       endif
3813     endif
3814   endif
3815
3816   if 'TARGET_XML_FILES' in config_target
3817     gdbstub_xml = custom_target(target + '-gdbstub-xml.c',
3818                                 output: target + '-gdbstub-xml.c',
3819                                 input: files(config_target['TARGET_XML_FILES'].split()),
3820                                 command: [feature_to_c, '@INPUT@'],
3821                                 capture: true)
3822     arch_srcs += gdbstub_xml
3823   endif
3824
3825   t = target_arch[target_base_arch].apply(config_target, strict: false)
3826   arch_srcs += t.sources()
3827   arch_deps += t.dependencies()
3828
3829   target_common = common_ss.apply(config_target, strict: false)
3830   objects = common_all.extract_objects(target_common.sources())
3831   deps = target_common.dependencies()
3832
3833   target_specific = specific_ss.apply(config_target, strict: false)
3834   arch_srcs += target_specific.sources()
3835   arch_deps += target_specific.dependencies()
3836
3837   lib = static_library('qemu-' + target,
3838                  sources: arch_srcs + genh,
3839                  dependencies: arch_deps,
3840                  objects: objects,
3841                  include_directories: target_inc,
3842                  c_args: c_args,
3843                  build_by_default: false,
3844                  name_suffix: 'fa')
3845
3846   if target.endswith('-softmmu')
3847     execs = [{
3848       'name': 'qemu-system-' + target_name,
3849       'win_subsystem': 'console',
3850       'sources': files('system/main.c'),
3851       'dependencies': []
3852     }]
3853     if targetos == 'windows' and (sdl.found() or gtk.found())
3854       execs += [{
3855         'name': 'qemu-system-' + target_name + 'w',
3856         'win_subsystem': 'windows',
3857         'sources': files('system/main.c'),
3858         'dependencies': []
3859       }]
3860     endif
3861     if get_option('fuzzing')
3862       specific_fuzz = specific_fuzz_ss.apply(config_target, strict: false)
3863       execs += [{
3864         'name': 'qemu-fuzz-' + target_name,
3865         'win_subsystem': 'console',
3866         'sources': specific_fuzz.sources(),
3867         'dependencies': specific_fuzz.dependencies(),
3868       }]
3869     endif
3870   else
3871     execs = [{
3872       'name': 'qemu-' + target_name,
3873       'win_subsystem': 'console',
3874       'sources': [],
3875       'dependencies': []
3876     }]
3877   endif
3878   foreach exe: execs
3879     exe_name = exe['name']
3880     if targetos == 'darwin'
3881       exe_name += '-unsigned'
3882     endif
3883
3884     emulator = executable(exe_name, exe['sources'],
3885                install: true,
3886                c_args: c_args,
3887                dependencies: arch_deps + deps + exe['dependencies'],
3888                objects: lib.extract_all_objects(recursive: true),
3889                link_depends: [block_syms, qemu_syms] + exe.get('link_depends', []),
3890                link_args: link_args,
3891                win_subsystem: exe['win_subsystem'])
3892
3893     if targetos == 'darwin'
3894       icon = 'pc-bios/qemu.rsrc'
3895       build_input = [emulator, files(icon)]
3896       install_input = [
3897         get_option('bindir') / exe_name,
3898         meson.current_source_dir() / icon
3899       ]
3900       if 'CONFIG_HVF' in config_target
3901         entitlements = 'accel/hvf/entitlements.plist'
3902         build_input += files(entitlements)
3903         install_input += meson.current_source_dir() / entitlements
3904       endif
3905
3906       emulators += {exe['name'] : custom_target(exe['name'],
3907                    input: build_input,
3908                    output: exe['name'],
3909                    command: [entitlement, '@OUTPUT@', '@INPUT@'])
3910       }
3911
3912       meson.add_install_script(entitlement, '--install',
3913                                get_option('bindir') / exe['name'],
3914                                install_input)
3915     else
3916       emulators += {exe['name']: emulator}
3917     endif
3918
3919     if stap.found()
3920       foreach stp: [
3921         {'ext': '.stp-build', 'fmt': 'stap', 'bin': meson.current_build_dir() / exe['name'], 'install': false},
3922         {'ext': '.stp', 'fmt': 'stap', 'bin': get_option('prefix') / get_option('bindir') / exe['name'], 'install': true},
3923         {'ext': '-simpletrace.stp', 'fmt': 'simpletrace-stap', 'bin': '', 'install': true},
3924         {'ext': '-log.stp', 'fmt': 'log-stap', 'bin': '', 'install': true},
3925       ]
3926         custom_target(exe['name'] + stp['ext'],
3927                       input: trace_events_all,
3928                       output: exe['name'] + stp['ext'],
3929                       install: stp['install'],
3930                       install_dir: get_option('datadir') / 'systemtap/tapset',
3931                       command: [
3932                         tracetool, '--group=all', '--format=' + stp['fmt'],
3933                         '--binary=' + stp['bin'],
3934                         '--target-name=' + target_name,
3935                         '--target-type=' + target_type,
3936                         '--probe-prefix=qemu.' + target_type + '.' + target_name,
3937                         '@INPUT@', '@OUTPUT@'
3938                       ],
3939                       depend_files: tracetool_depends)
3940       endforeach
3941     endif
3942   endforeach
3943 endforeach
3944
3945 # Other build targets
3946
3947 if get_option('plugins')
3948   install_headers('include/qemu/qemu-plugin.h')
3949   if targetos == 'windows'
3950     # On windows, we want to deliver the qemu_plugin_api.lib file in the qemu installer,
3951     # so that plugin authors can compile against it.
3952     install_data(win32_qemu_plugin_api_lib, install_dir: 'lib')
3953   endif
3954 endif
3955
3956 subdir('qga')
3957
3958 # Don't build qemu-keymap if xkbcommon is not explicitly enabled
3959 # when we don't build tools or system
3960 if xkbcommon.found()
3961   # used for the update-keymaps target, so include rules even if !have_tools
3962   qemu_keymap = executable('qemu-keymap', files('qemu-keymap.c', 'ui/input-keymap.c') + genh,
3963                            dependencies: [qemuutil, xkbcommon], install: have_tools)
3964 endif
3965
3966 if have_tools
3967   qemu_img = executable('qemu-img', [files('qemu-img.c'), hxdep],
3968              dependencies: [authz, block, crypto, io, qom, qemuutil], install: true)
3969   qemu_io = executable('qemu-io', files('qemu-io.c'),
3970              dependencies: [block, qemuutil], install: true)
3971   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
3972                dependencies: [blockdev, qemuutil, gnutls, selinux],
3973                install: true)
3974
3975   subdir('storage-daemon')
3976   subdir('contrib/rdmacm-mux')
3977   subdir('contrib/elf2dmp')
3978
3979   executable('qemu-edid', files('qemu-edid.c', 'hw/display/edid-generate.c'),
3980              dependencies: qemuutil,
3981              install: true)
3982
3983   if have_vhost_user
3984     subdir('contrib/vhost-user-blk')
3985     subdir('contrib/vhost-user-gpu')
3986     subdir('contrib/vhost-user-input')
3987     subdir('contrib/vhost-user-scsi')
3988   endif
3989
3990   if targetos == 'linux'
3991     executable('qemu-bridge-helper', files('qemu-bridge-helper.c'),
3992                dependencies: [qemuutil, libcap_ng],
3993                install: true,
3994                install_dir: get_option('libexecdir'))
3995
3996     executable('qemu-pr-helper', files('scsi/qemu-pr-helper.c', 'scsi/utils.c'),
3997                dependencies: [authz, crypto, io, qom, qemuutil,
3998                               libcap_ng, mpathpersist],
3999                install: true)
4000   endif
4001
4002   if have_ivshmem
4003     subdir('contrib/ivshmem-client')
4004     subdir('contrib/ivshmem-server')
4005   endif
4006 endif
4007
4008 subdir('scripts')
4009 subdir('tools')
4010 subdir('pc-bios')
4011 subdir('docs')
4012 subdir('tests')
4013 if gtk.found()
4014   subdir('po')
4015 endif
4016
4017 if host_machine.system() == 'windows'
4018   nsis_cmd = [
4019     find_program('scripts/nsis.py'),
4020     '@OUTPUT@',
4021     get_option('prefix'),
4022     meson.current_source_dir(),
4023     glib_pc.get_variable('bindir'),
4024     host_machine.cpu(),
4025     '--',
4026     '-DDISPLAYVERSION=' + meson.project_version(),
4027   ]
4028   if build_docs
4029     nsis_cmd += '-DCONFIG_DOCUMENTATION=y'
4030   endif
4031   if gtk.found()
4032     nsis_cmd += '-DCONFIG_GTK=y'
4033   endif
4034
4035   nsis = custom_target('nsis',
4036                        output: 'qemu-setup-' + meson.project_version() + '.exe',
4037                        input: files('qemu.nsi'),
4038                        build_always_stale: true,
4039                        command: nsis_cmd + ['@INPUT@'])
4040   alias_target('installer', nsis)
4041 endif
4042
4043 #########################
4044 # Configuration summary #
4045 #########################
4046
4047 # Build environment
4048 summary_info = {}
4049 summary_info += {'Build directory':   meson.current_build_dir()}
4050 summary_info += {'Source path':       meson.current_source_dir()}
4051 summary_info += {'Download dependencies': get_option('wrap_mode') != 'nodownload'}
4052 summary(summary_info, bool_yn: true, section: 'Build environment')
4053
4054 # Directories
4055 summary_info += {'Install prefix':    get_option('prefix')}
4056 summary_info += {'BIOS directory':    qemu_datadir}
4057 pathsep = targetos == 'windows' ? ';' : ':'
4058 summary_info += {'firmware path':     pathsep.join(get_option('qemu_firmwarepath'))}
4059 summary_info += {'binary directory':  get_option('prefix') / get_option('bindir')}
4060 summary_info += {'library directory': get_option('prefix') / get_option('libdir')}
4061 summary_info += {'module directory':  qemu_moddir}
4062 summary_info += {'libexec directory': get_option('prefix') / get_option('libexecdir')}
4063 summary_info += {'include directory': get_option('prefix') / get_option('includedir')}
4064 summary_info += {'config directory':  get_option('prefix') / get_option('sysconfdir')}
4065 if targetos != 'windows'
4066   summary_info += {'local state directory': get_option('prefix') / get_option('localstatedir')}
4067   summary_info += {'Manual directory':      get_option('prefix') / get_option('mandir')}
4068 else
4069   summary_info += {'local state directory': 'queried at runtime'}
4070 endif
4071 summary_info += {'Doc directory':     get_option('prefix') / get_option('docdir')}
4072 summary(summary_info, bool_yn: true, section: 'Directories')
4073
4074 # Host binaries
4075 summary_info = {}
4076 summary_info += {'python':            '@0@ (version: @1@)'.format(python.full_path(), python.language_version())}
4077 summary_info += {'sphinx-build':      sphinx_build}
4078
4079 # FIXME: the [binaries] section of machine files, which can be probed
4080 # with find_program(), would be great for passing gdb and genisoimage
4081 # paths from configure to Meson.  However, there seems to be no way to
4082 # hide a program (for example if gdb is too old).
4083 if config_host.has_key('GDB')
4084   summary_info += {'gdb':             config_host['GDB']}
4085 endif
4086 summary_info += {'iasl':              iasl}
4087 summary_info += {'genisoimage':       config_host['GENISOIMAGE']}
4088 if targetos == 'windows' and have_ga
4089   summary_info += {'wixl':            wixl}
4090 endif
4091 if slirp.found() and have_system
4092   summary_info += {'smbd':            have_slirp_smbd ? smbd_path : false}
4093 endif
4094 summary(summary_info, bool_yn: true, section: 'Host binaries')
4095
4096 # Configurable features
4097 summary_info = {}
4098 summary_info += {'Documentation':     build_docs}
4099 summary_info += {'system-mode emulation': have_system}
4100 summary_info += {'user-mode emulation': have_user}
4101 summary_info += {'block layer':       have_block}
4102 summary_info += {'Install blobs':     get_option('install_blobs')}
4103 summary_info += {'module support':    enable_modules}
4104 if enable_modules
4105   summary_info += {'alternative module path': get_option('module_upgrades')}
4106 endif
4107 summary_info += {'fuzzing support':   get_option('fuzzing')}
4108 if have_system
4109   summary_info += {'Audio drivers':     ' '.join(audio_drivers_selected)}
4110 endif
4111 summary_info += {'Trace backends':    ','.join(get_option('trace_backends'))}
4112 if 'simple' in get_option('trace_backends')
4113   summary_info += {'Trace output file': get_option('trace_file') + '-<pid>'}
4114 endif
4115 summary_info += {'D-Bus display':     dbus_display}
4116 summary_info += {'QOM debugging':     get_option('qom_cast_debug')}
4117 summary_info += {'Relocatable install': get_option('relocatable')}
4118 summary_info += {'vhost-kernel support': have_vhost_kernel}
4119 summary_info += {'vhost-net support': have_vhost_net}
4120 summary_info += {'vhost-user support': have_vhost_user}
4121 summary_info += {'vhost-user-crypto support': have_vhost_user_crypto}
4122 summary_info += {'vhost-user-blk server support': have_vhost_user_blk_server}
4123 summary_info += {'vhost-vdpa support': have_vhost_vdpa}
4124 summary_info += {'build guest agent': have_ga}
4125 summary(summary_info, bool_yn: true, section: 'Configurable features')
4126
4127 # Compilation information
4128 summary_info = {}
4129 summary_info += {'host CPU':          cpu}
4130 summary_info += {'host endianness':   build_machine.endian()}
4131 summary_info += {'C compiler':        ' '.join(meson.get_compiler('c').cmd_array())}
4132 summary_info += {'Host C compiler':   ' '.join(meson.get_compiler('c', native: true).cmd_array())}
4133 if 'cpp' in all_languages
4134   summary_info += {'C++ compiler':    ' '.join(meson.get_compiler('cpp').cmd_array())}
4135 else
4136   summary_info += {'C++ compiler':      false}
4137 endif
4138 if 'objc' in all_languages
4139   summary_info += {'Objective-C compiler': ' '.join(meson.get_compiler('objc').cmd_array())}
4140 else
4141   summary_info += {'Objective-C compiler': false}
4142 endif
4143 option_cflags = (get_option('debug') ? ['-g'] : [])
4144 if get_option('optimization') != 'plain'
4145   option_cflags += ['-O' + get_option('optimization')]
4146 endif
4147 summary_info += {'CFLAGS':            ' '.join(get_option('c_args') + option_cflags)}
4148 if 'cpp' in all_languages
4149   summary_info += {'CXXFLAGS':        ' '.join(get_option('cpp_args') + option_cflags)}
4150 endif
4151 if 'objc' in all_languages
4152   summary_info += {'OBJCFLAGS':       ' '.join(get_option('objc_args') + option_cflags)}
4153 endif
4154 link_args = get_option('c_link_args')
4155 if link_args.length() > 0
4156   summary_info += {'LDFLAGS':         ' '.join(link_args)}
4157 endif
4158 summary_info += {'QEMU_CFLAGS':       ' '.join(qemu_common_flags + qemu_cflags)}
4159 if 'cpp' in all_languages
4160   summary_info += {'QEMU_CXXFLAGS':     ' '.join(qemu_common_flags + qemu_cxxflags)}
4161 endif
4162 if 'objc' in all_languages
4163   summary_info += {'QEMU_OBJCFLAGS':    ' '.join(qemu_common_flags)}
4164 endif
4165 summary_info += {'QEMU_LDFLAGS':      ' '.join(qemu_ldflags)}
4166 summary_info += {'link-time optimization (LTO)': get_option('b_lto')}
4167 summary_info += {'PIE':               get_option('b_pie')}
4168 summary_info += {'static build':      get_option('prefer_static')}
4169 summary_info += {'malloc trim support': has_malloc_trim}
4170 summary_info += {'membarrier':        have_membarrier}
4171 summary_info += {'debug graph lock':  get_option('debug_graph_lock')}
4172 summary_info += {'debug stack usage': get_option('debug_stack_usage')}
4173 summary_info += {'mutex debugging':   get_option('debug_mutex')}
4174 summary_info += {'memory allocator':  get_option('malloc')}
4175 summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')}
4176 summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')}
4177 summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')}
4178 summary_info += {'gcov':              get_option('b_coverage')}
4179 summary_info += {'thread sanitizer':  get_option('tsan')}
4180 summary_info += {'CFI support':       get_option('cfi')}
4181 if get_option('cfi')
4182   summary_info += {'CFI debug support': get_option('cfi_debug')}
4183 endif
4184 summary_info += {'strip binaries':    get_option('strip')}
4185 summary_info += {'sparse':            sparse}
4186 summary_info += {'mingw32 support':   targetos == 'windows'}
4187 summary(summary_info, bool_yn: true, section: 'Compilation')
4188
4189 # snarf the cross-compilation information for tests
4190 summary_info = {}
4191 have_cross = false
4192 foreach target: target_dirs
4193   tcg_mak = meson.current_build_dir() / 'tests/tcg' / target / 'config-target.mak'
4194   if fs.exists(tcg_mak)
4195     config_cross_tcg = keyval.load(tcg_mak)
4196     if 'CC' in config_cross_tcg
4197       summary_info += {config_cross_tcg['TARGET_NAME']: config_cross_tcg['CC']}
4198       have_cross = true
4199     endif
4200   endif
4201 endforeach
4202 if have_cross
4203   summary(summary_info, bool_yn: true, section: 'Cross compilers')
4204 endif
4205
4206 # Targets and accelerators
4207 summary_info = {}
4208 if have_system
4209   summary_info += {'KVM support':       config_all.has_key('CONFIG_KVM')}
4210   summary_info += {'HVF support':       config_all.has_key('CONFIG_HVF')}
4211   summary_info += {'WHPX support':      config_all.has_key('CONFIG_WHPX')}
4212   summary_info += {'NVMM support':      config_all.has_key('CONFIG_NVMM')}
4213   summary_info += {'Xen support':       xen.found()}
4214   if xen.found()
4215     summary_info += {'xen ctrl version':  xen.version()}
4216   endif
4217   summary_info += {'Xen emulation':     config_all.has_key('CONFIG_XEN_EMU')}
4218 endif
4219 summary_info += {'TCG support':       config_all.has_key('CONFIG_TCG')}
4220 if config_all.has_key('CONFIG_TCG')
4221   if get_option('tcg_interpreter')
4222     summary_info += {'TCG backend':   'TCI (TCG with bytecode interpreter, slow)'}
4223   else
4224     summary_info += {'TCG backend':   'native (@0@)'.format(cpu)}
4225   endif
4226   summary_info += {'TCG plugins':       get_option('plugins')}
4227   summary_info += {'TCG debug enabled': get_option('debug_tcg')}
4228 endif
4229 summary_info += {'target list':       ' '.join(target_dirs)}
4230 if have_system
4231   summary_info += {'default devices':   get_option('default_devices')}
4232   summary_info += {'out of process emulation': multiprocess_allowed}
4233   summary_info += {'vfio-user server': vfio_user_server_allowed}
4234 endif
4235 summary(summary_info, bool_yn: true, section: 'Targets and accelerators')
4236
4237 # Block layer
4238 summary_info = {}
4239 summary_info += {'coroutine backend': coroutine_backend}
4240 summary_info += {'coroutine pool':    have_coroutine_pool}
4241 if have_block
4242   summary_info += {'Block whitelist (rw)': get_option('block_drv_rw_whitelist')}
4243   summary_info += {'Block whitelist (ro)': get_option('block_drv_ro_whitelist')}
4244   summary_info += {'Use block whitelist in tools': get_option('block_drv_whitelist_in_tools')}
4245   summary_info += {'VirtFS (9P) support':    have_virtfs}
4246   summary_info += {'VirtFS (9P) Proxy Helper support (deprecated)': have_virtfs_proxy_helper}
4247   summary_info += {'Live block migration': config_host_data.get('CONFIG_LIVE_BLOCK_MIGRATION')}
4248   summary_info += {'replication support': config_host_data.get('CONFIG_REPLICATION')}
4249   summary_info += {'bochs support':     get_option('bochs').allowed()}
4250   summary_info += {'cloop support':     get_option('cloop').allowed()}
4251   summary_info += {'dmg support':       get_option('dmg').allowed()}
4252   summary_info += {'qcow v1 support':   get_option('qcow1').allowed()}
4253   summary_info += {'vdi support':       get_option('vdi').allowed()}
4254   summary_info += {'vhdx support':      get_option('vhdx').allowed()}
4255   summary_info += {'vmdk support':      get_option('vmdk').allowed()}
4256   summary_info += {'vpc support':       get_option('vpc').allowed()}
4257   summary_info += {'vvfat support':     get_option('vvfat').allowed()}
4258   summary_info += {'qed support':       get_option('qed').allowed()}
4259   summary_info += {'parallels support': get_option('parallels').allowed()}
4260   summary_info += {'FUSE exports':      fuse}
4261   summary_info += {'VDUSE block exports': have_vduse_blk_export}
4262 endif
4263 summary(summary_info, bool_yn: true, section: 'Block layer support')
4264
4265 # Crypto
4266 summary_info = {}
4267 summary_info += {'TLS priority':      get_option('tls_priority')}
4268 summary_info += {'GNUTLS support':    gnutls}
4269 if gnutls.found()
4270   summary_info += {'  GNUTLS crypto':   gnutls_crypto.found()}
4271 endif
4272 summary_info += {'libgcrypt':         gcrypt}
4273 summary_info += {'nettle':            nettle}
4274 if nettle.found()
4275    summary_info += {'  XTS':             xts != 'private'}
4276 endif
4277 summary_info += {'AF_ALG support':    have_afalg}
4278 summary_info += {'rng-none':          get_option('rng_none')}
4279 summary_info += {'Linux keyring':     have_keyring}
4280 summary_info += {'Linux keyutils':    keyutils}
4281 summary(summary_info, bool_yn: true, section: 'Crypto')
4282
4283 # UI
4284 summary_info = {}
4285 if targetos == 'darwin'
4286   summary_info += {'Cocoa support':           cocoa}
4287 endif
4288 summary_info += {'SDL support':       sdl}
4289 summary_info += {'SDL image support': sdl_image}
4290 summary_info += {'GTK support':       gtk}
4291 summary_info += {'pixman':            pixman}
4292 summary_info += {'VTE support':       vte}
4293 summary_info += {'PNG support':       png}
4294 summary_info += {'VNC support':       vnc}
4295 if vnc.found()
4296   summary_info += {'VNC SASL support':  sasl}
4297   summary_info += {'VNC JPEG support':  jpeg}
4298 endif
4299 summary_info += {'spice protocol support': spice_protocol}
4300 if spice_protocol.found()
4301   summary_info += {'  spice server support': spice}
4302 endif
4303 summary_info += {'curses support':    curses}
4304 summary_info += {'brlapi support':    brlapi}
4305 summary(summary_info, bool_yn: true, section: 'User interface')
4306
4307 # Audio backends
4308 summary_info = {}
4309 if targetos not in ['darwin', 'haiku', 'windows']
4310   summary_info += {'OSS support':     oss}
4311   summary_info += {'sndio support':   sndio}
4312 elif targetos == 'darwin'
4313   summary_info += {'CoreAudio support': coreaudio}
4314 elif targetos == 'windows'
4315   summary_info += {'DirectSound support': dsound}
4316 endif
4317 if targetos == 'linux'
4318   summary_info += {'ALSA support':    alsa}
4319   summary_info += {'PulseAudio support': pulse}
4320 endif
4321 summary_info += {'PipeWire support':  pipewire}
4322 summary_info += {'JACK support':      jack}
4323 summary(summary_info, bool_yn: true, section: 'Audio backends')
4324
4325 # Network backends
4326 summary_info = {}
4327 if targetos == 'darwin'
4328   summary_info += {'vmnet.framework support': vmnet}
4329 endif
4330 summary_info += {'AF_XDP support':    libxdp}
4331 summary_info += {'slirp support':     slirp}
4332 summary_info += {'vde support':       vde}
4333 summary_info += {'netmap support':    have_netmap}
4334 summary_info += {'l2tpv3 support':    have_l2tpv3}
4335 summary(summary_info, bool_yn: true, section: 'Network backends')
4336
4337 # Libraries
4338 summary_info = {}
4339 summary_info += {'libtasn1':          tasn1}
4340 summary_info += {'PAM':               pam}
4341 summary_info += {'iconv support':     iconv}
4342 summary_info += {'virgl support':     virgl}
4343 summary_info += {'rutabaga support':  rutabaga}
4344 summary_info += {'blkio support':     blkio}
4345 summary_info += {'curl support':      curl}
4346 summary_info += {'Multipath support': mpathpersist}
4347 summary_info += {'Linux AIO support': libaio}
4348 summary_info += {'Linux io_uring support': linux_io_uring}
4349 summary_info += {'ATTR/XATTR support': libattr}
4350 summary_info += {'RDMA support':      rdma}
4351 summary_info += {'PVRDMA support':    have_pvrdma}
4352 summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
4353 summary_info += {'libcap-ng support': libcap_ng}
4354 summary_info += {'bpf support':       libbpf}
4355 summary_info += {'rbd support':       rbd}
4356 summary_info += {'smartcard support': cacard}
4357 summary_info += {'U2F support':       u2f}
4358 summary_info += {'libusb':            libusb}
4359 summary_info += {'usb net redir':     usbredir}
4360 summary_info += {'OpenGL support (epoxy)': opengl}
4361 summary_info += {'GBM':               gbm}
4362 summary_info += {'libiscsi support':  libiscsi}
4363 summary_info += {'libnfs support':    libnfs}
4364 if targetos == 'windows'
4365   if have_ga
4366     summary_info += {'QGA VSS support':   have_qga_vss}
4367   endif
4368 endif
4369 summary_info += {'seccomp support':   seccomp}
4370 summary_info += {'GlusterFS support': glusterfs}
4371 summary_info += {'hv-balloon support': hv_balloon}
4372 summary_info += {'TPM support':       have_tpm}
4373 summary_info += {'libssh support':    libssh}
4374 summary_info += {'lzo support':       lzo}
4375 summary_info += {'snappy support':    snappy}
4376 summary_info += {'bzip2 support':     libbzip2}
4377 summary_info += {'lzfse support':     liblzfse}
4378 summary_info += {'zstd support':      zstd}
4379 summary_info += {'NUMA host support': numa}
4380 summary_info += {'capstone':          capstone}
4381 summary_info += {'libpmem support':   libpmem}
4382 summary_info += {'libdaxctl support': libdaxctl}
4383 summary_info += {'libudev':           libudev}
4384 # Dummy dependency, keep .found()
4385 summary_info += {'FUSE lseek':        fuse_lseek.found()}
4386 summary_info += {'selinux':           selinux}
4387 summary_info += {'libdw':             libdw}
4388 summary(summary_info, bool_yn: true, section: 'Dependencies')
4389
4390 if host_arch == 'unknown'
4391   message()
4392   warning('UNSUPPORTED HOST CPU')
4393   message()
4394   message('Support for CPU host architecture ' + cpu + ' is not currently')
4395   message('maintained. The QEMU project does not guarantee that QEMU will')
4396   message('compile or work on this host CPU. You can help by volunteering')
4397   message('to maintain it and providing a build host for our continuous')
4398   message('integration setup.')
4399   if get_option('tcg').allowed() and target_dirs.length() > 0
4400     message()
4401     message('configure has succeeded and you can continue to build, but')
4402     message('QEMU will use a slow interpreter to emulate the target CPU.')
4403   endif
4404 endif
4405
4406 if not supported_oses.contains(targetos)
4407   message()
4408   warning('UNSUPPORTED HOST OS')
4409   message()
4410   message('Support for host OS ' + targetos + 'is not currently maintained.')
4411   message('configure has succeeded and you can continue to build, but')
4412   message('the QEMU project does not guarantee that QEMU will compile or')
4413   message('work on this operating system. You can help by volunteering')
4414   message('to maintain it and providing a build host for our continuous')
4415   message('integration setup. This will ensure that future versions of QEMU')
4416   message('will keep working on ' + targetos + '.')
4417 endif
4418
4419 if host_arch == 'unknown' or not supported_oses.contains(targetos)
4420   message()
4421   message('If you want to help supporting QEMU on this platform, please')
4422   message('contact the developers at qemu-devel@nongnu.org.')
4423 endif
4424
4425 actually_reloc = get_option('relocatable')
4426 # check if get_relocated_path() is actually able to relocate paths
4427 if get_option('relocatable') and \
4428   not (get_option('prefix') / get_option('bindir')).startswith(get_option('prefix') / '')
4429   message()
4430   warning('bindir not included within prefix, the installation will not be relocatable.')
4431   actually_reloc = false
4432 endif
4433 if not actually_reloc and (targetos == 'windows' or get_option('relocatable'))
4434   if targetos == 'windows'
4435     message()
4436     warning('Windows installs should usually be relocatable.')
4437   endif
4438   message()
4439   message('QEMU will have to be installed under ' + get_option('prefix') + '.')
4440   message('Use --disable-relocatable to remove this warning.')
4441 endif