Prevent deopt when assigning double values to typed arrays

src/hydrogen-instructions.h

 // 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 240 matching lines @@
   Range* next_;
   bool can_be_minus_zero_;
 };
 
 
 class Representation {
  public:
   enum Kind {
     kNone,
     kTagged,
+    // Specializations
+    kTruncatedInteger32,
+    kClampedRoundedUInteger8,
+    // Terminal specializations
+    kInteger32,
     kDouble,
-    kInteger32,
     kExternal,
-    kNumRepresentations
+    // Derived
+    kNumRepresentations,
+    kFirstSpecialization = kTruncatedInteger32,
+    kLastSpecialization = kExternal,
+    kNumberOfSpecialization = kLastSpecialization -
+        kFirstSpecialization + 1,
+    kFirstTerminalSpecialization = kInteger32,
+    kLastTerminalSpecialization = kExternal,
+    kNumberOfTerminalSpecialization =
+        kLastTerminalSpecialization - kFirstTerminalSpecialization + 1
   };
 
   Representation() : kind_(kNone) { }
 
   static Representation None() { return Representation(kNone); }
   static Representation Tagged() { return Representation(kTagged); }
+  static Representation Double() { return Representation(kDouble); }
   static Representation Integer32() { return Representation(kInteger32); }
-  static Representation Double() { return Representation(kDouble); }
+  static Representation TruncatedInteger32() {
+    return Representation(kTruncatedInteger32);
+  }
+  static Representation ClampedRoundedUInteger8() {
+    return Representation(kClampedRoundedUInteger8);
+  }
   static Representation External() { return Representation(kExternal); }
 
   bool Equals(const Representation& other) {
     return kind_ == other.kind_;
   }
 
   Kind kind() const { return static_cast<Kind>(kind_); }
   bool IsNone() const { return kind_ == kNone; }
   bool IsTagged() const { return kind_ == kTagged; }
-  bool IsInteger32() const { return kind_ == kInteger32; }
+  bool IsInteger32X() const { return kind_ == kInteger32; }
+  bool IsTruncatedInteger32() const { return kind_ == kTruncatedInteger32; }
+  bool IsClampedRoundedInteger8() const {
+    return kind_ == kClampedRoundedUInteger8;
+  }
+  bool IsInteger() const { return IsInteger32X() || IsTruncatedInteger32() ||
+        IsClampedRoundedInteger8(); }
   bool IsDouble() const { return kind_ == kDouble; }
   bool IsExternal() const { return kind_ == kExternal; }
-  bool IsSpecialization() const {
-    return kind_ == kInteger32 || kind_ == kDouble;
+  bool IsTerminalSpecialization() const {
+    return kind_ >= kFirstTerminalSpecialization &&
+        kind_ <= kLastTerminalSpecialization;
   }
   const char* Mnemonic() const;
 
  private:
   explicit Representation(Kind k) : kind_(k) { }
 
   // Make sure kind fits in int8.
   STATIC_ASSERT(kNumRepresentations <= (1 << kBitsPerByte));
 
   int8_t kind_;
 };
 
 
+enum ToIRoundingMode {
+  kNoRoundingMode = 0,
+  kTruncatingRoundingMode,
+  k8BitClampedRoundingMode
+};
+
+
+inline static ToIRoundingMode RepresentationToRoundingMode(Representation r) {
+  if (r.IsClampedRoundedInteger8()) {
+    return k8BitClampedRoundingMode;
+  } else if (r.IsTruncatedInteger32()) {
+    return kTruncatingRoundingMode;
+  } else {
+    return kNoRoundingMode;
+  }
+}
+
+
 class HType {
  public:
   HType() : type_(kUninitialized) { }
 
   static HType Tagged() { return HType(kTagged); }
   static HType TaggedPrimitive() { return HType(kTaggedPrimitive); }
   static HType TaggedNumber() { return HType(kTaggedNumber); }
   static HType Smi() { return HType(kSmi); }
   static HType HeapNumber() { return HType(kHeapNumber); }
   static HType String() { return HType(kString); }
@@ skipping 110 matching lines @@
     // Declare global value numbering flags.
   #define DECLARE_DO(type) kChanges##type, kDependsOn##type,
     GVN_FLAG_LIST(DECLARE_DO)
   #undef DECLARE_DO
     kFlexibleRepresentation,
     kUseGVN,
     kCanOverflow,
     kBailoutOnMinusZero,
     kCanBeDivByZero,
     kIsArguments,
-    kTruncatingToInt32,
-    kLastFlag = kTruncatingToInt32
+    kLastFlag = kIsArguments
   };
 
   STATIC_ASSERT(kLastFlag < kBitsPerInt);
 
   static const int kChangesToDependsFlagsLeftShift = 1;
 
   static int ChangesFlagsMask() {
     int result = 0;
     // Create changes mask.
 #define DECLARE_DO(type) result |= (1 << kChanges##type);
@@ skipping 490 matching lines @@
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Throw, "throw")
 };
 
 
 class HChange: public HUnaryOperation {
  public:
   HChange(HValue* value,
           Representation from,
-          Representation to,
-          bool is_truncating)
+          Representation to)
       : HUnaryOperation(value), from_(from) {
     ASSERT(!from.IsNone() && !to.IsNone());
     ASSERT(!from.Equals(to));
     set_representation(to);
     SetFlag(kUseGVN);
-    if (is_truncating) SetFlag(kTruncatingToInt32);
-    if (from.IsInteger32() && to.IsTagged() && value->range() != NULL &&
+    if (from.IsInteger() && to.IsTagged() && value->range() != NULL &&
         value->range()->IsInSmiRange()) {
       set_type(HType::Smi());
     }
   }
 
   virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
 
   Representation from() const { return from_; }
   Representation to() const { return representation(); }
   virtual Representation RequiredInputRepresentation(int index) const {
     return from_;
   }
 
-  bool CanTruncateToInt32() const { return CheckFlag(kTruncatingToInt32); }
-
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(Change,
-                               CanTruncateToInt32() ? "truncate" : "change")
+      representation().IsTruncatedInteger32()
+          ? "truncate"
+          : (representation().IsClampedRoundedInteger8()
+              ? "clamp"
+              : "change"))
 
  protected:
   virtual bool DataEquals(HValue* other) {
     if (!other->IsChange()) return false;
     HChange* change = HChange::cast(other);
     return value() == change->value()
         && to().Equals(change->to());
   }
 
  private:
