Experimental implementation: Exposing SIMD instructions into JavaScript

src/hydrogen-instructions.h

 // Copyright 2012 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 168 matching lines @@
   V(StringCompareAndBranch)                    \
   V(Sub)                                       \
   V(ThisFunction)                              \
   V(Throw)                                     \
   V(ToFastProperties)                          \
   V(TransitionElementsKind)                    \
   V(TrapAllocationMemento)                     \
   V(Typeof)                                    \
   V(TypeofIsAndBranch)                         \
   V(UnaryMathOperation)                        \
+  V(NullarySIMDOperation)                      \
+  V(UnarySIMDOperation)                        \
+  V(BinarySIMDOperation)                       \
+  V(TernarySIMDOperation)                      \
+  V(QuarternarySIMDOperation)                  \
   V(UnknownOSRValue)                           \
   V(UseConst)                                  \
   V(ValueOf)                                   \
   V(WrapReceiver)
 
 #define GVN_TRACKED_FLAG_LIST(V)               \
   V(Maps)                                      \
   V(NewSpacePromotion)
 
 #define GVN_UNTRACKED_FLAG_LIST(V)             \
@@ skipping 110 matching lines @@
 
 
 class HType V8_FINAL {
  public:
   static HType None() { return HType(kNone); }
   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 Float32x4() { return HType(kFloat32x4); }
+  static HType Int32x4() { return HType(kInt32x4); }
   static HType String() { return HType(kString); }
   static HType Boolean() { return HType(kBoolean); }
   static HType NonPrimitive() { return HType(kNonPrimitive); }
   static HType JSArray() { return HType(kJSArray); }
   static HType JSObject() { return HType(kJSObject); }
 
   // Return the weakest (least precise) common type.
   HType Combine(HType other) {
     return HType(static_cast<Type>(type_ & other.type_));
   }
@@ skipping 15 matching lines @@
   }
 
   bool IsSmi() const {
     return ((type_ & kSmi) == kSmi);
   }
 
   bool IsHeapNumber() const {
     return ((type_ & kHeapNumber) == kHeapNumber);
   }
 
+  bool IsFloat32x4() const {
+    return ((type_ & kFloat32x4) == kFloat32x4);
+  }
+
+  bool IsInt32x4() const {
+    return ((type_ & kInt32x4) == kInt32x4);
+  }
+
   bool IsString() const {
     return ((type_ & kString) == kString);
   }
 
   bool IsNonString() const {
     return IsTaggedPrimitive() || IsSmi() || IsHeapNumber() ||
-        IsBoolean() || IsJSArray();
+        IsFloat32x4() || IsInt32x4() || IsBoolean() || IsJSArray();
   }
 
   bool IsBoolean() const {
     return ((type_ & kBoolean) == kBoolean);
   }
 
   bool IsNonPrimitive() const {
     return ((type_ & kNonPrimitive) == kNonPrimitive);
   }
 
   bool IsJSArray() const {
     return ((type_ & kJSArray) == kJSArray);
   }
 
   bool IsJSObject() const {
     return ((type_ & kJSObject) == kJSObject);
   }
 
   bool IsHeapObject() const {
-    return IsHeapNumber() || IsString() || IsBoolean() || IsNonPrimitive();
+    return IsHeapNumber() || IsFloat32x4() || IsInt32x4() || IsString() ||
+        IsBoolean() || IsNonPrimitive();
   }
 
   bool ToStringOrToNumberCanBeObserved(Representation representation) {
     switch (type_) {
       case kTaggedPrimitive:  // fallthru
       case kTaggedNumber:     // fallthru
       case kSmi:              // fallthru
       case kHeapNumber:       // fallthru
+      case kFloat32x4:        // fallthru
+      case kInt32x4:          // fallthru
       case kString:           // fallthru
       case kBoolean:
         return false;
       case kJSArray:          // fallthru
       case kJSObject:
         return true;
       case kTagged:
         break;
     }
     return !representation.IsSmiOrInteger32() && !representation.IsDouble();
   }
 
   static HType TypeFromValue(Handle<Object> value);
