[Isolates] Merge from bleeding_edge, revisions 5934-6100.

src/hydrogen-instructions.h

 // Copyright 2010 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 59 matching lines @@
 //         HShl
 //         HShr
 //       HBoundsCheck
 //       HCompare
 //       HCompareJSObjectEq
 //       HInstanceOf
 //       HLoadKeyed
 //         HLoadKeyedFastElement
 //         HLoadKeyedGeneric
 //       HLoadNamedGeneric
+//       HPower
 //       HStoreNamed
 //         HStoreNamedField
 //         HStoreNamedGeneric
 //     HBlockEntry
 //     HCall
 //       HCallConstantFunction
 //       HCallFunction
 //       HCallGlobal
 //       HCallKeyed
 //       HCallKnownGlobal
 //       HCallNamed
 //       HCallNew
 //       HCallRuntime
 //     HCallStub
 //     HConstant
 //     HControlInstruction
+//       HDeoptimize
 //       HGoto
 //       HUnaryControlInstruction
 //         HBranch
 //         HCompareMapAndBranch
 //         HReturn
 //         HThrow
-//     HDeoptimize
 //     HEnterInlined
 //     HFunctionLiteral
 //     HGlobalObject
 //     HGlobalReceiver
 //     HLeaveInlined
 //     HLoadGlobal
 //     HMaterializedLiteral
 //       HArrayLiteral
 //       HObjectLiteral
 //       HRegExpLiteral
@@ skipping 19 matching lines @@
 //         HTypeofIs
 //       HLoadNamedField
 //       HPushArgument
 //       HTypeof
 //       HUnaryMathOperation
 //       HUnaryPredicate
 //         HClassOfTest
 //         HHasCachedArrayIndex
 //         HHasInstanceType
 //         HIsNull
+//         HIsObject
 //         HIsSmi
 //       HValueOf
 //     HUnknownOSRValue
 //   HPhi
 
 #define HYDROGEN_ALL_INSTRUCTION_LIST(V)       \
   V(ArithmeticBinaryOperation)                 \
   V(BinaryOperation)                           \
   V(BitwiseBinaryOperation)                    \
   V(Call)                                      \
@@ skipping 48 matching lines @@
   V(DeleteProperty)                            \
   V(Deoptimize)                                \
   V(Div)                                       \
   V(EnterInlined)                              \
   V(FunctionLiteral)                           \
   V(GlobalObject)                              \
   V(GlobalReceiver)                            \
   V(Goto)                                      \
   V(InstanceOf)                                \
   V(IsNull)                                    \
+  V(IsObject)                                  \
   V(IsSmi)                                     \
   V(HasInstanceType)                           \
   V(HasCachedArrayIndex)                       \
   V(ClassOfTest)                               \
   V(LeaveInlined)                              \
   V(LoadElements)                              \
   V(LoadGlobal)                                \
   V(LoadKeyedFastElement)                      \
   V(LoadKeyedGeneric)                          \
   V(LoadNamedField)                            \
   V(LoadNamedGeneric)                          \
   V(Mod)                                       \
   V(Mul)                                       \
   V(ObjectLiteral)                             \
   V(OsrEntry)                                  \
   V(Parameter)                                 \
+  V(Power)                                     \
   V(PushArgument)                              \
   V(RegExpLiteral)                             \
   V(Return)                                    \
   V(Sar)                                       \
   V(Shl)                                       \
   V(Shr)                                       \
   V(Simulate)                                  \
   V(StackCheck)                                \
   V(StoreGlobal)                               \
   V(StoreKeyedFastElement)                     \
@@ skipping 87 matching lines @@
     int old_upper = upper_;
     lower_ = lower_ << bits;
     upper_ = upper_ << bits;
     if (old_lower != lower_ >> bits || old_upper != upper_ >> bits) {
       upper_ = kMaxInt;
       lower_ = kMinInt;
     }
     set_can_be_minus_zero(false);
   }
 
