ExternalVendorCode/crosstool-ng
1
0
Fork 0
mirror of https://github.com/crosstool-ng/crosstool-ng.git synced 2025-04-18 00:06:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Change multilib functions to set the variable.

Browse Source 
Rather than echo-ing the new value, set the value into the variable with
the name passed as an argument (similar to CT_SanitizeVarDir). This
allows to use CT_DoLog in these functions.

Signed-off-by: Alexey Neyman <stilor@att.net>
This commit is contained in:
Alexey Neyman 2016-04-03 10:26:24 -07:00
parent 3ebc5d0c1e
commit 0fdc1887a7
7 changed files with 79 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
scripts/build/arch.sh
View File

@ -6,18 +6,15 @@ CT_DoArchTupleValues() {
}
# Multilib: change the target triplet according to CFLAGS
# Usage: CT_DoArchGlibcAdjustTuple <variable-name> <CFLAGS>
CT_DoArchMultilibTarget() {
local multi_flags="${1}"
local target="${2}"
echo "${target}"
:;
}
# Multilib: Adjust target tuple for GLIBC
# Usage: CT_DoArchGlibcAdjustTuple <variable-name>
CT_DoArchGlibcAdjustTuple() {
local target="${1}"
echo "${target}"
:;
}
# Override from the actual arch implementation as needed.

31
scripts/build/arch/powerpc.sh
View File

