centralize VECTORCALL as SK_VECTORCALL

src/core/SkLinearBitmapPipeline_core.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLinearBitmapPipeline_core_DEFINED
 #define SkLinearBitmapPipeline_core_DEFINED
 
 #include <cmath>
 #include "SkNx.h"
 
 // New bilerp strategy:
 // Pass through on bilerpList4 and bilerpListFew (analogs to pointList), introduce bilerpEdge
 // which takes 4 points. If the sample spans an edge, then break it into a bilerpEdge. Bilerp
 // span then becomes a normal span except in special cases where an extra Y is given. The bilerp
 // need to stay single point calculations until the tile layer.
 // TODO:
 //  - edge span predicate.
 //  - introduce new point API
 //  - Add tile for new api.
 
-// Tweak ABI of functions that pass Sk4f by value to pass them via registers.
-#if defined(_MSC_VER) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
-    #define VECTORCALL __vectorcall
-#elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON)
-    #define VECTORCALL __attribute__((pcs("aapcs-vfp")))
-#else
-    #define VECTORCALL
-#endif
-
 namespace {
 struct X {
     explicit X(SkScalar val) : fVal{val} { }
     explicit X(SkPoint pt)   : fVal{pt.fX} { }
     explicit X(SkSize s)     : fVal{s.fWidth} { }
     explicit X(SkISize s)    : fVal((SkScalar)s.fWidth) { }
     operator SkScalar () const {return fVal;}
 private:
     SkScalar fVal;
 };
@@ skipping 144 matching lines @@
     }
 }
 }  // namespace
 
 class SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     virtual ~PointProcessorInterface() { }
     // Take the first n (where 0 < n && n < 4) items from xs and ys and sample those points. For
     // nearest neighbor, that means just taking the floor xs and ys. For bilerp, this means
     // to expand the bilerp filter around the point and sample using that filter.
-    virtual void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
+    virtual void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
     // Same as pointListFew, but n = 4.
-    virtual void VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
+    virtual void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
     // A span is a compact form of sample points that are obtained by mapping points from
     // destination space to source space. This is used for horizontal lines only, and is mainly
     // used to take advantage of memory coherence for horizontal spans.
     virtual void pointSpan(Span span) = 0;
 };
 
 class SkLinearBitmapPipeline::SampleProcessorInterface
     : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     // Used for nearest neighbor when scale factor is 1.0. The span can just be repeated with no
     // edge pixel alignment problems. This is for handling a very common case.
     virtual void repeatSpan(Span span, int32_t repeatCount) = 0;
 
     // The x's and y's are setup in the following order:
     // +--------+--------+
     // |        |        |
     // |  px00  |  px10  |
     // |    0   |    1   |
     // +--------+--------+
     // |        |        |
     // |  px01  |  px11  |
     // |    2   |    3   |
     // +--------+--------+
     // These pixels coordinates are arranged in the following order in xs and ys:
     // px00  px10  px01  px11
-    virtual void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) = 0;
+    virtual void SK_VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) = 0;
 
     // A span represents sample points that have been mapped from destination space to source
     // space. Each sample point is then expanded to the four bilerp points by add +/- 0.5. The
     // resulting Y values my be off the tile. When y +/- 0.5 are more than 1 apart because of
     // tiling, the second Y is used to denote the retiled Y value.
     virtual void bilerpSpan(Span span, SkScalar y) = 0;
 };
 
 class SkLinearBitmapPipeline::DestinationInterface {
 public:
     virtual ~DestinationInterface() { }
     // Count is normally not needed, but in these early stages of development it is useful to
     // check bounds.
     // TODO(herb): 4/6/2016 - remove count when code is stable.
     virtual void setDestination(void* dst, int count) = 0;
 };
 
 class SkLinearBitmapPipeline::BlendProcessorInterface
     : public SkLinearBitmapPipeline::DestinationInterface {
 public:
-    virtual void VECTORCALL blendPixel(Sk4f pixel0) = 0;
-    virtual void VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
+    virtual void SK_VECTORCALL blendPixel(Sk4f pixel0) = 0;
+    virtual void SK_VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
 };
 
 #endif // SkLinearBitmapPipeline_core_DEFINED