@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/include/private/base/SkASAN.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkASAN_DEFINED
+#define SkASAN_DEFINED
+
+#include <cstddef>
+
+#ifdef __SANITIZE_ADDRESS__
+    #define SK_SANITIZE_ADDRESS 1
+#endif
+#if !defined(SK_SANITIZE_ADDRESS) && defined(__has_feature)
+    #if __has_feature(address_sanitizer)
+        #define SK_SANITIZE_ADDRESS 1
+    #endif
+#endif
+
+// Typically declared in LLVM's asan_interface.h.
+#ifdef SK_SANITIZE_ADDRESS
+extern "C" {
+    void __asan_poison_memory_region(void const volatile *addr, size_t size);
+    void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+    int __asan_address_is_poisoned(void const volatile *addr);
+}
+#endif
+
+// Code that implements bespoke allocation arenas can poison the entire arena on creation, then
+// unpoison chunks of arena memory as they are parceled out. Consider leaving gaps between blocks
+// to detect buffer overrun.
+static inline void sk_asan_poison_memory_region([[maybe_unused]] void const volatile* addr,
+                                                [[maybe_unused]] size_t size) {
+#ifdef SK_SANITIZE_ADDRESS
+    __asan_poison_memory_region(addr, size);
+#endif
+}
+
+static inline void sk_asan_unpoison_memory_region([[maybe_unused]] void const volatile* addr,
+                                                  [[maybe_unused]] size_t size) {
+#ifdef SK_SANITIZE_ADDRESS
+    __asan_unpoison_memory_region(addr, size);
+#endif
+}
+
+static inline int sk_asan_address_is_poisoned([[maybe_unused]] void const volatile* addr) {
+#ifdef SK_SANITIZE_ADDRESS
+    return __asan_address_is_poisoned(addr);
+#else
+    return 0;
+#endif
+}
+
+#endif  // SkASAN_DEFINED

package/cpp/skia/include/private/base/SkAlign.h

@@ -15,15 +15,20 @@
 template <typename T> static constexpr T SkAlign2(T x) { return (x + 1) >> 1 << 1; }
 template <typename T> static constexpr T SkAlign4(T x) { return (x + 3) >> 2 << 2; }
 template <typename T> static constexpr T SkAlign8(T x) { return (x + 7) >> 3 << 3; }
+template <typename T> static constexpr T SkAlign16(T x) { return (x + 15) >> 4 << 4; }
 
 template <typename T> static constexpr bool SkIsAlign2(T x) { return 0 == (x & 1); }
 template <typename T> static constexpr bool SkIsAlign4(T x) { return 0 == (x & 3); }
 template <typename T> static constexpr bool SkIsAlign8(T x) { return 0 == (x & 7); }
+template <typename T> static constexpr bool SkIsAlign16(T x) { return 0 == (x & 15); }
+
 
 template <typename T> static constexpr T SkAlignPtr(T x) {
+    static_assert(sizeof(void*) == 4 || sizeof(void*) == 8);
     return sizeof(void*) == 8 ? SkAlign8(x) : SkAlign4(x);
 }
 template <typename T> static constexpr bool SkIsAlignPtr(T x) {
+    static_assert(sizeof(void*) == 4 || sizeof(void*) == 8);
     return sizeof(void*) == 8 ? SkIsAlign8(x) : SkIsAlign4(x);
 }
 

package/cpp/skia/include/private/base/SkContainers.h

@@ -5,6 +5,7 @@
 #define SkContainers_DEFINED
 
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAlign.h"
 #include "include/private/base/SkSpan_impl.h"
 
 #include <cstddef>
@@ -20,10 +21,17 @@ public:
     // The bytes allocated are freed using sk_free().
     SkSpan<std::byte> allocate(int capacity, double growthFactor = 1.0);
 
+    // Rounds a requested capacity up towards `kCapacityMultiple` in a constexpr-friendly fashion.
+    template <typename T>
+    static constexpr size_t RoundUp(size_t capacity) {
+        return SkAlignTo(capacity * sizeof(T), kCapacityMultiple) / sizeof(T);
+    }
+
 private:
     friend struct SkContainerAllocatorTestingPeer;
-    // All capacity counts will be rounded up to kCapacityMultiple.
-    // TODO: this is a constant from the original SkTArray code. This should be checked some how.
+
+    // All capacity counts will be rounded up to kCapacityMultiple. This matches ASAN's shadow
+    // granularity, as well as our typical struct alignment on a 64-bit machine.
     static constexpr int64_t kCapacityMultiple = 8;
 
     // Rounds up capacity to next multiple of kCapacityMultiple and pin to fMaxCapacity.

