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