Replace OStream with std::ostream.

src/compiler/instruction.cc

 // 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.
 
 #include "src/compiler/instruction.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-OStream& operator<<(OStream& os, const InstructionOperand& op) {
+std::ostream& operator<<(std::ostream& os, const InstructionOperand& op) {
   switch (op.kind()) {
     case InstructionOperand::INVALID:
       return os << "(0)";
     case InstructionOperand::UNALLOCATED: {
       const UnallocatedOperand* unalloc = UnallocatedOperand::cast(&op);
       os << "v" << unalloc->virtual_register();
       if (unalloc->basic_policy() == UnallocatedOperand::FIXED_SLOT) {
         return os << "(=" << unalloc->fixed_slot_index() << "S)";
       }
       switch (unalloc->extended_policy()) {
@@ skipping 64 matching lines @@
 
 
 void InstructionOperand::TearDownCaches() {
 #define INSTRUCTION_OPERAND_TEARDOWN(name, type, number) \
   name##Operand::TearDownCache();
   INSTRUCTION_OPERAND_LIST(INSTRUCTION_OPERAND_TEARDOWN)
 #undef INSTRUCTION_OPERAND_TEARDOWN
 }
 
 
-OStream& operator<<(OStream& os, const MoveOperands& mo) {
+std::ostream& operator<<(std::ostream& os, const MoveOperands& mo) {
   os << *mo.destination();
   if (!mo.source()->Equals(mo.destination())) os << " = " << *mo.source();
   return os << ";";
 }
 
 
 bool ParallelMove::IsRedundant() const {
   for (int i = 0; i < move_operands_.length(); ++i) {
     if (!move_operands_[i].IsRedundant()) return false;
   }
   return true;
 }
 
 
-OStream& operator<<(OStream& os, const ParallelMove& pm) {
+std::ostream& operator<<(std::ostream& os, const ParallelMove& pm) {
   bool first = true;
   for (ZoneList<MoveOperands>::iterator move = pm.move_operands()->begin();
        move != pm.move_operands()->end(); ++move) {
     if (move->IsEliminated()) continue;
     if (!first) os << " ";
     first = false;
     os << *move;
   }
   return os;
 }
@@ skipping 21 matching lines @@
 
 
 void PointerMap::RecordUntagged(InstructionOperand* op, Zone* zone) {
   // Do not record arguments as pointers.
   if (op->IsStackSlot() && op->index() < 0) return;
   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   untagged_operands_.Add(op, zone);
 }
 
 
-OStream& operator<<(OStream& os, const PointerMap& pm) {
+std::ostream& operator<<(std::ostream& os, const PointerMap& pm) {
   os << "{";
   for (ZoneList<InstructionOperand*>::iterator op =
            pm.pointer_operands_.begin();
        op != pm.pointer_operands_.end(); ++op) {
     if (op != pm.pointer_operands_.begin()) os << ";";
     os << *op;
   }
   return os << "}";
 }
 
 
-OStream& operator<<(OStream& os, const ArchOpcode& ao) {
+std::ostream& operator<<(std::ostream& os, const ArchOpcode& ao) {
   switch (ao) {
 #define CASE(Name) \
   case k##Name:    \
     return os << #Name;
     ARCH_OPCODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return os;
 }
 
 
-OStream& operator<<(OStream& os, const AddressingMode& am) {
+std::ostream& operator<<(std::ostream& os, const AddressingMode& am) {
   switch (am) {
     case kMode_None:
       return os;
 #define CASE(Name)   \
   case kMode_##Name: \
     return os << #Name;
       TARGET_ADDRESSING_MODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return os;
 }
 
 
-OStream& operator<<(OStream& os, const FlagsMode& fm) {
+std::ostream& operator<<(std::ostream& os, const FlagsMode& fm) {
   switch (fm) {
     case kFlags_none:
       return os;
     case kFlags_branch:
       return os << "branch";
     case kFlags_set:
       return os << "set";
   }
   UNREACHABLE();
   return os;
 }
 
 
-OStream& operator<<(OStream& os, const FlagsCondition& fc) {
+std::ostream& operator<<(std::ostream& os, const FlagsCondition& fc) {
   switch (fc) {
     case kEqual:
       return os << "equal";
     case kNotEqual:
       return os << "not equal";
     case kSignedLessThan:
       return os << "signed less than";
     case kSignedGreaterThanOrEqual:
       return os << "signed greater than or equal";
     case kSignedLessThanOrEqual:
@@ skipping 23 matching lines @@
     case kOverflow:
       return os << "overflow";
     case kNotOverflow:
       return os << "not overflow";
   }
   UNREACHABLE();
   return os;
 }
 
 
-OStream& operator<<(OStream& os, const Instruction& instr) {
+std::ostream& operator<<(std::ostream& os, const Instruction& instr) {
   if (instr.OutputCount() > 1) os << "(";
   for (size_t i = 0; i < instr.OutputCount(); i++) {
     if (i > 0) os << ", ";
     os << *instr.OutputAt(i);
   }
 
   if (instr.OutputCount() > 1) os << ") = ";
   if (instr.OutputCount() == 1) os << " = ";
 
   if (instr.IsGapMoves()) {
@@ skipping 23 matching lines @@
   }
   if (instr.InputCount() > 0) {
     for (size_t i = 0; i < instr.InputCount(); i++) {
       os << " " << *instr.InputAt(i);
     }
   }
   return os << "\n";
 }
 
 
-OStream& operator<<(OStream& os, const Constant& constant) {
+std::ostream& operator<<(std::ostream& os, const Constant& constant) {
   switch (constant.type()) {
     case Constant::kInt32:
       return os << constant.ToInt32();
     case Constant::kInt64:
       return os << constant.ToInt64() << "l";
     case Constant::kFloat32:
       return os << constant.ToFloat32() << "f";
     case Constant::kFloat64:
       return os << constant.ToFloat64();
     case Constant::kExternalReference:
@@ skipping 99 matching lines @@
     InstructionSequence::StateId state_id) {
   return deoptimization_entries_[state_id.ToInt()];
 }
 
 
 int InstructionSequence::GetFrameStateDescriptorCount() {
   return static_cast<int>(deoptimization_entries_.size());
 }
 
 
-OStream& operator<<(OStream& os, const InstructionSequence& code) {
+std::ostream& operator<<(std::ostream& os, const InstructionSequence& code) {
   for (size_t i = 0; i < code.immediates_.size(); ++i) {
     Constant constant = code.immediates_[i];
     os << "IMM#" << i << ": " << constant << "\n";
   }
   int i = 0;
   for (ConstantMap::const_iterator it = code.constants_.begin();
        it != code.constants_.end(); ++i, ++it) {
     os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
   }
   for (int i = 0; i < code.BasicBlockCount(); i++) {
@@ skipping 46 matching lines @@
       os << " B" << (*iter)->id();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8