+  static HType TypeFromRepresentation(Representation representation);
 
   const char* ToString();
 
  private:
   enum Type {
     kNone = 0x0,             // 0000 0000 0000 0000
     kTagged = 0x1,           // 0000 0000 0000 0001
     kTaggedPrimitive = 0x5,  // 0000 0000 0000 0101
     kTaggedNumber = 0xd,     // 0000 0000 0000 1101
     kSmi = 0x1d,             // 0000 0000 0001 1101
     kHeapNumber = 0x2d,      // 0000 0000 0010 1101
-    kString = 0x45,          // 0000 0000 0100 0101
-    kBoolean = 0x85,         // 0000 0000 1000 0101
-    kNonPrimitive = 0x101,   // 0000 0001 0000 0001
-    kJSObject = 0x301,       // 0000 0011 0000 0001
-    kJSArray = 0x701         // 0000 0111 0000 0001
+    kFloat32x4 = 0x45,       // 0000 0000 0100 0101
+    kInt32x4 = 0x85,         // 0000 0000 1000 0101
+    kString = 0x105,         // 0000 0001 0000 0101
+    kBoolean = 0x205,        // 0000 0010 1000 0101
+    kNonPrimitive = 0x401,   // 0000 0100 0000 0001
+    kJSObject = 0xc01,       // 0000 1100 0000 0001
+    kJSArray = 0x1c01        // 0001 1100 0000 0001
   };
 
   // Make sure type fits in int16.
   STATIC_ASSERT(kJSArray < (1 << (2 * kBitsPerByte)));
 
   explicit HType(Type t) : type_(t) { }
 
   int16_t type_;
 };
 
@@ skipping 241 matching lines @@
     }
   }
   virtual void AssumeRepresentation(Representation r);
 
   virtual Representation KnownOptimalRepresentation() {
     Representation r = representation();
     if (r.IsTagged()) {
       HType t = type();
       if (t.IsSmi()) return Representation::Smi();
       if (t.IsHeapNumber()) return Representation::Double();
+      if (t.IsFloat32x4()) return Representation::Float32x4();
+      if (t.IsInt32x4()) return Representation::Int32x4();
       if (t.IsHeapObject()) return r;
       return Representation::None();
     }
     return r;
   }
 
   HType type() const { return type_; }
   void set_type(HType new_type) {
     ASSERT(new_type.IsSubtypeOf(type_));
     type_ = new_type;
@@ skipping 1022 matching lines @@
     set_representation(to);
     SetFlag(kUseGVN);
     if (is_truncating_to_smi) {
       SetFlag(kTruncatingToSmi);
       SetFlag(kTruncatingToInt32);
     }
     if (is_truncating_to_int32) SetFlag(kTruncatingToInt32);
     if (value->representation().IsSmi() || value->type().IsSmi()) {
       set_type(HType::Smi());
     } else {
-      set_type(HType::TaggedNumber());
+      if (to.IsFloat32x4()) {
+        set_type(HType::Float32x4());
+      } else if (to.IsInt32x4()) {
+        set_type(HType::Int32x4());
+      } else {
+        set_type(HType::TaggedNumber());
+      }
       if (to.IsTagged()) SetGVNFlag(kChangesNewSpacePromotion);
     }
   }
 
   bool can_convert_undefined_to_nan() {
     return CheckUsesForFlag(kAllowUndefinedAsNaN);
   }
 
   virtual HValue* EnsureAndPropagateNotMinusZero(
       BitVector* visited) V8_OVERRIDE;
@@ skipping 1005 matching lines @@
     // corresponding HStoreRoot instruction.
     SetGVNFlag(kDependsOnCalls);
   }
 
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 
   const Heap::RootListIndex index_;
 };
 
 
+class HNullarySIMDOperation V8_FINAL : public HTemplateInstruction<1> {
+ public:
+  static HInstruction* New(Zone* zone,
+                           HValue* context,
+                           BuiltinFunctionId op);
+
+  HValue* context() { return OperandAt(0); }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    return Representation::Tagged();
+  }
+
+  virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
+  virtual HValue* Canonicalize() V8_OVERRIDE;
+
+  BuiltinFunctionId op() const { return op_; }
+  const char* OpName() const;
+
+  DECLARE_CONCRETE_INSTRUCTION(NullarySIMDOperation)
+
+ protected:
+  virtual bool DataEquals(HValue* other) V8_OVERRIDE {
+    HNullarySIMDOperation* b = HNullarySIMDOperation::cast(other);
+    return op_ == b->op();
+  }
+
+ private:
+  HNullarySIMDOperation(HValue* context, BuiltinFunctionId op)
+      : HTemplateInstruction<1>(HType::Float32x4()), op_(op) {
+    SetOperandAt(0, context);
+    switch (op) {
+      case kFloat32x4Zero:
+        set_representation(Representation::Float32x4());
+        break;
+      default:
+        UNREACHABLE();
+    }
+    SetFlag(kUseGVN);
+  }
+
+  virtual bool IsDeletable() const V8_OVERRIDE { return true; }
+
+  BuiltinFunctionId op_;
+};
+
+
+class HUnarySIMDOperation V8_FINAL : public HTemplateInstruction<2> {
+ public:
+  static HInstruction* New(Zone* zone,
+                           HValue* context,
+                           HValue* value,
+                           BuiltinFunctionId op,
+                           Representation to = Representation::Float32x4());
+
+  HValue* context() { return OperandAt(0); }
+  HValue* value() { return OperandAt(1); }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    if (op_ == kFloat32x4OrInt32x4Change) {
+      return value()->representation();
+    } else if (index == 0) {
+      return Representation::Tagged();
+    } else {
+      switch (op_) {
+        case kSIMDAbs:
+        case kSIMDNeg:
+        case kSIMDReciprocal:
+        case kSIMDReciprocalSqrt:
+        case kSIMDSqrt:
+        case kSIMDBitsToInt32x4:
+        case kSIMDToInt32x4:
+        case kFloat32x4SignMask:
+        case kFloat32x4X:
+        case kFloat32x4Y:
+        case kFloat32x4Z:
+        case kFloat32x4W:
+          return Representation::Float32x4();
+        case kSIMDBitsToFloat32x4:
+        case kSIMDToFloat32x4:
+        case kInt32x4SignMask:
+        case kInt32x4X:
+        case kInt32x4Y:
+        case kInt32x4Z:
+        case kInt32x4W:
+        case kInt32x4FlagX:
+        case kInt32x4FlagY:
+        case kInt32x4FlagZ:
+        case kInt32x4FlagW:
+        case kSIMDNegU32:
+          return Representation::Int32x4();
+        case kFloat32x4Splat:
+          return Representation::Double();
+        case kInt32x4Splat:
+          return Representation::Integer32();
+        default:
+          UNREACHABLE();
+          return Representation::None();
+      }
+    }
+  }
+
+  virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
+
+  virtual HValue* Canonicalize() V8_OVERRIDE;
+  virtual Representation RepresentationFromInputs() V8_OVERRIDE;
+
+  BuiltinFunctionId op() const { return op_; }
+  const char* OpName() const;
+
+  DECLARE_CONCRETE_INSTRUCTION(UnarySIMDOperation)
+
+ protected:
+  virtual bool DataEquals(HValue* other) V8_OVERRIDE {
+    HUnarySIMDOperation* b = HUnarySIMDOperation::cast(other);
+    return op_ == b->op();
+  }
+
+ private:
+  HUnarySIMDOperation(HValue* context, HValue* value, BuiltinFunctionId op,
+                      Representation to = Representation::Float32x4())
+      : HTemplateInstruction<2>(HType::TypeFromRepresentation(to)), op_(op) {
+    SetOperandAt(0, context);
+    SetOperandAt(1, value);
+    switch (op) {
+      case kFloat32x4OrInt32x4Change:
+        set_representation(to);
+        break;
+      case kSIMDAbs:
+      case kSIMDNeg:
+      case kSIMDReciprocal:
+      case kSIMDReciprocalSqrt:
+      case kSIMDSqrt:
+      case kSIMDBitsToFloat32x4:
+      case kSIMDToFloat32x4:
+      case kFloat32x4Splat:
+        set_representation(Representation::Float32x4());
+        break;
+      case kSIMDBitsToInt32x4:
+      case kSIMDToInt32x4:
+      case kInt32x4Splat:
+      case kSIMDNegU32:
+        set_representation(Representation::Int32x4());
+        type_ = HType::Int32x4();
+        break;
+      case kFloat32x4SignMask:
+      case kInt32x4SignMask:
+        set_representation(Representation::Integer32());
+        break;
+      case kFloat32x4X:
+      case kFloat32x4Y:
+      case kFloat32x4Z:
+      case kFloat32x4W:
+        set_representation(Representation::Double());
+        break;
+      case kInt32x4X:
+      case kInt32x4Y:
+      case kInt32x4Z:
+      case kInt32x4W:
+        set_representation(Representation::Integer32());
+        break;
+      case kInt32x4FlagX:
+      case kInt32x4FlagY:
+      case kInt32x4FlagZ:
+      case kInt32x4FlagW:
+        set_representation(Representation::Tagged());
+        break;
+      default:
+        UNREACHABLE();
+    }
+    SetFlag(kUseGVN);
+  }
+
+  virtual bool IsDeletable() const V8_OVERRIDE { return true; }
+
+  BuiltinFunctionId op_;
+};
+
+
+class HBinarySIMDOperation V8_FINAL : public HTemplateInstruction<3> {
+ public:
+  static HInstruction* New(Zone* zone,
+                           HValue* context,
+                           HValue* left,
+                           HValue* right,
+                           BuiltinFunctionId op);
+
+  HValue* context() { return OperandAt(0); }
+  HValue* left() { return OperandAt(1); }
+  HValue* right() { return OperandAt(2); }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    if (index == 0) {
+      return Representation::Tagged();
+    } else {
+      switch (op_) {
+        case kSIMDAdd:
+        case kSIMDSub:
+        case kSIMDMul:
+        case kSIMDDiv:
+        case kSIMDMin:
+        case kSIMDMax:
+        case kSIMDLessThan:
+        case kSIMDLessThanOrEqual:
+        case kSIMDEqual:
+        case kSIMDNotEqual:
+        case kSIMDGreaterThanOrEqual:
+        case kSIMDGreaterThan:
+          return Representation::Float32x4();
+        case kSIMDAnd:
+        case kSIMDOr:
+        case kSIMDXor:
+        case kSIMDAddU32:
+        case kSIMDSubU32:
+        case kSIMDMulU32:
+          return Representation::Int32x4();
+        case kSIMDShuffle:
+          return index == 1 ? Representation::Float32x4()
+                            : Representation::Integer32();
+        case kSIMDScale:
+        case kSIMDWithX:
+        case kSIMDWithY:
+        case kSIMDWithZ:
+        case kSIMDWithW:
+          return index == 1 ? Representation::Float32x4()
+                            : Representation::Double();
+        case kSIMDWithXu32:
+        case kSIMDWithYu32:
+        case kSIMDWithZu32:
+        case kSIMDWithWu32:
+        case kSIMDShuffleU32:
+          return index == 1 ? Representation::Int32x4()
+                            : Representation::Integer32();
+        case kSIMDWithFlagX:
+        case kSIMDWithFlagY:
+        case kSIMDWithFlagZ:
+        case kSIMDWithFlagW:
+          return index == 1 ? Representation::Int32x4()
+                            : Representation::Tagged();
+        default:
+          UNREACHABLE();
+          return Representation::None();
+      }
+    }
+  }
+
+  virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
+
+  virtual HValue* Canonicalize() V8_OVERRIDE;
+  virtual Representation RepresentationFromInputs() V8_OVERRIDE;
+
+  BuiltinFunctionId op() const { return op_; }
+  const char* OpName() const;
+
+  DECLARE_CONCRETE_INSTRUCTION(BinarySIMDOperation)
+
+ protected:
+  virtual bool DataEquals(HValue* other) V8_OVERRIDE {
+    HBinarySIMDOperation* b = HBinarySIMDOperation::cast(other);
+    return op_ == b->op();
+  }
+
+ private:
+  HBinarySIMDOperation(HValue* context, HValue* left, HValue* right,
+                       BuiltinFunctionId op)
+      : HTemplateInstruction<3>(HType::Float32x4()), op_(op) {
+    SetOperandAt(0, context);
+    SetOperandAt(1, left);
+    SetOperandAt(2, right);
+    switch (op) {
+      case kSIMDAdd:
+      case kSIMDSub:
+      case kSIMDMul:
+      case kSIMDDiv:
+      case kSIMDMin:
+      case kSIMDMax:
+      case kSIMDScale:
+      case kSIMDShuffle:
+      case kSIMDWithX:
+      case kSIMDWithY:
+      case kSIMDWithZ:
+      case kSIMDWithW:
+        set_representation(Representation::Float32x4());
+        break;
+      case kSIMDAnd:
+      case kSIMDOr:
+      case kSIMDXor:
+      case kSIMDAddU32:
+      case kSIMDSubU32:
+      case kSIMDMulU32:
+      case kSIMDLessThan:
+      case kSIMDLessThanOrEqual:
+      case kSIMDEqual:
+      case kSIMDNotEqual:
+      case kSIMDGreaterThanOrEqual:
+      case kSIMDGreaterThan:
+      case kSIMDWithXu32:
+      case kSIMDWithYu32:
+      case kSIMDWithZu32:
+      case kSIMDWithWu32:
+      case kSIMDWithFlagX:
+      case kSIMDWithFlagY:
+      case kSIMDWithFlagZ:
+      case kSIMDWithFlagW:
+      case kSIMDShuffleU32:
+        set_representation(Representation::Int32x4());
+        type_ = HType::Int32x4();
+        break;
+      default:
+        UNREACHABLE();
+    }
+    SetFlag(kUseGVN);
+  }
+
+  virtual bool IsDeletable() const V8_OVERRIDE { return true; }
+
+  BuiltinFunctionId op_;
+};
+
+
+class HTernarySIMDOperation V8_FINAL : public HTemplateInstruction<4> {
+ public:
+  static HInstruction* New(Zone* zone,
+                           HValue* context,
+                           HValue* first,
+                           HValue* second,
+                           HValue* third,
+                           BuiltinFunctionId op);
+
+  HValue* context() { return OperandAt(0); }
+  HValue* first() { return OperandAt(1); }
+  HValue* second() { return OperandAt(2); }
+  HValue* third() { return OperandAt(3); }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    if (index == 0) {
+      return Representation::Tagged();
+    } else {
+      switch (op_) {
+        case kSIMDSelect:
+          switch (index) {
+            case 1: return Representation::Int32x4();
+            case 2: return Representation::Float32x4();
+            case 3: return Representation::Float32x4();
+            default:
+              UNREACHABLE();
+              return Representation::None();
+          }
+        case kSIMDShuffleMix:
+          switch (index) {
+            case 1: return Representation::Float32x4();
+            case 2: return Representation::Float32x4();
+            case 3: return Representation::Integer32();
+            default:
+              UNREACHABLE();
+              return Representation::None();
+          }
+        case kSIMDClamp:
+          return Representation::Float32x4();
+        default:
+          UNREACHABLE();
+          return Representation::None();
+      }
+    }
+  }
+
+  virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
+
+  virtual HValue* Canonicalize() V8_OVERRIDE;
+  virtual Representation RepresentationFromInputs() V8_OVERRIDE;
+
+  BuiltinFunctionId op() const { return op_; }
+  const char* OpName() const;
+
+  DECLARE_CONCRETE_INSTRUCTION(TernarySIMDOperation)
+
+ protected:
+  virtual bool DataEquals(HValue* other) V8_OVERRIDE {
+    HTernarySIMDOperation* b = HTernarySIMDOperation::cast(other);
+    return op_ == b->op();
+  }
+
+ private:
+  HTernarySIMDOperation(HValue* context, HValue* first, HValue* second,
+                        HValue* third, BuiltinFunctionId op)
+      : HTemplateInstruction<4>(HType::Float32x4()), op_(op) {
+    SetOperandAt(0, context);
+    SetOperandAt(1, first);
+    SetOperandAt(2, second);
+    SetOperandAt(3, third);
+    switch (op) {
+      case kSIMDSelect:
+      case kSIMDShuffleMix:
+      case kSIMDClamp:
+        set_representation(Representation::Float32x4());
+        break;
+      default:
+        UNREACHABLE();
+    }
+    SetFlag(kUseGVN);
+  }
+
+  virtual bool IsDeletable() const V8_OVERRIDE { return true; }
+
+  BuiltinFunctionId op_;
+};
+
+
+class HQuarternarySIMDOperation V8_FINAL : public HTemplateInstruction<5> {
+ public:
+  static HInstruction* New(Zone* zone,
+                           HValue* context,
+                           HValue* x,
+                           HValue* y,
+                           HValue* z,
+                           HValue* w,
+                           BuiltinFunctionId op);
+
+  HValue* context() { return OperandAt(0); }
+  HValue* x() { return OperandAt(1); }
+  HValue* y() { return OperandAt(2); }
+  HValue* z() { return OperandAt(3); }
+  HValue* w() { return OperandAt(4); }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    if (index == 0) {
+      return Representation::Tagged();
+    } else {
+      switch (op_) {
+        case kFloat32x4Constructor: return Representation::Double();
+        case kInt32x4Constructor:
+          return Representation::Integer32();
+        case kInt32x4Bool:
+          return Representation::Tagged();
+        default:
+          UNREACHABLE();
+          return Representation::None();
+      }
+    }
+  }
+
+  virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
+
+  virtual HValue* Canonicalize() V8_OVERRIDE;
+  virtual Representation RepresentationFromInputs() V8_OVERRIDE;
+
+  BuiltinFunctionId op() const { return op_; }
+  const char* OpName() const;
+
+  DECLARE_CONCRETE_INSTRUCTION(QuarternarySIMDOperation)
+
+ protected:
+  virtual bool DataEquals(HValue* other) V8_OVERRIDE {
+    HQuarternarySIMDOperation* b = HQuarternarySIMDOperation::cast(other);
+    return op_ == b->op();
+  }
+
+ private:
+  HQuarternarySIMDOperation(HValue* context, HValue* x, HValue* y, HValue* z,
+                            HValue* w, BuiltinFunctionId op)
+      : HTemplateInstruction<5>(HType::Float32x4()), op_(op) {
+    SetOperandAt(0, context);
+    SetOperandAt(1, x);
+    SetOperandAt(2, y);
+    SetOperandAt(3, z);
+    SetOperandAt(4, w);
+    switch (op) {
+      case kFloat32x4Constructor:
+        set_representation(Representation::Float32x4());
+        break;
+      case kInt32x4Constructor:
+      case kInt32x4Bool:
+        set_representation(Representation::Int32x4());
+        type_ = HType::Int32x4();
+        break;
+      default:
+        UNREACHABLE();
+    }
+    SetFlag(kUseGVN);
+  }
+
+  virtual bool IsDeletable() const V8_OVERRIDE { return true; }
+
+  BuiltinFunctionId op_;
+};
+
+
 class HLoadExternalArrayPointer V8_FINAL : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HLoadExternalArrayPointer, HValue*);
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return Representation::Tagged();
   }
 
   virtual HType CalculateInferredType() V8_OVERRIDE {
     return HType::None();
@@ skipping 1847 matching lines @@
   Handle<String> class_name_;
 };
 
 
 class HTypeofIsAndBranch V8_FINAL : public HUnaryControlInstruction {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HTypeofIsAndBranch, HValue*, Handle<String>);
 
   Handle<String> type_literal() { return type_literal_; }
   bool compares_number_type() { return compares_number_type_; }
+  bool compares_float32x4_type() { return compares_float32x4_type_; }
+  bool compares_int32x4_type() { return compares_int32x4_type_; }
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
 
   DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return Representation::None();
   }
 
   virtual bool KnownSuccessorBlock(HBasicBlock** block) V8_OVERRIDE;
 
  private:
   HTypeofIsAndBranch(HValue* value, Handle<String> type_literal)
       : HUnaryControlInstruction(value, NULL, NULL),
         type_literal_(type_literal) {
     Heap* heap = type_literal->GetHeap();
     compares_number_type_ = type_literal->Equals(heap->number_string());
+    compares_float32x4_type_ = type_literal->Equals(heap->float32x4_string());
+    compares_int32x4_type_ = type_literal->Equals(heap->int32x4_string());
   }
 
   Handle<String> type_literal_;
   bool compares_number_type_ : 1;
+  bool compares_float32x4_type_ : 1;
+  bool compares_int32x4_type_ : 1;
 };
 
 
 class HInstanceOf V8_FINAL : public HBinaryOperation {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOf, HValue*, HValue*);
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return Representation::Tagged();
   }
@@ skipping 1379 matching lines @@
                          Map::kInstanceSizeOffset,
                          Representation::UInteger8());
   }
 
   static HObjectAccess ForMapInstanceType() {
     return HObjectAccess(kInobject,
                          Map::kInstanceTypeOffset,
                          Representation::UInteger8());
   }
 
+  static HObjectAccess ForMapPrototype() {
+    return HObjectAccess(kInobject, Map::kPrototypeOffset);
+  }
+
   static HObjectAccess ForPropertyCellValue() {
     return HObjectAccess(kInobject, PropertyCell::kValueOffset);
   }
 
   static HObjectAccess ForCellValue() {
     return HObjectAccess(kInobject, Cell::kValueOffset);
   }
 
   static HObjectAccess ForAllocationMementoSite() {
     return HObjectAccess(kInobject, AllocationMemento::kAllocationSiteOffset);
@@ skipping 367 matching lines @@
 
         SetGVNFlag(kDependsOnArrayElements);
       } else {
         set_representation(Representation::Double());
         SetGVNFlag(kDependsOnDoubleArrayElements);
       }
     } else {
       if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
           elements_kind == EXTERNAL_DOUBLE_ELEMENTS) {
         set_representation(Representation::Double());
+      } else if (elements_kind == EXTERNAL_FLOAT32x4_ELEMENTS) {
+        set_representation(CpuFeatures::IsSupported(SSE2) ?
+            Representation::Float32x4() : Representation::Tagged());
+      } else if (elements_kind == EXTERNAL_INT32x4_ELEMENTS) {
+        set_representation(CpuFeatures::IsSupported(SSE2) ?
+            Representation::Int32x4() : Representation::Tagged());
       } else {
         set_representation(Representation::Integer32());
       }
 
       SetGVNFlag(kDependsOnExternalMemory);
       // Native code could change the specialized array.
       SetGVNFlag(kDependsOnCalls);
     }
 
     SetFlag(kUseGVN);
@@ skipping 234 matching lines @@
     // kind_external: external[int32] = (double | int32)
     if (index == 0) {
       return is_external() ? Representation::External()
                            : Representation::Tagged();
     } else if (index == 1) {
       return ArrayInstructionInterface::KeyedAccessIndexRequirement(
           OperandAt(1)->representation());
     }
 
     ASSERT_EQ(index, 2);
+
     if (IsDoubleOrFloatElementsKind(elements_kind())) {
       return Representation::Double();
     }
 
+    if (IsExternalFloat32x4ElementsKind(elements_kind())) {
+      return CpuFeatures::IsSupported(SSE2) ?
+          Representation::Float32x4() : Representation::Tagged();
+    }
+
+    if (IsExternalInt32x4ElementsKind(elements_kind())) {
+      return CpuFeatures::IsSupported(SSE2) ?
+          Representation::Int32x4() : Representation::Tagged();
+    }
+
     if (IsFastSmiElementsKind(elements_kind())) {
       return Representation::Smi();
     }
 
     return is_external() ? Representation::Integer32()
                          : Representation::Tagged();
   }
 
   bool is_external() const {
     return IsExternalArrayElementsKind(elements_kind());
   }
 
   virtual Representation observed_input_representation(int index) V8_OVERRIDE {
     if (index < 2) return RequiredInputRepresentation(index);
     if (IsUninitialized()) {
       return Representation::None();
     }
     if (IsFastSmiElementsKind(elements_kind())) {
       return Representation::Smi();
     }
     if (IsDoubleOrFloatElementsKind(elements_kind())) {
       return Representation::Double();
     }
+    if (IsExternalFloat32x4ElementsKind(elements_kind())) {
+      return CpuFeatures::IsSupported(SSE2) ?
+          Representation::Float32x4() : Representation::Tagged();
+    }
+    if (IsExternalInt32x4ElementsKind(elements_kind())) {
+      return CpuFeatures::IsSupported(SSE2) ?
+          Representation::Int32x4() : Representation::Tagged();
+    }
     if (is_external()) {
       return Representation::Integer32();
     }
     // For fast object elements kinds, don't assume anything.
     return Representation::None();
   }
 
   HValue* elements() { return OperandAt(0); }
   HValue* key() { return OperandAt(1); }
   HValue* value() { return OperandAt(2); }
@@ skipping 762 matching lines @@
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_