xref: /openbmc/qemu/configure (revision 646b5378)
1#!/bin/sh
2#
3# qemu configure script (c) 2003 Fabrice Bellard
4#
5
6# Unset some variables known to interfere with behavior of common tools,
7# just as autoconf does.  Unlike autoconf, we assume that unset exists.
8unset CLICOLOR_FORCE GREP_OPTIONS BASH_ENV ENV MAIL MAILPATH CDPATH
9
10# Don't allow CCACHE, if present, to use cached results of compile tests!
11export CCACHE_RECACHE=yes
12
13# make source path absolute
14source_path=$(cd "$(dirname -- "$0")"; pwd)
15
16if test "$PWD" = "$source_path"
17then
18    echo "Using './build' as the directory for build output"
19
20    MARKER=build/auto-created-by-configure
21
22    if test -e build
23    then
24        if test -f $MARKER
25        then
26           rm -rf build
27        else
28            echo "ERROR: ./build dir already exists and was not previously created by configure"
29            exit 1
30        fi
31    fi
32
33    if ! mkdir build || ! touch $MARKER
34    then
35        echo "ERROR: Could not create ./build directory. Check the permissions on"
36        echo "your source directory, or try doing an out-of-tree build."
37        exit 1
38    fi
39
40    cat > GNUmakefile <<'EOF'
41# This file is auto-generated by configure to support in-source tree
42# 'make' command invocation
43
44build:
45	@echo 'changing dir to build for $(MAKE) "$(MAKECMDGOALS)"...'
46	@$(MAKE) -C build -f Makefile $(MAKECMDGOALS)
47	@if test "$(MAKECMDGOALS)" = "distclean" && \
48	    test -e build/auto-created-by-configure ; \
49	then \
50	    rm -rf build GNUmakefile ; \
51	fi
52%: build
53	@
54.PHONY: build
55GNUmakefile: ;
56
57EOF
58    cd build
59    exec "$source_path/configure" "$@"
60fi
61
62# Temporary directory used for files created while
63# configure runs. Since it is in the build directory
64# we can safely blow away any previous version of it
65# (and we need not jump through hoops to try to delete
66# it when configure exits.)
67TMPDIR1="config-temp"
68rm -rf "${TMPDIR1}"
69if ! mkdir -p "${TMPDIR1}"; then
70    echo "ERROR: failed to create temporary directory"
71    exit 1
72fi
73
74TMPB="qemu-conf"
75TMPC="${TMPDIR1}/${TMPB}.c"
76TMPO="${TMPDIR1}/${TMPB}.o"
77TMPE="${TMPDIR1}/${TMPB}.exe"
78
79rm -f config.log
80
81# Print a helpful header at the top of config.log
82echo "# QEMU configure log $(date)" >> config.log
83printf "# Configured with:" >> config.log
84# repeat the invocation to log and stdout for CI
85invoke=$(printf " '%s'" "$0" "$@")
86test -n "$GITLAB_CI" && echo "configuring with: $invoke"
87{ echo "$invoke"; echo; echo "#"; } >> config.log
88
89quote_sh() {
90    printf "%s" "$1" | sed "s,','\\\\'',g; s,.*,'&',"
91}
92
93error_exit() {
94    (echo
95    echo "ERROR: $1"
96    while test -n "$2"; do
97        echo "       $2"
98        shift
99    done
100    echo) >&2
101    exit 1
102}
103
104do_compiler() {
105  # Run the compiler, capturing its output to the log. First argument
106  # is compiler binary to execute.
107  compiler="$1"
108  shift
109  if test -n "$BASH_VERSION"; then eval '
110      echo >>config.log "
111funcs: ${FUNCNAME[*]}
112lines: ${BASH_LINENO[*]}"
113  '; fi
114  echo $compiler "$@" >> config.log
115  $compiler "$@" >> config.log 2>&1 || return $?
116}
117
118do_cc() {
119    do_compiler "$cc" $CPU_CFLAGS "$@"
120}
121
122compile_object() {
123  local_cflags="$1"
124  do_cc $CFLAGS $EXTRA_CFLAGS $local_cflags -c -o $TMPO $TMPC
125}
126
127compile_prog() {
128  local_cflags="$1"
129  local_ldflags="$2"
130  do_cc $CFLAGS $EXTRA_CFLAGS $local_cflags -o $TMPE $TMPC \
131      $LDFLAGS $EXTRA_LDFLAGS $local_ldflags
132}
133
134# symbolically link $1 to $2.  Portable version of "ln -sf".
135symlink() {
136  rm -rf "$2"
137  mkdir -p "$(dirname "$2")"
138  ln -s "$1" "$2"
139}
140
141# check whether a command is available to this shell (may be either an
142# executable or a builtin)
143has() {
144    type "$1" >/dev/null 2>&1
145}
146
147version_ge () {
148    local_ver1=$(expr "$1" : '\([0-9.]*\)' | tr . ' ')
149    local_ver2=$(echo "$2" | tr . ' ')
150    while true; do
151        set x $local_ver1
152        local_first=${2-0}
153        # 'shift 2' if $2 is set, or 'shift' if $2 is not set
154        shift ${2:+2}
155        local_ver1=$*
156        set x $local_ver2
157        # the second argument finished, the first must be greater or equal
158        test $# = 1 && return 0
159        test $local_first -lt $2 && return 1
160        test $local_first -gt $2 && return 0
161        shift ${2:+2}
162        local_ver2=$*
163    done
164}
165
166if printf %s\\n "$source_path" "$PWD" | grep -q "[[:space:]:]";
167then
168  error_exit "main directory cannot contain spaces nor colons"
169fi
170
171# parse CC options first; some compiler tests are used to establish
172# some defaults, based on the host environment
173
174# default parameters
175container_engine="auto"
176cpu=""
177cross_compile="no"
178cross_prefix=""
179host_cc="cc"
180EXTRA_CFLAGS=""
181EXTRA_CXXFLAGS=""
182EXTRA_OBJCFLAGS=""
183EXTRA_LDFLAGS=""
184
185# Default value for a variable defining feature "foo".
186#  * foo="no"  feature will only be used if --enable-foo arg is given
187#  * foo=""    feature will be searched for, and if found, will be used
188#              unless --disable-foo is given
189#  * foo="yes" this value will only be set by --enable-foo flag.
190#              feature will searched for,
191#              if not found, configure exits with error
192#
193# Always add --enable-foo and --disable-foo command line args.
194# Distributions want to ensure that several features are compiled in, and it
195# is impossible without a --enable-foo that exits if a feature is not found.
196default_feature=""
197
198for opt do
199  optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
200  case "$opt" in
201  --cross-prefix=*) cross_prefix="$optarg"
202                    cross_compile="yes"
203  ;;
204  --cc=*) CC="$optarg"
205  ;;
206  --cxx=*) CXX="$optarg"
207  ;;
208  --objcc=*) objcc="$optarg"
209  ;;
210  --rustc=*) RUSTC="$optarg"
211  ;;
212  --cpu=*) cpu="$optarg"
213  ;;
214  --extra-cflags=*)
215    EXTRA_CFLAGS="$EXTRA_CFLAGS $optarg"
216    EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $optarg"
217    EXTRA_OBJCFLAGS="$EXTRA_OBJCFLAGS $optarg"
218    ;;
219  --extra-cxxflags=*) EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $optarg"
220  ;;
221  --extra-objcflags=*) EXTRA_OBJCFLAGS="$EXTRA_OBJCFLAGS $optarg"
222  ;;
223  --extra-ldflags=*) EXTRA_LDFLAGS="$EXTRA_LDFLAGS $optarg"
224  ;;
225  --cross-cc-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --cross-cc-FOO option"
226  ;;
227  --cross-cc-cflags-*) cc_arch=${opt#--cross-cc-cflags-}; cc_arch=${cc_arch%%=*}
228                      eval "cross_cc_cflags_${cc_arch}=\$optarg"
229  ;;
230  --cross-cc-*) cc_arch=${opt#--cross-cc-}; cc_arch=${cc_arch%%=*}
231                eval "cross_cc_${cc_arch}=\$optarg"
232  ;;
233  --cross-prefix-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --cross-prefix-FOO option"
234  ;;
235  --cross-prefix-*) cc_arch=${opt#--cross-prefix-}; cc_arch=${cc_arch%%=*}
236                    eval "cross_prefix_${cc_arch}=\$optarg"
237  ;;
238  --without-default-features) default_feature="no"
239  ;;
240  esac
241done
242
243default_cflags='-O2 -g'
244git_submodules_action="update"
245docs="auto"
246EXESUF=""
247system="yes"
248linux_user=""
249bsd_user=""
250plugins="$default_feature"
251subdirs=""
252ninja=""
253python=
254download="enabled"
255skip_meson=no
256use_containers="yes"
257rust="disabled"
258rust_target_triple=""
259gdb_bin=$(command -v "gdb-multiarch" || command -v "gdb")
260gdb_arches=""
261
262# Don't accept a target_list environment variable.
263unset target_list
264unset target_list_exclude
265
266# The following Meson options are handled manually (still they
267# are included in the automatically generated help message)
268# because they automatically enable/disable other options
269tcg="auto"
270cfi="false"
271
272# Meson has PIE as a boolean rather than enabled/disabled/auto,
273# and we also need to check for -static-pie before Meson runs
274# which requires knowing whether --static is enabled.
275pie=""
276static="no"
277
278# Preferred compiler:
279#  ${CC} (if set)
280#  ${cross_prefix}gcc (if cross-prefix specified)
281#  system compiler
282if test -z "${CC}${cross_prefix}"; then
283  cc="cc"
284else
285  cc="${CC-${cross_prefix}gcc}"
286fi
287
288if test -z "${CXX}${cross_prefix}"; then
289  cxx="c++"
290else
291  cxx="${CXX-${cross_prefix}g++}"
292fi
293
294# Preferred ObjC compiler:
295# $objcc (if set, i.e. via --objcc option)
296# ${cross_prefix}clang (if cross-prefix specified)
297# clang (if available)
298# $cc
299if test -z "${objcc}${cross_prefix}"; then
300  if has clang; then
301    objcc=clang
302  else
303    objcc="$cc"
304  fi
305else
306  objcc="${objcc-${cross_prefix}clang}"
307fi
308
309ar="${AR-${cross_prefix}ar}"
310as="${AS-${cross_prefix}as}"
311ccas="${CCAS-$cc}"
312dlltool="${DLLTOOL-${cross_prefix}dlltool}"
313objcopy="${OBJCOPY-${cross_prefix}objcopy}"
314ld="${LD-${cross_prefix}ld}"
315ranlib="${RANLIB-${cross_prefix}ranlib}"
316nm="${NM-${cross_prefix}nm}"
317readelf="${READELF-${cross_prefix}readelf}"
318strip="${STRIP-${cross_prefix}strip}"
319widl="${WIDL-${cross_prefix}widl}"
320windres="${WINDRES-${cross_prefix}windres}"
321windmc="${WINDMC-${cross_prefix}windmc}"
322pkg_config="${PKG_CONFIG-${cross_prefix}pkg-config}"
323sdl2_config="${SDL2_CONFIG-${cross_prefix}sdl2-config}"
324
325rustc="${RUSTC-rustc}"
326
327check_define() {
328cat > $TMPC <<EOF
329#if !defined($1)
330#error $1 not defined
331#endif
332int main(void) { return 0; }
333EOF
334  compile_object
335}
336
337write_c_skeleton() {
338    cat > $TMPC <<EOF
339int main(void) { return 0; }
340EOF
341}
342
343if check_define __linux__ ; then
344  host_os=linux
345elif check_define _WIN32 ; then
346  host_os=windows
347elif check_define __OpenBSD__ ; then
348  host_os=openbsd
349elif check_define __sun__ ; then
350  host_os=sunos
351elif check_define __HAIKU__ ; then
352  host_os=haiku
353elif check_define __FreeBSD__ ; then
354  host_os=freebsd
355elif check_define __FreeBSD_kernel__ && check_define __GLIBC__; then
356  host_os=gnu/kfreebsd
357elif check_define __DragonFly__ ; then
358  host_os=dragonfly
359elif check_define __NetBSD__; then
360  host_os=netbsd
361elif check_define __APPLE__; then
362  host_os=darwin
363else
364  # This is a fatal error, but don't report it yet, because we
365  # might be going to just print the --help text, or it might
366  # be the result of a missing compiler.
367  host_os=bogus
368fi
369
370if test ! -z "$cpu" ; then
371  # command line argument
372  :
373elif check_define __i386__ ; then
374  cpu="i386"
375elif check_define __x86_64__ ; then
376  if check_define __ILP32__ ; then
377    cpu="x32"
378  else
379    cpu="x86_64"
380  fi
381elif check_define __sparc__ ; then
382  if check_define __arch64__ ; then
383    cpu="sparc64"
384  else
385    cpu="sparc"
386  fi
387elif check_define _ARCH_PPC ; then
388  if check_define _ARCH_PPC64 ; then
389    if check_define _LITTLE_ENDIAN ; then
390      cpu="ppc64le"
391    else
392      cpu="ppc64"
393    fi
394  else
395    cpu="ppc"
396  fi
397elif check_define __mips__ ; then
398  if check_define __mips64 ; then
399    cpu="mips64"
400  else
401    cpu="mips"
402  fi
403elif check_define __s390__ ; then
404  if check_define __s390x__ ; then
405    cpu="s390x"
406  else
407    cpu="s390"
408  fi
409elif check_define __riscv ; then
410  if check_define _LP64 ; then
411    cpu="riscv64"
412  else
413    cpu="riscv32"
414  fi
415elif check_define __arm__ ; then
416  cpu="arm"
417elif check_define __aarch64__ ; then
418  cpu="aarch64"
419elif check_define __loongarch64 ; then
420  cpu="loongarch64"
421else
422  # Using uname is really broken, but it is just a fallback for architectures
423  # that are going to use TCI anyway
424  cpu=$(uname -m)
425  if test "$host_os" != "bogus"; then
426    echo "WARNING: unrecognized host CPU, proceeding with 'uname -m' output '$cpu'"
427  fi
428fi
429
430# Normalise host CPU name to the values used by Meson cross files and in source
431# directories, and set multilib cflags.  The canonicalization isn't really
432# necessary, because the architectures that we check for should not hit the
433# 'uname -m' case, but better safe than sorry in case --cpu= is used.
434#
435# Note that this case should only have supported host CPUs, not guests.
436# Please keep it sorted and synchronized with meson.build's host_arch.
437host_arch=
438linux_arch=
439raw_cpu=$cpu
440case "$cpu" in
441  aarch64)
442    host_arch=aarch64
443    linux_arch=arm64
444    ;;
445
446  armv*b|armv*l|arm)
447    cpu=arm
448    host_arch=arm
449    linux_arch=arm
450    ;;
451
452  i386|i486|i586|i686)
453    cpu="i386"
454    host_arch=i386
455    linux_arch=x86
456    CPU_CFLAGS="-m32"
457    ;;
458
459  loongarch*)
460    cpu=loongarch64
461    host_arch=loongarch64
462    linux_arch=loongarch
463    ;;
464
465  mips64*|mipsisa64*)
466    cpu=mips64
467    host_arch=mips
468    linux_arch=mips
469    ;;
470  mips*)
471    cpu=mips
472    host_arch=mips
473    linux_arch=mips
474    ;;
475
476  ppc)
477    host_arch=ppc
478    linux_arch=powerpc
479    CPU_CFLAGS="-m32"
480    ;;
481  ppc64)
482    host_arch=ppc64
483    linux_arch=powerpc
484    CPU_CFLAGS="-m64 -mbig-endian"
485    ;;
486  ppc64le)
487    cpu=ppc64
488    host_arch=ppc64
489    linux_arch=powerpc
490    CPU_CFLAGS="-m64 -mlittle-endian"
491    ;;
492
493  riscv32 | riscv64)
494    host_arch=riscv
495    linux_arch=riscv
496    ;;
497
498  s390)
499    linux_arch=s390
500    CPU_CFLAGS="-m31"
501    ;;
502  s390x)
503    host_arch=s390x
504    linux_arch=s390
505    CPU_CFLAGS="-m64"
506    ;;
507
508  sparc|sun4[cdmuv])
509    cpu=sparc
510    CPU_CFLAGS="-m32 -mv8plus -mcpu=ultrasparc"
511    ;;
512  sparc64)
513    host_arch=sparc64
514    CPU_CFLAGS="-m64 -mcpu=ultrasparc"
515    ;;
516
517  x32)
518    cpu="x86_64"
519    host_arch=x86_64
520    linux_arch=x86
521    CPU_CFLAGS="-mx32"
522    ;;
523  x86_64|amd64)
524    cpu="x86_64"
525    host_arch=x86_64
526    linux_arch=x86
527    CPU_CFLAGS="-m64"
528    ;;
529esac
530
531# Now we have our CPU_CFLAGS we can check if we are targeting a 32 or
532# 64 bit host.
533
534check_64bit_host() {
535cat > $TMPC <<EOF
536#if __SIZEOF_POINTER__ != 8
537#error not 64 bit system
538#endif
539int main(void) { return 0; }
540EOF
541  compile_object "$1"
542}
543
544if check_64bit_host "$CPU_CFLAGS"; then
545    host_bits=64
546else
547    host_bits=32
548fi
549
550if test -n "$host_arch" && {
551    ! test -d "$source_path/linux-user/include/host/$host_arch" ||
552    ! test -d "$source_path/common-user/host/$host_arch"; }; then
553    error_exit "linux-user/include/host/$host_arch does not exist." \
554       "This is a bug in the configure script, please report it."
555fi
556if test -n "$linux_arch" && ! test -d "$source_path/linux-headers/asm-$linux_arch"; then
557    error_exit "linux-headers/asm-$linux_arch does not exist." \
558       "This is a bug in the configure script, please report it."
559fi
560
561check_py_version() {
562    # We require python >= 3.8.
563    # NB: a True python conditional creates a non-zero return code (Failure)
564    "$1" -c 'import sys; sys.exit(sys.version_info < (3,8))'
565}
566
567first_python=
568if test -z "${PYTHON}"; then
569    # A bare 'python' is traditionally python 2.x, but some distros
570    # have it as python 3.x, so check in both places.
571    for binary in python3 python python3.12 python3.11 \
572                          python3.10 python3.9 python3.8; do
573        if has "$binary"; then
574            python=$(command -v "$binary")
575            if check_py_version "$python"; then
576                # This one is good.
577                first_python=
578                break
579            else
580                first_python=$python
581            fi
582        fi
583    done
584else
585    # Same as above, but only check the environment variable.
586    has "${PYTHON}" || error_exit "The PYTHON environment variable does not point to an executable"
587    python=$(command -v "$PYTHON")
588    if check_py_version "$python"; then
589        # This one is good.
590        first_python=
591    else
592        first_python=$first_python
593    fi
594fi
595
596# Check for ancillary tools used in testing
597genisoimage=
598for binary in genisoimage mkisofs
599do
600    if has $binary
601    then
602        genisoimage=$(command -v "$binary")
603        break
604    fi
605done
606
607if test "$host_os" = "windows" ; then
608  EXESUF=".exe"
609fi
610
611meson_option_build_array() {
612  printf '['
613  (if test "$host_os" = windows; then
614    IFS=\;
615  else
616    IFS=:
617  fi
618  for e in $1; do
619    printf '"""'
620    # backslash escape any '\' and '"' characters
621    printf "%s" "$e" | sed -e 's/\([\"]\)/\\\1/g'
622    printf '""",'
623  done)
624  printf ']\n'
625}
626
627. "$source_path/scripts/meson-buildoptions.sh"
628
629meson_options=
630meson_option_add() {
631  local arg
632  for arg; do
633    meson_options="$meson_options $(quote_sh "$arg")"
634  done
635}
636meson_option_parse() {
637  meson_options="$meson_options $(_meson_option_parse "$@")"
638  if test $? -eq 1; then
639    echo "ERROR: unknown option $1"
640    echo "Try '$0 --help' for more information"
641    exit 1
642  fi
643}
644has_meson_option() {
645    test "${meson_options#*"$1"}" != "$meson_options"
646}
647
648meson_add_machine_file() {
649  if test "$cross_compile" = "yes"; then
650    meson_option_add --cross-file "$1"
651  else
652    meson_option_add --native-file "$1"
653  fi
654}
655
656for opt do
657  optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
658  case "$opt" in
659  --help|-h) show_help=yes
660  ;;
661  --version|-V) exec cat "$source_path/VERSION"
662  ;;
663  --cross-prefix=*)
664  ;;
665  --cc=*)
666  ;;
667  --host-cc=*) host_cc="$optarg"
668  ;;
669  --cxx=*)
670  ;;
671  --objcc=*)
672  ;;
673  --rustc=*)
674  ;;
675  --make=*)
676  ;;
677  --install=*)
678  ;;
679  --python=*) python="$optarg"
680  ;;
681  --skip-meson) skip_meson=yes
682  ;;
683  --ninja=*) ninja="$optarg"
684  ;;
685  --extra-cflags=*)
686  ;;
687  --extra-cxxflags=*)
688  ;;
689  --extra-objcflags=*)
690  ;;
691  --extra-ldflags=*)
692  ;;
693  --cross-cc-*)
694  ;;
695  --cross-prefix-*)
696  ;;
697  --enable-docs) docs=enabled
698  ;;
699  --disable-docs) docs=disabled
700  ;;
701  --cpu=*)
702  ;;
703  --target-list=*) target_list="$optarg"
704                   if test "$target_list_exclude"; then
705                       error_exit "Can't mix --target-list with --target-list-exclude"
706                   fi
707  ;;
708  --target-list-exclude=*) target_list_exclude="$optarg"
709                   if test "$target_list"; then
710                       error_exit "Can't mix --target-list-exclude with --target-list"
711                   fi
712  ;;
713  --with-default-devices) meson_option_add -Ddefault_devices=true
714  ;;
715  --without-default-devices) meson_option_add -Ddefault_devices=false
716  ;;
717  --with-devices-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --with-devices-FOO option"
718  ;;
719  --with-devices-*) device_arch=${opt#--with-devices-};
720                    device_arch=${device_arch%%=*}
721                    cf=$source_path/configs/devices/$device_arch-softmmu/$optarg.mak
722                    if test -f "$cf"; then
723                        device_archs="$device_archs $device_arch"
724                        eval "devices_${device_arch}=\$optarg"
725                    else
726                        error_exit "File $cf does not exist"
727                    fi
728  ;;
729  --without-default-features) # processed above
730  ;;
731  --static) static="yes"
732  ;;
733  --host=*|--build=*|\
734  --disable-dependency-tracking|\
735  --sbindir=*|--sharedstatedir=*|\
736  --oldincludedir=*|--datarootdir=*|--infodir=*|\
737  --htmldir=*|--dvidir=*|--pdfdir=*|--psdir=*)
738    # These switches are silently ignored, for compatibility with
739    # autoconf-generated configure scripts. This allows QEMU's
740    # configure to be used by RPM and similar macros that set
741    # lots of directory switches by default.
742  ;;
743  --enable-debug)
744      # Enable debugging options that aren't excessively noisy
745      meson_option_parse --enable-debug-tcg ""
746      meson_option_parse --enable-debug-graph-lock ""
747      meson_option_parse --enable-debug-mutex ""
748      meson_option_add -Doptimization=0
749      default_cflags='-O0 -g'
750  ;;
751  --disable-tcg) tcg="disabled"
752  ;;
753  --enable-tcg) tcg="enabled"
754  ;;
755  --disable-system) system="no"
756  ;;
757  --enable-system) system="yes"
758  ;;
759  --disable-user)
760      linux_user="no" ;
761      bsd_user="no" ;
762  ;;
763  --enable-user) ;;
764  --disable-linux-user) linux_user="no"
765  ;;
766  --enable-linux-user) linux_user="yes"
767  ;;
768  --disable-bsd-user) bsd_user="no"
769  ;;
770  --enable-bsd-user) bsd_user="yes"
771  ;;
772  --enable-pie) pie="yes"
773  ;;
774  --disable-pie) pie="no"
775  ;;
776  --enable-cfi) cfi=true
777  ;;
778  --disable-cfi) cfi=false
779  ;;
780  --disable-download) download="disabled"; git_submodules_action=validate;
781  ;;
782  --enable-download) download="enabled"; git_submodules_action=update;
783  ;;
784  --enable-plugins) plugins="yes"
785  ;;
786  --disable-plugins) plugins="no"
787  ;;
788  --enable-containers) use_containers="yes"
789  ;;
790  --disable-containers) use_containers="no"
791  ;;
792  --container-engine=*) container_engine="$optarg"
793  ;;
794  --rust-target-triple=*) rust_target_triple="$optarg"
795  ;;
796  --gdb=*) gdb_bin="$optarg"
797  ;;
798  --enable-rust) rust=enabled
799  ;;
800  --disable-rust) rust=disabled
801  ;;
802  # everything else has the same name in configure and meson
803  --*) meson_option_parse "$opt" "$optarg"
804  ;;
805  # Pass through -Dxxxx options to meson
806  -D*) meson_option_add "$opt"
807  ;;
808  esac
809done
810
811if ! test -e "$source_path/.git"
812then
813    git_submodules_action="validate"
814fi
815
816if ! test -f "$source_path/subprojects/keycodemapdb/README" \
817    && test "$download" = disabled
818then
819    echo
820    echo "ERROR: missing subprojects"
821    echo
822    if test -e "$source_path/.git"; then
823        echo "--disable-download specified but subprojects were not"
824        echo 'checked out.  Please invoke "meson subprojects download"'
825        echo "before configuring QEMU, or remove --disable-download"
826        echo "from the command line."
827    else
828        echo "This is not a GIT checkout but subproject content appears to"
829        echo "be missing. Do not use 'git archive' or GitHub download links"
830        echo "to acquire QEMU source archives. Non-GIT builds are only"
831        echo "supported with source archives linked from:"
832        echo
833        echo "  https://www.qemu.org/download/#source"
834        echo
835        echo "Developers working with GIT can use scripts/archive-source.sh"
836        echo "if they need to create valid source archives."
837    fi
838    echo
839    exit 1
840fi
841
842default_target_list=""
843mak_wilds=""
844
845if [ -n "$host_arch" ] && [ -d "$source_path/common-user/host/$host_arch" ]; then
846    if [ "$linux_user" != no ]; then
847        if [ "$host_os" = linux ]; then
848            linux_user=yes
849        elif [ "$linux_user" = yes ]; then
850            error_exit "linux-user not supported on this architecture"
851        fi
852        if [ "$linux_user" = "yes" ]; then
853            mak_wilds="${mak_wilds} $source_path/configs/targets/*-linux-user.mak"
854        fi
855    fi
856    if [ "$bsd_user" != no ]; then
857        if [ "$bsd_user" = "" ]; then
858            test $host_os = freebsd && bsd_user=yes
859        fi
860        if [ "$bsd_user" = yes ] && ! [ -d "$source_path/bsd-user/$host_os" ]; then
861            error_exit "bsd-user not supported on this host OS"
862        fi
863        if [ "$bsd_user" = "yes" ]; then
864            mak_wilds="${mak_wilds} $source_path/configs/targets/*-bsd-user.mak"
865        fi
866    fi
867else
868    if [ "$linux_user" = yes ] || [ "$bsd_user" = yes ]; then
869        error_exit "user mode emulation not supported on this architecture"
870    fi
871fi
872if [ "$system" = "yes" ]; then
873    mak_wilds="${mak_wilds} $source_path/configs/targets/*-softmmu.mak"
874fi
875
876for config in $mak_wilds; do
877    target="$(basename "$config" .mak)"
878    if echo "$target_list_exclude" | grep -vq "$target"; then
879        default_target_list="${default_target_list} $target"
880    fi
881done
882
883if test x"$show_help" = x"yes" ; then
884cat << EOF
885
886Usage: configure [options]
887Options: [defaults in brackets after descriptions]
888
889Standard options:
890  --help                   print this message
891  --target-list=LIST       set target list (default: build all)
892$(echo Available targets: $default_target_list | \
893  fold -s -w 53 | sed -e 's/^/                           /')
894  --target-list-exclude=LIST exclude a set of targets from the default target-list
895
896Advanced options (experts only):
897  -Dmesonoptname=val       passthrough option to meson unmodified
898  --cross-prefix=PREFIX    use PREFIX for compile tools, PREFIX can be blank [$cross_prefix]
899  --cc=CC                  use C compiler CC [$cc]
900  --host-cc=CC             when cross compiling, use C compiler CC for code run
901                           at build time [$host_cc]
902  --cxx=CXX                use C++ compiler CXX [$cxx]
903  --objcc=OBJCC            use Objective-C compiler OBJCC [$objcc]
904  --rustc=RUSTC            use Rust compiler RUSTC [$rustc]
905  --extra-cflags=CFLAGS    append extra C compiler flags CFLAGS
906  --extra-cxxflags=CXXFLAGS append extra C++ compiler flags CXXFLAGS
907  --extra-objcflags=OBJCFLAGS append extra Objective C compiler flags OBJCFLAGS
908  --extra-ldflags=LDFLAGS  append extra linker flags LDFLAGS
909  --cross-cc-ARCH=CC       use compiler when building ARCH guest test cases
910  --cross-cc-cflags-ARCH=  use compiler flags when building ARCH guest tests
911  --cross-prefix-ARCH=PREFIX cross compiler prefix when building ARCH guest test cases
912  --python=PYTHON          use specified python [$python]
913  --ninja=NINJA            use specified ninja [$ninja]
914  --static                 enable static build [$static]
915  --rust-target-triple=TRIPLE  compilation target for Rust code [autodetect]
916  --without-default-features   default all --enable-* options to "disabled"
917  --without-default-devices    do not include any device that is not needed to
918                           start the emulator (only use if you are including
919                           desired devices in configs/devices/)
920  --with-devices-ARCH=NAME override default configs/devices
921  --enable-debug           enable common debug build options
922  --cpu=CPU                Build for host CPU [$cpu]
923  --disable-containers     don't use containers for cross-building
924  --container-engine=TYPE  which container engine to use [$container_engine]
925  --gdb=GDB-path           gdb to use for gdbstub tests [$gdb_bin]
926EOF
927  meson_options_help
928cat << EOF
929  system          all system emulation targets
930  user            supported user emulation targets
931  linux-user      all linux usermode emulation targets
932  bsd-user        all BSD usermode emulation targets
933  pie             Position Independent Executables
934
935NOTE: The object files are built at the place where configure is launched
936EOF
937exit 0
938fi
939
940# Now that we are sure that the user did not only want to print the --help
941# information, we should double-check that the C compiler really works:
942write_c_skeleton
943if ! compile_object ; then
944    error_exit "C compiler \"$cc\" either does not exist or does not work."
945fi
946
947# Remove old dependency files to make sure that they get properly regenerated
948rm -f ./*/config-devices.mak.d
949
950if test -z "$python"
951then
952    # If first_python is set, there was a binary somewhere even though
953    # it was not suitable.  Use it for the error message.
954    if test -n "$first_python"; then
955        error_exit "Cannot use '$first_python', Python >= 3.8 is required." \
956            "Use --python=/path/to/python to specify a supported Python."
957    else
958        error_exit "Python not found. Use --python=/path/to/python"
959    fi
960fi
961
962if ! check_py_version "$python"; then
963  error_exit "Cannot use '$python', Python >= 3.8 is required." \
964             "Use --python=/path/to/python to specify a supported Python." \
965             "Maybe try:" \
966             "  openSUSE Leap 15.3+: zypper install python39" \
967             "  CentOS 8: dnf install python38"
968fi
969
970# Resolve PATH
971python="$(command -v "$python")"
972
973# Create a Python virtual environment using our configured python.
974# The stdout of this script will be the location of a symlink that
975# points to the configured Python.
976# Entry point scripts for pip, meson, and sphinx are generated if those
977# packages are present.
978
979# Defaults assumed for now:
980# - venv is cleared if it exists already;
981# - venv is allowed to use system packages;
982# - all setup can be performed offline;
983# - missing packages may be fetched from PyPI,
984#   unless --disable-download is passed.
985# - pip is not installed into the venv when possible,
986#   but ensurepip is called as a fallback when necessary.
987
988echo "python determined to be '$python'"
989echo "python version: $($python --version)"
990
991python="$($python -B "${source_path}/python/scripts/mkvenv.py" create pyvenv)"
992if test "$?" -ne 0 ; then
993    error_exit "python venv creation failed"
994fi
995
996# Suppress writing compiled files
997python="$python -B"
998mkvenv="$python ${source_path}/python/scripts/mkvenv.py"
999
1000# Finish preparing the virtual environment using vendored .whl files
1001
1002$mkvenv ensuregroup --dir "${source_path}/python/wheels" \
1003     ${source_path}/pythondeps.toml meson || exit 1
1004
1005# At this point, we expect Meson to be installed and available.
1006# We expect mkvenv or pip to have created pyvenv/bin/meson for us.
1007# We ignore PATH completely here: we want to use the venv's Meson
1008# *exclusively*.
1009
1010meson="$(cd pyvenv/bin; pwd)/meson"
1011
1012# Conditionally ensure Sphinx is installed.
1013
1014mkvenv_online_flag=""
1015if test "$download" = "enabled" ; then
1016    mkvenv_online_flag=" --online"
1017fi
1018
1019if test "$docs" != "disabled" ; then
1020    if ! $mkvenv ensuregroup \
1021         $(test "$docs" = "enabled" && echo "$mkvenv_online_flag") \
1022         ${source_path}/pythondeps.toml docs;
1023    then
1024        if test "$docs" = "enabled" ; then
1025            exit 1
1026        fi
1027        echo "Sphinx not found/usable, disabling docs."
1028        docs=disabled
1029    else
1030        docs=enabled
1031    fi
1032fi
1033
1034# Probe for ninja
1035
1036if test -z "$ninja"; then
1037    for c in ninja ninja-build samu; do
1038        if has $c; then
1039            ninja=$(command -v "$c")
1040            break
1041        fi
1042    done
1043    if test -z "$ninja"; then
1044      error_exit "Cannot find Ninja"
1045    fi
1046fi
1047
1048if test "$host_os" = "bogus"; then
1049    # Now that we know that we're not printing the help and that
1050    # the compiler works (so the results of the check_defines we used
1051    # to identify the OS are reliable), if we didn't recognize the
1052    # host OS we should stop now.
1053    error_exit "Unrecognized host OS (uname -s reports '$(uname -s)')"
1054fi
1055
1056# test for any invalid configuration combinations
1057if test "$host_os" = "windows" && ! has "$dlltool"; then
1058  if test "$plugins" = "yes"; then
1059    error_exit "TCG plugins requires dlltool to build on Windows platforms"
1060  fi
1061  plugins="no"
1062fi
1063if test "$tcg" = "disabled" ; then
1064  if test "$plugins" = "yes"; then
1065    error_exit "Can't enable plugins on non-TCG builds"
1066  fi
1067  plugins="no"
1068fi
1069if test "$static" = "yes" ; then
1070  if test "$plugins" = "yes"; then
1071    error_exit "static and plugins are mutually incompatible"
1072  fi
1073  plugins="no"
1074fi
1075if test "$plugins" != "no" && test $host_bits -eq 64; then
1076    if has_meson_option "-Dtcg_interpreter=true"; then
1077        plugins="no"
1078    else
1079        plugins=yes
1080        subdirs="$subdirs contrib/plugins"
1081    fi
1082fi
1083
1084cat > $TMPC << EOF
1085
1086#ifdef __linux__
1087#  define THREAD __thread
1088#else
1089#  define THREAD
1090#endif
1091static THREAD int tls_var;
1092int main(void) { return tls_var; }
1093EOF
1094
1095if test "$host_os" = windows || test "$host_os" = haiku; then
1096  if test "$pie" = "yes"; then
1097    error_exit "PIE not available due to missing OS support"
1098  fi
1099  pie=no
1100fi
1101
1102if test "$pie" != "no"; then
1103  if test "$static" = "yes"; then
1104    pie_ldflags=-static-pie
1105  else
1106    pie_ldflags=-pie
1107  fi
1108  if compile_prog "-Werror -fPIE -DPIE" "$pie_ldflags"; then
1109    pie="yes"
1110  elif test "$pie" = "yes"; then
1111    error_exit "-static-pie not available due to missing toolchain support"
1112  else
1113    echo "Disabling PIE due to missing toolchain support"
1114    pie="no"
1115  fi
1116fi
1117
1118##########################################
1119
1120if test -z "${target_list+xxx}" ; then
1121    default_targets=yes
1122    for target in $default_target_list; do
1123        target_list="$target_list $target"
1124    done
1125    target_list="${target_list# }"
1126else
1127    default_targets=no
1128    target_list=$(echo "$target_list" | sed -e 's/,/ /g')
1129    for target in $target_list; do
1130        # Check that we recognised the target name; this allows a more
1131        # friendly error message than if we let it fall through.
1132        case " $default_target_list " in
1133            *" $target "*)
1134                ;;
1135            *)
1136                error_exit "Unknown target name '$target'"
1137                ;;
1138        esac
1139    done
1140fi
1141
1142if test "$tcg" = "auto"; then
1143  if test -z "$target_list"; then
1144    tcg="disabled"
1145  else
1146    tcg="enabled"
1147  fi
1148fi
1149
1150#########################################
1151# gdb test
1152
1153if test -n "$gdb_bin"; then
1154    gdb_version_string=$($gdb_bin --version | head -n 1)
1155    # Extract last field in the version string
1156    gdb_version=${gdb_version_string##* }
1157    if version_ge $gdb_version 9.1; then
1158        gdb_arches=$($python "$source_path/scripts/probe-gdb-support.py" $gdb_bin)
1159    else
1160        gdb_bin=""
1161    fi
1162fi
1163
1164##########################################
1165# big/little endian test
1166cat > $TMPC << EOF
1167#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1168# error LITTLE
1169#endif
1170int main(void) { return 0; }
1171EOF
1172
1173if ! compile_prog ; then
1174  bigendian="no"
1175else
1176  cat > $TMPC << EOF
1177#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1178# error BIG
1179#endif
1180int main(void) { return 0; }
1181EOF
1182
1183  if ! compile_prog ; then
1184    bigendian="yes"
1185  else
1186    echo big/little test failed
1187    exit 1
1188  fi
1189fi
1190
1191##########################################
1192# detect rust triple
1193
1194if test "$rust" != disabled && has "$rustc" && $rustc -vV > "${TMPDIR1}/${TMPB}.out"; then
1195  rust_host_triple=$(sed -n 's/^host: //p' "${TMPDIR1}/${TMPB}.out")
1196else
1197  if test "$rust" = enabled; then
1198    error_exit "could not execute rustc binary \"$rustc\""
1199  fi
1200  rust=disabled
1201fi
1202if test "$rust" != disabled && test -z "$rust_target_triple"; then
1203  # arch and os generally matches between meson and rust
1204  rust_arch=$host_arch
1205  rust_os=$host_os
1206  rust_machine=unknown
1207  rust_osvariant=
1208
1209  # tweak rust_os if needed; also, machine and variant depend on the OS
1210  android=no
1211  case "$host_os" in
1212  darwin)
1213    # e.g. aarch64-apple-darwin
1214    rust_machine=apple
1215    ;;
1216
1217  linux)
1218    # detect android/glibc/musl
1219    if check_define __ANDROID__; then
1220      rust_osvariant=android
1221      android=yes
1222    else
1223      cat > $TMPC << EOF
1224#define _GNU_SOURCE
1225#include <features.h>
1226#ifndef __USE_GNU
1227error using musl
1228#endif
1229EOF
1230      if compile_object; then
1231        rust_osvariant=gnu
1232      else
1233        rust_osvariant=musl
1234      fi
1235    fi
1236
1237    case "$cpu" in
1238    arm)
1239      # e.g. arm-unknown-linux-gnueabi, arm-unknown-linux-gnueabihf
1240      write_c_skeleton
1241      compile_object
1242      if $READELF -A $TMPO | grep Tag_API_VFP_args: > /dev/null; then
1243        rust_osvariant=${rust_osvariant}eabihf
1244      else
1245        rust_osvariant=${rust_osvariant}eabi
1246      fi
1247      ;;
1248
1249    mips64)
1250      # e.g. mips64-unknown-linux-gnuabi64
1251      rust_osvariant=${rust_osvariant}abi64
1252      ;;
1253    esac
1254    ;;
1255
1256  netbsd)
1257    # e.g. arm-unknown-netbsd-eabihf
1258    test "$host_arch" = arm && rust_osvariant=eabihf
1259    ;;
1260
1261  sunos)
1262    rust_machine=pc
1263    rust_os=solaris
1264    ;;
1265
1266  windows)
1267    # e.g. aarch64-pc-windows-gnullvm, x86_64-pc-windows-gnu (MSVC not supported)
1268    rust_machine=pc
1269    if test "$host_arch" = aarch64; then
1270      rust_osvariant=gnullvm
1271    else
1272      rust_osvariant=gnu
1273    fi
1274    ;;
1275  esac
1276
1277  # now tweak the architecture part, possibly based on pre-canonicalization --cpu
1278  case "$host_arch" in
1279  arm)
1280    # preserve ISA version (armv7 etc.) from $raw_cpu if passed via --cpu
1281    rust_arch=$raw_cpu
1282    test "$rust_arch" = arm && test "$rust_os" != linux && rust_arch=armv7
1283    ;;
1284
1285  mips)
1286    # preserve ISA version (mipsisa64r6 etc.) and include endianness
1287    rust_arch=${raw_cpu%el}
1288    test "$bigendian" = no && rust_arch=${rust_arch}el
1289    ;;
1290
1291  riscv32|riscv64)
1292    # e.g. riscv64gc-unknown-linux-gnu, but riscv64-linux-android
1293    test "$android" = no && rust_arch=${rust_arch}gc
1294    ;;
1295
1296  sparc64)
1297    if test "$rust_os" = solaris; then
1298      rust_arch=sparcv9
1299      rust_machine=sun
1300    fi
1301    ;;
1302
1303  x86_64)
1304    # e.g. x86_64-unknown-linux-gnux32
1305    test "$raw_cpu" = x32 && rust_osvariant=${rust_osvariant}x32
1306    ;;
1307  esac
1308
1309  if test "$android" = yes; then
1310    # e.g. aarch64-linux-android
1311    rust_target_triple=$rust_arch-$rust_os-$rust_osvariant
1312  else
1313    rust_target_triple=$rust_arch-$rust_machine-$rust_os${rust_osvariant:+-$rust_osvariant}
1314  fi
1315fi
1316
1317##########################################
1318# functions to probe cross compilers
1319
1320container="no"
1321runc=""
1322if test $use_containers = "yes" && (has "docker" || has "podman"); then
1323    case $($python "$source_path"/tests/docker/docker.py --engine "$container_engine" probe) in
1324        *docker) container=docker ;;
1325        podman) container=podman ;;
1326        no) container=no ;;
1327    esac
1328    if test "$container" != "no"; then
1329        docker_py="$python $source_path/tests/docker/docker.py --engine $container"
1330        runc=$container
1331    fi
1332fi
1333
1334# cross compilers defaults, can be overridden with --cross-cc-ARCH
1335: ${cross_prefix_aarch64="aarch64-linux-gnu-"}
1336: ${cross_prefix_aarch64_be="$cross_prefix_aarch64"}
1337: ${cross_prefix_alpha="alpha-linux-gnu-"}
1338: ${cross_prefix_arm="arm-linux-gnueabihf-"}
1339: ${cross_prefix_armeb="$cross_prefix_arm"}
1340: ${cross_prefix_hexagon="hexagon-unknown-linux-musl-"}
1341: ${cross_prefix_loongarch64="loongarch64-unknown-linux-gnu-"}
1342: ${cross_prefix_hppa="hppa-linux-gnu-"}
1343: ${cross_prefix_i386="i686-linux-gnu-"}
1344: ${cross_prefix_m68k="m68k-linux-gnu-"}
1345: ${cross_prefix_microblaze="microblaze-linux-musl-"}
1346: ${cross_prefix_mips64el="mips64el-linux-gnuabi64-"}
1347: ${cross_prefix_mips64="mips64-linux-gnuabi64-"}
1348: ${cross_prefix_mipsel="mipsel-linux-gnu-"}
1349: ${cross_prefix_mips="mips-linux-gnu-"}
1350: ${cross_prefix_ppc="powerpc-linux-gnu-"}
1351: ${cross_prefix_ppc64="powerpc64-linux-gnu-"}
1352: ${cross_prefix_ppc64le="$cross_prefix_ppc64"}
1353: ${cross_prefix_riscv64="riscv64-linux-gnu-"}
1354: ${cross_prefix_s390x="s390x-linux-gnu-"}
1355: ${cross_prefix_sh4="sh4-linux-gnu-"}
1356: ${cross_prefix_sparc64="sparc64-linux-gnu-"}
1357: ${cross_prefix_sparc="$cross_prefix_sparc64"}
1358: ${cross_prefix_tricore="tricore-"}
1359: ${cross_prefix_x86_64="x86_64-linux-gnu-"}
1360
1361: ${cross_cc_aarch64_be="$cross_cc_aarch64"}
1362: ${cross_cc_cflags_aarch64_be="-mbig-endian"}
1363: ${cross_cc_armeb="$cross_cc_arm"}
1364: ${cross_cc_cflags_armeb="-mbig-endian"}
1365: ${cross_cc_hexagon="hexagon-unknown-linux-musl-clang"}
1366: ${cross_cc_cflags_hexagon="-mv73 -O2 -static"}
1367: ${cross_cc_cflags_i386="-m32"}
1368: ${cross_cc_cflags_ppc="-m32 -mbig-endian"}
1369: ${cross_cc_cflags_ppc64="-m64 -mbig-endian"}
1370: ${cross_cc_ppc64le="$cross_cc_ppc64"}
1371: ${cross_cc_cflags_ppc64le="-m64 -mlittle-endian"}
1372: ${cross_cc_cflags_sparc64="-m64 -mcpu=ultrasparc"}
1373: ${cross_cc_sparc="$cross_cc_sparc64"}
1374: ${cross_cc_cflags_sparc="-m32 -mcpu=supersparc"}
1375: ${cross_cc_cflags_x86_64="-m64 -mcx16"}
1376
1377compute_target_variable() {
1378  eval "$2="
1379  if eval test -n "\"\${cross_prefix_$1}\""; then
1380    if eval has "\"\${cross_prefix_$1}\$3\""; then
1381      eval "$2=\"\${cross_prefix_$1}\$3\""
1382    fi
1383  fi
1384}
1385
1386have_target() {
1387  for i; do
1388    case " $target_list " in
1389      *" $i "*) return 0;;
1390      *) ;;
1391    esac
1392  done
1393  return 1
1394}
1395
1396# probe_target_compiler TARGET
1397#
1398# Look for a compiler for the given target, either native or cross.
1399# Set variables target_* if a compiler is found, and container_cross_*
1400# if a Docker-based cross-compiler image is known for the target.
1401# Set got_cross_cc to yes/no depending on whether a non-container-based
1402# compiler was found.
1403#
1404# If TARGET is a user-mode emulation target, also set build_static to
1405# "y" if static linking is possible.
1406#
1407probe_target_compiler() {
1408  # reset all output variables
1409  got_cross_cc=no
1410  container_image=
1411  container_hosts=
1412  container_cross_prefix=
1413  container_cross_cc=
1414  container_cross_ar=
1415  container_cross_as=
1416  container_cross_ld=
1417  container_cross_nm=
1418  container_cross_objcopy=
1419  container_cross_ranlib=
1420  container_cross_strip=
1421
1422  target_arch=${1%%-*}
1423  case $target_arch in
1424    aarch64) container_hosts="x86_64 aarch64" ;;
1425    aarch64_be) container_hosts="x86_64 aarch64" ;;
1426    alpha) container_hosts=x86_64 ;;
1427    arm) container_hosts="x86_64 aarch64" ;;
1428    hexagon) container_hosts=x86_64 ;;
1429    hppa) container_hosts=x86_64 ;;
1430    i386) container_hosts=x86_64 ;;
1431    loongarch64) container_hosts=x86_64 ;;
1432    m68k) container_hosts=x86_64 ;;
1433    microblaze) container_hosts=x86_64 ;;
1434    mips64el) container_hosts=x86_64 ;;
1435    mips64) container_hosts=x86_64 ;;
1436    mipsel) container_hosts=x86_64 ;;
1437    mips) container_hosts=x86_64 ;;
1438    ppc) container_hosts=x86_64 ;;
1439    ppc64|ppc64le) container_hosts=x86_64 ;;
1440    riscv64) container_hosts=x86_64 ;;
1441    s390x) container_hosts=x86_64 ;;
1442    sh4) container_hosts=x86_64 ;;
1443    sparc64) container_hosts=x86_64 ;;
1444    tricore) container_hosts=x86_64 ;;
1445    x86_64) container_hosts="aarch64 ppc64le x86_64" ;;
1446    xtensa*) container_hosts=x86_64 ;;
1447  esac
1448
1449  for host in $container_hosts; do
1450    test "$container" != no || continue
1451    test "$host" = "$cpu" || continue
1452    case $target_arch in
1453      # debian-all-test-cross architectures
1454
1455      aarch64_be)
1456        container_image=debian-all-test-cross
1457        container_cross_prefix=aarch64-linux-gnu-
1458        ;;
1459      hppa|m68k|mips|riscv64|sparc64)
1460        container_image=debian-all-test-cross
1461        ;;
1462      mips64)
1463        container_image=debian-all-test-cross
1464        container_cross_prefix=mips64-linux-gnuabi64-
1465        ;;
1466      ppc|ppc64|ppc64le)
1467        container_image=debian-all-test-cross
1468        container_cross_prefix=powerpc${target_arch#ppc}-linux-gnu-
1469        ;;
1470
1471      # debian-legacy-test-cross architectures (need Debian 11)
1472      # - libc6.1-dev-alpha-cross: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1054412
1473      # - sh4-linux-user: binaries don't run with bookworm compiler
1474
1475      alpha|sh4)
1476        container_image=debian-legacy-test-cross
1477        ;;
1478
1479      # architectures with individual containers
1480
1481      aarch64)
1482        # We don't have any bigendian build tools so we only use this for AArch64
1483        container_image=debian-arm64-cross
1484        ;;
1485      arm)
1486        # We don't have any bigendian build tools so we only use this for ARM
1487        container_image=debian-armhf-cross
1488        container_cross_prefix=arm-linux-gnueabihf-
1489        ;;
1490      hexagon)
1491        container_cross_prefix=hexagon-unknown-linux-musl-
1492        container_cross_cc=${container_cross_prefix}clang
1493        ;;
1494      i386)
1495        container_image=debian-i686-cross
1496        container_cross_prefix=i686-linux-gnu-
1497        ;;
1498      loongarch64)
1499        container_image=debian-loongarch-cross
1500        container_cross_prefix=loongarch64-unknown-linux-gnu-
1501        ;;
1502      microblaze)
1503        container_cross_prefix=microblaze-linux-musl-
1504        ;;
1505      mips64el)
1506        container_image=debian-all-test-cross
1507        container_cross_prefix=mips64el-linux-gnuabi64-
1508        ;;
1509      tricore)
1510        container_image=debian-tricore-cross
1511        container_cross_prefix=tricore-
1512        ;;
1513      x86_64)
1514        container_image=debian-amd64-cross
1515        ;;
1516      xtensa*)
1517        container_image=debian-xtensa-cross
1518
1519        # default to the dc232b cpu
1520        container_cross_prefix=/opt/2020.07/xtensa-dc232b-elf/bin/xtensa-dc232b-elf-
1521        ;;
1522    esac
1523    # Debian and GNU architecture names usually match
1524    : ${container_image:=debian-$target_arch-cross}
1525    : ${container_cross_prefix:=$target_arch-linux-gnu-}
1526    : ${container_cross_cc:=${container_cross_prefix}gcc}
1527    : ${container_cross_ar:=${container_cross_prefix}ar}
1528    : ${container_cross_as:=${container_cross_prefix}as}
1529    : ${container_cross_ld:=${container_cross_prefix}ld}
1530    : ${container_cross_nm:=${container_cross_prefix}nm}
1531    : ${container_cross_objcopy:=${container_cross_prefix}objcopy}
1532    : ${container_cross_ranlib:=${container_cross_prefix}ranlib}
1533    : ${container_cross_strip:=${container_cross_prefix}strip}
1534  done
1535
1536  try=cross
1537  # For softmmu/roms also look for a bi-endian or multilib-enabled host compiler
1538  if [ "${1%softmmu}" != "$1" ] || test "$target_arch" = "$cpu"; then
1539      case "$target_arch:$cpu" in
1540        aarch64_be:aarch64 | \
1541        armeb:arm | \
1542        i386:x86_64 | \
1543        mips*:mips64 | \
1544        ppc*:ppc64 | \
1545        sparc:sparc64 | \
1546        "$cpu:$cpu")
1547        try='native cross' ;;
1548      esac
1549  fi
1550  eval "target_cflags=\${cross_cc_cflags_$target_arch}"
1551  for thistry in $try; do
1552    case $thistry in
1553    native)
1554      target_cc=$cc
1555      target_ccas=$ccas
1556      target_ar=$ar
1557      target_as=$as
1558      target_ld=$ld
1559      target_nm=$nm
1560      target_objcopy=$objcopy
1561      target_ranlib=$ranlib
1562      target_strip=$strip
1563      ;;
1564    cross)
1565      target_cc=
1566      if eval test -n "\"\${cross_cc_$target_arch}\""; then
1567        if eval has "\"\${cross_cc_$target_arch}\""; then
1568          eval "target_cc=\"\${cross_cc_$target_arch}\""
1569        fi
1570      else
1571        compute_target_variable $target_arch target_cc gcc
1572      fi
1573      target_ccas=$target_cc
1574      compute_target_variable $target_arch target_ar ar
1575      compute_target_variable $target_arch target_as as
1576      compute_target_variable $target_arch target_ld ld
1577      compute_target_variable $target_arch target_nm nm
1578      compute_target_variable $target_arch target_objcopy objcopy
1579      compute_target_variable $target_arch target_ranlib ranlib
1580      compute_target_variable $target_arch target_strip strip
1581      ;;
1582    esac
1583
1584    if test -n "$target_cc"; then
1585      case $target_arch in
1586        i386|x86_64)
1587          if $target_cc --version | grep -qi "clang"; then
1588            continue
1589          fi
1590          ;;
1591      esac
1592    elif test -n "$target_as" && test -n "$target_ld"; then
1593      # Special handling for assembler only targets
1594      case $target in
1595        tricore-softmmu)
1596          build_static=
1597          got_cross_cc=yes
1598          break
1599          ;;
1600        *)
1601          continue
1602          ;;
1603      esac
1604    else
1605      continue
1606    fi
1607
1608    write_c_skeleton
1609    case $1 in
1610      *-softmmu)
1611        if do_compiler "$target_cc" $target_cflags -o $TMPO -c $TMPC &&
1612          do_compiler "$target_cc" $target_cflags -r -nostdlib -o "${TMPDIR1}/${TMPB}2.o" "$TMPO" -lgcc; then
1613          got_cross_cc=yes
1614          break
1615        fi
1616        ;;
1617      *)
1618        if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC -static ; then
1619          build_static=y
1620          got_cross_cc=yes
1621          break
1622        fi
1623        if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC ; then
1624          build_static=
1625          got_cross_cc=yes
1626          break
1627        fi
1628        ;;
1629    esac
1630  done
1631  if test $got_cross_cc != yes; then
1632    build_static=
1633    target_cc=
1634    target_ccas=
1635    target_ar=
1636    target_as=
1637    target_ld=
1638    target_nm=
1639    target_objcopy=
1640    target_ranlib=
1641    target_strip=
1642  fi
1643  test -n "$target_cc"
1644}
1645
1646write_target_makefile() {
1647  echo "EXTRA_CFLAGS=$target_cflags"
1648  if test -z "$target_cc" && test -z "$target_as"; then
1649    test -z "$container_image" && error_exit "Internal error: could not find cross compiler for $1?"
1650    echo "$1: docker-image-$container_image" >> Makefile.prereqs
1651    if test -n "$container_cross_cc"; then
1652      echo "CC=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
1653      echo "CCAS=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
1654    fi
1655    echo "AR=$docker_py cc --cc $container_cross_ar -i qemu/$container_image -s $source_path --"
1656    echo "AS=$docker_py cc --cc $container_cross_as -i qemu/$container_image -s $source_path --"
1657    echo "LD=$docker_py cc --cc $container_cross_ld -i qemu/$container_image -s $source_path --"
1658    echo "NM=$docker_py cc --cc $container_cross_nm -i qemu/$container_image -s $source_path --"
1659    echo "OBJCOPY=$docker_py cc --cc $container_cross_objcopy -i qemu/$container_image -s $source_path --"
1660    echo "RANLIB=$docker_py cc --cc $container_cross_ranlib -i qemu/$container_image -s $source_path --"
1661    echo "STRIP=$docker_py cc --cc $container_cross_strip -i qemu/$container_image -s $source_path --"
1662  else
1663    if test -n "$target_cc"; then
1664      echo "CC=$target_cc"
1665      echo "CCAS=$target_ccas"
1666    fi
1667    if test -n "$target_ar"; then
1668      echo "AR=$target_ar"
1669    fi
1670    if test -n "$target_as"; then
1671      echo "AS=$target_as"
1672    fi
1673    if test -n "$target_ld"; then
1674      echo "LD=$target_ld"
1675    fi
1676    if test -n "$target_nm"; then
1677      echo "NM=$target_nm"
1678    fi
1679    if test -n "$target_objcopy"; then
1680      echo "OBJCOPY=$target_objcopy"
1681    fi
1682    if test -n "$target_ranlib"; then
1683      echo "RANLIB=$target_ranlib"
1684    fi
1685    if test -n "$target_strip"; then
1686      echo "STRIP=$target_strip"
1687    fi
1688  fi
1689}
1690
1691#######################################
1692# cross-compiled firmware targets
1693
1694# Set up build tree symlinks that point back into the source tree
1695# (these can be both files and directories).
1696# Caution: avoid adding files or directories here using wildcards. This
1697# will result in problems later if a new file matching the wildcard is
1698# added to the source tree -- nothing will cause configure to be rerun
1699# so the build tree will be missing the link back to the new file, and
1700# tests might fail. Prefer to keep the relevant files in their own
1701# directory and symlink the directory instead.
1702LINKS="Makefile"
1703LINKS="$LINKS docs/config"
1704LINKS="$LINKS pc-bios/optionrom/Makefile"
1705LINKS="$LINKS pc-bios/s390-ccw/Makefile"
1706LINKS="$LINKS pc-bios/vof/Makefile"
1707LINKS="$LINKS .gdbinit scripts" # scripts needed by relative path in .gdbinit
1708LINKS="$LINKS tests/avocado tests/data"
1709LINKS="$LINKS tests/qemu-iotests/check tests/qemu-iotests/Makefile"
1710LINKS="$LINKS python"
1711LINKS="$LINKS contrib/plugins/Makefile "
1712for f in $LINKS ; do
1713    if [ -e "$source_path/$f" ]; then
1714        symlink "$source_path/$f" "$f"
1715    fi
1716done
1717
1718# use included Linux headers for KVM architectures
1719if test "$host_os" = "linux" && test -n "$linux_arch"; then
1720  symlink "$source_path/linux-headers/asm-$linux_arch" linux-headers/asm
1721fi
1722
1723echo "# Automatically generated by configure - do not modify" > Makefile.prereqs
1724
1725# Mac OS X ships with a broken assembler
1726if have_target i386-softmmu x86_64-softmmu && \
1727        test "$host_os" != "darwin" && test "$host_os" != "sunos" && \
1728        test "$host_os" != "haiku" && \
1729        probe_target_compiler i386-softmmu; then
1730    subdirs="$subdirs pc-bios/optionrom"
1731    config_mak=pc-bios/optionrom/config.mak
1732    echo "# Automatically generated by configure - do not modify" > $config_mak
1733    echo "TOPSRC_DIR=$source_path" >> $config_mak
1734    write_target_makefile >> $config_mak
1735fi
1736
1737if have_target ppc-softmmu ppc64-softmmu && \
1738        probe_target_compiler ppc-softmmu; then
1739    subdirs="$subdirs pc-bios/vof"
1740    config_mak=pc-bios/vof/config.mak
1741    echo "# Automatically generated by configure - do not modify" > $config_mak
1742    echo "SRC_DIR=$source_path/pc-bios/vof" >> $config_mak
1743    write_target_makefile >> $config_mak
1744fi
1745
1746# Only build s390-ccw bios if the compiler has -march=z900 or -march=z10
1747# (which is the lowest architecture level that Clang supports)
1748if have_target s390x-softmmu && probe_target_compiler s390x-softmmu && \
1749    GIT=git "$source_path/scripts/git-submodule.sh" "$git_submodules_action" roms/SLOF >> config.log 2>&1; then
1750  write_c_skeleton
1751  do_compiler "$target_cc" $target_cc_cflags -march=z900 -o $TMPO -c $TMPC
1752  has_z900=$?
1753  if [ $has_z900 = 0 ] || do_compiler "$target_cc" $target_cc_cflags -march=z10 -msoft-float -Werror -o $TMPO -c $TMPC; then
1754    if [ $has_z900 != 0 ]; then
1755      echo "WARNING: Your compiler does not support the z900!"
1756      echo "         The s390-ccw bios will only work with guest CPUs >= z10."
1757    fi
1758    subdirs="$subdirs pc-bios/s390-ccw"
1759    config_mak=pc-bios/s390-ccw/config-host.mak
1760    echo "# Automatically generated by configure - do not modify" > $config_mak
1761    echo "SRC_PATH=$source_path/pc-bios/s390-ccw" >> $config_mak
1762    echo "GIT_SUBMODULES_ACTION=$git_submodules_action" >> $config_mak
1763    write_target_makefile >> $config_mak
1764  fi
1765fi
1766
1767#######################################
1768# generate config-host.mak
1769
1770config_host_mak="config-host.mak"
1771
1772echo "# Automatically generated by configure - do not modify" > $config_host_mak
1773echo >> $config_host_mak
1774
1775echo all: >> $config_host_mak
1776
1777echo "SRC_PATH=$source_path" >> $config_host_mak
1778echo "TARGET_DIRS=$target_list" >> $config_host_mak
1779echo "GDB=$gdb_bin" >> $config_host_mak
1780if test "$container" != no; then
1781    echo "RUNC=$runc" >> $config_host_mak
1782fi
1783echo "SUBDIRS=$subdirs" >> $config_host_mak
1784if test "$rust" != disabled; then
1785  echo "RUST_TARGET_TRIPLE=$rust_target_triple" >> $config_host_mak
1786fi
1787echo "PYTHON=$python" >> $config_host_mak
1788echo "MKVENV_ENSUREGROUP=$mkvenv ensuregroup $mkvenv_online_flag" >> $config_host_mak
1789echo "GENISOIMAGE=$genisoimage" >> $config_host_mak
1790echo "MESON=$meson" >> $config_host_mak
1791echo "NINJA=$ninja" >> $config_host_mak
1792echo "EXESUF=$EXESUF" >> $config_host_mak
1793if test "$default_targets" = "yes"; then
1794  echo "CONFIG_DEFAULT_TARGETS=y" >> $config_host_mak
1795fi
1796
1797# contrib/plugins configuration
1798echo "# Automatically generated by configure - do not modify" > contrib/plugins/$config_host_mak
1799echo "SRC_PATH=$source_path/contrib/plugins" >> contrib/plugins/$config_host_mak
1800echo "PKG_CONFIG=${pkg_config}" >> contrib/plugins/$config_host_mak
1801echo "CC=$cc $CPU_CFLAGS" >> contrib/plugins/$config_host_mak
1802echo "CFLAGS=${CFLAGS-$default_cflags} $EXTRA_CFLAGS" >> contrib/plugins/$config_host_mak
1803if test "$host_os" = windows; then
1804  echo "DLLTOOL=$dlltool" >> contrib/plugins/$config_host_mak
1805fi
1806if test "$host_os" = darwin; then
1807  echo "CONFIG_DARWIN=y" >> contrib/plugins/$config_host_mak
1808fi
1809if test "$host_os" = windows; then
1810  echo "CONFIG_WIN32=y" >> contrib/plugins/$config_host_mak
1811fi
1812
1813# tests/tcg configuration
1814mkdir -p tests/tcg
1815echo "# Automatically generated by configure - do not modify" > tests/tcg/$config_host_mak
1816echo "SRC_PATH=$source_path" >> tests/tcg/$config_host_mak
1817if test "$plugins" = "yes" ; then
1818    echo "CONFIG_PLUGIN=y" >> tests/tcg/$config_host_mak
1819fi
1820
1821tcg_tests_targets=
1822for target in $target_list; do
1823  arch=${target%%-*}
1824
1825  case $target in
1826    xtensa*-linux-user)
1827      # the toolchain is not complete with headers, only build system tests
1828      continue
1829      ;;
1830    *-softmmu)
1831      test -f "$source_path/tests/tcg/$arch/Makefile.softmmu-target" || continue
1832      qemu="qemu-system-$arch"
1833      ;;
1834    *-linux-user|*-bsd-user)
1835      qemu="qemu-$arch"
1836      ;;
1837  esac
1838
1839  if probe_target_compiler $target || test -n "$container_image"; then
1840      test -n "$container_image" && build_static=y
1841      mkdir -p "tests/tcg/$target"
1842      config_target_mak=tests/tcg/$target/config-target.mak
1843      ln -sf "$source_path/tests/tcg/Makefile.target" "tests/tcg/$target/Makefile"
1844      echo "# Automatically generated by configure - do not modify" > "$config_target_mak"
1845      echo "TARGET_NAME=$arch" >> "$config_target_mak"
1846      echo "TARGET=$target" >> "$config_target_mak"
1847      write_target_makefile "build-tcg-tests-$target" >> "$config_target_mak"
1848      echo "BUILD_STATIC=$build_static" >> "$config_target_mak"
1849      echo "QEMU=$PWD/$qemu" >> "$config_target_mak"
1850
1851      # will GDB work with these binaries?
1852      if test "${gdb_arches#*$arch}" != "$gdb_arches"; then
1853          echo "GDB=$gdb_bin" >> $config_target_mak
1854      fi
1855
1856      if test "${gdb_arches#*aarch64}" != "$gdb_arches" && version_ge $gdb_version 15.1; then
1857          echo "GDB_HAS_MTE=y" >> $config_target_mak
1858      fi
1859
1860      if test "${gdb_arches#*aarch64}" != "$gdb_arches" && version_ge $gdb_version 16.0; then
1861          # GDB has to support MTE in baremetal to allow debugging MTE in QEMU system mode
1862          echo "GDB_SUPPORTS_MTE_IN_BAREMETAL=y" >> $config_target_mak
1863      fi
1864
1865      echo "run-tcg-tests-$target: $qemu\$(EXESUF)" >> Makefile.prereqs
1866      tcg_tests_targets="$tcg_tests_targets $target"
1867  fi
1868done
1869
1870if test "$tcg" = "enabled"; then
1871    echo "TCG_TESTS_TARGETS=$tcg_tests_targets" >> $config_host_mak
1872fi
1873
1874if test "$skip_meson" = no; then
1875  cross="config-meson.cross.new"
1876  meson_quote() {
1877    test $# = 0 && return
1878    echo "'$(echo $* | sed "s/ /','/g")'"
1879  }
1880
1881  echo "# Automatically generated by configure - do not modify" > $cross
1882  echo "[properties]" >> $cross
1883
1884  # unroll any custom device configs
1885  for a in $device_archs; do
1886      eval "c=\$devices_${a}"
1887      echo "${a}-softmmu = '$c'" >> $cross
1888  done
1889
1890  echo "[built-in options]" >> $cross
1891  echo "c_args = [$(meson_quote $CFLAGS $EXTRA_CFLAGS)]" >> $cross
1892  echo "cpp_args = [$(meson_quote $CXXFLAGS $EXTRA_CXXFLAGS)]" >> $cross
1893  test -n "$objcc" && echo "objc_args = [$(meson_quote $OBJCFLAGS $EXTRA_OBJCFLAGS)]" >> $cross
1894  echo "c_link_args = [$(meson_quote $CFLAGS $LDFLAGS $EXTRA_CFLAGS $EXTRA_LDFLAGS)]" >> $cross
1895  echo "cpp_link_args = [$(meson_quote $CXXFLAGS $LDFLAGS $EXTRA_CXXFLAGS $EXTRA_LDFLAGS)]" >> $cross
1896
1897  # Only enable by default for git builds and on select OSes
1898  echo "# environment defaults, can still be overridden on " >> $cross
1899  echo "# the command line" >> $cross
1900  if test -e "$source_path/.git" && \
1901      { test "$host_os" = linux || test "$host_os" = "windows"; }; then
1902      echo 'werror = true' >> $cross
1903  fi
1904  echo "[project options]" >> $cross
1905  if test "$SMBD" != ''; then
1906    echo "smbd = $(meson_quote "$SMBD")" >> $cross
1907  fi
1908  if test "${QEMU_GA_MANUFACTURER}" != ''; then
1909    echo "qemu_ga_manufacturer = $(meson_quote "${QEMU_GA_MANUFACTURER}")" >> $cross
1910  fi
1911  if test "${QEMU_GA_DISTRO}" != ''; then
1912    echo "qemu_ga_distro = $(meson_quote "${QEMU_GA_DISTRO}")" >> $cross
1913  fi
1914  if test "${QEMU_GA_VERSION}" != ''; then
1915    echo "qemu_ga_version = $(meson_quote "${QEMU_GA_VERSION}")" >> $cross
1916  fi
1917
1918  echo >> $cross
1919  echo "[binaries]" >> $cross
1920  echo "c = [$(meson_quote $cc $CPU_CFLAGS)]" >> $cross
1921  test -n "$cxx" && echo "cpp = [$(meson_quote $cxx $CPU_CFLAGS)]" >> $cross
1922  test -n "$objcc" && echo "objc = [$(meson_quote $objcc $CPU_CFLAGS)]" >> $cross
1923  if test "$rust" != disabled; then
1924    if test "$rust_host_triple" != "$rust_target_triple"; then
1925      echo "rust = [$(meson_quote $rustc --target "$rust_target_triple")]" >> $cross
1926    else
1927      echo "rust = [$(meson_quote $rustc)]" >> $cross
1928    fi
1929  fi
1930  echo "ar = [$(meson_quote $ar)]" >> $cross
1931  echo "dlltool = [$(meson_quote $dlltool)]" >> $cross
1932  echo "nm = [$(meson_quote $nm)]" >> $cross
1933  echo "pkgconfig = [$(meson_quote $pkg_config)]" >> $cross
1934  echo "pkg-config = [$(meson_quote $pkg_config)]" >> $cross
1935  echo "ranlib = [$(meson_quote $ranlib)]" >> $cross
1936  echo "readelf = [$(meson_quote $readelf)]" >> $cross
1937  if has $sdl2_config; then
1938    echo "sdl2-config = [$(meson_quote $sdl2_config)]" >> $cross
1939  fi
1940  echo "strip = [$(meson_quote $strip)]" >> $cross
1941  echo "widl = [$(meson_quote $widl)]" >> $cross
1942  echo "windres = [$(meson_quote $windres)]" >> $cross
1943  echo "windmc = [$(meson_quote $windmc)]" >> $cross
1944  if test "$cross_compile" = "yes"; then
1945    echo "[host_machine]" >> $cross
1946    echo "system = '$host_os'" >> $cross
1947    case "$cpu" in
1948        i386)
1949            echo "cpu_family = 'x86'" >> $cross
1950            ;;
1951        *)
1952            echo "cpu_family = '$cpu'" >> $cross
1953            ;;
1954    esac
1955    echo "cpu = '$cpu'" >> $cross
1956    if test "$bigendian" = "yes" ; then
1957        echo "endian = 'big'" >> $cross
1958    else
1959        echo "endian = 'little'" >> $cross
1960    fi
1961
1962    native="config-meson.native.new"
1963    echo "# Automatically generated by configure - do not modify" > $native
1964    echo "[binaries]" >> $native
1965    echo "c = [$(meson_quote $host_cc)]" >> $native
1966    if test "$rust" != disabled; then
1967      echo "rust = [$(meson_quote $rustc)]" >> $cross
1968    fi
1969    mv $native config-meson.native
1970    meson_option_add --native-file
1971    meson_option_add config-meson.native
1972  fi
1973  mv $cross config-meson.cross
1974  meson_add_machine_file config-meson.cross
1975  if test -f "$source_path/configs/meson/$host_os.txt"; then
1976    meson_add_machine_file $source_path/configs/meson/$host_os.txt
1977  fi
1978
1979  rm -rf meson-private meson-info meson-logs
1980
1981  test "$download" = "disabled" && meson_option_add "--wrap-mode=nodownload"
1982  test "$default_feature" = no && meson_option_add -Dauto_features=disabled
1983  test "$static" = yes && meson_option_add -Dprefer_static=true
1984  test "$pie" = no && meson_option_add -Db_pie=false
1985
1986  # QEMU options
1987  test "$rust" != "disabled" && meson_option_add "-Drust=$rust"
1988  test "$cfi" != false && meson_option_add "-Dcfi=$cfi" "-Db_lto=$cfi"
1989  test "$docs" != auto && meson_option_add "-Ddocs=$docs"
1990  test -n "${LIB_FUZZING_ENGINE+xxx}" && meson_option_add "-Dfuzzing_engine=$LIB_FUZZING_ENGINE"
1991  test "$plugins" = yes && meson_option_add "-Dplugins=true"
1992  test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
1993  run_meson() {
1994    NINJA=$ninja $meson setup "$@" "$PWD" "$source_path"
1995  }
1996  eval run_meson $meson_options
1997  if test "$?" -ne 0 ; then
1998      error_exit "meson setup failed"
1999  fi
2000  echo "$meson" > build.ninja.stamp
2001else
2002  if test -f meson-private/cmd_line.txt; then
2003    # Adjust old command line options that were removed
2004    # sed -i is not portable
2005    perl -i -ne '
2006      /^sphinx_build/ && next;
2007      print;' meson-private/cmd_line.txt
2008  fi
2009fi
2010
2011# Save the configure command line for later reuse.
2012cat <<EOD >config.status
2013#!/bin/sh
2014# Generated by configure.
2015# Run this file to recreate the current configuration.
2016# Compiler output produced by configure, useful for debugging
2017# configure, is in config.log if it exists.
2018EOD
2019
2020preserve_env() {
2021    envname=$1
2022
2023    eval envval=\$$envname
2024
2025    if test -n "$envval"
2026    then
2027	echo "$envname='$envval'" >> config.status
2028	echo "export $envname" >> config.status
2029    else
2030	echo "unset $envname" >> config.status
2031    fi
2032}
2033
2034# Preserve various env variables that influence what
2035# features/build target configure will detect
2036preserve_env AR
2037preserve_env AS
2038preserve_env CC
2039preserve_env CFLAGS
2040preserve_env CXX
2041preserve_env CXXFLAGS
2042preserve_env DLLTOOL
2043preserve_env LD
2044preserve_env LDFLAGS
2045preserve_env LD_LIBRARY_PATH
2046preserve_env NM
2047preserve_env OBJCFLAGS
2048preserve_env OBJCOPY
2049preserve_env PATH
2050preserve_env PKG_CONFIG
2051preserve_env PKG_CONFIG_LIBDIR
2052preserve_env PKG_CONFIG_PATH
2053preserve_env PYTHON
2054preserve_env QEMU_GA_MANUFACTURER
2055preserve_env QEMU_GA_DISTRO
2056preserve_env QEMU_GA_VERSION
2057preserve_env SDL2_CONFIG
2058preserve_env SMBD
2059preserve_env STRIP
2060preserve_env WIDL
2061preserve_env WINDRES
2062preserve_env WINDMC
2063
2064printf "exec" >>config.status
2065for i in "$0" "$@"; do
2066  test "$i" = --skip-meson || printf " %s" "$(quote_sh "$i")" >>config.status
2067done
2068echo ' "$@"' >>config.status
2069chmod +x config.status
2070
2071rm -r "$TMPDIR1"
2072
2073if test "$rust" != disabled; then
2074  echo
2075  echo 'INFO: Rust bindings generation with `bindgen` might fail in some cases where'
2076  echo 'the detected `libclang` does not match the expected `clang` version/target. In'
2077  echo 'this case you must pass the path to `clang` and `libclang` to your build'
2078  echo 'command invocation using the environment variables CLANG_PATH and LIBCLANG_PATH'
2079fi
2080