Merge revision 6500-6600 from bleeding_edge to the isolates branch.

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 46 matching lines @@
   V(MaterializedLiteral)                       \
   V(Phi)                                       \
   V(StoreKeyed)                                \
   V(StoreNamed)                                \
   V(UnaryControlInstruction)                   \
   V(UnaryOperation)                            \
   HYDROGEN_CONCRETE_INSTRUCTION_LIST(V)
 
 
 #define HYDROGEN_CONCRETE_INSTRUCTION_LIST(V)  \
+  V(AbnormalExit)                              \
   V(AccessArgumentsAt)                         \
   V(Add)                                       \
   V(ApplyArguments)                            \
   V(ArgumentsElements)                         \
   V(ArgumentsLength)                           \
   V(ArgumentsObject)                           \
   V(ArrayLiteral)                              \
   V(BitAnd)                                    \
   V(BitNot)                                    \
   V(BitOr)                                     \
@@ skipping 750 matching lines @@
 class HReturn: public HUnaryControlInstruction {
  public:
   explicit HReturn(HValue* value)
       : HUnaryControlInstruction(value, NULL, NULL) {
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Return, "return")
 };
 
 
-class HThrow: public HUnaryControlInstruction {
+class HAbnormalExit: public HControlInstruction {
  public:
-  explicit HThrow(HValue* value)
-      : HUnaryControlInstruction(value, NULL, NULL) { }
+  HAbnormalExit() : HControlInstruction(NULL, NULL) { }
 
-  DECLARE_CONCRETE_INSTRUCTION(Throw, "throw")
+  DECLARE_CONCRETE_INSTRUCTION(AbnormalExit, "abnormal_exit")
 };
 
 
 class HUnaryOperation: public HInstruction {
  public:
   explicit HUnaryOperation(HValue* value) {
     SetOperandAt(0, value);
   }
 
   HValue* value() const { return OperandAt(0); }
   virtual void PrintDataTo(StringStream* stream) const;
   virtual int OperandCount() const { return 1; }
   virtual HValue* OperandAt(int index) const { return operands_[index]; }
 
   DECLARE_INSTRUCTION(UnaryOperation)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<1> operands_;
 };
 
 
+class HThrow: public HUnaryOperation {
+ public:
+  explicit HThrow(HValue* value) : HUnaryOperation(value) {
+    SetAllSideEffects();
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) const {
+    return Representation::Tagged();
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(Throw, "throw")
+};
+
+
 class HChange: public HUnaryOperation {
  public:
   HChange(HValue* value,
           Representation from,
           Representation to)
       : HUnaryOperation(value), from_(from), to_(to) {
     ASSERT(!from.IsNone() && !to.IsNone());
     ASSERT(!from.Equals(to));
     set_representation(to);
     SetFlag(kUseGVN);
@@ skipping 103 matching lines @@
   int environment_length_;
   ZoneList<HValue*> values_;
   ZoneList<int> assigned_indexes_;
 };
 
 
 class HStackCheck: public HInstruction {
  public:
   HStackCheck() { }
 
-  DECLARE_CONCRETE_INSTRUCTION(Throw, "stack_check")
+  DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack_check")
 };
 
 
 class HEnterInlined: public HInstruction {
  public:
   HEnterInlined(Handle<JSFunction> closure, FunctionLiteral* function)
       : closure_(closure), function_(function) {
   }
 
   virtual void PrintDataTo(StringStream* stream) const;
@@ skipping 822 matching lines @@
  public:
   HApplyArguments(HValue* function,
                   HValue* receiver,
                   HValue* length,
                   HValue* elements) {
     set_representation(Representation::Tagged());
     SetOperandAt(0, function);
     SetOperandAt(1, receiver);
     SetOperandAt(2, length);
     SetOperandAt(3, elements);
+    SetAllSideEffects();
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     // The length is untagged, all other inputs are tagged.
     return (index == 2)
         ? Representation::Integer32()
         : Representation::Tagged();
   }
 
   HValue* function() const { return OperandAt(0); }
   HValue* receiver() const { return OperandAt(1); }
   HValue* length() const { return OperandAt(2); }
   HValue* elements() const { return OperandAt(3); }
 
   virtual int OperandCount() const { return operands_.length(); }
   virtual HValue* OperandAt(int index) const { return operands_[index]; }
 
   DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply_arguments")
 
-
-
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<4> operands_;
 };
 
 
@@ skipping 703 matching lines @@
   }
 
  private:
   Handle<JSGlobalPropertyCell> cell_;
   bool check_hole_value_;
 };
 
 
 class HStoreGlobal: public HUnaryOperation {
  public:
-  HStoreGlobal(HValue* value, Handle<JSGlobalPropertyCell> cell)
-      : HUnaryOperation(value), cell_(cell) {
+  HStoreGlobal(HValue* value,
+               Handle<JSGlobalPropertyCell> cell,
+               bool check_hole_value)
+      : HUnaryOperation(value),
+        cell_(cell),
+        check_hole_value_(check_hole_value) {
     SetFlag(kChangesGlobalVars);
   }
 
   Handle<JSGlobalPropertyCell> cell() const { return cell_; }
+  bool check_hole_value() const { return check_hole_value_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream) const;
 
   DECLARE_CONCRETE_INSTRUCTION(StoreGlobal, "store_global")
 
  private:
   Handle<JSGlobalPropertyCell> cell_;
+  bool check_hole_value_;
 };
 
 
 class HLoadContextSlot: public HInstruction {
  public:
   HLoadContextSlot(int context_chain_length , int slot_index)
       : context_chain_length_(context_chain_length), slot_index_(slot_index) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kDependsOnCalls);
@@ skipping 456 matching lines @@
   bool pretenure_;
 };
 
 
 class HTypeof: public HUnaryOperation {
  public:
   explicit HTypeof(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
   }
 
+  virtual Representation RequiredInputRepresentation(int index) const {
+    return Representation::Tagged();
+  }
+
   DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
 };
 
 
 class HValueOf: public HUnaryOperation {
  public:
   explicit HValueOf(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
   }
 
@@ skipping 18 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_