SkNx: use SK_ALWAYS_INLINE thoroughly.

MSVC's not so good at inlining.  So tell it where to.  It won't hurt the others.

This has nothing directly to do with ODR safety.  The anonymous namespaces and 'static' on freestanding functions provide the correctness we need there.  But this change can help to mechanically prevent the sort of problems ODR violations can lead to.

I may follow up by extending this strategy further to Sk4px, which is used to implement a lot of the legacy xfermodes.

BUG=skia:

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=3608
CQ_INCLUDE_TRYBOTS=master.client.skia:Test-Ubuntu-GCC-GCE-CPU-AVX2-x86_64-Release-SKNX_NO_SIMD-Trybot

Change-Id: I927334c40910ce43da1fbabdf243c9cd5438bea6
Reviewed-on: https://skia-review.googlesource.com/3608
Reviewed-by: Matt Sarett <msarett@google.com>
Commit-Queue: Mike Klein <mtklein@chromium.org>

1 files changed, 109 insertions, 106 deletions

diff --git a/src/core/SkNx.h b/src/core/SkNx.h
index 6d9af9fe47..ad0fc0d7c1 100644
--- a/src/core/SkNx.h
+++ b/src/core/SkNx.h
@@ -8,8 +8,6 @@
 #ifndef SkNx_DEFINED
 #define SkNx_DEFINED
 
-//#define SKNX_NO_SIMD
-
 #include "SkScalar.h"
 #include "SkTypes.h"
 #include <limits>
@@ -21,9 +19,10 @@
 template <int N, typename T> struct SkNx_abi      { SkNx_abi<N/2,T> lo, hi; };
 template <       typename T> struct SkNx_abi<1,T> {              T     val; };
 
