Start using OStreams.

src/ic.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_IC_H_
 #define V8_IC_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 336 matching lines @@
     ExtraICState GetExtraICState() const;
 
     static void GenerateAheadOfTime(
         Isolate*, void (*Generate)(Isolate*, const State&));
 
     int arg_count() const { return argc_; }
     CallType call_type() const { return call_type_; }
 
     bool CallAsMethod() const { return call_type_ == METHOD; }
 
-    void Print(StringStream* stream) const;
-
    private:
     class ArgcBits: public BitField<int, 0, Code::kArgumentsBits> {};
     class CallTypeBits: public BitField<CallType, Code::kArgumentsBits, 1> {};
 
     const int argc_;
     const CallType call_type_;
   };
 
   explicit CallIC(Isolate* isolate)
       : IC(EXTRA_CALL_FRAME, isolate) {
@@ skipping 16 matching lines @@
   // Code generator routines.
   static Handle<Code> initialize_stub(Isolate* isolate,
                                       int argc,
                                       CallType call_type);
 
   static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 };
 
 
+OStream& operator<<(OStream& os, const CallIC::State& s);
+
+
 class LoadIC: public IC {
  public:
   // ExtraICState bits
   class ContextualModeBits: public BitField<ContextualMode, 0, 1> {};
   STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
 
   enum RegisterInfo {
     kReceiverIndex,
     kNameIndex,
     kRegisterArgumentCount
@@ skipping 453 matching lines @@
     Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
 
     Type* GetLeftType(Zone* zone) const {
       return KindToType(left_kind_, zone);
     }
     Type* GetRightType(Zone* zone) const {
       return KindToType(right_kind_, zone);
     }
     Type* GetResultType(Zone* zone) const;
 
-    void Print(StringStream* stream) const;
-
     void Update(Handle<Object> left,
                 Handle<Object> right,
                 Handle<Object> result);
 
     Isolate* isolate() const { return isolate_; }
 
    private:
+    friend OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
+
     enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
 
     Kind UpdateKind(Handle<Object> object, Kind kind) const;
 
     static const char* KindToString(Kind kind);
     static Type* KindToType(Kind kind, Zone* zone);
     static bool KindMaybeSmi(Kind kind) {
       return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
     }
 
@@ skipping 21 matching lines @@
   explicit BinaryOpIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) { }
 
   static Builtins::JavaScript TokenToJSBuiltin(Token::Value op);
 
   MaybeHandle<Object> Transition(Handle<AllocationSite> allocation_site,
                                  Handle<Object> left,
                                  Handle<Object> right) V8_WARN_UNUSED_RESULT;
 };
 
 
+OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
+
+
 class CompareIC: public IC {
  public:
   // The type/state lattice is defined by the following inequations:
   //   UNINITIALIZED < ...
   //   ... < GENERIC
   //   SMI < NUMBER
   //   INTERNALIZED_STRING < STRING
   //   KNOWN_OBJECT < OBJECT
   enum State {
     UNINITIALIZED,
@@ skipping 97 matching lines @@
 DECLARE_RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss);
 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_Miss);
 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite);
 DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss);
 DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss);
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_IC_H_