@@ skipping 505 matching lines @@
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 };
 
 
 class HBitNot: public HUnaryOperation {
  public:
   explicit HBitNot(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Integer32());
     SetFlag(kUseGVN);
-    SetFlag(kTruncatingToInt32);
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
-    return Representation::Integer32();
+    return Representation::TruncatedInteger32();
   }
   virtual HType CalculateInferredType();
 
   DECLARE_CONCRETE_INSTRUCTION(BitNot, "bit_not")
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 };
 
 
@@ skipping 47 matching lines @@
         UNREACHABLE();
         return Representation::None();
     }
   }
 
   virtual HValue* Canonicalize() {
     // If the input is integer32 then we replace the floor instruction
     // with its inputs.  This happens before the representation changes are
     // introduced.
     if (op() == kMathFloor) {
-      if (value()->representation().IsInteger32()) return value();
+      if (value()->representation().IsInteger()) return value();
     }
     return this;
   }
 
   BuiltinFunctionId op() const { return op_; }
   const char* OpName() const;
 
   DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation, "unary_math_operation")
 
  protected:
@@ skipping 297 matching lines @@
       non_phi_uses_[i] = 0;
       indirect_uses_[i] = 0;
     }
     ASSERT(merged_index >= 0);
     set_representation(Representation::Tagged());
     SetFlag(kFlexibleRepresentation);
   }
 
   virtual Representation InferredRepresentation() {
     bool double_occurred = false;
-    bool int32_occurred = false;
+    bool int_occurred = false;
+    Representation int_representation(Representation::None());
     for (int i = 0; i < OperandCount(); ++i) {
       HValue* value = OperandAt(i);
       if (value->representation().IsDouble()) double_occurred = true;
-      if (value->representation().IsInteger32()) int32_occurred = true;
+      if (value->representation().IsInteger()) {
+        int_occurred = true;
+        if (int_representation.IsNone()) {
+          int_representation = value->representation();
+        } else if (!int_representation.Equals(value->representation())) {
+          int_representation = Representation::Integer32();
+        } else {
+          int_representation = value->representation();
+        }
+      }
       if (value->representation().IsTagged()) return Representation::Tagged();
     }
 
     if (double_occurred) return Representation::Double();
-    if (int32_occurred) return Representation::Integer32();
+    if (!int_representation.IsNone()) {
+      return int_representation;
+    }
     return Representation::None();
   }
 
   virtual Range* InferRange();
   virtual Representation RequiredInputRepresentation(int index) const {
     return representation();
   }
   virtual HType CalculateInferredType();
   virtual int OperandCount() { return inputs_.length(); }
   virtual HValue* OperandAt(int index) { return inputs_[index]; }
