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