2003-03-07 02:23:54 +03:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
2003-03-23 23:17:16 +03:00
|
|
|
# qemu configure script (c) 2003 Fabrice Bellard
|
2003-03-07 02:23:54 +03:00
|
|
|
#
|
2014-05-23 20:07:24 +04:00
|
|
|
|
2014-05-28 14:39:17 +04:00
|
|
|
# Unset some variables known to interfere with behavior of common tools,
|
2023-05-25 18:46:07 +03:00
|
|
|
# just as autoconf does. Unlike autoconf, we assume that unset exists.
|
|
|
|
unset CLICOLOR_FORCE GREP_OPTIONS BASH_ENV ENV MAIL MAILPATH CDPATH
|
2014-05-28 14:39:17 +04:00
|
|
|
|
2015-10-28 20:56:40 +03:00
|
|
|
# Don't allow CCACHE, if present, to use cached results of compile tests!
|
|
|
|
export CCACHE_RECACHE=yes
|
|
|
|
|
2020-08-21 13:22:04 +03:00
|
|
|
# make source path absolute
|
|
|
|
source_path=$(cd "$(dirname -- "$0")"; pwd)
|
|
|
|
|
|
|
|
if test "$PWD" = "$source_path"
|
|
|
|
then
|
|
|
|
echo "Using './build' as the directory for build output"
|
|
|
|
|
|
|
|
MARKER=build/auto-created-by-configure
|
|
|
|
|
|
|
|
if test -e build
|
|
|
|
then
|
|
|
|
if test -f $MARKER
|
|
|
|
then
|
|
|
|
rm -rf build
|
|
|
|
else
|
|
|
|
echo "ERROR: ./build dir already exists and was not previously created by configure"
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2023-02-21 14:06:30 +03:00
|
|
|
if ! mkdir build || ! touch $MARKER
|
|
|
|
then
|
|
|
|
echo "ERROR: Could not create ./build directory. Check the permissions on"
|
|
|
|
echo "your source directory, or try doing an out-of-tree build."
|
|
|
|
exit 1
|
|
|
|
fi
|
2020-08-21 13:22:04 +03:00
|
|
|
|
|
|
|
cat > GNUmakefile <<'EOF'
|
|
|
|
# This file is auto-generated by configure to support in-source tree
|
|
|
|
# 'make' command invocation
|
|
|
|
|
2023-11-19 13:16:02 +03:00
|
|
|
build:
|
2020-08-21 13:22:04 +03:00
|
|
|
@echo 'changing dir to build for $(MAKE) "$(MAKECMDGOALS)"...'
|
|
|
|
@$(MAKE) -C build -f Makefile $(MAKECMDGOALS)
|
|
|
|
@if test "$(MAKECMDGOALS)" = "distclean" && \
|
|
|
|
test -e build/auto-created-by-configure ; \
|
|
|
|
then \
|
|
|
|
rm -rf build GNUmakefile ; \
|
|
|
|
fi
|
2023-11-19 13:16:02 +03:00
|
|
|
%: build
|
|
|
|
@
|
|
|
|
.PHONY: build
|
2020-08-21 13:22:04 +03:00
|
|
|
GNUmakefile: ;
|
|
|
|
|
|
|
|
EOF
|
|
|
|
cd build
|
2022-08-25 18:06:59 +03:00
|
|
|
exec "$source_path/configure" "$@"
|
2020-08-21 13:22:04 +03:00
|
|
|
fi
|
|
|
|
|
2014-05-23 20:07:24 +04:00
|
|
|
# Temporary directory used for files created while
|
|
|
|
# configure runs. Since it is in the build directory
|
|
|
|
# we can safely blow away any previous version of it
|
|
|
|
# (and we need not jump through hoops to try to delete
|
|
|
|
# it when configure exits.)
|
|
|
|
TMPDIR1="config-temp"
|
|
|
|
rm -rf "${TMPDIR1}"
|
2022-08-25 18:07:02 +03:00
|
|
|
if ! mkdir -p "${TMPDIR1}"; then
|
2014-05-23 20:07:24 +04:00
|
|
|
echo "ERROR: failed to create temporary directory"
|
|
|
|
exit 1
|
2003-03-07 02:23:54 +03:00
|
|
|
fi
|
|
|
|
|
2014-05-23 20:07:24 +04:00
|
|
|
TMPB="qemu-conf"
|
|
|
|
TMPC="${TMPDIR1}/${TMPB}.c"
|
2014-01-03 06:12:46 +04:00
|
|
|
TMPO="${TMPDIR1}/${TMPB}.o"
|
2014-05-23 20:07:24 +04:00
|
|
|
TMPE="${TMPDIR1}/${TMPB}.exe"
|
2003-03-07 02:23:54 +03:00
|
|
|
|
2010-04-23 15:44:10 +04:00
|
|
|
rm -f config.log
|
2008-11-29 23:09:56 +03:00
|
|
|
|
2011-11-23 21:26:44 +04:00
|
|
|
# Print a helpful header at the top of config.log
|
|
|
|
echo "# QEMU configure log $(date)" >> config.log
|
2012-03-07 16:16:29 +04:00
|
|
|
printf "# Configured with:" >> config.log
|
2022-12-21 12:04:08 +03:00
|
|
|
# repeat the invocation to log and stdout for CI
|
|
|
|
invoke=$(printf " '%s'" "$0" "$@")
|
|
|
|
test -n "$GITLAB_CI" && echo "configuring with: $invoke"
|
|
|
|
{ echo "$invoke"; echo; echo "#"; } >> config.log
|
2011-11-23 21:26:44 +04:00
|
|
|
|
2020-09-08 14:20:45 +03:00
|
|
|
quote_sh() {
|
|
|
|
printf "%s" "$1" | sed "s,','\\\\'',g; s,.*,'&',"
|
|
|
|
}
|
|
|
|
|
2023-09-28 13:07:23 +03:00
|
|
|
error_exit() {
|
2017-07-03 17:58:28 +03:00
|
|
|
(echo
|
2013-04-08 15:11:26 +04:00
|
|
|
echo "ERROR: $1"
|
|
|
|
while test -n "$2"; do
|
|
|
|
echo " $2"
|
|
|
|
shift
|
|
|
|
done
|
2017-07-03 17:58:28 +03:00
|
|
|
echo) >&2
|
2013-04-08 15:11:26 +04:00
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
|
2014-02-25 22:27:49 +04:00
|
|
|
do_compiler() {
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
# Run the compiler, capturing its output to the log. First argument
|
|
|
|
# is compiler binary to execute.
|
2022-08-25 18:07:03 +03:00
|
|
|
compiler="$1"
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
shift
|
|
|
|
if test -n "$BASH_VERSION"; then eval '
|
|
|
|
echo >>config.log "
|
|
|
|
funcs: ${FUNCNAME[*]}
|
|
|
|
lines: ${BASH_LINENO[*]}"
|
|
|
|
'; fi
|
|
|
|
echo $compiler "$@" >> config.log
|
|
|
|
$compiler "$@" >> config.log 2>&1 || return $?
|
|
|
|
}
|
|
|
|
|
2014-02-25 22:27:49 +04:00
|
|
|
do_cc() {
|
2022-10-18 10:38:44 +03:00
|
|
|
do_compiler "$cc" $CPU_CFLAGS "$@"
|
2014-02-25 22:27:49 +04:00
|
|
|
}
|
|
|
|
|
2009-08-03 16:46:03 +04:00
|
|
|
compile_object() {
|
2015-03-26 01:57:39 +03:00
|
|
|
local_cflags="$1"
|
2022-10-20 15:20:30 +03:00
|
|
|
do_cc $CFLAGS $EXTRA_CFLAGS $local_cflags -c -o $TMPO $TMPC
|
2009-08-03 16:46:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
compile_prog() {
|
|
|
|
local_cflags="$1"
|
|
|
|
local_ldflags="$2"
|
2022-10-20 15:20:30 +03:00
|
|
|
do_cc $CFLAGS $EXTRA_CFLAGS $local_cflags -o $TMPE $TMPC \
|
|
|
|
$LDFLAGS $EXTRA_LDFLAGS $local_ldflags
|
2009-08-03 16:46:03 +04:00
|
|
|
}
|
|
|
|
|
2010-12-23 13:43:58 +03:00
|
|
|
# symbolically link $1 to $2. Portable version of "ln -sf".
|
|
|
|
symlink() {
|
2012-03-19 16:20:47 +04:00
|
|
|
rm -rf "$2"
|
2012-06-06 12:57:00 +04:00
|
|
|
mkdir -p "$(dirname "$2")"
|
2012-03-19 16:20:47 +04:00
|
|
|
ln -s "$1" "$2"
|
2010-12-23 13:43:58 +03:00
|
|
|
}
|
|
|
|
|
2010-01-29 00:26:51 +03:00
|
|
|
# check whether a command is available to this shell (may be either an
|
|
|
|
# executable or a builtin)
|
|
|
|
has() {
|
|
|
|
type "$1" >/dev/null 2>&1
|
|
|
|
}
|
|
|
|
|
2019-08-21 10:21:16 +03:00
|
|
|
version_ge () {
|
2021-02-02 16:39:52 +03:00
|
|
|
local_ver1=$(expr "$1" : '\([0-9.]*\)' | tr . ' ')
|
|
|
|
local_ver2=$(echo "$2" | tr . ' ')
|
2019-08-21 10:21:16 +03:00
|
|
|
while true; do
|
|
|
|
set x $local_ver1
|
|
|
|
local_first=${2-0}
|
2020-08-21 23:35:58 +03:00
|
|
|
# 'shift 2' if $2 is set, or 'shift' if $2 is not set
|
|
|
|
shift ${2:+2}
|
2019-08-21 10:21:16 +03:00
|
|
|
local_ver1=$*
|
|
|
|
set x $local_ver2
|
|
|
|
# the second argument finished, the first must be greater or equal
|
|
|
|
test $# = 1 && return 0
|
|
|
|
test $local_first -lt $2 && return 1
|
|
|
|
test $local_first -gt $2 && return 0
|
2020-08-21 23:35:58 +03:00
|
|
|
shift ${2:+2}
|
2019-08-21 10:21:16 +03:00
|
|
|
local_ver2=$*
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2019-05-26 17:47:47 +03:00
|
|
|
if printf %s\\n "$source_path" "$PWD" | grep -q "[[:space:]:]";
|
|
|
|
then
|
|
|
|
error_exit "main directory cannot contain spaces nor colons"
|
|
|
|
fi
|
|
|
|
|
2023-05-11 10:34:13 +03:00
|
|
|
# parse CC options first; some compiler tests are used to establish
|
|
|
|
# some defaults, based on the host environment
|
|
|
|
|
2019-05-26 17:47:46 +03:00
|
|
|
# default parameters
|
2023-10-09 19:40:45 +03:00
|
|
|
container_engine="auto"
|
2009-08-03 16:45:55 +04:00
|
|
|
cpu=""
|
2021-01-26 04:24:48 +03:00
|
|
|
cross_compile="no"
|
2003-03-07 02:23:54 +03:00
|
|
|
cross_prefix=""
|
2012-12-07 19:39:13 +04:00
|
|
|
host_cc="cc"
|
2023-05-11 10:34:13 +03:00
|
|
|
EXTRA_CFLAGS=""
|
|
|
|
EXTRA_CXXFLAGS=""
|
|
|
|
EXTRA_OBJCFLAGS=""
|
|
|
|
EXTRA_LDFLAGS=""
|
2010-12-23 13:43:50 +03:00
|
|
|
|
|
|
|
# Default value for a variable defining feature "foo".
|
|
|
|
# * foo="no" feature will only be used if --enable-foo arg is given
|
|
|
|
# * foo="" feature will be searched for, and if found, will be used
|
|
|
|
# unless --disable-foo is given
|
|
|
|
# * foo="yes" this value will only be set by --enable-foo flag.
|
|
|
|
# feature will searched for,
|
|
|
|
# if not found, configure exits with error
|
|
|
|
#
|
|
|
|
# Always add --enable-foo and --disable-foo command line args.
|
|
|
|
# Distributions want to ensure that several features are compiled in, and it
|
|
|
|
# is impossible without a --enable-foo that exits if a feature is not found.
|
2020-12-10 22:04:13 +03:00
|
|
|
default_feature=""
|
2021-10-07 16:08:29 +03:00
|
|
|
|
2008-12-29 20:14:15 +03:00
|
|
|
for opt do
|
2016-05-16 16:10:20 +03:00
|
|
|
optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
|
2008-12-29 20:14:15 +03:00
|
|
|
case "$opt" in
|
|
|
|
--cross-prefix=*) cross_prefix="$optarg"
|
2021-01-26 04:24:48 +03:00
|
|
|
cross_compile="yes"
|
2008-12-29 20:14:15 +03:00
|
|
|
;;
|
2010-12-23 13:43:48 +03:00
|
|
|
--cc=*) CC="$optarg"
|
2008-12-29 20:14:15 +03:00
|
|
|
;;
|
2013-08-07 19:39:36 +04:00
|
|
|
--cxx=*) CXX="$optarg"
|
|
|
|
;;
|
2023-04-18 19:15:54 +03:00
|
|
|
--objcc=*) objcc="$optarg"
|
|
|
|
;;
|
2009-08-03 16:45:55 +04:00
|
|
|
--cpu=*) cpu="$optarg"
|
|
|
|
;;
|
2021-11-05 12:09:26 +03:00
|
|
|
--extra-cflags=*)
|
|
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $optarg"
|
|
|
|
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $optarg"
|
2022-01-09 00:38:55 +03:00
|
|
|
EXTRA_OBJCFLAGS="$EXTRA_OBJCFLAGS $optarg"
|
2021-11-05 12:09:26 +03:00
|
|
|
;;
|
|
|
|
--extra-cxxflags=*) EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $optarg"
|
2017-06-06 16:07:47 +03:00
|
|
|
;;
|
2022-01-09 00:38:55 +03:00
|
|
|
--extra-objcflags=*) EXTRA_OBJCFLAGS="$EXTRA_OBJCFLAGS $optarg"
|
|
|
|
;;
|
2021-11-05 12:09:26 +03:00
|
|
|
--extra-ldflags=*) EXTRA_LDFLAGS="$EXTRA_LDFLAGS $optarg"
|
2009-08-03 16:46:02 +04:00
|
|
|
;;
|
2018-04-04 22:27:05 +03:00
|
|
|
--cross-cc-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --cross-cc-FOO option"
|
|
|
|
;;
|
2022-01-20 20:31:41 +03:00
|
|
|
--cross-cc-cflags-*) cc_arch=${opt#--cross-cc-cflags-}; cc_arch=${cc_arch%%=*}
|
2018-04-13 13:07:58 +03:00
|
|
|
eval "cross_cc_cflags_${cc_arch}=\$optarg"
|
|
|
|
;;
|
2018-04-04 22:27:05 +03:00
|
|
|
--cross-cc-*) cc_arch=${opt#--cross-cc-}; cc_arch=${cc_arch%%=*}
|
|
|
|
eval "cross_cc_${cc_arch}=\$optarg"
|
|
|
|
;;
|
2022-05-27 18:35:51 +03:00
|
|
|
--cross-prefix-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --cross-prefix-FOO option"
|
|
|
|
;;
|
|
|
|
--cross-prefix-*) cc_arch=${opt#--cross-prefix-}; cc_arch=${cc_arch%%=*}
|
|
|
|
eval "cross_prefix_${cc_arch}=\$optarg"
|
|
|
|
;;
|
2023-05-11 10:34:13 +03:00
|
|
|
--without-default-features) default_feature="no"
|
|
|
|
;;
|
2008-12-29 20:14:15 +03:00
|
|
|
esac
|
|
|
|
done
|
|
|
|
|
2023-09-07 13:54:42 +03:00
|
|
|
default_cflags='-O2 -g'
|
2023-05-30 17:03:50 +03:00
|
|
|
git_submodules_action="update"
|
2023-05-11 10:34:13 +03:00
|
|
|
docs="auto"
|
|
|
|
EXESUF=""
|
2023-10-04 16:46:56 +03:00
|
|
|
system="yes"
|
2023-05-11 10:34:13 +03:00
|
|
|
linux_user=""
|
|
|
|
bsd_user=""
|
|
|
|
plugins="$default_feature"
|
2023-08-30 13:05:08 +03:00
|
|
|
subdirs=""
|
2023-05-11 10:34:13 +03:00
|
|
|
ninja=""
|
|
|
|
python=
|
2023-05-18 17:11:29 +03:00
|
|
|
download="enabled"
|
2023-05-11 10:34:13 +03:00
|
|
|
skip_meson=no
|
|
|
|
use_containers="yes"
|
|
|
|
gdb_bin=$(command -v "gdb-multiarch" || command -v "gdb")
|
|
|
|
gdb_arches=""
|
|
|
|
|
|
|
|
# Don't accept a target_list environment variable.
|
|
|
|
unset target_list
|
|
|
|
unset target_list_exclude
|
|
|
|
|
|
|
|
# The following Meson options are handled manually (still they
|
|
|
|
# are included in the automatically generated help message)
|
meson: subprojects: replace submodules with wrap files
Compared to submodules, .wrap files have several advantages:
* option parsing and downloading is delegated to meson
* the commit is stored in a text file instead of a magic entry in the
git tree object
* we could stop shipping external dependencies that are only used as a
fallback, but not break compilation on platforms that lack them.
For example it may make sense to download dtc at build time, controlled
by --enable-download, even when building from a tarball. Right now,
this patch does the opposite: make-release treats dtc like libvfio-user
(which is not stable API and therefore hasn't found its way into any
distros) and keycodemap (which is a copylib, for better or worse).
dependency() can fall back to a wrap automatically. However, this
is only possible for libraries that come with a .pc file, and this
is not very common for libfdt even though the upstream project in
principle provides it; it also removes the control that we provide with
--enable-fdt={system,internal}. Therefore, the logic to pick system
vs. internal libfdt is left untouched.
--enable-fdt=git is removed; it was already a synonym for
--enable-fdt=internal.
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-18 17:50:00 +03:00
|
|
|
# because they automatically enable/disable other options
|
2023-05-11 10:34:13 +03:00
|
|
|
tcg="auto"
|
|
|
|
cfi="false"
|
|
|
|
|
meson: subprojects: replace submodules with wrap files
Compared to submodules, .wrap files have several advantages:
* option parsing and downloading is delegated to meson
* the commit is stored in a text file instead of a magic entry in the
git tree object
* we could stop shipping external dependencies that are only used as a
fallback, but not break compilation on platforms that lack them.
For example it may make sense to download dtc at build time, controlled
by --enable-download, even when building from a tarball. Right now,
this patch does the opposite: make-release treats dtc like libvfio-user
(which is not stable API and therefore hasn't found its way into any
distros) and keycodemap (which is a copylib, for better or worse).
dependency() can fall back to a wrap automatically. However, this
is only possible for libraries that come with a .pc file, and this
is not very common for libfdt even though the upstream project in
principle provides it; it also removes the control that we provide with
--enable-fdt={system,internal}. Therefore, the logic to pick system
vs. internal libfdt is left untouched.
--enable-fdt=git is removed; it was already a synonym for
--enable-fdt=internal.
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-18 17:50:00 +03:00
|
|
|
# Meson has PIE as a boolean rather than enabled/disabled/auto,
|
|
|
|
# and we also need to check for -static-pie before Meson runs
|
|
|
|
# which requires knowing whether --static is enabled.
|
2023-05-11 10:34:13 +03:00
|
|
|
pie=""
|
|
|
|
static="no"
|
|
|
|
|
2012-12-07 19:39:13 +04:00
|
|
|
# Preferred compiler:
|
|
|
|
# ${CC} (if set)
|
|
|
|
# ${cross_prefix}gcc (if cross-prefix specified)
|
|
|
|
# system compiler
|
|
|
|
if test -z "${CC}${cross_prefix}"; then
|
2023-07-07 17:12:19 +03:00
|
|
|
cc="cc"
|
2012-12-07 19:39:13 +04:00
|
|
|
else
|
|
|
|
cc="${CC-${cross_prefix}gcc}"
|
|
|
|
fi
|
|
|
|
|
2013-08-07 19:39:36 +04:00
|
|
|
if test -z "${CXX}${cross_prefix}"; then
|
|
|
|
cxx="c++"
|
|
|
|
else
|
|
|
|
cxx="${CXX-${cross_prefix}g++}"
|
|
|
|
fi
|
|
|
|
|
2023-04-18 19:15:54 +03:00
|
|
|
# Preferred ObjC compiler:
|
|
|
|
# $objcc (if set, i.e. via --objcc option)
|
|
|
|
# ${cross_prefix}clang (if cross-prefix specified)
|
|
|
|
# clang (if available)
|
|
|
|
# $cc
|
|
|
|
if test -z "${objcc}${cross_prefix}"; then
|
|
|
|
if has clang; then
|
|
|
|
objcc=clang
|
|
|
|
else
|
|
|
|
objcc="$cc"
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
objcc="${objcc-${cross_prefix}clang}"
|
|
|
|
fi
|
|
|
|
|
2011-08-05 02:10:08 +04:00
|
|
|
ar="${AR-${cross_prefix}ar}"
|
2016-07-08 07:49:36 +03:00
|
|
|
as="${AS-${cross_prefix}as}"
|
2016-06-23 20:39:18 +03:00
|
|
|
ccas="${CCAS-$cc}"
|
2023-11-06 21:51:02 +03:00
|
|
|
dlltool="${DLLTOOL-${cross_prefix}dlltool}"
|
2011-08-05 02:10:08 +04:00
|
|
|
objcopy="${OBJCOPY-${cross_prefix}objcopy}"
|
|
|
|
ld="${LD-${cross_prefix}ld}"
|
2017-11-08 04:10:46 +03:00
|
|
|
ranlib="${RANLIB-${cross_prefix}ranlib}"
|
2014-09-18 23:55:08 +04:00
|
|
|
nm="${NM-${cross_prefix}nm}"
|
2011-08-05 02:10:08 +04:00
|
|
|
strip="${STRIP-${cross_prefix}strip}"
|
2022-04-28 21:15:25 +03:00
|
|
|
widl="${WIDL-${cross_prefix}widl}"
|
2011-08-05 02:10:08 +04:00
|
|
|
windres="${WINDRES-${cross_prefix}windres}"
|
2022-11-29 20:38:08 +03:00
|
|
|
windmc="${WINDMC-${cross_prefix}windmc}"
|
2022-10-12 14:03:18 +03:00
|
|
|
pkg_config="${PKG_CONFIG-${cross_prefix}pkg-config}"
|
ui/sdl2 : initial port to SDL 2.0 (v2.0)
I've ported the SDL1.2 code over, and rewritten it to use the SDL2 interface.
The biggest changes were in the input handling, where SDL2 has done a major
overhaul, and I've had to include a generated translation file to get from
SDL2 codes back to qemu compatible ones. I'm still not sure how the keyboard
layout code works in qemu, so there may be further work if someone can point
me a test case that works with SDL1.2 and doesn't with SDL2.
Some SDL env vars we used to set are no longer used by SDL2,
Windows, OSX support is untested,
I don't think we can link to SDL1.2 and SDL2 at the same time, so I felt
using --with-sdlabi=2.0 to select the new code should be fine, like how
gtk does it.
v1.1: fix keys in text console
v1.2: fix shutdown, cleanups a bit of code, support ARGB cursor
v2.0: merge the SDL multihead patch into this, g_new the number of consoles
needed, wrap DCL inside per-console structure.
Signed-off-by: Dave Airlie <airlied@redhat.com>
Fixes & improvements by kraxel:
* baum build fix
* remove text console logic
* adapt to new input core
* codestyle fixups
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2013-12-10 08:05:51 +04:00
|
|
|
sdl2_config="${SDL2_CONFIG-${cross_prefix}sdl2-config}"
|
2008-12-29 20:14:15 +03:00
|
|
|
|
|
|
|
check_define() {
|
|
|
|
cat > $TMPC <<EOF
|
|
|
|
#if !defined($1)
|
2011-11-23 21:26:43 +04:00
|
|
|
#error $1 not defined
|
2008-12-29 20:14:15 +03:00
|
|
|
#endif
|
|
|
|
int main(void) { return 0; }
|
|
|
|
EOF
|
2009-08-03 16:46:03 +04:00
|
|
|
compile_object
|
2008-12-29 20:14:15 +03:00
|
|
|
}
|
|
|
|
|
2015-03-26 01:57:37 +03:00
|
|
|
write_c_skeleton() {
|
|
|
|
cat > $TMPC <<EOF
|
|
|
|
int main(void) { return 0; }
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
2012-08-14 18:35:34 +04:00
|
|
|
if check_define __linux__ ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=linux
|
2012-08-14 18:35:34 +04:00
|
|
|
elif check_define _WIN32 ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=windows
|
2012-08-14 18:35:34 +04:00
|
|
|
elif check_define __OpenBSD__ ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=openbsd
|
2012-08-14 18:35:34 +04:00
|
|
|
elif check_define __sun__ ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=sunos
|
2012-08-14 18:35:34 +04:00
|
|
|
elif check_define __HAIKU__ ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=haiku
|
2017-07-13 18:15:32 +03:00
|
|
|
elif check_define __FreeBSD__ ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=freebsd
|
2017-07-13 18:15:32 +03:00
|
|
|
elif check_define __FreeBSD_kernel__ && check_define __GLIBC__; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=gnu/kfreebsd
|
2017-07-13 18:15:32 +03:00
|
|
|
elif check_define __DragonFly__ ; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=dragonfly
|
2017-07-13 18:15:32 +03:00
|
|
|
elif check_define __NetBSD__; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=netbsd
|
2017-07-13 18:15:32 +03:00
|
|
|
elif check_define __APPLE__; then
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=darwin
|
2012-08-14 18:35:34 +04:00
|
|
|
else
|
2017-07-13 18:15:32 +03:00
|
|
|
# This is a fatal error, but don't report it yet, because we
|
|
|
|
# might be going to just print the --help text, or it might
|
|
|
|
# be the result of a missing compiler.
|
2023-11-03 11:17:48 +03:00
|
|
|
host_os=bogus
|
2012-08-14 18:35:34 +04:00
|
|
|
fi
|
|
|
|
|
2009-08-03 16:45:55 +04:00
|
|
|
if test ! -z "$cpu" ; then
|
|
|
|
# command line argument
|
|
|
|
:
|
|
|
|
elif check_define __i386__ ; then
|
2008-12-29 20:14:15 +03:00
|
|
|
cpu="i386"
|
|
|
|
elif check_define __x86_64__ ; then
|
2013-08-20 23:20:05 +04:00
|
|
|
if check_define __ILP32__ ; then
|
|
|
|
cpu="x32"
|
|
|
|
else
|
|
|
|
cpu="x86_64"
|
|
|
|
fi
|
2008-12-31 19:55:26 +03:00
|
|
|
elif check_define __sparc__ ; then
|
|
|
|
if check_define __arch64__ ; then
|
|
|
|
cpu="sparc64"
|
|
|
|
else
|
|
|
|
cpu="sparc"
|
|
|
|
fi
|
2009-01-14 21:39:52 +03:00
|
|
|
elif check_define _ARCH_PPC ; then
|
|
|
|
if check_define _ARCH_PPC64 ; then
|
2019-05-02 01:38:18 +03:00
|
|
|
if check_define _LITTLE_ENDIAN ; then
|
|
|
|
cpu="ppc64le"
|
|
|
|
else
|
|
|
|
cpu="ppc64"
|
|
|
|
fi
|
2009-01-14 21:39:52 +03:00
|
|
|
else
|
|
|
|
cpu="ppc"
|
|
|
|
fi
|
2009-10-17 16:17:47 +04:00
|
|
|
elif check_define __mips__ ; then
|
|
|
|
cpu="mips"
|
2010-06-13 14:28:21 +04:00
|
|
|
elif check_define __s390__ ; then
|
|
|
|
if check_define __s390x__ ; then
|
|
|
|
cpu="s390x"
|
|
|
|
else
|
|
|
|
cpu="s390"
|
|
|
|
fi
|
2018-12-19 22:20:19 +03:00
|
|
|
elif check_define __riscv ; then
|
2023-07-11 14:06:19 +03:00
|
|
|
if check_define _LP64 ; then
|
|
|
|
cpu="riscv64"
|
|
|
|
else
|
|
|
|
cpu="riscv32"
|
|
|
|
fi
|
2011-11-30 13:57:48 +04:00
|
|
|
elif check_define __arm__ ; then
|
|
|
|
cpu="arm"
|
2013-06-12 19:20:23 +04:00
|
|
|
elif check_define __aarch64__ ; then
|
|
|
|
cpu="aarch64"
|
2021-12-21 08:41:04 +03:00
|
|
|
elif check_define __loongarch64 ; then
|
|
|
|
cpu="loongarch64"
|
2008-12-29 20:14:15 +03:00
|
|
|
else
|
2022-10-12 16:27:03 +03:00
|
|
|
# Using uname is really broken, but it is just a fallback for architectures
|
|
|
|
# that are going to use TCI anyway
|
2016-05-16 16:10:20 +03:00
|
|
|
cpu=$(uname -m)
|
2022-10-12 16:27:03 +03:00
|
|
|
echo "WARNING: unrecognized host CPU, proceeding with 'uname -m' output '$cpu'"
|
2008-12-29 20:14:15 +03:00
|
|
|
fi
|
|
|
|
|
2023-08-08 15:03:03 +03:00
|
|
|
# Normalise host CPU name to the values used by Meson cross files and in source
|
|
|
|
# directories, and set multilib cflags. The canonicalization isn't really
|
|
|
|
# necessary, because the architectures that we check for should not hit the
|
|
|
|
# 'uname -m' case, but better safe than sorry in case --cpu= is used.
|
|
|
|
#
|
2011-12-24 17:07:25 +04:00
|
|
|
# Note that this case should only have supported host CPUs, not guests.
|
2023-08-08 15:03:03 +03:00
|
|
|
# Please keep it sorted and synchronized with meson.build's host_arch.
|
|
|
|
host_arch=
|
|
|
|
linux_arch=
|
2003-03-07 02:23:54 +03:00
|
|
|
case "$cpu" in
|
2023-08-08 15:03:03 +03:00
|
|
|
aarch64)
|
|
|
|
host_arch=aarch64
|
|
|
|
linux_arch=arm64
|
|
|
|
;;
|
|
|
|
|
2021-11-09 11:23:56 +03:00
|
|
|
armv*b|armv*l|arm)
|
2023-08-08 15:03:03 +03:00
|
|
|
cpu=arm
|
|
|
|
host_arch=arm
|
|
|
|
linux_arch=arm
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
|
2022-10-12 16:27:03 +03:00
|
|
|
i386|i486|i586|i686)
|
2003-08-11 01:36:04 +04:00
|
|
|
cpu="i386"
|
2023-08-08 15:03:03 +03:00
|
|
|
host_arch=i386
|
|
|
|
linux_arch=x86
|
|
|
|
CPU_CFLAGS="-m32"
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
|
2023-08-08 15:03:03 +03:00
|
|
|
loongarch*)
|
|
|
|
cpu=loongarch64
|
|
|
|
host_arch=loongarch64
|
2024-01-16 04:39:52 +03:00
|
|
|
linux_arch=loongarch
|
2023-08-08 15:03:03 +03:00
|
|
|
;;
|
|
|
|
|
|
|
|
mips64*)
|
|
|
|
cpu=mips64
|
|
|
|
host_arch=mips
|
|
|
|
linux_arch=mips
|
|
|
|
;;
|
2009-10-17 16:17:47 +04:00
|
|
|
mips*)
|
2023-08-08 15:03:03 +03:00
|
|
|
cpu=mips
|
|
|
|
host_arch=mips
|
|
|
|
linux_arch=mips
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
|
|
|
|
ppc)
|
2023-08-08 15:03:03 +03:00
|
|
|
host_arch=ppc
|
|
|
|
linux_arch=powerpc
|
|
|
|
CPU_CFLAGS="-m32"
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
ppc64)
|
2023-08-08 15:03:03 +03:00
|
|
|
host_arch=ppc64
|
|
|
|
linux_arch=powerpc
|
|
|
|
CPU_CFLAGS="-m64 -mbig-endian"
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
ppc64le)
|
2023-08-08 15:03:03 +03:00
|
|
|
cpu=ppc64
|
|
|
|
host_arch=ppc64
|
|
|
|
linux_arch=powerpc
|
|
|
|
CPU_CFLAGS="-m64 -mlittle-endian"
|
|
|
|
;;
|
|
|
|
|
|
|
|
riscv32 | riscv64)
|
|
|
|
host_arch=riscv
|
|
|
|
linux_arch=riscv
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
|
|
|
|
s390)
|
2023-08-08 15:03:03 +03:00
|
|
|
linux_arch=s390
|
|
|
|
CPU_CFLAGS="-m31"
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
s390x)
|
2023-08-08 15:03:03 +03:00
|
|
|
host_arch=s390x
|
|
|
|
linux_arch=s390
|
|
|
|
CPU_CFLAGS="-m64"
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
|
2007-04-16 22:27:06 +04:00
|
|
|
sparc|sun4[cdmuv])
|
2023-08-08 15:03:03 +03:00
|
|
|
cpu=sparc
|
|
|
|
CPU_CFLAGS="-m32 -mv8plus -mcpu=ultrasparc"
|
|
|
|
;;
|
2021-11-09 11:23:56 +03:00
|
|
|
sparc64)
|
2023-08-08 15:03:03 +03:00
|
|
|
host_arch=sparc64
|
|
|
|
CPU_CFLAGS="-m64 -mcpu=ultrasparc"
|
|
|
|
;;
|
|
|
|
|
|
|
|
x32)
|
|
|
|
cpu="x86_64"
|
|
|
|
host_arch=x86_64
|
|
|
|
linux_arch=x86
|
|
|
|
CPU_CFLAGS="-mx32"
|
|
|
|
;;
|
|
|
|
x86_64|amd64)
|
|
|
|
cpu="x86_64"
|
|
|
|
host_arch=x86_64
|
|
|
|
linux_arch=x86
|
|
|
|
# ??? Only extremely old AMD cpus do not have cmpxchg16b.
|
|
|
|
# If we truly care, we should simply detect this case at
|
|
|
|
# runtime and generate the fallback to serial emulation.
|
|
|
|
CPU_CFLAGS="-m64 -mcx16"
|
|
|
|
;;
|
2003-03-07 02:23:54 +03:00
|
|
|
esac
|
2009-08-12 20:20:24 +04:00
|
|
|
|
2023-08-08 15:03:03 +03:00
|
|
|
if test -n "$host_arch" && {
|
|
|
|
! test -d "$source_path/linux-user/include/host/$host_arch" ||
|
|
|
|
! test -d "$source_path/common-user/host/$host_arch"; }; then
|
|
|
|
error_exit "linux-user/include/host/$host_arch does not exist." \
|
|
|
|
"This is a bug in the configure script, please report it."
|
|
|
|
fi
|
|
|
|
if test -n "$linux_arch" && ! test -d "$source_path/linux-headers/asm-$linux_arch"; then
|
|
|
|
error_exit "linux-headers/asm-$linux_arch does not exist." \
|
|
|
|
"This is a bug in the configure script, please report it."
|
|
|
|
fi
|
|
|
|
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
check_py_version() {
|
Python: Drop support for Python 3.7
Debian 10 is not anymore a supported distro, since Debian 12 was
released on June 10, 2023. Our supported build platforms as of today
all support at least 3.8 (and all of them except for Ubuntu 20.04
support 3.9):
openSUSE Leap 15.5: 3.6.15 (3.11.2)
CentOS Stream 8: 3.6.8 (3.8.13, 3.9.16, 3.11.4)
CentOS Stream 9: 3.9.17 (3.11.4)
Fedora 37: 3.11.4
Fedora 38: 3.11.4
Debian 11: 3.9.2
Debian 12: 3.11.2
Alpine 3.14, 3.15: 3.9.16
Alpine 3.16, 3.17: 3.10.10
Ubuntu 20.04 LTS: 3.8.10
Ubuntu 22.04 LTS: 3.10.12
NetBSD 9.3: 3.9.13*
FreeBSD 12.4: 3.9.16
FreeBSD 13.1: 3.9.18
OpenBSD 7.2: 3.9.17
Note: NetBSD does not appear to have a default meta-package, but offers
several options, the lowest of which is 3.7.15. However, "python39"
appears to be a pre-requisite to one of the other packages we request
in tests/vm/netbsd.
Since it is safe under our supported platform policy, bump our
minimum supported version of Python to 3.8. The two most interesting
features to have by default include:
- the importlib.metadata module, whose lack is responsible for over 100
lines of code in mkvenv.py
- improvements to asyncio, for example asyncio.CancelledError
inherits from BaseException rather than Exception
In addition, code can now use the assignment operator ':='
Because mypy now learns about importlib.metadata, a small change to
mkvenv.py is needed to pass type checking.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-03 13:48:02 +03:00
|
|
|
# We require python >= 3.8.
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
# NB: a True python conditional creates a non-zero return code (Failure)
|
Python: Drop support for Python 3.7
Debian 10 is not anymore a supported distro, since Debian 12 was
released on June 10, 2023. Our supported build platforms as of today
all support at least 3.8 (and all of them except for Ubuntu 20.04
support 3.9):
openSUSE Leap 15.5: 3.6.15 (3.11.2)
CentOS Stream 8: 3.6.8 (3.8.13, 3.9.16, 3.11.4)
CentOS Stream 9: 3.9.17 (3.11.4)
Fedora 37: 3.11.4
Fedora 38: 3.11.4
Debian 11: 3.9.2
Debian 12: 3.11.2
Alpine 3.14, 3.15: 3.9.16
Alpine 3.16, 3.17: 3.10.10
Ubuntu 20.04 LTS: 3.8.10
Ubuntu 22.04 LTS: 3.10.12
NetBSD 9.3: 3.9.13*
FreeBSD 12.4: 3.9.16
FreeBSD 13.1: 3.9.18
OpenBSD 7.2: 3.9.17
Note: NetBSD does not appear to have a default meta-package, but offers
several options, the lowest of which is 3.7.15. However, "python39"
appears to be a pre-requisite to one of the other packages we request
in tests/vm/netbsd.
Since it is safe under our supported platform policy, bump our
minimum supported version of Python to 3.8. The two most interesting
features to have by default include:
- the importlib.metadata module, whose lack is responsible for over 100
lines of code in mkvenv.py
- improvements to asyncio, for example asyncio.CancelledError
inherits from BaseException rather than Exception
In addition, code can now use the assignment operator ':='
Because mypy now learns about importlib.metadata, a small change to
mkvenv.py is needed to pass type checking.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-03 13:48:02 +03:00
|
|
|
"$1" -c 'import sys; sys.exit(sys.version_info < (3,8))'
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
first_python=
|
|
|
|
if test -z "${PYTHON}"; then
|
|
|
|
# A bare 'python' is traditionally python 2.x, but some distros
|
|
|
|
# have it as python 3.x, so check in both places.
|
2023-10-06 22:52:43 +03:00
|
|
|
for binary in python3 python python3.12 python3.11 \
|
|
|
|
python3.10 python3.9 python3.8; do
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
if has "$binary"; then
|
|
|
|
python=$(command -v "$binary")
|
|
|
|
if check_py_version "$python"; then
|
|
|
|
# This one is good.
|
|
|
|
first_python=
|
|
|
|
break
|
|
|
|
else
|
|
|
|
first_python=$python
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
else
|
|
|
|
# Same as above, but only check the environment variable.
|
|
|
|
has "${PYTHON}" || error_exit "The PYTHON environment variable does not point to an executable"
|
|
|
|
python=$(command -v "$PYTHON")
|
|
|
|
if check_py_version "$python"; then
|
|
|
|
# This one is good.
|
|
|
|
first_python=
|
|
|
|
else
|
|
|
|
first_python=$first_python
|
2019-03-27 20:07:01 +03:00
|
|
|
fi
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
fi
|
2020-02-14 20:18:41 +03:00
|
|
|
|
2020-03-03 18:06:20 +03:00
|
|
|
# Check for ancillary tools used in testing
|
|
|
|
genisoimage=
|
2020-05-19 16:22:48 +03:00
|
|
|
for binary in genisoimage mkisofs
|
2020-03-03 18:06:20 +03:00
|
|
|
do
|
|
|
|
if has $binary
|
|
|
|
then
|
|
|
|
genisoimage=$(command -v "$binary")
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = "windows" ; then
|
2009-08-03 16:46:07 +04:00
|
|
|
EXESUF=".exe"
|
|
|
|
fi
|
|
|
|
|
2022-06-24 18:40:42 +03:00
|
|
|
meson_option_build_array() {
|
|
|
|
printf '['
|
2023-11-03 11:17:48 +03:00
|
|
|
(if test "$host_os" = windows; then
|
2022-06-24 18:40:42 +03:00
|
|
|
IFS=\;
|
|
|
|
else
|
|
|
|
IFS=:
|
|
|
|
fi
|
|
|
|
for e in $1; do
|
2022-07-20 18:26:29 +03:00
|
|
|
printf '"""'
|
|
|
|
# backslash escape any '\' and '"' characters
|
|
|
|
printf "%s" "$e" | sed -e 's/\([\"]\)/\\\1/g'
|
|
|
|
printf '""",'
|
2022-06-24 18:40:42 +03:00
|
|
|
done)
|
|
|
|
printf ']\n'
|
|
|
|
}
|
|
|
|
|
2022-08-25 18:06:59 +03:00
|
|
|
. "$source_path/scripts/meson-buildoptions.sh"
|
2021-10-07 16:08:28 +03:00
|
|
|
|
|
|
|
meson_options=
|
2022-04-20 18:33:58 +03:00
|
|
|
meson_option_add() {
|
2023-09-26 18:20:53 +03:00
|
|
|
local arg
|
|
|
|
for arg; do
|
|
|
|
meson_options="$meson_options $(quote_sh "$arg")"
|
|
|
|
done
|
2022-04-20 18:33:58 +03:00
|
|
|
}
|
2021-10-07 16:08:28 +03:00
|
|
|
meson_option_parse() {
|
|
|
|
meson_options="$meson_options $(_meson_option_parse "$@")"
|
|
|
|
if test $? -eq 1; then
|
|
|
|
echo "ERROR: unknown option $1"
|
|
|
|
echo "Try '$0 --help' for more information"
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2023-10-16 09:18:08 +03:00
|
|
|
meson_add_machine_file() {
|
|
|
|
if test "$cross_compile" = "yes"; then
|
|
|
|
meson_option_add --cross-file "$1"
|
|
|
|
else
|
|
|
|
meson_option_add --native-file "$1"
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2003-03-07 02:23:54 +03:00
|
|
|
for opt do
|
2016-05-16 16:10:20 +03:00
|
|
|
optarg=$(expr "x$opt" : 'x[^=]*=\(.*\)')
|
2003-03-07 02:23:54 +03:00
|
|
|
case "$opt" in
|
2005-12-18 22:14:49 +03:00
|
|
|
--help|-h) show_help=yes
|
|
|
|
;;
|
2022-08-25 18:06:59 +03:00
|
|
|
--version|-V) exec cat "$source_path/VERSION"
|
2011-04-07 09:12:28 +04:00
|
|
|
;;
|
2008-12-29 20:14:15 +03:00
|
|
|
--cross-prefix=*)
|
2003-03-07 02:23:54 +03:00
|
|
|
;;
|
2008-12-29 20:14:15 +03:00
|
|
|
--cc=*)
|
2003-03-07 02:23:54 +03:00
|
|
|
;;
|
2006-04-16 17:28:56 +04:00
|
|
|
--host-cc=*) host_cc="$optarg"
|
2005-07-23 18:27:54 +04:00
|
|
|
;;
|
2013-08-07 19:39:36 +04:00
|
|
|
--cxx=*)
|
|
|
|
;;
|
2023-04-18 19:15:54 +03:00
|
|
|
--objcc=*)
|
2012-08-12 01:34:40 +04:00
|
|
|
;;
|
2022-06-07 13:48:49 +03:00
|
|
|
--make=*)
|
2003-03-07 02:23:54 +03:00
|
|
|
;;
|
2020-09-01 13:38:04 +03:00
|
|
|
--install=*)
|
2006-04-17 17:57:12 +04:00
|
|
|
;;
|
2023-05-11 06:54:23 +03:00
|
|
|
--python=*) python="$optarg"
|
2011-07-23 01:08:09 +04:00
|
|
|
;;
|
2019-06-10 13:05:14 +03:00
|
|
|
--skip-meson) skip_meson=yes
|
|
|
|
;;
|
2020-08-26 09:04:15 +03:00
|
|
|
--ninja=*) ninja="$optarg"
|
|
|
|
;;
|
2009-08-03 16:46:02 +04:00
|
|
|
--extra-cflags=*)
|
2003-03-07 02:23:54 +03:00
|
|
|
;;
|
2017-06-06 16:07:47 +03:00
|
|
|
--extra-cxxflags=*)
|
|
|
|
;;
|
2022-01-09 00:38:55 +03:00
|
|
|
--extra-objcflags=*)
|
|
|
|
;;
|
2009-08-03 16:46:02 +04:00
|
|
|
--extra-ldflags=*)
|
2003-03-07 02:23:54 +03:00
|
|
|
;;
|
2022-04-20 18:33:39 +03:00
|
|
|
--cross-cc-*)
|
2012-02-08 16:54:13 +04:00
|
|
|
;;
|
2022-05-27 18:35:51 +03:00
|
|
|
--cross-prefix-*)
|
|
|
|
;;
|
2023-05-11 06:54:28 +03:00
|
|
|
--enable-docs) docs=enabled
|
|
|
|
;;
|
|
|
|
--disable-docs) docs=disabled
|
|
|
|
;;
|
2009-08-03 16:45:55 +04:00
|
|
|
--cpu=*)
|
2003-03-07 02:23:54 +03:00
|
|
|
;;
|
2006-04-16 17:28:56 +04:00
|
|
|
--target-list=*) target_list="$optarg"
|
2019-03-19 14:59:12 +03:00
|
|
|
if test "$target_list_exclude"; then
|
|
|
|
error_exit "Can't mix --target-list with --target-list-exclude"
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
--target-list-exclude=*) target_list_exclude="$optarg"
|
|
|
|
if test "$target_list"; then
|
|
|
|
error_exit "Can't mix --target-list-exclude with --target-list"
|
|
|
|
fi
|
2003-06-16 00:25:43 +04:00
|
|
|
;;
|
2022-04-20 18:33:58 +03:00
|
|
|
--with-default-devices) meson_option_add -Ddefault_devices=true
|
2019-01-23 09:56:17 +03:00
|
|
|
;;
|
2022-04-20 18:33:58 +03:00
|
|
|
--without-default-devices) meson_option_add -Ddefault_devices=false
|
2019-01-23 09:56:17 +03:00
|
|
|
;;
|
2021-07-07 16:17:44 +03:00
|
|
|
--with-devices-*[!a-zA-Z0-9_-]*=*) error_exit "Passed bad --with-devices-FOO option"
|
|
|
|
;;
|
|
|
|
--with-devices-*) device_arch=${opt#--with-devices-};
|
|
|
|
device_arch=${device_arch%%=*}
|
|
|
|
cf=$source_path/configs/devices/$device_arch-softmmu/$optarg.mak
|
|
|
|
if test -f "$cf"; then
|
|
|
|
device_archs="$device_archs $device_arch"
|
|
|
|
eval "devices_${device_arch}=\$optarg"
|
|
|
|
else
|
|
|
|
error_exit "File $cf does not exist"
|
|
|
|
fi
|
|
|
|
;;
|
2020-12-10 22:04:13 +03:00
|
|
|
--without-default-features) # processed above
|
|
|
|
;;
|
2022-10-12 14:03:18 +03:00
|
|
|
--static) static="yes"
|
2003-06-09 23:53:12 +04:00
|
|
|
;;
|
2018-04-18 10:50:44 +03:00
|
|
|
--host=*|--build=*|\
|
|
|
|
--disable-dependency-tracking|\
|
2012-10-04 01:35:57 +04:00
|
|
|
--sbindir=*|--sharedstatedir=*|\
|
2020-10-16 11:35:10 +03:00
|
|
|
--oldincludedir=*|--datarootdir=*|--infodir=*|\
|
2011-11-24 16:11:31 +04:00
|
|
|
--htmldir=*|--dvidir=*|--pdfdir=*|--psdir=*)
|
|
|
|
# These switches are silently ignored, for compatibility with
|
|
|
|
# autoconf-generated configure scripts. This allows QEMU's
|
|
|
|
# configure to be used by RPM and similar macros that set
|
|
|
|
# lots of directory switches by default.
|
|
|
|
;;
|
2009-06-04 14:39:04 +04:00
|
|
|
--enable-debug)
|
|
|
|
# Enable debugging options that aren't excessively noisy
|
2023-08-28 12:48:30 +03:00
|
|
|
meson_option_parse --enable-debug-tcg ""
|
2023-05-01 20:34:43 +03:00
|
|
|
meson_option_parse --enable-debug-graph-lock ""
|
2021-10-13 12:46:09 +03:00
|
|
|
meson_option_parse --enable-debug-mutex ""
|
2022-04-20 18:33:58 +03:00
|
|
|
meson_option_add -Doptimization=0
|
2023-09-07 13:54:42 +03:00
|
|
|
default_cflags='-O0 -g'
|
2020-06-12 22:02:23 +03:00
|
|
|
;;
|
2020-09-18 11:57:25 +03:00
|
|
|
--disable-tcg) tcg="disabled"
|
2017-07-03 17:59:07 +03:00
|
|
|
;;
|
2020-09-18 11:57:25 +03:00
|
|
|
--enable-tcg) tcg="enabled"
|
2017-07-03 17:59:07 +03:00
|
|
|
;;
|
2023-10-04 16:46:56 +03:00
|
|
|
--disable-system) system="no"
|
2006-03-19 17:54:16 +03:00
|
|
|
;;
|
2023-10-04 16:46:56 +03:00
|
|
|
--enable-system) system="yes"
|
2006-03-19 17:54:16 +03:00
|
|
|
;;
|
2009-07-30 14:14:59 +04:00
|
|
|
--disable-user)
|
|
|
|
linux_user="no" ;
|
|
|
|
bsd_user="no" ;
|
|
|
|
;;
|
|
|
|
--enable-user) ;;
|
2007-01-18 23:06:33 +03:00
|
|
|
--disable-linux-user) linux_user="no"
|
2006-03-19 17:54:16 +03:00
|
|
|
;;
|
2007-01-18 23:06:33 +03:00
|
|
|
--enable-linux-user) linux_user="yes"
|
|
|
|
;;
|
2008-10-26 23:33:16 +03:00
|
|
|
--disable-bsd-user) bsd_user="no"
|
|
|
|
;;
|
|
|
|
--enable-bsd-user) bsd_user="yes"
|
|
|
|
;;
|
2011-11-15 22:12:17 +04:00
|
|
|
--enable-pie) pie="yes"
|
2009-09-12 03:17:55 +04:00
|
|
|
;;
|
2011-11-15 22:12:17 +04:00
|
|
|
--disable-pie) pie="no"
|
2009-09-12 03:17:55 +04:00
|
|
|
;;
|
2023-09-26 18:20:53 +03:00
|
|
|
--enable-cfi) cfi=true
|
2020-12-05 02:06:14 +03:00
|
|
|
;;
|
2023-09-26 18:20:53 +03:00
|
|
|
--disable-cfi) cfi=false
|
2020-12-05 02:06:14 +03:00
|
|
|
;;
|
2023-05-30 17:03:50 +03:00
|
|
|
--disable-download) download="disabled"; git_submodules_action=validate;
|
2017-10-26 15:52:26 +03:00
|
|
|
;;
|
2023-05-30 17:03:50 +03:00
|
|
|
--enable-download) download="enabled"; git_submodules_action=update;
|
configure: add --enable-pypi and --disable-pypi
In the event that there's no vendored source present and no sufficient
version of $package can be found, we will attempt to connect to PyPI to
install the package if '--disable-pypi' was not passed.
This means that PyPI access is "enabled by default", but there are some
subtleties that make this action occur much less frequently than you
might imagine:
(1) While --enable-pypi is the default, vendored source will always be
preferred when found, making PyPI a fallback. This should ensure
that configure-time venv building "just works" for almost everyone
in almost every circumstance.
(2) Because meson source is, at time of writing, vendored directly into
qemu.git, PyPI will never be used for sourcing meson.
(3) Because Sphinx is an optional dependency, if docs are set to "auto",
PyPI will not be used to obtain Sphinx source as a fallback and
instead docs will be disabled. If PyPI sourcing of sphinx is
desired, --enable-docs should be passed to force the lookup. I chose
this as the default behavior to avoid adding new internet lookups to
a "default" invocation of configure.
Signed-off-by: John Snow <jsnow@redhat.com>
Message-Id: <20230511035435.734312-23-jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-11 06:54:30 +03:00
|
|
|
;;
|
2023-09-18 12:06:48 +03:00
|
|
|
--enable-plugins) plugins="yes"
|
2019-06-13 16:52:25 +03:00
|
|
|
;;
|
|
|
|
--disable-plugins) plugins="no"
|
|
|
|
;;
|
2019-11-28 18:35:24 +03:00
|
|
|
--enable-containers) use_containers="yes"
|
|
|
|
;;
|
|
|
|
--disable-containers) use_containers="no"
|
|
|
|
;;
|
2023-10-09 19:40:45 +03:00
|
|
|
--container-engine=*) container_engine="$optarg"
|
|
|
|
;;
|
2020-03-16 20:21:48 +03:00
|
|
|
--gdb=*) gdb_bin="$optarg"
|
|
|
|
;;
|
2021-10-07 16:08:29 +03:00
|
|
|
# everything else has the same name in configure and meson
|
2022-04-20 18:33:51 +03:00
|
|
|
--*) meson_option_parse "$opt" "$optarg"
|
2007-11-17 13:24:32 +03:00
|
|
|
;;
|
2023-08-01 16:04:01 +03:00
|
|
|
# Pass through -Dxxxx options to meson
|
|
|
|
-D*) meson_options="$meson_options $opt"
|
|
|
|
;;
|
2003-03-07 02:23:54 +03:00
|
|
|
esac
|
|
|
|
done
|
|
|
|
|
2023-05-30 17:03:50 +03:00
|
|
|
if ! test -e "$source_path/.git"
|
|
|
|
then
|
2023-06-19 00:10:39 +03:00
|
|
|
git_submodules_action="validate"
|
2023-05-30 17:03:50 +03:00
|
|
|
fi
|
|
|
|
|
meson: subprojects: replace submodules with wrap files
Compared to submodules, .wrap files have several advantages:
* option parsing and downloading is delegated to meson
* the commit is stored in a text file instead of a magic entry in the
git tree object
* we could stop shipping external dependencies that are only used as a
fallback, but not break compilation on platforms that lack them.
For example it may make sense to download dtc at build time, controlled
by --enable-download, even when building from a tarball. Right now,
this patch does the opposite: make-release treats dtc like libvfio-user
(which is not stable API and therefore hasn't found its way into any
distros) and keycodemap (which is a copylib, for better or worse).
dependency() can fall back to a wrap automatically. However, this
is only possible for libraries that come with a .pc file, and this
is not very common for libfdt even though the upstream project in
principle provides it; it also removes the control that we provide with
--enable-fdt={system,internal}. Therefore, the logic to pick system
vs. internal libfdt is left untouched.
--enable-fdt=git is removed; it was already a synonym for
--enable-fdt=internal.
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-18 17:50:00 +03:00
|
|
|
if ! test -f "$source_path/subprojects/keycodemapdb/README" \
|
2023-06-07 11:01:03 +03:00
|
|
|
&& test "$download" = disabled
|
meson: subprojects: replace submodules with wrap files
Compared to submodules, .wrap files have several advantages:
* option parsing and downloading is delegated to meson
* the commit is stored in a text file instead of a magic entry in the
git tree object
* we could stop shipping external dependencies that are only used as a
fallback, but not break compilation on platforms that lack them.
For example it may make sense to download dtc at build time, controlled
by --enable-download, even when building from a tarball. Right now,
this patch does the opposite: make-release treats dtc like libvfio-user
(which is not stable API and therefore hasn't found its way into any
distros) and keycodemap (which is a copylib, for better or worse).
dependency() can fall back to a wrap automatically. However, this
is only possible for libraries that come with a .pc file, and this
is not very common for libfdt even though the upstream project in
principle provides it; it also removes the control that we provide with
--enable-fdt={system,internal}. Therefore, the logic to pick system
vs. internal libfdt is left untouched.
--enable-fdt=git is removed; it was already a synonym for
--enable-fdt=internal.
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-18 17:50:00 +03:00
|
|
|
then
|
|
|
|
echo
|
|
|
|
echo "ERROR: missing subprojects"
|
|
|
|
echo
|
|
|
|
if test -e "$source_path/.git"; then
|
|
|
|
echo "--disable-download specified but subprojects were not"
|
|
|
|
echo 'checked out. Please invoke "meson subprojects download"'
|
|
|
|
echo "before configuring QEMU, or remove --disable-download"
|
|
|
|
echo "from the command line."
|
|
|
|
else
|
|
|
|
echo "This is not a GIT checkout but subproject content appears to"
|
|
|
|
echo "be missing. Do not use 'git archive' or GitHub download links"
|
|
|
|
echo "to acquire QEMU source archives. Non-GIT builds are only"
|
|
|
|
echo "supported with source archives linked from:"
|
|
|
|
echo
|
|
|
|
echo " https://www.qemu.org/download/#source"
|
|
|
|
echo
|
|
|
|
echo "Developers working with GIT can use scripts/archive-source.sh"
|
|
|
|
echo "if they need to create valid source archives."
|
|
|
|
fi
|
|
|
|
echo
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
|
2011-05-03 17:50:13 +04:00
|
|
|
default_target_list=""
|
2013-05-20 19:16:15 +04:00
|
|
|
mak_wilds=""
|
|
|
|
|
2022-09-26 19:22:39 +03:00
|
|
|
if [ -n "$host_arch" ] && [ -d "$source_path/common-user/host/$host_arch" ]; then
|
|
|
|
if [ "$linux_user" != no ]; then
|
2023-11-03 11:17:48 +03:00
|
|
|
if [ "$host_os" = linux ]; then
|
2022-09-26 19:22:39 +03:00
|
|
|
linux_user=yes
|
|
|
|
elif [ "$linux_user" = yes ]; then
|
|
|
|
error_exit "linux-user not supported on this architecture"
|
|
|
|
fi
|
|
|
|
if [ "$linux_user" = "yes" ]; then
|
|
|
|
mak_wilds="${mak_wilds} $source_path/configs/targets/*-linux-user.mak"
|
|
|
|
fi
|
2021-11-09 12:10:41 +03:00
|
|
|
fi
|
2022-09-26 19:22:39 +03:00
|
|
|
if [ "$bsd_user" != no ]; then
|
|
|
|
if [ "$bsd_user" = "" ]; then
|
2023-11-03 11:17:48 +03:00
|
|
|
test $host_os = freebsd && bsd_user=yes
|
2022-09-26 19:22:39 +03:00
|
|
|
fi
|
2023-11-03 11:17:48 +03:00
|
|
|
if [ "$bsd_user" = yes ] && ! [ -d "$source_path/bsd-user/$host_os" ]; then
|
2022-09-26 19:22:39 +03:00
|
|
|
error_exit "bsd-user not supported on this host OS"
|
|
|
|
fi
|
|
|
|
if [ "$bsd_user" = "yes" ]; then
|
|
|
|
mak_wilds="${mak_wilds} $source_path/configs/targets/*-bsd-user.mak"
|
|
|
|
fi
|
2021-11-09 12:10:41 +03:00
|
|
|
fi
|
2022-09-26 19:22:39 +03:00
|
|
|
else
|
|
|
|
if [ "$linux_user" = yes ] || [ "$bsd_user" = yes ]; then
|
|
|
|
error_exit "user mode emulation not supported on this architecture"
|
2021-11-09 12:10:41 +03:00
|
|
|
fi
|
|
|
|
fi
|
2023-10-04 16:46:56 +03:00
|
|
|
if [ "$system" = "yes" ]; then
|
2021-07-07 16:17:43 +03:00
|
|
|
mak_wilds="${mak_wilds} $source_path/configs/targets/*-softmmu.mak"
|
2011-05-03 17:50:13 +04:00
|
|
|
fi
|
|
|
|
|
2020-09-09 14:27:37 +03:00
|
|
|
for config in $mak_wilds; do
|
|
|
|
target="$(basename "$config" .mak)"
|
2020-09-15 16:43:14 +03:00
|
|
|
if echo "$target_list_exclude" | grep -vq "$target"; then
|
2020-09-09 14:27:37 +03:00
|
|
|
default_target_list="${default_target_list} $target"
|
|
|
|
fi
|
|
|
|
done
|
2013-05-20 19:16:15 +04:00
|
|
|
|
2006-04-08 18:26:41 +04:00
|
|
|
if test x"$show_help" = x"yes" ; then
|
|
|
|
cat << EOF
|
|
|
|
|
|
|
|
Usage: configure [options]
|
|
|
|
Options: [defaults in brackets after descriptions]
|
|
|
|
|
2013-12-19 01:09:39 +04:00
|
|
|
Standard options:
|
|
|
|
--help print this message
|
2022-01-12 14:27:22 +03:00
|
|
|
--target-list=LIST set target list (default: build all)
|
2013-12-19 01:09:39 +04:00
|
|
|
$(echo Available targets: $default_target_list | \
|
|
|
|
fold -s -w 53 | sed -e 's/^/ /')
|
2019-03-19 14:59:12 +03:00
|
|
|
--target-list-exclude=LIST exclude a set of targets from the default target-list
|
2013-12-19 01:09:39 +04:00
|
|
|
|
|
|
|
Advanced options (experts only):
|
2023-08-01 16:04:01 +03:00
|
|
|
-Dmesonoptname=val passthrough option to meson unmodified
|
2021-01-26 04:24:48 +03:00
|
|
|
--cross-prefix=PREFIX use PREFIX for compile tools, PREFIX can be blank [$cross_prefix]
|
2013-12-19 01:09:39 +04:00
|
|
|
--cc=CC use C compiler CC [$cc]
|
2023-07-07 17:12:19 +03:00
|
|
|
--host-cc=CC when cross compiling, use C compiler CC for code run
|
|
|
|
at build time [$host_cc]
|
2013-12-19 01:09:39 +04:00
|
|
|
--cxx=CXX use C++ compiler CXX [$cxx]
|
|
|
|
--objcc=OBJCC use Objective-C compiler OBJCC [$objcc]
|
2021-11-05 12:09:26 +03:00
|
|
|
--extra-cflags=CFLAGS append extra C compiler flags CFLAGS
|
|
|
|
--extra-cxxflags=CXXFLAGS append extra C++ compiler flags CXXFLAGS
|
2022-01-09 00:38:55 +03:00
|
|
|
--extra-objcflags=OBJCFLAGS append extra Objective C compiler flags OBJCFLAGS
|
2013-12-19 01:09:39 +04:00
|
|
|
--extra-ldflags=LDFLAGS append extra linker flags LDFLAGS
|
2018-04-04 22:27:05 +03:00
|
|
|
--cross-cc-ARCH=CC use compiler when building ARCH guest test cases
|
2022-01-20 20:31:41 +03:00
|
|
|
--cross-cc-cflags-ARCH= use compiler flags when building ARCH guest tests
|
2022-05-27 18:35:51 +03:00
|
|
|
--cross-prefix-ARCH=PREFIX cross compiler prefix when building ARCH guest test cases
|
2013-12-19 01:09:39 +04:00
|
|
|
--python=PYTHON use specified python [$python]
|
2020-08-26 09:04:15 +03:00
|
|
|
--ninja=NINJA use specified ninja [$ninja]
|
2013-12-19 01:09:39 +04:00
|
|
|
--static enable static build [$static]
|
2020-12-14 13:34:47 +03:00
|
|
|
--without-default-features default all --enable-* options to "disabled"
|
|
|
|
--without-default-devices do not include any device that is not needed to
|
|
|
|
start the emulator (only use if you are including
|
2021-07-07 16:17:44 +03:00
|
|
|
desired devices in configs/devices/)
|
|
|
|
--with-devices-ARCH=NAME override default configs/devices
|
2013-12-19 01:09:39 +04:00
|
|
|
--enable-debug enable common debug build options
|
2015-06-17 22:19:26 +03:00
|
|
|
--cpu=CPU Build for host CPU [$cpu]
|
2019-11-28 18:35:24 +03:00
|
|
|
--disable-containers don't use containers for cross-building
|
2023-10-09 19:40:45 +03:00
|
|
|
--container-engine=TYPE which container engine to use [$container_engine]
|
2020-03-16 20:21:48 +03:00
|
|
|
--gdb=GDB-path gdb to use for gdbstub tests [$gdb_bin]
|
2021-10-07 16:08:28 +03:00
|
|
|
EOF
|
|
|
|
meson_options_help
|
|
|
|
cat << EOF
|
2015-06-17 22:19:26 +03:00
|
|
|
system all system emulation targets
|
|
|
|
user supported user emulation targets
|
|
|
|
linux-user all linux usermode emulation targets
|
|
|
|
bsd-user all BSD usermode emulation targets
|
|
|
|
pie Position Independent Executables
|
2013-12-19 01:09:39 +04:00
|
|
|
|
|
|
|
NOTE: The object files are built at the place where configure is launched
|
2006-04-08 18:26:41 +04:00
|
|
|
EOF
|
2014-04-18 10:55:36 +04:00
|
|
|
exit 0
|
2006-04-08 18:26:41 +04:00
|
|
|
fi
|
|
|
|
|
2019-03-11 13:20:34 +03:00
|
|
|
# Remove old dependency files to make sure that they get properly regenerated
|
2022-08-25 18:07:00 +03:00
|
|
|
rm -f ./*/config-devices.mak.d
|
2019-03-11 13:20:34 +03:00
|
|
|
|
2019-03-27 20:07:01 +03:00
|
|
|
if test -z "$python"
|
|
|
|
then
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
# If first_python is set, there was a binary somewhere even though
|
|
|
|
# it was not suitable. Use it for the error message.
|
|
|
|
if test -n "$first_python"; then
|
2023-10-06 22:52:42 +03:00
|
|
|
error_exit "Cannot use '$first_python', Python >= 3.8 is required." \
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
"Use --python=/path/to/python to specify a supported Python."
|
|
|
|
else
|
|
|
|
error_exit "Python not found. Use --python=/path/to/python"
|
|
|
|
fi
|
2017-03-28 16:44:18 +03:00
|
|
|
fi
|
configure: Look for auxiliary Python installations
At the moment, we look for just "python3" and "python", which is good
enough almost all of the time. But ... if you are on a platform that
uses an older Python by default and only offers a newer Python as an
option, you'll have to specify --python=/usr/bin/foo every time.
We can be kind and instead make a cursory attempt to locate a suitable
Python binary ourselves, looking for the remaining well-known binaries.
This configure loop will prefer, in order:
1. Whatever is specified in $PYTHON
2. python3
3. python
4. python3.11 down through python3.6
Notes:
- Python virtual environment provides binaries for "python3", "python",
and whichever version you used to create the venv,
e.g. "python3.8". If configure is invoked from inside of a venv, this
configure loop will not "break out" of that venv unless that venv is
created using an explicitly non-suitable version of Python that we
cannot use.
- In the event that no suitable python is found, the first python found
is the version used to generate the human-readable error message.
- The error message isn't printed right away to allow later
configuration code to pick up an explicitly configured python.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-02-10 03:31:43 +03:00
|
|
|
|
|
|
|
if ! check_py_version "$python"; then
|
Python: Drop support for Python 3.7
Debian 10 is not anymore a supported distro, since Debian 12 was
released on June 10, 2023. Our supported build platforms as of today
all support at least 3.8 (and all of them except for Ubuntu 20.04
support 3.9):
openSUSE Leap 15.5: 3.6.15 (3.11.2)
CentOS Stream 8: 3.6.8 (3.8.13, 3.9.16, 3.11.4)
CentOS Stream 9: 3.9.17 (3.11.4)
Fedora 37: 3.11.4
Fedora 38: 3.11.4
Debian 11: 3.9.2
Debian 12: 3.11.2
Alpine 3.14, 3.15: 3.9.16
Alpine 3.16, 3.17: 3.10.10
Ubuntu 20.04 LTS: 3.8.10
Ubuntu 22.04 LTS: 3.10.12
NetBSD 9.3: 3.9.13*
FreeBSD 12.4: 3.9.16
FreeBSD 13.1: 3.9.18
OpenBSD 7.2: 3.9.17
Note: NetBSD does not appear to have a default meta-package, but offers
several options, the lowest of which is 3.7.15. However, "python39"
appears to be a pre-requisite to one of the other packages we request
in tests/vm/netbsd.
Since it is safe under our supported platform policy, bump our
minimum supported version of Python to 3.8. The two most interesting
features to have by default include:
- the importlib.metadata module, whose lack is responsible for over 100
lines of code in mkvenv.py
- improvements to asyncio, for example asyncio.CancelledError
inherits from BaseException rather than Exception
In addition, code can now use the assignment operator ':='
Because mypy now learns about importlib.metadata, a small change to
mkvenv.py is needed to pass type checking.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-03 13:48:02 +03:00
|
|
|
error_exit "Cannot use '$python', Python >= 3.8 is required." \
|
2023-05-11 06:54:32 +03:00
|
|
|
"Use --python=/path/to/python to specify a supported Python." \
|
|
|
|
"Maybe try:" \
|
|
|
|
" openSUSE Leap 15.3+: zypper install python39" \
|
|
|
|
" CentOS 8: dnf install python38"
|
2017-03-28 16:44:18 +03:00
|
|
|
fi
|
|
|
|
|
2023-05-11 06:54:23 +03:00
|
|
|
# Resolve PATH
|
|
|
|
python="$(command -v "$python")"
|
|
|
|
|
|
|
|
# Create a Python virtual environment using our configured python.
|
|
|
|
# The stdout of this script will be the location of a symlink that
|
|
|
|
# points to the configured Python.
|
|
|
|
# Entry point scripts for pip, meson, and sphinx are generated if those
|
|
|
|
# packages are present.
|
|
|
|
|
|
|
|
# Defaults assumed for now:
|
|
|
|
# - venv is cleared if it exists already;
|
|
|
|
# - venv is allowed to use system packages;
|
configure: add --enable-pypi and --disable-pypi
In the event that there's no vendored source present and no sufficient
version of $package can be found, we will attempt to connect to PyPI to
install the package if '--disable-pypi' was not passed.
This means that PyPI access is "enabled by default", but there are some
subtleties that make this action occur much less frequently than you
might imagine:
(1) While --enable-pypi is the default, vendored source will always be
preferred when found, making PyPI a fallback. This should ensure
that configure-time venv building "just works" for almost everyone
in almost every circumstance.
(2) Because meson source is, at time of writing, vendored directly into
qemu.git, PyPI will never be used for sourcing meson.
(3) Because Sphinx is an optional dependency, if docs are set to "auto",
PyPI will not be used to obtain Sphinx source as a fallback and
instead docs will be disabled. If PyPI sourcing of sphinx is
desired, --enable-docs should be passed to force the lookup. I chose
this as the default behavior to avoid adding new internet lookups to
a "default" invocation of configure.
Signed-off-by: John Snow <jsnow@redhat.com>
Message-Id: <20230511035435.734312-23-jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-11 06:54:30 +03:00
|
|
|
# - all setup can be performed offline;
|
|
|
|
# - missing packages may be fetched from PyPI,
|
2023-05-18 17:11:29 +03:00
|
|
|
# unless --disable-download is passed.
|
2023-05-11 06:54:23 +03:00
|
|
|
# - pip is not installed into the venv when possible,
|
|
|
|
# but ensurepip is called as a fallback when necessary.
|
|
|
|
|
|
|
|
echo "python determined to be '$python'"
|
|
|
|
echo "python version: $($python --version)"
|
|
|
|
|
|
|
|
python="$($python -B "${source_path}/python/scripts/mkvenv.py" create pyvenv)"
|
|
|
|
if test "$?" -ne 0 ; then
|
|
|
|
error_exit "python venv creation failed"
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Suppress writing compiled files
|
|
|
|
python="$python -B"
|
2023-05-11 06:54:29 +03:00
|
|
|
mkvenv="$python ${source_path}/python/scripts/mkvenv.py"
|
2023-02-10 19:18:54 +03:00
|
|
|
|
2023-08-08 21:19:43 +03:00
|
|
|
# Finish preparing the virtual environment using vendored .whl files
|
|
|
|
|
|
|
|
if $python -c 'import sys; sys.exit(sys.version_info >= (3,11))'; then
|
|
|
|
$mkvenv ensure --dir "${source_path}/python/wheels" \
|
|
|
|
'tomli>=1.2.0' || exit 1
|
|
|
|
fi
|
2023-08-08 12:23:48 +03:00
|
|
|
$mkvenv ensuregroup --dir "${source_path}/python/wheels" \
|
|
|
|
${source_path}/pythondeps.toml meson || exit 1
|
2019-06-10 13:05:14 +03:00
|
|
|
|
configure: use 'mkvenv ensure meson' to bootstrap meson
This commit changes how we detect and install meson. It notably removes
'--meson='.
Currently, configure creates a lightweight Python virtual environment
unconditionally using the user's configured $python that inherits system
packages. Temporarily, we forced the use of meson source present via git
submodule or in the release tarball.
With this patch, we restore the ability to use a system-provided meson:
If Meson is installed in the build venv and meets our minimum version
requirements, we will use that Meson. This includes a system provided
meson, which would be visible via system-site packages inside the venv.
In the event that Meson is installed but *not for the chosen Python
interpreter*, not found, or of insufficient version, we will attempt to
install Meson from vendored source into the newly created Python virtual
environment. This vendored installation replaces both the git submodule
and tarball source mechanisms for sourcing meson.
As a result of this patch, the Python interpreter we use for both our
own build scripts *and* Meson extensions are always known to be the
exact same Python. As a further benefit, there will also be a symlink
available in the build directory that points to the correct, configured
python and can be used by e.g. manual tests to invoke the correct,
configured Python unambiguously.
Signed-off-by: John Snow <jsnow@redhat.com>
Message-Id: <20230511035435.734312-18-jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-11 06:54:25 +03:00
|
|
|
# At this point, we expect Meson to be installed and available.
|
|
|
|
# We expect mkvenv or pip to have created pyvenv/bin/meson for us.
|
|
|
|
# We ignore PATH completely here: we want to use the venv's Meson
|
|
|
|
# *exclusively*.
|
2019-08-21 10:21:16 +03:00
|
|
|
|
configure: use 'mkvenv ensure meson' to bootstrap meson
This commit changes how we detect and install meson. It notably removes
'--meson='.
Currently, configure creates a lightweight Python virtual environment
unconditionally using the user's configured $python that inherits system
packages. Temporarily, we forced the use of meson source present via git
submodule or in the release tarball.
With this patch, we restore the ability to use a system-provided meson:
If Meson is installed in the build venv and meets our minimum version
requirements, we will use that Meson. This includes a system provided
meson, which would be visible via system-site packages inside the venv.
In the event that Meson is installed but *not for the chosen Python
interpreter*, not found, or of insufficient version, we will attempt to
install Meson from vendored source into the newly created Python virtual
environment. This vendored installation replaces both the git submodule
and tarball source mechanisms for sourcing meson.
As a result of this patch, the Python interpreter we use for both our
own build scripts *and* Meson extensions are always known to be the
exact same Python. As a further benefit, there will also be a symlink
available in the build directory that points to the correct, configured
python and can be used by e.g. manual tests to invoke the correct,
configured Python unambiguously.
Signed-off-by: John Snow <jsnow@redhat.com>
Message-Id: <20230511035435.734312-18-jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-11 06:54:25 +03:00
|
|
|
meson="$(cd pyvenv/bin; pwd)/meson"
|
2019-08-21 10:21:16 +03:00
|
|
|
|
2023-05-11 06:54:29 +03:00
|
|
|
# Conditionally ensure Sphinx is installed.
|
|
|
|
|
2023-11-10 11:37:34 +03:00
|
|
|
mkvenv_online_flag=""
|
|
|
|
if test "$download" = "enabled" ; then
|
|
|
|
mkvenv_online_flag=" --online"
|
configure: add --enable-pypi and --disable-pypi
In the event that there's no vendored source present and no sufficient
version of $package can be found, we will attempt to connect to PyPI to
install the package if '--disable-pypi' was not passed.
This means that PyPI access is "enabled by default", but there are some
subtleties that make this action occur much less frequently than you
might imagine:
(1) While --enable-pypi is the default, vendored source will always be
preferred when found, making PyPI a fallback. This should ensure
that configure-time venv building "just works" for almost everyone
in almost every circumstance.
(2) Because meson source is, at time of writing, vendored directly into
qemu.git, PyPI will never be used for sourcing meson.
(3) Because Sphinx is an optional dependency, if docs are set to "auto",
PyPI will not be used to obtain Sphinx source as a fallback and
instead docs will be disabled. If PyPI sourcing of sphinx is
desired, --enable-docs should be passed to force the lookup. I chose
this as the default behavior to avoid adding new internet lookups to
a "default" invocation of configure.
Signed-off-by: John Snow <jsnow@redhat.com>
Message-Id: <20230511035435.734312-23-jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-05-11 06:54:30 +03:00
|
|
|
fi
|
|
|
|
|
2023-05-11 06:54:29 +03:00
|
|
|
if test "$docs" != "disabled" ; then
|
2023-08-08 12:23:48 +03:00
|
|
|
if ! $mkvenv ensuregroup \
|
2023-11-10 11:37:34 +03:00
|
|
|
$(test "$docs" = "enabled" && echo "$mkvenv_online_flag") \
|
2023-08-08 12:23:48 +03:00
|
|
|
${source_path}/pythondeps.toml docs;
|
2023-05-11 06:54:29 +03:00
|
|
|
then
|
|
|
|
if test "$docs" = "enabled" ; then
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
echo "Sphinx not found/usable, disabling docs."
|
|
|
|
docs=disabled
|
|
|
|
else
|
|
|
|
docs=enabled
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2020-08-13 16:28:11 +03:00
|
|
|
# Probe for ninja
|
2020-08-26 09:04:15 +03:00
|
|
|
|
|
|
|
if test -z "$ninja"; then
|
|
|
|
for c in ninja ninja-build samu; do
|
|
|
|
if has $c; then
|
|
|
|
ninja=$(command -v "$c")
|
|
|
|
break
|
|
|
|
fi
|
|
|
|
done
|
2020-08-13 16:28:11 +03:00
|
|
|
if test -z "$ninja"; then
|
|
|
|
error_exit "Cannot find Ninja"
|
|
|
|
fi
|
2020-08-26 09:04:15 +03:00
|
|
|
fi
|
2019-06-10 13:05:14 +03:00
|
|
|
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = "bogus"; then
|
2017-03-28 16:01:52 +03:00
|
|
|
# Now that we know that we're not printing the help and that
|
|
|
|
# the compiler works (so the results of the check_defines we used
|
|
|
|
# to identify the OS are reliable), if we didn't recognize the
|
|
|
|
# host OS we should stop now.
|
2017-07-13 18:15:32 +03:00
|
|
|
error_exit "Unrecognized host OS (uname -s reports '$(uname -s)')"
|
2017-03-28 16:01:52 +03:00
|
|
|
fi
|
|
|
|
|
2023-09-18 12:06:48 +03:00
|
|
|
# test for any invalid configuration combinations
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = "windows" && ! has "$dlltool"; then
|
2023-09-18 12:06:48 +03:00
|
|
|
if test "$plugins" = "yes"; then
|
2023-11-06 21:51:06 +03:00
|
|
|
error_exit "TCG plugins requires dlltool to build on Windows platforms"
|
2023-09-18 12:06:48 +03:00
|
|
|
fi
|
|
|
|
plugins="no"
|
|
|
|
fi
|
|
|
|
if test "$tcg" = "disabled" ; then
|
|
|
|
if test "$plugins" = "yes"; then
|
|
|
|
error_exit "Can't enable plugins on non-TCG builds"
|
|
|
|
fi
|
|
|
|
plugins="no"
|
|
|
|
fi
|
2011-11-15 22:12:17 +04:00
|
|
|
if test "$static" = "yes" ; then
|
2021-07-09 17:29:55 +03:00
|
|
|
if test "$plugins" = "yes"; then
|
|
|
|
error_exit "static and plugins are mutually incompatible"
|
|
|
|
fi
|
2023-09-18 12:06:48 +03:00
|
|
|
plugins="no"
|
2011-11-15 22:12:17 +04:00
|
|
|
fi
|
2023-09-18 12:06:48 +03:00
|
|
|
if test "$plugins" != "no"; then
|
|
|
|
plugins=yes
|
2023-08-30 13:05:08 +03:00
|
|
|
subdirs="$subdirs contrib/plugins"
|
|
|
|
fi
|
2011-11-15 22:12:17 +04:00
|
|
|
|
2019-12-18 02:54:56 +03:00
|
|
|
cat > $TMPC << EOF
|
2011-11-23 13:24:25 +04:00
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
# define THREAD __thread
|
|
|
|
#else
|
|
|
|
# define THREAD
|
|
|
|
#endif
|
|
|
|
static THREAD int tls_var;
|
|
|
|
int main(void) { return tls_var; }
|
2011-11-15 22:12:17 +04:00
|
|
|
EOF
|
2019-08-15 22:41:51 +03:00
|
|
|
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = windows || test "$host_os" = haiku; then
|
2023-09-28 11:41:29 +03:00
|
|
|
if test "$pie" = "yes"; then
|
|
|
|
error_exit "PIE not available due to missing OS support"
|
|
|
|
fi
|
|
|
|
pie=no
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "$pie" != "no"; then
|
|
|
|
if test "$static" = "yes"; then
|
|
|
|
pie_ldflags=-static-pie
|
2019-12-18 04:30:14 +03:00
|
|
|
else
|
2023-09-28 11:41:29 +03:00
|
|
|
pie_ldflags=-pie
|
2019-12-18 04:30:14 +03:00
|
|
|
fi
|
2023-09-28 11:41:29 +03:00
|
|
|
if compile_prog "-Werror -fPIE -DPIE" "$pie_ldflags"; then
|
2022-10-20 15:20:30 +03:00
|
|
|
pie="yes"
|
|
|
|
elif test "$pie" = "yes"; then
|
2023-09-28 11:41:29 +03:00
|
|
|
error_exit "-static-pie not available due to missing toolchain support"
|
2022-10-20 15:20:30 +03:00
|
|
|
else
|
|
|
|
echo "Disabling PIE due to missing toolchain support"
|
|
|
|
pie="no"
|
2022-03-29 14:07:25 +03:00
|
|
|
fi
|
2011-11-15 22:12:17 +04:00
|
|
|
fi
|
|
|
|
|
2013-04-17 18:26:47 +04:00
|
|
|
##########################################
|
|
|
|
|
2012-09-27 00:04:38 +04:00
|
|
|
if test -z "${target_list+xxx}" ; then
|
2020-09-21 11:37:49 +03:00
|
|
|
default_targets=yes
|
2017-07-03 17:58:28 +03:00
|
|
|
for target in $default_target_list; do
|
2020-09-21 11:37:49 +03:00
|
|
|
target_list="$target_list $target"
|
2017-07-03 17:58:28 +03:00
|
|
|
done
|
|
|
|
target_list="${target_list# }"
|
2012-09-14 17:17:03 +04:00
|
|
|
else
|
2020-09-21 11:37:49 +03:00
|
|
|
default_targets=no
|
2016-05-16 16:10:20 +03:00
|
|
|
target_list=$(echo "$target_list" | sed -e 's/,/ /g')
|
2017-07-03 17:58:28 +03:00
|
|
|
for target in $target_list; do
|
|
|
|
# Check that we recognised the target name; this allows a more
|
|
|
|
# friendly error message than if we let it fall through.
|
|
|
|
case " $default_target_list " in
|
|
|
|
*" $target "*)
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
error_exit "Unknown target name '$target'"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
2012-09-14 17:17:03 +04:00
|
|
|
fi
|
2013-05-20 19:16:16 +04:00
|
|
|
|
2022-02-04 17:54:47 +03:00
|
|
|
if test "$tcg" = "auto"; then
|
|
|
|
if test -z "$target_list"; then
|
|
|
|
tcg="disabled"
|
|
|
|
else
|
|
|
|
tcg="enabled"
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2023-09-28 11:44:56 +03:00
|
|
|
#########################################
|
|
|
|
# gdb test
|
|
|
|
|
|
|
|
if test -n "$gdb_bin"; then
|
|
|
|
gdb_version=$($gdb_bin --version | head -n 1)
|
|
|
|
if version_ge ${gdb_version##* } 9.1; then
|
|
|
|
gdb_arches=$($python "$source_path/scripts/probe-gdb-support.py" $gdb_bin)
|
|
|
|
else
|
|
|
|
gdb_bin=""
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2022-10-14 10:30:15 +03:00
|
|
|
##########################################
|
2003-03-07 02:23:54 +03:00
|
|
|
# big/little endian test
|
|
|
|
cat > $TMPC << EOF
|
2022-10-14 10:30:15 +03:00
|
|
|
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
|
# error LITTLE
|
|
|
|
#endif
|
|
|
|
int main(void) { return 0; }
|
2003-03-07 02:23:54 +03:00
|
|
|
EOF
|
|
|
|
|
2022-10-14 10:30:15 +03:00
|
|
|
if ! compile_prog ; then
|
|
|
|
bigendian="no"
|
2013-07-01 07:30:18 +04:00
|
|
|
else
|
2022-10-14 10:30:15 +03:00
|
|
|
cat > $TMPC << EOF
|
|
|
|
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
|
|
|
|
# error BIG
|
|
|
|
#endif
|
|
|
|
int main(void) { return 0; }
|
|
|
|
EOF
|
|
|
|
|
|
|
|
if ! compile_prog ; then
|
|
|
|
bigendian="yes"
|
|
|
|
else
|
2013-07-01 07:30:18 +04:00
|
|
|
echo big/little test failed
|
2021-07-15 11:39:28 +03:00
|
|
|
exit 1
|
2022-10-14 10:30:15 +03:00
|
|
|
fi
|
2003-03-07 02:23:54 +03:00
|
|
|
fi
|
|
|
|
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
##########################################
|
|
|
|
# functions to probe cross compilers
|
|
|
|
|
|
|
|
container="no"
|
2023-02-28 22:06:46 +03:00
|
|
|
runc=""
|
2022-11-17 20:25:20 +03:00
|
|
|
if test $use_containers = "yes" && (has "docker" || has "podman"); then
|
2023-10-09 19:40:45 +03:00
|
|
|
case $($python "$source_path"/tests/docker/docker.py --engine "$container_engine" probe) in
|
2022-09-29 14:41:58 +03:00
|
|
|
*docker) container=docker ;;
|
|
|
|
podman) container=podman ;;
|
|
|
|
no) container=no ;;
|
|
|
|
esac
|
2022-09-29 14:41:59 +03:00
|
|
|
if test "$container" != "no"; then
|
|
|
|
docker_py="$python $source_path/tests/docker/docker.py --engine $container"
|
2023-10-09 19:40:45 +03:00
|
|
|
runc=$container
|
2022-09-29 14:41:59 +03:00
|
|
|
fi
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
fi
|
|
|
|
|
|
|
|
# cross compilers defaults, can be overridden with --cross-cc-ARCH
|
2022-05-27 18:35:51 +03:00
|
|
|
: ${cross_prefix_aarch64="aarch64-linux-gnu-"}
|
|
|
|
: ${cross_prefix_aarch64_be="$cross_prefix_aarch64"}
|
|
|
|
: ${cross_prefix_alpha="alpha-linux-gnu-"}
|
|
|
|
: ${cross_prefix_arm="arm-linux-gnueabihf-"}
|
|
|
|
: ${cross_prefix_armeb="$cross_prefix_arm"}
|
|
|
|
: ${cross_prefix_hexagon="hexagon-unknown-linux-musl-"}
|
2022-06-06 15:43:33 +03:00
|
|
|
: ${cross_prefix_loongarch64="loongarch64-unknown-linux-gnu-"}
|
2022-05-27 18:35:51 +03:00
|
|
|
: ${cross_prefix_hppa="hppa-linux-gnu-"}
|
|
|
|
: ${cross_prefix_i386="i686-linux-gnu-"}
|
|
|
|
: ${cross_prefix_m68k="m68k-linux-gnu-"}
|
|
|
|
: ${cross_prefix_microblaze="microblaze-linux-musl-"}
|
|
|
|
: ${cross_prefix_mips64el="mips64el-linux-gnuabi64-"}
|
|
|
|
: ${cross_prefix_mips64="mips64-linux-gnuabi64-"}
|
|
|
|
: ${cross_prefix_mipsel="mipsel-linux-gnu-"}
|
|
|
|
: ${cross_prefix_mips="mips-linux-gnu-"}
|
|
|
|
: ${cross_prefix_nios2="nios2-linux-gnu-"}
|
|
|
|
: ${cross_prefix_ppc="powerpc-linux-gnu-"}
|
|
|
|
: ${cross_prefix_ppc64="powerpc64-linux-gnu-"}
|
|
|
|
: ${cross_prefix_ppc64le="$cross_prefix_ppc64"}
|
|
|
|
: ${cross_prefix_riscv64="riscv64-linux-gnu-"}
|
|
|
|
: ${cross_prefix_s390x="s390x-linux-gnu-"}
|
|
|
|
: ${cross_prefix_sh4="sh4-linux-gnu-"}
|
|
|
|
: ${cross_prefix_sparc64="sparc64-linux-gnu-"}
|
|
|
|
: ${cross_prefix_sparc="$cross_prefix_sparc64"}
|
2023-08-09 11:13:43 +03:00
|
|
|
: ${cross_prefix_tricore="tricore-"}
|
2022-05-27 18:35:51 +03:00
|
|
|
: ${cross_prefix_x86_64="x86_64-linux-gnu-"}
|
|
|
|
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
: ${cross_cc_aarch64_be="$cross_cc_aarch64"}
|
|
|
|
: ${cross_cc_cflags_aarch64_be="-mbig-endian"}
|
2022-05-27 18:35:49 +03:00
|
|
|
: ${cross_cc_armeb="$cross_cc_arm"}
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
: ${cross_cc_cflags_armeb="-mbig-endian"}
|
|
|
|
: ${cross_cc_hexagon="hexagon-unknown-linux-musl-clang"}
|
2023-04-28 01:40:49 +03:00
|
|
|
: ${cross_cc_cflags_hexagon="-mv73 -O2 -static"}
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
: ${cross_cc_cflags_i386="-m32"}
|
2022-06-15 12:42:01 +03:00
|
|
|
: ${cross_cc_cflags_ppc="-m32 -mbig-endian"}
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
: ${cross_cc_cflags_ppc64="-m64 -mbig-endian"}
|
|
|
|
: ${cross_cc_ppc64le="$cross_cc_ppc64"}
|
|
|
|
: ${cross_cc_cflags_ppc64le="-m64 -mlittle-endian"}
|
|
|
|
: ${cross_cc_cflags_sparc64="-m64 -mcpu=ultrasparc"}
|
2022-05-27 18:35:49 +03:00
|
|
|
: ${cross_cc_sparc="$cross_cc_sparc64"}
|
|
|
|
: ${cross_cc_cflags_sparc="-m32 -mcpu=supersparc"}
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
: ${cross_cc_cflags_x86_64="-m64"}
|
|
|
|
|
2022-05-27 18:35:51 +03:00
|
|
|
compute_target_variable() {
|
build: try both native and cross compilers
Configure is trying to fall back on cross compilers for targets that
can have bi-arch or bi-endian toolchains, but there are many corner
cases where just checking the name can go wrong. For example, the RHEL
ppc64le compiler is bi-arch and bi-endian, but multilibs are disabled.
Therefore it cannot be used to build 32-bit hosted binaries like the
linux-user TCG tests.
Trying the cross compiler first also does not work, and an example for
this is also ppc64le. The powerpc64-linux-gnu-gcc binary from the
cross-gcc package is theoretically multilib-friendly, but it cannot
find the CRT files on a ppc64le host, because they are not in the .../le
multilib subdirectory.
This can be fixed by testing both the native compiler and the cross
compiler, and proceeding with the first one that works. To do this,
move the compiler usability check from the tests/tcg snippet to inside
probe_target_compiler and, while at it, restrict the softmmu emulation
target to basically a test for the presence of libgcc.
Tested-by: Matheus Kowalczuk Ferst <matheus.ferst@eldorado.org.br>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2022-06-22 11:42:58 +03:00
|
|
|
eval "$2="
|
2022-05-27 18:35:51 +03:00
|
|
|
if eval test -n "\"\${cross_prefix_$1}\""; then
|
|
|
|
if eval has "\"\${cross_prefix_$1}\$3\""; then
|
|
|
|
eval "$2=\"\${cross_prefix_$1}\$3\""
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
}
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
|
2022-10-12 17:33:03 +03:00
|
|
|
have_target() {
|
|
|
|
for i; do
|
|
|
|
case " $target_list " in
|
|
|
|
*" $i "*) return 0;;
|
|
|
|
*) ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2022-07-02 16:59:02 +03:00
|
|
|
# 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.
|
|
|
|
#
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
probe_target_compiler() {
|
|
|
|
# reset all output variables
|
build: try both native and cross compilers
Configure is trying to fall back on cross compilers for targets that
can have bi-arch or bi-endian toolchains, but there are many corner
cases where just checking the name can go wrong. For example, the RHEL
ppc64le compiler is bi-arch and bi-endian, but multilibs are disabled.
Therefore it cannot be used to build 32-bit hosted binaries like the
linux-user TCG tests.
Trying the cross compiler first also does not work, and an example for
this is also ppc64le. The powerpc64-linux-gnu-gcc binary from the
cross-gcc package is theoretically multilib-friendly, but it cannot
find the CRT files on a ppc64le host, because they are not in the .../le
multilib subdirectory.
This can be fixed by testing both the native compiler and the cross
compiler, and proceeding with the first one that works. To do this,
move the compiler usability check from the tests/tcg snippet to inside
probe_target_compiler and, while at it, restrict the softmmu emulation
target to basically a test for the presence of libgcc.
Tested-by: Matheus Kowalczuk Ferst <matheus.ferst@eldorado.org.br>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2022-06-22 11:42:58 +03:00
|
|
|
got_cross_cc=no
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
container_image=
|
|
|
|
container_hosts=
|
2023-11-03 11:48:21 +03:00
|
|
|
container_cross_prefix=
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
container_cross_cc=
|
2022-05-27 18:35:52 +03:00
|
|
|
container_cross_ar=
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
container_cross_as=
|
|
|
|
container_cross_ld=
|
2022-05-27 18:35:52 +03:00
|
|
|
container_cross_nm=
|
|
|
|
container_cross_objcopy=
|
|
|
|
container_cross_ranlib=
|
|
|
|
container_cross_strip=
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
|
2022-07-02 16:59:02 +03:00
|
|
|
target_arch=${1%%-*}
|
|
|
|
case $target_arch in
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
aarch64) container_hosts="x86_64 aarch64" ;;
|
|
|
|
alpha) container_hosts=x86_64 ;;
|
|
|
|
arm) container_hosts="x86_64 aarch64" ;;
|
|
|
|
cris) container_hosts=x86_64 ;;
|
|
|
|
hexagon) container_hosts=x86_64 ;;
|
|
|
|
hppa) container_hosts=x86_64 ;;
|
|
|
|
i386) container_hosts=x86_64 ;;
|
2022-07-04 10:06:29 +03:00
|
|
|
loongarch64) container_hosts=x86_64 ;;
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
m68k) container_hosts=x86_64 ;;
|
|
|
|
microblaze) container_hosts=x86_64 ;;
|
|
|
|
mips64el) container_hosts=x86_64 ;;
|
|
|
|
mips64) container_hosts=x86_64 ;;
|
|
|
|
mipsel) container_hosts=x86_64 ;;
|
|
|
|
mips) container_hosts=x86_64 ;;
|
|
|
|
nios2) container_hosts=x86_64 ;;
|
|
|
|
ppc) container_hosts=x86_64 ;;
|
|
|
|
ppc64|ppc64le) container_hosts=x86_64 ;;
|
|
|
|
riscv64) container_hosts=x86_64 ;;
|
|
|
|
s390x) container_hosts=x86_64 ;;
|
|
|
|
sh4) container_hosts=x86_64 ;;
|
|
|
|
sparc64) container_hosts=x86_64 ;;
|
|
|
|
tricore) container_hosts=x86_64 ;;
|
2023-08-07 12:22:08 +03:00
|
|
|
x86_64) container_hosts="aarch64 ppc64le x86_64" ;;
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
xtensa*) container_hosts=x86_64 ;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
for host in $container_hosts; do
|
|
|
|
test "$container" != no || continue
|
|
|
|
test "$host" = "$cpu" || continue
|
2022-07-02 16:59:02 +03:00
|
|
|
case $target_arch in
|
2023-11-03 11:48:21 +03:00
|
|
|
# debian-all-test-cross architectures
|
|
|
|
|
|
|
|
hppa|m68k|mips|riscv64|sparc64)
|
|
|
|
container_image=debian-all-test-cross
|
|
|
|
;;
|
|
|
|
mips64)
|
|
|
|
container_image=debian-all-test-cross
|
|
|
|
container_cross_prefix=mips64-linux-gnuabi64-
|
|
|
|
;;
|
|
|
|
ppc|ppc64|ppc64le)
|
|
|
|
container_image=debian-all-test-cross
|
|
|
|
container_cross_prefix=powerpc${target_arch#ppc}-linux-gnu-
|
|
|
|
;;
|
|
|
|
|
|
|
|
# debian-legacy-test-cross architectures (need Debian 11)
|
|
|
|
# - libc6.1-dev-alpha-cross: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1054412
|
|
|
|
# - sh4-linux-user: binaries don't run with bookworm compiler
|
|
|
|
|
|
|
|
alpha|sh4)
|
|
|
|
container_image=debian-legacy-test-cross
|
|
|
|
;;
|
|
|
|
|
|
|
|
# architectures with individual containers
|
|
|
|
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
aarch64)
|
|
|
|
# We don't have any bigendian build tools so we only use this for AArch64
|
|
|
|
container_image=debian-arm64-cross
|
2023-10-29 17:50:20 +03:00
|
|
|
;;
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
arm)
|
|
|
|
# We don't have any bigendian build tools so we only use this for ARM
|
|
|
|
container_image=debian-armhf-cross
|
2022-05-27 18:35:51 +03:00
|
|
|
container_cross_prefix=arm-linux-gnueabihf-
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
|
|
|
cris)
|
|
|
|
container_image=fedora-cris-cross
|
|
|
|
;;
|
|
|
|
hexagon)
|
2022-05-27 18:35:51 +03:00
|
|
|
container_cross_prefix=hexagon-unknown-linux-musl-
|
|
|
|
container_cross_cc=${container_cross_prefix}clang
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
|
|
|
i386)
|
2023-11-20 18:08:20 +03:00
|
|
|
container_image=debian-i686-cross
|
|
|
|
container_cross_prefix=i686-linux-gnu-
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
2022-07-04 10:06:29 +03:00
|
|
|
loongarch64)
|
|
|
|
container_image=debian-loongarch-cross
|
|
|
|
container_cross_prefix=loongarch64-unknown-linux-gnu-
|
|
|
|
;;
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
microblaze)
|
2022-05-27 18:35:51 +03:00
|
|
|
container_cross_prefix=microblaze-linux-musl-
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
|
|
|
mips64el)
|
|
|
|
container_image=debian-mips64el-cross
|
2022-05-27 18:35:51 +03:00
|
|
|
container_cross_prefix=mips64el-linux-gnuabi64-
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
|
|
|
tricore)
|
|
|
|
container_image=debian-tricore-cross
|
2022-05-27 18:35:51 +03:00
|
|
|
container_cross_prefix=tricore-
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
|
|
|
x86_64)
|
|
|
|
container_image=debian-amd64-cross
|
|
|
|
;;
|
|
|
|
xtensa*)
|
|
|
|
container_image=debian-xtensa-cross
|
|
|
|
|
|
|
|
# default to the dc232b cpu
|
2022-05-27 18:35:51 +03:00
|
|
|
container_cross_prefix=/opt/2020.07/xtensa-dc232b-elf/bin/xtensa-dc232b-elf-
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
;;
|
|
|
|
esac
|
2023-11-03 11:48:21 +03:00
|
|
|
# Debian and GNU architecture names usually match
|
|
|
|
: ${container_image:=debian-$target_arch-cross}
|
|
|
|
: ${container_cross_prefix:=$target_arch-linux-gnu-}
|
2022-05-27 18:35:51 +03:00
|
|
|
: ${container_cross_cc:=${container_cross_prefix}gcc}
|
2022-05-27 18:35:52 +03:00
|
|
|
: ${container_cross_ar:=${container_cross_prefix}ar}
|
2022-05-27 18:35:51 +03:00
|
|
|
: ${container_cross_as:=${container_cross_prefix}as}
|
|
|
|
: ${container_cross_ld:=${container_cross_prefix}ld}
|
2022-05-27 18:35:52 +03:00
|
|
|
: ${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}
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
done
|
|
|
|
|
build: try both native and cross compilers
Configure is trying to fall back on cross compilers for targets that
can have bi-arch or bi-endian toolchains, but there are many corner
cases where just checking the name can go wrong. For example, the RHEL
ppc64le compiler is bi-arch and bi-endian, but multilibs are disabled.
Therefore it cannot be used to build 32-bit hosted binaries like the
linux-user TCG tests.
Trying the cross compiler first also does not work, and an example for
this is also ppc64le. The powerpc64-linux-gnu-gcc binary from the
cross-gcc package is theoretically multilib-friendly, but it cannot
find the CRT files on a ppc64le host, because they are not in the .../le
multilib subdirectory.
This can be fixed by testing both the native compiler and the cross
compiler, and proceeding with the first one that works. To do this,
move the compiler usability check from the tests/tcg snippet to inside
probe_target_compiler and, while at it, restrict the softmmu emulation
target to basically a test for the presence of libgcc.
Tested-by: Matheus Kowalczuk Ferst <matheus.ferst@eldorado.org.br>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2022-06-22 11:42:58 +03:00
|
|
|
try=cross
|
2023-12-22 12:55:43 +03:00
|
|
|
# For softmmu/roms also look for a bi-endian or multilib-enabled host compiler
|
|
|
|
if [ "${1%softmmu}" != "$1" ] || test "$target_arch" = "$cpu"; then
|
2023-11-20 18:08:32 +03:00
|
|
|
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
|
|
|
|
fi
|
build: try both native and cross compilers
Configure is trying to fall back on cross compilers for targets that
can have bi-arch or bi-endian toolchains, but there are many corner
cases where just checking the name can go wrong. For example, the RHEL
ppc64le compiler is bi-arch and bi-endian, but multilibs are disabled.
Therefore it cannot be used to build 32-bit hosted binaries like the
linux-user TCG tests.
Trying the cross compiler first also does not work, and an example for
this is also ppc64le. The powerpc64-linux-gnu-gcc binary from the
cross-gcc package is theoretically multilib-friendly, but it cannot
find the CRT files on a ppc64le host, because they are not in the .../le
multilib subdirectory.
This can be fixed by testing both the native compiler and the cross
compiler, and proceeding with the first one that works. To do this,
move the compiler usability check from the tests/tcg snippet to inside
probe_target_compiler and, while at it, restrict the softmmu emulation
target to basically a test for the presence of libgcc.
Tested-by: Matheus Kowalczuk Ferst <matheus.ferst@eldorado.org.br>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2022-06-22 11:42:58 +03:00
|
|
|
eval "target_cflags=\${cross_cc_cflags_$target_arch}"
|
2022-08-25 18:07:03 +03:00
|
|
|
for thistry in $try; do
|
|
|
|
case $thistry in
|
build: try both native and cross compilers
Configure is trying to fall back on cross compilers for targets that
can have bi-arch or bi-endian toolchains, but there are many corner
cases where just checking the name can go wrong. For example, the RHEL
ppc64le compiler is bi-arch and bi-endian, but multilibs are disabled.
Therefore it cannot be used to build 32-bit hosted binaries like the
linux-user TCG tests.
Trying the cross compiler first also does not work, and an example for
this is also ppc64le. The powerpc64-linux-gnu-gcc binary from the
cross-gcc package is theoretically multilib-friendly, but it cannot
find the CRT files on a ppc64le host, because they are not in the .../le
multilib subdirectory.
This can be fixed by testing both the native compiler and the cross
compiler, and proceeding with the first one that works. To do this,
move the compiler usability check from the tests/tcg snippet to inside
probe_target_compiler and, while at it, restrict the softmmu emulation
target to basically a test for the presence of libgcc.
Tested-by: Matheus Kowalczuk Ferst <matheus.ferst@eldorado.org.br>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2022-06-22 11:42:58 +03:00
|
|
|
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
|
|
|
|
|
|
|
|
write_c_skeleton
|
|
|
|
case $1 in
|
|
|
|
*-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
|
2022-05-27 18:35:50 +03:00
|
|
|
fi
|
|
|
|
;;
|
|
|
|
esac
|
build: try both native and cross compilers
Configure is trying to fall back on cross compilers for targets that
can have bi-arch or bi-endian toolchains, but there are many corner
cases where just checking the name can go wrong. For example, the RHEL
ppc64le compiler is bi-arch and bi-endian, but multilibs are disabled.
Therefore it cannot be used to build 32-bit hosted binaries like the
linux-user TCG tests.
Trying the cross compiler first also does not work, and an example for
this is also ppc64le. The powerpc64-linux-gnu-gcc binary from the
cross-gcc package is theoretically multilib-friendly, but it cannot
find the CRT files on a ppc64le host, because they are not in the .../le
multilib subdirectory.
This can be fixed by testing both the native compiler and the cross
compiler, and proceeding with the first one that works. To do this,
move the compiler usability check from the tests/tcg snippet to inside
probe_target_compiler and, while at it, restrict the softmmu emulation
target to basically a test for the presence of libgcc.
Tested-by: Matheus Kowalczuk Ferst <matheus.ferst@eldorado.org.br>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2022-06-22 11:42:58 +03:00
|
|
|
done
|
|
|
|
if test $got_cross_cc != yes; then
|
|
|
|
build_static=
|
|
|
|
target_cc=
|
|
|
|
target_ccas=
|
|
|
|
target_ar=
|
|
|
|
target_as=
|
|
|
|
target_ld=
|
|
|
|
target_nm=
|
|
|
|
target_objcopy=
|
|
|
|
target_ranlib=
|
|
|
|
target_strip=
|
2022-05-27 18:35:50 +03:00
|
|
|
fi
|
2022-10-11 14:34:16 +03:00
|
|
|
test -n "$target_cc"
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
write_target_makefile() {
|
2022-06-15 12:45:55 +03:00
|
|
|
echo "EXTRA_CFLAGS=$target_cflags"
|
2022-09-29 14:42:06 +03:00
|
|
|
if test -z "$target_cc" && test -z "$target_as"; then
|
|
|
|
test -z "$container_image" && error_exit "Internal error: could not find cross compiler for $1?"
|
|
|
|
echo "$1: docker-image-$container_image" >> Makefile.prereqs
|
|
|
|
if test -n "$container_cross_cc"; then
|
|
|
|
echo "CC=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "CCAS=$docker_py cc --cc $container_cross_cc -i qemu/$container_image -s $source_path --"
|
|
|
|
fi
|
|
|
|
echo "AR=$docker_py cc --cc $container_cross_ar -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "AS=$docker_py cc --cc $container_cross_as -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "LD=$docker_py cc --cc $container_cross_ld -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "NM=$docker_py cc --cc $container_cross_nm -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "OBJCOPY=$docker_py cc --cc $container_cross_objcopy -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "RANLIB=$docker_py cc --cc $container_cross_ranlib -i qemu/$container_image -s $source_path --"
|
|
|
|
echo "STRIP=$docker_py cc --cc $container_cross_strip -i qemu/$container_image -s $source_path --"
|
|
|
|
else
|
|
|
|
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"
|
|
|
|
fi
|
|
|
|
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
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2022-05-27 18:35:55 +03:00
|
|
|
#######################################
|
|
|
|
# cross-compiled firmware targets
|
|
|
|
|
2022-05-27 18:35:53 +03:00
|
|
|
# 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"
|
2023-03-01 00:15:29 +03:00
|
|
|
LINKS="$LINKS docs/config"
|
2022-05-27 18:35:53 +03:00
|
|
|
LINKS="$LINKS pc-bios/optionrom/Makefile"
|
|
|
|
LINKS="$LINKS pc-bios/s390-ccw/Makefile"
|
2022-05-27 18:35:56 +03:00
|
|
|
LINKS="$LINKS pc-bios/vof/Makefile"
|
2022-05-27 18:35:53 +03:00
|
|
|
LINKS="$LINKS .gdbinit scripts" # scripts needed by relative path in .gdbinit
|
|
|
|
LINKS="$LINKS tests/avocado tests/data"
|
2023-11-03 12:00:04 +03:00
|
|
|
LINKS="$LINKS tests/qemu-iotests/check tests/qemu-iotests/Makefile"
|
2022-05-27 18:35:53 +03:00
|
|
|
LINKS="$LINKS python"
|
|
|
|
LINKS="$LINKS contrib/plugins/Makefile "
|
|
|
|
for f in $LINKS ; do
|
|
|
|
if [ -e "$source_path/$f" ]; then
|
|
|
|
symlink "$source_path/$f" "$f"
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
2022-09-29 14:42:05 +03:00
|
|
|
echo "# Automatically generated by configure - do not modify" > Makefile.prereqs
|
|
|
|
|
2010-05-26 18:08:29 +04:00
|
|
|
# Mac OS X ships with a broken assembler
|
2022-10-12 17:33:03 +03:00
|
|
|
if have_target i386-softmmu x86_64-softmmu && \
|
2023-11-03 11:17:48 +03:00
|
|
|
test "$host_os" != "darwin" && test "$host_os" != "sunos" && \
|
|
|
|
test "$host_os" != "haiku" && \
|
2022-09-29 14:41:57 +03:00
|
|
|
probe_target_compiler i386-softmmu; then
|
2023-08-30 13:05:08 +03:00
|
|
|
subdirs="$subdirs pc-bios/optionrom"
|
2022-06-06 12:35:41 +03:00
|
|
|
config_mak=pc-bios/optionrom/config.mak
|
|
|
|
echo "# Automatically generated by configure - do not modify" > $config_mak
|
|
|
|
echo "TOPSRC_DIR=$source_path" >> $config_mak
|
2022-10-11 14:34:16 +03:00
|
|
|
write_target_makefile >> $config_mak
|
2010-05-26 18:08:29 +04:00
|
|
|
fi
|
|
|
|
|
2022-10-12 17:33:03 +03:00
|
|
|
if have_target ppc-softmmu ppc64-softmmu && \
|
|
|
|
probe_target_compiler ppc-softmmu; then
|
2023-08-30 13:05:08 +03:00
|
|
|
subdirs="$subdirs pc-bios/vof"
|
2022-05-27 18:35:56 +03:00
|
|
|
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
|
2022-10-11 14:34:16 +03:00
|
|
|
write_target_makefile >> $config_mak
|
2022-05-27 18:35:56 +03:00
|
|
|
fi
|
|
|
|
|
2022-05-27 18:35:54 +03:00
|
|
|
# Only build s390-ccw bios if the compiler has -march=z900 or -march=z10
|
|
|
|
# (which is the lowest architecture level that Clang supports)
|
2023-05-19 14:26:39 +03:00
|
|
|
if have_target s390x-softmmu && probe_target_compiler s390x-softmmu && \
|
|
|
|
GIT=git "$source_path/scripts/git-submodule.sh" "$git_submodules_action" roms/SLOF >> config.log 2>&1; then
|
2022-10-11 14:34:16 +03:00
|
|
|
write_c_skeleton
|
|
|
|
do_compiler "$target_cc" $target_cc_cflags -march=z900 -o $TMPO -c $TMPC
|
|
|
|
has_z900=$?
|
|
|
|
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."
|
2021-05-02 14:22:21 +03:00
|
|
|
fi
|
2023-08-30 13:05:08 +03:00
|
|
|
subdirs="$subdirs pc-bios/s390-ccw"
|
2022-05-27 18:35:54 +03:00
|
|
|
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
|
2023-05-19 14:26:39 +03:00
|
|
|
echo "GIT_SUBMODULES_ACTION=$git_submodules_action" >> $config_mak
|
2022-10-11 14:34:16 +03:00
|
|
|
write_target_makefile >> $config_mak
|
2019-01-14 15:52:26 +03:00
|
|
|
fi
|
2013-04-23 05:23:03 +04:00
|
|
|
fi
|
|
|
|
|
2022-05-27 18:35:54 +03:00
|
|
|
#######################################
|
|
|
|
# generate config-host.mak
|
|
|
|
|
2009-07-16 20:34:18 +04:00
|
|
|
config_host_mak="config-host.mak"
|
|
|
|
|
|
|
|
echo "# Automatically generated by configure - do not modify" > $config_host_mak
|
|
|
|
echo >> $config_host_mak
|
|
|
|
|
2010-10-21 12:18:35 +04:00
|
|
|
echo all: >> $config_host_mak
|
2009-07-27 18:12:49 +04:00
|
|
|
|
2009-07-16 20:34:18 +04:00
|
|
|
echo "SRC_PATH=$source_path" >> $config_host_mak
|
2018-07-04 09:30:11 +03:00
|
|
|
echo "TARGET_DIRS=$target_list" >> $config_host_mak
|
2023-09-28 11:44:56 +03:00
|
|
|
echo "GDB=$gdb_bin" >> $config_host_mak
|
2022-09-29 14:41:58 +03:00
|
|
|
if test "$container" != no; then
|
2023-02-28 22:06:46 +03:00
|
|
|
echo "RUNC=$runc" >> $config_host_mak
|
2022-09-29 14:41:58 +03:00
|
|
|
fi
|
2023-08-30 13:05:08 +03:00
|
|
|
echo "SUBDIRS=$subdirs" >> $config_host_mak
|
2011-07-23 01:08:09 +04:00
|
|
|
echo "PYTHON=$python" >> $config_host_mak
|
2023-11-10 11:37:34 +03:00
|
|
|
echo "MKVENV_ENSUREGROUP=$mkvenv ensuregroup $mkvenv_online_flag" >> $config_host_mak
|
2020-03-03 18:06:20 +03:00
|
|
|
echo "GENISOIMAGE=$genisoimage" >> $config_host_mak
|
2019-06-10 13:05:14 +03:00
|
|
|
echo "MESON=$meson" >> $config_host_mak
|
2020-08-13 16:28:11 +03:00
|
|
|
echo "NINJA=$ninja" >> $config_host_mak
|
2009-07-27 18:12:49 +04:00
|
|
|
echo "EXESUF=$EXESUF" >> $config_host_mak
|
2023-08-08 15:03:03 +03:00
|
|
|
# use included Linux headers for KVM architectures
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = "linux" && test -n "$linux_arch"; then
|
2023-08-08 15:03:03 +03:00
|
|
|
symlink "$source_path/linux-headers/asm-$linux_arch" linux-headers/asm
|
2011-11-30 15:59:04 +04:00
|
|
|
fi
|
|
|
|
|
2020-09-21 11:37:49 +03:00
|
|
|
if test "$default_targets" = "yes"; then
|
|
|
|
echo "CONFIG_DEFAULT_TARGETS=y" >> $config_host_mak
|
|
|
|
fi
|
2013-04-18 08:47:31 +04:00
|
|
|
|
2023-09-07 13:54:42 +03:00
|
|
|
# contrib/plugins configuration
|
|
|
|
echo "# Automatically generated by configure - do not modify" > contrib/plugins/$config_host_mak
|
|
|
|
echo "SRC_PATH=$source_path/contrib/plugins" >> contrib/plugins/$config_host_mak
|
|
|
|
echo "PKG_CONFIG=${pkg_config}" >> contrib/plugins/$config_host_mak
|
|
|
|
echo "CC=$cc $CPU_CFLAGS" >> contrib/plugins/$config_host_mak
|
|
|
|
echo "CFLAGS=${CFLAGS-$default_cflags} $EXTRA_CFLAGS" >> contrib/plugins/$config_host_mak
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = windows; then
|
2023-11-06 21:51:02 +03:00
|
|
|
echo "DLLTOOL=$dlltool" >> contrib/plugins/$config_host_mak
|
|
|
|
fi
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = darwin; then
|
2023-09-07 13:54:42 +03:00
|
|
|
echo "CONFIG_DARWIN=y" >> contrib/plugins/$config_host_mak
|
|
|
|
fi
|
2023-11-03 11:17:48 +03:00
|
|
|
if test "$host_os" = windows; then
|
2023-11-06 21:51:04 +03:00
|
|
|
echo "CONFIG_WIN32=y" >> contrib/plugins/$config_host_mak
|
|
|
|
fi
|
2023-09-07 13:54:42 +03:00
|
|
|
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
# tests/tcg configuration
|
2022-09-29 14:42:00 +03:00
|
|
|
mkdir -p tests/tcg
|
2023-11-03 12:06:08 +03:00
|
|
|
echo "# Automatically generated by configure - do not modify" > tests/tcg/$config_host_mak
|
|
|
|
echo "SRC_PATH=$source_path" >> tests/tcg/$config_host_mak
|
2024-02-07 19:38:01 +03:00
|
|
|
if test "$plugins" = "yes" ; then
|
|
|
|
echo "CONFIG_PLUGIN=y" >> tests/tcg/$config_host_mak
|
|
|
|
fi
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
|
|
|
|
tcg_tests_targets=
|
|
|
|
for target in $target_list; do
|
|
|
|
arch=${target%%-*}
|
|
|
|
|
|
|
|
case $target in
|
2022-06-13 20:12:56 +03:00
|
|
|
xtensa*-linux-user)
|
2023-10-04 16:46:56 +03:00
|
|
|
# the toolchain is not complete with headers, only build system tests
|
2022-06-13 20:12:56 +03:00
|
|
|
continue
|
|
|
|
;;
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
*-softmmu)
|
2022-08-25 18:06:59 +03:00
|
|
|
test -f "$source_path/tests/tcg/$arch/Makefile.softmmu-target" || continue
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
qemu="qemu-system-$arch"
|
|
|
|
;;
|
|
|
|
*-linux-user|*-bsd-user)
|
|
|
|
qemu="qemu-$arch"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
2022-10-11 14:34:16 +03:00
|
|
|
if probe_target_compiler $target || test -n "$container_image"; then
|
2022-09-29 14:42:06 +03:00
|
|
|
test -n "$container_image" && build_static=y
|
2022-09-29 14:42:00 +03:00
|
|
|
mkdir -p "tests/tcg/$target"
|
2022-09-29 14:42:07 +03:00
|
|
|
config_target_mak=tests/tcg/$target/config-target.mak
|
2022-09-29 14:42:00 +03:00
|
|
|
ln -sf "$source_path/tests/tcg/Makefile.target" "tests/tcg/$target/Makefile"
|
2022-09-29 14:42:07 +03:00
|
|
|
echo "# Automatically generated by configure - do not modify" > "$config_target_mak"
|
|
|
|
echo "TARGET_NAME=$arch" >> "$config_target_mak"
|
2022-09-29 14:41:59 +03:00
|
|
|
echo "TARGET=$target" >> "$config_target_mak"
|
2022-09-29 14:42:07 +03:00
|
|
|
write_target_makefile "build-tcg-tests-$target" >> "$config_target_mak"
|
2022-09-29 14:42:04 +03:00
|
|
|
echo "BUILD_STATIC=$build_static" >> "$config_target_mak"
|
2022-09-29 14:42:07 +03:00
|
|
|
echo "QEMU=$PWD/$qemu" >> "$config_target_mak"
|
2023-03-03 05:57:59 +03:00
|
|
|
|
|
|
|
# will GDB work with these binaries?
|
|
|
|
if test "${gdb_arches#*$arch}" != "$gdb_arches"; then
|
2023-09-28 11:44:56 +03:00
|
|
|
echo "GDB=$gdb_bin" >> $config_target_mak
|
2023-03-03 05:57:59 +03:00
|
|
|
fi
|
|
|
|
|
2022-09-29 14:42:05 +03:00
|
|
|
echo "run-tcg-tests-$target: $qemu\$(EXESUF)" >> Makefile.prereqs
|
tests/tcg: merge configure.sh back into main configure script
tests/tcg/configure.sh has a complicated story.
In the beginning its code ran as part of the creation of config-target.mak
files, and that is where it placed the information on the target compiler.
However, probing for the buildability of TCG tests required multiple
inclusions of config-target.mak in the _main_ Makefile (not in
Makefile.target, which took care of building the QEMU executables in
the pre-Meson era), which polluted the namespace.
Thus, it was moved to a separate directory. It created small config-*.mak
files in $(BUILD_DIR)/tests/tcg. Those were also included multiple
times, but at least they were small and manageable; this was also an
important step in disentangling the TCG tests from Makefile.target.
Since then, Meson has allowed the configure script to go on a diet.
A few compilation tests survive (mostly for sanitizers) but these days
it mostly takes care of command line parsing, looking for tools, and
setting up the environment for Meson to do its stuff.
It's time to extend configure with the capability to build for more
than just one target: not just tests, but also firmware. As a first
step, integrate all the logic to find cross compilers in the configure
script, and move tests/tcg/configure.sh back there (though as a
separate loop, not integrated in the one that generates target
configurations for Meson).
tests/tcg is actually very close to being buildable as a standalone
project, so I actually expect the compiler tests to move back to
tests/tcg, as a "configure" script of sorts which would run at Make
time after the docker images are built. The GCC tree has a similar idea
of doing only bare-bones tree-wide configuration and leaving the rest
for Make time.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220517092616.1272238-8-pbonzini@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20220527153603.887929-19-alex.bennee@linaro.org>
2022-05-27 18:35:48 +03:00
|
|
|
tcg_tests_targets="$tcg_tests_targets $target"
|
|
|
|
fi
|
2019-08-07 17:35:23 +03:00
|
|
|
done
|
2023-01-20 21:48:22 +03:00
|
|
|
|
|
|
|
if test "$tcg" = "enabled"; then
|
2023-11-03 12:06:08 +03:00
|
|
|
echo "TCG_TESTS_TARGETS=$tcg_tests_targets" >> $config_host_mak
|
2023-01-20 21:48:22 +03:00
|
|
|
fi
|
2019-08-07 17:35:23 +03:00
|
|
|
|
2019-06-10 13:05:14 +03:00
|
|
|
if test "$skip_meson" = no; then
|
2021-03-16 10:19:34 +03:00
|
|
|
cross="config-meson.cross.new"
|
|
|
|
meson_quote() {
|
2021-11-05 12:07:37 +03:00
|
|
|
test $# = 0 && return
|
2020-09-23 12:26:17 +03:00
|
|
|
echo "'$(echo $* | sed "s/ /','/g")'"
|
2021-03-16 10:19:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
echo "# Automatically generated by configure - do not modify" > $cross
|
|
|
|
echo "[properties]" >> $cross
|
2021-07-07 16:17:44 +03:00
|
|
|
|
|
|
|
# unroll any custom device configs
|
2021-07-21 02:26:38 +03:00
|
|
|
for a in $device_archs; do
|
|
|
|
eval "c=\$devices_${a}"
|
|
|
|
echo "${a}-softmmu = '$c'" >> $cross
|
|
|
|
done
|
2021-07-07 16:17:44 +03:00
|
|
|
|
2021-03-16 10:19:34 +03:00
|
|
|
echo "[built-in options]" >> $cross
|
2021-11-05 12:09:26 +03:00
|
|
|
echo "c_args = [$(meson_quote $CFLAGS $EXTRA_CFLAGS)]" >> $cross
|
|
|
|
echo "cpp_args = [$(meson_quote $CXXFLAGS $EXTRA_CXXFLAGS)]" >> $cross
|
2022-01-09 00:38:55 +03:00
|
|
|
test -n "$objcc" && echo "objc_args = [$(meson_quote $OBJCFLAGS $EXTRA_OBJCFLAGS)]" >> $cross
|
2021-11-05 12:09:26 +03:00
|
|
|
echo "c_link_args = [$(meson_quote $CFLAGS $LDFLAGS $EXTRA_CFLAGS $EXTRA_LDFLAGS)]" >> $cross
|
|
|
|
echo "cpp_link_args = [$(meson_quote $CXXFLAGS $LDFLAGS $EXTRA_CXXFLAGS $EXTRA_LDFLAGS)]" >> $cross
|
2023-10-16 09:20:13 +03:00
|
|
|
|
|
|
|
# Only enable by default for git builds and on select OSes
|
|
|
|
echo "# environment defaults, can still be overridden on " >> $cross
|
|
|
|
echo "# the command line" >> $cross
|
|
|
|
if test -e "$source_path/.git" && \
|
2023-11-03 11:17:48 +03:00
|
|
|
{ test "$host_os" = linux || test "$host_os" = "windows"; }; then
|
2023-10-16 09:20:13 +03:00
|
|
|
echo 'werror = true' >> $cross
|
|
|
|
fi
|
|
|
|
echo "[project options]" >> $cross
|
|
|
|
if test "$SMBD" != ''; then
|
|
|
|
echo "smbd = $(meson_quote "$SMBD")" >> $cross
|
|
|
|
fi
|
2023-10-09 15:13:59 +03:00
|
|
|
if test "${QEMU_GA_MANUFACTURER}" != ''; then
|
|
|
|
echo "qemu_ga_manufacturer = $(meson_quote "${QEMU_GA_MANUFACTURER}")" >> $cross
|
|
|
|
fi
|
|
|
|
if test "${QEMU_GA_DISTRO}" != ''; then
|
|
|
|
echo "qemu_ga_distro = $(meson_quote "${QEMU_GA_DISTRO}")" >> $cross
|
|
|
|
fi
|
|
|
|
if test "${QEMU_GA_VERSION}" != ''; then
|
|
|
|
echo "qemu_ga_version = $(meson_quote "${QEMU_GA_VERSION}")" >> $cross
|
|
|
|
fi
|
2023-10-16 09:20:13 +03:00
|
|
|
|
|
|
|
echo >> $cross
|
2021-03-16 10:19:34 +03:00
|
|
|
echo "[binaries]" >> $cross
|
2021-09-29 18:14:43 +03:00
|
|
|
echo "c = [$(meson_quote $cc $CPU_CFLAGS)]" >> $cross
|
|
|
|
test -n "$cxx" && echo "cpp = [$(meson_quote $cxx $CPU_CFLAGS)]" >> $cross
|
|
|
|
test -n "$objcc" && echo "objc = [$(meson_quote $objcc $CPU_CFLAGS)]" >> $cross
|
2021-03-16 10:19:34 +03:00
|
|
|
echo "ar = [$(meson_quote $ar)]" >> $cross
|
2023-11-06 21:51:02 +03:00
|
|
|
echo "dlltool = [$(meson_quote $dlltool)]" >> $cross
|
2021-03-16 10:19:34 +03:00
|
|
|
echo "nm = [$(meson_quote $nm)]" >> $cross
|
2022-10-12 14:03:18 +03:00
|
|
|
echo "pkgconfig = [$(meson_quote $pkg_config)]" >> $cross
|
2023-10-17 18:32:50 +03:00
|
|
|
echo "pkg-config = [$(meson_quote $pkg_config)]" >> $cross
|
2021-03-16 10:19:34 +03:00
|
|
|
echo "ranlib = [$(meson_quote $ranlib)]" >> $cross
|
|
|
|
if has $sdl2_config; then
|
|
|
|
echo "sdl2-config = [$(meson_quote $sdl2_config)]" >> $cross
|
|
|
|
fi
|
|
|
|
echo "strip = [$(meson_quote $strip)]" >> $cross
|
2022-04-28 21:15:25 +03:00
|
|
|
echo "widl = [$(meson_quote $widl)]" >> $cross
|
2021-03-16 10:19:34 +03:00
|
|
|
echo "windres = [$(meson_quote $windres)]" >> $cross
|
2022-11-29 20:38:08 +03:00
|
|
|
echo "windmc = [$(meson_quote $windmc)]" >> $cross
|
2021-03-16 10:19:34 +03:00
|
|
|
if test "$cross_compile" = "yes"; then
|
2019-07-13 00:47:54 +03:00
|
|
|
echo "[host_machine]" >> $cross
|
2023-11-03 11:17:48 +03:00
|
|
|
echo "system = '$host_os'" >> $cross
|
2021-11-08 16:18:17 +03:00
|
|
|
case "$cpu" in
|
2021-01-26 04:24:54 +03:00
|
|
|
i386)
|
2019-07-13 00:47:54 +03:00
|
|
|
echo "cpu_family = 'x86'" >> $cross
|
|
|
|
;;
|
|
|
|
*)
|
2021-11-08 16:18:17 +03:00
|
|
|
echo "cpu_family = '$cpu'" >> $cross
|
2019-07-13 00:47:54 +03:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
echo "cpu = '$cpu'" >> $cross
|
|
|
|
if test "$bigendian" = "yes" ; then
|
|
|
|
echo "endian = 'big'" >> $cross
|
|
|
|
else
|
|
|
|
echo "endian = 'little'" >> $cross
|
|
|
|
fi
|
2023-07-07 17:12:19 +03:00
|
|
|
|
|
|
|
native="config-meson.native.new"
|
|
|
|
echo "# Automatically generated by configure - do not modify" > $native
|
|
|
|
echo "[binaries]" >> $native
|
|
|
|
echo "c = [$(meson_quote $host_cc)]" >> $native
|
|
|
|
mv $native config-meson.native
|
2023-10-16 09:18:08 +03:00
|
|
|
meson_option_add --native-file
|
|
|
|
meson_option_add config-meson.native
|
2021-03-16 10:19:34 +03:00
|
|
|
fi
|
|
|
|
mv $cross config-meson.cross
|
2023-10-16 09:18:08 +03:00
|
|
|
meson_add_machine_file config-meson.cross
|
2023-11-03 11:17:48 +03:00
|
|
|
if test -f "$source_path/configs/meson/$host_os.txt"; then
|
|
|
|
meson_add_machine_file $source_path/configs/meson/$host_os.txt
|
2023-10-16 09:18:08 +03:00
|
|
|
fi
|
2019-07-13 00:47:54 +03:00
|
|
|
|
2021-03-16 10:19:34 +03:00
|
|
|
rm -rf meson-private meson-info meson-logs
|
2022-04-20 18:33:59 +03:00
|
|
|
|
2023-05-18 17:11:29 +03:00
|
|
|
test "$download" = "disabled" && meson_option_add "--wrap-mode=nodownload"
|
2022-04-20 18:33:59 +03:00
|
|
|
test "$default_feature" = no && meson_option_add -Dauto_features=disabled
|
2022-07-14 15:33:49 +03:00
|
|
|
test "$static" = yes && meson_option_add -Dprefer_static=true
|
2022-04-20 18:33:59 +03:00
|
|
|
test "$pie" = no && meson_option_add -Db_pie=false
|
|
|
|
|
|
|
|
# QEMU options
|
2023-09-26 18:20:53 +03:00
|
|
|
test "$cfi" != false && meson_option_add "-Dcfi=$cfi" "-Db_lto=$cfi"
|
2023-05-11 06:54:28 +03:00
|
|
|
test "$docs" != auto && meson_option_add "-Ddocs=$docs"
|
2022-04-20 18:33:59 +03:00
|
|
|
test -n "${LIB_FUZZING_ENGINE+xxx}" && meson_option_add "-Dfuzzing_engine=$LIB_FUZZING_ENGINE"
|
2023-08-30 13:20:53 +03:00
|
|
|
test "$plugins" = yes && meson_option_add "-Dplugins=true"
|
2022-04-20 18:33:59 +03:00
|
|
|
test "$tcg" != enabled && meson_option_add "-Dtcg=$tcg"
|
2021-10-07 16:08:28 +03:00
|
|
|
run_meson() {
|
2023-10-16 09:18:08 +03:00
|
|
|
NINJA=$ninja $meson setup "$@" "$PWD" "$source_path"
|
2021-10-07 16:08:28 +03:00
|
|
|
}
|
|
|
|
eval run_meson $meson_options
|
2021-03-16 10:19:34 +03:00
|
|
|
if test "$?" -ne 0 ; then
|
|
|
|
error_exit "meson setup failed"
|
|
|
|
fi
|
2023-05-23 18:56:33 +03:00
|
|
|
echo "$meson" > build.ninja.stamp
|
2023-05-19 21:04:07 +03:00
|
|
|
else
|
|
|
|
if test -f meson-private/cmd_line.txt; then
|
|
|
|
# Adjust old command line options that were removed
|
|
|
|
# sed -i is not portable
|
|
|
|
perl -i -ne '
|
|
|
|
/^sphinx_build/ && next;
|
|
|
|
print;' meson-private/cmd_line.txt
|
|
|
|
fi
|
2019-06-10 13:05:14 +03:00
|
|
|
fi
|
|
|
|
|
2014-03-09 19:37:49 +04:00
|
|
|
# Save the configure command line for later reuse.
|
|
|
|
cat <<EOD >config.status
|
|
|
|
#!/bin/sh
|
|
|
|
# Generated by configure.
|
|
|
|
# Run this file to recreate the current configuration.
|
|
|
|
# Compiler output produced by configure, useful for debugging
|
|
|
|
# configure, is in config.log if it exists.
|
|
|
|
EOD
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
|
|
|
|
preserve_env() {
|
|
|
|
envname=$1
|
|
|
|
|
|
|
|
eval envval=\$$envname
|
|
|
|
|
|
|
|
if test -n "$envval"
|
|
|
|
then
|
|
|
|
echo "$envname='$envval'" >> config.status
|
|
|
|
echo "export $envname" >> config.status
|
|
|
|
else
|
|
|
|
echo "unset $envname" >> config.status
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
|
|
|
# Preserve various env variables that influence what
|
|
|
|
# features/build target configure will detect
|
|
|
|
preserve_env AR
|
|
|
|
preserve_env AS
|
|
|
|
preserve_env CC
|
2021-11-05 12:08:43 +03:00
|
|
|
preserve_env CFLAGS
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
preserve_env CXX
|
2021-11-05 12:08:43 +03:00
|
|
|
preserve_env CXXFLAGS
|
2023-11-06 21:51:02 +03:00
|
|
|
preserve_env DLLTOOL
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
preserve_env LD
|
2021-11-05 12:08:43 +03:00
|
|
|
preserve_env LDFLAGS
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
preserve_env LD_LIBRARY_PATH
|
|
|
|
preserve_env NM
|
2022-06-07 13:14:47 +03:00
|
|
|
preserve_env OBJCFLAGS
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
preserve_env OBJCOPY
|
|
|
|
preserve_env PATH
|
|
|
|
preserve_env PKG_CONFIG
|
|
|
|
preserve_env PKG_CONFIG_LIBDIR
|
|
|
|
preserve_env PKG_CONFIG_PATH
|
|
|
|
preserve_env PYTHON
|
2022-10-12 12:35:17 +03:00
|
|
|
preserve_env QEMU_GA_MANUFACTURER
|
|
|
|
preserve_env QEMU_GA_DISTRO
|
|
|
|
preserve_env QEMU_GA_VERSION
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
preserve_env SDL2_CONFIG
|
|
|
|
preserve_env SMBD
|
|
|
|
preserve_env STRIP
|
2022-04-28 21:15:25 +03:00
|
|
|
preserve_env WIDL
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
preserve_env WINDRES
|
2022-11-29 20:38:08 +03:00
|
|
|
preserve_env WINDMC
|
configure: preserve various environment variables in config.status
The config.status script is auto-generated by configure upon
completion. The intention is that config.status can be later invoked by
the developer directly, or by make indirectly, to re-detect the same
environment that configure originally used.
The current config.status script, however, only contains a record of the
command line arguments to configure. Various environment variables have
an effect on what configure will find. In particular PKG_CONFIG_LIBDIR &
PKG_CONFIG_PATH vars will affect what libraries pkg-config finds. The
PATH var will affect what toolchain binaries and XXXX-config scripts are
found. The LD_LIBRARY_PATH var will affect what libraries are
found. Most commands have env variables that will override the name/path
of the default version configure finds.
All these key env variables should be recorded in the config.status script.
Autoconf would also preserve CFLAGS, LDFLAGS, LIBS, CPPFLAGS, but QEMU
deals with those differently, expecting extra flags to be set using
configure args, rather than env variables. At the end of the script we
also don't have the original values of those env vars, as we modify them
during configure.
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <20180904123603.10016-1-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-09-04 15:36:03 +03:00
|
|
|
|
2014-03-09 19:37:49 +04:00
|
|
|
printf "exec" >>config.status
|
2019-06-10 13:05:14 +03:00
|
|
|
for i in "$0" "$@"; do
|
2020-09-08 14:20:45 +03:00
|
|
|
test "$i" = --skip-meson || printf " %s" "$(quote_sh "$i")" >>config.status
|
2019-06-10 13:05:14 +03:00
|
|
|
done
|
2016-01-12 14:58:48 +03:00
|
|
|
echo ' "$@"' >>config.status
|
2014-03-09 19:37:49 +04:00
|
|
|
chmod +x config.status
|
|
|
|
|
2014-05-23 20:07:24 +04:00
|
|
|
rm -r "$TMPDIR1"
|