@ -29,11 +29,12 @@ CT_DoArchTupleValues () {
#------------------------------------------------------------------------------
# Get multilib architecture-specific target
# Usage: CT_DoArchMultilibTarget "multilib flags" "target tuple"
# Usage: CT_DoArchMultilibTarget "target variable" "multilib flags"
CT_DoArchMultilibTarget ()
{
local target="${1}"; shift
local target_var="${1}"; shift
local -a multi_flags=( "$@" )
local target_
local m32=false
local m64=false
@ -49,22 +50,24 @@ CT_DoArchMultilibTarget ()
esac
done
eval target_=\"\${${target_var}}\"
# Fix up bitness
case "${target}" in
powerpc-*) $m64 && target=${target/#powerpc-/powerpc64-} ;;
powerpcle-*) $m64 && target=${target/#powerpcle-/powerpc64le-} ;;
powerpc64-*) $m32 && target=${target/#powerpc64-/powerpc-} ;;
powerpc64le-*) $m32 && target=${target/#powerpc64le-/powerpcle-} ;;
case "${target_}" in
powerpc-*) $m64 && target_=${target_/#powerpc-/powerpc64-} ;;
powerpcle-*) $m64 && target_=${target_/#powerpcle-/powerpc64le-} ;;
powerpc64-*) $m32 && target_=${target_/#powerpc64-/powerpc-} ;;
powerpc64le-*) $m32 && target_=${target_/#powerpc64le-/powerpcle-} ;;
esac
# Fix up endianness
case "${target}" in
powerpc-*) $mlittle && target=${target/#powerpc-/powerpcle-} ;;
powerpcle-*) $mbig && target=${target/#powerpcle-/powerpc-} ;;
powerpc64-*) $mlittle && target=${target/#powerpc64-/powerpc64le-} ;;
powerpc64le-*) $mbig && target=${target/#powerpc64le-/powerpc64-} ;;
case "${target_}" in
powerpc-*) $mlittle && target_=${target_/#powerpc-/powerpcle-} ;;
powerpcle-*) $mbig && target_=${target_/#powerpcle-/powerpc-} ;;
powerpc64-*) $mlittle && target_=${target_/#powerpc64-/powerpc64le-} ;;
powerpc64le-*) $mbig && target_=${target_/#powerpc64le-/powerpc64-} ;;
esac
# return the target
echo "${target}"
# Set the target variable
eval ${target_var}=\"${target_}\"
}

16
scripts/build/arch/s390.sh
View File

@ -9,11 +9,12 @@ CT_DoArchTupleValues() {
#------------------------------------------------------------------------------
# Get multilib architecture-specific target
# Usage: CT_DoArchMultilibTarget "multilib flags" "target tuple"
# Usage: CT_DoArchMultilibTarget "target variable" "multilib flags"
CT_DoArchMultilibTarget ()
{
local target="${1}"; shift
local target_var="${1}"; shift
local -a multi_flags=( "$@" )
local target_
local m31=false
local m64=false
@ -25,11 +26,14 @@ CT_DoArchMultilibTarget ()
esac
done
eval target_=\"\${${target_var}}\"
# Fix bitness
case "${target}" in
s390-*) $m64 && target=${target/#s390-/s390x-} ;;
s390x-*) $m31 && target=${target/#s390x-/s390-} ;;
case "${target_}" in
s390-*) $m64 && target_=${target_/#s390-/s390x-} ;;
s390x-*) $m31 && target_=${target_/#s390x-/s390-} ;;
esac
echo "${target}"
# Set the target variable
eval ${target_var}=\"${target_}\"
}

29
scripts/build/arch/sparc.sh
View File

@ -19,11 +19,12 @@ CT_DoArchTupleValues() {
#------------------------------------------------------------------------------
# Get multilib architecture-specific target
# Usage: CT_DoArchMultilibTarget "multilib flags" "target tuple"
# Usage: CT_DoArchMultilibTarget "target variable" "multilib flags"
CT_DoArchMultilibTarget ()
{
local target="${1}"; shift
local target_var="${1}"; shift
local -a multi_flags=( "$@" )
local target_
local m32=false
local m64=false
@ -35,29 +36,37 @@ CT_DoArchMultilibTarget ()
esac
done
eval target_=\"\${${target_var}}\"
# Fix up bitness
case "${target}" in
sparc-*) $m64 && target=${target/#sparc-/sparc64-} ;;
sparc64-*) $m32 && target=${target/#sparc64-/sparc-} ;;
case "${target_}" in
sparc-*) $m64 && target_=${target_/#sparc-/sparc64-} ;;
sparc64-*) $m32 && target_=${target_/#sparc64-/sparc-} ;;
esac
echo "${target}"
# Set the target variable
eval ${target_var}=\"${target_}\"
}
# Special tuple adjustment for glibc.
CT_DoArchGlibcAdjustTuple() {
local target="${1}"
local target_var="${1}"
local target_
case "${target}" in
eval target_=\"\${${target_var}}\"
case "${target_}" in
# SPARC quirk: glibc 2.23 and newer dropped support for SPARCv8 and
# earlier (corresponding pthread barrier code is missing). Until this
# support is reintroduced, configure as sparcv9.
sparc-*)
if [ "${CT_LIBC_GLIBC_2_23_or_later}" = y ]; then
target=${target/#sparc-/sparcv9-}
CT_DoLog WARN "GLIBC 2.23 only supports SPARCv9"
target_=${target_/#sparc-/sparcv9-}
fi
;;
esac
echo "${target}"
# Set the target variable
eval ${target_var}=\"${target_}\"
}

38
scripts/build/arch/x86.sh
View File

@ -35,11 +35,12 @@ CT_DoArchTupleValues() {
#------------------------------------------------------------------------------
# Get multilib architecture-specific target
# Usage: CT_DoArchMultilibTarget "multilib flags" "target tuple"
# Usage: CT_DoArchMultilibTarget "target variable" "multilib flags"
CT_DoArchMultilibTarget ()
{
local target="${1}"; shift
local target_var="${1}"; shift
local -a multi_flags=( "$@" )
local target_
local bit32=false
local bit64=false
@ -54,26 +55,32 @@ CT_DoArchMultilibTarget ()
esac
done
eval target_=\"\${${target_var}}\"
# Fix up architecture.
case "${target}" in
x86_64-*) $bit32 && target=${target/#x86_64-/i386-} ;;
i[34567]86-*) $bit64 && target=${target/#i[34567]86-/x86_64-} ;;
case "${target_}" in
x86_64-*) $bit32 && target_=${target_/#x86_64-/i386-} ;;
i[34567]86-*) $bit64 && target_=${target_/#i[34567]86-/x86_64-} ;;
esac
# Fix up the ABI part.
case "${target}" in
*x32) $abi_dflt && target=${target/%x32} ;;
*) $abi_x32 && target=${target}x32 ;;
case "${target_}" in
*x32) $abi_dflt && target_=${target_/%x32} ;;
*) $abi_x32 && target_=${target_}x32 ;;
esac
echo "${target}"
# Set the target variable
eval ${target_var}=\"${target_}\"
}
# Adjust target tuple for GLIBC
CT_DoArchGlibcAdjustTuple() {
local target="${1}"
local target_var="${1}"
local target_
case "${target}" in
eval target_=\"\${${target_var}}\"
case "${target_}" in
# x86 quirk: architecture name is i386, but glibc expects i[4567]86 - to
# indicate the desired optimization. If it was a multilib variant of x86_64,
# then it targets at least NetBurst a.k.a. i786, but we'll follow the model
@ -81,14 +88,15 @@ CT_DoArchGlibcAdjustTuple() {
# conservative choice, i486.
i386-*)
if [ "${CT_TARGET_ARCH}" = "x86_64" ]; then
target=${target/#i386-/i686-}
target_=${target_/#i386-/i686-}
elif [ "${CT_TARGET_ARCH}" != "i386" ]; then
target=${target/#i386-/${CT_TARGET_ARCH}-}
target_=${target_/#i386-/${CT_TARGET_ARCH}-}
else
target=${target/#i386-/i486-}
target_=${target_/#i386-/i486-}
fi
;;
esac
echo "${target}"
# Set the target variable
eval ${target_var}=\"${target_}\"
}

5
scripts/build/libc/glibc.sh
View File

@ -120,8 +120,9 @@ do_libc_backend() {
multi_root=$( "${CT_TARGET}-gcc" -print-sysroot ${multi_flags} )
# Adjust target tuple according to CFLAGS + any GLIBC quirks
target=$( CT_DoMultilibTarget "${CT_TARGET}" ${extra_flags} )
target=$( CT_DoArchGlibcAdjustTuple "${target}" )
target="${CT_TARGET}"
CT_DoMultilibTarget target ${extra_flags}
CT_DoArchGlibcAdjustTuple target
CT_DoStep INFO "Building for multilib '${multi_flags}'"
# Ensure sysroot (with suffix, if applicable) exists

6
scripts/functions
View File

@ -1371,18 +1371,18 @@ CT_DoBuildTargetTuple() {
# GCC prints nothing and exits with status 0), falling back to calling
# the architecture-specific functions.
CT_DoMultilibTarget() {
local target="$1"; shift
local target_var="$1"; shift
local -a multi_flags=( "$@" )
local gcc_multiarch
gcc_multiarch=$( "${CT_TARGET}-gcc" -print-multiarch "${multi_flags[@]}" )
if [ -n "${gcc_multiarch}" ]; then
echo "${gcc_multiarch}"
eval "${target_var}=${gcc_multiarch}"
return
fi
# Fall back to arch-specific guesswork
CT_DoArchMultilibTarget "${target}" "${multi_flags[@]}"
CT_DoArchMultilibTarget "${target_var}" "${multi_flags[@]}"
}
# This function does pause the build until the user strikes "Return"