The compiler can generate smulbb perfectly well nowadays.

include/core/SkMath.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkMath_DEFINED
@@ skipping 139 matching lines @@
  *  Returns true if value is a power of 2. Does not explicitly check for
  *  value <= 0.
  */
 template <typename T> inline bool SkIsPow2(T value) {
     return (value & (value - 1)) == 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
- *  SkMulS16(a, b) multiplies a * b, but requires that a and b are both int16_t.
- *  With this requirement, we can generate faster instructions on some
- *  architectures.
- */
-#ifdef SK_ARM_HAS_EDSP
-    static inline int32_t SkMulS16(S16CPU x, S16CPU y) {
-        SkASSERT((int16_t)x == x);
-        SkASSERT((int16_t)y == y);
-        int32_t product;
-        asm("smulbb %0, %1, %2 \n"
-            : "=r"(product)
-            : "r"(x), "r"(y)
-            );
-        return product;
-    }
-#else
-    #ifdef SK_DEBUG
-        static inline int32_t SkMulS16(S16CPU x, S16CPU y) {
-            SkASSERT((int16_t)x == x);
-            SkASSERT((int16_t)y == y);
-            return x * y;
-        }
-    #else
-        #define SkMulS16(x, y)  ((x) * (y))
-    #endif
-#endif
-
-/**
  *  Return a*b/((1 << shift) - 1), rounding any fractional bits.
  *  Only valid if a and b are unsigned and <= 32767 and shift is > 0 and <= 8
  */
 static inline unsigned SkMul16ShiftRound(U16CPU a, U16CPU b, int shift) {
     SkASSERT(a <= 32767);
     SkASSERT(b <= 32767);
     SkASSERT(shift > 0 && shift <= 8);
-    unsigned prod = SkMulS16(a, b) + (1 << (shift - 1));
+    unsigned prod = a*b + (1 << (shift - 1));
     return (prod + (prod >> shift)) >> shift;
 }
 
 /**
  *  Return a*b/255, rounding any fractional bits.
  *  Only valid if a and b are unsigned and <= 32767.
  */
 static inline U8CPU SkMulDiv255Round(U16CPU a, U16CPU b) {
     SkASSERT(a <= 32767);
     SkASSERT(b <= 32767);
-    unsigned prod = SkMulS16(a, b) + 128;
+    unsigned prod = a*b + 128;
     return (prod + (prod >> 8)) >> 8;
 }
 
 /**
  * Stores numer/denom and numer%denom into div and mod respectively.
  */
 template <typename In, typename Out>
 inline void SkTDivMod(In numer, In denom, Out* div, Out* mod) {
 #ifdef SK_CPU_ARM32
     // If we wrote this as in the else branch, GCC won't fuse the two into one
     // divmod call, but rather a div call followed by a divmod.  Silly!  This
     // version is just as fast as calling __aeabi_[u]idivmod manually, but with
     // prettier code.
     //
     // This benches as around 2x faster than the code in the else branch.
     const In d = numer/denom;
     *div = static_cast<Out>(d);
     *mod = static_cast<Out>(numer-d*denom);
 #else
     // On x86 this will just be a single idiv.
     *div = static_cast<Out>(numer/denom);
     *mod = static_cast<Out>(numer%denom);
 #endif
 }
 
 #endif