Add flow graph printing into a .cfg file with flag --print-flow-graph-file.

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"
@@ skipping 153 matching lines @@
   ASSERT(parent->is_empty());
 
   // This node has no parent, indicated by -1.  The preorder number is 0.
   parent->Add(-1);
   set_preorder_number(0);
   preorder->Add(this);
   BitVector* vars =
       (variable_count == 0) ? NULL : new BitVector(variable_count);
   assigned_vars->Add(vars);
 
+  // The graph entry consists of only one instruction.
+  set_last_instruction(this);
+
   // 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);
   }
   normal_entry_->DiscoverBlocks(this, preorder, postorder,
                                 parent, assigned_vars, variable_count);
 
@@ skipping 78 matching lines @@
   // 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);
 }
 
 
+intptr_t Instruction::SuccessorCount() const {
+  ASSERT(!IsBranch());
+  ASSERT(!IsGraphEntry());
+  ASSERT(StraightLineSuccessor() == NULL ||
+         StraightLineSuccessor()->IsBlockEntry());
+  return StraightLineSuccessor() != NULL ? 1 : 0;
+}
+
+
+BlockEntryInstr* Instruction::SuccessorAt(intptr_t index) const {
+  return StraightLineSuccessor()->AsBlockEntry();
+}
+
+
+intptr_t GraphEntryInstr::SuccessorCount() const {
+  return 1 + catch_entries_.length();
+}
+
+
+BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
+  if (index == 0) return normal_entry_;
+  return catch_entries_[index - 1];
+}
+
+
+intptr_t BranchInstr::SuccessorCount() const {
+  return 2;
+}
+
+
+BlockEntryInstr* BranchInstr::SuccessorAt(intptr_t index) const {
+  if (index == 0) return true_successor_;
+  if (index == 1) return false_successor_;
+  UNREACHABLE();
+  return NULL;
+}
+
+
 // ==== Support for propagating static type.
 RawAbstractType* ConstantVal::StaticType() const {
   if (value().IsInstance()) {
     Instance& instance = Instance::Handle();
     instance ^= value().raw();
     return instance.GetType();
   } else {
     UNREACHABLE();
     return AbstractType::null();
   }
@@ skipping 247 matching lines @@
 }
 
 
 RawAbstractType* BinaryOpComp::StaticType() const {
   // TODO(srdjan): Compute based on input types (ICData).
   return Type::DynamicType();
 }
 
 
 }  // namespace dart