Cleanup the ARM blitrow optimizations

src/opts/SkBlitRow_opts_arm.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.h"
-
 #include "SkBlitMask.h"
 #include "SkBlitRow.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkMathPriv.h"
 #include "SkUtils.h"
+#include "SkUtilsArm.h"
 
 #include "SkCachePreload_arm.h"
 
+// Define USE_NEON_CODE to indicate that we need to build NEON routines
+#define USE_NEON_CODE  (!SK_ARM_NEON_IS_NONE)
+
+// Define USE_ARM_CODE to indicate that we need to build ARM routines
+#define USE_ARM_CODE   (!SK_ARM_NEON_IS_ALWAYS)
+
+#if USE_NEON_CODE
+  #include "SkBlitRow_opts_arm_neon.h"
+#endif
+
 #if USE_ARM_CODE
 
 static void S32A_D565_Opaque(uint16_t* SK_RESTRICT dst,
                              const SkPMColor* SK_RESTRICT src, int count,
                              U8CPU alpha, int /*x*/, int /*y*/) {
     SkASSERT(255 == alpha);
 
     asm volatile (
                   "1:                                   \n\t"
                   "ldr     r3, [%[src]], #4             \n\t"
@@ skipping 149 matching lines @@
                   /* ----------------- */
                   "str    r7, [%[dst]], #4           \n\t" /* *dst = r7, increment dst by one (times 4) */
                   /* ----------------- */
 
                   "3:                                \n\t" /* <exit> */
                   : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
                   :
                   : "cc", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "ip", "memory"
                   );
 }
-#endif // USE_ARM_CODE
 
 /*
  * ARM asm version of S32A_Blend_BlitRow32
  */
-// This version is also used by the NEON procs table, so always compile it
 void S32A_Blend_BlitRow32_arm(SkPMColor* SK_RESTRICT dst,
                               const SkPMColor* SK_RESTRICT src,
                               int count, U8CPU alpha) {
     asm volatile (
                   "cmp    %[count], #0               \n\t" /* comparing count with 0 */
                   "beq    3f                         \n\t" /* if zero exit */
 
                   "mov    r12, #0xff                 \n\t" /* load the 0xff mask in r12 */
                   "orr    r12, r12, r12, lsl #16     \n\t" /* convert it to 0xff00ff in r12 */
 
@@ skipping 120 matching lines @@
                   "3:                                \n\t" /* <exit> */
                   : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count), [alpha] "+r" (alpha)
                   :
                   : "cc", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "memory"
                   );
 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#if USE_ARM_CODE
-const SkBlitRow::Proc sk_blitrow_platform_565_procs_arm[] = {
+static const SkBlitRow::Proc sk_blitrow_platform_565_procs_arm[] = {
     // no dither
     // NOTE: For the functions below, we don't have a special version
     //       that assumes that each source pixel is opaque. But our S32A is
     //       still faster than the default, so use it.
     S32A_D565_Opaque,   // S32_D565_Opaque
     NULL,               // S32_D565_Blend
     S32A_D565_Opaque,   // S32A_D565_Opaque
     NULL,               // S32A_D565_Blend
 
     // dither
     NULL,   // S32_D565_Opaque_Dither
     NULL,   // S32_D565_Blend_Dither
     NULL,   // S32A_D565_Opaque_Dither
     NULL,   // S32A_D565_Blend_Dither
 };
 
-const SkBlitRow::Proc32 sk_blitrow_platform_32_procs_arm[] = {
+static const SkBlitRow::Proc32 sk_blitrow_platform_32_procs_arm[] = {
     NULL,   // S32_Opaque,
     NULL,   // S32_Blend,
     S32A_Opaque_BlitRow32_arm,   // S32A_Opaque,
     S32A_Blend_BlitRow32_arm     // S32A_Blend
 };
-#endif
+
+#endif // USE_ARM_CODE
 
 SkBlitRow::Proc SkBlitRow::PlatformProcs565(unsigned flags) {
     return SK_ARM_NEON_WRAP(sk_blitrow_platform_565_procs_arm)[flags];
 }
 
 SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
     return SK_ARM_NEON_WRAP(sk_blitrow_platform_32_procs_arm)[flags];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 10 matching lines @@
 
 SkBlitMask::BlitLCD16RowProc SkBlitMask::PlatformBlitRowProcs16(bool isOpaque) {
     return NULL;
 }
 
 SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkBitmap::Config dstConfig,
                                                  SkMask::Format maskFormat,
                                                  RowFlags flags) {
     return NULL;
 }