Prevent deopt when assigning double values to typed arrays

src/hydrogen-instructions.cc

 // 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
@@ skipping 41 matching lines @@
 HYDROGEN_CONCRETE_INSTRUCTION_LIST(DEFINE_COMPILE)
 #undef DEFINE_COMPILE
 
 
 const char* Representation::Mnemonic() const {
   switch (kind_) {
     case kNone: return "v";
     case kTagged: return "t";
     case kDouble: return "d";
     case kInteger32: return "i";
+    case kTruncatedInteger32: return "ti";
+    case kClampedRoundedUInteger8: return "cri";
     case kExternal: return "x";
     case kNumRepresentations:
       UNREACHABLE();
       return NULL;
   }
   UNREACHABLE();
   return NULL;
 }
 
 
@@ skipping 648 matching lines @@
 void HTypeofIs::PrintDataTo(StringStream* stream) {
   value()->PrintNameTo(stream);
   stream->Add(" == ");
   stream->Add(type_literal_->ToAsciiVector());
 }
 
 
 void HChange::PrintDataTo(StringStream* stream) {
   HUnaryOperation::PrintDataTo(stream);
   stream->Add(" %s to %s", from_.Mnemonic(), to().Mnemonic());
-
-  if (CanTruncateToInt32()) stream->Add(" truncating-int32");
   if (CheckFlag(kBailoutOnMinusZero)) stream->Add(" -0?");
 }
 
 
 HCheckInstanceType* HCheckInstanceType::NewIsJSObjectOrJSFunction(
     HValue* value)  {
   STATIC_ASSERT((LAST_JS_OBJECT_TYPE + 1) == JS_FUNCTION_TYPE);
   return new HCheckInstanceType(value, FIRST_JS_OBJECT_TYPE, JS_FUNCTION_TYPE);
 }
 
