qemu

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.
8
unset 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!
11
export CCACHE_RECACHE=yes
12

13
# make source path absolute
14
source_path=$(cd "$(dirname -- "$0")"; pwd)
15

16
if test "$PWD" = "$source_path"
17
then
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

44
build:
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
55
GNUmakefile: ;
56

57
EOF
58
    cd build
59
    exec "$source_path/configure" "$@"
60
fi
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.)
67
TMPDIR1="config-temp"
68
rm -rf "${TMPDIR1}"
69
if ! mkdir -p "${TMPDIR1}"; then
70
    echo "ERROR: failed to create temporary directory"
71
    exit 1
72
fi
73

74
TMPB="qemu-conf"
75
TMPC="${TMPDIR1}/${TMPB}.c"
76
TMPO="${TMPDIR1}/${TMPB}.o"
77
TMPE="${TMPDIR1}/${TMPB}.exe"
78

79
rm -f config.log
80

81
# Print a helpful header at the top of config.log
82
echo "# QEMU configure log $(date)" >> config.log
83
printf "# Configured with:" >> config.log
84
# repeat the invocation to log and stdout for CI
85
invoke=$(printf " '%s'" "$0" "$@")
86
test -n "$GITLAB_CI" && echo "configuring with: $invoke"
87
{ echo "$invoke"; echo; echo "#"; } >> config.log
88

89
quote_sh() {
90
    printf "%s" "$1" | sed "s,','\\\\'',g; s,.*,'&',"
91
}
92

93
error_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

104
do_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 "
111
funcs: ${FUNCNAME[*]}
112
lines: ${BASH_LINENO[*]}"
113
  '; fi
114
  echo $compiler "$@" >> config.log
115
  $compiler "$@" >> config.log 2>&1 || return $?
116
}
117

118
do_cc() {
119
    do_compiler "$cc" $CPU_CFLAGS "$@"
120
}
121

122
compile_object() {
123
  local_cflags="$1"
124
  do_cc $CFLAGS $EXTRA_CFLAGS $local_cflags -c -o $TMPO $TMPC
125
}
126

127
compile_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".
135
symlink() {
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)
143
has() {
144
    type "$1" >/dev/null 2>&1
145
}
146

147
version_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

166
if printf %s\\n "$source_path" "$PWD" | grep -q "[[:space:]:]";
167
then
168
  error_exit "main directory cannot contain spaces nor colons"
169
fi
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
175
container_engine="auto"
176
cpu=""
177
cross_compile="no"
178
cross_prefix=""
179
host_cc="cc"
180
EXTRA_CFLAGS=""
181
EXTRA_CXXFLAGS=""
182
EXTRA_OBJCFLAGS=""
183
EXTRA_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.
196
default_feature=""
197

198
for 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
239
done
240

241
default_cflags='-O2 -g'
242
git_submodules_action="update"
243
docs="auto"
244
EXESUF=""
245
system="yes"
246
linux_user=""
247
bsd_user=""
248
plugins="$default_feature"
249
subdirs=""
250
ninja=""
251
python=
252
download="enabled"
253
skip_meson=no
254
use_containers="yes"
255
gdb_bin=$(command -v "gdb-multiarch" || command -v "gdb")
256
gdb_arches=""
257

258
# Don't accept a target_list environment variable.
259
unset target_list
260
unset 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
265
tcg="auto"
266
cfi="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.
271
pie=""
272
static="no"
273

274
# Preferred compiler:
275
#  ${CC} (if set)
276
#  ${cross_prefix}gcc (if cross-prefix specified)
277
#  system compiler
278
if test -z "${CC}${cross_prefix}"; then
279
  cc="cc"
280
else
281
  cc="${CC-${cross_prefix}gcc}"
282
fi
283

284
if test -z "${CXX}${cross_prefix}"; then
285
  cxx="c++"
286
else
287
  cxx="${CXX-${cross_prefix}g++}"
288
fi
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
295
if test -z "${objcc}${cross_prefix}"; then
296
  if has clang; then
297
    objcc=clang
298
  else
299
    objcc="$cc"
300
  fi
301
else
302
  objcc="${objcc-${cross_prefix}clang}"
303
fi
304

305
ar="${AR-${cross_prefix}ar}"
306
as="${AS-${cross_prefix}as}"
307
ccas="${CCAS-$cc}"
308
dlltool="${DLLTOOL-${cross_prefix}dlltool}"
309
objcopy="${OBJCOPY-${cross_prefix}objcopy}"
310
ld="${LD-${cross_prefix}ld}"
311
ranlib="${RANLIB-${cross_prefix}ranlib}"
312
nm="${NM-${cross_prefix}nm}"
313
strip="${STRIP-${cross_prefix}strip}"
314
widl="${WIDL-${cross_prefix}widl}"
315
windres="${WINDRES-${cross_prefix}windres}"
316
windmc="${WINDMC-${cross_prefix}windmc}"
317
pkg_config="${PKG_CONFIG-${cross_prefix}pkg-config}"
318
sdl2_config="${SDL2_CONFIG-${cross_prefix}sdl2-config}"
319

320
check_define() {
321
cat > $TMPC <<EOF
322
#if !defined($1)
323
#error $1 not defined
324
#endif
325
int main(void) { return 0; }
326
EOF
327
  compile_object
328
}
329

330
write_c_skeleton() {
331
    cat > $TMPC <<EOF
332
int main(void) { return 0; }
333
EOF
334
}
335

336
if check_define __linux__ ; then
337
  host_os=linux
338
elif check_define _WIN32 ; then
339
  host_os=windows
340
elif check_define __OpenBSD__ ; then
341
  host_os=openbsd
342
elif check_define __sun__ ; then
343
  host_os=sunos
344
elif check_define __HAIKU__ ; then
345
  host_os=haiku
346
elif check_define __FreeBSD__ ; then
347
  host_os=freebsd
348
elif check_define __FreeBSD_kernel__ && check_define __GLIBC__; then
349
  host_os=gnu/kfreebsd
350
elif check_define __DragonFly__ ; then
351
  host_os=dragonfly
352
elif check_define __NetBSD__; then
353
  host_os=netbsd
354
elif check_define __APPLE__; then
355
  host_os=darwin
356
else
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
361
fi
362

363
if test ! -z "$cpu" ; then
364
  # command line argument
365
  :
366
elif check_define __i386__ ; then
367
  cpu="i386"
368
elif check_define __x86_64__ ; then
369
  if check_define __ILP32__ ; then
370
    cpu="x32"
371
  else
372
    cpu="x86_64"
373
  fi
374
elif check_define __sparc__ ; then
375
  if check_define __arch64__ ; then
376
    cpu="sparc64"
377
  else
378
    cpu="sparc"
379
  fi
380
elif 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
390
elif check_define __mips__ ; then
391
  cpu="mips"
392
elif check_define __s390__ ; then
393
  if check_define __s390x__ ; then
394
    cpu="s390x"
395
  else
396
    cpu="s390"
397
  fi
398
elif check_define __riscv ; then
399
  if check_define _LP64 ; then
400
    cpu="riscv64"
401
  else
402
    cpu="riscv32"
403
  fi
404
elif check_define __arm__ ; then
405
  cpu="arm"
406
elif check_define __aarch64__ ; then
407
  cpu="aarch64"
408
elif check_define __loongarch64 ; then
409
  cpu="loongarch64"
410
else
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
  if test "$host_os" != "bogus"; then
415
    echo "WARNING: unrecognized host CPU, proceeding with 'uname -m' output '$cpu'"
416
  fi
417
fi
418

419
# Normalise host CPU name to the values used by Meson cross files and in source
420
# directories, and set multilib cflags.  The canonicalization isn't really
421
# necessary, because the architectures that we check for should not hit the
422
# 'uname -m' case, but better safe than sorry in case --cpu= is used.
423
#
424
# Note that this case should only have supported host CPUs, not guests.
425
# Please keep it sorted and synchronized with meson.build's host_arch.
426
host_arch=
427
linux_arch=
428
case "$cpu" in
429
  aarch64)
430
    host_arch=aarch64
431
    linux_arch=arm64
432
    ;;
433

434
  armv*b|armv*l|arm)
435
    cpu=arm
436
    host_arch=arm
437
    linux_arch=arm
438
    ;;
439

440
  i386|i486|i586|i686)
441
    cpu="i386"
442
    host_arch=i386
443
    linux_arch=x86
444
    CPU_CFLAGS="-m32"
445
    ;;
446

447
  loongarch*)
