Allow control intructions to have side effects.

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 80 matching lines @@
   V(CheckHeapObject)                           \
   V(CheckInstanceType)                         \
   V(CheckMaps)                                 \
   V(CheckMapValue)                             \
   V(CheckSmi)                                  \
   V(CheckValue)                                \
   V(ClampToUint8)                              \
   V(ClassOfTestAndBranch)                      \
   V(CompareNumericAndBranch)                   \
   V(CompareHoleAndBranch)                      \
-  V(CompareGeneric)                            \
+  V(CompareGenericAndBranch)                   \
   V(CompareObjectEqAndBranch)                  \
   V(CompareMap)                                \
   V(Constant)                                  \
   V(Context)                                   \
   V(DateField)                                 \
   V(DebugBreak)                                \
   V(DeclareGlobals)                            \
   V(Deoptimize)                                \
   V(Div)                                       \
   V(DummyUse)                                  \
@@ skipping 950 matching lines @@
   int flags_;
   GVNFlagSet gvn_flags_;
 
  private:
   virtual bool IsDeletable() const { return false; }
 
   DISALLOW_COPY_AND_ASSIGN(HValue);
 };
 
 
+#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P0(I)                         \
+  static I* New(Zone* zone, HValue* context) {                                 \
+    return new(zone) I(context);                                               \
+}
+
 #define DECLARE_INSTRUCTION_FACTORY_P0(I)                                      \
   static I* New(Zone* zone, HValue* context) {                                 \
     return new(zone) I();                                                      \
 }
 
+#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(I, P1)                     \
+  static I* New(Zone* zone, HValue* context, P1 p1) {                          \
+    return new(zone) I(context, p1);                                           \
+  }
+
 #define DECLARE_INSTRUCTION_FACTORY_P1(I, P1)                                  \
   static I* New(Zone* zone, HValue* context, P1 p1) {                          \
     return new(zone) I(p1);                                                    \
   }
 
+#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(I, P1, P2)                 \
+  static I* New(Zone* zone, HValue* context, P1 p1, P2 p2) {                   \
+    return new(zone) I(context, p1, p2);                                       \
+  }
+
 #define DECLARE_INSTRUCTION_FACTORY_P2(I, P1, P2)                              \
   static I* New(Zone* zone, HValue* context, P1 p1, P2 p2) {                   \
     return new(zone) I(p1, p2);                                                \
   }
 
+#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(I, P1, P2, P3)             \
+  static I* New(Zone* zone, HValue* context, P1 p1, P2 p2, P3 p3) {            \
+    return new(zone) I(context, p1, p2, p3);                                   \
+  }
+
 #define DECLARE_INSTRUCTION_FACTORY_P3(I, P1, P2, P3)                          \
   static I* New(Zone* zone, HValue* context, P1 p1, P2 p2, P3 p3) {            \
     return new(zone) I(p1, p2, p3);                                            \
   }
 
+#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(I, P1, P2, P3, P4)         \
+  static I* New(Zone* zone,                                                    \
+                HValue* context,                                               \
+                P1 p1,                                                         \
+                P2 p2,                                                         \
+                P3 p3,                                                         \
+                P4 p4) {                                                       \
+    return new(zone) I(context, p1, p2, p3, p4);                               \
+  }
+
 #define DECLARE_INSTRUCTION_FACTORY_P4(I, P1, P2, P3, P4)                      \
   static I* New(Zone* zone,                                                    \
                 HValue* context,                                               \
                 P1 p1,                                                         \
                 P2 p2,                                                         \
                 P3 p3,                                                         \
                 P4 p4) {                                                       \
     return new(zone) I(p1, p2, p3, p4);                                        \
   }
 
+#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(I, P1, P2, P3, P4, P5)     \
+  static I* New(Zone* zone,                                                    \
+                HValue* context,                                               \
+                P1 p1,                                                         \
+                P2 p2,                                                         \
+                P3 p3,                                                         \
+                P4 p4,                                                         \
+                P5 p5) {                                                       \
+    return new(zone) I(context, p1, p2, p3, p4, p5);                           \
+  }
+
 #define DECLARE_INSTRUCTION_FACTORY_P5(I, P1, P2, P3, P4, P5)                  \
   static I* New(Zone* zone,                                                    \
                 HValue* context,                                               \
                 P1 p1,                                                         \
                 P2 p2,                                                         \
                 P3 p3,                                                         \
                 P4 p4,                                                         \
                 P5 p5) {                                                       \
     return new(zone) I(p1, p2, p3, p4, p5);                                    \
   }
