Replace OStream with std::ostream.

src/compiler/simplified-operator.cc

 // 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.
 
 #include "src/compiler/simplified-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/types-inl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-OStream& operator<<(OStream& os, BaseTaggedness base_taggedness) {
+std::ostream& operator<<(std::ostream& os, BaseTaggedness base_taggedness) {
   switch (base_taggedness) {
     case kUntaggedBase:
       return os << "untagged base";
     case kTaggedBase:
       return os << "tagged base";
   }
   UNREACHABLE();
   return os;
 }
 
 
 bool operator==(ElementAccess const& lhs, ElementAccess const& rhs) {
   return lhs.base_is_tagged == rhs.base_is_tagged &&
          lhs.header_size == rhs.header_size && lhs.type == rhs.type &&
          lhs.machine_type == rhs.machine_type;
 }
 
 
 bool operator!=(ElementAccess const& lhs, ElementAccess const& rhs) {
   return !(lhs == rhs);
 }
 
 
-OStream& operator<<(OStream& os, ElementAccess const& access) {
+std::ostream& operator<<(std::ostream& os, ElementAccess const& access) {
   os << "[" << access.base_is_tagged << ", " << access.header_size << ", ";
   access.type->PrintTo(os);
   os << ", " << access.machine_type << "]";
   return os;
 }
 
 
 const FieldAccess& FieldAccessOf(const Operator* op) {
   DCHECK_NOT_NULL(op);
   DCHECK(op->opcode() == IrOpcode::kLoadField ||
          op->opcode() == IrOpcode::kStoreField);
   return OpParameter<FieldAccess>(op);
 }
 
 
 const ElementAccess& ElementAccessOf(const Operator* op) {
   DCHECK_NOT_NULL(op);
   DCHECK(op->opcode() == IrOpcode::kLoadElement ||
          op->opcode() == IrOpcode::kStoreElement);
   return OpParameter<ElementAccess>(op);
 }
 
 
 // Specialization for static parameters of type {FieldAccess}.
 template <>
 struct StaticParameterTraits<FieldAccess> {
-  static OStream& PrintTo(OStream& os, const FieldAccess& val) {
+  static std::ostream& PrintTo(std::ostream& os, const FieldAccess& val) {
     return os << val.offset;
   }
   static int HashCode(const FieldAccess& val) {
     return (val.offset < 16) | (val.machine_type & 0xffff);
   }
   static bool Equals(const FieldAccess& lhs, const FieldAccess& rhs) {
     return lhs.base_is_tagged == rhs.base_is_tagged &&
            lhs.offset == rhs.offset && lhs.machine_type == rhs.machine_type &&
            lhs.type->Is(rhs.type);
   }
 };
 
 
 // Specialization for static parameters of type {ElementAccess}.
 template <>
 struct StaticParameterTraits<ElementAccess> {
-  static OStream& PrintTo(OStream& os, const ElementAccess& access) {
+  static std::ostream& PrintTo(std::ostream& os, const ElementAccess& access) {
     return os << access;
   }
   static int HashCode(const ElementAccess& access) {
     return (access.header_size < 16) | (access.machine_type & 0xffff);
   }
   static bool Equals(const ElementAccess& lhs, const ElementAccess& rhs) {
     return lhs.base_is_tagged == rhs.base_is_tagged &&
            lhs.header_size == rhs.header_size &&
            lhs.machine_type == rhs.machine_type && lhs.type->Is(rhs.type);
   }
@@ skipping 74 matching lines @@
     return new (zone())                                                     \
         Operator1<Type>(IrOpcode::k##Name, Operator::kNoThrow | properties, \
                         input_count, output_count, #Name, access);          \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8