@shopify/react-native-skia 0.1.158 → 0.1.160

package/cpp/skia/include/private/SkHalf.h

@@ -9,7 +9,7 @@
 #define SkHalf_DEFINED
 
 #include "include/core/SkTypes.h"
-#include "include/private/SkNx.h"
+#include "include/private/SkVx.h"
 
 // 16-bit floating point value
 // format is 1 bit sign, 5 bits exponent, 10 bits mantissa
@@ -28,58 +28,11 @@ SkHalf SkFloatToHalf(float f);
 // Convert between half and single precision floating point,
 // assuming inputs and outputs are both finite, and may
 // flush values which would be denormal half floats to zero.
-static inline Sk4f SkHalfToFloat_finite_ftz(uint64_t);
-static inline Sk4h SkFloatToHalf_finite_ftz(const Sk4f&);
-
-// ~~~~~~~~~~~ impl ~~~~~~~~~~~~~~ //
-
-// Like the serial versions in SkHalf.cpp, these are based on
-// https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
-
-// GCC 4.9 lacks the intrinsics to use ARMv8 f16<->f32 instructions, so we use inline assembly.
-
-static inline Sk4f SkHalfToFloat_finite_ftz(uint64_t rgba) {
-    Sk4h hs = Sk4h::Load(&rgba);
-#if !defined(SKNX_NO_SIMD) && defined(SK_CPU_ARM64)
-    float32x4_t fs;
-    asm ("fcvtl %[fs].4s, %[hs].4h   \n"   // vcvt_f32_f16(...)
-        : [fs] "=w" (fs)                   // =w: write-only NEON register
-        : [hs] "w" (hs.fVec));             //  w: read-only NEON register
-    return fs;
-#else
-    Sk4i bits     = SkNx_cast<int>(hs),  // Expand to 32 bit.
-         sign     = bits & 0x00008000,   // Save the sign bit for later...
-         positive = bits ^ sign,         // ...but strip it off for now.
-         is_norm  = 0x03ff < positive;   // Exponent > 0?
-
-    // For normal half floats, extend the mantissa by 13 zero bits,
-    // then adjust the exponent from 15 bias to 127 bias.
-    Sk4i norm = (positive << 13) + ((127 - 15) << 23);
-
-    Sk4i merged = (sign << 16) | (norm & is_norm);
-    return Sk4f::Load(&merged);
-#endif
+static inline skvx::float4 SkHalfToFloat_finite_ftz(uint64_t rgba) {
+    return skvx::from_half(skvx::half4::Load(&rgba));
 }
-
-static inline Sk4h SkFloatToHalf_finite_ftz(const Sk4f& fs) {
-#if !defined(SKNX_NO_SIMD) && defined(SK_CPU_ARM64)
-    float32x4_t vec = fs.fVec;
-    asm ("fcvtn %[vec].4h, %[vec].4s  \n"   // vcvt_f16_f32(vec)
-        : [vec] "+w" (vec));                // +w: read-write NEON register
-    return vreinterpret_u16_f32(vget_low_f32(vec));
-#else
-    Sk4i bits         = Sk4i::Load(&fs),
-         sign         = bits & 0x80000000,      // Save the sign bit for later...
-         positive     = bits ^ sign,            // ...but strip it off for now.
-         will_be_norm = 0x387fdfff < positive;  // greater than largest denorm half?
-
-    // For normal half floats, adjust the exponent from 127 bias to 15 bias,
-    // then drop the bottom 13 mantissa bits.
-    Sk4i norm = (positive - ((127 - 15) << 23)) >> 13;
-
-    Sk4i merged = (sign >> 16) | (will_be_norm & norm);
-    return SkNx_cast<uint16_t>(merged);
-#endif
+static inline skvx::half4 SkFloatToHalf_finite_ftz(const skvx::float4& c) {
+    return skvx::to_half(c);
 }
 
 #endif

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

@@ -30,7 +30,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// Can be used to bracket data types that must be dense, e.g. hash keys.
+// Can be used to bracket data types that must be dense/packed, e.g. hash keys.
 #if defined(__clang__)  // This should work on GCC too, but GCC diagnostic pop didn't seem to work!
     #define SK_BEGIN_REQUIRE_DENSE _Pragma("GCC diagnostic push") \
                                    _Pragma("GCC diagnostic error \"-Wpadded\"")

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

@@ -78,6 +78,10 @@ SK_API extern void* sk_calloc_throw(size_t count, size_t elemSize);
 SK_API extern void* sk_malloc_throw(size_t count, size_t elemSize);
 SK_API extern void* sk_realloc_throw(void* buffer, size_t count, size_t elemSize);
 
+// Returns the true usable size provided by the underlying allocator, or 0 if
+// querying the allocation size is not supported.
+SK_API extern size_t sk_malloc_usable_size(void* buffer);
+
 /**
  *  These variants return nullptr on failure
  */

package/cpp/skia/include/private/SkPathRef.h

@@ -283,9 +283,9 @@ public:
     static void Rewind(sk_sp<SkPathRef>* pathRef);
 
     ~SkPathRef();
-    int countPoints() const { return fPoints.count(); }
-    int countVerbs() const { return fVerbs.count(); }
-    int countWeights() const { return fConicWeights.count(); }
+    int countPoints() const { return fPoints.size(); }
+    int countVerbs() const { return fVerbs.size(); }
+    int countWeights() const { return fConicWeights.size(); }
 
     size_t approximateBytesUsed() const;
 
@@ -397,8 +397,8 @@ private:
     /** Makes additional room but does not change the counts or change the genID */
     void incReserve(int additionalVerbs, int additionalPoints) {
         SkDEBUGCODE(this->validate();)
-        fPoints.setReserve(fPoints.count() + additionalPoints);
-        fVerbs.setReserve(fVerbs.count() + additionalVerbs);
+        fPoints.reserve(fPoints.size() + additionalPoints);
+        fVerbs.reserve(fVerbs.size() + additionalVerbs);
         SkDEBUGCODE(this->validate();)
     }
 
@@ -415,11 +415,11 @@ private:
         fIsOval = false;
         fIsRRect = false;
 
-        fPoints.setReserve(pointCount + reservePoints);
-        fPoints.setCount(pointCount);
-        fVerbs.setReserve(verbCount + reserveVerbs);
-        fVerbs.setCount(verbCount);
-        fConicWeights.setCount(conicCount);
+        fPoints.reserve(pointCount + reservePoints);
+        fPoints.resize(pointCount);
+        fVerbs.reserve(verbCount + reserveVerbs);
+        fVerbs.resize(verbCount);
+        fConicWeights.resize(conicCount);
         SkDEBUGCODE(this->validate();)
     }
 

package/cpp/skia/include/private/SkSLModifiers.h

@@ -9,13 +9,15 @@
 #define SKSL_MODIFIERS
 
 #include "include/private/SkSLLayout.h"
-#include "include/sksl/SkSLPosition.h"
 
-#include <vector>
+#include <cstddef>
+#include <memory>
+#include <string>
 
 namespace SkSL {
 
 class Context;
+class Position;
 
 /**
  * A set of modifier keywords (in, out, uniform, etc.) appearing before a declaration.
@@ -44,11 +46,17 @@ struct Modifiers {
         kHighp_Flag          = 1 <<  6,
         kMediump_Flag        = 1 <<  7,
         kLowp_Flag           = 1 <<  8,
+        kReadOnly_Flag       = 1 <<  9,
+        kWriteOnly_Flag      = 1 << 10,
+        kBuffer_Flag         = 1 << 11,
+        // We use the Metal name for this one (corresponds to the GLSL 'shared' modifier)
+        kThreadgroup_Flag    = 1 << 12,
         // SkSL extensions, not present in GLSL
-        kES3_Flag            = 1 <<  9,
-        kHasSideEffects_Flag = 1 <<  10,
-        kInline_Flag         = 1 <<  11,
-        kNoInline_Flag       = 1 <<  12,
+        kExport_Flag         = 1 << 13,
+        kES3_Flag            = 1 << 14,
+        kPure_Flag           = 1 << 15,
+        kInline_Flag         = 1 << 16,
+        kNoInline_Flag       = 1 << 17,
     };
 
     Modifiers()
@@ -60,49 +68,75 @@ struct Modifiers {
     , fFlags(flags) {}
 
     std::string description() const {
-        std::string result = fLayout.description();
+        return fLayout.description() + DescribeFlags(fFlags) + " ";
+    }
 
+    static std::string DescribeFlags(int flags) {
         // SkSL extensions
-        if (fFlags & kES3_Flag) {
+        std::string result;
+        if (flags & kExport_Flag) {
+            result += "$export ";
+        }
+        if (flags & kES3_Flag) {
             result += "$es3 ";
         }
-        if (fFlags & kHasSideEffects_Flag) {
-            result += "sk_has_side_effects ";
+        if (flags & kPure_Flag) {
+            result += "$pure ";
+        }
+        if (flags & kInline_Flag) {
+            result += "inline ";
         }
-        if (fFlags & kNoInline_Flag) {
+        if (flags & kNoInline_Flag) {
             result += "noinline ";
         }
 
         // Real GLSL qualifiers (must be specified in order in GLSL 4.1 and below)
-        if (fFlags & kFlat_Flag) {
+        if (flags & kFlat_Flag) {
             result += "flat ";
         }
-        if (fFlags & kNoPerspective_Flag) {
+        if (flags & kNoPerspective_Flag) {
             result += "noperspective ";
         }
-        if (fFlags & kConst_Flag) {
+        if (flags & kConst_Flag) {
             result += "const ";
         }
-        if (fFlags & kUniform_Flag) {
+        if (flags & kUniform_Flag) {
             result += "uniform ";
         }
-        if ((fFlags & kIn_Flag) && (fFlags & kOut_Flag)) {
+        if ((flags & kIn_Flag) && (flags & kOut_Flag)) {
             result += "inout ";
-        } else if (fFlags & kIn_Flag) {
+        } else if (flags & kIn_Flag) {
             result += "in ";
-        } else if (fFlags & kOut_Flag) {
+        } else if (flags & kOut_Flag) {
             result += "out ";
         }
-        if (fFlags & kHighp_Flag) {
+        if (flags & kHighp_Flag) {
             result += "highp ";
         }
-        if (fFlags & kMediump_Flag) {
+        if (flags & kMediump_Flag) {
             result += "mediump ";
         }
-        if (fFlags & kLowp_Flag) {
+        if (flags & kLowp_Flag) {
             result += "lowp ";
         }
+        if (flags & kReadOnly_Flag) {
+            result += "readonly ";
+        }
+        if (flags & kWriteOnly_Flag) {
+            result += "writeonly ";
+        }
+        if (flags & kBuffer_Flag) {
+            result += "buffer ";
+        }
+
+        // We're using a non-GLSL name for this one; the GLSL equivalent is "shared"
+        if (flags & kThreadgroup_Flag) {
+            result += "threadgroup ";
+        }
 
+        if (!result.empty()) {
+            result.pop_back();
+        }
         return result;
     }
 
@@ -118,8 +152,10 @@ struct Modifiers {
      * Verifies that only permitted modifiers and layout flags are included. Reports errors and
      * returns false in the event of a violation.
      */
-    bool checkPermitted(const Context& context, Position pos, int permittedModifierFlags,
-            int permittedLayoutFlags) const;
+    bool checkPermitted(const Context& context,
+                        Position pos,
+                        int permittedModifierFlags,
+                        int permittedLayoutFlags) const;
 
     Layout fLayout;
     int fFlags;

package/cpp/skia/include/private/SkSLProgramKind.h

@@ -18,6 +18,7 @@ namespace SkSL {
 enum class ProgramKind : int8_t {
     kFragment,
     kVertex,
+    kCompute,
     kGraphiteFragment,
     kGraphiteVertex,
     kRuntimeColorFilter,    // Runtime effect only suitable as SkColorFilter

package/cpp/skia/include/private/SkSLSymbol.h

@@ -23,7 +23,6 @@ public:
         kField,
         kFunctionDeclaration,
         kType,
-        kUnresolvedFunction,
         kVariable,
 
         kFirst = kExternal,
@@ -52,6 +51,13 @@ public:
         return fName;
     }
 
+    /**
+     *  Don't call this directly--use SymbolTable::renameSymbol instead!
+     */
+    void setName(std::string_view newName) {
+        fName = newName;
+    }
+
     /**
      *  Use is<T> to check the type of a symbol.
      *  e.g. replace `sym.kind() == Symbol::Kind::kVariable` with `sym.is<Variable>()`.
@@ -81,8 +87,6 @@ private:
     const Type* fType;
 
     using INHERITED = IRNode;
-
-    friend class Type;
 };
 
 }  // namespace SkSL

package/cpp/skia/include/private/SkStringView.h

@@ -42,6 +42,10 @@ inline constexpr bool contains(std::string_view str, std::string_view needle) {
     return str.find(needle) != std::string_view::npos;
 }
 
+inline constexpr bool contains(std::string_view str, std::string_view::value_type c) {
+    return str.find(c) != std::string_view::npos;
+}
+
 }  // namespace skstd
 
 #endif

package/cpp/skia/include/private/SkTArray.h

@@ -33,7 +33,7 @@
     Modern implementations of std::vector<T> will generally provide similar performance
     characteristics when used with appropriate care. Consider using std::vector<T> in new code.
 */
-template <typename T, bool MEM_MOVE = false> class SkTArray {
+template <typename T, bool MEM_MOVE = sk_is_trivially_relocatable<T>::value> class SkTArray {
 private:
     enum ReallocType { kExactFit, kGrowing, kShrinking };
 
@@ -461,6 +461,18 @@ protected:
     }
 
 private:
+    // We disable Control-Flow Integrity sanitization (go/cfi) when casting item-array buffers.
+    // CFI flags this code as dangerous because we are casting `buffer` to a T* while the buffer's
+    // contents might still be uninitialized memory. When T has a vtable, this is especially risky
+    // because we could hypothetically access a virtual method on fItemArray and jump to an
+    // unpredictable location in memory. Of course, SkTArray won't actually use fItemArray in this
+    // way, and we don't want to construct a T before the user requests one. There's no real risk
+    // here, so disable CFI when doing these casts.
+    SK_ATTRIBUTE(no_sanitize("cfi"))
+    static T* TCast(void* buffer) {
+        return (T*)buffer;
+    }
+
     void init(int count) {
         fCount = SkToU32(count);
         if (!count) {
@@ -468,7 +480,7 @@ private:
             fItemArray = nullptr;
         } else {
             fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount));
-            fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T));
+            fItemArray = TCast(sk_malloc_throw((size_t)fAllocCount, sizeof(T)));
         }
         fOwnMemory = true;
         fReserved = false;
@@ -483,11 +495,11 @@ private:
         fReserved = false;
         if (count > preallocCount) {
             fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount));