448
    cpu=loongarch64
449
    host_arch=loongarch64
450
    linux_arch=loongarch
451
    ;;
452

453
  mips64*|mipsisa64*)
454
    cpu=mips64
455
    host_arch=mips
456
    linux_arch=mips
457
    ;;
458
  mips*)
459
    cpu=mips
460
    host_arch=mips
461
    linux_arch=mips
462
    ;;
463

464
  ppc)
465
    host_arch=ppc
466
    linux_arch=powerpc
467
    CPU_CFLAGS="-m32"
468
    ;;
469
  ppc64)
470
    host_arch=ppc64
471
    linux_arch=powerpc
472
    CPU_CFLAGS="-m64 -mbig-endian"
473
    ;;
474
  ppc64le)
475
    cpu=ppc64
476
    host_arch=ppc64
477
    linux_arch=powerpc
478
    CPU_CFLAGS="-m64 -mlittle-endian"
479
    ;;
480

481
  riscv32 | riscv64)
482
    host_arch=riscv
483
    linux_arch=riscv
484
    ;;
485

486
  s390)
487
    linux_arch=s390
488
    CPU_CFLAGS="-m31"
489
    ;;
490
  s390x)
491
    host_arch=s390x
492
    linux_arch=s390
493
    CPU_CFLAGS="-m64"
494
    ;;
495

496
  sparc|sun4[cdmuv])
497
    cpu=sparc
498
    CPU_CFLAGS="-m32 -mv8plus -mcpu=ultrasparc"
499
    ;;
500
  sparc64)
501
    host_arch=sparc64
502
    CPU_CFLAGS="-m64 -mcpu=ultrasparc"
503
    ;;
504

505
  x32)
506
    cpu="x86_64"
507
    host_arch=x86_64
508
    linux_arch=x86
509
    CPU_CFLAGS="-mx32"
510
    ;;
511
  x86_64|amd64)
512
    cpu="x86_64"
513
    host_arch=x86_64
514
    linux_arch=x86
515
    CPU_CFLAGS="-m64"
516
    ;;
517
esac
518

519
if test -n "$host_arch" && {
520
    ! test -d "$source_path/linux-user/include/host/$host_arch" ||
521
    ! test -d "$source_path/common-user/host/$host_arch"; }; then
522
    error_exit "linux-user/include/host/$host_arch does not exist." \
523
       "This is a bug in the configure script, please report it."
524
fi
525
if test -n "$linux_arch" && ! test -d "$source_path/linux-headers/asm-$linux_arch"; then
526
    error_exit "linux-headers/asm-$linux_arch does not exist." \
527
       "This is a bug in the configure script, please report it."
528
fi
529

530
check_py_version() {
531
    # We require python >= 3.8.
532
    # NB: a True python conditional creates a non-zero return code (Failure)
533
    "$1" -c 'import sys; sys.exit(sys.version_info < (3,8))'
534
}
535

536
first_python=
537
if test -z "${PYTHON}"; then
538
    # A bare 'python' is traditionally python 2.x, but some distros
539
    # have it as python 3.x, so check in both places.
540
    for binary in python3 python python3.12 python3.11 \
541
                          python3.10 python3.9 python3.8; do
542
        if has "$binary"; then
543
            python=$(command -v "$binary")
544
            if check_py_version "$python"; then
545
                # This one is good.
546
                first_python=
547
                break
548
            else
549
                first_python=$python
550
            fi
551
        fi
552
    done
553
else
554
    # Same as above, but only check the environment variable.
555
    has "${PYTHON}" || error_exit "The PYTHON environment variable does not point to an executable"
556
    python=$(command -v "$PYTHON")
557
    if check_py_version "$python"; then
558
        # This one is good.
559
        first_python=
560
    else
561
        first_python=$first_python
562
    fi
563
fi
564

565
# Check for ancillary tools used in testing
566
genisoimage=
567
for binary in genisoimage mkisofs
568
do
569
    if has $binary
570
    then
571
        genisoimage=$(command -v "$binary")
572
        break
573
    fi
574
done
575

576
if test "$host_os" = "windows" ; then
577
  EXESUF=".exe"
578
fi
579

580
meson_option_build_array() {
581
  printf '['
582
  (if test "$host_os" = windows; then
583
    IFS=\;
584
  else
585
    IFS=:
586
  fi
587
  for e in $1; do
588
    printf '"""'
589
    # backslash escape any '\' and '"' characters
590
    printf "%s" "$e" | sed -e 's/\([\"]\)/\\\1/g'
591
    printf '""",'
592
  done)
593
  printf ']\n'
594
}
595

596
. "$source_path/scripts/meson-buildoptions.sh"
597

598
meson_options=
599
meson_option_add() {
600
  local arg
601
  for arg; do
602
    meson_options="$meson_options $(quote_sh "$arg")"
603
  done
604
}
605
meson_option_parse() {
606
  meson_options="$meson_options $(_meson_option_parse "$@")"
607
  if test $? -eq 1; then
608
    echo "ERROR: unknown option $1"
609
    echo "Try '$0 --help' for more information"
610
    exit 1
611
  fi
612
}
613

614
meson_add_machine_file() {
615
  if test "$cross_compile" = "yes"; then
616
    meson_option_add --cross-file "$1"
617
  else
618
    meson_option_add --native-file "$1"
619
  fi
620
}
621

622
for opt do
623
  optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
624
  case "$opt" in
625
  --help|-h) show_help=yes
626
  ;;
627
  --version|-V) exec cat "$source_path/VERSION"
628
  ;;
629
  --cross-prefix=*)
630
  ;;
631
  --cc=*)
632
  ;;
633
  --host-cc=*) host_cc="$optarg"
634
  ;;
635
  --cxx=*)
636
  ;;
637
  --objcc=*)
638
  ;;
639
  --make=*)
640
  ;;
641
  --install=*)
642
  ;;
643
  --python=*) python="$optarg"
644
  ;;
645
  --skip-meson) skip_meson=yes
646
  ;;
647
  --ninja=*) ninja="$optarg"
648
  ;;
649
  --extra-cflags=*)
650
  ;;
651
  --extra-cxxflags=*)
652
  ;;
653
  --extra-objcflags=*)
654
  ;;
655
  --extra-ldflags=*)
656
  ;;
657
  --cross-cc-*)
658
  ;;
659
  --cross-prefix-*)
660
  ;;
661
  --enable-docs) docs=enabled
662
  ;;
663
  --disable-docs) docs=disabled
664
  ;;
665
  --cpu=*)
666
  ;;
667
  --target-list=*) target_list="$optarg"
668
                   if test "$target_list_exclude"; then
669
                       error_exit "Can't mix --target-list with --target-list-exclude"
670
                   fi
671
  ;;
672
  --target-list-exclude=*) target_list_exclude="$optarg"
673
                   if test "$target_list"; then
674
                       error_exit "Can't mix --target-list-exclude with --target-list"
675
                   fi
676
  ;;
677
  --with-default-devices) meson_option_add -Ddefault_devices=true
678
  ;;
679
  --without-default-devices) meson_option_add -Ddefault_devices=false
680
  ;;
681
  --with-devices-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --with-devices-FOO option"
682
  ;;
683
  --with-devices-*) device_arch=${opt#--with-devices-};
684
                    device_arch=${device_arch%%=*}
685
                    cf=$source_path/configs/devices/$device_arch-softmmu/$optarg.mak
686
                    if test -f "$cf"; then
687
                        device_archs="$device_archs $device_arch"
688
                        eval "devices_${device_arch}=\$optarg"
689
                    else
690
                        error_exit "File $cf does not exist"
691
                    fi
692
  ;;
693
  --without-default-features) # processed above
694
  ;;
695
  --static) static="yes"
696
  ;;
697
  --host=*|--build=*|\
698
  --disable-dependency-tracking|\
699
  --sbindir=*|--sharedstatedir=*|\
700
  --oldincludedir=*|--datarootdir=*|--infodir=*|\
701
  --htmldir=*|--dvidir=*|--pdfdir=*|--psdir=*)
702
    # These switches are silently ignored, for compatibility with
703
    # autoconf-generated configure scripts. This allows QEMU's
704
    # configure to be used by RPM and similar macros that set
705
    # lots of directory switches by default.
706
  ;;
707
  --enable-debug)
708
      # Enable debugging options that aren't excessively noisy
709
      meson_option_parse --enable-debug-tcg ""
710
      meson_option_parse --enable-debug-graph-lock ""
