Add IR printing into a supplied buffer.

vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
+#include "vm/flow_graph_builder.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 
 namespace dart {
 
 // ==== Support for visiting flow graphs.
 #define DEFINE_ACCEPT(ShortName, ClassName)                                    \
 void ClassName::Accept(FlowGraphVisitor* visitor) {                            \
   visitor->Visit##ShortName(this);                                             \
@@ skipping 169 matching lines @@
   set_preorder_number(0);
   preorder->Add(this);
   BitVector* vars =
       (variable_count == 0) ? NULL : new BitVector(variable_count);
   assigned_vars->Add(vars);
 
   // Iteratively traverse all successors.  In the unoptimized code, we will
   // enter the function at the first successor in reverse postorder, so we
   // must visit the normal entry last.
   for (intptr_t i = catch_entries_.length() - 1; i >= 0; --i) {
-    catch_entries_[i]->DiscoverBlocks(this, preorder, postorder, parent,
-                                      assigned_vars, variable_count);
+    catch_entries_[i]->DiscoverBlocks(this, preorder, postorder,
+                                      parent, assigned_vars, variable_count);
   }
-  normal_entry_->DiscoverBlocks(this, preorder, postorder, parent,
-                                assigned_vars, variable_count);
+  normal_entry_->DiscoverBlocks(this, preorder, postorder,
+                                parent, assigned_vars, variable_count);
 
   // Assign postorder number.
   set_postorder_number(postorder->length());
   postorder->Add(this);
 }
 
 
 // Base class implementation used for JoinEntry and TargetEntry.
 void BlockEntryInstr::DiscoverBlocks(
     BlockEntryInstr* current_block,
@@ skipping 39 matching lines @@
   if (next->IsBlockEntry()) {
     set_last_instruction(this);
   } else {
     while ((next != NULL) && !next->IsBlockEntry() && !next->IsBranch()) {
       if (vars != NULL) next->RecordAssignedVars(vars);
       set_last_instruction(next);
       next = next->StraightLineSuccessor();
     }
   }
   if (next != NULL) {
-    next->DiscoverBlocks(this, preorder, postorder, parent, assigned_vars,
-                         variable_count);
+    next->DiscoverBlocks(this, preorder, postorder,
+                         parent, assigned_vars, variable_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
 }
 
 
 void BranchInstr::DiscoverBlocks(
     BlockEntryInstr* current_block,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent,
     GrowableArray<BitVector*>* assigned_vars,
     intptr_t variable_count) {
   current_block->set_last_instruction(this);
   // Visit the false successor before the true successor so they appear in
   // true/false order in reverse postorder used as the block ordering in the
   // nonoptimizing compiler.
   ASSERT(true_successor_ != NULL);
   ASSERT(false_successor_ != NULL);
-  false_successor_->DiscoverBlocks(current_block, preorder, postorder, parent,
-                                   assigned_vars, variable_count);
-  true_successor_->DiscoverBlocks(current_block, preorder, postorder, parent,
-                                  assigned_vars, variable_count);
+  false_successor_->DiscoverBlocks(current_block, preorder, postorder,
+                                   parent, assigned_vars, variable_count);
+  true_successor_->DiscoverBlocks(current_block, preorder, postorder,
+                                  parent, assigned_vars, variable_count);
 }
 
 
 // ==== Support for propagating static type.
 RawAbstractType* ConstantVal::StaticType() const {
   if (value().IsInstance()) {
     Instance& instance = Instance::Handle();
     instance ^= value().raw();
     return instance.GetType();
   } else {
@@ skipping 243 matching lines @@
 }
 
 
 RawAbstractType* CatchEntryComp::StaticType() const {
   UNREACHABLE();
   return AbstractType::null();
 }
 
 
 }  // namespace dart