Add IR printing into a supplied buffer.

vm/flow_graph_compiler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/debugger.h"
 #include "vm/disassembler.h"
+#include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_functions, false, "Trace entry of each function.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, optimization_counter_threshold);
 DECLARE_FLAG(bool, print_ast);
 DECLARE_FLAG(bool, report_usage_count);
+DECLARE_FLAG(bool, code_comments);
 
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     const ParsedFunction& parsed_function,
     const GrowableArray<BlockEntryInstr*>& block_order,
     bool is_optimizing)
     : FlowGraphVisitor(block_order),
       assembler_(assembler),
       parsed_function_(parsed_function),
@@ skipping 1080 matching lines @@
 
 
 void FlowGraphCompiler::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     __ Comment("B%d", i);
     // Compile the block entry.
     current_block_ = block_order_[i];
     Instruction* instr = current_block()->Accept(this);
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
-      __ Comment("@%d: instruction", instr->cid());
+      if (FLAG_code_comments) EmitComment(instr);
       instr = instr->Accept(this);
     }
 
     BlockEntryInstr* successor =
         (instr == NULL) ? NULL : instr->AsBlockEntry();
     if (successor != NULL) {
       // Block ended with a "goto".  We can fall through if it is the
       // next block in the list.  Otherwise, we need a jump.
       if ((i == block_order_.length() - 1) ||
           (block_order_[i + 1] != successor)) {
         __ jmp(&block_info_[successor->postorder_number()]->label);
       }
     }
   }
 }
 
 
+void FlowGraphCompiler::EmitComment(Instruction* instr) {
+  char buffer[80];
+  BufferFormatter f(buffer, sizeof(buffer));
+  instr->PrintTo(&f);
+  __ Comment("@%d: %s", instr->cid(), buffer);
+}
+
+
 void FlowGraphCompiler::VisitGraphEntry(GraphEntryInstr* instr) {
   // Nothing to do.
 }
 
 
 void FlowGraphCompiler::VisitJoinEntry(JoinEntryInstr* instr) {
   __ Bind(&block_info_[instr->postorder_number()]->label);
 }
 
 
@@ skipping 545 matching lines @@
 
 
 void FlowGraphCompiler::FinalizeComments(const Code& code) {
   code.set_comments(assembler_->GetCodeComments());
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64