Replace OStream with std::ostream.

src/compiler/instruction.h

 // Copyright 2014 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_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
+#include <iosfwd>
 #include <map>
 #include <set>
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/instruction-codes.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/schedule.h"
 // TODO(titzer): don't include the macro-assembler?
 #include "src/macro-assembler.h"
 #include "src/zone-allocator.h"
 
 namespace v8 {
 namespace internal {
-
-// Forward declarations.
-class OStream;
-
 namespace compiler {
 
 // Forward declarations.
 class Linkage;
 
 // A couple of reserved opcodes are used for internal use.
 const InstructionCode kGapInstruction = -1;
 const InstructionCode kBlockStartInstruction = -2;
 const InstructionCode kSourcePositionInstruction = -3;
 
@@ skipping 46 matching lines @@
   static void TearDownCaches();
 
  protected:
   typedef BitField<Kind, 0, 3> KindField;
 
   unsigned value_;
 };
 
 typedef ZoneVector<InstructionOperand*> InstructionOperandVector;
 
-OStream& operator<<(OStream& os, const InstructionOperand& op);
+std::ostream& operator<<(std::ostream& os, const InstructionOperand& op);
 
 class UnallocatedOperand : public InstructionOperand {
  public:
   enum BasicPolicy { FIXED_SLOT, EXTENDED_POLICY };
 
   enum ExtendedPolicy {
     NONE,
     ANY,
     FIXED_REGISTER,
     FIXED_DOUBLE_REGISTER,
@@ skipping 198 matching lines @@
   bool IsEliminated() const {
     DCHECK(source_ != NULL || destination_ == NULL);
     return source_ == NULL;
   }
 
  private:
   InstructionOperand* source_;
   InstructionOperand* destination_;
 };
 
-OStream& operator<<(OStream& os, const MoveOperands& mo);
+std::ostream& operator<<(std::ostream& os, const MoveOperands& mo);
 
 template <InstructionOperand::Kind kOperandKind, int kNumCachedOperands>
 class SubKindOperand FINAL : public InstructionOperand {
  public:
   static SubKindOperand* Create(int index, Zone* zone) {
     DCHECK(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new (zone) SubKindOperand(index);
   }
 
@@ skipping 32 matching lines @@
 
   ZoneList<MoveOperands>* move_operands() { return &move_operands_; }
   const ZoneList<MoveOperands>* move_operands() const {
     return &move_operands_;
   }
 
  private:
   ZoneList<MoveOperands> move_operands_;
 };
 
-OStream& operator<<(OStream& os, const ParallelMove& pm);
+std::ostream& operator<<(std::ostream& os, const ParallelMove& pm);
 
 class PointerMap FINAL : public ZoneObject {
  public:
   explicit PointerMap(Zone* zone)
       : pointer_operands_(8, zone),
         untagged_operands_(0, zone),
         instruction_position_(-1) {}
 
   const ZoneList<InstructionOperand*>* GetNormalizedOperands() {
     for (int i = 0; i < untagged_operands_.length(); ++i) {
       RemovePointer(untagged_operands_[i]);
     }
     untagged_operands_.Clear();
     return &pointer_operands_;
   }
   int instruction_position() const { return instruction_position_; }
 
   void set_instruction_position(int pos) {
     DCHECK(instruction_position_ == -1);
     instruction_position_ = pos;
   }
 
   void RecordPointer(InstructionOperand* op, Zone* zone);
   void RemovePointer(InstructionOperand* op);
   void RecordUntagged(InstructionOperand* op, Zone* zone);
 
  private:
-  friend OStream& operator<<(OStream& os, const PointerMap& pm);
+  friend std::ostream& operator<<(std::ostream& os, const PointerMap& pm);
 
   ZoneList<InstructionOperand*> pointer_operands_;
   ZoneList<InstructionOperand*> untagged_operands_;
   int instruction_position_;
 };
 
-OStream& operator<<(OStream& os, const PointerMap& pm);
+std::ostream& operator<<(std::ostream& os, const PointerMap& pm);
 
 // TODO(titzer): s/PointerMap/ReferenceMap/
 class Instruction : public ZoneObject {
  public:
   size_t OutputCount() const { return OutputCountField::decode(bit_field_); }
   InstructionOperand* OutputAt(size_t i) const {
     DCHECK(i < OutputCount());
     return operands_[i];
   }
 
@@ skipping 119 matching lines @@
   typedef BitField<size_t, 24, 6> TempCountField;
   typedef BitField<bool, 30, 1> IsCallField;
   typedef BitField<bool, 31, 1> IsControlField;
 
   InstructionCode opcode_;
   uint32_t bit_field_;
   PointerMap* pointer_map_;
   InstructionOperand* operands_[1];
 };
 
-OStream& operator<<(OStream& os, const Instruction& instr);
+std::ostream& operator<<(std::ostream& os, const Instruction& instr);
 
 // Represents moves inserted before an instruction due to register allocation.
 // TODO(titzer): squash GapInstruction back into Instruction, since essentially
 // every instruction can possibly have moves inserted before it.
 class GapInstruction : public Instruction {
  public:
   enum InnerPosition {
     BEFORE,
     START,
     END,
@@ skipping 30 matching lines @@
 
  protected:
   explicit GapInstruction(InstructionCode opcode) : Instruction(opcode) {
     parallel_moves_[BEFORE] = NULL;
     parallel_moves_[START] = NULL;
     parallel_moves_[END] = NULL;
     parallel_moves_[AFTER] = NULL;
   }
 
  private:
-  friend OStream& operator<<(OStream& os, const Instruction& instr);
+  friend std::ostream& operator<<(std::ostream& os, const Instruction& instr);
   ParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
 };
 
 
 // This special kind of gap move instruction represents the beginning of a
 // block of code.
 // TODO(titzer): move code_start and code_end from BasicBlock to here.
 class BlockStartInstruction FINAL : public GapInstruction {
  public:
   BasicBlock* block() const { return block_; }
@@ skipping 182 matching lines @@
   FrameStateType type_;
   BailoutId bailout_id_;
   OutputFrameStateCombine frame_state_combine_;
   size_t parameters_count_;
   size_t locals_count_;
   size_t stack_count_;
   FrameStateDescriptor* outer_state_;
   MaybeHandle<JSFunction> jsfunction_;
 };
 
-OStream& operator<<(OStream& os, const Constant& constant);
+std::ostream& operator<<(std::ostream& os, const Constant& constant);
 
 typedef ZoneDeque<Constant> ConstantDeque;
 typedef std::map<int, Constant, std::less<int>,
                  zone_allocator<std::pair<int, Constant> > > ConstantMap;
 
 typedef ZoneDeque<Instruction*> InstructionDeque;
 typedef ZoneDeque<PointerMap*> PointerMapDeque;
 typedef ZoneVector<FrameStateDescriptor*> DeoptimizationVector;
 
 // Represents architecture-specific generated code before, during, and after
@@ skipping 110 matching lines @@
    private:
     explicit StateId(int id) : id_(id) {}
     int id_;
   };
 
   StateId AddFrameStateDescriptor(FrameStateDescriptor* descriptor);
   FrameStateDescriptor* GetFrameStateDescriptor(StateId deoptimization_id);
   int GetFrameStateDescriptorCount();
 
  private:
-  friend OStream& operator<<(OStream& os, const InstructionSequence& code);
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const InstructionSequence& code);
 
   typedef std::set<int, std::less<int>, ZoneIntAllocator> VirtualRegisterSet;
 
   Graph* graph_;
   Linkage* linkage_;
   Schedule* schedule_;
   ConstantMap constants_;
   ConstantDeque immediates_;
   InstructionDeque instructions_;
   int next_virtual_register_;
   PointerMapDeque pointer_maps_;
   VirtualRegisterSet doubles_;
   VirtualRegisterSet references_;
   Frame frame_;
   DeoptimizationVector deoptimization_entries_;
 };
 
-OStream& operator<<(OStream& os, const InstructionSequence& code);
+std::ostream& operator<<(std::ostream& os, const InstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_