[turbofan] Print APIs are for debugging.

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>
@@ skipping 87 matching lines @@
   bool EqualsCanonicalized(const InstructionOperand& that) const {
     return this->GetCanonicalizedValue() == that.GetCanonicalizedValue();
   }
 
   bool CompareCanonicalized(const InstructionOperand& that) const {
     return this->GetCanonicalizedValue() < that.GetCanonicalizedValue();
   }
 
   bool InterferesWith(const InstructionOperand& that) const;
 
-  void Print(std::ostream& os, const RegisterConfiguration* config) const;
-  void Print(std::ostream& os) const;
+  // APIs to aid debugging. For general-stream APIs, use operator<<
+  void Print(const RegisterConfiguration* config) const;
+  void Print() const;
 
  protected:
   explicit InstructionOperand(Kind kind) : value_(KindField::encode(kind)) {}
 
   inline uint64_t GetCanonicalizedValue() const;
 
   class KindField : public BitField64<Kind, 0, 3> {};
 
   uint64_t value_;
 };
@@ skipping 545 matching lines @@
     return IsEliminated() || source_.EqualsCanonicalized(destination_);
   }
 
   // We clear both operands to indicate move that's been eliminated.
   void Eliminate() { source_ = destination_ = InstructionOperand(); }
   bool IsEliminated() const {
     DCHECK_IMPLIES(source_.IsInvalid(), destination_.IsInvalid());
     return source_.IsInvalid();
   }
 
-  void Print(std::ostream& os, const RegisterConfiguration* config) const;
-  void Print(std::ostream& os) const;
+  // APIs to aid debugging. For general-stream APIs, use operator<<
+  void Print(const RegisterConfiguration* config) const;
+  void Print() const;
 
  private:
   InstructionOperand source_;
   InstructionOperand destination_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveOperands);
 };
 
 
 struct PrintableMoveOperands {
@@ skipping 218 matching lines @@
 
   // The block_id may be invalidated in JumpThreading. It is only important for
   // register allocation, to avoid searching for blocks from instruction
   // indexes.
   InstructionBlock* block() const { return block_; }
   void set_block(InstructionBlock* block) {
     DCHECK_NOT_NULL(block);
     block_ = block;
   }
 
-  void Print(std::ostream& os, const RegisterConfiguration* config) const;
-  void Print(std::ostream& os) const;
+  // APIs to aid debugging. For general-stream APIs, use operator<<
+  void Print(const RegisterConfiguration* config) const;
+  void Print() const;
 
  private:
   explicit Instruction(InstructionCode opcode);
 
   Instruction(InstructionCode opcode, size_t output_count,
               InstructionOperand* outputs, size_t input_count,
               InstructionOperand* inputs, size_t temp_count,
               InstructionOperand* temps);
 
   typedef BitField<size_t, 0, 8> OutputCountField;
@@ skipping 348 matching lines @@
   int32_t code_start_;   // start index of arch-specific code.
   int32_t code_end_;     // end index of arch-specific code.
   const bool deferred_;  // Block contains deferred code.
   const bool handler_;   // Block is a handler entry point.
   bool needs_frame_;
   bool must_construct_frame_;
   bool must_deconstruct_frame_;
   RpoNumber last_deferred_;
 };
 
+class InstructionSequence;
+
+struct PrintableInstructionBlock {
+  const RegisterConfiguration* register_configuration_;
+  const InstructionBlock* block_;
+  const InstructionSequence* code_;
+};
+
+std::ostream& operator<<(std::ostream& os,
+                         const PrintableInstructionBlock& printable_block);
+
 typedef ZoneDeque<Constant> ConstantDeque;
 typedef std::map<int, Constant, std::less<int>,
                  zone_allocator<std::pair<const int, Constant> > > ConstantMap;
 
 typedef ZoneDeque<Instruction*> InstructionDeque;
 typedef ZoneDeque<ReferenceMap*> ReferenceMapDeque;
 typedef ZoneVector<InstructionBlock*> InstructionBlocks;
 
 
 // Forward declarations.
@@ skipping 139 matching lines @@
   bool GetSourcePosition(const Instruction* instr,
                          SourcePosition* result) const;
   void SetSourcePosition(const Instruction* instr, SourcePosition value);
 
   bool ContainsCall() const {
     for (Instruction* instr : instructions_) {
       if (instr->IsCall()) return true;
     }
     return false;
   }
-  void Print(std::ostream& os, const RegisterConfiguration* config) const;
-  void Print(std::ostream& os) const;
 
-  void PrintBlock(std::ostream& os, const RegisterConfiguration* config,
-                  int block_id) const;
-  void PrintBlock(std::ostream& os, int block_id) const;
+  // APIs to aid debugging. For general-stream APIs, use operator<<
+  void Print(const RegisterConfiguration* config) const;
+  void Print() const;
+
+  void PrintBlock(const RegisterConfiguration* config, int block_id) const;
+  void PrintBlock(int block_id) const;
 
   void ValidateEdgeSplitForm() const;
   void ValidateDeferredBlockExitPaths() const;
   void ValidateDeferredBlockEntryPaths() const;
   void ValidateSSA() const;
 
  private:
   friend std::ostream& operator<<(std::ostream& os,
                                   const PrintableInstructionSequence& code);
 
@@ skipping 25 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_