+  // Adds a constant to the lower and upper bound of the range.
+  void AddConstant(int32_t value);
+
   void StackUpon(Range* other) {
     Intersect(other);
     next_ = other;
   }
 
   void Intersect(Range* other) {
     upper_ = Min(upper_, other->upper_);
     lower_ = Max(lower_, other->lower_);
     bool b = CanBeMinusZero() && other->CanBeMinusZero();
     set_can_be_minus_zero(b);
   }
 
   void Union(Range* other) {
     upper_ = Max(upper_, other->upper_);
     lower_ = Min(lower_, other->lower_);
     bool b = CanBeMinusZero() || other->CanBeMinusZero();
     set_can_be_minus_zero(b);
   }
 
-  void Add(int32_t value);
+  // Compute a new result range and return true, if the operation
+  // can overflow.
   bool AddAndCheckOverflow(Range* other);
   bool SubAndCheckOverflow(Range* other);
   bool MulAndCheckOverflow(Range* other);
 
  private:
   int32_t lower_;
   int32_t upper_;
   Range* next_;
   bool can_be_minus_zero_;
 };
@@ skipping 527 matching lines @@
         true_destination_(true_destination),
         false_destination_(false_destination) {
     ASSERT(true_destination != NULL);
     ASSERT(false_destination != NULL);
     ASSERT(!map.is_null());
   }
 
   virtual HBasicBlock* FirstSuccessor() const { return true_destination_; }
   virtual HBasicBlock* SecondSuccessor() const { return false_destination_; }
 
+  virtual void PrintDataTo(StringStream* stream) const;
+
   Handle<Map> map() const { return map_; }
 
   DECLARE_CONCRETE_INSTRUCTION(CompareMapAndBranch, "compare_map_and_branch")
 
  private:
   Handle<Map> map_;
   HBasicBlock* true_destination_;
   HBasicBlock* false_destination_;
 };
 
@@ skipping 448 matching lines @@
     return Representation::Integer32();
   }
   virtual HType CalculateInferredType() const;
 
   DECLARE_CONCRETE_INSTRUCTION(BitNot, "bit_not")
 };
 
 
 class HUnaryMathOperation: public HUnaryOperation {
  public:
-  HUnaryMathOperation(HValue* value, MathFunctionId op)
+  HUnaryMathOperation(HValue* value, BuiltinFunctionId op)
       : HUnaryOperation(value), op_(op) {
     switch (op) {
       case kMathFloor:
       case kMathRound:
       case kMathCeil:
         set_representation(Representation::Integer32());
         break;
       case kMathAbs:
         set_representation(Representation::Tagged());
         SetFlag(kFlexibleRepresentation);
         break;
       case kMathSqrt:
+      case kMathPowHalf:
+      case kMathLog:
+      case kMathSin:
+      case kMathCos:
+        set_representation(Representation::Double());
+        break;
       default:
-        set_representation(Representation::Double());
+        UNREACHABLE();
     }
     SetFlag(kUseGVN);
   }
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   virtual HType CalculateInferredType() const;
 
   virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
 
   virtual Representation RequiredInputRepresentation(int index) const {
     switch (op_) {
       case kMathFloor:
       case kMathRound:
       case kMathCeil:
       case kMathSqrt:
+      case kMathPowHalf:
+      case kMathLog:
+      case kMathSin:
+      case kMathCos:
         return Representation::Double();
         break;
       case kMathAbs:
         return representation();
         break;
       default:
         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();
     }
     return this;
   }
 
-  MathFunctionId op() const { return op_; }
+  BuiltinFunctionId op() const { return op_; }
   const char* OpName() const;
 
   DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation, "unary_math_operation")
 
+ protected:
+  virtual bool DataEquals(HValue* other) const {
+    HUnaryMathOperation* b = HUnaryMathOperation::cast(other);
+    return op_ == b->op();
+  }
+
  private:
-  MathFunctionId op_;
+  BuiltinFunctionId op_;
 };
 
 
 class HLoadElements: public HUnaryOperation {
  public:
   explicit HLoadElements(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kDependsOnMaps);
   }