711
      meson_option_parse --enable-debug-mutex ""
712
      meson_option_add -Doptimization=0
713
      default_cflags='-O0 -g'
714
  ;;
715
  --disable-tcg) tcg="disabled"
716
  ;;
717
  --enable-tcg) tcg="enabled"
718
  ;;
719
  --disable-system) system="no"
720
  ;;
721
  --enable-system) system="yes"
722
  ;;
723
  --disable-user)
724
      linux_user="no" ;
725
      bsd_user="no" ;
726
  ;;
727
  --enable-user) ;;
728
  --disable-linux-user) linux_user="no"
729
  ;;
730
  --enable-linux-user) linux_user="yes"
731
  ;;
732
  --disable-bsd-user) bsd_user="no"
733
  ;;
734
  --enable-bsd-user) bsd_user="yes"
735
  ;;
736
  --enable-pie) pie="yes"
737
  ;;
738
  --disable-pie) pie="no"
739
  ;;
740
  --enable-cfi) cfi=true
741
  ;;
742
  --disable-cfi) cfi=false
743
  ;;
744
  --disable-download) download="disabled"; git_submodules_action=validate;
745
  ;;
746
  --enable-download) download="enabled"; git_submodules_action=update;
747
  ;;
748
  --enable-plugins) plugins="yes"
749
  ;;
750
  --disable-plugins) plugins="no"
751
  ;;
752
  --enable-containers) use_containers="yes"
753
  ;;
754
  --disable-containers) use_containers="no"
755
  ;;
756
  --container-engine=*) container_engine="$optarg"
757
  ;;
758
  --gdb=*) gdb_bin="$optarg"
759
  ;;
760
  # everything else has the same name in configure and meson
761
  --*) meson_option_parse "$opt" "$optarg"
762
  ;;
763
  # Pass through -Dxxxx options to meson
764
  -D*) meson_option_add "$opt"
765
  ;;
766
  esac
767
done
768

769
if ! test -e "$source_path/.git"
770
then
771
    git_submodules_action="validate"
772
fi
773

774
if ! test -f "$source_path/subprojects/keycodemapdb/README" \
775
    && test "$download" = disabled
776
then
777
    echo
778
    echo "ERROR: missing subprojects"
779
    echo
780
    if test -e "$source_path/.git"; then
781
        echo "--disable-download specified but subprojects were not"
782
        echo 'checked out.  Please invoke "meson subprojects download"'
783
        echo "before configuring QEMU, or remove --disable-download"
784
        echo "from the command line."
785
    else
786
        echo "This is not a GIT checkout but subproject content appears to"
787
        echo "be missing. Do not use 'git archive' or GitHub download links"
788
        echo "to acquire QEMU source archives. Non-GIT builds are only"
789
        echo "supported with source archives linked from:"
790
        echo
791
        echo "  https://www.qemu.org/download/#source"
792
        echo
793
        echo "Developers working with GIT can use scripts/archive-source.sh"
794
        echo "if they need to create valid source archives."
795
    fi
796
    echo
797
    exit 1
798
fi
799

800
default_target_list=""
801
mak_wilds=""
802

803
if [ -n "$host_arch" ] && [ -d "$source_path/common-user/host/$host_arch" ]; then
804
    if [ "$linux_user" != no ]; then
805
        if [ "$host_os" = linux ]; then
806
            linux_user=yes
807
        elif [ "$linux_user" = yes ]; then
808
            error_exit "linux-user not supported on this architecture"
809
        fi
810
        if [ "$linux_user" = "yes" ]; then
811
            mak_wilds="${mak_wilds} $source_path/configs/targets/*-linux-user.mak"
812
        fi
813
    fi
814
    if [ "$bsd_user" != no ]; then
815
        if [ "$bsd_user" = "" ]; then
816
            test $host_os = freebsd && bsd_user=yes
817
        fi
818
        if [ "$bsd_user" = yes ] && ! [ -d "$source_path/bsd-user/$host_os" ]; then
819
            error_exit "bsd-user not supported on this host OS"
820
        fi
821
        if [ "$bsd_user" = "yes" ]; then
822
            mak_wilds="${mak_wilds} $source_path/configs/targets/*-bsd-user.mak"
823
        fi
824
    fi
825
else
826
    if [ "$linux_user" = yes ] || [ "$bsd_user" = yes ]; then
827
        error_exit "user mode emulation not supported on this architecture"
828
    fi
829
fi
830
if [ "$system" = "yes" ]; then
831
    mak_wilds="${mak_wilds} $source_path/configs/targets/*-softmmu.mak"
832
fi
833

834
for config in $mak_wilds; do
835
    target="$(basename "$config" .mak)"
836
    if echo "$target_list_exclude" | grep -vq "$target"; then
837
        default_target_list="${default_target_list} $target"
838
    fi
839
done
840

841
if test x"$show_help" = x"yes" ; then
842
cat << EOF
843

844
Usage: configure [options]
845
Options: [defaults in brackets after descriptions]
846

847
Standard options:
848
  --help                   print this message
849
  --target-list=LIST       set target list (default: build all)
850
$(echo Available targets: $default_target_list | \
851
  fold -s -w 53 | sed -e 's/^/                           /')
852
  --target-list-exclude=LIST exclude a set of targets from the default target-list
853

854
Advanced options (experts only):
855
  -Dmesonoptname=val       passthrough option to meson unmodified
856
  --cross-prefix=PREFIX    use PREFIX for compile tools, PREFIX can be blank [$cross_prefix]
857
  --cc=CC                  use C compiler CC [$cc]
858
  --host-cc=CC             when cross compiling, use C compiler CC for code run
859
                           at build time [$host_cc]
860
  --cxx=CXX                use C++ compiler CXX [$cxx]
861
  --objcc=OBJCC            use Objective-C compiler OBJCC [$objcc]
862
  --extra-cflags=CFLAGS    append extra C compiler flags CFLAGS
863
  --extra-cxxflags=CXXFLAGS append extra C++ compiler flags CXXFLAGS
864
  --extra-objcflags=OBJCFLAGS append extra Objective C compiler flags OBJCFLAGS
865
  --extra-ldflags=LDFLAGS  append extra linker flags LDFLAGS
866
  --cross-cc-ARCH=CC       use compiler when building ARCH guest test cases
867
  --cross-cc-cflags-ARCH=  use compiler flags when building ARCH guest tests
868
  --cross-prefix-ARCH=PREFIX cross compiler prefix when building ARCH guest test cases
869
  --python=PYTHON          use specified python [$python]
870
  --ninja=NINJA            use specified ninja [$ninja]
871
  --static                 enable static build [$static]
872
  --without-default-features default all --enable-* options to "disabled"
873
  --without-default-devices  do not include any device that is not needed to
874
                           start the emulator (only use if you are including
875
                           desired devices in configs/devices/)
876
  --with-devices-ARCH=NAME override default configs/devices
877
  --enable-debug           enable common debug build options
878
  --cpu=CPU                Build for host CPU [$cpu]
879
  --disable-containers     don't use containers for cross-building
880
  --container-engine=TYPE  which container engine to use [$container_engine]
881
  --gdb=GDB-path           gdb to use for gdbstub tests [$gdb_bin]
882
EOF
883
  meson_options_help
884
cat << EOF
885
  system          all system emulation targets
886
  user            supported user emulation targets
887
  linux-user      all linux usermode emulation targets
888
  bsd-user        all BSD usermode emulation targets
889
  pie             Position Independent Executables
890

891
NOTE: The object files are built at the place where configure is launched
892
EOF
893
exit 0
894
fi
895

896
# Now that we are sure that the user did not only want to print the --help
897
# information, we should double-check that the C compiler really works:
898
write_c_skeleton
899
if ! compile_object ; then
900
    error_exit "C compiler \"$cc\" either does not exist or does not work."
901
fi
902

