Improved printing of a few Hydrogen instructions.

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 1960 matching lines @@
   static HCheckInstanceType* NewIsJSArray(HValue* value) {
     return new HCheckInstanceType(value, IS_JS_ARRAY);
   }
   static HCheckInstanceType* NewIsString(HValue* value) {
     return new HCheckInstanceType(value, IS_STRING);
   }
   static HCheckInstanceType* NewIsSymbol(HValue* value) {
     return new HCheckInstanceType(value, IS_SYMBOL);
   }
 
+  virtual void PrintDataTo(StringStream* stream);
+
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   virtual HValue* Canonicalize();
 
   bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; }
   void GetCheckInterval(InstanceType* first, InstanceType* last);
   void GetCheckMaskAndTag(uint8_t* mask, uint8_t* tag);
 
@@ skipping 10 matching lines @@
 
  private:
   enum Check {
     IS_SPEC_OBJECT,
     IS_JS_ARRAY,
     IS_STRING,
     IS_SYMBOL,
     LAST_INTERVAL_CHECK = IS_JS_ARRAY
   };
 
+  const char* GetCheckName();
+
   HCheckInstanceType(HValue* value, Check check)
       : HUnaryOperation(value), check_(check) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
   }
 
   const Check check_;
 };
 
 
@@ skipping 595 matching lines @@
 class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> {
  public:
   HCompareObjectEqAndBranch(HValue* left, HValue* right) {
     SetOperandAt(0, left);
     SetOperandAt(1, right);
   }
 
   HValue* left() { return OperandAt(0); }
   HValue* right() { return OperandAt(1); }
 
+  virtual void PrintDataTo(StringStream* stream);
+
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CompareObjectEqAndBranch)
 };
 
 
 class HCompareConstantEqAndBranch: public HUnaryControlInstruction {
  public:
@@ skipping 19 matching lines @@
 
 
 class HIsNilAndBranch: public HUnaryControlInstruction {
  public:
   HIsNilAndBranch(HValue* value, EqualityKind kind, NilValue nil)
       : HUnaryControlInstruction(value, NULL, NULL), kind_(kind), nil_(nil) { }
 
   EqualityKind kind() const { return kind_; }
   NilValue nil() const { return nil_; }
 
+  virtual void PrintDataTo(StringStream* stream);
+
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(IsNilAndBranch)
 
  private:
   EqualityKind kind_;
   NilValue nil_;
 };
@@ skipping 1447 matching lines @@
  public:
   explicit HTypeof(HValue* context, HValue* value) {
     SetOperandAt(0, context);
     SetOperandAt(1, value);
     set_representation(Representation::Tagged());
   }
 
   HValue* context() { return OperandAt(0); }
   HValue* value() { return OperandAt(1); }
 
+  virtual void PrintDataTo(StringStream* stream);
+
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Typeof)
 };
 
 
 class HToFastProperties: public HUnaryOperation {
  public:
@@ skipping 74 matching lines @@
 
   DECLARE_CONCRETE_INSTRUCTION(In)
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_