ubsan shift fixes

src/core/SkEdge.cpp

 
 /*
  * Copyright 2006 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 "SkEdge.h"
 #include "SkFDot6.h"
 #include "SkMath.h"
 
 /*
     In setLine, setQuadratic, setCubic, the first thing we do is to convert
     the points into FDot6. This is modulated by the shift parameter, which
     will either be 0, or something like 2 for antialiasing.
 
     In the float case, we want to turn the float into .6 by saying pt * 64,
     or pt * 256 for antialiasing. This is implemented as 1 << (shift + 6).
 
     In the fixed case, we want to turn the fixed into .6 by saying pt >> 10,
     or pt >> 8 for antialiasing. This is implemented as pt >> (10 - shift).
 */
 
 static inline SkFixed SkFDot6ToFixedDiv2(SkFDot6 value) {
     // we want to return SkFDot6ToFixed(value >> 1), but we don't want to throw
     // away data in value, so just perform a modify up-shift
-    return value << (16 - 6 - 1);
+    return SkLeftShift(value, 16 - 6 - 1);
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 int SkEdge::setLine(const SkPoint& p0, const SkPoint& p1, const SkIRect* clip,
                     int shift) {
     SkFDot6 x0, y0, x1, y1;
 
     {
 #ifdef SK_RASTERIZE_EVEN_ROUNDING
@@ skipping 167 matching lines @@
 
     int top = SkFDot6Round(y0);
     int bot = SkFDot6Round(y2);
 
     // are we a zero-height quad (line)?
     if (top == bot)
         return 0;
 
     // compute number of steps needed (1 << shift)
     {
-        SkFDot6 dx = ((x1 << 1) - x0 - x2) >> 2;
-        SkFDot6 dy = ((y1 << 1) - y0 - y2) >> 2;
+        SkFDot6 dx = (SkLeftShift(x1, 1) - x0 - x2) >> 2;
+        SkFDot6 dy = (SkLeftShift(y1, 1) - y0 - y2) >> 2;
         shift = diff_to_shift(dx, dy);
         SkASSERT(shift >= 0);
     }
     // need at least 1 subdivision for our bias trick
     if (shift == 0) {
         shift = 1;
     } else if (shift > MAX_COEFF_SHIFT) {
         shift = MAX_COEFF_SHIFT;
     }
 
@@ skipping 76 matching lines @@
     fQy         = newy;
     fQDx        = dx;
     fQDy        = dy;
     fCurveCount = SkToS8(count);
     return success;
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 static inline int SkFDot6UpShift(SkFDot6 x, int upShift) {
-    SkASSERT((x << upShift >> upShift) == x);
-    return x << upShift;
+    SkASSERT((SkLeftShift(x, upShift) >> upShift) == x);
+    return SkLeftShift(x, upShift);
 }
 
 /*  f(1/3) = (8a + 12b + 6c + d) / 27
     f(2/3) = (a + 6b + 12c + 8d) / 27
 
     f(1/3)-b = (8a - 15b + 6c + d) / 27
     f(2/3)-c = (a + 6b - 15c + 8d) / 27
 
     use 16/512 to approximate 1/27
 */
@@ skipping 69 matching lines @@
         compute coefficients with a 3*, so the safest upshift is really 6
     */
     int upShift = 6;    // largest safe value
     int downShift = shift + upShift - 10;
     if (downShift < 0) {
         downShift = 0;
         upShift = 10 - shift;
     }
 
     fWinding    = SkToS8(winding);
-    fCurveCount = SkToS8(-1 << shift);
+    fCurveCount = SkToS8(SkLeftShift(-1, shift));
     fCurveShift = SkToU8(shift);
     fCubicDShift = SkToU8(downShift);
 
     SkFixed B = SkFDot6UpShift(3 * (x1 - x0), upShift);
     SkFixed C = SkFDot6UpShift(3 * (x0 - x1 - x1 + x2), upShift);
     SkFixed D = SkFDot6UpShift(x3 + 3 * (x1 - x2) - x0, upShift);
 
     fCx     = SkFDot6ToFixed(x0);
     fCDx    = B + (C >> shift) + (D >> 2*shift);    // biased by shift
     fCDDx   = 2*C + (3*D >> (shift - 1));           // biased by 2*shift
@@ skipping 53 matching lines @@
         success = this->updateLine(oldx, oldy, newx, newy);
         oldx = newx;
         oldy = newy;
     } while (count < 0 && !success);
 
     fCx         = newx;
     fCy         = newy;
     fCurveCount = SkToS8(count);
     return success;
 }