903
# Remove old dependency files to make sure that they get properly regenerated
904
rm -f ./*/config-devices.mak.d
905

906
if test -z "$python"
907
then
908
    # If first_python is set, there was a binary somewhere even though
909
    # it was not suitable.  Use it for the error message.
910
    if test -n "$first_python"; then
911
        error_exit "Cannot use '$first_python', Python >= 3.8 is required." \
912
            "Use --python=/path/to/python to specify a supported Python."
913
    else
914
        error_exit "Python not found. Use --python=/path/to/python"
915
    fi
916
fi
917

918
if ! check_py_version "$python"; then
919
  error_exit "Cannot use '$python', Python >= 3.8 is required." \
920
             "Use --python=/path/to/python to specify a supported Python." \
921
             "Maybe try:" \
922
             "  openSUSE Leap 15.3+: zypper install python39" \
923
             "  CentOS 8: dnf install python38"
924
fi
925

926
# Resolve PATH
927
python="$(command -v "$python")"
928

929
# Create a Python virtual environment using our configured python.
930
# The stdout of this script will be the location of a symlink that
931
# points to the configured Python.
932
# Entry point scripts for pip, meson, and sphinx are generated if those
933
# packages are present.
934

935
# Defaults assumed for now:
936
# - venv is cleared if it exists already;
937
# - venv is allowed to use system packages;
938
# - all setup can be performed offline;
939
# - missing packages may be fetched from PyPI,
940
#   unless --disable-download is passed.
941
# - pip is not installed into the venv when possible,
942
#   but ensurepip is called as a fallback when necessary.
943

944
echo "python determined to be '$python'"
945
echo "python version: $($python --version)"
946

947
python="$($python -B "${source_path}/python/scripts/mkvenv.py" create pyvenv)"
948
if test "$?" -ne 0 ; then
949
    error_exit "python venv creation failed"
950
fi
951

952
# Suppress writing compiled files
953
python="$python -B"
954
mkvenv="$python ${source_path}/python/scripts/mkvenv.py"
955

956
# Finish preparing the virtual environment using vendored .whl files
957

958
$mkvenv ensuregroup --dir "${source_path}/python/wheels" \
959
     ${source_path}/pythondeps.toml meson || exit 1
960

961
# At this point, we expect Meson to be installed and available.
962
# We expect mkvenv or pip to have created pyvenv/bin/meson for us.
963
# We ignore PATH completely here: we want to use the venv's Meson
964
# *exclusively*.
965

966
meson="$(cd pyvenv/bin; pwd)/meson"
967

968
# Conditionally ensure Sphinx is installed.
969

970
mkvenv_online_flag=""
971
if test "$download" = "enabled" ; then
972
    mkvenv_online_flag=" --online"
973
fi
974

975
if test "$docs" != "disabled" ; then
976
    if ! $mkvenv ensuregroup \
977
         $(test "$docs" = "enabled" && echo "$mkvenv_online_flag") \
978
         ${source_path}/pythondeps.toml docs;
979
    then
980
        if test "$docs" = "enabled" ; then
981
            exit 1
982
        fi
983
        echo "Sphinx not found/usable, disabling docs."
984
        docs=disabled
985
    else
986
        docs=enabled
987
    fi
988
fi
989

990
# Probe for ninja
991

992
if test -z "$ninja"; then
993
    for c in ninja ninja-build samu; do
994
        if has $c; then
995
            ninja=$(command -v "$c")
996
            break
997
        fi
998
    done
999
    if test -z "$ninja"; then
1000
      error_exit "Cannot find Ninja"
1001
    fi
1002
fi
1003

1004
if test "$host_os" = "bogus"; then
1005
    # Now that we know that we're not printing the help and that
1006
    # the compiler works (so the results of the check_defines we used
1007
    # to identify the OS are reliable), if we didn't recognize the
1008
    # host OS we should stop now.
1009
    error_exit "Unrecognized host OS (uname -s reports '$(uname -s)')"
1010
fi
1011

1012
# test for any invalid configuration combinations
1013
if test "$host_os" = "windows" && ! has "$dlltool"; then
1014
  if test "$plugins" = "yes"; then
1015
    error_exit "TCG plugins requires dlltool to build on Windows platforms"
1016
  fi
1017
  plugins="no"
1018
fi
1019
if test "$tcg" = "disabled" ; then
1020
  if test "$plugins" = "yes"; then
1021
    error_exit "Can't enable plugins on non-TCG builds"
1022
  fi
1023
  plugins="no"
1024
fi
1025
if test "$static" = "yes" ; then
1026
  if test "$plugins" = "yes"; then
1027
    error_exit "static and plugins are mutually incompatible"
1028
  fi
1029
  plugins="no"
1030
fi
1031
if test "$plugins" != "no"; then
1032
  plugins=yes
1033
  subdirs="$subdirs contrib/plugins"
1034
fi
1035

1036
cat > $TMPC << EOF
1037

1038
#ifdef __linux__
1039
#  define THREAD __thread
1040
#else
1041
#  define THREAD
1042
#endif
1043
static THREAD int tls_var;
1044
int main(void) { return tls_var; }
1045
EOF
1046

1047
if test "$host_os" = windows || test "$host_os" = haiku; then
1048
  if test "$pie" = "yes"; then
1049
    error_exit "PIE not available due to missing OS support"
1050
  fi
1051
  pie=no
1052
fi
1053

1054
if test "$pie" != "no"; then
1055
  if test "$static" = "yes"; then
1056
    pie_ldflags=-static-pie
1057
  else
1058
    pie_ldflags=-pie
1059
  fi
1060
  if compile_prog "-Werror -fPIE -DPIE" "$pie_ldflags"; then
1061
    pie="yes"
1062
  elif test "$pie" = "yes"; then
1063
    error_exit "-static-pie not available due to missing toolchain support"
1064
  else
1065
    echo "Disabling PIE due to missing toolchain support"
1066
    pie="no"
1067
  fi
1068
fi
1069

1070
##########################################
1071

1072
if test -z "${target_list+xxx}" ; then
1073
    default_targets=yes
1074
    for target in $default_target_list; do
1075
        target_list="$target_list $target"
1076
    done
1077
    target_list="${target_list# }"
1078
else
1079
    default_targets=no
1080
    target_list=$(echo "$target_list" | sed -e 's/,/ /g')
1081
    for target in $target_list; do
1082
        # Check that we recognised the target name; this allows a more
1083
        # friendly error message than if we let it fall through.
1084
        case " $default_target_list " in
1085
            *" $target "*)
1086
                ;;
1087
            *)
1088
                error_exit "Unknown target name '$target'"
1089
                ;;
1090
        esac
1091
    done
1092
fi
1093

1094
if test "$tcg" = "auto"; then
1095
  if test -z "$target_list"; then
1096
    tcg="disabled"
1097
  else
1098
    tcg="enabled"
1099
  fi
1100
fi
1101

1102
#########################################
1103
# gdb test
1104

1105
if test -n "$gdb_bin"; then
1106
    gdb_version_string=$($gdb_bin --version | head -n 1)
1107
    # Extract last field in the version string
1108
    gdb_version=${gdb_version_string##* }
1109
    if version_ge $gdb_version 9.1; then
1110
        gdb_arches=$($python "$source_path/scripts/probe-gdb-support.py" $gdb_bin)
1111
    else
1112
        gdb_bin=""
1113
    fi
1114
fi
1115

1116
##########################################
1117
# big/little endian test
1118
cat > $TMPC << EOF
1119
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1120
# error LITTLE
1121
#endif
1122
int main(void) { return 0; }
1123
EOF
1124

1125
if ! compile_prog ; then
1126
  bigendian="no"
1127
else
1128
  cat > $TMPC << EOF
1129
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1130
# error BIG
1131
#endif
1132
int main(void) { return 0; }
1133
EOF
1134

1135
  if ! compile_prog ; then
1136
    bigendian="yes"
1137
  else
1138
    echo big/little test failed
1139
    exit 1
1140
  fi
1141
fi
1142

1143
##########################################
1144
# functions to probe cross compilers
1145

1146
container="no"
1147
runc=""
1148
if test $use_containers = "yes" && (has "docker" || has "podman"); then
1149
    case $($python "$source_path"/tests/docker/docker.py --engine "$container_engine" probe) in
1150
        *docker) container=docker ;;
1151
        podman) container=podman ;;
1152
        no) container=no ;;
1153
    esac
1154
    if test "$container" != "no"; then
1155
        docker_py="$python $source_path/tests/docker/docker.py --engine $container"
1156
        runc=$container
1157
    fi
1158
fi
1159

1160
# cross compilers defaults, can be overridden with --cross-cc-ARCH
1161
: ${cross_prefix_aarch64="aarch64-linux-gnu-"}
1162
: ${cross_prefix_aarch64_be="$cross_prefix_aarch64"}
1163
: ${cross_prefix_alpha="alpha-linux-gnu-"}
1164
: ${cross_prefix_arm="arm-linux-gnueabihf-"}
1165
: ${cross_prefix_armeb="$cross_prefix_arm"}
1166
: ${cross_prefix_hexagon="hexagon-unknown-linux-musl-"}
1167
: ${cross_prefix_loongarch64="loongarch64-unknown-linux-gnu-"}
1168
: ${cross_prefix_hppa="hppa-linux-gnu-"}
1169
: ${cross_prefix_i386="i686-linux-gnu-"}
1170
: ${cross_prefix_m68k="m68k-linux-gnu-"}
1171
: ${cross_prefix_microblaze="microblaze-linux-musl-"}
1172
: ${cross_prefix_mips64el="mips64el-linux-gnuabi64-"}
1173
: ${cross_prefix_mips64="mips64-linux-gnuabi64-"}
1174
: ${cross_prefix_mipsel="mipsel-linux-gnu-"}
1175
: ${cross_prefix_mips="mips-linux-gnu-"}
1176
: ${cross_prefix_ppc="powerpc-linux-gnu-"}
1177
: ${cross_prefix_ppc64="powerpc64-linux-gnu-"}
1178
: ${cross_prefix_ppc64le="$cross_prefix_ppc64"}
1179
: ${cross_prefix_riscv64="riscv64-linux-gnu-"}
1180
: ${cross_prefix_s390x="s390x-linux-gnu-"}
1181
: ${cross_prefix_sh4="sh4-linux-gnu-"}
1182
: ${cross_prefix_sparc64="sparc64-linux-gnu-"}
1183
: ${cross_prefix_sparc="$cross_prefix_sparc64"}
1184
: ${cross_prefix_tricore="tricore-"}
1185
: ${cross_prefix_x86_64="x86_64-linux-gnu-"}
1186

1187
: ${cross_cc_aarch64_be="$cross_cc_aarch64"}
1188
: ${cross_cc_cflags_aarch64_be="-mbig-endian"}
1189
: ${cross_cc_armeb="$cross_cc_arm"}
1190
: ${cross_cc_cflags_armeb="-mbig-endian"}
1191
: ${cross_cc_hexagon="hexagon-unknown-linux-musl-clang"}
1192
: ${cross_cc_cflags_hexagon="-mv73 -O2 -static"}
1193
: ${cross_cc_cflags_i386="-m32"}
1194
: ${cross_cc_cflags_ppc="-m32 -mbig-endian"}
1195
: ${cross_cc_cflags_ppc64="-m64 -mbig-endian"}
1196
: ${cross_cc_ppc64le="$cross_cc_ppc64"}
1197
: ${cross_cc_cflags_ppc64le="-m64 -mlittle-endian"}
1198
: ${cross_cc_cflags_sparc64="-m64 -mcpu=ultrasparc"}
1199
: ${cross_cc_sparc="$cross_cc_sparc64"}
1200
: ${cross_cc_cflags_sparc="-m32 -mcpu=supersparc"}
1201
: ${cross_cc_cflags_x86_64="-m64 -mcx16"}
1202

1203
compute_target_variable() {
1204
  eval "$2="
1205
  if eval test -n "\"\${cross_prefix_$1}\""; then
1206
    if eval has "\"\${cross_prefix_$1}\$3\""; then
1207
      eval "$2=\"\${cross_prefix_$1}\$3\""
1208
    fi
1209
  fi
1210
}
1211

1212
have_target() {
1213
  for i; do
1214
    case " $target_list " in
1215
      *" $i "*) return 0;;
1216
      *) ;;
1217
    esac
1218
  done
1219
  return 1
1220
}
1221

1222
# probe_target_compiler TARGET
1223
#
1224
# Look for a compiler for the given target, either native or cross.
1225
# Set variables target_* if a compiler is found, and container_cross_*
1226
# if a Docker-based cross-compiler image is known for the target.
1227
# Set got_cross_cc to yes/no depending on whether a non-container-based
1228
# compiler was found.
1229
#
1230
# If TARGET is a user-mode emulation target, also set build_static to
1231
# "y" if static linking is possible.
1232
#
1233
probe_target_compiler() {
1234
  # reset all output variables
1235
  got_cross_cc=no
1236
  container_image=
1237
  container_hosts=
1238
  container_cross_prefix=
1239
  container_cross_cc=
1240
  container_cross_ar=
1241
  container_cross_as=
1242
  container_cross_ld=
1243
  container_cross_nm=
1244
  container_cross_objcopy=
1245
  container_cross_ranlib=
1246
  container_cross_strip=
1247

1248
  target_arch=${1%%-*}
1249
  case $target_arch in
1250
    aarch64) container_hosts="x86_64 aarch64" ;;
1251
    alpha) container_hosts=x86_64 ;;
1252
    arm) container_hosts="x86_64 aarch64" ;;
1253
    cris) container_hosts=x86_64 ;;
1254
    hexagon) container_hosts=x86_64 ;;
1255
    hppa) container_hosts=x86_64 ;;
1256
    i386) container_hosts=x86_64 ;;
1257
    loongarch64) container_hosts=x86_64 ;;
1258
    m68k) container_hosts=x86_64 ;;
1259
    microblaze) container_hosts=x86_64 ;;
1260
    mips64el) container_hosts=x86_64 ;;
1261
    mips64) container_hosts=x86_64 ;;
1262
    mipsel) container_hosts=x86_64 ;;
1263
    mips) container_hosts=x86_64 ;;
1264
    ppc) container_hosts=x86_64 ;;
1265
    ppc64|ppc64le) container_hosts=x86_64 ;;
1266
    riscv64) container_hosts=x86_64 ;;
1267
    s390x) container_hosts=x86_64 ;;
1268
    sh4) container_hosts=x86_64 ;;
1269
    sparc64) container_hosts=x86_64 ;;
1270
    tricore) container_hosts=x86_64 ;;
1271
    x86_64) container_hosts="aarch64 ppc64le x86_64" ;;
1272
    xtensa*) container_hosts=x86_64 ;;
1273
  esac
1274

1275
  for host in $container_hosts; do
1276
    test "$container" != no || continue
1277
    test "$host" = "$cpu" || continue
1278
    case $target_arch in
1279
      # debian-all-test-cross architectures
1280

1281
      hppa|m68k|mips|riscv64|sparc64)
1282
        container_image=debian-all-test-cross
1283
        ;;
1284
      mips64)
1285
        container_image=debian-all-test-cross
1286
        container_cross_prefix=mips64-linux-gnuabi64-
1287
        ;;
1288
      ppc|ppc64|ppc64le)
1289
        container_image=debian-all-test-cross
1290
        container_cross_prefix=powerpc${target_arch#ppc}-linux-gnu-
1291
        ;;
1292

1293
      # debian-legacy-test-cross architectures (need Debian 11)
1294
      # - libc6.1-dev-alpha-cross: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1054412
1295
      # - sh4-linux-user: binaries don't run with bookworm compiler
1296

1297
      alpha|sh4)
1298
        container_image=debian-legacy-test-cross
1299
        ;;
1300

1301
      # architectures with individual containers
1302

1303
      aarch64)
1304
        # We don't have any bigendian build tools so we only use this for AArch64
1305
        container_image=debian-arm64-cross
1306
        ;;
1307
      arm)
1308
        # We don't have any bigendian build tools so we only use this for ARM
1309
        container_image=debian-armhf-cross
1310
        container_cross_prefix=arm-linux-gnueabihf-
1311
        ;;
1312
      cris)
1313
        container_image=fedora-cris-cross
1314
        ;;
1315
      hexagon)
1316
        container_cross_prefix=hexagon-unknown-linux-musl-
1317
        container_cross_cc=${container_cross_prefix}clang
1318
        ;;
1319
      i386)
1320
        container_image=debian-i686-cross
1321
        container_cross_prefix=i686-linux-gnu-
1322
        ;;
1323
      loongarch64)
1324
        container_image=debian-loongarch-cross
1325
        container_cross_prefix=loongarch64-unknown-linux-gnu-
1326
        ;;
1327
      microblaze)
1328
        container_cross_prefix=microblaze-linux-musl-
1329
        ;;
1330
      mips64el)
1331
        container_image=debian-mips64el-cross
1332
        container_cross_prefix=mips64el-linux-gnuabi64-
1333
        ;;
1334
      tricore)
1335
        container_image=debian-tricore-cross
1336
        container_cross_prefix=tricore-
1337
        ;;
1338
      x86_64)
1339
        container_image=debian-amd64-cross
1340
        ;;
1341
      xtensa*)
1342
        container_image=debian-xtensa-cross
1343

1344
        # default to the dc232b cpu
1345
        container_cross_prefix=/opt/2020.07/xtensa-dc232b-elf/bin/xtensa-dc232b-elf-
1346
        ;;
1347
    esac
1348
    # Debian and GNU architecture names usually match
1349
    : ${container_image:=debian-$target_arch-cross}
1350
    : ${container_cross_prefix:=$target_arch-linux-gnu-}
1351
    : ${container_cross_cc:=${container_cross_prefix}gcc}
1352
    : ${container_cross_ar:=${container_cross_prefix}ar}
1353
    : ${container_cross_as:=${container_cross_prefix}as}
1354
    : ${container_cross_ld:=${container_cross_prefix}ld}
1355
    : ${container_cross_nm:=${container_cross_prefix}nm}
1356
    : ${container_cross_objcopy:=${container_cross_prefix}objcopy}
1357
    : ${container_cross_ranlib:=${container_cross_prefix}ranlib}
1358
    : ${container_cross_strip:=${container_cross_prefix}strip}
1359
  done
1360

1361
  try=cross
1362
  # For softmmu/roms also look for a bi-endian or multilib-enabled host compiler
1363
  if [ "${1%softmmu}" != "$1" ] || test "$target_arch" = "$cpu"; then
1364
      case "$target_arch:$cpu" in
1365
        aarch64_be:aarch64 | \
1366
        armeb:arm | \
1367
        i386:x86_64 | \
1368
        mips*:mips64 | \
1369
        ppc*:ppc64 | \
1370
        sparc:sparc64 | \
1371
        "$cpu:$cpu")
1372
        try='native cross' ;;
1373
      esac
1374
  fi
1375
  eval "target_cflags=\${cross_cc_cflags_$target_arch}"
1376
  for thistry in $try; do
1377
    case $thistry in
1378
    native)
1379
      target_cc=$cc
1380
      target_ccas=$ccas
1381
      target_ar=$ar
1382
      target_as=$as
1383
      target_ld=$ld
1384
      target_nm=$nm
1385
      target_objcopy=$objcopy
1386
      target_ranlib=$ranlib
1387
      target_strip=$strip
1388
      ;;
1389
    cross)
1390
      target_cc=
1391
      if eval test -n "\"\${cross_cc_$target_arch}\""; then
1392
        if eval has "\"\${cross_cc_$target_arch}\""; then
1393
          eval "target_cc=\"\${cross_cc_$target_arch}\""
1394
        fi
1395
      else
1396
        compute_target_variable $target_arch target_cc gcc
1397
      fi
1398
      target_ccas=$target_cc
1399
      compute_target_variable $target_arch target_ar ar
1400
      compute_target_variable $target_arch target_as as
1401
      compute_target_variable $target_arch target_ld ld
1402
      compute_target_variable $target_arch target_nm nm
1403
      compute_target_variable $target_arch target_objcopy objcopy
1404
      compute_target_variable $target_arch target_ranlib ranlib
1405
      compute_target_variable $target_arch target_strip strip
1406
      ;;
1407
    esac
1408

1409
    if test -n "$target_cc"; then
1410
      case $target_arch in
1411
        i386|x86_64)
1412
          if $target_cc --version | grep -qi "clang"; then
1413
            continue
1414
          fi
1415
          ;;
1416
      esac
1417
    elif test -n "$target_as" && test -n "$target_ld"; then
1418
      # Special handling for assembler only targets
1419
      case $target in
1420
        tricore-softmmu)
1421
          build_static=
1422
          got_cross_cc=yes
1423
          break
1424
          ;;
1425
        *)
1426
          continue
1427
          ;;
1428
      esac
1429
    else
1430
      continue
1431
    fi
1432

1433
    write_c_skeleton
1434
    case $1 in
1435
      *-softmmu)
1436
        if do_compiler "$target_cc" $target_cflags -o $TMPO -c $TMPC &&
1437
          do_compiler "$target_cc" $target_cflags -r -nostdlib -o "${TMPDIR1}/${TMPB}2.o" "$TMPO" -lgcc; then
1438
          got_cross_cc=yes
1439
          break
1440
        fi
1441
        ;;
1442
      *)
1443
        if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC -static ; then
1444
          build_static=y
1445
          got_cross_cc=yes
1446
          break
1447
        fi
1448
        if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC ; then
1449
          build_static=
1450
          got_cross_cc=yes
1451
          break
1452
        fi
1453
        ;;
1454
    esac
1455
  done
1456
  if test $got_cross_cc != yes; then
1457
    build_static=
1458
    target_cc=
1459
    target_ccas=
1460
    target_ar=
1461
    target_as=
1462
    target_ld=
1463
    target_nm=
1464
    target_objcopy=
1465
    target_ranlib=
1466
    target_strip=
1467
  fi
1468
  test -n "$target_cc"
1469
}
1470

1471
write_target_makefile() {
1472
  echo "EXTRA_CFLAGS=$target_cflags"
1473
  if test -z "$target_cc" && test -z "$target_as"; then
1474
    test -z "$container_image" && error_exit "Internal error: could not find cross compiler for $1?"
1475
    echo "$1: docker-image-$container_image" >> Makefile.prereqs
1476
    if test -n "$container_cross_cc"; then
1477
      echo "CC=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
1478
      echo "CCAS=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
1479
    fi
1480
    echo "AR=$docker_py cc --cc $container_cross_ar -i qemu/$container_image -s $source_path --"
1481
    echo "AS=$docker_py cc --cc $container_cross_as -i qemu/$container_image -s $source_path --"
1482
    echo "LD=$docker_py cc --cc $container_cross_ld -i qemu/$container_image -s $source_path --"
1483
    echo "NM=$docker_py cc --cc $container_cross_nm -i qemu/$container_image -s $source_path --"
1484
    echo "OBJCOPY=$docker_py cc --cc $container_cross_objcopy -i qemu/$container_image -s $source_path --"
1485
    echo "RANLIB=$docker_py cc --cc $container_cross_ranlib -i qemu/$container_image -s $source_path --"
1486
    echo "STRIP=$docker_py cc --cc $container_cross_strip -i qemu/$container_image -s $source_path --"
1487
  else
1488
    if test -n "$target_cc"; then
1489
      echo "CC=$target_cc"
1490
      echo "CCAS=$target_ccas"
1491
    fi
1492
    if test -n "$target_ar"; then
1493
      echo "AR=$target_ar"
1494
    fi
1495
    if test -n "$target_as"; then
1496
      echo "AS=$target_as"
1497
    fi
1498
    if test -n "$target_ld"; then
1499
      echo "LD=$target_ld"
1500
    fi
1501
    if test -n "$target_nm"; then
1502
      echo "NM=$target_nm"
1503
    fi
1504
    if test -n "$target_objcopy"; then
1505
      echo "OBJCOPY=$target_objcopy"
1506
    fi
1507
    if test -n "$target_ranlib"; then
1508
      echo "RANLIB=$target_ranlib"
1509
    fi
1510
    if test -n "$target_strip"; then
1511
      echo "STRIP=$target_strip"
1512
    fi
1513
  fi
1514
}
1515

1516
#######################################
1517
# cross-compiled firmware targets
1518

1519
# Set up build tree symlinks that point back into the source tree
1520
# (these can be both files and directories).
1521
# Caution: avoid adding files or directories here using wildcards. This
1522
# will result in problems later if a new file matching the wildcard is
1523
# added to the source tree -- nothing will cause configure to be rerun
1524
# so the build tree will be missing the link back to the new file, and
1525
# tests might fail. Prefer to keep the relevant files in their own
1526
# directory and symlink the directory instead.
1527
LINKS="Makefile"
1528
LINKS="$LINKS docs/config"
1529
LINKS="$LINKS pc-bios/optionrom/Makefile"
1530
LINKS="$LINKS pc-bios/s390-ccw/Makefile"
1531
LINKS="$LINKS pc-bios/vof/Makefile"
1532
LINKS="$LINKS .gdbinit scripts" # scripts needed by relative path in .gdbinit
1533
LINKS="$LINKS tests/avocado tests/data"
1534
LINKS="$LINKS tests/qemu-iotests/check tests/qemu-iotests/Makefile"
1535
LINKS="$LINKS python"
1536
LINKS="$LINKS contrib/plugins/Makefile "
1537
for f in $LINKS ; do
1538
    if [ -e "$source_path/$f" ]; then
1539
        symlink "$source_path/$f" "$f"
1540
    fi
1541
done
1542

1543
# use included Linux headers for KVM architectures
1544
if test "$host_os" = "linux" && test -n "$linux_arch"; then
1545
  symlink "$source_path/linux-headers/asm-$linux_arch" linux-headers/asm
1546
fi
1547

1548
echo "# Automatically generated by configure - do not modify" > Makefile.prereqs
1549

1550
# Mac OS X ships with a broken assembler
1551
if have_target i386-softmmu x86_64-softmmu && \
1552
        test "$host_os" != "darwin" && test "$host_os" != "sunos" && \
1553
        test "$host_os" != "haiku" && \
1554
        probe_target_compiler i386-softmmu; then
1555
    subdirs="$subdirs pc-bios/optionrom"
1556
    config_mak=pc-bios/optionrom/config.mak
1557
    echo "# Automatically generated by configure - do not modify" > $config_mak
1558
    echo "TOPSRC_DIR=$source_path" >> $config_mak
1559
    write_target_makefile >> $config_mak
1560
fi
1561

1562
if have_target ppc-softmmu ppc64-softmmu && \
1563
        probe_target_compiler ppc-softmmu; then
1564
    subdirs="$subdirs pc-bios/vof"
1565
    config_mak=pc-bios/vof/config.mak
1566
    echo "# Automatically generated by configure - do not modify" > $config_mak
1567
    echo "SRC_DIR=$source_path/pc-bios/vof" >> $config_mak
1568
    write_target_makefile >> $config_mak
1569
fi
1570

1571
# Only build s390-ccw bios if the compiler has -march=z900 or -march=z10
1572
# (which is the lowest architecture level that Clang supports)
1573
if have_target s390x-softmmu && probe_target_compiler s390x-softmmu && \
1574
    GIT=git "$source_path/scripts/git-submodule.sh" "$git_submodules_action" roms/SLOF >> config.log 2>&1; then
1575
  write_c_skeleton
1576
  do_compiler "$target_cc" $target_cc_cflags -march=z900 -o $TMPO -c $TMPC
1577
  has_z900=$?
1578
  if [ $has_z900 = 0 ] || do_compiler "$target_cc" $target_cc_cflags -march=z10 -msoft-float -Werror -o $TMPO -c $TMPC; then
1579
    if [ $has_z900 != 0 ]; then
1580
      echo "WARNING: Your compiler does not support the z900!"
1581
      echo "         The s390-ccw bios will only work with guest CPUs >= z10."
1582
    fi
1583
    subdirs="$subdirs pc-bios/s390-ccw"
1584
    config_mak=pc-bios/s390-ccw/config-host.mak
1585
    echo "# Automatically generated by configure - do not modify" > $config_mak
1586
    echo "SRC_PATH=$source_path/pc-bios/s390-ccw" >> $config_mak
1587
    echo "GIT_SUBMODULES_ACTION=$git_submodules_action" >> $config_mak
1588
    write_target_makefile >> $config_mak
1589
  fi
1590
fi
1591

1592
#######################################
1593
# generate config-host.mak
1594

1595
config_host_mak="config-host.mak"
1596

1597
echo "# Automatically generated by configure - do not modify" > $config_host_mak
1598
echo >> $config_host_mak
1599

1600
echo all: >> $config_host_mak
1601

1602
echo "SRC_PATH=$source_path" >> $config_host_mak
1603
echo "TARGET_DIRS=$target_list" >> $config_host_mak
1604
echo "GDB=$gdb_bin" >> $config_host_mak
1605
if test "$container" != no; then
1606
    echo "RUNC=$runc" >> $config_host_mak
1607
fi
1608
echo "SUBDIRS=$subdirs" >> $config_host_mak
1609
echo "PYTHON=$python" >> $config_host_mak
1610
echo "MKVENV_ENSUREGROUP=$mkvenv ensuregroup $mkvenv_online_flag" >> $config_host_mak
1611
echo "GENISOIMAGE=$genisoimage" >> $config_host_mak
1612
echo "MESON=$meson" >> $config_host_mak
1613
echo "NINJA=$ninja" >> $config_host_mak
1614
echo "EXESUF=$EXESUF" >> $config_host_mak
1615
if test "$default_targets" = "yes"; then
1616
  echo "CONFIG_DEFAULT_TARGETS=y" >> $config_host_mak
1617
fi
1618

1619
# contrib/plugins configuration
1620
echo "# Automatically generated by configure - do not modify" > contrib/plugins/$config_host_mak
1621
echo "SRC_PATH=$source_path/contrib/plugins" >> contrib/plugins/$config_host_mak
1622
echo "PKG_CONFIG=${pkg_config}" >> contrib/plugins/$config_host_mak
1623
echo "CC=$cc $CPU_CFLAGS" >> contrib/plugins/$config_host_mak
1624
echo "CFLAGS=${CFLAGS-$default_cflags} $EXTRA_CFLAGS" >> contrib/plugins/$config_host_mak
1625
if test "$host_os" = windows; then
1626
  echo "DLLTOOL=$dlltool" >> contrib/plugins/$config_host_mak
1627
fi
1628
if test "$host_os" = darwin; then
1629
  echo "CONFIG_DARWIN=y" >> contrib/plugins/$config_host_mak
1630
fi
1631
if test "$host_os" = windows; then
1632
  echo "CONFIG_WIN32=y" >> contrib/plugins/$config_host_mak
1633
fi
1634

1635
# tests/tcg configuration
1636
mkdir -p tests/tcg
1637
echo "# Automatically generated by configure - do not modify" > tests/tcg/$config_host_mak
1638
echo "SRC_PATH=$source_path" >> tests/tcg/$config_host_mak
1639
if test "$plugins" = "yes" ; then
1640
    echo "CONFIG_PLUGIN=y" >> tests/tcg/$config_host_mak
1641
fi
1642

1643
tcg_tests_targets=
1644
for target in $target_list; do
1645
  arch=${target%%-*}
1646

1647
  case $target in
1648
    xtensa*-linux-user)
1649
      # the toolchain is not complete with headers, only build system tests
1650
      continue
1651
      ;;
1652
    *-softmmu)
1653
      test -f "$source_path/tests/tcg/$arch/Makefile.softmmu-target" || continue
1654
      qemu="qemu-system-$arch"
1655
      ;;
1656
    *-linux-user|*-bsd-user)
1657
      qemu="qemu-$arch"
1658
      ;;
1659
  esac
1660

1661
  if probe_target_compiler $target || test -n "$container_image"; then
1662
      test -n "$container_image" && build_static=y
1663
      mkdir -p "tests/tcg/$target"
1664
      config_target_mak=tests/tcg/$target/config-target.mak
1665
      ln -sf "$source_path/tests/tcg/Makefile.target" "tests/tcg/$target/Makefile"
1666
      echo "# Automatically generated by configure - do not modify" > "$config_target_mak"
1667
      echo "TARGET_NAME=$arch" >> "$config_target_mak"
1668
      echo "TARGET=$target" >> "$config_target_mak"
1669
      write_target_makefile "build-tcg-tests-$target" >> "$config_target_mak"
1670
      echo "BUILD_STATIC=$build_static" >> "$config_target_mak"
1671
      echo "QEMU=$PWD/$qemu" >> "$config_target_mak"
1672

1673
      # will GDB work with these binaries?
1674
      if test "${gdb_arches#*$arch}" != "$gdb_arches"; then
1675
          echo "GDB=$gdb_bin" >> $config_target_mak
1676
      fi
1677

1678
      if test "${gdb_arches#*aarch64}" != "$gdb_arches" && version_ge $gdb_version 15.1; then
1679
          echo "GDB_HAS_MTE=y" >> $config_target_mak
1680
      fi
1681

1682
      echo "run-tcg-tests-$target: $qemu\$(EXESUF)" >> Makefile.prereqs
1683
      tcg_tests_targets="$tcg_tests_targets $target"
1684
  fi
1685
done
1686

1687
if test "$tcg" = "enabled"; then
1688
    echo "TCG_TESTS_TARGETS=$tcg_tests_targets" >> $config_host_mak
1689
fi
1690

1691
if test "$skip_meson" = no; then
1692
  cross="config-meson.cross.new"
1693
  meson_quote() {
1694
    test $# = 0 && return
1695
    echo "'$(echo $* | sed "s/ /','/g")'"
1696
  }
1697

1698
  echo "# Automatically generated by configure - do not modify" > $cross
1699
  echo "[properties]" >> $cross
1700

1701
  # unroll any custom device configs
1702
  for a in $device_archs; do
1703
      eval "c=\$devices_${a}"
1704
      echo "${a}-softmmu = '$c'" >> $cross
1705
  done
1706

1707
  echo "[built-in options]" >> $cross
1708
  echo "c_args = [$(meson_quote $CFLAGS $EXTRA_CFLAGS)]" >> $cross
1709
  echo "cpp_args = [$(meson_quote $CXXFLAGS $EXTRA_CXXFLAGS)]" >> $cross
1710
  test -n "$objcc" && echo "objc_args = [$(meson_quote $OBJCFLAGS $EXTRA_OBJCFLAGS)]" >> $cross
1711
  echo "c_link_args = [$(meson_quote $CFLAGS $LDFLAGS $EXTRA_CFLAGS $EXTRA_LDFLAGS)]" >> $cross
1712
  echo "cpp_link_args = [$(meson_quote $CXXFLAGS $LDFLAGS $EXTRA_CXXFLAGS $EXTRA_LDFLAGS)]" >> $cross
1713

1714
  # Only enable by default for git builds and on select OSes
1715
  echo "# environment defaults, can still be overridden on " >> $cross
1716
  echo "# the command line" >> $cross
1717
  if test -e "$source_path/.git" && \
1718
      { test "$host_os" = linux || test "$host_os" = "windows"; }; then
1719
      echo 'werror = true' >> $cross
1720
  fi
1721
  echo "[project options]" >> $cross
1722
  if test "$SMBD" != ''; then
1723
    echo "smbd = $(meson_quote "$SMBD")" >> $cross
1724
  fi
1725
  if test "${QEMU_GA_MANUFACTURER}" != ''; then
1726
    echo "qemu_ga_manufacturer = $(meson_quote "${QEMU_GA_MANUFACTURER}")" >> $cross
1727
  fi
1728
  if test "${QEMU_GA_DISTRO}" != ''; then
1729
    echo "qemu_ga_distro = $(meson_quote "${QEMU_GA_DISTRO}")" >> $cross
1730
  fi
1731
  if test "${QEMU_GA_VERSION}" != ''; then
1732
    echo "qemu_ga_version = $(meson_quote "${QEMU_GA_VERSION}")" >> $cross
1733
  fi
1734

1735
  echo >> $cross
1736
  echo "[binaries]" >> $cross
1737
  echo "c = [$(meson_quote $cc $CPU_CFLAGS)]" >> $cross
1738
  test -n "$cxx" && echo "cpp = [$(meson_quote $cxx $CPU_CFLAGS)]" >> $cross
1739
  test -n "$objcc" && echo "objc = [$(meson_quote $objcc $CPU_CFLAGS)]" >> $cross
1740
  echo "ar = [$(meson_quote $ar)]" >> $cross
1741
  echo "dlltool = [$(meson_quote $dlltool)]" >> $cross
1742
  echo "nm = [$(meson_quote $nm)]" >> $cross
1743
  echo "pkgconfig = [$(meson_quote $pkg_config)]" >> $cross
1744
  echo "pkg-config = [$(meson_quote $pkg_config)]" >> $cross
1745
  echo "ranlib = [$(meson_quote $ranlib)]" >> $cross
1746
  if has $sdl2_config; then
1747
    echo "sdl2-config = [$(meson_quote $sdl2_config)]" >> $cross
1748
  fi
1749
  echo "strip = [$(meson_quote $strip)]" >> $cross
1750
  echo "widl = [$(meson_quote $widl)]" >> $cross
1751
  echo "windres = [$(meson_quote $windres)]" >> $cross
1752
  echo "windmc = [$(meson_quote $windmc)]" >> $cross
1753
  if test "$cross_compile" = "yes"; then
1754
    echo "[host_machine]" >> $cross
1755
    echo "system = '$host_os'" >> $cross
1756
    case "$cpu" in
1757
        i386)
1758
            echo "cpu_family = 'x86'" >> $cross
1759
            ;;
1760
        *)
1761
            echo "cpu_family = '$cpu'" >> $cross
1762
            ;;
1763
    esac
1764
    echo "cpu = '$cpu'" >> $cross
1765
    if test "$bigendian" = "yes" ; then
1766
        echo "endian = 'big'" >> $cross
1767
    else
1768
        echo "endian = 'little'" >> $cross
1769
    fi
1770

1771
    native="config-meson.native.new"
1772
    echo "# Automatically generated by configure - do not modify" > $native
1773
    echo "[binaries]" >> $native
1774
    echo "c = [$(meson_quote $host_cc)]" >> $native
1775
    mv $native config-meson.native
1776
    meson_option_add --native-file
1777
    meson_option_add config-meson.native
1778
  fi
1779
  mv $cross config-meson.cross
1780
  meson_add_machine_file config-meson.cross
1781
  if test -f "$source_path/configs/meson/$host_os.txt"; then
1782
    meson_add_machine_file $source_path/configs/meson/$host_os.txt
1783
  fi
1784

1785
  rm -rf meson-private meson-info meson-logs
1786

1787
  test "$download" = "disabled" && meson_option_add "--wrap-mode=nodownload"
1788
  test "$default_feature" = no && meson_option_add -Dauto_features=disabled
1789
  test "$static" = yes && meson_option_add -Dprefer_static=true
1790
  test "$pie" = no && meson_option_add -Db_pie=false
1791

1792
  # QEMU options
1793
  test "$cfi" != false && meson_option_add "-Dcfi=$cfi" "-Db_lto=$cfi"
1794
  test "$docs" != auto && meson_option_add "-Ddocs=$docs"
1795
  test -n "${LIB_FUZZING_ENGINE+xxx}" && meson_option_add "-Dfuzzing_engine=$LIB_FUZZING_ENGINE"
1796
  test "$plugins" = yes && meson_option_add "-Dplugins=true"
1797
  test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
1798
  run_meson() {
1799
    NINJA=$ninja $meson setup "$@" "$PWD" "$source_path"
1800
  }
1801
  eval run_meson $meson_options
1802
  if test "$?" -ne 0 ; then
1803
      error_exit "meson setup failed"
1804
  fi
1805
  echo "$meson" > build.ninja.stamp
1806
else
1807
  if test -f meson-private/cmd_line.txt; then
1808
    # Adjust old command line options that were removed
1809
    # sed -i is not portable
1810
    perl -i -ne '
1811
      /^sphinx_build/ && next;
1812
      print;' meson-private/cmd_line.txt
1813
  fi
1814
fi
1815

1816
# Save the configure command line for later reuse.
1817
cat <<EOD >config.status
1818
#!/bin/sh
1819
# Generated by configure.
1820
# Run this file to recreate the current configuration.
1821
# Compiler output produced by configure, useful for debugging
1822
# configure, is in config.log if it exists.
1823
EOD
1824

1825
preserve_env() {
1826
    envname=$1
1827

1828
    eval envval=\$$envname
1829

1830
    if test -n "$envval"
1831
    then
1832
	echo "$envname='$envval'" >> config.status
1833
	echo "export $envname" >> config.status
1834
    else
1835
	echo "unset $envname" >> config.status
1836
    fi
1837
}
1838

1839
# Preserve various env variables that influence what
1840
# features/build target configure will detect
1841
preserve_env AR
1842
preserve_env AS
1843
preserve_env CC
1844
preserve_env CFLAGS
1845
preserve_env CXX
1846
preserve_env CXXFLAGS
1847
preserve_env DLLTOOL
1848
preserve_env LD
1849
preserve_env LDFLAGS
1850
preserve_env LD_LIBRARY_PATH
1851
preserve_env NM
1852
preserve_env OBJCFLAGS
1853
preserve_env OBJCOPY
1854
preserve_env PATH
1855
preserve_env PKG_CONFIG
1856
preserve_env PKG_CONFIG_LIBDIR
1857
preserve_env PKG_CONFIG_PATH
1858
preserve_env PYTHON
1859
preserve_env QEMU_GA_MANUFACTURER
1860
preserve_env QEMU_GA_DISTRO
1861
preserve_env QEMU_GA_VERSION
1862
preserve_env SDL2_CONFIG
1863
preserve_env SMBD
1864
preserve_env STRIP
1865
preserve_env WIDL
1866
preserve_env WINDRES
1867
preserve_env WINDMC
1868

1869
printf "exec" >>config.status
1870
for i in "$0" "$@"; do
1871
  test "$i" = --skip-meson || printf " %s" "$(quote_sh "$i")" >>config.status
1872
done
1873
echo ' "$@"' >>config.status
1874
chmod +x config.status
1875

1876
rm -r "$TMPDIR1"
1877