Prevent deopt when assigning double values to typed arrays

src/conversions-inl.h

-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
@@ skipping 58 matching lines @@
 }
 
 
 static inline double DoubleToInteger(double x) {
   if (isnan(x)) return 0;
   if (!isfinite(x) || x == 0) return x;
   return (x >= 0) ? floor(x) : ceil(x);
 }
 
 
+uint8_t ClampToUInt8(double double_value) {
+  if (!(double_value > 0)) {
+    // NaN and less than zero clamp to zero.
+    return 0;
+  } else if (double_value > 255) {
+    // Greater than 255 clamp to 255.
+    return 255;
+  } else {
+    // Other doubles are rounded to the nearest integer.
+    return static_cast<uint8_t>(double_value + 0.5);
+  }
+}
+
+
 int32_t NumberToInt32(Object* number) {
   if (number->IsSmi()) return Smi::cast(number)->value();
   return DoubleToInt32(number->Number());
 }
 
 
 uint32_t NumberToUint32(Object* number) {
   if (number->IsSmi()) return Smi::cast(number)->value();
   return DoubleToUint32(number->Number());
 }
 
 
+uint8_t NumberToClampedUInt8(Object* number)
+{
+  if (number->IsSmi()) {
+    int32_t value = Smi::cast(number)->value();
+    if (value < 0) {
+      return 0;
+    } else if (value > 255) {
+      return 255;
+    } else {
+      return static_cast<uint8_t>(value);
+    }
+  } else if (number->IsHeapNumber()) {
+    return ClampToUInt8(number->Number());
+  } else {
+    // Clamp undefined to zero (default). All other types have been
+    // converted to a number type further up in the call chain.
+    ASSERT(number->IsUndefined());
+    return 0;
+  }
+}
+
+
 int32_t DoubleToInt32(double x) {
   int32_t i = FastD2I(x);
   if (FastI2D(i) == x) return i;
   static const double two32 = 4294967296.0;
   static const double two31 = 2147483648.0;
   if (!isfinite(x) || x == 0) return 0;
   if (x < 0 || x >= two32) x = modulo(x, two32);
   x = (x >= 0) ? floor(x) : ceil(x) + two32;
   return (int32_t) ((x >= two31) ? x - two32 : x);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CONVERSIONS_INL_H_