Start using OStreams.

src/code-stubs.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_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 153 matching lines @@
   // they are running.  If that is the case they should override this to return
   // true, which will cause an assertion if we try to call something that can
   // GC or if we try to put a stack frame on top of the junk, which would not
   // result in a traversable stack.
   virtual bool SometimesSetsUpAFrame() { return true; }
 
   // Lookup the code in the (possibly custom) cache.
   bool FindCodeInCache(Code** code_out);
 
   // Returns information for computing the number key.
-  virtual Major MajorKey() = 0;
-  virtual int MinorKey() = 0;
+  virtual Major MajorKey() const = 0;
+  virtual int MinorKey() const = 0;
 
   virtual InlineCacheState GetICState() {
     return UNINITIALIZED;
   }
-  virtual ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() const {
     return kNoExtraICState;
   }
   virtual Code::StubType GetStubType() {
     return Code::NORMAL;
   }
 
-  virtual void PrintName(StringStream* stream);
-
-  // Returns a name for logging/debugging purposes.
-  SmartArrayPointer<const char> GetName();
+  friend OStream& operator<<(OStream& os, const CodeStub& s) {
+    return s.PrintName(os);
+  }
 
   Isolate* isolate() const { return isolate_; }
 
  protected:
   // Generates the assembler code for the stub.
   virtual Handle<Code> GenerateCode() = 0;
 
   // Returns whether the code generated for this stub needs to be allocated as
   // a fixed (non-moveable) code object.
   virtual bool NeedsImmovableCode() { return false; }
 
-  virtual void PrintBaseName(StringStream* stream);
-  virtual void PrintState(StringStream* stream) { }
+  virtual OStream& PrintName(OStream& os) const;  // NOLINT

[Michael Starzinger, 2014/07/02 15:14:58]

suggestion: We could switch the PrintFoo methods to return void instead and only
allow chaining of the actual operator.

[Sven Panne, 2014/07/03 07:18:52]

Done.

+  virtual OStream& PrintBaseName(OStream& os) const;  // NOLINT
+  virtual OStream& PrintState(OStream& os) const { return os; }  // NOLINT
 
  private:
   // Perform bookkeeping required after code generation when stub code is
   // initially generated.
   void RecordCodeGeneration(Handle<Code> code);
 
   // Finish the code object after it has been generated.
   virtual void FinishCode(Handle<Code> code) { }
 
   // Activate newly generated stub. Is called after
@@ skipping 226 matching lines @@
     SubClass::GenerateAheadOfTime(isolate);
     return SubClass().GetCode(isolate);
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) = 0;
 
   // Retrieve the code for the stub. Generate the code if needed.
   virtual Handle<Code> GenerateCode() = 0;
 
-  virtual int NotMissMinorKey() = 0;
+  virtual int NotMissMinorKey() const = 0;
 
   Handle<Code> GenerateLightweightMissCode();
 
   template<class StateType>
   void TraceTransition(StateType from, StateType to);
 
  private:
   class MinorKeyBits: public BitField<int, 0, kStubMinorKeyBits - 1> {};
   class IsMissBits: public BitField<bool, kStubMinorKeyBits - 1, 1> {};
 
   void GenerateLightweightMiss(MacroAssembler* masm);
-  virtual int MinorKey() {
+  virtual int MinorKey() const {
     return IsMissBits::encode(is_uninitialized_) |
         MinorKeyBits::encode(NotMissMinorKey());
   }
 
   bool is_uninitialized_;
 };
 
 
 // Helper interface to prepare to/restore after making runtime calls.
 class RuntimeCallHelper {
@@ skipping 66 matching lines @@
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate) {
     ToNumberStub stub(isolate);
     stub.InitializeInterfaceDescriptor(
         isolate->code_stub_interface_descriptor(CodeStub::ToNumber));
   }
 
  private:
