diff --git a/extra/qt5-webengine/0001-Add-ARM-headers-back.patch b/extra/qt5-webengine/0001-Add-ARM-headers-back.patch new file mode 100644 index 000000000..926c4ce62 --- /dev/null +++ b/extra/qt5-webengine/0001-Add-ARM-headers-back.patch @@ -0,0 +1,200 @@ +From 65fd24e06b2f1b559a7c788d5b90afacf9dba9a4 Mon Sep 17 00:00:00 2001 +From: Kevin Mihelich +Date: Sun, 12 Aug 2018 18:11:42 -0600 +Subject: [PATCH] Add ARM headers back + +--- + base/numerics/safe_conversions_arm_impl.h | 51 +++++++++ + base/numerics/safe_math_arm_impl.h | 122 ++++++++++++++++++++++ + 2 files changed, 173 insertions(+) + create mode 100644 base/numerics/safe_conversions_arm_impl.h + create mode 100644 base/numerics/safe_math_arm_impl.h + +diff --git a/base/numerics/safe_conversions_arm_impl.h b/base/numerics/safe_conversions_arm_impl.h +new file mode 100644 +index 00000000..da5813f6 +--- /dev/null ++++ b/base/numerics/safe_conversions_arm_impl.h +@@ -0,0 +1,51 @@ ++// Copyright 2017 The Chromium Authors. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_ ++#define BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_ ++ ++#include ++#include ++#include ++ ++#include "base/numerics/safe_conversions_impl.h" ++ ++namespace base { ++namespace internal { ++ ++// Fast saturation to a destination type. ++template ++struct SaturateFastAsmOp { ++ static const bool is_supported = ++ std::is_signed::value && std::is_integral::value && ++ std::is_integral::value && ++ IntegerBitsPlusSign::value <= IntegerBitsPlusSign::value && ++ IntegerBitsPlusSign::value <= IntegerBitsPlusSign::value && ++ !IsTypeInRangeForNumericType::value; ++ ++ __attribute__((always_inline)) static Dst Do(Src value) { ++ int32_t src = value; ++ typename std::conditional::value, int32_t, ++ uint32_t>::type result; ++ if (std::is_signed::value) { ++ asm("ssat %[dst], %[shift], %[src]" ++ : [dst] "=r"(result) ++ : [src] "r"(src), [shift] "n"(IntegerBitsPlusSign::value <= 32 ++ ? IntegerBitsPlusSign::value ++ : 32)); ++ } else { ++ asm("usat %[dst], %[shift], %[src]" ++ : [dst] "=r"(result) ++ : [src] "r"(src), [shift] "n"(IntegerBitsPlusSign::value < 32 ++ ? IntegerBitsPlusSign::value ++ : 31)); ++ } ++ return static_cast(result); ++ } ++}; ++ ++} // namespace internal ++} // namespace base ++ ++#endif // BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_ +diff --git a/base/numerics/safe_math_arm_impl.h b/base/numerics/safe_math_arm_impl.h +new file mode 100644 +index 00000000..a7cda1bb +--- /dev/null ++++ b/base/numerics/safe_math_arm_impl.h +@@ -0,0 +1,122 @@ ++// Copyright 2017 The Chromium Authors. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_ ++#define BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_ ++ ++#include ++#include ++#include ++ ++#include "base/numerics/safe_conversions.h" ++ ++namespace base { ++namespace internal { ++ ++template ++struct CheckedMulFastAsmOp { ++ static const bool is_supported = ++ FastIntegerArithmeticPromotion::is_contained; ++ ++ // The following is much more efficient than the Clang and GCC builtins for ++ // performing overflow-checked multiplication when a twice wider type is ++ // available. The below compiles down to 2-3 instructions, depending on the ++ // width of the types in use. ++ // As an example, an int32_t multiply compiles to: ++ // smull r0, r1, r0, r1 ++ // cmp r1, r1, asr #31 ++ // And an int16_t multiply compiles to: ++ // smulbb r1, r1, r0 ++ // asr r2, r1, #16 ++ // cmp r2, r1, asr #15 ++ template ++ __attribute__((always_inline)) static bool Do(T x, U y, V* result) { ++ using Promotion = typename FastIntegerArithmeticPromotion::type; ++ Promotion presult; ++ ++ presult = static_cast(x) * static_cast(y); ++ *result = static_cast(presult); ++ return IsValueInRangeForNumericType(presult); ++ } ++}; ++ ++template ++struct ClampedAddFastAsmOp { ++ static const bool is_supported = ++ BigEnoughPromotion::is_contained && ++ IsTypeInRangeForNumericType< ++ int32_t, ++ typename BigEnoughPromotion::type>::value; ++ ++ template ++ __attribute__((always_inline)) static V Do(T x, U y) { ++ // This will get promoted to an int, so let the compiler do whatever is ++ // clever and rely on the saturated cast to bounds check. ++ if (IsIntegerArithmeticSafe::value) ++ return saturated_cast(x + y); ++ ++ int32_t result; ++ int32_t x_i32 = x; ++ int32_t y_i32 = y; ++ ++ asm("qadd %[result], %[first], %[second]" ++ : [result] "=r"(result) ++ : [first] "r"(x_i32), [second] "r"(y_i32)); ++ return saturated_cast(result); ++ } ++}; ++ ++template ++struct ClampedSubFastAsmOp { ++ static const bool is_supported = ++ BigEnoughPromotion::is_contained && ++ IsTypeInRangeForNumericType< ++ int32_t, ++ typename BigEnoughPromotion::type>::value; ++ ++ template ++ __attribute__((always_inline)) static V Do(T x, U y) { ++ // This will get promoted to an int, so let the compiler do whatever is ++ // clever and rely on the saturated cast to bounds check. ++ if (IsIntegerArithmeticSafe::value) ++ return saturated_cast(x - y); ++ ++ int32_t result; ++ int32_t x_i32 = x; ++ int32_t y_i32 = y; ++ ++ asm("qsub %[result], %[first], %[second]" ++ : [result] "=r"(result) ++ : [first] "r"(x_i32), [second] "r"(y_i32)); ++ return saturated_cast(result); ++ } ++}; ++ ++template ++struct ClampedMulFastAsmOp { ++ static const bool is_supported = CheckedMulFastAsmOp::is_supported; ++ ++ template ++ __attribute__((always_inline)) static V Do(T x, U y) { ++ // Use the CheckedMulFastAsmOp for full-width 32-bit values, because ++ // it's fewer instructions than promoting and then saturating. ++ if (!IsIntegerArithmeticSafe::value && ++ !IsIntegerArithmeticSafe::value) { ++ V result; ++ if (CheckedMulFastAsmOp::Do(x, y, &result)) ++ return result; ++ return CommonMaxOrMin(IsValueNegative(x) ^ IsValueNegative(y)); ++ } ++ ++ assert((FastIntegerArithmeticPromotion::is_contained)); ++ using Promotion = typename FastIntegerArithmeticPromotion::type; ++ return saturated_cast(static_cast(x) * ++ static_cast(y)); ++ } ++}; ++ ++} // namespace internal ++} // namespace base ++ ++#endif // BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_ +-- +2.18.0 + diff --git a/extra/qt5-webengine/PKGBUILD b/extra/qt5-webengine/PKGBUILD index 95377ef06..637792754 100644 --- a/extra/qt5-webengine/PKGBUILD +++ b/extra/qt5-webengine/PKGBUILD @@ -3,6 +3,7 @@ # ALARM: Kevin Mihelich # - patch for chromium GN +# - patch for bundled gn buildarch=12 highmem=1 @@ -24,12 +25,14 @@ source=("http://download.qt.io/official_releases/qt/${pkgver%.*}/${_qtver}/submo qtwebengine-harmony.patch qtbug-71370.patch::"http://code.qt.io/cgit/qt/qtwebengine.git/patch/?id=20238f2c" qtbug-69605.patch::"http://code.qt.io/cgit/qt/qtwebengine.git/patch/?id=721cd2d2" - 0001-ARM-toolchain-fixes.patch) + 0001-ARM-toolchain-fixes.patch + 0001-Add-ARM-headers-back.patch) sha256sums=('bd581e390a30e0f74d41b0e3334b3cf612dd4af23de36a3bf5931d5b4453687c' 'feca54ab09ac0fc9d0626770a6b899a6ac5a12173c7d0c1005bc3964ec83e7b3' '58aaec357311fcf72b1d94c40f5159b84c835bbf41fcf9a0977368c99bea70f4' '8f44545a6acd1bc58c7ddd8ff369a818102b6a1fecd132eb2508b18fd1433d8b' - '8202b09a1caa82538a2eacd79b62b61d8661c65cdfb275560d231aa31a362b12') + '8202b09a1caa82538a2eacd79b62b61d8661c65cdfb275560d231aa31a362b12' + '7fbafe97a1e6b607dbd9325f426217fd7051d4d6c8dc33df1cc388f416007c4d') prepare() { mkdir -p build @@ -49,6 +52,7 @@ prepare() { cd src/3rdparty patch -p1 -i ${srcdir}/0001-ARM-toolchain-fixes.patch + patch -p1 -d gn -i ${srcdir}/0001-Add-ARM-headers-back.patch } build() {