ninja=""
bindir="bin"
skip_meson=no
+vfio_user_server="disabled"
# The following Meson options are handled manually (still they
# are included in the automatically generated help message)
fdt="auto"
# 2. Automatically enable/disable other options
-tcg="enabled"
+tcg="auto"
cfi="false"
# parse CC options second
werror=""
+meson_option_build_array() {
+ printf '['
+ (if test "$targetos" == windows; then
+ IFS=\;
+ else
+ IFS=:
+ fi
+ for e in $1; do
+ e=${e/'\'/'\\'}
+ e=${e/\"/'\"'}
+ printf '"""%s""",' "$e"
+ done)
+ printf ']\n'
+}
+
. $source_path/scripts/meson-buildoptions.sh
meson_options=
;;
--disable-blobs) meson_option_parse --disable-install-blobs ""
;;
+ --enable-vfio-user-server) vfio_user_server="enabled"
+ ;;
+ --disable-vfio-user-server) vfio_user_server="disabled"
+ ;;
--enable-tcmalloc) meson_option_parse --enable-malloc=tcmalloc tcmalloc
;;
--enable-jemalloc) meson_option_parse --enable-malloc=jemalloc jemalloc
--with-git-submodules=ignore do not update or check git submodules (default if no .git dir)
--static enable static build [$static]
--bindir=PATH install binaries in PATH
- --efi-aarch64=PATH PATH of efi file to use for aarch64 VMs.
--with-suffix=SUFFIX suffix for QEMU data inside datadir/libdir/sysconfdir/docdir [$qemu_suffix]
--without-default-features default all --enable-* options to "disabled"
--without-default-devices do not include any device that is not needed to
int main(void) { return tls_var; }
EOF
-# Check we support -fno-pie and -no-pie first; we will need the former for
-# building ROMs, and both for everything if --disable-pie is passed.
-if compile_prog "-Werror -fno-pie" "-no-pie"; then
- CFLAGS_NOPIE="-fno-pie"
- LDFLAGS_NOPIE="-no-pie"
-fi
-
if test "$static" = "yes"; then
if test "$pie" != "no" && compile_prog "-Werror -fPIE -DPIE" "-static-pie"; then
CONFIGURE_CFLAGS="-fPIE -DPIE $CONFIGURE_CFLAGS"
pie="no"
fi
elif test "$pie" = "no"; then
- CONFIGURE_CFLAGS="$CFLAGS_NOPIE $CONFIGURE_CFLAGS"
- CONFIGURE_LDFLAGS="$LDFLAGS_NOPIE $CONFIGURE_LDFLAGS"
+ if compile_prog "-Werror -fno-pie" "-no-pie"; then
+ CONFIGURE_CFLAGS="-fno-pie $CONFIGURE_CFLAGS"
+ CONFIGURE_LDFLAGS="-no-pie $CONFIGURE_LDFLAGS"
+ fi
elif compile_prog "-Werror -fPIE -DPIE" "-pie"; then
CONFIGURE_CFLAGS="-fPIE -DPIE $CONFIGURE_CFLAGS"
CONFIGURE_LDFLAGS="-pie $CONFIGURE_LDFLAGS"
fi
fi
-if test "$tcg" = "enabled"; then
- git_submodules="$git_submodules tests/fp/berkeley-testfloat-3"
- git_submodules="$git_submodules tests/fp/berkeley-softfloat-3"
-fi
-
if test -z "${target_list+xxx}" ; then
default_targets=yes
for target in $default_target_list; do
;;
esac
+if test "$tcg" = "auto"; then
+ if test -z "$target_list"; then
+ tcg="disabled"
+ else
+ tcg="enabled"
+ fi
+fi
+
+if test "$tcg" = "enabled"; then
+ git_submodules="$git_submodules tests/fp/berkeley-testfloat-3"
+ git_submodules="$git_submodules tests/fp/berkeley-softfloat-3"
+fi
+
feature_not_found() {
feature=$1
remedy=$2
: ${cross_prefix_arm="arm-linux-gnueabihf-"}
: ${cross_prefix_armeb="$cross_prefix_arm"}
: ${cross_prefix_hexagon="hexagon-unknown-linux-musl-"}
+: ${cross_prefix_loongarch64="loongarch64-unknown-linux-gnu-"}
: ${cross_prefix_hppa="hppa-linux-gnu-"}
: ${cross_prefix_i386="i686-linux-gnu-"}
: ${cross_prefix_m68k="m68k-linux-gnu-"}
: ${cross_cc_hexagon="hexagon-unknown-linux-musl-clang"}
: ${cross_cc_cflags_hexagon="-mv67 -O2 -static"}
: ${cross_cc_cflags_i386="-m32"}
-: ${cross_cc_cflags_ppc="-m32"}
+: ${cross_cc_cflags_ppc="-m32 -mbig-endian"}
: ${cross_cc_cflags_ppc64="-m64 -mbig-endian"}
: ${cross_cc_ppc64le="$cross_cc_ppc64"}
: ${cross_cc_cflags_ppc64le="-m64 -mlittle-endian"}
: ${cross_cc_cflags_x86_64="-m64"}
compute_target_variable() {
+ eval "$2="
if eval test -n "\"\${cross_prefix_$1}\""; then
if eval has "\"\${cross_prefix_$1}\$3\""; then
eval "$2=\"\${cross_prefix_$1}\$3\""
fi
}
+# probe_target_compiler TARGET
+#
+# Look for a compiler for the given target, either native or cross.
+# Set variables target_* if a compiler is found, and container_cross_*
+# if a Docker-based cross-compiler image is known for the target.
+# Set got_cross_cc to yes/no depending on whether a non-container-based
+# compiler was found.
+#
+# If TARGET is a user-mode emulation target, also set build_static to
+# "y" if static linking is possible.
+#
probe_target_compiler() {
# reset all output variables
+ got_cross_cc=no
container_image=
container_hosts=
container_cross_cc=
+ container_cross_ar=
container_cross_as=
container_cross_ld=
- target_cc=
- target_as=
- target_ld=
+ container_cross_nm=
+ container_cross_objcopy=
+ container_cross_ranlib=
+ container_cross_strip=
- case $1 in
+ target_arch=${1%%-*}
+ case $target_arch in
aarch64) container_hosts="x86_64 aarch64" ;;
alpha) container_hosts=x86_64 ;;
arm) container_hosts="x86_64 aarch64" ;;
hexagon) container_hosts=x86_64 ;;
hppa) container_hosts=x86_64 ;;
i386) container_hosts=x86_64 ;;
+ loongarch64) container_hosts=x86_64 ;;
m68k) container_hosts=x86_64 ;;
microblaze) container_hosts=x86_64 ;;
mips64el) container_hosts=x86_64 ;;
for host in $container_hosts; do
test "$container" != no || continue
test "$host" = "$cpu" || continue
- case $1 in
+ case $target_arch in
aarch64)
# We don't have any bigendian build tools so we only use this for AArch64
container_image=debian-arm64-cross
container_image=fedora-i386-cross
container_cross_prefix=
;;
+ loongarch64)
+ container_image=debian-loongarch-cross
+ container_cross_prefix=loongarch64-unknown-linux-gnu-
+ ;;
m68k)
container_image=debian-m68k-cross
container_cross_prefix=m68k-linux-gnu-
container_cross_prefix=x86_64-linux-gnu-
;;
xtensa*)
- # FIXME: xtensa-linux-user?
container_hosts=x86_64
container_image=debian-xtensa-cross
;;
esac
: ${container_cross_cc:=${container_cross_prefix}gcc}
+ : ${container_cross_ar:=${container_cross_prefix}ar}
: ${container_cross_as:=${container_cross_prefix}as}
: ${container_cross_ld:=${container_cross_prefix}ld}
+ : ${container_cross_nm:=${container_cross_prefix}nm}
+ : ${container_cross_objcopy:=${container_cross_prefix}objcopy}
+ : ${container_cross_ranlib:=${container_cross_prefix}ranlib}
+ : ${container_cross_strip:=${container_cross_prefix}strip}
done
- eval "target_cflags=\${cross_cc_cflags_$1}"
- if eval test -n "\"\${cross_cc_$1}\""; then
- if eval has "\"\${cross_cc_$1}\""; then
- eval "target_cc=\"\${cross_cc_$1}\""
+ local t try
+ try=cross
+ case "$target_arch:$cpu" in
+ aarch64_be:aarch64 | \
+ armeb:arm | \
+ i386:x86_64 | \
+ mips*:mips64 | \
+ ppc*:ppc64 | \
+ sparc:sparc64 | \
+ "$cpu:$cpu")
+ try='native cross' ;;
+ esac
+ eval "target_cflags=\${cross_cc_cflags_$target_arch}"
+ for t in $try; do
+ case $t in
+ native)
+ target_cc=$cc
+ target_ccas=$ccas
+ target_ar=$ar
+ target_as=$as
+ target_ld=$ld
+ target_nm=$nm
+ target_objcopy=$objcopy
+ target_ranlib=$ranlib
+ target_strip=$strip
+ ;;
+ cross)
+ target_cc=
+ if eval test -n "\"\${cross_cc_$target_arch}\""; then
+ if eval has "\"\${cross_cc_$target_arch}\""; then
+ eval "target_cc=\"\${cross_cc_$target_arch}\""
+ fi
+ else
+ compute_target_variable $target_arch target_cc gcc
+ fi
+ target_ccas=$target_cc
+ compute_target_variable $target_arch target_ar ar
+ compute_target_variable $target_arch target_as as
+ compute_target_variable $target_arch target_ld ld
+ compute_target_variable $target_arch target_nm nm
+ compute_target_variable $target_arch target_objcopy objcopy
+ compute_target_variable $target_arch target_ranlib ranlib
+ compute_target_variable $target_arch target_strip strip
+ ;;
+ esac
+
+ if test -n "$target_cc"; then
+ case $target_arch in
+ i386|x86_64)
+ if $target_cc --version | grep -qi "clang"; then
+ continue
+ fi
+ ;;
+ esac
+ elif test -n "$target_as" && test -n "$target_ld"; then
+ # Special handling for assembler only targets
+ case $target in
+ tricore-softmmu)
+ build_static=
+ got_cross_cc=yes
+ break
+ ;;
+ *)
+ continue
+ ;;
+ esac
+ else
+ continue
fi
- else
- compute_target_variable $1 target_cc gcc
- fi
- compute_target_variable $1 target_as as
- compute_target_variable $1 target_ld ld
- if test "$1" = $cpu; then
- : ${target_cc:=$cc}
- : ${target_as:=$as}
- : ${target_ld:=$ld}
- fi
- if test -n "$target_cc"; then
+
+ write_c_skeleton
case $1 in
- i386|x86_64)
- if $target_cc --version | grep -qi "clang"; then
- unset target_cc
+ *-softmmu)
+ if do_compiler "$target_cc" $target_cflags -o $TMPO -c $TMPC &&
+ do_compiler "$target_cc" $target_cflags -r -nostdlib -o "${TMPDIR1}/${TMPB}2.o" "$TMPO" -lgcc; then
+ got_cross_cc=yes
+ break
+ fi
+ ;;
+ *)
+ if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC -static ; then
+ build_static=y
+ got_cross_cc=yes
+ break
+ fi
+ if do_compiler "$target_cc" $target_cflags -o $TMPE $TMPC ; then
+ build_static=
+ got_cross_cc=yes
+ break
fi
;;
esac
+ done
+ if test $got_cross_cc != yes; then
+ build_static=
+ target_cc=
+ target_ccas=
+ target_cflags=
+ target_ar=
+ target_as=
+ target_ld=
+ target_nm=
+ target_objcopy=
+ target_ranlib=
+ target_strip=
fi
}
write_target_makefile() {
+ echo "EXTRA_CFLAGS=$target_cflags"
if test -n "$target_cc"; then
echo "CC=$target_cc"
+ echo "CCAS=$target_ccas"
+ fi
+ if test -n "$target_ar"; then
+ echo "AR=$target_ar"
fi
if test -n "$target_as"; then
echo "AS=$target_as"
if test -n "$target_ld"; then
echo "LD=$target_ld"
fi
+ if test -n "$target_nm"; then
+ echo "NM=$target_nm"
+ fi
+ if test -n "$target_objcopy"; then
+ echo "OBJCOPY=$target_objcopy"
+ fi
+ if test -n "$target_ranlib"; then
+ echo "RANLIB=$target_ranlib"
+ fi
+ if test -n "$target_strip"; then
+ echo "STRIP=$target_strip"
+ fi
}
write_container_target_makefile() {
+ echo "EXTRA_CFLAGS=$target_cflags"
if test -n "$container_cross_cc"; then
echo "CC=\$(DOCKER_SCRIPT) cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
+ echo "CCAS=\$(DOCKER_SCRIPT) cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
fi
+ echo "AR=\$(DOCKER_SCRIPT) cc --cc $container_cross_ar -i qemu/$container_image -s $source_path --"
echo "AS=\$(DOCKER_SCRIPT) cc --cc $container_cross_as -i qemu/$container_image -s $source_path --"
echo "LD=\$(DOCKER_SCRIPT) cc --cc $container_cross_ld -i qemu/$container_image -s $source_path --"
+ echo "NM=\$(DOCKER_SCRIPT) cc --cc $container_cross_nm -i qemu/$container_image -s $source_path --"
+ echo "OBJCOPY=\$(DOCKER_SCRIPT) cc --cc $container_cross_objcopy -i qemu/$container_image -s $source_path --"
+ echo "RANLIB=\$(DOCKER_SCRIPT) cc --cc $container_cross_ranlib -i qemu/$container_image -s $source_path --"
+ echo "STRIP=\$(DOCKER_SCRIPT) cc --cc $container_cross_strip -i qemu/$container_image -s $source_path --"
}
+##########################################
+# check for vfio_user_server
+
+case "$vfio_user_server" in
+ enabled )
+ if test "$git_submodules_action" != "ignore"; then
+ git_submodules="${git_submodules} subprojects/libvfio-user"
+ fi
+ ;;
+esac
+
##########################################
# End of CC checks
# After here, no more $cc or $ld runs
QEMU_GA_VERSION=$(cat $source_path/VERSION)
fi
+
+#######################################
+# cross-compiled firmware targets
+
+# Set up build tree symlinks that point back into the source tree
+# (these can be both files and directories).
+# Caution: avoid adding files or directories here using wildcards. This
+# will result in problems later if a new file matching the wildcard is
+# added to the source tree -- nothing will cause configure to be rerun
+# so the build tree will be missing the link back to the new file, and
+# tests might fail. Prefer to keep the relevant files in their own
+# directory and symlink the directory instead.
+LINKS="Makefile"
+LINKS="$LINKS tests/tcg/Makefile.target"
+LINKS="$LINKS pc-bios/optionrom/Makefile"
+LINKS="$LINKS pc-bios/s390-ccw/Makefile"
+LINKS="$LINKS pc-bios/vof/Makefile"
+LINKS="$LINKS .gdbinit scripts" # scripts needed by relative path in .gdbinit
+LINKS="$LINKS tests/avocado tests/data"
+LINKS="$LINKS tests/qemu-iotests/check"
+LINKS="$LINKS python"
+LINKS="$LINKS contrib/plugins/Makefile "
+for f in $LINKS ; do
+ if [ -e "$source_path/$f" ]; then
+ mkdir -p `dirname ./$f`
+ symlink "$source_path/$f" "$f"
+ fi
+done
+
# Mac OS X ships with a broken assembler
roms=
-if { test "$cpu" = "i386" || test "$cpu" = "x86_64"; } && \
+probe_target_compiler i386-softmmu
+if test -n "$target_cc" &&
test "$targetos" != "darwin" && test "$targetos" != "sunos" && \
test "$targetos" != "haiku" && test "$softmmu" = yes ; then
# Different host OS linkers have different ideas about the name of the ELF
# emulation. Linux and OpenBSD/amd64 use 'elf_i386'; FreeBSD uses the _fbsd
# variant; OpenBSD/i386 uses the _obsd variant; and Windows uses i386pe.
for emu in elf_i386 elf_i386_fbsd elf_i386_obsd i386pe; do
- if "$ld" -verbose 2>&1 | grep -q "^[[:space:]]*$emu[[:space:]]*$"; then
+ if "$target_ld" -verbose 2>&1 | grep -q "^[[:space:]]*$emu[[:space:]]*$"; then
ld_i386_emulation="$emu"
- roms="optionrom"
break
fi
done
+ if test -n "$ld_i386_emulation"; then
+ roms="pc-bios/optionrom"
+ config_mak=pc-bios/optionrom/config.mak
+ echo "# Automatically generated by configure - do not modify" > $config_mak
+ echo "TOPSRC_DIR=$source_path" >> $config_mak
+ echo "LD_I386_EMULATION=$ld_i386_emulation" >> $config_mak
+ write_target_makefile >> $config_mak
+ fi
+fi
+
+probe_target_compiler ppc-softmmu
+if test -n "$target_cc" && test "$softmmu" = yes; then
+ roms="$roms pc-bios/vof"
+ config_mak=pc-bios/vof/config.mak
+ echo "# Automatically generated by configure - do not modify" > $config_mak
+ echo "SRC_DIR=$source_path/pc-bios/vof" >> $config_mak
+ write_target_makefile >> $config_mak
fi
-# Only build s390-ccw bios if we're on s390x and the compiler has -march=z900
-# or -march=z10 (which is the lowest architecture level that Clang supports)
-if test "$cpu" = "s390x" ; then
+# Only build s390-ccw bios if the compiler has -march=z900 or -march=z10
+# (which is the lowest architecture level that Clang supports)
+probe_target_compiler s390x-softmmu
+if test -n "$target_cc" && test "$softmmu" = yes; then
write_c_skeleton
- compile_prog "-march=z900" ""
+ do_compiler "$target_cc" $target_cc_cflags -march=z900 -o $TMPO -c $TMPC
has_z900=$?
- if [ $has_z900 = 0 ] || compile_object "-march=z10 -msoft-float -Werror"; then
+ if [ $has_z900 = 0 ] || do_compiler "$target_cc" $target_cc_cflags -march=z10 -msoft-float -Werror -o $TMPO -c $TMPC; then
if [ $has_z900 != 0 ]; then
echo "WARNING: Your compiler does not support the z900!"
echo " The s390-ccw bios will only work with guest CPUs >= z10."
fi
- roms="$roms s390-ccw"
+ roms="$roms pc-bios/s390-ccw"
+ config_mak=pc-bios/s390-ccw/config-host.mak
+ echo "# Automatically generated by configure - do not modify" > $config_mak
+ echo "SRC_PATH=$source_path/pc-bios/s390-ccw" >> $config_mak
+ write_target_makefile >> $config_mak
# SLOF is required for building the s390-ccw firmware on s390x,
# since it is using the libnet code from SLOF for network booting.
git_submodules="${git_submodules} roms/SLOF"
fi
fi
+#######################################
+# generate config-host.mak
+
# Check that the C++ compiler exists and works with the C compiler.
# All the QEMU_CXXFLAGS are based on QEMU_CFLAGS. Keep this at the end to don't miss any other that could be added.
if has $cxx; then
echo "MESON=$meson" >> $config_host_mak
echo "NINJA=$ninja" >> $config_host_mak
echo "CC=$cc" >> $config_host_mak
-echo "AR=$ar" >> $config_host_mak
-echo "AS=$as" >> $config_host_mak
-echo "CCAS=$ccas" >> $config_host_mak
-echo "OBJCOPY=$objcopy" >> $config_host_mak
-echo "LD=$ld" >> $config_host_mak
echo "QEMU_CFLAGS=$QEMU_CFLAGS" >> $config_host_mak
echo "QEMU_CXXFLAGS=$QEMU_CXXFLAGS" >> $config_host_mak
echo "QEMU_OBJCFLAGS=$QEMU_OBJCFLAGS" >> $config_host_mak
echo "GLIB_BINDIR=$glib_bindir" >> $config_host_mak
echo "GLIB_VERSION=$(pkg-config --modversion glib-2.0)" >> $config_host_mak
echo "QEMU_LDFLAGS=$QEMU_LDFLAGS" >> $config_host_mak
-echo "LD_I386_EMULATION=$ld_i386_emulation" >> $config_host_mak
-echo "STRIP=$strip" >> $config_host_mak
echo "EXESUF=$EXESUF" >> $config_host_mak
# use included Linux headers
echo "CONFIG_SAFESTACK=y" >> $config_host_mak
fi
-# If we're using a separate build tree, set it up now.
-# LINKS are things to symlink back into the source tree
-# (these can be both files and directories).
-# Caution: do not add files or directories here using wildcards. This
-# will result in problems later if a new file matching the wildcard is
-# added to the source tree -- nothing will cause configure to be rerun
-# so the build tree will be missing the link back to the new file, and
-# tests might fail. Prefer to keep the relevant files in their own
-# directory and symlink the directory instead.
-LINKS="Makefile"
-LINKS="$LINKS tests/tcg/Makefile.target"
-LINKS="$LINKS pc-bios/optionrom/Makefile"
-LINKS="$LINKS pc-bios/s390-ccw/Makefile"
-LINKS="$LINKS .gdbinit scripts" # scripts needed by relative path in .gdbinit
-LINKS="$LINKS tests/avocado tests/data"
-LINKS="$LINKS tests/qemu-iotests/check"
-LINKS="$LINKS python"
-LINKS="$LINKS contrib/plugins/Makefile "
-for f in $LINKS ; do
- if [ -e "$source_path/$f" ]; then
- mkdir -p `dirname ./$f`
- symlink "$source_path/$f" "$f"
- fi
-done
-
# tests/tcg configuration
(makefile=tests/tcg/Makefile.prereqs
echo "# Automatically generated by configure - do not modify" > $makefile
for target in $target_list; do
arch=${target%%-*}
- probe_target_compiler ${arch}
config_target_mak=tests/tcg/config-$target.mak
echo "# Automatically generated by configure - do not modify" > $config_target_mak
echo "TARGET_NAME=$arch" >> $config_target_mak
case $target in
+ xtensa*-linux-user)
+ # the toolchain is not complete with headers, only build softmmu tests
+ continue
+ ;;
*-softmmu)
test -f $source_path/tests/tcg/$arch/Makefile.softmmu-target || continue
qemu="qemu-system-$arch"
;;
esac
- got_cross_cc=no
- unset build_static
-
- if test -n "$target_cc"; then
- write_c_skeleton
- if ! do_compiler "$target_cc" $target_cflags \
- -o $TMPE $TMPC -static ; then
- # For host systems we might get away with building without -static
- if do_compiler "$target_cc" $target_cflags \
- -o $TMPE $TMPC ; then
- got_cross_cc=yes
- fi
- else
- got_cross_cc=yes
- build_static=y
- fi
- elif test -n "$target_as" && test -n "$target_ld"; then
- # Special handling for assembler only tests
- case $target in
- tricore-softmmu) got_cross_cc=yes ;;
- esac
- fi
-
+ probe_target_compiler $target
if test $got_cross_cc = yes; then
# Test for compiler features for optional tests. We only do this
# for cross compilers because ensuring the docker containers based
if test $got_cross_cc = yes; then
mkdir -p tests/tcg/$target
echo "QEMU=$PWD/$qemu" >> $config_target_mak
- echo "EXTRA_CFLAGS=$target_cflags" >> $config_target_mak
echo "run-tcg-tests-$target: $qemu\$(EXESUF)" >> $makefile
tcg_tests_targets="$tcg_tests_targets $target"
fi
done
echo "TCG_TESTS_TARGETS=$tcg_tests_targets" >> $makefile)
-config_mak=pc-bios/optionrom/config.mak
-echo "# Automatically generated by configure - do not modify" > $config_mak
-echo "TOPSRC_DIR=$source_path" >> $config_mak
-
if test "$skip_meson" = no; then
cross="config-meson.cross.new"
meson_quote() {
test "$slirp" != auto && meson_option_add "-Dslirp=$slirp"
test "$smbd" != '' && meson_option_add "-Dsmbd=$smbd"
test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
+ test "$vfio_user_server" != auto && meson_option_add "-Dvfio_user_server=$vfio_user_server"
run_meson() {
NINJA=$ninja $meson setup --prefix "$prefix" "$@" $cross_arg "$PWD" "$source_path"
}
preserve_env CFLAGS
preserve_env CXX
preserve_env CXXFLAGS
-preserve_env INSTALL
preserve_env LD
preserve_env LDFLAGS
preserve_env LD_LIBRARY_PATH
-preserve_env LIBTOOL
preserve_env MAKE
preserve_env NM
+preserve_env OBJCFLAGS
preserve_env OBJCOPY
preserve_env PATH
preserve_env PKG_CONFIG