-  Major MajorKey() { return ToNumber; }
-  int NotMissMinorKey() { return 0; }
+  Major MajorKey() const { return ToNumber; }
+  int NotMissMinorKey() const { return 0; }
 };
 
 
 class NumberToStringStub V8_FINAL : public HydrogenCodeStub {
  public:
   explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kNumber = 0;
 
  private:
-  virtual Major MajorKey() V8_OVERRIDE { return NumberToString; }
-  virtual int NotMissMinorKey() V8_OVERRIDE { return 0; }
+  virtual Major MajorKey() const V8_OVERRIDE { return NumberToString; }
+  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
 };
 
 
 class FastNewClosureStub : public HydrogenCodeStub {
  public:
   FastNewClosureStub(Isolate* isolate,
                      StrictMode strict_mode,
                      bool is_generator)
       : HydrogenCodeStub(isolate),
         strict_mode_(strict_mode),
         is_generator_(is_generator) { }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   StrictMode strict_mode() const { return strict_mode_; }
   bool is_generator() const { return is_generator_; }
 
  private:
   class StrictModeBits: public BitField<bool, 0, 1> {};
   class IsGeneratorBits: public BitField<bool, 1, 1> {};
 
-  Major MajorKey() { return FastNewClosure; }
-  int NotMissMinorKey() {
+  Major MajorKey() const { return FastNewClosure; }
+  int NotMissMinorKey() const {
     return StrictModeBits::encode(strict_mode_ == STRICT) |
       IsGeneratorBits::encode(is_generator_);
   }
 
   StrictMode strict_mode_;
   bool is_generator_;
 };
 
 
 class FastNewContextStub V8_FINAL : public HydrogenCodeStub {
  public:
   static const int kMaximumSlots = 64;
 
   FastNewContextStub(Isolate* isolate, int slots)
       : HydrogenCodeStub(isolate), slots_(slots) {
     ASSERT(slots_ > 0 && slots_ <= kMaximumSlots);
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   int slots() const { return slots_; }
 
-  virtual Major MajorKey() V8_OVERRIDE { return FastNewContext; }
-  virtual int NotMissMinorKey() V8_OVERRIDE { return slots_; }
+  virtual Major MajorKey() const V8_OVERRIDE { return FastNewContext; }
+  virtual int NotMissMinorKey() const V8_OVERRIDE { return slots_; }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kFunction = 0;
 
  private:
   int slots_;
 };
 
 
 class FastCloneShallowArrayStub : public HydrogenCodeStub {
@@ skipping 12 matching lines @@
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
  private:
   AllocationSiteMode allocation_site_mode_;
 
   class AllocationSiteModeBits: public BitField<AllocationSiteMode, 0, 1> {};
   // Ensure data fits within available bits.
-  Major MajorKey() { return FastCloneShallowArray; }
-  int NotMissMinorKey() {
+  Major MajorKey() const { return FastCloneShallowArray; }
+  int NotMissMinorKey() const {
     return AllocationSiteModeBits::encode(allocation_site_mode_);
   }
 };
 
 
 class FastCloneShallowObjectStub : public HydrogenCodeStub {
  public:
   // Maximum number of properties in copied object.
   static const int kMaximumClonedProperties = 6;
 
   FastCloneShallowObjectStub(Isolate* isolate, int length)
       : HydrogenCodeStub(isolate), length_(length) {
     ASSERT_GE(length_, 0);
     ASSERT_LE(length_, kMaximumClonedProperties);
   }
 
   int length() const { return length_; }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
   int length_;
 
-  Major MajorKey() { return FastCloneShallowObject; }
-  int NotMissMinorKey() { return length_; }
+  Major MajorKey() const { return FastCloneShallowObject; }
+  int NotMissMinorKey() const { return length_; }
 
   DISALLOW_COPY_AND_ASSIGN(FastCloneShallowObjectStub);
 };
 
 
 class CreateAllocationSiteStub : public HydrogenCodeStub {
  public:
   explicit CreateAllocationSiteStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) { }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return CreateAllocationSite; }
-  int NotMissMinorKey() { return 0; }
+  Major MajorKey() const { return CreateAllocationSite; }
+  int NotMissMinorKey() const { return 0; }
 
   DISALLOW_COPY_AND_ASSIGN(CreateAllocationSiteStub);
 };
 
 
 class InstanceofStub: public PlatformCodeStub {
  public:
   enum Flags {
     kNoFlags = 0,
     kArgsInRegisters = 1 << 0,
     kCallSiteInlineCheck = 1 << 1,
     kReturnTrueFalseObject = 1 << 2
   };
 
   InstanceofStub(Isolate* isolate, Flags flags)
       : PlatformCodeStub(isolate), flags_(flags) { }
 
   static Register left();
   static Register right();
 
   void Generate(MacroAssembler* masm);
 
  private:
-  Major MajorKey() { return Instanceof; }
-  int MinorKey() { return static_cast<int>(flags_); }
+  Major MajorKey() const { return Instanceof; }
+  int MinorKey() const { return static_cast<int>(flags_); }
 
   bool HasArgsInRegisters() const {
     return (flags_ & kArgsInRegisters) != 0;
   }
 
   bool HasCallSiteInlineCheck() const {
     return (flags_ & kCallSiteInlineCheck) != 0;
   }
 
   bool ReturnTrueFalseObject() const {
     return (flags_ & kReturnTrueFalseObject) != 0;
   }
 
-  virtual void PrintName(StringStream* stream);
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
   Flags flags_;
 };
 
 
 enum AllocationSiteOverrideMode {
   DONT_OVERRIDE,
   DISABLE_ALLOCATION_SITES,
   LAST_ALLOCATION_SITE_OVERRIDE_MODE = DISABLE_ALLOCATION_SITES
 };
 
 
 class ArrayConstructorStub: public PlatformCodeStub {
  public:
   enum ArgumentCountKey { ANY, NONE, ONE, MORE_THAN_ONE };
   ArrayConstructorStub(Isolate* isolate, int argument_count);
   explicit ArrayConstructorStub(Isolate* isolate);
 
   void Generate(MacroAssembler* masm);
 
  private:
   void GenerateDispatchToArrayStub(MacroAssembler* masm,
                                    AllocationSiteOverrideMode mode);
-  virtual void PrintName(StringStream* stream);
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
-  virtual CodeStub::Major MajorKey() { return ArrayConstructor; }
-  virtual int MinorKey() { return argument_count_; }
+  virtual CodeStub::Major MajorKey() const { return ArrayConstructor; }
+  virtual int MinorKey() const { return argument_count_; }
 
   ArgumentCountKey argument_count_;
 };
 
 
 class InternalArrayConstructorStub: public PlatformCodeStub {
  public:
   explicit InternalArrayConstructorStub(Isolate* isolate);
 
   void Generate(MacroAssembler* masm);
 
  private:
-  virtual CodeStub::Major MajorKey() { return InternalArrayConstructor; }
-  virtual int MinorKey() { return 0; }
+  virtual CodeStub::Major MajorKey() const { return InternalArrayConstructor; }
+  virtual int MinorKey() const { return 0; }
 
   void GenerateCase(MacroAssembler* masm, ElementsKind kind);
 };
 
 
 class MathPowStub: public PlatformCodeStub {
  public:
   enum ExponentType { INTEGER, DOUBLE, TAGGED, ON_STACK };
 
   MathPowStub(Isolate* isolate, ExponentType exponent_type)
       : PlatformCodeStub(isolate), exponent_type_(exponent_type) { }
   virtual void Generate(MacroAssembler* masm);
 
  private:
-  virtual CodeStub::Major MajorKey() { return MathPow; }
-  virtual int MinorKey() { return exponent_type_; }
+  virtual CodeStub::Major MajorKey() const { return MathPow; }
+  virtual int MinorKey() const { return exponent_type_; }
 
   ExponentType exponent_type_;
 };
 
 
 class ICStub: public PlatformCodeStub {
  public:
   ICStub(Isolate* isolate, Code::Kind kind)
       : PlatformCodeStub(isolate), kind_(kind) { }
   virtual Code::Kind GetCodeKind() const { return kind_; }
   virtual InlineCacheState GetICState() { return MONOMORPHIC; }
 
   bool Describes(Code* code) {
     return GetMajorKey(code) == MajorKey() && code->stub_info() == MinorKey();
   }
 
  protected:
   class KindBits: public BitField<Code::Kind, 0, 4> {};
   virtual void FinishCode(Handle<Code> code) {
     code->set_stub_info(MinorKey());
   }
-  Code::Kind kind() { return kind_; }
+  Code::Kind kind() const { return kind_; }
 
-  virtual int MinorKey() {
+  virtual int MinorKey() const {
     return KindBits::encode(kind_);
   }
 
  private:
   Code::Kind kind_;
 };
 
 
 class CallICStub: public PlatformCodeStub {
  public:
@@ skipping 12 matching lines @@
   virtual void Generate(MacroAssembler* masm);
 
   virtual Code::Kind GetCodeKind() const V8_OVERRIDE {
     return Code::CALL_IC;
   }
 
   virtual InlineCacheState GetICState() V8_FINAL V8_OVERRIDE {
     return state_.GetICState();
   }
 
-  virtual ExtraICState GetExtraICState() V8_FINAL V8_OVERRIDE {
+  virtual ExtraICState GetExtraICState() const V8_FINAL V8_OVERRIDE {
     return state_.GetExtraICState();
   }
 
  protected:
-  virtual int MinorKey() { return GetExtraICState(); }
-  virtual void PrintState(StringStream* stream) V8_OVERRIDE;
+  virtual int MinorKey() const { return GetExtraICState(); }
+  virtual OStream& PrintState(OStream& os) const V8_OVERRIDE;  // NOLINT
 
-  virtual CodeStub::Major MajorKey() { return CallIC; }
+  virtual CodeStub::Major MajorKey() const { return CallIC; }
 
   // Code generation helpers.
   void GenerateMiss(MacroAssembler* masm, IC::UtilityId id);
 
   const CallIC::State state_;
 };
 
 
 class CallIC_ArrayStub: public CallICStub {
  public:
   CallIC_ArrayStub(Isolate* isolate, const CallIC::State& state_in)
       : CallICStub(isolate, state_in) {}
 
   virtual void Generate(MacroAssembler* masm);
 
  protected:
-  virtual void PrintState(StringStream* stream) V8_OVERRIDE;
+  virtual OStream& PrintState(OStream& os) const V8_OVERRIDE;  // NOLINT
 
-  virtual CodeStub::Major MajorKey() { return CallIC_Array; }
+  virtual CodeStub::Major MajorKey() const { return CallIC_Array; }
 };
 
 
 class FunctionPrototypeStub: public ICStub {
  public:
   FunctionPrototypeStub(Isolate* isolate, Code::Kind kind)
       : ICStub(isolate, kind) { }
   virtual void Generate(MacroAssembler* masm);
 
  private:
-  virtual CodeStub::Major MajorKey() { return FunctionPrototype; }
+  virtual CodeStub::Major MajorKey() const { return FunctionPrototype; }
 };
 
 
 class StoreICStub: public ICStub {
  public:
   StoreICStub(Isolate* isolate, Code::Kind kind, StrictMode strict_mode)
       : ICStub(isolate, kind), strict_mode_(strict_mode) { }
 
  protected:
-  virtual ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() const {
     return StoreIC::ComputeExtraICState(strict_mode_);
   }
 
  private:
   STATIC_ASSERT(KindBits::kSize == 4);
   class StrictModeBits: public BitField<bool, 4, 1> {};
-  virtual int MinorKey() {
+  virtual int MinorKey() const {
     return KindBits::encode(kind()) | StrictModeBits::encode(strict_mode_);
   }
 
   StrictMode strict_mode_;
 };
 
 
 class HICStub: public HydrogenCodeStub {
  public:
   explicit HICStub(Isolate* isolate) : HydrogenCodeStub(isolate) { }
   virtual Code::Kind GetCodeKind() const { return kind(); }
   virtual InlineCacheState GetICState() { return MONOMORPHIC; }
 
  protected:
   class KindBits: public BitField<Code::Kind, 0, 4> {};
   virtual Code::Kind kind() const = 0;
 };
 
 
 class HandlerStub: public HICStub {
  public:
   virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
-  virtual ExtraICState GetExtraICState() { return kind(); }
+  virtual ExtraICState GetExtraICState() const { return kind(); }
 
  protected:
   explicit HandlerStub(Isolate* isolate) : HICStub(isolate) { }
-  virtual int NotMissMinorKey() { return bit_field_; }
+  virtual int NotMissMinorKey() const { return bit_field_; }
   int bit_field_;
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
   LoadFieldStub(Isolate* isolate, FieldIndex index)
     : HandlerStub(isolate), index_(index) {
     Initialize(Code::LOAD_IC);
   }
@@ skipping 27 matching lines @@
     int property_index_key = index_.GetLoadFieldStubKey();
     // Save a copy of the essence of the property index into the bit field to
     // make sure that hashing of unique stubs works correctly..
     bit_field_ = KindBits::encode(kind) |
         EncodedLoadFieldByIndexBits::encode(property_index_key);
   }
 
  private:
   STATIC_ASSERT(KindBits::kSize == 4);
   class EncodedLoadFieldByIndexBits: public BitField<int, 4, 13> {};
-  virtual CodeStub::Major MajorKey() { return LoadField; }
+  virtual CodeStub::Major MajorKey() const { return LoadField; }
   FieldIndex index_;
 };
 
 
 class StringLengthStub: public HandlerStub {
  public:
   explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {
     Initialize(Code::LOAD_IC);
   }
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  protected:
   virtual Code::Kind kind() const {
     return KindBits::decode(bit_field_);
   }
 
   void Initialize(Code::Kind kind) {
     bit_field_ = KindBits::encode(kind);
   }
 
  private:
-  virtual CodeStub::Major MajorKey() { return StringLength; }
+  virtual CodeStub::Major MajorKey() const { return StringLength; }
 };
 
 
 class KeyedStringLengthStub: public StringLengthStub {
  public:
   explicit KeyedStringLengthStub(Isolate* isolate) : StringLengthStub(isolate) {
     Initialize(Code::KEYED_LOAD_IC);
   }
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  virtual CodeStub::Major MajorKey() { return KeyedStringLength; }
+  virtual CodeStub::Major MajorKey() const { return KeyedStringLength; }
 };
 
 
 class StoreGlobalStub : public HandlerStub {
  public:
   StoreGlobalStub(Isolate* isolate, bool is_constant, bool check_global)
       : HandlerStub(isolate) {
     bit_field_ = IsConstantBits::encode(is_constant) |
         CheckGlobalBits::encode(check_global);
   }
@@ skipping 35 matching lines @@
   }
 
   Representation representation() {
     return Representation::FromKind(RepresentationBits::decode(bit_field_));
   }
   void set_representation(Representation r) {
     bit_field_ = RepresentationBits::update(bit_field_, r.kind());
   }
 
  private:
-  Major MajorKey() { return StoreGlobal; }
+  Major MajorKey() const { return StoreGlobal; }
 
   class IsConstantBits: public BitField<bool, 0, 1> {};
   class RepresentationBits: public BitField<Representation::Kind, 1, 8> {};
   class CheckGlobalBits: public BitField<bool, 9, 1> {};
 
   DISALLOW_COPY_AND_ASSIGN(StoreGlobalStub);
 };
 
 
 class CallApiFunctionStub : public PlatformCodeStub {
  public:
   CallApiFunctionStub(Isolate* isolate,
                       bool is_store,
                       bool call_data_undefined,
                       int argc) : PlatformCodeStub(isolate) {
     bit_field_ =
         IsStoreBits::encode(is_store) |
         CallDataUndefinedBits::encode(call_data_undefined) |
         ArgumentBits::encode(argc);
     ASSERT(!is_store || argc == 1);
   }
 
  private:
   virtual void Generate(MacroAssembler* masm) V8_OVERRIDE;
-  virtual Major MajorKey() V8_OVERRIDE { return CallApiFunction; }
-  virtual int MinorKey() V8_OVERRIDE { return bit_field_; }
+  virtual Major MajorKey() const V8_OVERRIDE { return CallApiFunction; }
+  virtual int MinorKey() const V8_OVERRIDE { return bit_field_; }
 
   class IsStoreBits: public BitField<bool, 0, 1> {};
   class CallDataUndefinedBits: public BitField<bool, 1, 1> {};
   class ArgumentBits: public BitField<int, 2, Code::kArgumentsBits> {};
 
   int bit_field_;
 
   DISALLOW_COPY_AND_ASSIGN(CallApiFunctionStub);
 };
 
 
 class CallApiGetterStub : public PlatformCodeStub {
  public:
   explicit CallApiGetterStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
  private:
   virtual void Generate(MacroAssembler* masm) V8_OVERRIDE;
-  virtual Major MajorKey() V8_OVERRIDE { return CallApiGetter; }
-  virtual int MinorKey() V8_OVERRIDE { return 0; }
+  virtual Major MajorKey() const V8_OVERRIDE { return CallApiGetter; }
+  virtual int MinorKey() const V8_OVERRIDE { return 0; }
 
   DISALLOW_COPY_AND_ASSIGN(CallApiGetterStub);
 };
 
 
 class KeyedLoadFieldStub: public LoadFieldStub {
  public:
   KeyedLoadFieldStub(Isolate* isolate, FieldIndex index)
       : LoadFieldStub(isolate, index) {
     Initialize(Code::KEYED_LOAD_IC);
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  virtual CodeStub::Major MajorKey() { return KeyedLoadField; }
+  virtual CodeStub::Major MajorKey() const { return KeyedLoadField; }
 };
 
 
 class BinaryOpICStub : public HydrogenCodeStub {
  public:
   BinaryOpICStub(Isolate* isolate, Token::Value op, OverwriteMode mode)
       : HydrogenCodeStub(isolate, UNINITIALIZED), state_(isolate, op, mode) {}
 
   BinaryOpICStub(Isolate* isolate, const BinaryOpIC::State& state)
       : HydrogenCodeStub(isolate), state_(state) {}
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const V8_OVERRIDE {
     return Code::BINARY_OP_IC;
   }
 
   virtual InlineCacheState GetICState() V8_FINAL V8_OVERRIDE {
     return state_.GetICState();
   }
 
-  virtual ExtraICState GetExtraICState() V8_FINAL V8_OVERRIDE {
+  virtual ExtraICState GetExtraICState() const V8_FINAL V8_OVERRIDE {
     return state_.GetExtraICState();
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   const BinaryOpIC::State& state() const { return state_; }
 
-  virtual void PrintState(StringStream* stream) V8_FINAL V8_OVERRIDE;
+  virtual OStream& PrintState(OStream& os) const V8_FINAL V8_OVERRIDE;  // NOLINT
 
-  virtual Major MajorKey() V8_OVERRIDE { return BinaryOpIC; }
-  virtual int NotMissMinorKey() V8_FINAL V8_OVERRIDE {
+  virtual Major MajorKey() const V8_OVERRIDE { return BinaryOpIC; }
+  virtual int NotMissMinorKey() const V8_FINAL V8_OVERRIDE {
     return GetExtraICState();
   }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLeft = 0;
   static const int kRight = 1;
 
  private:
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpIC::State& state);
@@ skipping 21 matching lines @@
   }
 
   virtual Code::Kind GetCodeKind() const V8_OVERRIDE {
     return Code::BINARY_OP_IC;
   }
 
   virtual InlineCacheState GetICState() V8_OVERRIDE {
     return state_.GetICState();
   }
 
-  virtual ExtraICState GetExtraICState() V8_OVERRIDE {
+  virtual ExtraICState GetExtraICState() const V8_OVERRIDE {
     return state_.GetExtraICState();
   }
 
   virtual void Generate(MacroAssembler* masm) V8_OVERRIDE;
 
-  virtual void PrintState(StringStream* stream) V8_OVERRIDE;
+  virtual OStream& PrintState(OStream& os) const V8_OVERRIDE;  // NOLINT
 
-  virtual Major MajorKey() V8_OVERRIDE { return BinaryOpICWithAllocationSite; }
-  virtual int MinorKey() V8_OVERRIDE { return GetExtraICState(); }
+  virtual Major MajorKey() const V8_OVERRIDE {
+    return BinaryOpICWithAllocationSite;
+  }
+  virtual int MinorKey() const V8_OVERRIDE { return GetExtraICState(); }
 
  private:
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpIC::State& state);
 
   BinaryOpIC::State state_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryOpICWithAllocationSiteStub);
 };
 
@@ skipping 13 matching lines @@
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const V8_FINAL V8_OVERRIDE {
     return Code::STUB;
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
-  virtual Major MajorKey() V8_OVERRIDE {
+  virtual Major MajorKey() const V8_OVERRIDE {
     return BinaryOpWithAllocationSite;
   }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kAllocationSite = 0;
   static const int kLeft = 1;
   static const int kRight = 2;
 };
 
 
@@ skipping 35 matching lines @@
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLeft = 0;
   static const int kRight = 1;
 
  private:
   class StringAddFlagsBits: public BitField<StringAddFlags, 0, 2> {};
   class PretenureFlagBits: public BitField<PretenureFlag, 2, 1> {};
   uint32_t bit_field_;
 
-  virtual Major MajorKey() V8_OVERRIDE { return StringAdd; }
-  virtual int NotMissMinorKey() V8_OVERRIDE { return bit_field_; }
+  virtual Major MajorKey() const V8_OVERRIDE { return StringAdd; }
+  virtual int NotMissMinorKey() const V8_OVERRIDE { return bit_field_; }
 
-  virtual void PrintBaseName(StringStream* stream) V8_OVERRIDE;
+  virtual OStream& PrintBaseName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
   DISALLOW_COPY_AND_ASSIGN(StringAddStub);
 };
 
 
 class ICCompareStub: public PlatformCodeStub {
  public:
   ICCompareStub(Isolate* isolate,
                 Token::Value op,
                 CompareIC::State left,
@@ skipping 22 matching lines @@
  private:
   class OpField: public BitField<int, 0, 3> { };
   class LeftStateField: public BitField<int, 3, 4> { };
   class RightStateField: public BitField<int, 7, 4> { };
   class HandlerStateField: public BitField<int, 11, 4> { };
 
   virtual void FinishCode(Handle<Code> code) {
     code->set_stub_info(MinorKey());
   }
 
-  virtual CodeStub::Major MajorKey() { return CompareIC; }
-  virtual int MinorKey();
+  virtual CodeStub::Major MajorKey() const { return CompareIC; }
+  virtual int MinorKey() const;
 
   virtual Code::Kind GetCodeKind() const { return Code::COMPARE_IC; }
 
   void GenerateSmis(MacroAssembler* masm);
   void GenerateNumbers(MacroAssembler* masm);
   void GenerateInternalizedStrings(MacroAssembler* masm);
   void GenerateStrings(MacroAssembler* masm);
   void GenerateUniqueNames(MacroAssembler* masm);
   void GenerateObjects(MacroAssembler* masm);
   void GenerateMiss(MacroAssembler* masm);
@@ skipping 52 matching lines @@
       return MONOMORPHIC;
     } else {
       return PREMONOMORPHIC;
     }
   }
 
   virtual Code::Kind GetCodeKind() const { return Code::COMPARE_NIL_IC; }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
-  virtual ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() const {
     return NilValueField::encode(nil_value_) |
            TypesField::encode(state_.ToIntegral());
   }
 
   void UpdateStatus(Handle<Object> object);
 
   bool IsMonomorphic() const { return state_.Contains(MONOMORPHIC_MAP); }
   NilValue GetNilValue() const { return nil_value_; }
   void ClearState() { state_.RemoveAll(); }
 
-  virtual void PrintState(StringStream* stream);
-  virtual void PrintBaseName(StringStream* stream);
+  virtual OStream& PrintState(OStream& os) const V8_OVERRIDE;  // NOLINT
+  virtual OStream& PrintBaseName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
  private:
   friend class CompareNilIC;
 
   enum CompareNilType {
     UNDEFINED,
     NULL_TYPE,
     MONOMORPHIC_MAP,
     GENERIC,
     NUMBER_OF_TYPES
   };
 
   // At most 6 different types can be distinguished, because the Code object
   // only has room for a single byte to hold a set and there are two more
   // boolean flags we need to store. :-P
   STATIC_ASSERT(NUMBER_OF_TYPES <= 6);
 
   class State : public EnumSet<CompareNilType, byte> {
    public:
     State() : EnumSet<CompareNilType, byte>(0) { }
     explicit State(byte bits) : EnumSet<CompareNilType, byte>(bits) { }
-
-    void Print(StringStream* stream) const;
   };
+  friend OStream& operator<<(OStream& os, const State& s);
 
   CompareNilICStub(Isolate* isolate,
                    NilValue nil,
                    InitializationState init_state)
       : HydrogenCodeStub(isolate, init_state), nil_value_(nil) { }
 
   class NilValueField : public BitField<NilValue, 0, 1> {};
   class TypesField    : public BitField<byte,     1, NUMBER_OF_TYPES> {};
 
-  virtual CodeStub::Major MajorKey() { return CompareNilIC; }
-  virtual int NotMissMinorKey() { return GetExtraICState(); }
+  virtual CodeStub::Major MajorKey() const { return CompareNilIC; }
+  virtual int NotMissMinorKey() const { return GetExtraICState(); }
 
   NilValue nil_value_;
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(CompareNilICStub);
 };
 
 
+OStream& operator<<(OStream& os, const CompareNilICStub::State& s);
+
+
 class CEntryStub : public PlatformCodeStub {
  public:
   CEntryStub(Isolate* isolate,
              int result_size,
              SaveFPRegsMode save_doubles = kDontSaveFPRegs)
       : PlatformCodeStub(isolate),
         result_size_(result_size),
         save_doubles_(save_doubles) { }
 
   void Generate(MacroAssembler* masm);
 
   // The version of this stub that doesn't save doubles is generated ahead of
   // time, so it's OK to call it from other stubs that can't cope with GC during
   // their code generation.  On machines that always have gp registers (x64) we
   // can generate both variants ahead of time.
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   // Number of pointers/values returned.
   const int result_size_;
   SaveFPRegsMode save_doubles_;
 
-  Major MajorKey() { return CEntry; }
-  int MinorKey();
+  Major MajorKey() const { return CEntry; }
+  int MinorKey() const;
 
   bool NeedsImmovableCode();
 };
 
 
 class JSEntryStub : public PlatformCodeStub {
  public:
   explicit JSEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
   void Generate(MacroAssembler* masm) { GenerateBody(masm, false); }
 
  protected:
   void GenerateBody(MacroAssembler* masm, bool is_construct);
 
  private:
-  Major MajorKey() { return JSEntry; }
-  int MinorKey() { return 0; }
+  Major MajorKey() const { return JSEntry; }
+  int MinorKey() const { return 0; }
 
   virtual void FinishCode(Handle<Code> code);
 
   int handler_offset_;
 };
 
 
 class JSConstructEntryStub : public JSEntryStub {
  public:
   explicit JSConstructEntryStub(Isolate* isolate) : JSEntryStub(isolate) { }
 
   void Generate(MacroAssembler* masm) { GenerateBody(masm, true); }
 
  private:
-  int MinorKey() { return 1; }
+  int MinorKey() const { return 1; }
 
-  virtual void PrintName(StringStream* stream) {
-    stream->Add("JSConstructEntryStub");
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE {  // NOLINT
+    return os << "JSConstructEntryStub";
   }
 };
 
 
 class ArgumentsAccessStub: public PlatformCodeStub {
  public:
   enum Type {
     READ_ELEMENT,
     NEW_SLOPPY_FAST,
     NEW_SLOPPY_SLOW,
     NEW_STRICT
   };
 
   ArgumentsAccessStub(Isolate* isolate, Type type)
       : PlatformCodeStub(isolate), type_(type) { }
 
  private:
   Type type_;
 
-  Major MajorKey() { return ArgumentsAccess; }
-  int MinorKey() { return type_; }
+  Major MajorKey() const { return ArgumentsAccess; }
+  int MinorKey() const { return type_; }
 
   void Generate(MacroAssembler* masm);
   void GenerateReadElement(MacroAssembler* masm);
   void GenerateNewStrict(MacroAssembler* masm);
   void GenerateNewSloppyFast(MacroAssembler* masm);
   void GenerateNewSloppySlow(MacroAssembler* masm);
 
-  virtual void PrintName(StringStream* stream);
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 };
 
 
 class RegExpExecStub: public PlatformCodeStub {
  public:
   explicit RegExpExecStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
  private:
-  Major MajorKey() { return RegExpExec; }
-  int MinorKey() { return 0; }
+  Major MajorKey() const { return RegExpExec; }
+  int MinorKey() const { return 0; }
 
   void Generate(MacroAssembler* masm);
 };
 
 
 class RegExpConstructResultStub V8_FINAL : public HydrogenCodeStub {
  public:
   explicit RegExpConstructResultStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) { }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
-  virtual Major MajorKey() V8_OVERRIDE { return RegExpConstructResult; }
-  virtual int NotMissMinorKey() V8_OVERRIDE { return 0; }
+  virtual Major MajorKey() const V8_OVERRIDE { return RegExpConstructResult; }
+  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
 
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLength = 0;
   static const int kIndex = 1;
   static const int kInput = 2;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RegExpConstructResultStub);
 };
 
 
 class CallFunctionStub: public PlatformCodeStub {
  public:
   CallFunctionStub(Isolate* isolate, int argc, CallFunctionFlags flags)
       : PlatformCodeStub(isolate), argc_(argc), flags_(flags) { }
 
   void Generate(MacroAssembler* masm);
 
   static int ExtractArgcFromMinorKey(int minor_key) {
     return ArgcBits::decode(minor_key);
   }
 
  private:
   int argc_;
   CallFunctionFlags flags_;
 
-  virtual void PrintName(StringStream* stream);
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
   // Minor key encoding in 32 bits with Bitfield <Type, shift, size>.
   class FlagBits: public BitField<CallFunctionFlags, 0, 2> {};
   class ArgcBits: public BitField<unsigned, 2, 32 - 2> {};
 
-  Major MajorKey() { return CallFunction; }
-  int MinorKey() {
+  Major MajorKey() const { return CallFunction; }
+  int MinorKey() const {
     // Encode the parameters in a unique 32 bit value.
     return FlagBits::encode(flags_) | ArgcBits::encode(argc_);
   }
 
   bool CallAsMethod() {
     return flags_ == CALL_AS_METHOD || flags_ == WRAP_AND_CALL;
   }
 
   bool NeedsChecks() {
     return flags_ != WRAP_AND_CALL;
   }
 };
 
 
 class CallConstructStub: public PlatformCodeStub {
  public:
   CallConstructStub(Isolate* isolate, CallConstructorFlags flags)
       : PlatformCodeStub(isolate), flags_(flags) {}
 
   void Generate(MacroAssembler* masm);
 
   virtual void FinishCode(Handle<Code> code) {
     code->set_has_function_cache(RecordCallTarget());
   }
 
  private:
   CallConstructorFlags flags_;
 
-  virtual void PrintName(StringStream* stream);
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
-  Major MajorKey() { return CallConstruct; }
-  int MinorKey() { return flags_; }
+  Major MajorKey() const { return CallConstruct; }
+  int MinorKey() const { return flags_; }
 
-  bool RecordCallTarget() {
+  bool RecordCallTarget() const {
     return (flags_ & RECORD_CONSTRUCTOR_TARGET) != 0;
   }
 };
 
 
 enum StringIndexFlags {
   // Accepts smis or heap numbers.
   STRING_INDEX_IS_NUMBER,
 
   // Accepts smis or heap numbers that are valid array indices
@@ skipping 170 matching lines @@
  public:
   explicit KeyedLoadDictionaryElementStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return KeyedLoadElement; }
-  int NotMissMinorKey() { return DICTIONARY_ELEMENTS; }
+  Major MajorKey() const { return KeyedLoadElement; }
+  int NotMissMinorKey() const { return DICTIONARY_ELEMENTS; }
 
   DISALLOW_COPY_AND_ASSIGN(KeyedLoadDictionaryElementStub);
 };
 
 
 class KeyedLoadDictionaryElementPlatformStub : public PlatformCodeStub {
  public:
   explicit KeyedLoadDictionaryElementPlatformStub(Isolate* isolate)
       : PlatformCodeStub(isolate) {}
 
   void Generate(MacroAssembler* masm);
 
  private:
-  Major MajorKey() { return KeyedLoadElement; }
-  int MinorKey() { return DICTIONARY_ELEMENTS; }
+  Major MajorKey() const { return KeyedLoadElement; }
+  int MinorKey() const { return DICTIONARY_ELEMENTS; }
 
   DISALLOW_COPY_AND_ASSIGN(KeyedLoadDictionaryElementPlatformStub);
 };
 
 
 class KeyedLoadGenericElementStub : public HydrogenCodeStub {
  public:
   explicit KeyedLoadGenericElementStub(Isolate *isolate)
       : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const { return Code::KEYED_LOAD_IC; }
   virtual InlineCacheState GetICState() { return GENERIC; }
 
  private:
-  Major MajorKey() { return KeyedLoadGeneric; }
-  int NotMissMinorKey() { return 0; }
+  Major MajorKey() const { return KeyedLoadGeneric; }
+  int NotMissMinorKey() const { return 0; }
 
   DISALLOW_COPY_AND_ASSIGN(KeyedLoadGenericElementStub);
 };
 
 
 class DoubleToIStub : public PlatformCodeStub {
  public:
   DoubleToIStub(Isolate* isolate,
                 Register source,
                 Register destination,
@@ skipping 43 matching lines @@
         kBitsPerRegisterNumber> {};  // NOLINT
   class IsTruncatingBits:
       public BitField<bool, 2 * kBitsPerRegisterNumber, 1> {};  // NOLINT
   class OffsetBits:
       public BitField<int, 2 * kBitsPerRegisterNumber + 1, 3> {};  // NOLINT
   class SkipFastPathBits:
       public BitField<int, 2 * kBitsPerRegisterNumber + 4, 1> {};  // NOLINT
   class SSE3Bits:
       public BitField<int, 2 * kBitsPerRegisterNumber + 5, 1> {};  // NOLINT
 
-  Major MajorKey() { return DoubleToI; }
-  int MinorKey() { return bit_field_; }
+  Major MajorKey() const { return DoubleToI; }
+  int MinorKey() const { return bit_field_; }
 
   int bit_field_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToIStub);
 };
 
 
 class KeyedLoadFastElementStub : public HydrogenCodeStub {
  public:
   KeyedLoadFastElementStub(Isolate* isolate,
@@ skipping 15 matching lines @@
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 8, 1> {};
   uint32_t bit_field_;
 
-  Major MajorKey() { return KeyedLoadElement; }
-  int NotMissMinorKey() { return bit_field_; }
+  Major MajorKey() const { return KeyedLoadElement; }
+  int NotMissMinorKey() const { return bit_field_; }
 
   DISALLOW_COPY_AND_ASSIGN(KeyedLoadFastElementStub);
 };
 
 
 class KeyedStoreFastElementStub : public HydrogenCodeStub {
  public:
   KeyedStoreFastElementStub(Isolate* isolate,
                             bool is_js_array,
                             ElementsKind elements_kind,
@@ skipping 20 matching lines @@
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
   class ElementsKindBits: public BitField<ElementsKind,      0, 8> {};
   class StoreModeBits: public BitField<KeyedAccessStoreMode, 8, 4> {};
   class IsJSArrayBits: public BitField<bool,                12, 1> {};
   uint32_t bit_field_;
 
-  Major MajorKey() { return KeyedStoreElement; }
-  int NotMissMinorKey() { return bit_field_; }
+  Major MajorKey() const { return KeyedStoreElement; }
+  int NotMissMinorKey() const { return bit_field_; }
 
   DISALLOW_COPY_AND_ASSIGN(KeyedStoreFastElementStub);
 };
 
 
 class TransitionElementsKindStub : public HydrogenCodeStub {
  public:
   TransitionElementsKindStub(Isolate* isolate,
                              ElementsKind from_kind,
                              ElementsKind to_kind,
@@ skipping 19 matching lines @@
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
   class FromKindBits: public BitField<ElementsKind, 8, 8> {};
   class ToKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 16, 1> {};
   uint32_t bit_field_;
 
-  Major MajorKey() { return TransitionElementsKind; }
-  int NotMissMinorKey() { return bit_field_; }
+  Major MajorKey() const { return TransitionElementsKind; }
+  int NotMissMinorKey() const { return bit_field_; }
 
   DISALLOW_COPY_AND_ASSIGN(TransitionElementsKindStub);
 };
 
 
 class ArrayConstructorStubBase : public HydrogenCodeStub {
  public:
   ArrayConstructorStubBase(Isolate* isolate,
                            ElementsKind kind,
                            AllocationSiteOverrideMode override_mode)
@@ skipping 16 matching lines @@
   }
 
   static void GenerateStubsAheadOfTime(Isolate* isolate);
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kConstructor = 0;
   static const int kAllocationSite = 1;
 
  protected:
-  void BasePrintName(const char* name, StringStream* stream);
+  OStream& BasePrintName(OStream& os, const char* name) const;  // NOLINT
 
  private:
-  int NotMissMinorKey() { return bit_field_; }
+  int NotMissMinorKey() const { return bit_field_; }
 
   // Ensure data fits within available bits.
   STATIC_ASSERT(LAST_ALLOCATION_SITE_OVERRIDE_MODE == 1);
 
   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
   class AllocationSiteOverrideModeBits: public
       BitField<AllocationSiteOverrideMode, 8, 1> {};  // NOLINT
   uint32_t bit_field_;
 
   DISALLOW_COPY_AND_ASSIGN(ArrayConstructorStubBase);
 };
 
 
 class ArrayNoArgumentConstructorStub : public ArrayConstructorStubBase {
  public:
   ArrayNoArgumentConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return ArrayNoArgumentConstructor; }
+  Major MajorKey() const { return ArrayNoArgumentConstructor; }
 
-  virtual void PrintName(StringStream* stream) {
-    BasePrintName("ArrayNoArgumentConstructorStub", stream);
+  virtual OStream& PrintName(OStream& os) const V8_OVERRIDE {  // NOLINT
+    return BasePrintName(os, "ArrayNoArgumentConstructorStub");
   }
 
   DISALLOW_COPY_AND_ASSIGN(ArrayNoArgumentConstructorStub);
 };
 
 
 class ArraySingleArgumentConstructorStub : public ArrayConstructorStubBase {
  public:
   ArraySingleArgumentConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return ArraySingleArgumentConstructor; }
+  Major MajorKey() const { return ArraySingleArgumentConstructor; }
 
-  virtual void PrintName(StringStream* stream) {
-    BasePrintName("ArraySingleArgumentConstructorStub", stream);
+  virtual OStream& PrintName(OStream& os) const {  // NOLINT
+    return BasePrintName(os, "ArraySingleArgumentConstructorStub");
   }
 
   DISALLOW_COPY_AND_ASSIGN(ArraySingleArgumentConstructorStub);
 };
 
 
 class ArrayNArgumentsConstructorStub : public ArrayConstructorStubBase {
  public:
   ArrayNArgumentsConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return ArrayNArgumentsConstructor; }
+  Major MajorKey() const { return ArrayNArgumentsConstructor; }
 
-  virtual void PrintName(StringStream* stream) {
-    BasePrintName("ArrayNArgumentsConstructorStub", stream);
+  virtual OStream& PrintName(OStream& os) const {  // NOLINT
+    return BasePrintName(os, "ArrayNArgumentsConstructorStub");
   }
 
   DISALLOW_COPY_AND_ASSIGN(ArrayNArgumentsConstructorStub);
 };
 
 
 class InternalArrayConstructorStubBase : public HydrogenCodeStub {
  public:
   InternalArrayConstructorStubBase(Isolate* isolate, ElementsKind kind)
       : HydrogenCodeStub(isolate) {
     kind_ = kind;
   }
 
   static void GenerateStubsAheadOfTime(Isolate* isolate);
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kConstructor = 0;
 
   ElementsKind elements_kind() const { return kind_; }
 
  private:
-  int NotMissMinorKey() { return kind_; }
+  int NotMissMinorKey() const { return kind_; }
 
   ElementsKind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(InternalArrayConstructorStubBase);
 };
 
 
 class InternalArrayNoArgumentConstructorStub : public
     InternalArrayConstructorStubBase {
  public:
   InternalArrayNoArgumentConstructorStub(Isolate* isolate,
                                          ElementsKind kind)
       : InternalArrayConstructorStubBase(isolate, kind) { }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return InternalArrayNoArgumentConstructor; }
+  Major MajorKey() const { return InternalArrayNoArgumentConstructor; }
 
   DISALLOW_COPY_AND_ASSIGN(InternalArrayNoArgumentConstructorStub);
 };
 
 
 class InternalArraySingleArgumentConstructorStub : public
     InternalArrayConstructorStubBase {
  public:
   InternalArraySingleArgumentConstructorStub(Isolate* isolate,
                                              ElementsKind kind)
       : InternalArrayConstructorStubBase(isolate, kind) { }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return InternalArraySingleArgumentConstructor; }
+  Major MajorKey() const { return InternalArraySingleArgumentConstructor; }
 
   DISALLOW_COPY_AND_ASSIGN(InternalArraySingleArgumentConstructorStub);
 };
 
 
 class InternalArrayNArgumentsConstructorStub : public
     InternalArrayConstructorStubBase {
  public:
   InternalArrayNArgumentsConstructorStub(Isolate* isolate, ElementsKind kind)
       : InternalArrayConstructorStubBase(isolate, kind) { }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
-  Major MajorKey() { return InternalArrayNArgumentsConstructor; }
+  Major MajorKey() const { return InternalArrayNArgumentsConstructor; }
 
   DISALLOW_COPY_AND_ASSIGN(InternalArrayNArgumentsConstructorStub);
 };
 
 
 class KeyedStoreElementStub : public PlatformCodeStub {
  public:
   KeyedStoreElementStub(Isolate* isolate,
                         bool is_js_array,
                         ElementsKind elements_kind,
                         KeyedAccessStoreMode store_mode)
       : PlatformCodeStub(isolate),
         is_js_array_(is_js_array),
         elements_kind_(elements_kind),
         store_mode_(store_mode) { }
 
-  Major MajorKey() { return KeyedStoreElement; }
-  int MinorKey() {
+  Major MajorKey() const { return KeyedStoreElement; }
+  int MinorKey() const {
     return ElementsKindBits::encode(elements_kind_) |
         IsJSArrayBits::encode(is_js_array_) |
         StoreModeBits::encode(store_mode_);
   }
 
   void Generate(MacroAssembler* masm);
 
  private:
   class ElementsKindBits: public BitField<ElementsKind,      0, 8> {};
   class StoreModeBits: public BitField<KeyedAccessStoreMode, 8, 4> {};
@@ skipping 24 matching lines @@
   // At most 8 different types can be distinguished, because the Code object
   // only has room for a single byte to hold a set of these types. :-P
   STATIC_ASSERT(NUMBER_OF_TYPES <= 8);
 
   class Types : public EnumSet<Type, byte> {
    public:
     Types() : EnumSet<Type, byte>(0) {}
     explicit Types(byte bits) : EnumSet<Type, byte>(bits) {}
 
     byte ToByte() const { return ToIntegral(); }
-    void Print(StringStream* stream) const;
     bool UpdateStatus(Handle<Object> object);
     bool NeedsMap() const;
     bool CanBeUndetectable() const;
     bool IsGeneric() const { return ToIntegral() == Generic().ToIntegral(); }
 
     static Types Generic() { return Types((1 << NUMBER_OF_TYPES) - 1); }
   };
 
   ToBooleanStub(Isolate* isolate, Types types = Types())
       : HydrogenCodeStub(isolate), types_(types) { }
   ToBooleanStub(Isolate* isolate, ExtraICState state)
       : HydrogenCodeStub(isolate), types_(static_cast<byte>(state)) { }
 
   bool UpdateStatus(Handle<Object> object);
   Types GetTypes() { return types_; }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   virtual Code::Kind GetCodeKind() const { return Code::TO_BOOLEAN_IC; }
-  virtual void PrintState(StringStream* stream);
+  virtual OStream& PrintState(OStream& os) const V8_OVERRIDE;  // NOLINT
 
   virtual bool SometimesSetsUpAFrame() { return false; }
 
   static void InstallDescriptors(Isolate* isolate) {
     ToBooleanStub stub(isolate);
     stub.InitializeInterfaceDescriptor(
         isolate->code_stub_interface_descriptor(CodeStub::ToBoolean));
   }
 
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     return ToBooleanStub(isolate, UNINITIALIZED).GetCode();
   }
 
-  virtual ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() const {
     return types_.ToIntegral();
   }
 
   virtual InlineCacheState GetICState() {
     if (types_.IsEmpty()) {
       return ::v8::internal::UNINITIALIZED;
     } else {
       return MONOMORPHIC;
     }
   }
 
  private:
-  Major MajorKey() { return ToBoolean; }
-  int NotMissMinorKey() { return GetExtraICState(); }
+  Major MajorKey() const { return ToBoolean; }
+  int NotMissMinorKey() const { return GetExtraICState(); }
 
   ToBooleanStub(Isolate* isolate, InitializationState init_state) :
       HydrogenCodeStub(isolate, init_state) {}
 
   Types types_;
 };
 
 
+OStream& operator<<(OStream& os, const ToBooleanStub::Types& t);
+
+
 class ElementsTransitionAndStoreStub : public HydrogenCodeStub {
  public:
   ElementsTransitionAndStoreStub(Isolate* isolate,
                                  ElementsKind from_kind,
                                  ElementsKind to_kind,
                                  bool is_jsarray,
                                  KeyedAccessStoreMode store_mode)
       : HydrogenCodeStub(isolate),
         from_kind_(from_kind),
         to_kind_(to_kind),
         is_jsarray_(is_jsarray),
         store_mode_(store_mode) {}
 
   ElementsKind from_kind() const { return from_kind_; }
   ElementsKind to_kind() const { return to_kind_; }
   bool is_jsarray() const { return is_jsarray_; }
   KeyedAccessStoreMode store_mode() const { return store_mode_; }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
   class FromBits:      public BitField<ElementsKind,          0, 8> {};
   class ToBits:        public BitField<ElementsKind,          8, 8> {};
   class IsJSArrayBits: public BitField<bool,                 16, 1> {};
   class StoreModeBits: public BitField<KeyedAccessStoreMode, 17, 4> {};
 
-  Major MajorKey() { return ElementsTransitionAndStore; }
-  int NotMissMinorKey() {
+  Major MajorKey() const { return ElementsTransitionAndStore; }
+  int NotMissMinorKey() const {
     return FromBits::encode(from_kind_) |
         ToBits::encode(to_kind_) |
         IsJSArrayBits::encode(is_jsarray_) |
         StoreModeBits::encode(store_mode_);
   }
 
   ElementsKind from_kind_;
   ElementsKind to_kind_;
   bool is_jsarray_;
   KeyedAccessStoreMode store_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(ElementsTransitionAndStoreStub);
 };
 
 
 class StoreArrayLiteralElementStub : public PlatformCodeStub {
  public:
   explicit StoreArrayLiteralElementStub(Isolate* isolate)
       : PlatformCodeStub(isolate) { }
 
  private:
-  Major MajorKey() { return StoreArrayLiteralElement; }
-  int MinorKey() { return 0; }
+  Major MajorKey() const { return StoreArrayLiteralElement; }
+  int MinorKey() const { return 0; }
 
   void Generate(MacroAssembler* masm);
 
   DISALLOW_COPY_AND_ASSIGN(StoreArrayLiteralElementStub);
 };
 
 
 class StubFailureTrampolineStub : public PlatformCodeStub {
  public:
   StubFailureTrampolineStub(Isolate* isolate, StubFunctionMode function_mode)
       : PlatformCodeStub(isolate),
         function_mode_(function_mode) {}
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   class FunctionModeField: public BitField<StubFunctionMode,    0, 1> {};
 
-  Major MajorKey() { return StubFailureTrampoline; }
-  int MinorKey() {
+  Major MajorKey() const { return StubFailureTrampoline; }
+  int MinorKey() const {
     return FunctionModeField::encode(function_mode_);
   }
 
   void Generate(MacroAssembler* masm);
 
   StubFunctionMode function_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(StubFailureTrampolineStub);
 };
 
 
 class ProfileEntryHookStub : public PlatformCodeStub {
  public:
   explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   // The profile entry hook function is not allowed to cause a GC.
   virtual bool SometimesSetsUpAFrame() { return false; }
 
   // Generates a call to the entry hook if it's enabled.
   static void MaybeCallEntryHook(MacroAssembler* masm);
 
  private:
   static void EntryHookTrampoline(intptr_t function,
                                   intptr_t stack_pointer,
                                   Isolate* isolate);
 
-  Major MajorKey() { return ProfileEntryHook; }
-  int MinorKey() { return 0; }
+  Major MajorKey() const { return ProfileEntryHook; }
+  int MinorKey() const { return 0; }
 
   void Generate(MacroAssembler* masm);
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_