@@ skipping 47 matching lines @@
   if (has_int32_value_) {
     Range* result = new Range(int32_value_, int32_value_);
     result->set_can_be_minus_zero(false);
     return result;
   }
   return HValue::InferRange();
 }
 
 
 Range* HPhi::InferRange() {
-  if (representation().IsInteger32()) {
+  if (representation().IsInteger()) {
     if (block()->IsLoopHeader()) {
-      Range* range = new Range(kMinInt, kMaxInt);
+      Range* range = representation().IsClampedRoundedInteger8()
+          ? new Range(0, 255)
+          : new Range(kMinInt, kMaxInt);
       return range;
     } else {
       Range* range = OperandAt(0)->range()->Copy();
       for (int i = 1; i < OperandCount(); ++i) {
         range->Union(OperandAt(i)->range());
       }
       return range;
     }
   } else {
     return HValue::InferRange();
   }
 }
 
 
 Range* HAdd::InferRange() {
-  if (representation().IsInteger32()) {
+  if (representation().IsInteger()) {
     Range* a = left()->range();
     Range* b = right()->range();
     Range* res = a->Copy();
     if (!res->AddAndCheckOverflow(b)) {
       ClearFlag(kCanOverflow);
     }
     bool m0 = a->CanBeMinusZero() && b->CanBeMinusZero();
     res->set_can_be_minus_zero(m0);
     return res;
   } else {
     return HValue::InferRange();
   }
 }
 
 
 Range* HSub::InferRange() {
-  if (representation().IsInteger32()) {
+  if (representation().IsInteger()) {
     Range* a = left()->range();
     Range* b = right()->range();
     Range* res = a->Copy();
     if (!res->SubAndCheckOverflow(b)) {
       ClearFlag(kCanOverflow);
     }
     res->set_can_be_minus_zero(a->CanBeMinusZero() && b->CanBeZero());
     return res;
   } else {
     return HValue::InferRange();
   }
 }
 
 
 Range* HMul::InferRange() {
-  if (representation().IsInteger32()) {
+  if (representation().IsInteger()) {
     Range* a = left()->range();
     Range* b = right()->range();
     Range* res = a->Copy();
     if (!res->MulAndCheckOverflow(b)) {
       ClearFlag(kCanOverflow);
     }
     bool m0 = (a->CanBeZero() && b->CanBeNegative()) ||
         (a->CanBeNegative() && b->CanBeZero());
     res->set_can_be_minus_zero(m0);
     return res;
   } else {
     return HValue::InferRange();
   }
 }
 
 
 Range* HDiv::InferRange() {
-  if (representation().IsInteger32()) {
+  if (representation().IsInteger()) {
     Range* result = new Range();
     if (left()->range()->CanBeMinusZero()) {
       result->set_can_be_minus_zero(true);
     }
 
     if (left()->range()->CanBeZero() && right()->range()->CanBeNegative()) {
       result->set_can_be_minus_zero(true);
     }
 
     if (right()->range()->Includes(-1) && left()->range()->Includes(kMinInt)) {
       SetFlag(HValue::kCanOverflow);
     }
 
     if (!right()->range()->CanBeZero()) {
       ClearFlag(HValue::kCanBeDivByZero);
     }
     return result;
   } else {
     return HValue::InferRange();
   }
 }
 
 
 Range* HMod::InferRange() {
-  if (representation().IsInteger32()) {
+  if (representation().IsInteger()) {
     Range* a = left()->range();
     Range* result = new Range();
     if (a->CanBeMinusZero() || a->CanBeNegative()) {
       result->set_can_be_minus_zero(true);
     }
     if (!right()->range()->CanBeZero()) {
       ClearFlag(HValue::kCanBeDivByZero);
     }
     return result;
   } else {
@@ skipping 124 matching lines @@
     double roundtrip_value = static_cast<double>(static_cast<int32_t>(n));
     has_int32_value_ = BitCast<int64_t>(roundtrip_value) == BitCast<int64_t>(n);
     if (has_int32_value_) int32_value_ = static_cast<int32_t>(n);
     double_value_ = n;
     has_double_value_ = true;
   }
 }
 
 
 HConstant* HConstant::CopyToRepresentation(Representation r) const {
-  if (r.IsInteger32() && !has_int32_value_) return NULL;
+  if (r.IsInteger() && !has_int32_value_) return NULL;
+  if (r.IsClampedRoundedInteger8() &&
+      (int32_value_ > 255 || int32_value_ < 0)) return NULL;
   if (r.IsDouble() && !has_double_value_) return NULL;
   return new HConstant(handle_, r);
 }
 
 
 HConstant* HConstant::CopyToTruncatedInt32() const {
   if (!has_double_value_) return NULL;
   int32_t truncated = NumberToInt32(*handle_);
   return new HConstant(FACTORY->NewNumberFromInt(truncated),
-                       Representation::Integer32());
+                       Representation::TruncatedInteger32());
 }
 
 
+HConstant* HConstant::CopyToClampedRoundedUInt8() const {
+  if (!has_double_value_) return NULL;
+  int32_t clamped_rounded = NumberToClampedUInt8(*handle_);
+  return new HConstant(FACTORY->NewNumberFromInt(clamped_rounded),
+                       Representation::ClampedRoundedUInteger8());
+}
+
+
 bool HConstant::ToBoolean() const {
   // Converts the constant's boolean value according to
   // ECMAScript section 9.2 ToBoolean conversion.
   if (HasInteger32Value()) return Integer32Value() != 0;
   if (HasDoubleValue()) {
     double v = DoubleValue();
     return v != 0 && !isnan(v);
   }
   if (handle()->IsTrue()) return true;
   if (handle()->IsFalse()) return false;
@@ skipping 442 matching lines @@
 
 
 HType HSar::CalculateInferredType() {
   return HType::TaggedNumber();
 }
 
 
 HValue* HUnaryMathOperation::EnsureAndPropagateNotMinusZero(
     BitVector* visited) {
   visited->Add(id());
-  if (representation().IsInteger32() &&
-      !value()->representation().IsInteger32()) {
+  if (representation().IsInteger() &&
+      !value()->representation().IsInteger()) {
     if (value()->range() == NULL || value()->range()->CanBeMinusZero()) {
       SetFlag(kBailoutOnMinusZero);
     }
   }
-  if (RequiredInputRepresentation(0).IsInteger32() &&
-      representation().IsInteger32()) {
+  if (RequiredInputRepresentation(0).IsInteger() &&
+      representation().IsInteger()) {
     return value();
   }
   return NULL;
 }
 
 
 
 HValue* HChange::EnsureAndPropagateNotMinusZero(BitVector* visited) {
   visited->Add(id());
-  if (from().IsInteger32()) return NULL;
-  if (CanTruncateToInt32()) return NULL;
+  if (from().IsInteger()) return NULL;
+  if (to().IsTruncatedInteger32() || to().IsClampedRoundedInteger8()) {
+    return NULL;
+  }
   if (value()->range() == NULL || value()->range()->CanBeMinusZero()) {
     SetFlag(kBailoutOnMinusZero);
   }
-  ASSERT(!from().IsInteger32() || !to().IsInteger32());
+  ASSERT(!from().IsInteger() || !to().IsInteger());
   return NULL;
 }
 
 
 HValue* HMod::EnsureAndPropagateNotMinusZero(BitVector* visited) {
   visited->Add(id());
   if (range() == NULL || range()->CanBeMinusZero()) {
     SetFlag(kBailoutOnMinusZero);
     return left();
   }
@@ skipping 99 matching lines @@
 
 
 void HCheckPrototypeMaps::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal