Spin off some fixes to land right away.

src/core/Sk4x_sse.h

 // It is important _not_ to put header guards here.
 // This file will be intentionally included three times.
 
 // Useful reading:
 //   https://software.intel.com/sites/landingpage/IntrinsicsGuide/
 
 #if defined(SK4X_PREAMBLE)
     // Code in this file may assume SSE and SSE2.
     #include <emmintrin.h>
 
     // It must check for later instruction sets.
     #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE41
         #include <immintrin.h>
     #endif
 
     // A little bit of template metaprogramming to map
     // float to __m128 and int32_t to __m128i.
     template <typename T> struct SkScalarToSIMD;
     template <> struct SkScalarToSIMD<float>   { typedef __m128  Type; };
     template <> struct SkScalarToSIMD<int32_t> { typedef __m128i Type; };
 
     // These are all free, zero instructions.
     // MSVC insists we use _mm_castA_B(a) instead of (B)a.
-    static __m128  as_4f(__m128i v) { return _mm_castsi128_ps(v); }
-    static __m128  as_4f(__m128  v) { return                  v ; }
-    static __m128i as_4i(__m128i v) { return                  v ; }
-    static __m128i as_4i(__m128  v) { return _mm_castps_si128(v); }
+    static inline __m128  as_4f(__m128i v) { return _mm_castsi128_ps(v); }
+    static inline __m128  as_4f(__m128  v) { return                  v ; }
+    static inline __m128i as_4i(__m128i v) { return                  v ; }
+    static inline __m128i as_4i(__m128  v) { return _mm_castps_si128(v); }
 
 #elif defined(SK4X_PRIVATE)
     // It'd be slightly faster to call _mm_cmpeq_epi32() on an unintialized register and itself,
     // but that has caused hard to debug issues when compilers recognize dealing with uninitialized
     // memory as undefined behavior that can be optimized away.
     static __m128i True()  { return _mm_set1_epi8(~0); }
 
     // Leaving these implicit makes the rest of the code below a bit less noisy to read.
     Sk4x(__m128i);
     Sk4x(__m128);
@@ skipping 38 matching lines @@
 #define M(...) template <> inline __VA_ARGS__ Sk4f::
 
 M() Sk4x(float a, float b, float c, float d) : fVec(_mm_set_ps(d,c,b,a)) {}
 
 M(Sk4f) Load       (const float fs[4]) { return _mm_loadu_ps(fs); }
 M(Sk4f) LoadAligned(const float fs[4]) { return _mm_load_ps (fs); }
 
 M(void) store       (float fs[4]) const { _mm_storeu_ps(fs, fVec); }
 M(void) storeAligned(float fs[4]) const { _mm_store_ps (fs, fVec); }
 
-template <> template <>
-Sk4i Sk4f::reinterpret<Sk4i>() const { return as_4i(fVec); }
+template <>
+M(Sk4i) reinterpret<Sk4i>() const { return as_4i(fVec); }
 
-template <> template <>
-Sk4i Sk4f::cast<Sk4i>() const { return _mm_cvtps_epi32(fVec); }
+template <>
+M(Sk4i) cast<Sk4i>() const { return _mm_cvtps_epi32(fVec); }
 
 // We're going to try a little experiment here and skip allTrue(), anyTrue(), and bit-manipulators
 // for Sk4f.  Code that calls them probably does so accidentally.
 // Ask mtklein to fill these in if you really need them.
 
 M(Sk4f) add     (const Sk4f& o) const { return _mm_add_ps(fVec, o.fVec); }
 M(Sk4f) subtract(const Sk4f& o) const { return _mm_sub_ps(fVec, o.fVec); }
 M(Sk4f) multiply(const Sk4f& o) const { return _mm_mul_ps(fVec, o.fVec); }
 M(Sk4f) divide  (const Sk4f& o) const { return _mm_div_ps(fVec, o.fVec); }
 
@@ skipping 12 matching lines @@
 #define M(...) template <> inline __VA_ARGS__ Sk4i::
 
 M() Sk4x(int32_t a, int32_t b, int32_t c, int32_t d) : fVec(_mm_set_epi32(d,c,b,a)) {}
 
 M(Sk4i) Load       (const int32_t is[4]) { return _mm_loadu_si128((const __m128i*)is); }
 M(Sk4i) LoadAligned(const int32_t is[4]) { return _mm_load_si128 ((const __m128i*)is); }
 
 M(void) store       (int32_t is[4]) const { _mm_storeu_si128((__m128i*)is, fVec); }
 M(void) storeAligned(int32_t is[4]) const { _mm_store_si128 ((__m128i*)is, fVec); }
 
-template <> template <>
-Sk4f Sk4i::reinterpret<Sk4f>() const { return as_4f(fVec); }
+template <>
+M(Sk4f) reinterpret<Sk4f>() const { return as_4f(fVec); }
 
-template <> template <>
-Sk4f Sk4i::cast<Sk4f>() const { return _mm_cvtepi32_ps(fVec); }
+template <>
+M(Sk4f) cast<Sk4f>() const { return _mm_cvtepi32_ps(fVec); }
 
 M(bool) allTrue() const { return 0xf == _mm_movemask_ps(as_4f(fVec)); }
 M(bool) anyTrue() const { return 0x0 != _mm_movemask_ps(as_4f(fVec)); }
 
 M(Sk4i) bitNot() const { return _mm_xor_si128(fVec, True()); }
 M(Sk4i) bitAnd(const Sk4i& o) const { return _mm_and_si128(fVec, o.fVec); }
 M(Sk4i) bitOr (const Sk4i& o) const { return _mm_or_si128 (fVec, o.fVec); }
 
 M(Sk4i) equal           (const Sk4i& o) const { return _mm_cmpeq_epi32 (fVec, o.fVec); }
 M(Sk4i) lessThan        (const Sk4i& o) const { return _mm_cmplt_epi32 (fVec, o.fVec); }
@@ skipping 30 matching lines @@
     }
     M(Sk4i) Max(const Sk4i& a, const Sk4i& b) {
         Sk4i less = a.lessThan(b);
         return b.bitAnd(less).bitOr(a.andNot(less));
     }
 #endif
 
 #undef M
 
 #endif//Method definitions.