@shopify/react-native-skia 0.1.128 → 0.1.131

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

@@ -61,9 +61,9 @@ struct Layout {
         return result;
     }
 
-    String description() const {
-        String result;
-        auto separator = [firstSeparator = true]() mutable -> String {
+    std::string description() const {
+        std::string result;
+        auto separator = [firstSeparator = true]() mutable -> std::string {
             if (firstSeparator) {
                 firstSeparator = false;
                 return "";
@@ -71,25 +71,26 @@ struct Layout {
                 return ", ";
             }};
         if (fLocation >= 0) {
-            result += separator() + "location = " + to_string(fLocation);
+            result += separator() + "location = " + std::to_string(fLocation);
         }
         if (fOffset >= 0) {
-            result += separator() + "offset = " + to_string(fOffset);
+            result += separator() + "offset = " + std::to_string(fOffset);
         }
         if (fBinding >= 0) {
-            result += separator() + "binding = " + to_string(fBinding);
+            result += separator() + "binding = " + std::to_string(fBinding);
         }
         if (fIndex >= 0) {
-            result += separator() + "index = " + to_string(fIndex);
+            result += separator() + "index = " + std::to_string(fIndex);
         }
         if (fSet >= 0) {
-            result += separator() + "set = " + to_string(fSet);
+            result += separator() + "set = " + std::to_string(fSet);
         }
         if (fBuiltin >= 0) {
-            result += separator() + "builtin = " + to_string(fBuiltin);
+            result += separator() + "builtin = " + std::to_string(fBuiltin);
         }
         if (fInputAttachmentIndex >= 0) {
-            result += separator() + "input_attachment_index = " + to_string(fInputAttachmentIndex);
+            result += separator() + "input_attachment_index = " +
+                      std::to_string(fInputAttachmentIndex);
         }
         if (fFlags & kOriginUpperLeft_Flag) {
             result += separator() + "origin_upper_left";

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

@@ -9,6 +9,7 @@
 #define SKSL_MODIFIERS
 
 #include "include/private/SkSLLayout.h"
+#include "include/sksl/SkSLPosition.h"
 
 #include <vector>
 
@@ -58,8 +59,8 @@ struct Modifiers {
     : fLayout(layout)
     , fFlags(flags) {}
 
-    String description() const {
-        String result = fLayout.description();
+    std::string description() const {
+        std::string result = fLayout.description();
 
         // SkSL extensions
         if (fFlags & kES3_Flag) {
@@ -117,7 +118,7 @@ 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, int line, int permittedModifierFlags,
+    bool checkPermitted(const Context& context, Position pos, int permittedModifierFlags,
             int permittedLayoutFlags) const;
 
     Layout fLayout;

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

@@ -32,8 +32,8 @@ public:
         kLast = kStructDefinition
     };
 
-    ProgramElement(int offset, Kind kind)
-        : INHERITED(offset, (int) kind) {
+    ProgramElement(Position pos, Kind kind)
+        : INHERITED(pos, (int) kind) {
         SkASSERT(kind >= Kind::kFirst && kind <= Kind::kLast);
     }
 

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

@@ -18,11 +18,14 @@ namespace SkSL {
 enum class ProgramKind : int8_t {
     kFragment,
     kVertex,
-    kRuntimeColorFilter,  // Runtime effect only suitable as SkColorFilter
-    kRuntimeShader,       //   "       "     "      "     "  SkShader
-    kRuntimeBlender,      //   "       "     "      "     "  SkBlender
-    kCustomMeshVertex,    // Vertex   portion of a custom mesh
-    kCustomMeshFragment,  // Fragment  "      "  "  "     "
+    kGraphiteFragment,
+    kGraphiteVertex,
+    kRuntimeColorFilter,    // Runtime effect only suitable as SkColorFilter
+    kRuntimeShader,         //   "       "     "      "     "  SkShader
+    kRuntimeBlender,        //   "       "     "      "     "  SkBlender
+    kPrivateRuntimeShader,  // Runtime shader with public restrictions lifted
+    kMeshVertex,            // Vertex   portion of a custom mesh
+    kMeshFragment,          // Fragment  "      "  "  "     "
     kGeneric,
 };
 

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

@@ -27,7 +27,6 @@ public:
         kExpression,
         kFor,
         kIf,
-        kInlineMarker,
         kNop,
         kReturn,
         kSwitch,
@@ -38,8 +37,8 @@ public:
         kLast = kVarDeclaration,
     };
 
-    Statement(int line, Kind kind)
-    : INHERITED(line, (int) kind) {
+    Statement(Position pos, Kind kind)
+    : INHERITED(pos, (int) kind) {
         SkASSERT(kind >= Kind::kFirst && kind <= Kind::kLast);
     }
 

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

@@ -8,73 +8,34 @@
 #ifndef SKSL_STRING
 #define SKSL_STRING
 
-#include "include/core/SkStringView.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkSLDefines.h"
-#include <cstring>
+
 #include <stdarg.h>
 #include <string>
-
-#ifndef SKSL_STANDALONE
-#include "include/core/SkString.h"
-#endif
+#include <string_view>
 
 namespace SkSL {
 
-class String;
-
-class SK_API String : public std::string {
-public:
-    using std::string::string;
-
-    explicit String(std::string s) : INHERITED(std::move(s)) {}
-    explicit String(skstd::string_view s) : INHERITED(s.data(), s.length()) {}
-    // TODO(johnstiles): add operator skstd::string_view
-
-    static String printf(const char* fmt, ...) SK_PRINTF_LIKE(1, 2);
-    void appendf(const char* fmt, ...) SK_PRINTF_LIKE(2, 3);
-    void vappendf(const char* fmt, va_list va);
-
-    bool starts_with(const char prefix[]) const {
-        return skstd::string_view(data(), size()).starts_with(prefix);
-    }
-    bool ends_with(const char suffix[]) const {
-        return skstd::string_view(data(), size()).ends_with(suffix);
-    }
-
-    bool consumeSuffix(const char suffix[]);
-
-    String operator+(const char* s) const;
-    String operator+(const String& s) const;
-    String operator+(skstd::string_view s) const;
-    String& operator+=(char c);
-    String& operator+=(const char* s);
-    String& operator+=(const String& s);
-    String& operator+=(skstd::string_view s);
-    friend String operator+(const char* s1, const String& s2);
+bool stod(std::string_view s, SKSL_FLOAT* value);
+bool stoi(std::string_view s, SKSL_INT* value);
 
-private:
-    using INHERITED = std::string;
-};
+namespace String {
 
-String operator+(skstd::string_view left, skstd::string_view right);
+std::string printf(const char* fmt, ...) SK_PRINTF_LIKE(1, 2);
+void appendf(std::string* str, const char* fmt, ...) SK_PRINTF_LIKE(2, 3);
+void vappendf(std::string* str, const char* fmt, va_list va) SK_PRINTF_LIKE(2, 0);
 
-String to_string(double value);
-String to_string(int32_t value);
-String to_string(uint32_t value);
-String to_string(int64_t value);
-String to_string(uint64_t value);
+}  // namespace String
+}  // namespace SkSL
 
-bool stod(skstd::string_view s, SKSL_FLOAT* value);
-bool stoi(skstd::string_view s, SKSL_INT* value);
+namespace skstd {
 
-} // namespace SkSL
+// We use a custom to_string(float|double) which ignores locale settings and writes `1.0` instead
+// of `1.00000`.
+std::string to_string(float value);
+std::string to_string(double value);
 
-namespace std {
-    template<> struct hash<SkSL::String> {
-        size_t operator()(const SkSL::String& s) const {
-            return hash<std::string>{}(s);
-        }
-    };
-} // namespace std
+}  // namespace skstd
 
 #endif

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

@@ -30,8 +30,8 @@ public:
         kLast = kVariable
     };
 
-    Symbol(int offset, Kind kind, skstd::string_view name, const Type* type = nullptr)
-        : INHERITED(offset, (int) kind)
+    Symbol(Position pos, Kind kind, std::string_view name, const Type* type = nullptr)
+        : INHERITED(pos, (int) kind)
         , fName(name)
         , fType(type) {
         SkASSERT(kind >= Kind::kFirst && kind <= Kind::kLast);
@@ -48,7 +48,7 @@ public:
         return (Kind) fKind;
     }
 
-    skstd::string_view name() const {
+    std::string_view name() const {
         return fName;
     }
 
@@ -77,7 +77,7 @@ public:
     }
 
 private:
-    skstd::string_view fName;
+    std::string_view fName;
     const Type* fType;
 
     using INHERITED = IRNode;

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

@@ -18,8 +18,10 @@ enum SkShadowFlags {
     kGeometricOnly_ShadowFlag = 0x02,
     /** Light position represents a direction, light radius is blur radius at elevation 1 */
     kDirectionalLight_ShadowFlag = 0x04,
+    /** Concave paths will only use blur to generate the shadow */
+    kConcaveBlurOnly_ShadowFlag = 0x08,
     /** mask for all shadow flags */
-    kAll_ShadowFlag = 0x07
+    kAll_ShadowFlag = 0x0F
 };
 
 #endif

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2021 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkStringView_DEFINED
+#define SkStringView_DEFINED
+
+#include <string.h>
+#include <string_view>
+
+namespace skstd {
+
+// C++20 additions
+inline constexpr bool starts_with(std::string_view str, std::string_view prefix) {
+    if (prefix.length() > str.length()) {
+        return false;
+    }
+    return prefix.length() == 0 || !memcmp(str.data(), prefix.data(), prefix.length());
+}
+
+inline constexpr bool starts_with(std::string_view str, std::string_view::value_type c) {
+    return !str.empty() && str.front() == c;
+}
+
+inline constexpr bool ends_with(std::string_view str, std::string_view suffix) {
+    if (suffix.length() > str.length()) {
+        return false;
+    }
+    return suffix.length() == 0 || !memcmp(str.data() + str.length() - suffix.length(),
+                                           suffix.data(), suffix.length());
+}
+
+inline constexpr bool ends_with(std::string_view str, std::string_view::value_type c) {
+    return !str.empty() && str.back() == c;
+}
+
+// C++23 additions
+inline constexpr bool contains(std::string_view str, std::string_view needle) {
+    return str.find(needle) != std::string_view::npos;
+}
+
+}  // namespace skstd
+
+#endif

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

@@ -16,6 +16,7 @@
 #include "include/private/SkTemplates.h"
 #include "include/private/SkTo.h"
 
+#include <algorithm>
 #include <string.h>
 #include <initializer_list>
 #include <memory>
@@ -477,15 +478,15 @@ private:
         SkASSERT(count >= 0);
         SkASSERT(preallocCount > 0);
         SkASSERT(preallocStorage);
-        fCount = count;
+        fCount = SkToU32(count);
         fItemArray = nullptr;
         fReserved = false;
         if (count > preallocCount) {
-            fAllocCount = std::max(count, kMinHeapAllocCount);
+            fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount));
             fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T));
             fOwnMemory = true;
         } else {
-            fAllocCount = preallocCount;
+            fAllocCount = SkToU32(preallocCount);
             fItemArray = (T*)preallocStorage;
             fOwnMemory = false;
         }

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

@@ -11,6 +11,8 @@
 #include "include/core/SkTypes.h"
 #include "include/private/SkChecksum.h"
 #include "include/private/SkTemplates.h"
+
+#include <initializer_list>
 #include <new>
 #include <utility>
 
@@ -134,6 +136,27 @@ public:
         }
     }
 
+    // Hash tables will automatically resize themselves when set() and remove() are called, but
+    // resize() can be called to manually grow capacity before a bulk insertion.
+    void resize(int capacity) {
+        SkASSERT(capacity >= fCount);
+        int oldCapacity = fCapacity;
+        SkDEBUGCODE(int oldCount = fCount);
+
+        fCount = 0;
+        fCapacity = capacity;
+        SkAutoTArray<Slot> oldSlots = std::move(fSlots);
+        fSlots = SkAutoTArray<Slot>(capacity);
+
+        for (int i = 0; i < oldCapacity; i++) {
+            Slot& s = oldSlots[i];
+            if (s.has_value()) {
+                this->uncheckedSet(*std::move(s));
+            }
+        }
+        SkASSERT(fCount == oldCount);
+    }
+
     // Call fn on every entry in the table.  You may mutate the entries, but be very careful.
     template <typename Fn>  // f(T*)
     void foreach(Fn&& fn) {
@@ -259,24 +282,6 @@ private:
         return nullptr;
     }
 
-    void resize(int capacity) {
-        int oldCapacity = fCapacity;
-        SkDEBUGCODE(int oldCount = fCount);
-
-        fCount = 0;
-        fCapacity = capacity;
-        SkAutoTArray<Slot> oldSlots = std::move(fSlots);
-        fSlots = SkAutoTArray<Slot>(capacity);
-
-        for (int i = 0; i < oldCapacity; i++) {
-            Slot& s = oldSlots[i];
-            if (s.has_value()) {
-                this->uncheckedSet(*std::move(s));
-            }
-        }
-        SkASSERT(fCount == oldCount);
-    }
-
     void removeSlot(int index) {
         fCount--;
 
@@ -413,12 +418,38 @@ private:
 template <typename K, typename V, typename HashK = SkGoodHash>
 class SkTHashMap {
 public:
+    // Allow default construction and assignment.
+    SkTHashMap() = default;
+
+    SkTHashMap(SkTHashMap<K, V, HashK>&& that) = default;
+    SkTHashMap(const SkTHashMap<K, V, HashK>& that) = default;
+
+    SkTHashMap<K, V, HashK>& operator=(SkTHashMap<K, V, HashK>&& that) = default;
+    SkTHashMap<K, V, HashK>& operator=(const SkTHashMap<K, V, HashK>& that) = default;
+
+    // Construct with an initializer list of key-value pairs.
+    struct Pair : public std::pair<K, V> {
+        using std::pair<K, V>::pair;
+        static const K& GetKey(const Pair& p) { return p.first; }
+        static auto Hash(const K& key) { return HashK()(key); }
+    };
+
+    SkTHashMap(std::initializer_list<Pair> pairs) {
+        fTable.resize(pairs.size() * 5 / 3);
+        for (const Pair& p : pairs) {
+            fTable.set(p);
+        }
+    }
+
     // Clear the map.
     void reset() { fTable.reset(); }
 
     // How many key/value pairs are in the table?
     int count() const { return fTable.count(); }
 
+    // Is empty?
+    bool empty() const { return fTable.count() == 0; }
+
     // Approximately how many bytes of memory do we use beyond sizeof(*this)?
     size_t approxBytesUsed() const { return fTable.approxBytesUsed(); }
 
@@ -466,12 +497,6 @@ public:
     }
 
     // Dereferencing an iterator gives back a key-value pair, suitable for structured binding.
-    struct Pair : public std::pair<K, V> {
-        using std::pair<K, V>::pair;
-        static const K& GetKey(const Pair& p) { return p.first; }
-        static auto Hash(const K& key) { return HashK()(key); }
-    };
-
     using Iter = typename SkTHashTable<Pair, K>::template Iter<std::pair<K, V>>;
 
     Iter begin() const {
@@ -490,6 +515,23 @@ private:
 template <typename T, typename HashT = SkGoodHash>
 class SkTHashSet {
 public:
+    // Allow default construction and assignment.
+    SkTHashSet() = default;
+
+    SkTHashSet(SkTHashSet<T, HashT>&& that) = default;
+    SkTHashSet(const SkTHashSet<T, HashT>& that) = default;
+
+    SkTHashSet<T, HashT>& operator=(SkTHashSet<T, HashT>&& that) = default;
+    SkTHashSet<T, HashT>& operator=(const SkTHashSet<T, HashT>& that) = default;
+
+    // Construct with an initializer list of Ts.
+    SkTHashSet(std::initializer_list<T> vals) {
+        fTable.resize(vals.size() * 5 / 3);
+        for (const T& val : vals) {
+            fTable.set(val);
+        }
+    }
+
     // Clear the set.
     void reset() { fTable.reset(); }
 

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

@@ -12,40 +12,10 @@
 #ifndef SkTLogic_DEFINED
 #define SkTLogic_DEFINED
 
-#include <cstddef>
+#include <iterator>
 #include <type_traits>
-#include <utility>
 #include "include/private/SkTo.h"
 
-namespace skstd {
-
-// C++17, <variant>
-struct monostate {};
-
-// C++17, <type_traits>
-template<typename...> struct conjunction : std::true_type { };
-template<typename T> struct conjunction<T> : T { };
-template<typename T, typename... Ts>
-struct conjunction<T, Ts...> : std::conditional<bool(T::value), conjunction<Ts...>, T>::type { };
-
-// C++17, std::data, std::size
-template<typename Container>
-constexpr auto data(Container& c) -> decltype(c.data()) { return c.data(); }
-template<typename Container>
-constexpr auto data(const Container& c) -> decltype(c.data()) { return c.data(); }
-template<typename Array, size_t N>
-constexpr auto data(Array(&a)[N]) -> decltype(a) { return a; }
-template<typename T>
-constexpr const T* data(std::initializer_list<T> i) { return i.begin(); }
-
-template<typename Container>
-constexpr auto size(Container& c) -> decltype(c.size()) { return c.size(); }
-template<typename Array, size_t N>
-constexpr size_t size(Array(&)[N]) { return N; }
-template<typename T>
-constexpr const T* size(std::initializer_list<T> i) { return i.end() - i.begin(); }
-}  // namespace skstd
-
 // The sknonstd namespace contains things we would like to be proposed and feel std-ish.
 namespace sknonstd {
 
@@ -81,6 +51,6 @@ template <typename D, typename S> using same_cv_t = typename same_cv<D, S>::type
 }  // namespace sknonstd
 
 template <typename Container>
-constexpr int SkCount(const Container& c) { return SkTo<int>(skstd::size(c)); }
+constexpr int SkCount(const Container& c) { return SkTo<int>(std::size(c)); }
 
 #endif

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

@@ -35,14 +35,14 @@ template<typename T> inline void sk_ignore_unused_variable(const T&) { }
 /**
  *  Returns a pointer to a D which comes immediately after S[count].
  */
-template <typename D, typename S> static D* SkTAfter(S* ptr, size_t count = 1) {
+template <typename D, typename S> inline D* SkTAfter(S* ptr, size_t count = 1) {
     return reinterpret_cast<D*>(ptr + count);
 }
 
 /**
  *  Returns a pointer to a D which comes byteOffset bytes after S.
  */
-template <typename D, typename S> static D* SkTAddOffset(S* ptr, ptrdiff_t byteOffset) {
+template <typename D, typename S> inline D* SkTAddOffset(S* ptr, ptrdiff_t byteOffset) {
     // The intermediate char* has the same cv-ness as D as this produces better error messages.
     // This relies on the fact that reinterpret_cast can add constness, but cannot remove it.
     return reinterpret_cast<D*>(reinterpret_cast<sknonstd::same_cv_t<char, D>*>(ptr) + byteOffset);

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

@@ -78,11 +78,11 @@
 
 #if defined(SK_BUILD_FOR_GOOGLE3) && !defined(SK_BUILD_FOR_WASM_IN_GOOGLE3)
     extern "C" {
-        void __google_potentially_blocking_region_begin(void);
-        void __google_potentially_blocking_region_end  (void);
+        void __google_cxa_guard_acquire_begin(void);
+        void __google_cxa_guard_acquire_end  (void);
     }
-    #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN __google_potentially_blocking_region_begin()
-    #define SK_POTENTIALLY_BLOCKING_REGION_END   __google_potentially_blocking_region_end()
+    #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN __google_cxa_guard_acquire_begin()
+    #define SK_POTENTIALLY_BLOCKING_REGION_END   __google_cxa_guard_acquire_end()
 #else
     #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN
     #define SK_POTENTIALLY_BLOCKING_REGION_END

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

@@ -858,20 +858,20 @@ SI void strided_load4(const T* v, \
     c = skvx::bit_pun<skvx::Vec<N,T>>(mat.val[2]); \
     d = skvx::bit_pun<skvx::Vec<N,T>>(mat.val[3]); \
 }
-IMPL_LOAD4_TRANSPOSED(2, uint32_t, vld4_u32);
-IMPL_LOAD4_TRANSPOSED(4, uint16_t, vld4_u16);
-IMPL_LOAD4_TRANSPOSED(8, uint8_t, vld4_u8);
-IMPL_LOAD4_TRANSPOSED(2, int32_t, vld4_s32);
-IMPL_LOAD4_TRANSPOSED(4, int16_t, vld4_s16);
-IMPL_LOAD4_TRANSPOSED(8, int8_t, vld4_s8);
-IMPL_LOAD4_TRANSPOSED(2, float, vld4_f32);
-IMPL_LOAD4_TRANSPOSED(4, uint32_t, vld4q_u32);
-IMPL_LOAD4_TRANSPOSED(8, uint16_t, vld4q_u16);
-IMPL_LOAD4_TRANSPOSED(16, uint8_t, vld4q_u8);
-IMPL_LOAD4_TRANSPOSED(4, int32_t, vld4q_s32);
-IMPL_LOAD4_TRANSPOSED(8, int16_t, vld4q_s16);
-IMPL_LOAD4_TRANSPOSED(16, int8_t, vld4q_s8);
-IMPL_LOAD4_TRANSPOSED(4, float, vld4q_f32);
+IMPL_LOAD4_TRANSPOSED(2, uint32_t, vld4_u32)
+IMPL_LOAD4_TRANSPOSED(4, uint16_t, vld4_u16)
+IMPL_LOAD4_TRANSPOSED(8, uint8_t, vld4_u8)
+IMPL_LOAD4_TRANSPOSED(2, int32_t, vld4_s32)
+IMPL_LOAD4_TRANSPOSED(4, int16_t, vld4_s16)
+IMPL_LOAD4_TRANSPOSED(8, int8_t, vld4_s8)
+IMPL_LOAD4_TRANSPOSED(2, float, vld4_f32)
+IMPL_LOAD4_TRANSPOSED(4, uint32_t, vld4q_u32)
+IMPL_LOAD4_TRANSPOSED(8, uint16_t, vld4q_u16)
+IMPL_LOAD4_TRANSPOSED(16, uint8_t, vld4q_u8)
+IMPL_LOAD4_TRANSPOSED(4, int32_t, vld4q_s32)
+IMPL_LOAD4_TRANSPOSED(8, int16_t, vld4q_s16)
+IMPL_LOAD4_TRANSPOSED(16, int8_t, vld4q_s8)
+IMPL_LOAD4_TRANSPOSED(4, float, vld4q_f32)
 #undef IMPL_LOAD4_TRANSPOSED
 
 #elif SKVX_USE_SIMD && defined(__SSE__)
@@ -913,20 +913,20 @@ SI void strided_load2(const T* v, skvx::Vec<N,T>& a, skvx::Vec<N,T>& b) { \
     a = skvx::bit_pun<skvx::Vec<N,T>>(mat.val[0]); \
     b = skvx::bit_pun<skvx::Vec<N,T>>(mat.val[1]); \
 }
-IMPL_LOAD2_TRANSPOSED(2, uint32_t, vld2_u32);
-IMPL_LOAD2_TRANSPOSED(4, uint16_t, vld2_u16);
-IMPL_LOAD2_TRANSPOSED(8, uint8_t, vld2_u8);
-IMPL_LOAD2_TRANSPOSED(2, int32_t, vld2_s32);
-IMPL_LOAD2_TRANSPOSED(4, int16_t, vld2_s16);
-IMPL_LOAD2_TRANSPOSED(8, int8_t, vld2_s8);
-IMPL_LOAD2_TRANSPOSED(2, float, vld2_f32);
-IMPL_LOAD2_TRANSPOSED(4, uint32_t, vld2q_u32);
-IMPL_LOAD2_TRANSPOSED(8, uint16_t, vld2q_u16);
-IMPL_LOAD2_TRANSPOSED(16, uint8_t, vld2q_u8);
-IMPL_LOAD2_TRANSPOSED(4, int32_t, vld2q_s32);
-IMPL_LOAD2_TRANSPOSED(8, int16_t, vld2q_s16);
-IMPL_LOAD2_TRANSPOSED(16, int8_t, vld2q_s8);
-IMPL_LOAD2_TRANSPOSED(4, float, vld2q_f32);
+IMPL_LOAD2_TRANSPOSED(2, uint32_t, vld2_u32)
+IMPL_LOAD2_TRANSPOSED(4, uint16_t, vld2_u16)
+IMPL_LOAD2_TRANSPOSED(8, uint8_t, vld2_u8)
+IMPL_LOAD2_TRANSPOSED(2, int32_t, vld2_s32)
+IMPL_LOAD2_TRANSPOSED(4, int16_t, vld2_s16)
+IMPL_LOAD2_TRANSPOSED(8, int8_t, vld2_s8)
+IMPL_LOAD2_TRANSPOSED(2, float, vld2_f32)
+IMPL_LOAD2_TRANSPOSED(4, uint32_t, vld2q_u32)
+IMPL_LOAD2_TRANSPOSED(8, uint16_t, vld2q_u16)
+IMPL_LOAD2_TRANSPOSED(16, uint8_t, vld2q_u8)
+IMPL_LOAD2_TRANSPOSED(4, int32_t, vld2q_s32)
+IMPL_LOAD2_TRANSPOSED(8, int16_t, vld2q_s16)
+IMPL_LOAD2_TRANSPOSED(16, int8_t, vld2q_s8)
+IMPL_LOAD2_TRANSPOSED(4, float, vld2q_f32)
 #undef IMPL_LOAD2_TRANSPOSED
 #endif