package/cpp/skia/include/private/base/SkFeatures.h

@@ -65,6 +65,10 @@
   #define SK_CPU_X86 1
 #endif
 
+#if defined(__loongarch__) || defined (__loongarch64)
+  #define SK_CPU_LOONGARCH 1
+#endif
+
 /**
  *  SK_CPU_SSE_LEVEL
  *
@@ -81,7 +85,16 @@
 #define SK_CPU_SSE_LEVEL_AVX2     52
 #define SK_CPU_SSE_LEVEL_SKX      60
 
-// TODO(brianosman,kjlubick) clean up these checks
+/**
+ *  SK_CPU_LSX_LEVEL
+ *
+ *  If defined, SK_CPU_LSX_LEVEL should be set to the highest supported level.
+ *  On non-loongarch CPU this should be undefined.
+ */
+#define SK_CPU_LSX_LEVEL_LSX      70
+#define SK_CPU_LSX_LEVEL_LASX     80
+
+// TODO(kjlubick) clean up these checks
 
 // Are we in GCC/Clang?
 #ifndef SK_CPU_SSE_LEVEL
@@ -107,6 +120,14 @@
     #endif
 #endif
 
+#ifndef SK_CPU_LSX_LEVEL
+    #if defined(__loongarch_asx)
+        #define SK_CPU_LSX_LEVEL    SK_CPU_LSX_LEVEL_LASX
+    #elif defined(__loongarch_sx)
+        #define SK_CPU_LSX_LEVEL    SK_CPU_LSX_LEVEL_LSX
+    #endif
+#endif
+
 // Are we in VisualStudio?
 #ifndef SK_CPU_SSE_LEVEL
     // These checks must be done in descending order to ensure we set the highest

package/cpp/skia/include/private/base/SkFloatingPoint.h

@@ -9,36 +9,17 @@
 #define SkFloatingPoint_DEFINED
 
 #include "include/private/base/SkAttributes.h"
-#include "include/private/base/SkFloatBits.h"
 #include "include/private/base/SkMath.h"
 
 #include <cmath>
 #include <cstdint>
-#include <cstring>
 #include <limits>
+#include <type_traits>
 
 inline constexpr float SK_FloatSqrt2 = 1.41421356f;
 inline constexpr float SK_FloatPI    = 3.14159265f;
 inline constexpr double SK_DoublePI  = 3.14159265358979323846264338327950288;
 
-static inline float sk_float_sqrt(float x) { return std::sqrt(x); }
-static inline float sk_float_sin(float x) { return std::sin(x); }
-static inline float sk_float_cos(float x) { return std::cos(x); }
-static inline float sk_float_tan(float x) { return std::tan(x); }
-static inline float sk_float_floor(float x) { return std::floor(x); }
-static inline float sk_float_ceil(float x) { return std::ceil(x); }
-static inline float sk_float_trunc(float x) { return std::trunc(x); }
-static inline float sk_float_acos(float x) { return std::acos(x); }
-static inline float sk_float_asin(float x) { return std::asin(x); }
-static inline float sk_float_atan2(float y, float x) { return std::atan2(y,x); }
-static inline float sk_float_abs(float x) { return std::fabs(x); }
-static inline float sk_float_copysign(float x, float y) { return std::copysign(x, y); }
-static inline float sk_float_mod(float x, float y) { return std::fmod(x,y); }
-static inline float sk_float_pow(float x, float y) { return std::pow(x, y); }
-static inline float sk_float_exp(float x) { return std::exp(x); }
-static inline float sk_float_log(float x) { return std::log(x); }
-static inline float sk_float_log2(float x) { return std::log2(x); }
-
 static constexpr int sk_float_sgn(float x) {
     return (0.0f < x) - (x < 0.0f);
 }