@@ skipping 94 matching lines @@
   HBasicBlock* SecondSuccessor() {
     return SuccessorCount() > 1 ? SuccessorAt(1) : NULL;
   }
 
   void Not() {
     HBasicBlock* swap = SuccessorAt(0);
     SetSuccessorAt(0, SuccessorAt(1));
     SetSuccessorAt(1, swap);
   }
 
+#ifdef DEBUG
+  virtual void Verify() V8_OVERRIDE;
+#endif
+
   DECLARE_ABSTRACT_INSTRUCTION(ControlInstruction)
 };
 
 
 class HSuccessorIterator V8_FINAL BASE_EMBEDDED {
  public:
   explicit HSuccessorIterator(HControlInstruction* instr)
       : instr_(instr), current_(0) { }
 
   bool Done() { return current_ >= instr_->SuccessorCount(); }
@@ skipping 2775 matching lines @@
     }
   }
 
   DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
 
  private:
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 };
 
 
-class HCompareGeneric V8_FINAL : public HBinaryOperation {
+class HCompareGenericAndBranch V8_FINAL
+    : public HTemplateControlInstruction<2, 3> {
  public:
-  HCompareGeneric(HValue* context,
-                  HValue* left,
-                  HValue* right,
-                  Token::Value token)
-      : HBinaryOperation(context, left, right, HType::Boolean()),
-        token_(token) {
-    ASSERT(Token::IsCompareOp(token));
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
+  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCompareGenericAndBranch,
+                                              HValue*, HValue*, Token::Value);
+  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(HCompareGenericAndBranch,
+                                              HValue*, HValue*, Token::Value,
+                                              HBasicBlock*, HBasicBlock*);
+  HValue* context() { return OperandAt(0); }
+  HValue* left() { return OperandAt(1); }
+  HValue* right() { return OperandAt(2); }
+  Token::Value token() const { return token_; }
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return index == 0
         ? Representation::Tagged()
         : representation();
   }
 
-  Token::Value token() const { return token_; }
+  void set_observed_input_representation(Representation left,
+                                         Representation right) {
+      observed_input_representation_[0] = left;
+      observed_input_representation_[1] = right;
+  }
+
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
 
-  DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
+  DECLARE_CONCRETE_INSTRUCTION(CompareGenericAndBranch)
 
  private:
+  HCompareGenericAndBranch(HValue* context,
+                           HValue* left,
+                           HValue* right,
+                           Token::Value token,
+                           HBasicBlock* true_target = NULL,
+                           HBasicBlock* false_target = NULL)
+      : token_(token) {
+    set_representation(Representation::Tagged());
+    SetAllSideEffects();
+    SetOperandAt(0, context);
+    SetOperandAt(1, left);
+    SetOperandAt(2, right);
+    SetSuccessorAt(0, true_target);
+    SetSuccessorAt(1, false_target);
+  }
+
+  Representation observed_input_representation_[2];
   Token::Value token_;
 };
 
 
 class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P3(HCompareNumericAndBranch,
                                  HValue*, HValue*, Token::Value);
   DECLARE_INSTRUCTION_FACTORY_P5(HCompareNumericAndBranch,
                                  HValue*, HValue*, Token::Value,
@@ skipping 181 matching lines @@
   HIsUndetectableAndBranch(HValue* value,
                            HBasicBlock* true_target = NULL,
                            HBasicBlock* false_target = NULL)
       : HUnaryControlInstruction(value, true_target, false_target) {}
 };
 
 
 class HStringCompareAndBranch : public HTemplateControlInstruction<2, 3> {
  public:
   HStringCompareAndBranch(HValue* context,
-                           HValue* left,
-                           HValue* right,
-                           Token::Value token)
+                          HValue* left,
+                          HValue* right,
+                          Token::Value token)
       : token_(token) {
     ASSERT(Token::IsCompareOp(token));
     SetOperandAt(0, context);
     SetOperandAt(1, left);
     SetOperandAt(2, right);
     set_representation(Representation::Tagged());
     SetGVNFlag(kChangesNewSpacePromotion);
   }
 
   HValue* context() { return OperandAt(0); }
@@ skipping 2814 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_