From 0fdc1887a7426bf7974f0ca6bb24815dff4a2997 Mon Sep 17 00:00:00 2001 From: Alexey Neyman Date: Sun, 3 Apr 2016 10:26:24 -0700 Subject: Change multilib functions to set the variable. 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 diff --git a/scripts/build/arch.sh b/scripts/build/arch.sh index 48da2d6..2199a17 100644 --- a/scripts/build/arch.sh +++ b/scripts/build/arch.sh @@ -6,18 +6,15 @@ CT_DoArchTupleValues() { } # Multilib: change the target triplet according to CFLAGS +# Usage: CT_DoArchGlibcAdjustTuple CT_DoArchMultilibTarget() { - local multi_flags="${1}" - local target="${2}" - - echo "${target}" + :; } # Multilib: Adjust target tuple for GLIBC +# Usage: CT_DoArchGlibcAdjustTuple CT_DoArchGlibcAdjustTuple() { - local target="${1}" - - echo "${target}" + :; } # Override from the actual arch implementation as needed. diff --git a/scripts/build/arch/powerpc.sh b/scripts/build/arch/powerpc.sh index 964dd25..8015724 100644 --- a/scripts/build/arch/powerpc.sh +++ b/scripts/build/arch/powerpc.sh @@ -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_}\" } diff --git a/scripts/build/arch/s390.sh b/scripts/build/arch/s390.sh index e303420..dff86a0 100644 --- a/scripts/build/arch/s390.sh +++ b/scripts/build/arch/s390.sh @@ -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_}\" } diff --git a/scripts/build/arch/sparc.sh b/scripts/build/arch/sparc.sh index 189cebe..15213a6 100644 --- a/scripts/build/arch/sparc.sh +++ b/scripts/build/arch/sparc.sh @@ -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_ + + eval target_=\"\${${target_var}}\" - case "${target}" in + 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_}\" } diff --git a/scripts/build/arch/x86.sh b/scripts/build/arch/x86.sh index 0e41d67..5147678 100644 --- a/scripts/build/arch/x86.sh +++ b/scripts/build/arch/x86.sh @@ -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_ + + eval target_=\"\${${target_var}}\" - case "${target}" in + 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_}\" } diff --git a/scripts/build/libc/glibc.sh b/scripts/build/libc/glibc.sh index a08ed97..dc9443c 100644 --- a/scripts/build/libc/glibc.sh +++ b/scripts/build/libc/glibc.sh @@ -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 diff --git a/scripts/functions b/scripts/functions index 49b0686..ef75e09 100644 --- a/scripts/functions +++ b/scripts/functions @@ -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" -- cgit v0.10.2-6-g49f6