Narrow disabled vectorization further to just ConvolveHorizontally.

src/core/SkConvolver.cpp

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "SkConvolver.h"
 #include "SkSize.h"
 #include "SkTypes.h"
 
 namespace {
 
@@ skipping 140 matching lines @@
             // Store the new pixel.
             outRow[outX * 4 + 0] = ClampTo8(accum[0]);
             outRow[outX * 4 + 1] = ClampTo8(accum[1]);
             outRow[outX * 4 + 2] = ClampTo8(accum[2]);
             if (hasAlpha) {
                 outRow[outX * 4 + 3] = ClampTo8(accum[3]);
             }
         }
     }
 
+    // There's a bug somewhere here with GCC autovectorization (-ftree-vectorize) on 32 bit builds.
+    // Dropping to -O2 disables -ftree-vectorize.  http://skbug.com/2575
+    #if defined(__i386) && SK_HAS_ATTRIBUTE(optimize) && defined(SK_RELEASE)
+        #define SK_MAYBE_DISABLE_VECTORIZATION __attribute__((optimize("O2")))
+    #else
+        #define SK_MAYBE_DISABLE_VECTORIZATION
+    #endif
+
+    SK_MAYBE_DISABLE_VECTORIZATION
+    static void ConvolveHorizontallyAlpha(const unsigned char* srcData,
+                                          const SkConvolutionFilter1D& filter,
+                                          unsigned char* outRow) {
+        return ConvolveHorizontally<true>(srcData, filter, outRow);
+    }
+
+    SK_MAYBE_DISABLE_VECTORIZATION
+    static void ConvolveHorizontallyNoAlpha(const unsigned char* srcData,
+                                            const SkConvolutionFilter1D& filter,
+                                            unsigned char* outRow) {
+        return ConvolveHorizontally<false>(srcData, filter, outRow);
+    }
+
+    #undef SK_MAYBE_DISABLE_VECTORIZATION
+
+
 // Does vertical convolution to produce one output row. The filter values and
 // length are given in the first two parameters. These are applied to each
 // of the rows pointed to in the |sourceDataRows| array, with each row
 // being |pixelWidth| wide.
 //
 // The output must have room for |pixelWidth * 4| bytes.
 template<bool hasAlpha>
     void ConvolveVertically(const SkConvolutionFilter1D::ConvolutionFixed* filterValues,
                             int filterLength,
                             unsigned char* const* sourceDataRows,
@@ skipping 152 matching lines @@
     *filterOffset = filter.fOffset;
     *filterLength = filter.fTrimmedLength;
     *specifiedFilterlength = filter.fLength;
     if (filter.fTrimmedLength == 0) {
         return NULL;
     }
 
     return &fFilterValues[filter.fDataLocation];
 }
 
-// There's a bug somewhere in here with GCC autovectorization (-ftree-vectorize) on 32 bit builds.
-// Dropping to -O2 disables -ftree-vectorize.  http://skbug.com/2575
-#if defined(__i386) && SK_HAS_ATTRIBUTE(optimize) && defined(SK_RELEASE)
-    __attribute__((optimize("O2")))
-#endif
 void BGRAConvolve2D(const unsigned char* sourceData,
                     int sourceByteRowStride,
                     bool sourceHasAlpha,
                     const SkConvolutionFilter1D& filterX,
                     const SkConvolutionFilter1D& filterY,
                     int outputByteRowStride,
                     unsigned char* output,
                     const SkConvolutionProcs& convolveProcs,
                     bool useSimdIfPossible) {
 
@@ skipping 70 matching lines @@
             } else {
                 // Check if we need to avoid SSE2 for this row.
                 if (convolveProcs.fConvolveHorizontally &&
                     nextXRow < lastFilterOffset + lastFilterLength -
                     avoidSimdRows) {
                     convolveProcs.fConvolveHorizontally(
                         &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                         filterX, rowBuffer.advanceRow(), sourceHasAlpha);
                 } else {
                     if (sourceHasAlpha) {
-                        ConvolveHorizontally<true>(
+                        ConvolveHorizontallyAlpha(
                             &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                             filterX, rowBuffer.advanceRow());
                     } else {
-                        ConvolveHorizontally<false>(
+                        ConvolveHorizontallyNoAlpha(
                             &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                             filterX, rowBuffer.advanceRow());
                     }
                 }
                 nextXRow++;
             }
         }
 
         // Compute where in the output image this row of final data will go.
         unsigned char* curOutputRow = &output[outY * outputByteRowStride];
@@ skipping 14 matching lines @@
                                                filterX.numValues(), curOutputRow,
                                                sourceHasAlpha);
         } else {
             ConvolveVertically(filterValues, filterLength,
                                firstRowForFilter,
                                filterX.numValues(), curOutputRow,
                                sourceHasAlpha);
         }
     }
 }