@@ -56,30 +37,34 @@ static constexpr float sk_float_radians_to_degrees(float radians) {
 // as floatf(x + .5f), they would be 1 higher than expected.
 #define sk_float_round(x) (float)sk_double_round((double)(x))
 
-static inline bool sk_float_isfinite(float x) {
-    return SkFloatBits_IsFinite(SkFloat2Bits(x));
+template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+static inline constexpr bool SkIsNaN(T x) {
+    return x != x;
 }
 
-static inline bool sk_floats_are_finite(float a, float b) {
-    return sk_float_isfinite(a) && sk_float_isfinite(b);
+// Subtracting a value from itself will result in zero, except for NAN or ±Inf, which make NAN.
+// Multiplying a group of values against zero will result in zero for each product, except for
+// NAN or ±Inf, which will result in NAN and continue resulting in NAN for the rest of the elements.
+// This generates better code than `std::isfinite` when building with clang-cl (April 2024).
+template <typename T, typename... Pack, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+static inline bool SkIsFinite(T x, Pack... values) {
+    T prod = x - x;
+    prod = (prod * ... * values);
+    // At this point, `prod` will either be NaN or 0.
+    return prod == prod;
 }
 
-static inline bool sk_floats_are_finite(const float array[], int count) {
-    float prod = 0;
-    for (int i = 0; i < count; ++i) {
+template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+static inline bool SkIsFinite(const T array[], int count) {
+    T x = array[0];
+    T prod = x - x;
+    for (int i = 1; i < count; ++i) {
         prod *= array[i];
     }
-    // At this point, prod will either be NaN or 0
-    return prod == 0;   // if prod is NaN, this check will return false
-}
-
-static inline bool sk_float_isinf(float x) {
-    return SkFloatBits_IsInf(SkFloat2Bits(x));
+    // At this point, `prod` will either be NaN or 0.
+    return prod == prod;
 }
 
-static constexpr bool sk_float_isnan(float x) { return x != x; }
-static constexpr bool sk_double_isnan(double x) { return x != x; }
-
 inline constexpr int SK_MaxS32FitsInFloat = 2147483520;
 inline constexpr int SK_MinS32FitsInFloat = -SK_MaxS32FitsInFloat;
 
@@ -87,10 +72,22 @@ inline constexpr int SK_MinS32FitsInFloat = -SK_MaxS32FitsInFloat;
 inline constexpr int64_t SK_MaxS64FitsInFloat = SK_MaxS64 >> (63-24) << (63-24);
 inline constexpr int64_t SK_MinS64FitsInFloat = -SK_MaxS64FitsInFloat;
 
+// sk_[float|double]_saturate2int are written to return their maximum values when passed NaN.
+// MSVC 19.38+ has a bug with this implementation, leading to incorrect results:
+// https://developercommunity.visualstudio.com/t/Optimizer-incorrectly-handles-NaN-floati/10654403
+//
+// We inject an explicit NaN test on MSVC to work around the problem.
+#if defined(_MSC_VER) && !defined(__clang__)
+    #define SK_CHECK_NAN(resultVal) if (SkIsNaN(x)) { return resultVal; }
+#else
+    #define SK_CHECK_NAN(resultVal)
+#endif
+
 /**
  *  Return the closest int for the given float. Returns SK_MaxS32FitsInFloat for NaN.
  */
 static constexpr int sk_float_saturate2int(float x) {
+    SK_CHECK_NAN(SK_MaxS32FitsInFloat)
     x = x < SK_MaxS32FitsInFloat ? x : SK_MaxS32FitsInFloat;
     x = x > SK_MinS32FitsInFloat ? x : SK_MinS32FitsInFloat;
     return (int)x;
@@ -100,6 +97,7 @@ static constexpr int sk_float_saturate2int(float x) {
  *  Return the closest int for the given double. Returns SK_MaxS32 for NaN.
  */
 static constexpr int sk_double_saturate2int(double x) {
+    SK_CHECK_NAN(SK_MaxS32)
     x = x < SK_MaxS32 ? x : SK_MaxS32;
     x = x > SK_MinS32 ? x : SK_MinS32;
     return (int)x;
@@ -109,25 +107,26 @@ static constexpr int sk_double_saturate2int(double x) {
  *  Return the closest int64_t for the given float. Returns SK_MaxS64FitsInFloat for NaN.
  */
 static constexpr int64_t sk_float_saturate2int64(float x) {
+    SK_CHECK_NAN(SK_MaxS64FitsInFloat)
     x = x < SK_MaxS64FitsInFloat ? x : SK_MaxS64FitsInFloat;
     x = x > SK_MinS64FitsInFloat ? x : SK_MinS64FitsInFloat;
     return (int64_t)x;
 }
 
-#define sk_float_floor2int(x)   sk_float_saturate2int(sk_float_floor(x))
+#undef SK_CHECK_NAN
+
+#define sk_float_floor2int(x)   sk_float_saturate2int(std::floor(x))
 #define sk_float_round2int(x)   sk_float_saturate2int(sk_float_round(x))
-#define sk_float_ceil2int(x)    sk_float_saturate2int(sk_float_ceil(x))
+#define sk_float_ceil2int(x)    sk_float_saturate2int(std::ceil(x))
 
-#define sk_float_floor2int_no_saturate(x)   (int)sk_float_floor(x)
-#define sk_float_round2int_no_saturate(x)   (int)sk_float_round(x)
-#define sk_float_ceil2int_no_saturate(x)    (int)sk_float_ceil(x)
+#define sk_float_floor2int_no_saturate(x)   ((int)std::floor(x))
+#define sk_float_round2int_no_saturate(x)   ((int)sk_float_round(x))
+#define sk_float_ceil2int_no_saturate(x)    ((int)std::ceil(x))
 
-#define sk_double_floor(x)          floor(x)
-#define sk_double_round(x)          floor((x) + 0.5)
-#define sk_double_ceil(x)           ceil(x)
-#define sk_double_floor2int(x)      (int)sk_double_floor(x)
-#define sk_double_round2int(x)      (int)sk_double_round(x)
-#define sk_double_ceil2int(x)       (int)sk_double_ceil(x)
+#define sk_double_round(x)          (std::floor((x) + 0.5))
+#define sk_double_floor2int(x)      ((int)std::floor(x))
+#define sk_double_round2int(x)      ((int)std::round(x))
+#define sk_double_ceil2int(x)       ((int)std::ceil(x))
 
 // Cast double to float, ignoring any warning about too-large finite values being cast to float.
 // Clang thinks this is undefined, but it's actually implementation defined to return either
@@ -149,23 +148,15 @@ static constexpr float sk_float_midpoint(float a, float b) {
     return static_cast<float>(0.5 * (static_cast<double>(a) + b));
 }
 
-// Returns false if any of the floats are outside the range [0...1].
-// Returns true if count is 0.
-bool sk_floats_are_unit(const float array[], size_t count);
-
-static inline float sk_float_rsqrt_portable(float x) { return 1.0f / sk_float_sqrt(x); }
-static inline float sk_float_rsqrt         (float x) { return 1.0f / sk_float_sqrt(x); }
-
-// The number of significant digits to print.
-inline constexpr int SK_FLT_DECIMAL_DIG = std::numeric_limits<float>::max_digits10;
+static inline float sk_float_rsqrt_portable(float x) { return 1.0f / std::sqrt(x); }
+static inline float sk_float_rsqrt         (float x) { return 1.0f / std::sqrt(x); }
 
 // IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not,
 // so we have a helper that suppresses the possible undefined-behavior warnings.
 #ifdef SK_BUILD_FOR_WIN
-#pragma warning( push )
-#pragma warning( disable : 4723)
+#pragma warning(push)
+#pragma warning(disable : 4723)
 #endif
-// Your function
 SK_NO_SANITIZE("float-divide-by-zero")
 static constexpr float sk_ieee_float_divide(float numer, float denom) {
     return numer / denom;
@@ -179,11 +170,6 @@ static constexpr double sk_ieee_double_divide(double numer, double denom) {
 #pragma warning( pop )
 #endif
 
-// Return a*b + c.
-static inline float sk_fmaf(float a, float b, float c) {
-    return std::fma(a, b, c);
-}
-
 // Returns true iff the provided number is within a small epsilon of 0.
 bool sk_double_nearly_zero(double a);
 
@@ -193,6 +179,6 @@ bool sk_double_nearly_zero(double a);
 // * infinity and any other number - returns false.
 //
 // ulp is an initialism for Units in the Last Place.
-bool sk_doubles_nearly_equal_ulps(double a, double b, uint8_t maxUlpsDiff=16);
+bool sk_doubles_nearly_equal_ulps(double a, double b, uint8_t maxUlpsDiff = 16);
 
 #endif

package/cpp/skia/include/private/base/SkMacros.h

@@ -7,6 +7,8 @@
 #ifndef SkMacros_DEFINED
 #define SkMacros_DEFINED
 
+#include "include/private/base/SkTo.h" // IWYU pragma: keep
+
 /*
  *  Usage:  SK_MACRO_CONCAT(a, b)   to construct the symbol ab
  *
@@ -91,4 +93,69 @@ extern "C" {
     friend X operator &(X a, X b); \
     friend X& operator &=(X& a, X b);
 
+/**
+ * Wraps a C++11 enum that we use as a bitfield, and enables a limited amount of
+ * masking with type safety. Instantiated with the ~ operator.
+ */
+template<typename TFlags> class SkTFlagsMask {
+public:
+    constexpr explicit SkTFlagsMask(TFlags value) : SkTFlagsMask(static_cast<int>(value)) {}
+    constexpr explicit SkTFlagsMask(int value) : fValue(value) {}
+    constexpr int value() const { return fValue; }
+private:
+    const int fValue;
+};
+
+/**
+ * Defines bitwise operators that make it possible to use an enum class as a
+ * basic bitfield.
+ */
+#define SK_MAKE_BITFIELD_CLASS_OPS(X) \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator~(X a) { \
+        return SkTFlagsMask<X>(~static_cast<int>(a)); \
+    } \
+    [[maybe_unused]] constexpr X operator|(X a, X b) { \
+        return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] inline X& operator|=(X& a, X b) { \
+        return (a = a | b); \
+    } \
+    [[maybe_unused]] constexpr bool operator&(X a, X b) { \
+        return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X> a, SkTFlagsMask<X> b) { \
+        return SkTFlagsMask<X>(a.value() | b.value()); \
+    } \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X> a, X b) { \
+        return SkTFlagsMask<X>(a.value() | static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator|(X a, SkTFlagsMask<X> b) { \
+        return SkTFlagsMask<X>(static_cast<int>(a) | b.value()); \
+    } \
+    [[maybe_unused]] constexpr X operator&(SkTFlagsMask<X> a, SkTFlagsMask<X> b) { \
+        return static_cast<X>(a.value() & b.value()); \
+    } \
+    [[maybe_unused]] constexpr X operator&(SkTFlagsMask<X> a, X b) { \
+        return static_cast<X>(a.value() & static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] constexpr X operator&(X a, SkTFlagsMask<X> b) { \
+        return static_cast<X>(static_cast<int>(a) & b.value()); \
+    } \
+    [[maybe_unused]] inline X& operator&=(X& a, SkTFlagsMask<X> b) { \
+        return (a = a & b); \
+    } \
+
+#define SK_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
+    friend constexpr SkTFlagsMask<X> operator ~(X); \
+    friend constexpr X operator |(X, X); \
+    friend X& operator |=(X&, X); \
+    friend constexpr bool operator &(X, X); \
+    friend constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X>, SkTFlagsMask<X>); \
+    friend constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X>, X); \
+    friend constexpr SkTFlagsMask<X> operator|(X, SkTFlagsMask<X>); \
+    friend constexpr X operator&(SkTFlagsMask<X>, SkTFlagsMask<X>); \
+    friend constexpr X operator&(SkTFlagsMask<X>, X); \
+    friend constexpr X operator&(X, SkTFlagsMask<X>); \
+    friend X& operator &=(X&, SkTFlagsMask<X>)
+
 #endif  // SkMacros_DEFINED

package/cpp/skia/include/private/base/SkMalloc.h

@@ -56,6 +56,14 @@ SK_API extern void* sk_malloc_flags(size_t size, unsigned flags);
  */
 SK_API extern void* sk_realloc_throw(void* buffer, size_t size);
 
+/**
+ *  Return the size of the block of memory allocated in reality for a given pointer. The pointer
+ *  passed must have been allocated using the sk_malloc_* or sk_realloc_* functions. The "size"
+ *  parameter indicates the size originally requested when the memory block was allocated, and
+ *  the value returned by this function must be bigger or equal to it.
+ */
+SK_API extern size_t sk_malloc_size(void* addr, size_t size);
+
 static inline void* sk_malloc_throw(size_t size) {
     return sk_malloc_flags(size, SK_MALLOC_THROW);
 }

package/cpp/skia/include/private/base/SkPoint_impl.h

@@ -9,7 +9,7 @@
 #define SkPoint_DEFINED
 
 #include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSafe32.h"
 
 #include <cmath>
@@ -410,16 +410,7 @@ struct SK_API SkPoint {
         @return  true for values other than infinities and NaN
     */
     bool isFinite() const {
-        float accum = 0;
-        accum *= fX;
-        accum *= fY;
-
-        // accum is either NaN or it is finite (zero).
-        SkASSERT(0 == accum || std::isnan(accum));
-
-        // value==value will be true iff value is not NaN
-        // TODO: is it faster to say !accum or accum==accum?
-        return !std::isnan(accum);
+        return SkIsFinite(fX, fY);
     }
 
     /** Returns true if SkPoint is equivalent to SkPoint constructed from (x, y).