xref: /openbmc/qemu/configure (revision ab930e80)
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.
8CLICOLOR_FORCE= GREP_OPTIONS=
9unset CLICOLOR_FORCE GREP_OPTIONS
10
11# Don't allow CCACHE, if present, to use cached results of compile tests!
12export CCACHE_RECACHE=yes
13
14# make source path absolute
15source_path=$(cd "$(dirname -- "$0")"; pwd)
16
17if test "$PWD" = "$source_path"
18then
19    echo "Using './build' as the directory for build output"
20
21    MARKER=build/auto-created-by-configure
22
23    if test -e build
24    then
25        if test -f $MARKER
26        then
27           rm -rf build
28        else
29            echo "ERROR: ./build dir already exists and was not previously created by configure"
30            exit 1
31        fi
32    fi
33
34    if ! mkdir build || ! touch $MARKER
35    then
36        echo "ERROR: Could not create ./build directory. Check the permissions on"
37        echo "your source directory, or try doing an out-of-tree build."
38        exit 1
39    fi
40
41    cat > GNUmakefile <<'EOF'
42# This file is auto-generated by configure to support in-source tree
43# 'make' command invocation
44
45ifeq ($(MAKECMDGOALS),)
46recurse: all
47endif
48
49.NOTPARALLEL: %
50%: force
51	@echo 'changing dir to build for $(MAKE) "$(MAKECMDGOALS)"...'
52	@$(MAKE) -C build -f Makefile $(MAKECMDGOALS)
53	@if test "$(MAKECMDGOALS)" = "distclean" && \
54	    test -e build/auto-created-by-configure ; \
55	then \
56	    rm -rf build GNUmakefile ; \
57	fi
58force: ;
59.PHONY: force
60GNUmakefile: ;
61
62EOF
63    cd build
64    exec "$source_path/configure" "$@"
65fi
66
67# Temporary directory used for files created while
68# configure runs. Since it is in the build directory
69# we can safely blow away any previous version of it
70# (and we need not jump through hoops to try to delete
71# it when configure exits.)
72TMPDIR1="config-temp"
73rm -rf "${TMPDIR1}"
74if ! mkdir -p "${TMPDIR1}"; then
75    echo "ERROR: failed to create temporary directory"
76    exit 1
77fi
78
79TMPB="qemu-conf"
80TMPC="${TMPDIR1}/${TMPB}.c"
81TMPO="${TMPDIR1}/${TMPB}.o"
82TMPM="${TMPDIR1}/${TMPB}.m"
83TMPE="${TMPDIR1}/${TMPB}.exe"
84
85rm -f config.log
86
87# Print a helpful header at the top of config.log
88echo "# QEMU configure log $(date)" >> config.log
89printf "# Configured with:" >> config.log
90# repeat the invocation to log and stdout for CI
91invoke=$(printf " '%s'" "$0" "$@")
92test -n "$GITLAB_CI" && echo "configuring with: $invoke"
93{ echo "$invoke"; echo; echo "#"; } >> config.log
94
95quote_sh() {
96    printf "%s" "$1" | sed "s,','\\\\'',g; s,.*,'&',"
97}
98
99print_error() {
100    (echo
101    echo "ERROR: $1"
102    while test -n "$2"; do
103        echo "       $2"
104        shift
105    done
106    echo) >&2
107}
108
109error_exit() {
110    print_error "$@"
111    exit 1
112}
113
114do_compiler() {
115  # Run the compiler, capturing its output to the log. First argument
116  # is compiler binary to execute.
117  compiler="$1"
118  shift
119  if test -n "$BASH_VERSION"; then eval '
120      echo >>config.log "
121funcs: ${FUNCNAME[*]}
122lines: ${BASH_LINENO[*]}"
123  '; fi
124  echo $compiler "$@" >> config.log
125  $compiler "$@" >> config.log 2>&1 || return $?
126}
127
128do_compiler_werror() {
129    # Run the compiler, capturing its output to the log. First argument
130    # is compiler binary to execute.
131    compiler="$1"
132    shift
133    if test -n "$BASH_VERSION"; then eval '
134        echo >>config.log "
135funcs: ${FUNCNAME[*]}
136lines: ${BASH_LINENO[*]}"
137    '; fi
138    echo $compiler "$@" >> config.log
139    $compiler "$@" >> config.log 2>&1 || return $?
140    # Test passed. If this is an --enable-werror build, rerun
141    # the test with -Werror and bail out if it fails. This
142    # makes warning-generating-errors in configure test code
143    # obvious to developers.
144    if test "$werror" != "yes"; then
145        return 0
146    fi
147    # Don't bother rerunning the compile if we were already using -Werror
148    case "$*" in
149        *-Werror*)
150           return 0
151        ;;
152    esac
153    echo $compiler -Werror "$@" >> config.log
154    $compiler -Werror "$@" >> config.log 2>&1 && return $?
155    error_exit "configure test passed without -Werror but failed with -Werror." \
156        "This is probably a bug in the configure script. The failing command" \
157        "will be at the bottom of config.log." \
158        "You can run configure with --disable-werror to bypass this check."
159}
160
161do_cc() {
162    do_compiler_werror "$cc" $CPU_CFLAGS "$@"
163}
164
165do_objc() {
166    do_compiler_werror "$objcc" $CPU_CFLAGS "$@"
167}
168
169# Append $2 to the variable named $1, with space separation
170add_to() {
171    eval $1=\${$1:+\"\$$1 \"}\$2
172}
173
174compile_object() {
175  local_cflags="$1"
176  do_cc $CFLAGS $EXTRA_CFLAGS $CONFIGURE_CFLAGS $QEMU_CFLAGS $local_cflags -c -o $TMPO $TMPC
177}
178
179compile_prog() {
180  local_cflags="$1"
181  local_ldflags="$2"
182  do_cc $CFLAGS $EXTRA_CFLAGS $CONFIGURE_CFLAGS $QEMU_CFLAGS $local_cflags -o $TMPE $TMPC \
183      $LDFLAGS $EXTRA_LDFLAGS $CONFIGURE_LDFLAGS $QEMU_LDFLAGS $local_ldflags
184}
185
186# symbolically link $1 to $2.  Portable version of "ln -sf".
187symlink() {
188  rm -rf "$2"
189  mkdir -p "$(dirname "$2")"
190  ln -s "$1" "$2"
191}
192
193# check whether a command is available to this shell (may be either an
194# executable or a builtin)
195has() {
196    type "$1" >/dev/null 2>&1
197}
198
199version_ge () {
200    local_ver1=$(expr "$1" : '\([0-9.]*\)' | tr . ' ')
201    local_ver2=$(echo "$2" | tr . ' ')
202    while true; do
203        set x $local_ver1
204        local_first=${2-0}
205        # 'shift 2' if $2 is set, or 'shift' if $2 is not set
206        shift ${2:+2}
207        local_ver1=$*
208        set x $local_ver2
209        # the second argument finished, the first must be greater or equal
210        test $# = 1 && return 0
211        test $local_first -lt $2 && return 1
212        test $local_first -gt $2 && return 0
213        shift ${2:+2}
214        local_ver2=$*
215    done
216}
217
218if printf %s\\n "$source_path" "$PWD" | grep -q "[[:space:]:]";
219then
220  error_exit "main directory cannot contain spaces nor colons"
221fi
222
223# default parameters
224cpu=""
225static="no"
226cross_compile="no"
227cross_prefix=""
228host_cc="cc"
229stack_protector=""
230safe_stack=""
231use_containers="yes"
232gdb_bin=$(command -v "gdb-multiarch" || command -v "gdb")
233gdb_arches=""
234glib_has_gslice="no"
235
236if test -e "$source_path/.git"
237then
238    git_submodules_action="update"
239else
240    git_submodules_action="ignore"
241fi
242
243git_submodules="ui/keycodemapdb"
244git="git"
245
246# Don't accept a target_list environment variable.
247unset target_list
248unset target_list_exclude
249
250# Default value for a variable defining feature "foo".
251#  * foo="no"  feature will only be used if --enable-foo arg is given
252#  * foo=""    feature will be searched for, and if found, will be used
253#              unless --disable-foo is given
254#  * foo="yes" this value will only be set by --enable-foo flag.
255#              feature will searched for,
256#              if not found, configure exits with error
257#
258# Always add --enable-foo and --disable-foo command line args.
259# Distributions want to ensure that several features are compiled in, and it
260# is impossible without a --enable-foo that exits if a feature is not found.
261
262default_feature=""
263# parse CC options second
264for opt do
265  optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
266  case "$opt" in
267      --without-default-features)
268          default_feature="no"
269  ;;
270  esac
271done
272
273EXTRA_CFLAGS=""
274EXTRA_CXXFLAGS=""
275EXTRA_OBJCFLAGS=""
276EXTRA_LDFLAGS=""
277
278debug_tcg="no"
279sanitizers="no"
280tsan="no"
281fortify_source="yes"
282EXESUF=""
283modules="no"
284prefix="/usr/local"
285qemu_suffix="qemu"
286softmmu="yes"
287linux_user=""
288bsd_user=""
289pie=""
290coroutine=""
291plugins="$default_feature"
292meson=""
293ninja=""
294bindir="bin"
295skip_meson=no
296vfio_user_server="disabled"
297
298# The following Meson options are handled manually (still they
299# are included in the automatically generated help message)
300
301# 1. Track which submodules are needed
302fdt="auto"
303
304# 2. Automatically enable/disable other options
305tcg="auto"
306cfi="false"
307
308# parse CC options second
309for opt do
310  optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
311  case "$opt" in
312  --cross-prefix=*) cross_prefix="$optarg"
313                    cross_compile="yes"
314  ;;
315  --cc=*) CC="$optarg"
316  ;;
317  --cxx=*) CXX="$optarg"
318  ;;
319  --objcc=*) objcc="$optarg"
320  ;;
321  --cpu=*) cpu="$optarg"
322  ;;
323  --extra-cflags=*)
324    EXTRA_CFLAGS="$EXTRA_CFLAGS $optarg"
325    EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $optarg"
326    EXTRA_OBJCFLAGS="$EXTRA_OBJCFLAGS $optarg"
327    ;;
328  --extra-cxxflags=*) EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $optarg"
329  ;;
330  --extra-objcflags=*) EXTRA_OBJCFLAGS="$EXTRA_OBJCFLAGS $optarg"
331  ;;
332  --extra-ldflags=*) EXTRA_LDFLAGS="$EXTRA_LDFLAGS $optarg"
333  ;;
334  --cross-cc-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --cross-cc-FOO option"
335  ;;
336  --cross-cc-cflags-*) cc_arch=${opt#--cross-cc-cflags-}; cc_arch=${cc_arch%%=*}
337                      eval "cross_cc_cflags_${cc_arch}=\$optarg"
338  ;;
339  --cross-cc-*) cc_arch=${opt#--cross-cc-}; cc_arch=${cc_arch%%=*}
340                eval "cross_cc_${cc_arch}=\$optarg"
341  ;;
342  --cross-prefix-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --cross-prefix-FOO option"
343  ;;
344  --cross-prefix-*) cc_arch=${opt#--cross-prefix-}; cc_arch=${cc_arch%%=*}
345                    eval "cross_prefix_${cc_arch}=\$optarg"
346  ;;
347  esac
348done
349
350# Preferred compiler:
351#  ${CC} (if set)
352#  ${cross_prefix}gcc (if cross-prefix specified)
353#  system compiler
354if test -z "${CC}${cross_prefix}"; then
355  cc="$host_cc"
356else
357  cc="${CC-${cross_prefix}gcc}"
358fi
359
360if test -z "${CXX}${cross_prefix}"; then
361  cxx="c++"
362else
363  cxx="${CXX-${cross_prefix}g++}"
364fi
365
366# Preferred ObjC compiler:
367# $objcc (if set, i.e. via --objcc option)
368# ${cross_prefix}clang (if cross-prefix specified)
369# clang (if available)
370# $cc
371if test -z "${objcc}${cross_prefix}"; then
372  if has clang; then
373    objcc=clang
374  else
375    objcc="$cc"
376  fi
377else
378  objcc="${objcc-${cross_prefix}clang}"
379fi
380
381ar="${AR-${cross_prefix}ar}"
382as="${AS-${cross_prefix}as}"
383ccas="${CCAS-$cc}"
384objcopy="${OBJCOPY-${cross_prefix}objcopy}"
385ld="${LD-${cross_prefix}ld}"
386ranlib="${RANLIB-${cross_prefix}ranlib}"
387nm="${NM-${cross_prefix}nm}"
388smbd="$SMBD"
389strip="${STRIP-${cross_prefix}strip}"
390widl="${WIDL-${cross_prefix}widl}"
391windres="${WINDRES-${cross_prefix}windres}"
392windmc="${WINDMC-${cross_prefix}windmc}"
393pkg_config_exe="${PKG_CONFIG-${cross_prefix}pkg-config}"
394query_pkg_config() {
395    "${pkg_config_exe}" ${QEMU_PKG_CONFIG_FLAGS} "$@"
396}
397pkg_config=query_pkg_config
398sdl2_config="${SDL2_CONFIG-${cross_prefix}sdl2-config}"
399
400# default flags for all hosts
401# We use -fwrapv to tell the compiler that we require a C dialect where
402# left shift of signed integers is well defined and has the expected
403# 2s-complement style results. (Both clang and gcc agree that it
404# provides these semantics.)
405QEMU_CFLAGS="-fno-strict-aliasing -fno-common -fwrapv"
406QEMU_CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE $QEMU_CFLAGS"
407
408QEMU_LDFLAGS=
409
410# Flags that are needed during configure but later taken care of by Meson
411CONFIGURE_CFLAGS="-std=gnu11 -Wall"
412CONFIGURE_LDFLAGS=
413
414
415check_define() {
416cat > $TMPC <<EOF
417#if !defined($1)
418#error $1 not defined
419#endif
420int main(void) { return 0; }
421EOF
422  compile_object
423}
424
425check_include() {
426cat > $TMPC <<EOF
427#include <$1>
428int main(void) { return 0; }
429EOF
430  compile_object
431}
432
433write_c_skeleton() {
434    cat > $TMPC <<EOF
435int main(void) { return 0; }
436EOF
437}
438
439if check_define __linux__ ; then
440  targetos=linux
441elif check_define _WIN32 ; then
442  targetos=windows
443elif check_define __OpenBSD__ ; then
444  targetos=openbsd
445elif check_define __sun__ ; then
446  targetos=sunos
447elif check_define __HAIKU__ ; then
448  targetos=haiku
449elif check_define __FreeBSD__ ; then
450  targetos=freebsd
451elif check_define __FreeBSD_kernel__ && check_define __GLIBC__; then
452  targetos=gnu/kfreebsd
453elif check_define __DragonFly__ ; then
454  targetos=dragonfly
455elif check_define __NetBSD__; then
456  targetos=netbsd
457elif check_define __APPLE__; then
458  targetos=darwin
459else
460  # This is a fatal error, but don't report it yet, because we
461  # might be going to just print the --help text, or it might
462  # be the result of a missing compiler.
463  targetos=bogus
464fi
465
466# OS specific
467
468mingw32="no"
469bsd="no"
470linux="no"
471solaris="no"
472case $targetos in
473windows)
474  mingw32="yes"
475  plugins="no"
476  pie="no"
477;;
478gnu/kfreebsd)
479  bsd="yes"
480;;
481freebsd)
482  bsd="yes"
483  make="${MAKE-gmake}"
484  # needed for kinfo_getvmmap(3) in libutil.h
485;;
486dragonfly)
487  bsd="yes"
488  make="${MAKE-gmake}"
489;;
490netbsd)
491  bsd="yes"
492  make="${MAKE-gmake}"
493;;
494openbsd)
495  bsd="yes"
496  make="${MAKE-gmake}"
497;;
498darwin)
499  bsd="yes"
500  darwin="yes"
501  # Disable attempts to use ObjectiveC features in os/object.h since they
502  # won't work when we're compiling with gcc as a C compiler.
503  QEMU_CFLAGS="-DOS_OBJECT_USE_OBJC=0 $QEMU_CFLAGS"
504;;
505sunos)
506  solaris="yes"
507  make="${MAKE-gmake}"
508# needed for CMSG_ macros in sys/socket.h
509  QEMU_CFLAGS="-D_XOPEN_SOURCE=600 $QEMU_CFLAGS"
510# needed for TIOCWIN* defines in termios.h
511  QEMU_CFLAGS="-D__EXTENSIONS__ $QEMU_CFLAGS"
512;;
513haiku)
514  pie="no"
515  QEMU_CFLAGS="-DB_USE_POSITIVE_POSIX_ERRORS -D_BSD_SOURCE -fPIC $QEMU_CFLAGS"
516;;
517linux)
518  linux="yes"
519;;
520esac
521
522if test ! -z "$cpu" ; then
523  # command line argument
524  :
525elif check_define __i386__ ; then
526  cpu="i386"
527elif check_define __x86_64__ ; then
528  if check_define __ILP32__ ; then
529    cpu="x32"
530  else
531    cpu="x86_64"
532  fi
533elif check_define __sparc__ ; then
534  if check_define __arch64__ ; then
535    cpu="sparc64"
536  else
537    cpu="sparc"
538  fi
539elif check_define _ARCH_PPC ; then
540  if check_define _ARCH_PPC64 ; then
541    if check_define _LITTLE_ENDIAN ; then
542      cpu="ppc64le"
543    else
544      cpu="ppc64"
545    fi
546  else
547    cpu="ppc"
548  fi
549elif check_define __mips__ ; then
550  cpu="mips"
551elif check_define __s390__ ; then
552  if check_define __s390x__ ; then
553    cpu="s390x"
554  else
555    cpu="s390"
556  fi
557elif check_define __riscv ; then
558  cpu="riscv"
559elif check_define __arm__ ; then
560  cpu="arm"
561elif check_define __aarch64__ ; then
562  cpu="aarch64"
563elif check_define __loongarch64 ; then
564  cpu="loongarch64"
565else
566  # Using uname is really broken, but it is just a fallback for architectures
567  # that are going to use TCI anyway
568  cpu=$(uname -m)
569  echo "WARNING: unrecognized host CPU, proceeding with 'uname -m' output '$cpu'"
570fi
571
572# Normalise host CPU name and set multilib cflags.  The canonicalization
573# isn't really necessary, because the architectures that we check for
574# should not hit the 'uname -m' case, but better safe than sorry.
575# Note that this case should only have supported host CPUs, not guests.
576case "$cpu" in
577  armv*b|armv*l|arm)
578    cpu="arm" ;;
579
580  i386|i486|i586|i686)
581    cpu="i386"
582    CPU_CFLAGS="-m32" ;;
583  x32)
584    cpu="x86_64"
585    CPU_CFLAGS="-mx32" ;;
586  x86_64|amd64)
587    cpu="x86_64"
588    # ??? Only extremely old AMD cpus do not have cmpxchg16b.
589    # If we truly care, we should simply detect this case at
590    # runtime and generate the fallback to serial emulation.
591    CPU_CFLAGS="-m64 -mcx16" ;;
592
593  mips*)
594    cpu="mips" ;;
595
596  ppc)
597    CPU_CFLAGS="-m32" ;;
598  ppc64)
599    CPU_CFLAGS="-m64 -mbig-endian" ;;
600  ppc64le)
601    cpu="ppc64"
602    CPU_CFLAGS="-m64 -mlittle-endian" ;;
603
604  s390)
605    CPU_CFLAGS="-m31" ;;
606  s390x)
607    CPU_CFLAGS="-m64" ;;
608
609  sparc|sun4[cdmuv])
610    cpu="sparc"
611    CPU_CFLAGS="-m32 -mv8plus -mcpu=ultrasparc" ;;
612  sparc64)
613    CPU_CFLAGS="-m64 -mcpu=ultrasparc" ;;
614esac
615
616: ${make=${MAKE-make}}
617
618
619check_py_version() {
620    # We require python >= 3.6.
621    # NB: a True python conditional creates a non-zero return code (Failure)
622    "$1" -c 'import sys; sys.exit(sys.version_info < (3,6))'
623}
624
625python=
626first_python=
627if test -z "${PYTHON}"; then
628    explicit_python=no
629    # A bare 'python' is traditionally python 2.x, but some distros
630    # have it as python 3.x, so check in both places.
631    for binary in python3 python python3.11 python3.10 python3.9 python3.8 python3.7 python3.6; do
632        if has "$binary"; then
633            python=$(command -v "$binary")
634            if check_py_version "$python"; then
635                # This one is good.
636                first_python=
637                break
638            else
639                first_python=$python
640            fi
641        fi
642    done
643else
644    # Same as above, but only check the environment variable.
645    has "${PYTHON}" || error_exit "The PYTHON environment variable does not point to an executable"
646    python=$(command -v "$PYTHON")
647    explicit_python=yes
648    if check_py_version "$python"; then
649        # This one is good.
650        first_python=
651    else
652        first_python=$first_python
653    fi
654fi
655
656# Check for ancillary tools used in testing
657genisoimage=
658for binary in genisoimage mkisofs
659do
660    if has $binary
661    then
662        genisoimage=$(command -v "$binary")
663        break
664    fi
665done
666
667if test "$mingw32" = "yes" ; then
668  EXESUF=".exe"
669  # MinGW needs -mthreads for TLS and macro _MT.
670  CONFIGURE_CFLAGS="-mthreads $CONFIGURE_CFLAGS"
671  prefix="/qemu"
672  bindir=""
673  qemu_suffix=""
674fi
675
676werror=""
677
678meson_option_build_array() {
679  printf '['
680  (if test "$targetos" = windows; then
681    IFS=\;
682  else
683    IFS=:
684  fi
685  for e in $1; do
686    printf '"""'
687    # backslash escape any '\' and '"' characters
688    printf "%s" "$e" | sed -e 's/\([\"]\)/\\\1/g'
689    printf '""",'
690  done)
691  printf ']\n'
692}
693
694. "$source_path/scripts/meson-buildoptions.sh"
695
696meson_options=
697meson_option_add() {
698  meson_options="$meson_options $(quote_sh "$1")"
699}
700meson_option_parse() {
701  meson_options="$meson_options $(_meson_option_parse "$@")"
702  if test $? -eq 1; then
703    echo "ERROR: unknown option $1"
704    echo "Try '$0 --help' for more information"
705    exit 1
706  fi
707}
708
709for opt do
710  optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
711  case "$opt" in
712  --help|-h) show_help=yes
713  ;;
714  --version|-V) exec cat "$source_path/VERSION"
715  ;;
716  --prefix=*) prefix="$optarg"
717  ;;
718  --cross-prefix=*)
719  ;;
720  --cc=*)
721  ;;
722  --host-cc=*) host_cc="$optarg"
723  ;;
724  --cxx=*)
725  ;;
726  --objcc=*)
727  ;;
728  --make=*) make="$optarg"
729  ;;
730  --install=*)
731  ;;
732  --python=*) python="$optarg" ; explicit_python=yes
733  ;;
734  --skip-meson) skip_meson=yes
735  ;;
736  --meson=*) meson="$optarg"
737  ;;
738  --ninja=*) ninja="$optarg"
739  ;;
740  --smbd=*) smbd="$optarg"
741  ;;
742  --extra-cflags=*)
743  ;;
744  --extra-cxxflags=*)
745  ;;
746  --extra-objcflags=*)
747  ;;
748  --extra-ldflags=*)
749  ;;
750  --cross-cc-*)
751  ;;
752  --cross-prefix-*)
753  ;;
754  --enable-debug-info) meson_option_add -Ddebug=true
755  ;;
756  --disable-debug-info) meson_option_add -Ddebug=false
757  ;;
758  --enable-modules)
759      modules="yes"
760  ;;
761  --disable-modules)
762      modules="no"
763  ;;
764  --cpu=*)
765  ;;
766  --target-list=*) target_list="$optarg"
767                   if test "$target_list_exclude"; then
768                       error_exit "Can't mix --target-list with --target-list-exclude"
769                   fi
770  ;;
771  --target-list-exclude=*) target_list_exclude="$optarg"
772                   if test "$target_list"; then
773                       error_exit "Can't mix --target-list-exclude with --target-list"
774                   fi
775  ;;
776  --with-default-devices) meson_option_add -Ddefault_devices=true
777  ;;
778  --without-default-devices) meson_option_add -Ddefault_devices=false
779  ;;
780  --with-devices-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --with-devices-FOO option"
781  ;;
782  --with-devices-*) device_arch=${opt#--with-devices-};
783                    device_arch=${device_arch%%=*}
784                    cf=$source_path/configs/devices/$device_arch-softmmu/$optarg.mak
785                    if test -f "$cf"; then
786                        device_archs="$device_archs $device_arch"
787                        eval "devices_${device_arch}=\$optarg"
788                    else
789                        error_exit "File $cf does not exist"
790                    fi
791  ;;
792  --without-default-features) # processed above
793  ;;
794  --static)
795    static="yes"
796    QEMU_PKG_CONFIG_FLAGS="--static $QEMU_PKG_CONFIG_FLAGS"
797  ;;
798  --bindir=*) bindir="$optarg"
799  ;;
800  --with-suffix=*) qemu_suffix="$optarg"
801  ;;
802  --host=*|--build=*|\
803  --disable-dependency-tracking|\
804  --sbindir=*|--sharedstatedir=*|\
805  --oldincludedir=*|--datarootdir=*|--infodir=*|\
806  --htmldir=*|--dvidir=*|--pdfdir=*|--psdir=*)
807    # These switches are silently ignored, for compatibility with
808    # autoconf-generated configure scripts. This allows QEMU's
809    # configure to be used by RPM and similar macros that set
810    # lots of directory switches by default.
811  ;;
812  --enable-debug-tcg) debug_tcg="yes"
813  ;;
814  --disable-debug-tcg) debug_tcg="no"
815  ;;
816  --enable-debug)
817      # Enable debugging options that aren't excessively noisy
818      debug_tcg="yes"
819      meson_option_parse --enable-debug-graph-lock ""
820      meson_option_parse --enable-debug-mutex ""
821      meson_option_add -Doptimization=0
822      fortify_source="no"
823  ;;
824  --enable-sanitizers) sanitizers="yes"
825  ;;
826  --disable-sanitizers) sanitizers="no"
827  ;;
828  --enable-tsan) tsan="yes"
829  ;;
830  --disable-tsan) tsan="no"
831  ;;
832  --disable-tcg) tcg="disabled"
833                 plugins="no"
834  ;;
835  --enable-tcg) tcg="enabled"
836  ;;
837  --disable-system) softmmu="no"
838  ;;
839  --enable-system) softmmu="yes"
840  ;;
841  --disable-user)
842      linux_user="no" ;
843      bsd_user="no" ;
844  ;;
845  --enable-user) ;;
846  --disable-linux-user) linux_user="no"
847  ;;
848  --enable-linux-user) linux_user="yes"
849  ;;
850  --disable-bsd-user) bsd_user="no"
851  ;;
852  --enable-bsd-user) bsd_user="yes"
853  ;;
854  --enable-pie) pie="yes"
855  ;;
856  --disable-pie) pie="no"
857  ;;
858  --enable-werror) werror="yes"
859  ;;
860  --disable-werror) werror="no"
861  ;;
862  --enable-stack-protector) stack_protector="yes"
863  ;;
864  --disable-stack-protector) stack_protector="no"
865  ;;
866  --enable-safe-stack) safe_stack="yes"
867  ;;
868  --disable-safe-stack) safe_stack="no"
869  ;;
870  --enable-cfi)
871      cfi="true";
872      meson_option_add -Db_lto=true
873  ;;
874  --disable-cfi) cfi="false"
875  ;;
876  --disable-fdt) fdt="disabled"
877  ;;
878  --enable-fdt) fdt="enabled"
879  ;;
880  --enable-fdt=git) fdt="internal"
881  ;;
882  --enable-fdt=*) fdt="$optarg"
883  ;;
884  --with-coroutine=*) coroutine="$optarg"
885  ;;
886  --with-git=*) git="$optarg"
887  ;;
888  --with-git-submodules=*)
889      git_submodules_action="$optarg"
890  ;;
891  --enable-plugins) if test "$mingw32" = "yes"; then
892                        error_exit "TCG plugins not currently supported on Windows platforms"
893                    else
894                        plugins="yes"
895                    fi
896  ;;
897  --disable-plugins) plugins="no"
898  ;;
899  --enable-containers) use_containers="yes"
900  ;;
901  --disable-containers) use_containers="no"
902  ;;
903  --gdb=*) gdb_bin="$optarg"
904  ;;
905  --enable-vfio-user-server) vfio_user_server="enabled"
906  ;;
907  --disable-vfio-user-server) vfio_user_server="disabled"
908  ;;
909  # everything else has the same name in configure and meson
910  --*) meson_option_parse "$opt" "$optarg"
911  ;;
912  esac
913done
914
915# test for any invalid configuration combinations
916if test "$plugins" = "yes" -a "$tcg" = "disabled"; then
917    error_exit "Can't enable plugins on non-TCG builds"
918fi
919
920case $git_submodules_action in
921    update|validate)
922        if test ! -e "$source_path/.git"; then
923            echo "ERROR: cannot $git_submodules_action git submodules without .git"
924            exit 1
925        fi
926    ;;
927    ignore)
928        if ! test -f "$source_path/ui/keycodemapdb/README"
929        then
930            echo
931            echo "ERROR: missing GIT submodules"
932            echo
933            if test -e "$source_path/.git"; then
934                echo "--with-git-submodules=ignore specified but submodules were not"
935                echo "checked out.  Please initialize and update submodules."
936            else
937                echo "This is not a GIT checkout but module content appears to"
938                echo "be missing. Do not use 'git archive' or GitHub download links"
939                echo "to acquire QEMU source archives. Non-GIT builds are only"
940                echo "supported with source archives linked from:"
941                echo
942                echo "  https://www.qemu.org/download/#source"
943                echo
944                echo "Developers working with GIT can use scripts/archive-source.sh"
945                echo "if they need to create valid source archives."
946            fi
947            echo
948            exit 1
949        fi
950    ;;
951    *)
952        echo "ERROR: invalid --with-git-submodules= value '$git_submodules_action'"
953        exit 1
954    ;;
955esac
956
957default_target_list=""
958mak_wilds=""
959
960if [ "$linux_user" != no ]; then
961    if [ "$targetos" = linux ] && [ -d "$source_path/linux-user/include/host/$cpu" ]; then
962        linux_user=yes
963    elif [ "$linux_user" = yes ]; then
964        error_exit "linux-user not supported on this architecture"
965    fi
966fi
967if [ "$bsd_user" != no ]; then
968    if [ "$bsd_user" = "" ]; then
969        test $targetos = freebsd && bsd_user=yes
970    fi
971    if [ "$bsd_user" = yes ] && ! [ -d "$source_path/bsd-user/$targetos" ]; then
972        error_exit "bsd-user not supported on this host OS"
973    fi
974fi
975if [ "$softmmu" = "yes" ]; then
976    mak_wilds="${mak_wilds} $source_path/configs/targets/*-softmmu.mak"
977fi
978if [ "$linux_user" = "yes" ]; then
979    mak_wilds="${mak_wilds} $source_path/configs/targets/*-linux-user.mak"
980fi
981if [ "$bsd_user" = "yes" ]; then
982    mak_wilds="${mak_wilds} $source_path/configs/targets/*-bsd-user.mak"
983fi
984
985for config in $mak_wilds; do
986    target="$(basename "$config" .mak)"
987    if echo "$target_list_exclude" | grep -vq "$target"; then
988        default_target_list="${default_target_list} $target"
989    fi
990done
991
992if test x"$show_help" = x"yes" ; then
993cat << EOF
994
995Usage: configure [options]
996Options: [defaults in brackets after descriptions]
997
998Standard options:
999  --help                   print this message
1000  --prefix=PREFIX          install in PREFIX [$prefix]
1001  --target-list=LIST       set target list (default: build all)
1002$(echo Available targets: $default_target_list | \
1003  fold -s -w 53 | sed -e 's/^/                           /')
1004  --target-list-exclude=LIST exclude a set of targets from the default target-list
1005
1006Advanced options (experts only):
1007  --cross-prefix=PREFIX    use PREFIX for compile tools, PREFIX can be blank [$cross_prefix]
1008  --cc=CC                  use C compiler CC [$cc]
1009  --host-cc=CC             use C compiler CC [$host_cc] for code run at
1010                           build time
1011  --cxx=CXX                use C++ compiler CXX [$cxx]
1012  --objcc=OBJCC            use Objective-C compiler OBJCC [$objcc]
1013  --extra-cflags=CFLAGS    append extra C compiler flags CFLAGS
1014  --extra-cxxflags=CXXFLAGS append extra C++ compiler flags CXXFLAGS
1015  --extra-objcflags=OBJCFLAGS append extra Objective C compiler flags OBJCFLAGS
1016  --extra-ldflags=LDFLAGS  append extra linker flags LDFLAGS
1017  --cross-cc-ARCH=CC       use compiler when building ARCH guest test cases
1018  --cross-cc-cflags-ARCH=  use compiler flags when building ARCH guest tests
1019  --cross-prefix-ARCH=PREFIX cross compiler prefix when building ARCH guest test cases
1020  --make=MAKE              use specified make [$make]
1021  --python=PYTHON          use specified python [$python]
1022  --meson=MESON            use specified meson [$meson]
1023  --ninja=NINJA            use specified ninja [$ninja]
1024  --smbd=SMBD              use specified smbd [$smbd]
1025  --with-git=GIT           use specified git [$git]
1026  --with-git-submodules=update   update git submodules (default if .git dir exists)
1027  --with-git-submodules=validate fail if git submodules are not up to date
1028  --with-git-submodules=ignore   do not update or check git submodules (default if no .git dir)
1029  --static                 enable static build [$static]
1030  --bindir=PATH            install binaries in PATH
1031  --with-suffix=SUFFIX     suffix for QEMU data inside datadir/libdir/sysconfdir/docdir [$qemu_suffix]
1032  --without-default-features default all --enable-* options to "disabled"
1033  --without-default-devices  do not include any device that is not needed to
1034                           start the emulator (only use if you are including
1035                           desired devices in configs/devices/)
1036  --with-devices-ARCH=NAME override default configs/devices
1037  --enable-debug           enable common debug build options
1038  --enable-sanitizers      enable default sanitizers
1039  --enable-tsan            enable thread sanitizer
1040  --disable-werror         disable compilation abort on warning
1041  --disable-stack-protector disable compiler-provided stack protection
1042  --cpu=CPU                Build for host CPU [$cpu]
1043  --with-coroutine=BACKEND coroutine backend. Supported options:
1044                           ucontext, sigaltstack, windows
1045  --enable-plugins
1046                           enable plugins via shared library loading
1047  --disable-containers     don't use containers for cross-building
1048  --gdb=GDB-path           gdb to use for gdbstub tests [$gdb_bin]
1049EOF
1050  meson_options_help
1051cat << EOF
1052  system          all system emulation targets
1053  user            supported user emulation targets
1054  linux-user      all linux usermode emulation targets
1055  bsd-user        all BSD usermode emulation targets
1056  pie             Position Independent Executables
1057  modules         modules support (non-Windows)
1058  debug-tcg       TCG debugging (default is disabled)
1059  debug-info      debugging information
1060  safe-stack      SafeStack Stack Smash Protection. Depends on
1061                  clang/llvm and requires coroutine backend ucontext.
1062
1063NOTE: The object files are built at the place where configure is launched
1064EOF
1065exit 0
1066fi
1067
1068# Remove old dependency files to make sure that they get properly regenerated
1069rm -f ./*/config-devices.mak.d
1070
1071if test -z "$python"
1072then
1073    # If first_python is set, there was a binary somewhere even though
1074    # it was not suitable.  Use it for the error message.
1075    if test -n "$first_python"; then
1076        error_exit "Cannot use '$first_python', Python >= 3.6 is required." \
1077            "Use --python=/path/to/python to specify a supported Python."
1078    else
1079        error_exit "Python not found. Use --python=/path/to/python"
1080    fi
1081fi
1082
1083if ! has "$make"
1084then
1085    error_exit "GNU make ($make) not found"
1086fi
1087
1088if ! check_py_version "$python"; then
1089  error_exit "Cannot use '$python', Python >= 3.6 is required." \
1090      "Use --python=/path/to/python to specify a supported Python."
1091fi
1092
1093# Resolve PATH + suppress writing compiled files
1094python="$(command -v "$python") -B"
1095
1096has_meson() {
1097  local python_dir=$(dirname "$python")
1098  # PEP405: pyvenv.cfg is either adjacent to the Python executable
1099  # or one directory above
1100  if test -f $python_dir/pyvenv.cfg || test -f $python_dir/../pyvenv.cfg; then
1101    # Ensure that Meson and Python come from the same virtual environment
1102    test -x "$python_dir/meson" &&
1103      test "$(command -v meson)" -ef "$python_dir/meson"
1104  else
1105    has meson
1106  fi
1107}
1108
1109if test -z "$meson"; then
1110    if test "$explicit_python" = no && has_meson && version_ge "$(meson --version)" 0.61.5; then
1111        meson=meson
1112    elif test "$git_submodules_action" != 'ignore' ; then
1113        meson=git
1114    elif test -e "${source_path}/meson/meson.py" ; then
1115        meson=internal
1116    else
1117        if test "$explicit_python" = yes; then
1118            error_exit "--python requires using QEMU's embedded Meson distribution, but it was not found."
1119        else
1120            error_exit "Meson not found.  Use --meson=/path/to/meson"
1121        fi
1122    fi
1123else
1124    # Meson uses its own Python interpreter to invoke other Python scripts,
1125    # but the user wants to use the one they specified with --python.
1126    #
1127    # We do not want to override the distro Python interpreter (and sometimes
1128    # cannot: for example in Homebrew /usr/bin/meson is a bash script), so
1129    # just require --meson=git|internal together with --python.
1130    if test "$explicit_python" = yes; then
1131        case "$meson" in
1132            git | internal) ;;
1133            *) error_exit "--python requires using QEMU's embedded Meson distribution." ;;
1134        esac
1135    fi
1136fi
1137
1138if test "$meson" = git; then
1139    git_submodules="${git_submodules} meson"
1140fi
1141
1142case "$meson" in
1143    git | internal)
1144        meson="$python ${source_path}/meson/meson.py"
1145        ;;
1146    *) meson=$(command -v "$meson") ;;
1147esac
1148
1149# Probe for ninja
1150
1151if test -z "$ninja"; then
1152    for c in ninja ninja-build samu; do
1153        if has $c; then
1154            ninja=$(command -v "$c")
1155            break
1156        fi
1157    done
1158    if test -z "$ninja"; then
1159      error_exit "Cannot find Ninja"
1160    fi
1161fi
1162
1163# Check that the C compiler works. Doing this here before testing
1164# the host CPU ensures that we had a valid CC to autodetect the
1165# $cpu var (and we should bail right here if that's not the case).
1166# It also allows the help message to be printed without a CC.
1167write_c_skeleton;
1168if compile_object ; then
1169  : C compiler works ok
1170else
1171    error_exit "\"$cc\" either does not exist or does not work"
1172fi
1173if ! compile_prog ; then
1174    error_exit "\"$cc\" cannot build an executable (is your linker broken?)"
1175fi
1176
1177# Consult white-list to determine whether to enable werror
1178# by default.  Only enable by default for git builds
1179if test -z "$werror" ; then
1180    if test "$git_submodules_action" != "ignore" && \
1181        { test "$linux" = "yes" || test "$mingw32" = "yes"; }; then
1182        werror="yes"
1183    else
1184        werror="no"
1185    fi
1186fi
1187
1188if test "$targetos" = "bogus"; then
1189    # Now that we know that we're not printing the help and that
1190    # the compiler works (so the results of the check_defines we used
1191    # to identify the OS are reliable), if we didn't recognize the
1192    # host OS we should stop now.
1193    error_exit "Unrecognized host OS (uname -s reports '$(uname -s)')"
1194fi
1195
1196# Check whether the compiler matches our minimum requirements:
1197cat > $TMPC << EOF
1198#if defined(__clang_major__) && defined(__clang_minor__)
1199# ifdef __apple_build_version__
1200#  if __clang_major__ < 12 || (__clang_major__ == 12 && __clang_minor__ < 0)
1201#   error You need at least XCode Clang v12.0 to compile QEMU
1202#  endif
1203# else
1204#  if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)
1205#   error You need at least Clang v10.0 to compile QEMU
1206#  endif
1207# endif
1208#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
1209# if __GNUC__ < 7 || (__GNUC__ == 7 && __GNUC_MINOR__ < 4)
1210#  error You need at least GCC v7.4.0 to compile QEMU
1211# endif
1212#else
1213# error You either need GCC or Clang to compiler QEMU
1214#endif
1215int main (void) { return 0; }
1216EOF
1217if ! compile_prog "" "" ; then
1218    error_exit "You need at least GCC v7.4 or Clang v10.0 (or XCode Clang v12.0)"
1219fi
1220
1221# Accumulate -Wfoo and -Wno-bar separately.
1222# We will list all of the enable flags first, and the disable flags second.
1223# Note that we do not add -Werror, because that would enable it for all
1224# configure tests. If a configure test failed due to -Werror this would
1225# just silently disable some features, so it's too error prone.
1226
1227warn_flags=
1228add_to warn_flags -Wundef
1229add_to warn_flags -Wwrite-strings
1230add_to warn_flags -Wmissing-prototypes
1231add_to warn_flags -Wstrict-prototypes
1232add_to warn_flags -Wredundant-decls
1233add_to warn_flags -Wold-style-declaration
1234add_to warn_flags -Wold-style-definition
1235add_to warn_flags -Wtype-limits
1236add_to warn_flags -Wformat-security
1237add_to warn_flags -Wformat-y2k
1238add_to warn_flags -Winit-self
1239add_to warn_flags -Wignored-qualifiers
1240add_to warn_flags -Wempty-body
1241add_to warn_flags -Wnested-externs
1242add_to warn_flags -Wendif-labels
1243add_to warn_flags -Wexpansion-to-defined
1244add_to warn_flags -Wimplicit-fallthrough=2
1245add_to warn_flags -Wmissing-format-attribute
1246
1247if test "$targetos" != "darwin"; then
1248    add_to warn_flags -Wthread-safety
1249fi
1250
1251nowarn_flags=
1252add_to nowarn_flags -Wno-initializer-overrides
1253add_to nowarn_flags -Wno-missing-include-dirs
1254add_to nowarn_flags -Wno-shift-negative-value
1255add_to nowarn_flags -Wno-string-plus-int
1256add_to nowarn_flags -Wno-typedef-redefinition
1257add_to nowarn_flags -Wno-tautological-type-limit-compare
1258add_to nowarn_flags -Wno-psabi
1259add_to nowarn_flags -Wno-gnu-variable-sized-type-not-at-end
1260
1261gcc_flags="$warn_flags $nowarn_flags"
1262
1263cc_has_warning_flag() {
1264    write_c_skeleton;
1265
1266    # Use the positive sense of the flag when testing for -Wno-wombat
1267    # support (gcc will happily accept the -Wno- form of unknown
1268    # warning options).
1269    optflag="$(echo $1 | sed -e 's/^-Wno-/-W/')"
1270    compile_prog "-Werror $optflag" ""
1271}
1272
1273objcc_has_warning_flag() {
1274    cat > $TMPM <<EOF
1275int main(void) { return 0; }
1276EOF
1277
1278    # Use the positive sense of the flag when testing for -Wno-wombat
1279    # support (gcc will happily accept the -Wno- form of unknown
1280    # warning options).
1281    optflag="$(echo $1 | sed -e 's/^-Wno-/-W/')"
1282    do_objc -Werror $optflag \
1283      $OBJCFLAGS $EXTRA_OBJCFLAGS $CONFIGURE_OBJCFLAGS $QEMU_OBJCFLAGS \
1284      -o $TMPE $TMPM $QEMU_LDFLAGS
1285}
1286
1287for flag in $gcc_flags; do
1288    if cc_has_warning_flag $flag ; then
1289        QEMU_CFLAGS="$QEMU_CFLAGS $flag"
1290    fi
1291    if objcc_has_warning_flag $flag ; then
1292        QEMU_OBJCFLAGS="$QEMU_OBJCFLAGS $flag"
1293    fi
1294done
1295
1296if test "$stack_protector" != "no"; then
1297  cat > $TMPC << EOF
1298int main(int argc, char *argv[])
1299{
1300    char arr[64], *p = arr, *c = argv[argc - 1];
1301    while (*c) {
1302        *p++ = *c++;
1303    }
1304    return 0;
1305}
1306EOF
1307  gcc_flags="-fstack-protector-strong -fstack-protector-all"
1308  sp_on=0
1309  for flag in $gcc_flags; do
1310    # We need to check both a compile and a link, since some compiler
1311    # setups fail only on a .c->.o compile and some only at link time
1312    if compile_object "-Werror $flag" &&
1313       compile_prog "-Werror $flag" ""; then
1314      QEMU_CFLAGS="$QEMU_CFLAGS $flag"
1315      QEMU_LDFLAGS="$QEMU_LDFLAGS $flag"
1316      sp_on=1
1317      break
1318    fi
1319  done
1320  if test "$stack_protector" = yes; then
1321    if test $sp_on = 0; then
1322      error_exit "Stack protector not supported"
1323    fi
1324  fi
1325fi
1326
1327# Our module code doesn't support Windows
1328if test "$modules" = "yes" && test "$mingw32" = "yes" ; then
1329  error_exit "Modules are not available for Windows"
1330fi
1331
1332# Static linking is not possible with plugins, modules or PIE
1333if test "$static" = "yes" ; then
1334  if test "$modules" = "yes" ; then
1335    error_exit "static and modules are mutually incompatible"
1336  fi
1337  if test "$plugins" = "yes"; then
1338    error_exit "static and plugins are mutually incompatible"
1339  else
1340    plugins="no"
1341  fi
1342fi
1343test "$plugins" = "" && plugins=yes
1344
1345cat > $TMPC << EOF
1346
1347#ifdef __linux__
1348#  define THREAD __thread
1349#else
1350#  define THREAD
1351#endif
1352static THREAD int tls_var;
1353int main(void) { return tls_var; }
1354EOF
1355
1356# Meson currently only handles pie as a boolean for now so if we have
1357# explicitly disabled PIE we need to extend our cflags because it wont.
1358if test "$static" = "yes"; then
1359  if test "$pie" != "no" && compile_prog "-Werror -fPIE -DPIE" "-static-pie"; then
1360    CONFIGURE_CFLAGS="-fPIE -DPIE $CONFIGURE_CFLAGS"
1361    pie="yes"
1362  elif test "$pie" = "yes"; then
1363    error_exit "-static-pie not available due to missing toolchain support"
1364  else
1365    pie="no"
1366    QEMU_CFLAGS="-fno-pie $QEMU_CFLAGS"
1367  fi
1368elif test "$pie" = "no"; then
1369  if compile_prog "-Werror -fno-pie" "-no-pie"; then
1370    CONFIGURE_CFLAGS="-fno-pie $CONFIGURE_CFLAGS"
1371    CONFIGURE_LDFLAGS="-no-pie $CONFIGURE_LDFLAGS"
1372    QEMU_CFLAGS="-fno-pie -no-pie $QEMU_CFLAGS"
1373  fi
1374elif compile_prog "-Werror -fPIE -DPIE" "-pie"; then
1375  CONFIGURE_CFLAGS="-fPIE -DPIE $CONFIGURE_CFLAGS"
1376  CONFIGURE_LDFLAGS="-pie $CONFIGURE_LDFLAGS"
1377  pie="yes"
1378elif test "$pie" = "yes"; then
1379  error_exit "PIE not available due to missing toolchain support"
1380else
1381  echo "Disabling PIE due to missing toolchain support"
1382  pie="no"
1383fi
1384
1385##########################################
1386# __sync_fetch_and_and requires at least -march=i486. Many toolchains
1387# use i686 as default anyway, but for those that don't, an explicit
1388# specification is necessary
1389
1390if test "$cpu" = "i386"; then
1391  cat > $TMPC << EOF
1392static int sfaa(int *ptr)
1393{
1394  return __sync_fetch_and_and(ptr, 0);
1395}
1396
1397int main(void)
1398{
1399  int val = 42;
1400  val = __sync_val_compare_and_swap(&val, 0, 1);
1401  sfaa(&val);
1402  return val;
1403}
1404EOF
1405  if ! compile_prog "" "" ; then
1406    QEMU_CFLAGS="-march=i486 $QEMU_CFLAGS"
1407  fi
1408fi
1409
1410if test -z "${target_list+xxx}" ; then
1411    default_targets=yes
1412    for target in $default_target_list; do
1413        target_list="$target_list $target"
1414    done
1415    target_list="${target_list# }"
1416else
1417    default_targets=no
1418    target_list=$(echo "$target_list" | sed -e 's/,/ /g')
1419    for target in $target_list; do
1420        # Check that we recognised the target name; this allows a more
1421        # friendly error message than if we let it fall through.
1422        case " $default_target_list " in
1423            *" $target "*)
1424                ;;
1425            *)
1426                error_exit "Unknown target name '$target'"
1427                ;;
1428        esac
1429    done
1430fi
1431
1432# see if system emulation was really requested
1433case " $target_list " in
1434  *"-softmmu "*) softmmu=yes
1435  ;;
1436  *) softmmu=no
1437  ;;
1438esac
1439
1440if test "$tcg" = "auto"; then
1441  if test -z "$target_list"; then
1442    tcg="disabled"
1443  else
1444    tcg="enabled"
1445  fi
1446fi
1447
1448if test "$tcg" = "enabled"; then
1449    git_submodules="$git_submodules tests/fp/berkeley-testfloat-3"
1450    git_submodules="$git_submodules tests/fp/berkeley-softfloat-3"
1451fi
1452
1453##########################################
1454# big/little endian test
1455cat > $TMPC << EOF
1456#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1457# error LITTLE
1458#endif
1459int main(void) { return 0; }
1460EOF
1461
1462if ! compile_prog ; then
1463  bigendian="no"
1464else
1465  cat > $TMPC << EOF
1466#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1467# error BIG
1468#endif
1469int main(void) { return 0; }
1470EOF
1471
1472  if ! compile_prog ; then
1473    bigendian="yes"
1474  else
1475    echo big/little test failed
1476    exit 1
1477  fi
1478fi
1479
1480##########################################
1481# pkg-config probe
1482
1483if ! has "$pkg_config_exe"; then
1484  error_exit "pkg-config binary '$pkg_config_exe' not found"
1485fi
1486
1487##########################################
1488# glib support probe
1489
1490# When bumping glib_req_ver, please check also whether we should increase
1491# the _WIN32_WINNT setting in osdep.h according to the value from glib
1492glib_req_ver=2.56
1493glib_modules=gthread-2.0
1494if test "$modules" = yes; then
1495    glib_modules="$glib_modules gmodule-export-2.0"
1496elif test "$plugins" = "yes"; then
1497    glib_modules="$glib_modules gmodule-no-export-2.0"
1498fi
1499
1500for i in $glib_modules; do
1501    if $pkg_config --atleast-version=$glib_req_ver $i; then
1502        glib_cflags=$($pkg_config --cflags $i)
1503        glib_libs=$($pkg_config --libs $i)
1504    else
1505        error_exit "glib-$glib_req_ver $i is required to compile QEMU"
1506    fi
1507done
1508
1509# Check whether glib has gslice, which we have to avoid for correctness.
1510# TODO: remove this check and the corresponding workaround (qtree) when
1511# the minimum supported glib is >= $glib_dropped_gslice_version.
1512glib_dropped_gslice_version=2.75.3
1513for i in $glib_modules; do
1514    if ! $pkg_config --atleast-version=$glib_dropped_gslice_version $i; then
1515        glib_has_gslice="yes"
1516	break
1517    fi
1518done
1519
1520glib_bindir="$($pkg_config --variable=bindir glib-2.0)"
1521if test -z "$glib_bindir" ; then
1522	glib_bindir="$($pkg_config --variable=prefix glib-2.0)"/bin
1523fi
1524
1525# This workaround is required due to a bug in pkg-config file for glib as it
1526# doesn't define GLIB_STATIC_COMPILATION for pkg-config --static
1527
1528if test "$static" = yes && test "$mingw32" = yes; then
1529    glib_cflags="-DGLIB_STATIC_COMPILATION $glib_cflags"
1530fi
1531
1532# Sanity check that the current size_t matches the
1533# size that glib thinks it should be. This catches
1534# problems on multi-arch where people try to build
1535# 32-bit QEMU while pointing at 64-bit glib headers
1536cat > $TMPC <<EOF
1537#include <glib.h>
1538#include <unistd.h>
1539
1540#define QEMU_BUILD_BUG_ON(x) \
1541  typedef char qemu_build_bug_on[(x)?-1:1] __attribute__((unused));
1542
1543int main(void) {
1544   QEMU_BUILD_BUG_ON(sizeof(size_t) != GLIB_SIZEOF_SIZE_T);
1545   return 0;
1546}
1547EOF
1548
1549if ! compile_prog "$glib_cflags" "$glib_libs" ; then
1550    error_exit "sizeof(size_t) doesn't match GLIB_SIZEOF_SIZE_T."\
1551               "You probably need to set PKG_CONFIG_LIBDIR"\
1552	       "to point to the right pkg-config files for your"\
1553	       "build target"
1554fi
1555
1556# Silence clang warnings triggered by glib < 2.57.2
1557cat > $TMPC << EOF
1558#include <glib.h>
1559typedef struct Foo {
1560    int i;
1561} Foo;
1562static void foo_free(Foo *f)
1563{
1564    g_free(f);
1565}
1566G_DEFINE_AUTOPTR_CLEANUP_FUNC(Foo, foo_free)
1567int main(void) { return 0; }
1568EOF
1569if ! compile_prog "$glib_cflags -Werror" "$glib_libs" ; then
1570    if cc_has_warning_flag "-Wno-unused-function"; then
1571        glib_cflags="$glib_cflags -Wno-unused-function"
1572        CONFIGURE_CFLAGS="$CONFIGURE_CFLAGS -Wno-unused-function"
1573    fi
1574fi
1575
1576##########################################
1577# fdt probe
1578
1579case "$fdt" in
1580  auto | enabled | internal)
1581    # Simpler to always update submodule, even if not needed.
1582    git_submodules="${git_submodules} dtc"
1583    ;;
1584esac
1585
1586##########################################
1587# check and set a backend for coroutine
1588
1589# We prefer ucontext, but it's not always possible. The fallback
1590# is sigcontext. On Windows the only valid backend is the Windows
1591# specific one.
1592
1593ucontext_works=no
1594if test "$darwin" != "yes"; then
1595  cat > $TMPC << EOF
1596#include <ucontext.h>
1597#ifdef __stub_makecontext
1598#error Ignoring glibc stub makecontext which will always fail
1599#endif
1600int main(void) { makecontext(0, 0, 0); return 0; }
1601EOF
1602  if compile_prog "" "" ; then
1603    ucontext_works=yes
1604  fi
1605fi
1606
1607if test "$coroutine" = ""; then
1608  if test "$mingw32" = "yes"; then
1609    coroutine=win32
1610  elif test "$ucontext_works" = "yes"; then
1611    coroutine=ucontext
1612  else
1613    coroutine=sigaltstack
1614  fi
1615else
1616  case $coroutine in
1617  windows)
1618    if test "$mingw32" != "yes"; then
1619      error_exit "'windows' coroutine backend only valid for Windows"
1620    fi
1621    # Unfortunately the user visible backend name doesn't match the
1622    # coroutine-*.c filename for this case, so we have to adjust it here.
1623    coroutine=win32
1624    ;;
1625  ucontext)
1626    if test "$ucontext_works" != "yes"; then
1627      error_exit "'ucontext' backend requested but makecontext not available"
1628    fi
1629    ;;
1630  sigaltstack)
1631    if test "$mingw32" = "yes"; then
1632      error_exit "only the 'windows' coroutine backend is valid for Windows"
1633    fi
1634    ;;
1635  *)
1636    error_exit "unknown coroutine backend $coroutine"
1637    ;;
1638  esac
1639fi
1640
1641##################################################
1642# SafeStack
1643
1644
1645if test "$safe_stack" = "yes"; then
1646cat > $TMPC << EOF
1647int main(void)
1648{
1649#if ! __has_feature(safe_stack)
1650#error SafeStack Disabled
1651#endif
1652    return 0;
1653}
1654EOF
1655  flag="-fsanitize=safe-stack"
1656  # Check that safe-stack is supported and enabled.
1657  if compile_prog "-Werror $flag" "$flag"; then
1658    # Flag needed both at compilation and at linking
1659    QEMU_CFLAGS="$QEMU_CFLAGS $flag"
1660    QEMU_LDFLAGS="$QEMU_LDFLAGS $flag"
1661  else
1662    error_exit "SafeStack not supported by your compiler"
1663  fi
1664  if test "$coroutine" != "ucontext"; then
1665    error_exit "SafeStack is only supported by the coroutine backend ucontext"
1666  fi
1667else
1668cat > $TMPC << EOF
1669int main(void)
1670{
1671#if defined(__has_feature)
1672#if __has_feature(safe_stack)
1673#error SafeStack Enabled
1674#endif
1675#endif
1676    return 0;
1677}
1678EOF
1679if test "$safe_stack" = "no"; then
1680  # Make sure that safe-stack is disabled
1681  if ! compile_prog "-Werror" ""; then
1682    # SafeStack was already enabled, try to explicitly remove the feature
1683    flag="-fno-sanitize=safe-stack"
1684    if ! compile_prog "-Werror $flag" "$flag"; then
1685      error_exit "Configure cannot disable SafeStack"
1686    fi
1687    QEMU_CFLAGS="$QEMU_CFLAGS $flag"
1688    QEMU_LDFLAGS="$QEMU_LDFLAGS $flag"
1689  fi
1690else # "$safe_stack" = ""
1691  # Set safe_stack to yes or no based on pre-existing flags
1692  if compile_prog "-Werror" ""; then
1693    safe_stack="no"
1694  else
1695    safe_stack="yes"
1696    if test "$coroutine" != "ucontext"; then
1697      error_exit "SafeStack is only supported by the coroutine backend ucontext"
1698    fi
1699  fi
1700fi
1701fi
1702
1703########################################
1704# check if ccache is interfering with
1705# semantic analysis of macros
1706
1707unset CCACHE_CPP2
1708ccache_cpp2=no
1709cat > $TMPC << EOF
1710static const int Z = 1;
1711#define fn() ({ Z; })
1712#define TAUT(X) ((X) == Z)
1713#define PAREN(X, Y) (X == Y)
1714#define ID(X) (X)
1715int main(void)
1716{
1717    int x = 0, y = 0;
1718    x = ID(x);
1719    x = fn();
1720    fn();
1721    if (PAREN(x, y)) return 0;
1722    if (TAUT(Z)) return 0;
1723    return 0;
1724}
1725EOF
1726
1727if ! compile_object "-Werror"; then
1728    ccache_cpp2=yes
1729fi
1730
1731#################################################
1732# clang does not support glibc + FORTIFY_SOURCE.
1733
1734if test "$fortify_source" != "no"; then
1735  if echo | $cc -dM -E - | grep __clang__ > /dev/null 2>&1 ; then
1736    fortify_source="no";
1737  elif test -n "$cxx" && has $cxx &&
1738       echo | $cxx -dM -E - | grep __clang__ >/dev/null 2>&1 ; then
1739    fortify_source="no";
1740  else
1741    fortify_source="yes"
1742  fi
1743fi
1744
1745##########################################
1746# checks for sanitizers
1747
1748have_asan=no
1749have_ubsan=no
1750have_asan_iface_h=no
1751have_asan_iface_fiber=no
1752
1753if test "$sanitizers" = "yes" ; then
1754  write_c_skeleton
1755  if compile_prog "$CPU_CFLAGS -Werror -fsanitize=address" ""; then
1756      have_asan=yes
1757  fi
1758
1759  # we could use a simple skeleton for flags checks, but this also
1760  # detect the static linking issue of ubsan, see also:
1761  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84285
1762  cat > $TMPC << EOF
1763int main(int argc, char **argv)
1764{
1765    return argc + 1;
1766}
1767EOF
1768  if compile_prog "$CPU_CFLAGS -Werror -fsanitize=undefined" ""; then
1769      have_ubsan=yes
1770  fi
1771
1772  if check_include "sanitizer/asan_interface.h" ; then
1773      have_asan_iface_h=yes
1774  fi
1775
1776  cat > $TMPC << EOF
1777#include <sanitizer/asan_interface.h>
1778int main(void) {
1779  __sanitizer_start_switch_fiber(0, 0, 0);
1780  return 0;
1781}
1782EOF
1783  if compile_prog "$CPU_CFLAGS -Werror -fsanitize=address" "" ; then
1784      have_asan_iface_fiber=yes
1785  fi
1786fi
1787
1788# Thread sanitizer is, for now, much noisier than the other sanitizers;
1789# keep it separate until that is not the case.
1790if test "$tsan" = "yes" && test "$sanitizers" = "yes"; then
1791  error_exit "TSAN is not supported with other sanitiziers."
1792fi
1793have_tsan=no
1794have_tsan_iface_fiber=no
1795if test "$tsan" = "yes" ; then
1796  write_c_skeleton
1797  if compile_prog "$CPU_CFLAGS -Werror -fsanitize=thread" "" ; then
1798      have_tsan=yes
1799  fi
1800  cat > $TMPC << EOF
1801#include <sanitizer/tsan_interface.h>
1802int main(void) {
1803  __tsan_create_fiber(0);
1804  return 0;
1805}
1806EOF
1807  if compile_prog "$CPU_CFLAGS -Werror -fsanitize=thread" "" ; then
1808      have_tsan_iface_fiber=yes
1809  fi
1810fi
1811
1812##########################################
1813# functions to probe cross compilers
1814
1815container="no"
1816runc=""
1817if test $use_containers = "yes" && (has "docker" || has "podman"); then
1818    case $($python "$source_path"/tests/docker/docker.py probe) in
1819        *docker) container=docker ;;
1820        podman) container=podman ;;
1821        no) container=no ;;
1822    esac
1823    if test "$container" != "no"; then
1824        docker_py="$python $source_path/tests/docker/docker.py --engine $container"
1825        runc=$($python "$source_path"/tests/docker/docker.py probe)
1826    fi
1827fi
1828
1829# cross compilers defaults, can be overridden with --cross-cc-ARCH
1830: ${cross_prefix_aarch64="aarch64-linux-gnu-"}
1831: ${cross_prefix_aarch64_be="$cross_prefix_aarch64"}
1832: ${cross_prefix_alpha="alpha-linux-gnu-"}
1833: ${cross_prefix_arm="arm-linux-gnueabihf-"}
1834: ${cross_prefix_armeb="$cross_prefix_arm"}
1835: ${cross_prefix_hexagon="hexagon-unknown-linux-musl-"}
1836: ${cross_prefix_loongarch64="loongarch64-unknown-linux-gnu-"}
1837: ${cross_prefix_hppa="hppa-linux-gnu-"}
1838: ${cross_prefix_i386="i686-linux-gnu-"}
1839: ${cross_prefix_m68k="m68k-linux-gnu-"}
1840: ${cross_prefix_microblaze="microblaze-linux-musl-"}
1841: ${cross_prefix_mips64el="mips64el-linux-gnuabi64-"}
1842: ${cross_prefix_mips64="mips64-linux-gnuabi64-"}
1843: ${cross_prefix_mipsel="mipsel-linux-gnu-"}
1844: ${cross_prefix_mips="mips-linux-gnu-"}
1845: ${cross_prefix_nios2="nios2-linux-gnu-"}
1846: ${cross_prefix_ppc="powerpc-linux-gnu-"}
1847: ${cross_prefix_ppc64="powerpc64-linux-gnu-"}
1848: ${cross_prefix_ppc64le="$cross_prefix_ppc64"}
1849: ${cross_prefix_riscv64="riscv64-linux-gnu-"}
1850: ${cross_prefix_s390x="s390x-linux-gnu-"}
1851: ${cross_prefix_sh4="sh4-linux-gnu-"}
1852: ${cross_prefix_sparc64="sparc64-linux-gnu-"}
1853: ${cross_prefix_sparc="$cross_prefix_sparc64"}
1854: ${cross_prefix_x86_64="x86_64-linux-gnu-"}
1855
1856: ${cross_cc_aarch64_be="$cross_cc_aarch64"}
1857: ${cross_cc_cflags_aarch64_be="-mbig-endian"}
1858: ${cross_cc_armeb="$cross_cc_arm"}
1859: ${cross_cc_cflags_armeb="-mbig-endian"}
1860: ${cross_cc_hexagon="hexagon-unknown-linux-musl-clang"}
1861: ${cross_cc_cflags_hexagon="-mv73 -O2 -static"}
1862: ${cross_cc_cflags_i386="-m32"}
1863: ${cross_cc_cflags_ppc="-m32 -mbig-endian"}
1864: ${cross_cc_cflags_ppc64="-m64 -mbig-endian"}
1865: ${cross_cc_ppc64le="$cross_cc_ppc64"}
1866: ${cross_cc_cflags_ppc64le="-m64 -mlittle-endian"}
1867: ${cross_cc_cflags_sparc64="-m64 -mcpu=ultrasparc"}
1868: ${cross_cc_sparc="$cross_cc_sparc64"}
1869: ${cross_cc_cflags_sparc="-m32 -mcpu=supersparc"}
1870: ${cross_cc_cflags_x86_64="-m64"}
1871
1872compute_target_variable() {
1873  eval "$2="
1874  if eval test -n "\"\${cross_prefix_$1}\""; then
1875    if eval has "\"\${cross_prefix_$1}\$3\""; then
1876      eval "$2=\"\${cross_prefix_$1}\$3\""
1877    fi
1878  fi
1879}
1880
1881have_target() {
1882  for i; do
1883    case " $target_list " in
1884      *" $i "*) return 0;;
1885      *) ;;
1886    esac
1887  done
1888  return 1
1889}
1890
1891# probe_target_compiler TARGET
1892#
1893# Look for a compiler for the given target, either native or cross.
1894# Set variables target_* if a compiler is found, and container_cross_*
1895# if a Docker-based cross-compiler image is known for the target.
1896# Set got_cross_cc to yes/no depending on whether a non-container-based
1897# compiler was found.
1898#
1899# If TARGET is a user-mode emulation target, also set build_static to
1900# "y" if static linking is possible.
1901#
1902probe_target_compiler() {
1903  # reset all output variables
1904  got_cross_cc=no
1905  container_image=
1906  container_hosts=
1907  container_cross_cc=
1908  container_cross_ar=
1909  container_cross_as=
1910  container_cross_ld=
1911  container_cross_nm=
1912  container_cross_objcopy=
1913  container_cross_ranlib=
1914  container_cross_strip=
1915
1916  # We shall skip configuring the target compiler if the user didn't
1917  # bother enabling an appropriate guest. This avoids building
1918  # extraneous firmware images and tests.
1919  if test "${target_list#*$1}" = "$1"; then
1920      return 1
1921  fi
1922
1923  target_arch=${1%%-*}
1924  case $target_arch in
1925    aarch64) container_hosts="x86_64 aarch64" ;;
1926    alpha) container_hosts=x86_64 ;;
1927    arm) container_hosts="x86_64 aarch64" ;;
1928    cris) container_hosts=x86_64 ;;
1929    hexagon) container_hosts=x86_64 ;;
1930    hppa) container_hosts=x86_64 ;;
1931    i386) container_hosts=x86_64 ;;
1932    loongarch64) container_hosts=x86_64 ;;
1933    m68k) container_hosts=x86_64 ;;
1934    microblaze) container_hosts=x86_64 ;;
1935    mips64el) container_hosts=x86_64 ;;
1936    mips64) container_hosts=x86_64 ;;
1937    mipsel) container_hosts=x86_64 ;;
1938    mips) container_hosts=x86_64 ;;
1939    nios2) container_hosts=x86_64 ;;
1940    ppc) container_hosts=x86_64 ;;
1941    ppc64|ppc64le) container_hosts=x86_64 ;;
1942    riscv64) container_hosts=x86_64 ;;
1943    s390x) container_hosts=x86_64 ;;
1944    sh4) container_hosts=x86_64 ;;
1945    sparc64) container_hosts=x86_64 ;;
1946    tricore) container_hosts=x86_64 ;;
1947    x86_64) container_hosts="aarch64 ppc64el x86_64" ;;
1948    xtensa*) container_hosts=x86_64 ;;
1949  esac
1950
1951  for host in $container_hosts; do
1952    test "$container" != no || continue
1953    test "$host" = "$cpu" || continue
1954    case $target_arch in
1955      aarch64)
1956        # We don't have any bigendian build tools so we only use this for AArch64
1957        container_image=debian-arm64-cross
1958        container_cross_prefix=aarch64-linux-gnu-
1959        container_cross_cc=${container_cross_prefix}gcc-10
1960        ;;
1961      alpha)
1962        container_image=debian-alpha-cross
1963        container_cross_prefix=alpha-linux-gnu-
1964        ;;
1965      arm)
1966        # We don't have any bigendian build tools so we only use this for ARM
1967        container_image=debian-armhf-cross
1968        container_cross_prefix=arm-linux-gnueabihf-
1969        ;;
1970      cris)
1971        container_image=fedora-cris-cross
1972        container_cross_prefix=cris-linux-gnu-
1973        ;;
1974      hexagon)
1975        container_image=debian-hexagon-cross
1976        container_cross_prefix=hexagon-unknown-linux-musl-
1977        container_cross_cc=${container_cross_prefix}clang
1978        ;;
1979      hppa)
1980        container_image=debian-hppa-cross
1981        container_cross_prefix=hppa-linux-gnu-
1982        ;;
1983      i386)
1984        container_image=fedora-i386-cross
1985        container_cross_prefix=
1986        ;;
1987      loongarch64)
1988        container_image=debian-loongarch-cross
1989        container_cross_prefix=loongarch64-unknown-linux-gnu-
1990        ;;
1991      m68k)
1992        container_image=debian-m68k-cross
1993        container_cross_prefix=m68k-linux-gnu-
1994        ;;
1995      microblaze)
1996        container_image=debian-microblaze-cross
1997        container_cross_prefix=microblaze-linux-musl-
1998        ;;
1999      mips64el)
2000        container_image=debian-mips64el-cross
2001        container_cross_prefix=mips64el-linux-gnuabi64-
2002        ;;
2003      mips64)
2004        container_image=debian-mips64-cross
2005        container_cross_prefix=mips64-linux-gnuabi64-
2006        ;;
2007      mipsel)
2008        container_image=debian-mipsel-cross
2009        container_cross_prefix=mipsel-linux-gnu-
2010        ;;
2011      mips)
2012        container_image=debian-mips-cross
2013        container_cross_prefix=mips-linux-gnu-
2014        ;;
2015      nios2)
2016        container_image=debian-nios2-cross
2017        container_cross_prefix=nios2-linux-gnu-
2018        ;;
2019      ppc)
2020        container_image=debian-powerpc-test-cross
2021        container_cross_prefix=powerpc-linux-gnu-
2022        container_cross_cc=${container_cross_prefix}gcc-10
2023        ;;
2024      ppc64|ppc64le)
2025        container_image=debian-powerpc-test-cross
2026        container_cross_prefix=powerpc${target_arch#ppc}-linux-gnu-
2027        container_cross_cc=${container_cross_prefix}gcc-10
2028        ;;
2029      riscv64)
2030        container_image=debian-riscv64-test-cross
2031        container_cross_prefix=riscv64-linux-gnu-
2032        ;;
2033      s390x)
2034        container_image=debian-s390x-cross
2035        container_cross_prefix=s390x-linux-gnu-
2036        ;;
2037      sh4)
2038        container_image=debian-sh4-cross
2039        container_cross_prefix=sh4-linux-gnu-
2040        ;;
2041      sparc64)
2042        container_image=debian-sparc64-cross
2043        container_cross_prefix=sparc64-linux-gnu-
2044        ;;
2045      tricore)
2046        container_image=debian-tricore-cross
2047        container_cross_prefix=tricore-
2048        container_cross_as=tricore-as
2049        container_cross_ld=tricore-ld
2050        break
2051        ;;
2052      x86_64)
2053        container_image=debian-amd64-cross
2054        container_cross_prefix=x86_64-linux-gnu-
2055        ;;
2056      xtensa*)
2057        container_hosts=x86_64
2058        container_image=debian-xtensa-cross
2059
2060        # default to the dc232b cpu
2061        container_cross_prefix=/opt/2020.07/xtensa-dc232b-elf/bin/xtensa-dc232b-elf-
2062        ;;
2063    esac
2064    : ${container_cross_cc:=${container_cross_prefix}gcc}
2065    : ${container_cross_ar:=${container_cross_prefix}ar}
2066    : ${container_cross_as:=${container_cross_prefix}as}
2067    : ${container_cross_ld:=${container_cross_prefix}ld}
2068    : ${container_cross_nm:=${container_cross_prefix}nm}
2069    : ${container_cross_objcopy:=${container_cross_prefix}objcopy}
2070    : ${container_cross_ranlib:=${container_cross_prefix}ranlib}
2071    : ${container_cross_strip:=${container_cross_prefix}strip}
2072  done
2073
2074  try=cross
2075  case "$target_arch:$cpu" in
2076    aarch64_be:aarch64 | \
2077    armeb:arm | \
2078    i386:x86_64 | \
2079    mips*:mips64 | \
2080    ppc*:ppc64 | \
2081    sparc:sparc64 | \
2082    "$cpu:$cpu")
2083      try='native cross' ;;
2084  esac
2085  eval "target_cflags=\${cross_cc_cflags_$target_arch}"
2086  for thistry in $try; do
2087    case $thistry in
2088    native)
2089      target_cc=$cc
2090      target_ccas=$ccas
2091      target_ar=$ar
2092      target_as=$as
2093      target_ld=$ld
2094      target_nm=$nm
2095      target_objcopy=$objcopy
2096      target_ranlib=$ranlib
2097      target_strip=$strip
2098      ;;
2099    cross)
2100      target_cc=
2101      if eval test -n "\"\${cross_cc_$target_arch}\""; then
2102        if eval has "\"\${cross_cc_$target_arch}\""; then
2103          eval "target_cc=\"\${cross_cc_$target_arch}\""
2104        fi
2105      else
2106        compute_target_variable $target_arch target_cc gcc
2107      fi
2108      target_ccas=$target_cc
2109      compute_target_variable $target_arch target_ar ar
2110      compute_target_variable $target_arch target_as as
2111      compute_target_variable $target_arch target_ld ld
2112      compute_target_variable $target_arch target_nm nm
2113      compute_target_variable $target_arch target_objcopy objcopy
2114      compute_target_variable $target_arch target_ranlib ranlib
2115      compute_target_variable $target_arch target_strip strip
2116      ;;
2117    esac
2118
2119    if test -n "$target_cc"; then
2120      case $target_arch in
2121        i386|x86_64)
2122          if $target_cc --version | grep -qi "clang"; then
2123            continue
2124          fi
2125          ;;
2126      esac
2127    elif test -n "$target_as" && test -n "$target_ld"; then
2128      # Special handling for assembler only targets
2129      case $target in
2130        tricore-softmmu)
2131          build_static=
2132          got_cross_cc=yes
2133          break
2134          ;;
2135        *)
2136          continue
2137          ;;
2138      esac
2139    else
2140      continue
2141    fi
2142
2143    write_c_skeleton
2144    case $1 in
2145      *-softmmu)
2146        if do_compiler "$target_cc" $target_cflags -o $TMPO -c $TMPC &&
2147          do_compiler "$target_cc" $target_cflags -r -nostdlib -o "${TMPDIR1}/${TMPB}2.o" "$TMPO" -lgcc; then
2148          got_cross_cc=yes
2149          break
2150        fi
2151        ;;
2152      *)
2153        if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC -static ; then
2154          build_static=y
2155          got_cross_cc=yes
2156          break
2157        fi
2158        if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC ; then
2159          build_static=
2160          got_cross_cc=yes
2161          break
2162        fi
2163        ;;
2164    esac
2165  done
2166  if test $got_cross_cc != yes; then
2167    build_static=
2168    target_cc=
2169    target_ccas=
2170    target_ar=
2171    target_as=
2172    target_ld=
2173    target_nm=
2174    target_objcopy=
2175    target_ranlib=
2176    target_strip=
2177  fi
2178  test -n "$target_cc"
2179}
2180
2181write_target_makefile() {
2182  echo "EXTRA_CFLAGS=$target_cflags"
2183  if test -z "$target_cc" && test -z "$target_as"; then
2184    test -z "$container_image" && error_exit "Internal error: could not find cross compiler for $1?"
2185    echo "$1: docker-image-$container_image" >> Makefile.prereqs
2186    if test -n "$container_cross_cc"; then
2187      echo "CC=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
2188      echo "CCAS=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
2189    fi
2190    echo "AR=$docker_py cc --cc $container_cross_ar -i qemu/$container_image -s $source_path --"
2191    echo "AS=$docker_py cc --cc $container_cross_as -i qemu/$container_image -s $source_path --"
2192    echo "LD=$docker_py cc --cc $container_cross_ld -i qemu/$container_image -s $source_path --"
2193    echo "NM=$docker_py cc --cc $container_cross_nm -i qemu/$container_image -s $source_path --"
2194    echo "OBJCOPY=$docker_py cc --cc $container_cross_objcopy -i qemu/$container_image -s $source_path --"
2195    echo "RANLIB=$docker_py cc --cc $container_cross_ranlib -i qemu/$container_image -s $source_path --"
2196    echo "STRIP=$docker_py cc --cc $container_cross_strip -i qemu/$container_image -s $source_path --"
2197  else
2198    if test -n "$target_cc"; then
2199      echo "CC=$target_cc"
2200      echo "CCAS=$target_ccas"
2201    fi
2202    if test -n "$target_ar"; then
2203      echo "AR=$target_ar"
2204    fi
2205    if test -n "$target_as"; then
2206      echo "AS=$target_as"
2207    fi
2208    if test -n "$target_ld"; then
2209      echo "LD=$target_ld"
2210    fi
2211    if test -n "$target_nm"; then
2212      echo "NM=$target_nm"
2213    fi
2214    if test -n "$target_objcopy"; then
2215      echo "OBJCOPY=$target_objcopy"
2216    fi
2217    if test -n "$target_ranlib"; then
2218      echo "RANLIB=$target_ranlib"
2219    fi
2220    if test -n "$target_strip"; then
2221      echo "STRIP=$target_strip"
2222    fi
2223  fi
2224}
2225
2226##########################################
2227# check for vfio_user_server
2228
2229case "$vfio_user_server" in
2230  enabled )
2231    if test "$git_submodules_action" != "ignore"; then
2232      git_submodules="${git_submodules} subprojects/libvfio-user"
2233    fi
2234    ;;
2235esac
2236
2237##########################################
2238# End of CC checks
2239# After here, no more $cc or $ld runs
2240
2241write_c_skeleton
2242
2243if test "$fortify_source" = "yes" ; then
2244  QEMU_CFLAGS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 $QEMU_CFLAGS"
2245fi
2246
2247if test "$have_asan" = "yes"; then
2248  QEMU_CFLAGS="-fsanitize=address $QEMU_CFLAGS"
2249  QEMU_LDFLAGS="-fsanitize=address $QEMU_LDFLAGS"
2250  if test "$have_asan_iface_h" = "no" ; then
2251      echo "ASAN build enabled, but ASAN header missing." \
2252           "Without code annotation, the report may be inferior."
2253  elif test "$have_asan_iface_fiber" = "no" ; then
2254      echo "ASAN build enabled, but ASAN header is too old." \
2255           "Without code annotation, the report may be inferior."
2256  fi
2257fi
2258if test "$have_tsan" = "yes" ; then
2259  if test "$have_tsan_iface_fiber" = "yes" ; then
2260    QEMU_CFLAGS="-fsanitize=thread $QEMU_CFLAGS"
2261    QEMU_LDFLAGS="-fsanitize=thread $QEMU_LDFLAGS"
2262  else
2263    error_exit "Cannot enable TSAN due to missing fiber annotation interface."
2264  fi
2265elif test "$tsan" = "yes" ; then
2266  error_exit "Cannot enable TSAN due to missing sanitize thread interface."
2267fi
2268if test "$have_ubsan" = "yes"; then
2269  QEMU_CFLAGS="-fsanitize=undefined $QEMU_CFLAGS"
2270  QEMU_LDFLAGS="-fsanitize=undefined $QEMU_LDFLAGS"
2271fi
2272
2273#######################################
2274# cross-compiled firmware targets
2275
2276# Set up build tree symlinks that point back into the source tree
2277# (these can be both files and directories).
2278# Caution: avoid adding files or directories here using wildcards. This
2279# will result in problems later if a new file matching the wildcard is
2280# added to the source tree -- nothing will cause configure to be rerun
2281# so the build tree will be missing the link back to the new file, and
2282# tests might fail. Prefer to keep the relevant files in their own
2283# directory and symlink the directory instead.
2284LINKS="Makefile"
2285LINKS="$LINKS docs/config"
2286LINKS="$LINKS pc-bios/optionrom/Makefile"
2287LINKS="$LINKS pc-bios/s390-ccw/Makefile"
2288LINKS="$LINKS pc-bios/vof/Makefile"
2289LINKS="$LINKS .gdbinit scripts" # scripts needed by relative path in .gdbinit
2290LINKS="$LINKS tests/avocado tests/data"
2291LINKS="$LINKS tests/qemu-iotests/check"
2292LINKS="$LINKS python"
2293LINKS="$LINKS contrib/plugins/Makefile "
2294for f in $LINKS ; do
2295    if [ -e "$source_path/$f" ]; then
2296        mkdir -p "$(dirname ./"$f")"
2297        symlink "$source_path/$f" "$f"
2298    fi
2299done
2300
2301echo "# Automatically generated by configure - do not modify" > Makefile.prereqs
2302
2303# Mac OS X ships with a broken assembler
2304roms=
2305if have_target i386-softmmu x86_64-softmmu && \
2306        test "$targetos" != "darwin" && test "$targetos" != "sunos" && \
2307        test "$targetos" != "haiku" && \
2308        probe_target_compiler i386-softmmu; then
2309    roms="pc-bios/optionrom"
2310    config_mak=pc-bios/optionrom/config.mak
2311    echo "# Automatically generated by configure - do not modify" > $config_mak
2312    echo "TOPSRC_DIR=$source_path" >> $config_mak
2313    write_target_makefile >> $config_mak
2314fi
2315
2316if have_target ppc-softmmu ppc64-softmmu && \
2317        probe_target_compiler ppc-softmmu; then
2318    roms="$roms pc-bios/vof"
2319    config_mak=pc-bios/vof/config.mak
2320    echo "# Automatically generated by configure - do not modify" > $config_mak
2321    echo "SRC_DIR=$source_path/pc-bios/vof" >> $config_mak
2322    write_target_makefile >> $config_mak
2323fi
2324
2325# Only build s390-ccw bios if the compiler has -march=z900 or -march=z10
2326# (which is the lowest architecture level that Clang supports)
2327if have_target s390x-softmmu && probe_target_compiler s390x-softmmu; then
2328  write_c_skeleton
2329  do_compiler "$target_cc" $target_cc_cflags -march=z900 -o $TMPO -c $TMPC
2330  has_z900=$?
2331  if [ $has_z900 = 0 ] || do_compiler "$target_cc" $target_cc_cflags -march=z10 -msoft-float -Werror -o $TMPO -c $TMPC; then
2332    if [ $has_z900 != 0 ]; then
2333      echo "WARNING: Your compiler does not support the z900!"
2334      echo "         The s390-ccw bios will only work with guest CPUs >= z10."
2335    fi
2336    roms="$roms pc-bios/s390-ccw"
2337    config_mak=pc-bios/s390-ccw/config-host.mak
2338    echo "# Automatically generated by configure - do not modify" > $config_mak
2339    echo "SRC_PATH=$source_path/pc-bios/s390-ccw" >> $config_mak
2340    write_target_makefile >> $config_mak
2341    # SLOF is required for building the s390-ccw firmware on s390x,
2342    # since it is using the libnet code from SLOF for network booting.
2343    git_submodules="${git_submodules} roms/SLOF"
2344  fi
2345fi
2346
2347#######################################
2348# generate config-host.mak
2349
2350if ! (GIT="$git" "$source_path/scripts/git-submodule.sh" "$git_submodules_action" "$git_submodules"); then
2351    exit 1
2352fi
2353
2354config_host_mak="config-host.mak"
2355
2356echo "# Automatically generated by configure - do not modify" > $config_host_mak
2357echo >> $config_host_mak
2358
2359echo all: >> $config_host_mak
2360echo "GIT=$git" >> $config_host_mak
2361echo "GIT_SUBMODULES=$git_submodules" >> $config_host_mak
2362echo "GIT_SUBMODULES_ACTION=$git_submodules_action" >> $config_host_mak
2363
2364if test "$debug_tcg" = "yes" ; then
2365  echo "CONFIG_DEBUG_TCG=y" >> $config_host_mak
2366fi
2367if test "$mingw32" = "yes" ; then
2368  echo "CONFIG_WIN32=y" >> $config_host_mak
2369  echo "QEMU_GA_MANUFACTURER=${QEMU_GA_MANUFACTURER-QEMU}" >> $config_host_mak
2370  echo "QEMU_GA_DISTRO=${QEMU_GA_DISTRO-Linux}" >> $config_host_mak
2371  echo "QEMU_GA_VERSION=${QEMU_GA_VERSION-$(cat "$source_path"/VERSION)}" >> $config_host_mak
2372else
2373  echo "CONFIG_POSIX=y" >> $config_host_mak
2374fi
2375
2376if test "$linux" = "yes" ; then
2377  echo "CONFIG_LINUX=y" >> $config_host_mak
2378fi
2379
2380if test "$darwin" = "yes" ; then
2381  echo "CONFIG_DARWIN=y" >> $config_host_mak
2382fi
2383
2384if test "$solaris" = "yes" ; then
2385  echo "CONFIG_SOLARIS=y" >> $config_host_mak
2386fi
2387if test "$static" = "yes" ; then
2388  echo "CONFIG_STATIC=y" >> $config_host_mak
2389fi
2390echo "SRC_PATH=$source_path" >> $config_host_mak
2391echo "TARGET_DIRS=$target_list" >> $config_host_mak
2392if test "$modules" = "yes"; then
2393  echo "CONFIG_MODULES=y" >> $config_host_mak
2394fi
2395
2396# XXX: suppress that
2397if [ "$bsd" = "yes" ] ; then
2398  echo "CONFIG_BSD=y" >> $config_host_mak
2399fi
2400
2401echo "CONFIG_COROUTINE_BACKEND=$coroutine" >> $config_host_mak
2402
2403if test "$have_asan_iface_fiber" = "yes" ; then
2404    echo "CONFIG_ASAN_IFACE_FIBER=y" >> $config_host_mak
2405fi
2406
2407if test "$have_tsan" = "yes" && test "$have_tsan_iface_fiber" = "yes" ; then
2408    echo "CONFIG_TSAN=y" >> $config_host_mak
2409fi
2410
2411if test "$plugins" = "yes" ; then
2412    echo "CONFIG_PLUGIN=y" >> $config_host_mak
2413fi
2414
2415if test -n "$gdb_bin"; then
2416    gdb_version=$($gdb_bin --version | head -n 1)
2417    if version_ge ${gdb_version##* } 9.1; then
2418        echo "HAVE_GDB_BIN=$gdb_bin" >> $config_host_mak
2419        gdb_arches=$("$source_path/scripts/probe-gdb-support.py" $gdb_bin)
2420    else
2421        gdb_bin=""
2422    fi
2423fi
2424
2425if test "$container" != no; then
2426    echo "ENGINE=$container" >> $config_host_mak
2427    echo "RUNC=$runc" >> $config_host_mak
2428fi
2429echo "ROMS=$roms" >> $config_host_mak
2430echo "MAKE=$make" >> $config_host_mak
2431echo "PYTHON=$python" >> $config_host_mak
2432echo "GENISOIMAGE=$genisoimage" >> $config_host_mak
2433echo "MESON=$meson" >> $config_host_mak
2434echo "NINJA=$ninja" >> $config_host_mak
2435echo "CC=$cc" >> $config_host_mak
2436echo "QEMU_CFLAGS=$QEMU_CFLAGS" >> $config_host_mak
2437echo "QEMU_OBJCFLAGS=$QEMU_OBJCFLAGS" >> $config_host_mak
2438echo "GLIB_CFLAGS=$glib_cflags" >> $config_host_mak
2439echo "GLIB_LIBS=$glib_libs" >> $config_host_mak
2440echo "GLIB_BINDIR=$glib_bindir" >> $config_host_mak
2441echo "GLIB_VERSION=$($pkg_config --modversion glib-2.0)" >> $config_host_mak
2442if test "$glib_has_gslice" = "yes" ; then
2443    echo "HAVE_GLIB_WITH_SLICE_ALLOCATOR=y" >> $config_host_mak
2444fi
2445echo "QEMU_LDFLAGS=$QEMU_LDFLAGS" >> $config_host_mak
2446echo "EXESUF=$EXESUF" >> $config_host_mak
2447
2448# use included Linux headers
2449if test "$linux" = "yes" ; then
2450  mkdir -p linux-headers
2451  case "$cpu" in
2452  i386|x86_64)
2453    linux_arch=x86
2454    ;;
2455  ppc|ppc64)
2456    linux_arch=powerpc
2457    ;;
2458  s390x)
2459    linux_arch=s390
2460    ;;
2461  aarch64)
2462    linux_arch=arm64
2463    ;;
2464  loongarch*)
2465    linux_arch=loongarch
2466    ;;
2467  mips64)
2468    linux_arch=mips
2469    ;;
2470  *)
2471    # For most CPUs the kernel architecture name and QEMU CPU name match.
2472    linux_arch="$cpu"
2473    ;;
2474  esac
2475    # For non-KVM architectures we will not have asm headers
2476    if [ -e "$source_path/linux-headers/asm-$linux_arch" ]; then
2477      symlink "$source_path/linux-headers/asm-$linux_arch" linux-headers/asm
2478    fi
2479fi
2480
2481for target in $target_list; do
2482    target_dir="$target"
2483    target_name=$(echo $target | cut -d '-' -f 1)$EXESUF
2484    mkdir -p "$target_dir"
2485    case $target in
2486        *-user) symlink "../qemu-$target_name" "$target_dir/qemu-$target_name" ;;
2487        *) symlink "../qemu-system-$target_name" "$target_dir/qemu-system-$target_name" ;;
2488    esac
2489done
2490
2491if test "$default_targets" = "yes"; then
2492  echo "CONFIG_DEFAULT_TARGETS=y" >> $config_host_mak
2493fi
2494
2495if test "$ccache_cpp2" = "yes"; then
2496  echo "export CCACHE_CPP2=y" >> $config_host_mak
2497fi
2498
2499if test "$safe_stack" = "yes"; then
2500  echo "CONFIG_SAFESTACK=y" >> $config_host_mak
2501fi
2502
2503# tests/tcg configuration
2504(config_host_mak=tests/tcg/config-host.mak
2505mkdir -p tests/tcg
2506echo "# Automatically generated by configure - do not modify" > $config_host_mak
2507echo "SRC_PATH=$source_path" >> $config_host_mak
2508echo "HOST_CC=$host_cc" >> $config_host_mak
2509
2510# versioned checked in the main config_host.mak above
2511if test -n "$gdb_bin"; then
2512    echo "HAVE_GDB_BIN=$gdb_bin" >> $config_host_mak
2513fi
2514if test "$plugins" = "yes" ; then
2515    echo "CONFIG_PLUGIN=y" >> $config_host_mak
2516fi
2517
2518tcg_tests_targets=
2519for target in $target_list; do
2520  arch=${target%%-*}
2521
2522  case $target in
2523    xtensa*-linux-user)
2524      # the toolchain is not complete with headers, only build softmmu tests
2525      continue
2526      ;;
2527    *-softmmu)
2528      test -f "$source_path/tests/tcg/$arch/Makefile.softmmu-target" || continue
2529      qemu="qemu-system-$arch"
2530      ;;
2531    *-linux-user|*-bsd-user)
2532      qemu="qemu-$arch"
2533      ;;
2534  esac
2535
2536  if probe_target_compiler $target || test -n "$container_image"; then
2537      test -n "$container_image" && build_static=y
2538      mkdir -p "tests/tcg/$target"
2539      config_target_mak=tests/tcg/$target/config-target.mak
2540      ln -sf "$source_path/tests/tcg/Makefile.target" "tests/tcg/$target/Makefile"
2541      echo "# Automatically generated by configure - do not modify" > "$config_target_mak"
2542      echo "TARGET_NAME=$arch" >> "$config_target_mak"
2543      echo "TARGET=$target" >> "$config_target_mak"
2544      write_target_makefile "build-tcg-tests-$target" >> "$config_target_mak"
2545      echo "BUILD_STATIC=$build_static" >> "$config_target_mak"
2546      echo "QEMU=$PWD/$qemu" >> "$config_target_mak"
2547
2548      # will GDB work with these binaries?
2549      if test "${gdb_arches#*$arch}" != "$gdb_arches"; then
2550          echo "HOST_GDB_SUPPORTS_ARCH=y" >> "$config_target_mak"
2551      fi
2552
2553      echo "run-tcg-tests-$target: $qemu\$(EXESUF)" >> Makefile.prereqs
2554      tcg_tests_targets="$tcg_tests_targets $target"
2555  fi
2556done
2557
2558if test "$tcg" = "enabled"; then
2559    echo "TCG_TESTS_TARGETS=$tcg_tests_targets" >> config-host.mak
2560fi
2561)
2562
2563if test "$skip_meson" = no; then
2564  cross="config-meson.cross.new"
2565  meson_quote() {
2566    test $# = 0 && return
2567    echo "'$(echo $* | sed "s/ /','/g")'"
2568  }
2569
2570  echo "# Automatically generated by configure - do not modify" > $cross
2571  echo "[properties]" >> $cross
2572
2573  # unroll any custom device configs
2574  for a in $device_archs; do
2575      eval "c=\$devices_${a}"
2576      echo "${a}-softmmu = '$c'" >> $cross
2577  done
2578
2579  echo "[built-in options]" >> $cross
2580  echo "c_args = [$(meson_quote $CFLAGS $EXTRA_CFLAGS)]" >> $cross
2581  echo "cpp_args = [$(meson_quote $CXXFLAGS $EXTRA_CXXFLAGS)]" >> $cross
2582  test -n "$objcc" && echo "objc_args = [$(meson_quote $OBJCFLAGS $EXTRA_OBJCFLAGS)]" >> $cross
2583  echo "c_link_args = [$(meson_quote $CFLAGS $LDFLAGS $EXTRA_CFLAGS $EXTRA_LDFLAGS)]" >> $cross
2584  echo "cpp_link_args = [$(meson_quote $CXXFLAGS $LDFLAGS $EXTRA_CXXFLAGS $EXTRA_LDFLAGS)]" >> $cross
2585  echo "[binaries]" >> $cross
2586  echo "c = [$(meson_quote $cc $CPU_CFLAGS)]" >> $cross
2587  test -n "$cxx" && echo "cpp = [$(meson_quote $cxx $CPU_CFLAGS)]" >> $cross
2588  test -n "$objcc" && echo "objc = [$(meson_quote $objcc $CPU_CFLAGS)]" >> $cross
2589  echo "ar = [$(meson_quote $ar)]" >> $cross
2590  echo "nm = [$(meson_quote $nm)]" >> $cross
2591  echo "pkgconfig = [$(meson_quote $pkg_config_exe)]" >> $cross
2592  echo "ranlib = [$(meson_quote $ranlib)]" >> $cross
2593  if has $sdl2_config; then
2594    echo "sdl2-config = [$(meson_quote $sdl2_config)]" >> $cross
2595  fi
2596  echo "strip = [$(meson_quote $strip)]" >> $cross
2597  echo "widl = [$(meson_quote $widl)]" >> $cross
2598  echo "windres = [$(meson_quote $windres)]" >> $cross
2599  echo "windmc = [$(meson_quote $windmc)]" >> $cross
2600  if test "$cross_compile" = "yes"; then
2601    cross_arg="--cross-file config-meson.cross"
2602    echo "[host_machine]" >> $cross
2603    echo "system = '$targetos'" >> $cross
2604    case "$cpu" in
2605        i386)
2606            echo "cpu_family = 'x86'" >> $cross
2607            ;;
2608        *)
2609            echo "cpu_family = '$cpu'" >> $cross
2610            ;;
2611    esac
2612    echo "cpu = '$cpu'" >> $cross
2613    if test "$bigendian" = "yes" ; then
2614        echo "endian = 'big'" >> $cross
2615    else
2616        echo "endian = 'little'" >> $cross
2617    fi
2618  else
2619    cross_arg="--native-file config-meson.cross"
2620  fi
2621  mv $cross config-meson.cross
2622
2623  rm -rf meson-private meson-info meson-logs
2624
2625  # Prevent meson from automatically downloading wrapped subprojects when missing.
2626  # You can use 'meson subprojects download' before running configure.
2627  meson_option_add "--wrap-mode=nodownload"
2628
2629  # Built-in options
2630  test "$bindir" != "bin" && meson_option_add "-Dbindir=$bindir"
2631  test "$default_feature" = no && meson_option_add -Dauto_features=disabled
2632  test "$pie" = no && meson_option_add -Db_pie=false
2633  test "$werror" = yes && meson_option_add -Dwerror=true
2634
2635  # QEMU options
2636  test "$cfi" != false && meson_option_add "-Dcfi=$cfi"
2637  test "$fdt" != auto && meson_option_add "-Dfdt=$fdt"
2638  test -n "${LIB_FUZZING_ENGINE+xxx}" && meson_option_add "-Dfuzzing_engine=$LIB_FUZZING_ENGINE"
2639  test "$qemu_suffix" != qemu && meson_option_add "-Dqemu_suffix=$qemu_suffix"
2640  test "$smbd" != '' && meson_option_add "-Dsmbd=$smbd"
2641  test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
2642  test "$vfio_user_server" != auto && meson_option_add "-Dvfio_user_server=$vfio_user_server"
2643  run_meson() {
2644    NINJA=$ninja $meson setup --prefix "$prefix" "$@" $cross_arg "$PWD" "$source_path"
2645  }
2646  eval run_meson $meson_options
2647  if test "$?" -ne 0 ; then
2648      error_exit "meson setup failed"
2649  fi
2650fi
2651
2652# Save the configure command line for later reuse.
2653cat <<EOD >config.status
2654#!/bin/sh
2655# Generated by configure.
2656# Run this file to recreate the current configuration.
2657# Compiler output produced by configure, useful for debugging
2658# configure, is in config.log if it exists.
2659EOD
2660
2661preserve_env() {
2662    envname=$1
2663
2664    eval envval=\$$envname
2665
2666    if test -n "$envval"
2667    then
2668	echo "$envname='$envval'" >> config.status
2669	echo "export $envname" >> config.status
2670    else
2671	echo "unset $envname" >> config.status
2672    fi
2673}
2674
2675# Preserve various env variables that influence what
2676# features/build target configure will detect
2677preserve_env AR
2678preserve_env AS
2679preserve_env CC
2680preserve_env CFLAGS
2681preserve_env CXX
2682preserve_env CXXFLAGS
2683preserve_env LD
2684preserve_env LDFLAGS
2685preserve_env LD_LIBRARY_PATH
2686preserve_env MAKE
2687preserve_env NM
2688preserve_env OBJCFLAGS
2689preserve_env OBJCOPY
2690preserve_env PATH
2691preserve_env PKG_CONFIG
2692preserve_env PKG_CONFIG_LIBDIR
2693preserve_env PKG_CONFIG_PATH
2694preserve_env PYTHON
2695preserve_env QEMU_GA_MANUFACTURER
2696preserve_env QEMU_GA_DISTRO
2697preserve_env QEMU_GA_VERSION
2698preserve_env SDL2_CONFIG
2699preserve_env SMBD
2700preserve_env STRIP
2701preserve_env WIDL
2702preserve_env WINDRES
2703preserve_env WINDMC
2704
2705printf "exec" >>config.status
2706for i in "$0" "$@"; do
2707  test "$i" = --skip-meson || printf " %s" "$(quote_sh "$i")" >>config.status
2708done
2709echo ' "$@"' >>config.status
2710chmod +x config.status
2711
2712rm -r "$TMPDIR1"
2713