Move CPU feature detection to its own file.

src/core/SkCpu.cpp

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkCpu.h"
+#include "SkOncePtr.h"
+
+#if defined(SK_CPU_X86)
+    #if defined(SK_BUILD_FOR_WIN32)
+        #include <intrin.h>
+        static void cpuid (uint32_t abcd[4]) { __cpuid  ((int*)abcd, 1);    }
+        static void cpuid7(uint32_t abcd[4]) { __cpuidex((int*)abcd, 7, 0); }
+        static uint64_t xgetbv(uint32_t xcr) { return _xgetbv(xcr); }
+    #else
+        #include <cpuid.h>

[herb_g, 2016/04/14 15:38:34]

If you have a link to the docs that describe cpuid that you used to figure out
this code could you add it here.

[mtklein, 2016/04/14 15:52:28]

Done, below.

+        #if !defined(__cpuid_count)  // Old Mac Clang doesn't have this defined.
+            #define  __cpuid_count(eax, ecx, a, b, c, d) \
+                __asm__("cpuid" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "0"(eax), "2"(ecx))
+        #endif
+        static void cpuid (uint32_t abcd[4]) { __get_cpuid(1, abcd+0, abcd+1, abcd+2, abcd+3); }
+        static void cpuid7(uint32_t abcd[4]) {
+            __cpuid_count(7, 0, abcd[0], abcd[1], abcd[2], abcd[3]);
+        }
+        static uint64_t xgetbv(uint32_t xcr) {
+            uint32_t eax, edx;
+            __asm__ __volatile__ ( "xgetbv" : "=a"(eax), "=d"(edx) : "c"(xcr));
+            return (uint64_t)(edx) << 32 | eax;
+        }
+    #endif
+
+    static uint32_t read_cpu_features() {
+        uint32_t features = 0;
+        uint32_t abcd[4] = {0,0,0,0};
+
+        cpuid(abcd);
+        if (abcd[3] & (1<<25)) { features |= SkCpu:: SSE1; }

[f(malita), 2016/04/14 15:40:35]

It's a bummer we can't use the cpuid.h macros instead of magic constants.  I
guess adding an enum would be kinda redundant too.

[mtklein, 2016/04/14 15:52:28]

Yeah, we could use them when we have cpuid.h, but that'd fork this code.  This
function more or less is the enum(s) we'd write.

+        if (abcd[3] & (1<<26)) { features |= SkCpu:: SSE2; }
+        if (abcd[2] & (1<< 0)) { features |= SkCpu:: SSE3; }
+        if (abcd[2] & (1<< 9)) { features |= SkCpu::SSSE3; }
+        if (abcd[2] & (1<<19)) { features |= SkCpu::SSE41; }
+        if (abcd[2] & (1<<20)) { features |= SkCpu::SSE42; }
+
+        if ((abcd[2] & (3<<26)) == (3<<26) && (xgetbv(0) & 6) == 6) {  // XSAVE + OSXSAVE
+            if (abcd[2] & (1<<28)) { features |= SkCpu:: AVX; }
+            if (abcd[2] & (1<<29)) { features |= SkCpu::F16C; }
+            if (abcd[2] & (1<<12)) { features |= SkCpu:: FMA; }
+
+            cpuid7(abcd);
+            if (abcd[1] & (1<<5)) { features |= SkCpu::AVX2; }
+        }
+        return features;
+    }
+
+#elif defined(SK_CPU_ARM32)         && \
+      defined(SK_BUILD_FOR_ANDROID) && \
+     !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
+    #include <cpu-features.h>
+
+    static uint32_t read_cpu_features() {
+        uint32_t features = 0;
+
+        uint64_t android_features = android_getCpuFeatures();
+        if (android_features & ANDROID_CPU_ARM_FEATURE_NEON    ) { features |= SkCpu::NEON    ; }
+        if (android_features & ANDROID_CPU_ARM_FEATURE_NEON_FMA) { features |= SkCpu::NEON_FMA; }
+        if (android_features & ANDROID_CPU_ARM_FEATURE_VFP_FP16) { features |= SkCpu::VFP_FP16; }
+        return features;
+    }
+
+#else
+    static uint32_t read_cpu_features() {
+        return 0;
+    }
+
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    SK_DECLARE_STATIC_ONCE_PTR(uint32_t, gCachedCpuFeatures);
+    uint32_t SkCpu::RuntimeCpuFeatures() {
+        return *gCachedCpuFeatures.get([]{ return new uint32_t{read_cpu_features()}; });
+    }
+
+#else
+    const uint32_t SkCpu::gCachedCpuFeatures = read_cpu_features();
+
+#endif