-            fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T));
+            fItemArray = TCast(sk_malloc_throw(fAllocCount, sizeof(T)));
             fOwnMemory = true;
         } else {
             fAllocCount = SkToU32(preallocCount);
-            fItemArray = (T*)preallocStorage;
+            fItemArray = TCast(preallocStorage);
             fOwnMemory = false;
         }
     }
@@ -506,7 +518,9 @@ private:
     }
 
     template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(int dst, int src) {
-        memcpy(&fItemArray[dst], &fItemArray[src], sizeof(T));
+        memcpy(static_cast<void*>(&fItemArray[dst]),
+               static_cast<void*>(&fItemArray[src]),
+               sizeof(T));
     }
     template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) {
         sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T));
@@ -567,7 +581,7 @@ private:
 
         fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount));
         SkASSERT(fAllocCount >= newCount);
-        T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T));
+        T* newItemArray = TCast(sk_malloc_throw((size_t)fAllocCount, sizeof(T)));
         this->move(newItemArray);
         if (fOwnMemory) {
             sk_free(fItemArray);
@@ -593,7 +607,7 @@ template<typename T, bool MEM_MOVE> constexpr int SkTArray<T, MEM_MOVE>::kMinHea
 /**
  * Subclass of SkTArray that contains a preallocated memory block for the array.
  */
-template <int N, typename T, bool MEM_MOVE = false>
+template <int N, typename T, bool MEM_MOVE = sk_is_trivially_relocatable<T>::value>
 class SkSTArray : private SkAlignedSTStorage<N,T>, public SkTArray<T, MEM_MOVE> {
 private:
     using STORAGE   = SkAlignedSTStorage<N,T>;