trace-turbo should respect --redirect-code-traces

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/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/state-values-utils.h"
 
@@ skipping 50 matching lines @@
       return condition;
   }
   UNREACHABLE();
   return condition;
 }
 
 bool InstructionOperand::InterferesWith(const InstructionOperand& that) const {
   return EqualsCanonicalized(that);
 }
 
-void InstructionOperand::Print(const RegisterConfiguration* config) const {
-  OFStream os(stdout);
+void InstructionOperand::Print(std::ostream& os,
+                               const RegisterConfiguration* config) const {
   PrintableInstructionOperand wrapper;
   wrapper.register_configuration_ = config;
   wrapper.op_ = *this;
   os << wrapper << std::endl;
 }
 
-void InstructionOperand::Print() const { Print(GetRegConfig()); }
+void InstructionOperand::Print(std::ostream& os) const {
+  Print(os, GetRegConfig());
+}
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionOperand& printable) {
   const InstructionOperand& op = printable.op_;
   const RegisterConfiguration* conf = printable.register_configuration_;
   switch (op.kind()) {
     case InstructionOperand::UNALLOCATED: {
       const UnallocatedOperand* unalloc = UnallocatedOperand::cast(&op);
       os << "v" << unalloc->virtual_register();
       if (unalloc->basic_policy() == UnallocatedOperand::FIXED_SLOT) {
@@ skipping 102 matching lines @@
       }
       return os << "]";
     }
     case InstructionOperand::INVALID:
       return os << "(x)";
   }
   UNREACHABLE();
   return os;
 }
 
-void MoveOperands::Print(const RegisterConfiguration* config) const {
-  OFStream os(stdout);
+void MoveOperands::Print(std::ostream& os,
+                         const RegisterConfiguration* config) const {
   PrintableInstructionOperand wrapper;
   wrapper.register_configuration_ = config;
   wrapper.op_ = destination();
   os << wrapper << " = ";
   wrapper.op_ = source();
   os << wrapper << std::endl;
 }
 
-void MoveOperands::Print() const { Print(GetRegConfig()); }
+void MoveOperands::Print(std::ostream& os) const { Print(os, GetRegConfig()); }
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableMoveOperands& printable) {
   const MoveOperands& mo = *printable.move_operands_;
   PrintableInstructionOperand printable_op = {printable.register_configuration_,
                                               mo.destination()};
   os << printable_op;
   if (!mo.source().Equals(mo.destination())) {
     printable_op.op_ = mo.source();
     os << " = " << printable_op;
@@ skipping 84 matching lines @@
 bool Instruction::AreMovesRedundant() const {
   for (int i = Instruction::FIRST_GAP_POSITION;
        i <= Instruction::LAST_GAP_POSITION; i++) {
     if (parallel_moves_[i] != nullptr && !parallel_moves_[i]->IsRedundant()) {
       return false;
     }
   }
   return true;
 }
 
-
-void Instruction::Print(const RegisterConfiguration* config) const {
-  OFStream os(stdout);
+void Instruction::Print(std::ostream& os,
+                        const RegisterConfiguration* config) const {
   PrintableInstruction wrapper;
   wrapper.instr_ = this;
   wrapper.register_configuration_ = config;
   os << wrapper << std::endl;
 }
 
-void Instruction::Print() const { Print(GetRegConfig()); }
+void Instruction::Print(std::ostream& os) const { Print(os, GetRegConfig()); }
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableParallelMove& printable) {
   const ParallelMove& pm = *printable.parallel_move_;
   bool first = true;
   for (MoveOperands* move : pm) {
     if (move->IsEliminated()) continue;
     if (!first) os << " ";
     first = false;
     PrintableMoveOperands pmo = {printable.register_configuration_, move};
@@ skipping 530 matching lines @@
   *result = it->second;
   return true;
 }
 
 
 void InstructionSequence::SetSourcePosition(const Instruction* instr,
                                             SourcePosition value) {
   source_positions_.insert(std::make_pair(instr, value));
 }
 
-
-void InstructionSequence::Print(const RegisterConfiguration* config) const {
-  OFStream os(stdout);
+void InstructionSequence::Print(std::ostream& os,
+                                const RegisterConfiguration* config) const {
   PrintableInstructionSequence wrapper;
   wrapper.register_configuration_ = config;
   wrapper.sequence_ = this;
   os << wrapper << std::endl;
 }
 
-void InstructionSequence::Print() const { Print(GetRegConfig()); }
+void InstructionSequence::Print(std::ostream& os) const {
+  Print(os, GetRegConfig());
+}
 
-void InstructionSequence::PrintBlock(const RegisterConfiguration* config,
+void InstructionSequence::PrintBlock(std::ostream& os,
+                                     const RegisterConfiguration* config,
                                      int block_id) const {
-  OFStream os(stdout);
   RpoNumber rpo = RpoNumber::FromInt(block_id);
   const InstructionBlock* block = InstructionBlockAt(rpo);
   CHECK(block->rpo_number() == rpo);
 
   os << "B" << block->rpo_number();
   os << ": AO#" << block->ao_number();
   if (block->IsDeferred()) os << " (deferred)";
   if (!block->needs_frame()) os << " (no frame)";
   if (block->must_construct_frame()) os << " (construct frame)";
   if (block->must_deconstruct_frame()) os << " (deconstruct frame)";
@@ skipping 28 matching lines @@
     printable_instr.instr_ = InstructionAt(j);
     os << "   " << buf.start() << ": " << printable_instr << "\n";
   }
 
   for (RpoNumber succ : block->successors()) {
     os << " B" << succ.ToInt();
   }
   os << "\n";
 }
 
-void InstructionSequence::PrintBlock(int block_id) const {
-  PrintBlock(GetRegConfig(), block_id);
+void InstructionSequence::PrintBlock(std::ostream& os, int block_id) const {
+  PrintBlock(os, GetRegConfig(), block_id);
 }
 
 FrameStateDescriptor::FrameStateDescriptor(
     Zone* zone, FrameStateType type, BailoutId bailout_id,
     OutputFrameStateCombine state_combine, size_t parameters_count,
     size_t locals_count, size_t stack_count,
     MaybeHandle<SharedFunctionInfo> shared_info,
     FrameStateDescriptor* outer_state)
     : type_(type),
       bailout_id_(bailout_id),
@@ skipping 63 matching lines @@
   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.InstructionBlockCount(); i++) {
-    printable.sequence_->PrintBlock(printable.register_configuration_, i);
+    printable.sequence_->PrintBlock(os, printable.register_configuration_, i);
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8