SK_CPU_ARM --> SK_CPU_ARM32

src/opts/SkBlitRow_opts_arm_neon.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitRow_opts_arm_neon.h"
 
 #include "SkBlitMask.h"
 #include "SkBlitRow.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkMathPriv.h"
 #include "SkUtils.h"
 
 #include "SkColor_opts_neon.h"
 #include <arm_neon.h>
 
-#ifdef SK_CPU_ARM
+#ifdef SK_CPU_ARM32
 void S32_D565_Opaque_neon(uint16_t* SK_RESTRICT dst,
                            const SkPMColor* SK_RESTRICT src, int count,
                            U8CPU alpha, int /*x*/, int /*y*/) {
     SkASSERT(255 == alpha);
 
     while (count >= 8) {
         uint8x8x4_t vsrc;
         uint16x8_t vdst;
 
         // Load
@@ skipping 883 matching lines @@
         vsrc_wide = vmovl_u8(vsrc);
         vsrc_wide = vmulq_u16(vsrc_wide, vdupq_n_u16(src_scale));
         vdst_wide = vmull_u8(vdst, vdup_n_u8(dst_scale));
         vres = vshrn_n_u16(vdst_wide, 8) + vshrn_n_u16(vsrc_wide, 8);
 
         // Store
         vst1_lane_u32(dst, vreinterpret_u32_u8(vres), 0);
     }
 }
 
-#ifdef SK_CPU_ARM
+#ifdef SK_CPU_ARM32
 void S32A_Blend_BlitRow32_neon(SkPMColor* SK_RESTRICT dst,
                          const SkPMColor* SK_RESTRICT src,
                          int count, U8CPU alpha) {
 
     SkASSERT(255 >= alpha);
 
     if (count <= 0) {
         return;
     }
 
@@ skipping 463 matching lines @@
 
         vcolor = vdupq_n_u32(color);
 
         // scale numerical interval [0-255], so load as 8 bits
         vscale = vdup_n_u8(scale);
 
         do {
             // load src color, 8 pixels, 4 64 bit registers
             // (and increment src).
             uint32x2x4_t vsrc;
-#if defined(SK_CPU_ARM) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
+#if defined(SK_CPU_ARM32) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
             asm (
                 "vld1.32    %h[vsrc], [%[src]]!"
                 : [vsrc] "=w" (vsrc), [src] "+r" (src)
                 : :
             );
 #else // 64bit targets and Clang
             vsrc.val[0] = vld1_u32(src);
             vsrc.val[1] = vld1_u32(src+2);
             vsrc.val[2] = vld1_u32(src+4);
             vsrc.val[3] = vld1_u32(src+6);
@@ skipping 21 matching lines @@
 
             // adding back the color, using 128 bit registers.
             uint32x4x2_t vdst;
             vdst.val[0] = vreinterpretq_u32_u8(vres.val[0] +
                                                vreinterpretq_u8_u32(vcolor));
             vdst.val[1] = vreinterpretq_u32_u8(vres.val[1] +
                                                vreinterpretq_u8_u32(vcolor));
 
             // store back the 8 calculated pixels (2 128 bit
             // registers), and increment dst.
-#if defined(SK_CPU_ARM) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
+#if defined(SK_CPU_ARM32) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
             asm (
                 "vst1.32    %h[vdst], [%[dst]]!"
                 : [dst] "+r" (dst)
                 : [vdst] "w" (vdst)
                 : "memory"
             );
 #else // 64bit targets and Clang
             vst1q_u32(dst, vdst.val[0]);
             vst1q_u32(dst+4, vdst.val[1]);
             dst += 8;
 #endif
             count -= 8;
 
         } while (count >= 8);
     }
 
     while (count > 0) {
         *dst = color + SkAlphaMulQ(*src, scale);
         src += 1;
         dst += 1;
         count--;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkBlitRow::Proc sk_blitrow_platform_565_procs_arm_neon[] = {
-#ifdef SK_CPU_ARM
+#ifdef SK_CPU_ARM32
     // no dither
     S32_D565_Opaque_neon,
     S32_D565_Blend_neon,
     S32A_D565_Opaque_neon,
     S32A_D565_Blend_neon,
 
     // dither
     S32_D565_Opaque_Dither_neon,
     S32_D565_Blend_Dither_neon,
     S32A_D565_Opaque_Dither_neon,
@@ skipping 15 matching lines @@
      * the performance will almost certainly be worse.  However, for many
      * common cases the performance is equivalent or better than the standard
      * case where we do not inspect the src alpha.
      */
 #if SK_A32_SHIFT == 24
     // This proc assumes the alpha value occupies bits 24-32 of each SkPMColor
     S32A_Opaque_BlitRow32_neon_src_alpha,   // S32A_Opaque,
 #else
     S32A_Opaque_BlitRow32_neon,     // S32A_Opaque,
 #endif
-#ifdef SK_CPU_ARM
+#ifdef SK_CPU_ARM32
     S32A_Blend_BlitRow32_neon        // S32A_Blend
 #else
     NULL
 #endif
 };