-namespace {
+// Every single SkNx method wants to be fully inlined.  (We know better than MSVC).
+#define AI SK_ALWAYS_INLINE
 
-#define SI static inline
+namespace {
 
 // The default SkNx<N,T> just proxies down to a pair of SkNx<N/2, T>.
 template <int N, typename T>
@@ -32,40 +31,41 @@ struct SkNx {
 
     Half fLo, fHi;
 
-    SkNx() = default;
-    SkNx(const Half& lo, const Half& hi) : fLo(lo), fHi(hi) {}
+    AI SkNx() = default;
+    AI SkNx(const Half& lo, const Half& hi) : fLo(lo), fHi(hi) {}
 
-    SkNx(T v) : fLo(v), fHi(v) {}
+    AI SkNx(T v) : fLo(v), fHi(v) {}
 
-    SkNx(T a, T b)           : fLo(a)  , fHi(b)   { static_assert(N==2, ""); }
-    SkNx(T a, T b, T c, T d) : fLo(a,b), fHi(c,d) { static_assert(N==4, ""); }
-    SkNx(T a, T b, T c, T d,  T e, T f, T g, T h) : fLo(a,b,c,d), fHi(e,f,g,h) {
+    AI SkNx(T a, T b)           : fLo(a)  , fHi(b)   { static_assert(N==2, ""); }
+    AI SkNx(T a, T b, T c, T d) : fLo(a,b), fHi(c,d) { static_assert(N==4, ""); }
+    AI SkNx(T a, T b, T c, T d,  T e, T f, T g, T h) : fLo(a,b,c,d), fHi(e,f,g,h) {
         static_assert(N==8, "");
     }
-    SkNx(T a, T b, T c, T d,  T e, T f, T g, T h,
-         T i, T j, T k, T l,  T m, T n, T o, T p) : fLo(a,b,c,d, e,f,g,h), fHi(i,j,k,l, m,n,o,p) {
+    AI SkNx(T a, T b, T c, T d,  T e, T f, T g, T h,
+            T i, T j, T k, T l,  T m, T n, T o, T p)
+        : fLo(a,b,c,d, e,f,g,h), fHi(i,j,k,l, m,n,o,p) {
         static_assert(N==16, "");
     }
 
-    SkNx(const SkNx_abi<N,T>& a) : fLo(a.lo), fHi(a.hi) {}
-    operator SkNx_abi<N,T>() const { return { (SkNx_abi<N/2,T>)fLo, (SkNx_abi<N/2,T>)fHi }; }
+    AI SkNx(const SkNx_abi<N,T>& a) : fLo(a.lo), fHi(a.hi) {}
+    AI operator SkNx_abi<N,T>() const { return { (SkNx_abi<N/2,T>)fLo, (SkNx_abi<N/2,T>)fHi }; }
 
-    T operator[](int k) const {
+    AI T operator[](int k) const {
         SkASSERT(0 <= k && k < N);
         return k < N/2 ? fLo[k] : fHi[k-N/2];
     }
 
-    static SkNx Load(const void* vptr) {
+    AI static SkNx Load(const void* vptr) {
         auto ptr = (const char*)vptr;
         return { Half::Load(ptr), Half::Load(ptr + N/2*sizeof(T)) };
     }
-    void store(void* vptr) const {
+    AI void store(void* vptr) const {
         auto ptr = (char*)vptr;
         fLo.store(ptr);
         fHi.store(ptr + N/2*sizeof(T));
     }
 
-    static void Load4(const void* vptr, SkNx* a, SkNx* b, SkNx* c, SkNx* d) {
+    AI static void Load4(const void* vptr, SkNx* a, SkNx* b, SkNx* c, SkNx* d) {
         auto ptr = (const char*)vptr;
         Half al, bl, cl, dl,
              ah, bh, ch, dh;
@@ -76,55 +76,55 @@ struct SkNx {
         *c = SkNx{cl, ch};
         *d = SkNx{dl, dh};
     }
-    static void Store4(void* vptr, const SkNx& a, const SkNx& b, const SkNx& c, const SkNx& d) {
+    AI static void Store4(void* vptr, const SkNx& a, const SkNx& b, const SkNx& c, const SkNx& d) {
         auto ptr = (char*)vptr;
         Half::Store4(ptr,                   a.fLo, b.fLo, c.fLo, d.fLo);
         Half::Store4(ptr + 4*N/2*sizeof(T), a.fHi, b.fHi, c.fHi, d.fHi);
     }
 
-    bool anyTrue() const { return fLo.anyTrue() || fHi.anyTrue(); }
-    bool allTrue() const { return fLo.allTrue() && fHi.allTrue(); }
+    AI bool anyTrue() const { return fLo.anyTrue() || fHi.anyTrue(); }
+    AI bool allTrue() const { return fLo.allTrue() && fHi.allTrue(); }
 
-    SkNx    abs() const { return { fLo.   abs(), fHi.   abs() }; }
-    SkNx   sqrt() const { return { fLo.  sqrt(), fHi.  sqrt() }; }
-    SkNx  rsqrt() const { return { fLo. rsqrt(), fHi. rsqrt() }; }
-    SkNx  floor() const { return { fLo. floor(), fHi. floor() }; }
-    SkNx invert() const { return { fLo.invert(), fHi.invert() }; }
+    AI SkNx    abs() const { return { fLo.   abs(), fHi.   abs() }; }
+    AI SkNx   sqrt() const { return { fLo.  sqrt(), fHi.  sqrt() }; }
+    AI SkNx  rsqrt() const { return { fLo. rsqrt(), fHi. rsqrt() }; }
+    AI SkNx  floor() const { return { fLo. floor(), fHi. floor() }; }
+    AI SkNx invert() const { return { fLo.invert(), fHi.invert() }; }
 
-    SkNx operator!() const { return { !fLo, !fHi }; }
-    SkNx operator-() const { return { -fLo, -fHi }; }
-    SkNx operator~() const { return { ~fLo, ~fHi }; }
+    AI SkNx operator!() const { return { !fLo, !fHi }; }
+    AI SkNx operator-() const { return { -fLo, -fHi }; }
+    AI SkNx operator~() const { return { ~fLo, ~fHi }; }
 
-    SkNx operator<<(int bits) const { return { fLo << bits, fHi << bits }; }
-    SkNx operator>>(int bits) const { return { fLo >> bits, fHi >> bits }; }
+    AI SkNx operator<<(int bits) const { return { fLo << bits, fHi << bits }; }
+    AI SkNx operator>>(int bits) const { return { fLo >> bits, fHi >> bits }; }
 
-    SkNx operator+(const SkNx& y) const { return { fLo + y.fLo, fHi + y.fHi }; }
-    SkNx operator-(const SkNx& y) const { return { fLo - y.fLo, fHi - y.fHi }; }
-    SkNx operator*(const SkNx& y) const { return { fLo * y.fLo, fHi * y.fHi }; }
-    SkNx operator/(const SkNx& y) const { return { fLo / y.fLo, fHi / y.fHi }; }
+    AI SkNx operator+(const SkNx& y) const { return { fLo + y.fLo, fHi + y.fHi }; }
+    AI SkNx operator-(const SkNx& y) const { return { fLo - y.fLo, fHi - y.fHi }; }
+    AI SkNx operator*(const SkNx& y) const { return { fLo * y.fLo, fHi * y.fHi }; }
+    AI SkNx operator/(const SkNx& y) const { return { fLo / y.fLo, fHi / y.fHi }; }
 
-    SkNx operator&(const SkNx& y) const { return { fLo & y.fLo, fHi & y.fHi }; }
-    SkNx operator|(const SkNx& y) const { return { fLo | y.fLo, fHi | y.fHi }; }
-    SkNx operator^(const SkNx& y) const { return { fLo ^ y.fLo, fHi ^ y.fHi }; }
+    AI SkNx operator&(const SkNx& y) const { return { fLo & y.fLo, fHi & y.fHi }; }
+    AI SkNx operator|(const SkNx& y) const { return { fLo | y.fLo, fHi | y.fHi }; }
+    AI SkNx operator^(const SkNx& y) const { return { fLo ^ y.fLo, fHi ^ y.fHi }; }
 
-    SkNx operator==(const SkNx& y) const { return { fLo == y.fLo, fHi == y.fHi }; }
-    SkNx operator!=(const SkNx& y) const { return { fLo != y.fLo, fHi != y.fHi }; }
-    SkNx operator<=(const SkNx& y) const { return { fLo <= y.fLo, fHi <= y.fHi }; }
-    SkNx operator>=(const SkNx& y) const { return { fLo >= y.fLo, fHi >= y.fHi }; }
-    SkNx operator< (const SkNx& y) const { return { fLo <  y.fLo, fHi <  y.fHi }; }
-    SkNx operator> (const SkNx& y) const { return { fLo >  y.fLo, fHi >  y.fHi }; }
+    AI SkNx operator==(const SkNx& y) const { return { fLo == y.fLo, fHi == y.fHi }; }
+    AI SkNx operator!=(const SkNx& y) const { return { fLo != y.fLo, fHi != y.fHi }; }
+    AI SkNx operator<=(const SkNx& y) const { return { fLo <= y.fLo, fHi <= y.fHi }; }
+    AI SkNx operator>=(const SkNx& y) const { return { fLo >= y.fLo, fHi >= y.fHi }; }
+    AI SkNx operator< (const SkNx& y) const { return { fLo <  y.fLo, fHi <  y.fHi }; }
+    AI SkNx operator> (const SkNx& y) const { return { fLo >  y.fLo, fHi >  y.fHi }; }
 
-    SkNx saturatedAdd(const SkNx& y) const {
+    AI SkNx saturatedAdd(const SkNx& y) const {
         return { fLo.saturatedAdd(y.fLo), fHi.saturatedAdd(y.fHi) };
     }
-    SkNx thenElse(const SkNx& t, const SkNx& e) const {
+    AI SkNx thenElse(const SkNx& t, const SkNx& e) const {
         return { fLo.thenElse(t.fLo, e.fLo), fHi.thenElse(t.fHi, e.fHi) };
     }
 
-    static SkNx Min(const SkNx& x, const SkNx& y) {
+    AI static SkNx Min(const SkNx& x, const SkNx& y) {
         return { Half::Min(x.fLo, y.fLo), Half::Min(x.fHi, y.fHi) };
     }
-    static SkNx Max(const SkNx& x, const SkNx& y) {
+    AI static SkNx Max(const SkNx& x, const SkNx& y) {
         return { Half::Max(x.fLo, y.fLo), Half::Max(x.fHi, y.fHi) };
     }
 };
@@ -134,33 +134,33 @@ template <typename T>
 struct SkNx<1,T> {
     T fVal;
 
-    SkNx() = default;
-    SkNx(T v) : fVal(v) {}
+    AI SkNx() = default;
+    AI SkNx(T v) : fVal(v) {}
 
-    SkNx(const SkNx_abi<1,T>& a) : fVal(a.val) {}
-    operator SkNx_abi<1,T>() const { return { fVal }; }
+    AI SkNx(const SkNx_abi<1,T>& a) : fVal(a.val) {}
+    AI operator SkNx_abi<1,T>() const { return { fVal }; }
 
     // Android complains against unused parameters, so we guard it
-    T operator[](int SkDEBUGCODE(k)) const {
+    AI T operator[](int SkDEBUGCODE(k)) const {
         SkASSERT(k == 0);
         return fVal;
     }
 
-    static SkNx Load(const void* ptr) {
+    AI static SkNx Load(const void* ptr) {
         SkNx v;
         memcpy(&v, ptr, sizeof(T));
         return v;
     }
-    void store(void* ptr) const { memcpy(ptr, &fVal, sizeof(T)); }
+    AI void store(void* ptr) const { memcpy(ptr, &fVal, sizeof(T)); }
 
-    static void Load4(const void* vptr, SkNx* a, SkNx* b, SkNx* c, SkNx* d) {
+    AI static void Load4(const void* vptr, SkNx* a, SkNx* b, SkNx* c, SkNx* d) {
         auto ptr = (const char*)vptr;
         *a = Load(ptr + 0*sizeof(T));
         *b = Load(ptr + 1*sizeof(T));
         *c = Load(ptr + 2*sizeof(T));
         *d = Load(ptr + 3*sizeof(T));
     }
-    static void Store4(void* vptr, const SkNx& a, const SkNx& b, const SkNx& c, const SkNx& d) {
+    AI static void Store4(void* vptr, const SkNx& a, const SkNx& b, const SkNx& c, const SkNx& d) {
         auto ptr = (char*)vptr;
         a.store(ptr + 0*sizeof(T));
         b.store(ptr + 1*sizeof(T));
@@ -168,65 +168,67 @@ struct SkNx<1,T> {
         d.store(ptr + 3*sizeof(T));
     }
 
-    bool anyTrue() const { return fVal != 0; }
-    bool allTrue() const { return fVal != 0; }
+    AI bool anyTrue() const { return fVal != 0; }
+    AI bool allTrue() const { return fVal != 0; }
 
-    SkNx    abs() const { return Abs(fVal); }
-    SkNx   sqrt() const { return Sqrt(fVal); }
-    SkNx  rsqrt() const { return T(1) / this->sqrt(); }
-    SkNx  floor() const { return Floor(fVal); }
-    SkNx invert() const { return T(1) / *this; }
+    AI SkNx    abs() const { return Abs(fVal); }
+    AI SkNx   sqrt() const { return Sqrt(fVal); }
+    AI SkNx  rsqrt() const { return T(1) / this->sqrt(); }
+    AI SkNx  floor() const { return Floor(fVal); }
+    AI SkNx invert() const { return T(1) / *this; }
 
-    SkNx operator!() const { return !fVal; }
-    SkNx operator-() const { return -fVal; }
-    SkNx operator~() const { return FromBits(~ToBits(fVal)); }
+    AI SkNx operator!() const { return !fVal; }
+    AI SkNx operator-() const { return -fVal; }
+    AI SkNx operator~() const { return FromBits(~ToBits(fVal)); }
 
-    SkNx operator<<(int bits) const { return fVal << bits; }
-    SkNx operator>>(int bits) const { return fVal >> bits; }
+    AI SkNx operator<<(int bits) const { return fVal << bits; }
+    AI SkNx operator>>(int bits) const { return fVal >> bits; }
 
-    SkNx operator+(const SkNx& y) const { return fVal + y.fVal; }
-    SkNx operator-(const SkNx& y) const { return fVal - y.fVal; }
-    SkNx operator*(const SkNx& y) const { return fVal * y.fVal; }
-    SkNx operator/(const SkNx& y) const { return fVal / y.fVal; }
+    AI SkNx operator+(const SkNx& y) const { return fVal + y.fVal; }
+    AI SkNx operator-(const SkNx& y) const { return fVal - y.fVal; }
+    AI SkNx operator*(const SkNx& y) const { return fVal * y.fVal; }
+    AI SkNx operator/(const SkNx& y) const { return fVal / y.fVal; }
 
-    SkNx operator&(const SkNx& y) const { return FromBits(ToBits(fVal) & ToBits(y.fVal)); }
-    SkNx operator|(const SkNx& y) const { return FromBits(ToBits(fVal) | ToBits(y.fVal)); }
-    SkNx operator^(const SkNx& y) const { return FromBits(ToBits(fVal) ^ ToBits(y.fVal)); }
+    AI SkNx operator&(const SkNx& y) const { return FromBits(ToBits(fVal) & ToBits(y.fVal)); }
+    AI SkNx operator|(const SkNx& y) const { return FromBits(ToBits(fVal) | ToBits(y.fVal)); }
+    AI SkNx operator^(const SkNx& y) const { return FromBits(ToBits(fVal) ^ ToBits(y.fVal)); }
 
-    SkNx operator==(const SkNx& y) const { return FromBits(fVal == y.fVal ? ~0 : 0); }
-    SkNx operator!=(const SkNx& y) const { return FromBits(fVal != y.fVal ? ~0 : 0); }
-    SkNx operator<=(const SkNx& y) const { return FromBits(fVal <= y.fVal ? ~0 : 0); }
-    SkNx operator>=(const SkNx& y) const { return FromBits(fVal >= y.fVal ? ~0 : 0); }
-    SkNx operator< (const SkNx& y) const { return FromBits(fVal <  y.fVal ? ~0 : 0); }
-    SkNx operator> (const SkNx& y) const { return FromBits(fVal >  y.fVal ? ~0 : 0); }
+    AI SkNx operator==(const SkNx& y) const { return FromBits(fVal == y.fVal ? ~0 : 0); }
+    AI SkNx operator!=(const SkNx& y) const { return FromBits(fVal != y.fVal ? ~0 : 0); }
+    AI SkNx operator<=(const SkNx& y) const { return FromBits(fVal <= y.fVal ? ~0 : 0); }
+    AI SkNx operator>=(const SkNx& y) const { return FromBits(fVal >= y.fVal ? ~0 : 0); }
+    AI SkNx operator< (const SkNx& y) const { return FromBits(fVal <  y.fVal ? ~0 : 0); }
+    AI SkNx operator> (const SkNx& y) const { return FromBits(fVal >  y.fVal ? ~0 : 0); }
 
-    static SkNx Min(const SkNx& x, const SkNx& y) { return x.fVal < y.fVal ? x : y; }
-    static SkNx Max(const SkNx& x, const SkNx& y) { return x.fVal > y.fVal ? x : y; }
+    AI static SkNx Min(const SkNx& x, const SkNx& y) { return x.fVal < y.fVal ? x : y; }
+    AI static SkNx Max(const SkNx& x, const SkNx& y) { return x.fVal > y.fVal ? x : y; }
 
-    SkNx saturatedAdd(const SkNx& y) const {
+    AI SkNx saturatedAdd(const SkNx& y) const {
         static_assert(std::is_unsigned<T>::value, "");
         T sum = fVal + y.fVal;
         return sum < fVal ? std::numeric_limits<T>::max() : sum;
     }
 
-    SkNx thenElse(const SkNx& t, const SkNx& e) const { return fVal != 0 ? t : e; }
+    AI SkNx thenElse(const SkNx& t, const SkNx& e) const { return fVal != 0 ? t : e; }
 
 private:
     // Helper functions to choose the right float/double methods.  (In <cmath> madness lies...)
-    static float   Abs(float val) { return  ::fabsf(val); }
-    static float  Sqrt(float val) { return  ::sqrtf(val); }
-    static float Floor(float val) { return ::floorf(val); }
+    AI static float   Abs(float val) { return  ::fabsf(val); }
+    AI static float  Sqrt(float val) { return  ::sqrtf(val); }
+    AI static float Floor(float val) { return ::floorf(val); }
 
-    static double   Abs(double val) { return  ::fabs(val); }
-    static double  Sqrt(double val) { return  ::sqrt(val); }
-    static double Floor(double val) { return ::floor(val); }
+    AI static double   Abs(double val) { return  ::fabs(val); }
+    AI static double  Sqrt(double val) { return  ::sqrt(val); }
+    AI static double Floor(double val) { return ::floor(val); }
 
     // Helper functions for working with floats/doubles as bit patterns.
-    template <typename U> static U ToBits(U v) { return v; }
-    static int32_t ToBits(float  v) { int32_t bits; memcpy(&bits, &v, sizeof(v)); return bits; }
-    static int64_t ToBits(double v) { int64_t bits; memcpy(&bits, &v, sizeof(v)); return bits; }
+    template <typename U>
+    AI static U ToBits(U v) { return v; }
+    AI static int32_t ToBits(float  v) { int32_t bits; memcpy(&bits, &v, sizeof(v)); return bits; }
+    AI static int64_t ToBits(double v) { int64_t bits; memcpy(&bits, &v, sizeof(v)); return bits; }
 
-    template <typename Bits> static T FromBits(Bits bits) {
+    template <typename Bits>
+    AI static T FromBits(Bits bits) {
         static_assert(std::is_pod<T   >::value &&
                       std::is_pod<Bits>::value &&
                       sizeof(T) <= sizeof(Bits), "");
@@ -237,7 +239,7 @@ private:
 };
 
 // Allow scalars on the left or right of binary operators, and things like +=, &=, etc.
-#define V template <int N, typename T> SI SkNx<N,T>
+#define V template <int N, typename T> AI static SkNx<N,T>
     V operator+ (T x, const SkNx<N,T>& y) { return SkNx<N,T>(x) +  y; }
     V operator- (T x, const SkNx<N,T>& y) { return SkNx<N,T>(x) -  y; }
     V operator* (T x, const SkNx<N,T>& y) { return SkNx<N,T>(x) *  y; }
@@ -288,14 +290,14 @@ private:
 
 // SkNx<N,T> ~~> SkNx<N/2,T> + SkNx<N/2,T>
 template <int N, typename T>
-SI void SkNx_split(const SkNx<N,T>& v, SkNx<N/2,T>* lo, SkNx<N/2,T>* hi) {
+AI static void SkNx_split(const SkNx<N,T>& v, SkNx<N/2,T>* lo, SkNx<N/2,T>* hi) {
     *lo = v.fLo;
     *hi = v.fHi;
 }
 
 // SkNx<N/2,T> + SkNx<N/2,T> ~~> SkNx<N,T>
 template <int N, typename T>
-SI SkNx<N*2,T> SkNx_join(const SkNx<N,T>& lo, const SkNx<N,T>& hi) {
+AI static SkNx<N*2,T> SkNx_join(const SkNx<N,T>& lo, const SkNx<N,T>& hi) {
     return { lo, hi };
 }
 
@@ -306,22 +308,22 @@ SI SkNx<N*2,T> SkNx_join(const SkNx<N,T>& lo, const SkNx<N,T>& hi) {
 //    SkNx_shuffle<2,1,2,1,2,1,2,1>(v) ~~> {B,G,B,G,B,G,B,G}
 //    SkNx_shuffle<3,3,3,3>(v)         ~~> {A,A,A,A}
 template <int... Ix, int N, typename T>
-SI SkNx<sizeof...(Ix),T> SkNx_shuffle(const SkNx<N,T>& v) {
+AI static SkNx<sizeof...(Ix),T> SkNx_shuffle(const SkNx<N,T>& v) {
     return { v[Ix]... };
 }
 
 // Cast from SkNx<N, Src> to SkNx<N, Dst>, as if you called static_cast<Dst>(Src).
 template <typename Dst, typename Src, int N>
-SI SkNx<N,Dst> SkNx_cast(const SkNx<N,Src>& v) {
+AI static SkNx<N,Dst> SkNx_cast(const SkNx<N,Src>& v) {
     return { SkNx_cast<Dst>(v.fLo), SkNx_cast<Dst>(v.fHi) };
 }
 template <typename Dst, typename Src>
-SI SkNx<1,Dst> SkNx_cast(const SkNx<1,Src>& v) {
+AI static SkNx<1,Dst> SkNx_cast(const SkNx<1,Src>& v) {
     return static_cast<Dst>(v.fVal);
 }
 
 template <int N, typename T>
-SI SkNx<N,T> SkNx_fma(const SkNx<N,T>& f, const SkNx<N,T>& m, const SkNx<N,T>& a) {
+AI static SkNx<N,T> SkNx_fma(const SkNx<N,T>& f, const SkNx<N,T>& m, const SkNx<N,T>& a) {
     return f*m+a;
 }
 
@@ -356,7 +358,7 @@ typedef SkNx<4, uint32_t> Sk4u;
     #include "../opts/SkNx_neon.h"
 #else
 
-SI Sk4i Sk4f_round(const Sk4f& x) {
+AI static Sk4i Sk4f_round(const Sk4f& x) {
     return { (int) lrintf (x[0]),
              (int) lrintf (x[1]),
              (int) lrintf (x[2]),
@@ -365,10 +367,11 @@ SI Sk4i Sk4f_round(const Sk4f& x) {
 
 #endif
 
-SI void Sk4f_ToBytes(uint8_t p[16], const Sk4f& a, const Sk4f& b, const Sk4f& c, const Sk4f& d) {
+AI static void Sk4f_ToBytes(uint8_t p[16],
+                            const Sk4f& a, const Sk4f& b, const Sk4f& c, const Sk4f& d) {
     SkNx_cast<uint8_t>(SkNx_join(SkNx_join(a,b), SkNx_join(c,d))).store(p);
 }
 
-#undef SI
+#undef AI
 
 #endif//SkNx_DEFINED