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