Improve naive SkColorXform to half floats

src/core/SkHalf.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkHalf_DEFINED
 #define SkHalf_DEFINED
 
@@ skipping 47 matching lines @@
     // denorm value V*2^-14 into a normalized float K + V*2^-14.  Then subtract off K.
     const Sk4i K = ((127-15) + (23-10) + 1) << 23;
     Sk4i mask_K = positive | K;
     Sk4f denorm = Sk4f::Load(&mask_K) - Sk4f::Load(&K);
 
     Sk4i merged = (sign << 16) | is_denorm.thenElse(Sk4i::Load(&denorm), norm);
     return Sk4f::Load(&merged);
 #endif
 }
 
-static inline uint64_t SkFloatToHalf_finite(const Sk4f& fs) {
-    uint64_t r;
+static inline Sk4h SkFloatToVectorHalf_finite(const Sk4f& fs) {

[msarett, 2016/07/18 22:09:09]

I'm seeing significant benefit from having a version of this that keeps the
result in the vector registers.

[mtklein, 2016/07/19 12:45:45]

Cool cool cool.   Less assembly's always better.  Must be the old code is always
literally producing the fmov, where this new version can see it as a logical
operation?

[msarett, 2016/07/19 15:24:49]

That's potentially true.

I only looked at the Intel clang disassembly.  I was having issues with:
4h -> store to uint64_t -> load to 4h -> unpack

This code was moving out of the vector registers, then reloading one lane at a
time (instead of the unpack).  It was ugly.

 #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)
-         "fmov  %[r], %d[vec]         \n"   // vst1_f16(&r, ...)
-        : [r] "=r" (r)                      // =r: write-only 64-bit general register
-        , [vec] "+w" (vec));                // +w: read-write NEON register
+        : [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_denorm = positive < ((127-15+1) << 23);  // positve < smallest normal 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;
 
     // This mechanically inverts the denorm half -> normal float conversion above.
     // Knowning that and reading its explanation will leave you feeling more confident
     // than reading my best attempt at explaining this directly.
     const Sk4i K = ((127-15) + (23-10) + 1) << 23;
     Sk4f plus_K = Sk4f::Load(&positive) + Sk4f::Load(&K);
     Sk4i denorm = Sk4i::Load(&plus_K) ^ K;
 
     Sk4i merged = (sign >> 16) | will_be_denorm.thenElse(denorm, norm);
-    SkNx_cast<uint16_t>(merged).store(&r);
+    return SkNx_cast<uint16_t>(merged);
 #endif
+}
+
+static inline uint64_t SkFloatToHalf_finite(const Sk4f& fs) {
+    uint64_t r;
+    Sk4h v = SkFloatToVectorHalf_finite(fs);
+    v.store(&r);
     return r;
 }
 
 #endif