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