Hello community,
here is the log from the commit of package gn for openSUSE:Factory checked in at 2018-11-12 09:42:20
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/gn (Old)
and /work/SRC/openSUSE:Factory/.gn.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "gn"
Mon Nov 12 09:42:20 2018 rev:5 rq:647641 version:0.1479
Changes:
--------
--- /work/SRC/openSUSE:Factory/gn/gn.changes 2018-10-31 13:21:56.687029140 +0100
+++ /work/SRC/openSUSE:Factory/.gn.new/gn.changes 2018-11-12 09:42:22.153107615 +0100
@@ -1,0 +2,6 @@
+Fri Nov 9 08:44:22 UTC 2018 - Guillaume GARDET
+
+- Add patch to add missing files to fix armv7 build:
+ * gn-add_missing_arm_files.patch
+
+-------------------------------------------------------------------
New:
----
gn-add_missing_arm_files.patch
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ gn.spec ++++++
--- /var/tmp/diff_new_pack.6KpbEp/_old 2018-11-12 09:42:23.993104795 +0100
+++ /var/tmp/diff_new_pack.6KpbEp/_new 2018-11-12 09:42:23.993104795 +0100
@@ -25,6 +25,8 @@
URL: https://gn.googlesource.com/
Source: https://dev.gentoo.org/~floppym/dist/%{name}-%{version}.tar.gz
Patch0: gn-flags.patch
+# PATCH-FIX-UPSTREAM: https://bugs.chromium.org/p/gn/issues/detail?id=6
+Patch1: gn-add_missing_arm_files.patch
BuildRequires: gcc-c++
%if 0%{suse_version} < 1500
BuildRequires: gcc7-c++
@@ -38,6 +40,7 @@
%prep
%setup -q
%patch0 -p1
+%patch1 -p1
%build
export CC=gcc
++++++ gn-add_missing_arm_files.patch ++++++
diff -purN gn-0.1479.orig/base/numerics/safe_conversions_arm_impl.h gn-0.1479/base/numerics/safe_conversions_arm_impl.h
--- gn-0.1479.orig/base/numerics/safe_conversions_arm_impl.h 1970-01-01 01:00:00.000000000 +0100
+++ gn-0.1479/base/numerics/safe_conversions_arm_impl.h 2018-11-09 09:41:59.000000000 +0100
@@ -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 <cassert>
+#include <limits>
+#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<Src>::value && std::is_integral<Dst>::value &&
+ std::is_integral<Src>::value &&
+ IntegerBitsPlusSign<Src>::value <= IntegerBitsPlusSign::value &&
+ IntegerBitsPlusSign<Dst>::value <= IntegerBitsPlusSign::value &&
+ !IsTypeInRangeForNumericType::value;
+
+ __attribute__((always_inline)) static Dst Do(Src value) {
+ int32_t src = value;
+ typename std::conditional::type result;
+ if (std::is_signed<Dst>::value) {
+ asm("ssat %[dst], %[shift], %[src]"
+ : [dst] "=r"(result)
+ : [src] "r"(src), [shift] "n"(IntegerBitsPlusSign<Dst>::value <= 32
+ ? IntegerBitsPlusSign<Dst>::value
+ : 32));
+ } else {
+ asm("usat %[dst], %[shift], %[src]"
+ : [dst] "=r"(result)
+ : [src] "r"(src), [shift] "n"(IntegerBitsPlusSign<Dst>::value < 32
+ ? IntegerBitsPlusSign<Dst>::value
+ : 31));
+ }
+ return static_cast<Dst>(result);
+ }
+};
+
+} // namespace internal
+} // namespace base
+
+#endif // BASE_NUMERICS_SAFE_CONVERSIONS_ARM_IMPL_H_
diff -purN gn-0.1479.orig/base/numerics/safe_math_arm_impl.h gn-0.1479/base/numerics/safe_math_arm_impl.h
--- gn-0.1479.orig/base/numerics/safe_math_arm_impl.h 1970-01-01 01:00:00.000000000 +0100
+++ gn-0.1479/base/numerics/safe_math_arm_impl.h 2018-11-09 09:41:59.000000000 +0100
@@ -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 <cassert>
+#include <limits>
+#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 <typename V>
+ __attribute__((always_inline)) static bool Do(T x, U y, V* result) {
+ using Promotion = typename FastIntegerArithmeticPromotion::type;
+ Promotion presult;
+
+ presult = static_cast<Promotion>(x) * static_cast<Promotion>(y);
+ *result = static_cast<V>(presult);
+ return IsValueInRangeForNumericType<V>(presult);
+ }
+};
+
+template
+struct ClampedAddFastAsmOp {
+ static const bool is_supported =
+ BigEnoughPromotion::is_contained &&
+ IsTypeInRangeForNumericType<
+ int32_t,
+ typename BigEnoughPromotion::type>::value;
+
+ template <typename V>
+ __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<V>(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<V>(result);
+ }
+};
+
+template
+struct ClampedSubFastAsmOp {
+ static const bool is_supported =
+ BigEnoughPromotion::is_contained &&
+ IsTypeInRangeForNumericType<
+ int32_t,
+ typename BigEnoughPromotion::type>::value;
+
+ template <typename V>
+ __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<V>(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<V>(result);
+ }
+};
+
+template
+struct ClampedMulFastAsmOp {
+ static const bool is_supported = CheckedMulFastAsmOp::is_supported;
+
+ template <typename V>
+ __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<V>(IsValueNegative(x) ^ IsValueNegative(y));
+ }
+
+ assert((FastIntegerArithmeticPromotion::is_contained));
+ using Promotion = typename FastIntegerArithmeticPromotion::type;
+ return saturated_cast<V>(static_cast<Promotion>(x) *
+ static_cast<Promotion>(y));
+ }
+};
+
+} // namespace internal
+} // namespace base
+
+#endif // BASE_NUMERICS_SAFE_MATH_ARM_IMPL_H_