@@ skipping 645 matching lines @@
 
 class HIsNull: public HUnaryPredicate {
  public:
   HIsNull(HValue* value, bool is_strict)
       : HUnaryPredicate(value), is_strict_(is_strict) { }
 
   bool is_strict() const { return is_strict_; }
 
   DECLARE_CONCRETE_INSTRUCTION(IsNull, "is_null")
 
+ protected:
+  virtual bool DataEquals(HValue* other) const {
+    HIsNull* b = HIsNull::cast(other);
+    return is_strict_ == b->is_strict();
+  }
+
  private:
   bool is_strict_;
 };
 
 
+class HIsObject: public HUnaryPredicate {
+ public:
+  explicit HIsObject(HValue* value) : HUnaryPredicate(value) { }
+
+  DECLARE_CONCRETE_INSTRUCTION(IsObject, "is_object")
+};
+
+
 class HIsSmi: public HUnaryPredicate {
  public:
   explicit HIsSmi(HValue* value) : HUnaryPredicate(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(IsSmi, "is_smi")
 };
 
 
 class HHasInstanceType: public HUnaryPredicate {
  public:
   HHasInstanceType(HValue* value, InstanceType type)
       : HUnaryPredicate(value), from_(type), to_(type) { }
   HHasInstanceType(HValue* value, InstanceType from, InstanceType to)
       : HUnaryPredicate(value), from_(from), to_(to) {
     ASSERT(to == LAST_TYPE);  // Others not implemented yet in backend.
   }
 
   InstanceType from() { return from_; }
   InstanceType to() { return to_; }
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   DECLARE_CONCRETE_INSTRUCTION(HasInstanceType, "has_instance_type")
 
+ protected:
+  virtual bool DataEquals(HValue* other) const {
+    HHasInstanceType* b = HHasInstanceType::cast(other);
+    return (from_ == b->from()) && (to_ == b->to());
+  }
+
  private:
   InstanceType from_;
   InstanceType to_;  // Inclusive range, not all combinations work.
 };
 
 
 class HHasCachedArrayIndex: public HUnaryPredicate {
  public:
   explicit HHasCachedArrayIndex(HValue* value) : HUnaryPredicate(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndex, "has_cached_array_index")
 };
 
 
 class HClassOfTest: public HUnaryPredicate {
  public:
   HClassOfTest(HValue* value, Handle<String> class_name)
       : HUnaryPredicate(value), class_name_(class_name) { }
 
   DECLARE_CONCRETE_INSTRUCTION(ClassOfTest, "class_of_test")
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   Handle<String> class_name() const { return class_name_; }
 
+ protected:
+  virtual bool DataEquals(HValue* other) const {
+    HClassOfTest* b = HClassOfTest::cast(other);
+    return class_name_.is_identical_to(b->class_name_);
+  }
+
  private:
   Handle<String> class_name_;
 };
 
 
 class HTypeofIs: public HUnaryPredicate {
  public:
   HTypeofIs(HValue* value, Handle<String> type_literal)
       : HUnaryPredicate(value), type_literal_(type_literal) { }
 
@@ skipping 23 matching lines @@
   virtual bool EmitAtUses() const { return uses()->length() <= 1; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance_of")
 };
 
 
+class HPower: public HBinaryOperation {
+ public:
+  HPower(HValue* left, HValue* right)
+      : HBinaryOperation(left, right) {
+    set_representation(Representation::Double());
+    SetFlag(kUseGVN);
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) const {
+    return (index == 1) ? Representation::None() : Representation::Double();
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(Power, "power")
+};
+
+
 class HAdd: public HArithmeticBinaryOperation {
  public:
   HAdd(HValue* left, HValue* right) : HArithmeticBinaryOperation(left, right) {
     SetFlag(kCanOverflow);
   }
 
   // Add is only commutative if two integer values are added and not if two
   // tagged values are added (because it might be a String concatenation).
   virtual bool IsCommutative() const {
     return !representation().IsTagged();
@@ skipping 679 matching lines @@
   HValue* object() const { return left(); }
   HValue* key() const { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_