Use switch operator[](int) to kth<int>() so we can use vget_lane.

src/core/SkNx.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkNx_DEFINED
 #define SkNx_DEFINED
 
@@ skipping 60 matching lines @@
     static SkNf Max(const SkNf& l, const SkNf& r) {
         return SkNf(SkNf<N/2,T>::Max(l.fLo, r.fLo), SkNf<N/2,T>::Max(l.fHi, r.fHi));
     }
 
     SkNf  sqrt() const { return SkNf(fLo. sqrt(), fHi. sqrt()); }
     SkNf rsqrt() const { return SkNf(fLo.rsqrt(), fHi.rsqrt()); }
 
     SkNf       invert() const { return SkNf(fLo.      invert(), fHi.      invert()); }
     SkNf approxInvert() const { return SkNf(fLo.approxInvert(), fHi.approxInvert()); }
 
-    T operator[] (int k) const {
+    template <int k> T kth() const {
         SkASSERT(0 <= k && k < N);
-        return k < N/2 ? fLo[k] : fHi[k-N/2];
+        return k < N/2 ? fLo.template kth<k>() : fHi.template kth<k-N/2>();
     }
 
 private:
     REQUIRE(0 == (N & (N-1)));
     SkNf(const SkNf<N/2, T>& lo, const SkNf<N/2, T>& hi) : fLo(lo), fHi(hi) {}
 
     SkNf<N/2, T> fLo, fHi;
 };
 
 
@@ skipping 36 matching lines @@
 
     static SkNf Min(const SkNf& l, const SkNf& r) { return SkNf(SkTMin(l.fVal, r.fVal)); }
     static SkNf Max(const SkNf& l, const SkNf& r) { return SkNf(SkTMax(l.fVal, r.fVal)); }
 
     SkNf  sqrt() const { return SkNf(Sqrt(fVal));          }
     SkNf rsqrt() const { return SkNf((T)1 / Sqrt(fVal)); }
 
     SkNf       invert() const { return SkNf((T)1 / fVal); }
     SkNf approxInvert() const { return this->invert();    }
 
-    T operator[] (int SkDEBUGCODE(k)) const {
+    template <int k> T kth() const {
         SkASSERT(k == 0);
         return fVal;
     }
 
 private:
     // We do double sqrts natively, or via floats for any other type.
     template <typename U>
     static U      Sqrt(U      val) { return (U) ::sqrtf((float)val); }
     static double Sqrt(double val) { return     ::sqrt (       val); }
 
     T fVal;
 };
 
 
 // Generic syntax sugar that should work equally well for all SkNi and SkNf implementations.
-template <typename SkNx> SkNx operator - (const SkNx& l) { return SkNx((decltype(l[0]))0) - l; }
+template <typename SkNx> SkNx operator - (const SkNx& l) { return SkNx(0) - l; }
 
 template <typename SkNx> SkNx& operator += (SkNx& l, const SkNx& r) { return (l = l + r); }
 template <typename SkNx> SkNx& operator -= (SkNx& l, const SkNx& r) { return (l = l - r); }
 template <typename SkNx> SkNx& operator *= (SkNx& l, const SkNx& r) { return (l = l * r); }
 template <typename SkNx> SkNx& operator /= (SkNx& l, const SkNx& r) { return (l = l / r); }
 
 
 // Include platform specific specializations if available.
 #ifndef SKNX_NO_SIMD
     #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
         #include "../opts/SkNx_sse.h"
     #elif defined(SK_ARM_HAS_NEON)
         #include "../opts/SkNx_neon.h"
     #endif
 #endif
 
 #undef REQUIRE
 
 typedef SkNf<2,    float> Sk2f;
 typedef SkNf<2,   double> Sk2d;
 typedef SkNf<2, SkScalar> Sk2s;
 
 typedef SkNf<4,    float> Sk4f;
 typedef SkNf<4,   double> Sk4d;
 typedef SkNf<4, SkScalar> Sk4s;
 
 typedef SkNi<4, int32_t> Sk4i;
 
 #endif//SkNx_DEFINED