@@ skipping 84 matching lines @@
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::None();
   }
 
   virtual bool EmitAtUses() { return !representation().IsDouble(); }
   virtual void PrintDataTo(StringStream* stream);
   virtual HType CalculateInferredType();
   bool IsInteger() const { return handle_->IsSmi(); }
   HConstant* CopyToRepresentation(Representation r) const;
   HConstant* CopyToTruncatedInt32() const;
+  HConstant* CopyToClampedRoundedUInt8() const;
   bool HasInteger32Value() const { return has_int32_value_; }
   int32_t Integer32Value() const {
     ASSERT(HasInteger32Value());
     return int32_value_;
   }
   bool HasDoubleValue() const { return has_double_value_; }
   double DoubleValue() const {
     ASSERT(HasDoubleValue());
     return double_value_;
   }
@@ skipping 195 matching lines @@
     SetFlag(kFlexibleRepresentation);
     SetAllSideEffects();
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return representation();
   }
 
   virtual void RepresentationChanged(Representation to) {
     if (!to.IsTagged()) {
-      ASSERT(to.IsInteger32());
+      ASSERT(to.IsInteger());
       ClearAllSideEffects();
-      SetFlag(kTruncatingToInt32);
       SetFlag(kUseGVN);
     }
   }
 
   virtual HType CalculateInferredType();
 
   DECLARE_INSTRUCTION(BitwiseBinaryOperation)
 };
 
 
@@ skipping 1159 matching lines @@
     SetOperandAt(0, external_elements);
     SetOperandAt(1, key);
     SetOperandAt(2, val);
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   virtual Representation RequiredInputRepresentation(int index) const {
     if (index == 0) {
       return Representation::External();
+    } else if (index == 2) {
+      if (array_type_ == kExternalFloatArray) {
+        return Representation::Double();
+      } else if (array_type_ == kExternalPixelArray) {
+        return Representation::ClampedRoundedUInteger8();
+      } else {
+        return Representation::TruncatedInteger32();
+      }
     } else {
-      if (index == 2 && array_type() == kExternalFloatArray) {
-        return Representation::Double();
-      } else {
-        return Representation::Integer32();
-      }
+      return Representation::Integer32();
     }
   }
 
   HValue* external_pointer() { return OperandAt(0); }
   HValue* key() { return OperandAt(1); }
   HValue* value() { return OperandAt(2); }
   ExternalArrayType array_type() const { return array_type_; }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreKeyedSpecializedArrayElement,
                                "store_keyed_specialized_array_element")
@@ skipping 321 matching lines @@
   HValue* object() { return left(); }
   HValue* key() { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_