Add a global graph entry.

runtime/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/object.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 
@@ skipping 105 matching lines @@
 intptr_t BindInstr::InputCount() const {
   return computation()->InputCount();
 }
 
 
 intptr_t DoInstr::InputCount() const {
   return computation()->InputCount();
 }
 
 
+intptr_t GraphEntryInstr::InputCount() const {
+  return 0;
+}
+
+
 intptr_t TargetEntryInstr::InputCount() const {
   return 0;
 }
 
 
 intptr_t JoinEntryInstr::InputCount() const {
   return 0;
 }
 
 
 // ==== Postorder graph traversal.
+void GraphEntryInstr::DiscoverBlocks(
+    BlockEntryInstr* current_block,
+    GrowableArray<BlockEntryInstr*>* preorder,
+    GrowableArray<BlockEntryInstr*>* postorder,
+    GrowableArray<intptr_t>* parent) {
+  // We only visit this block once, first of all blocks.
+  ASSERT(preorder_number() == -1);
+  ASSERT(current_block == NULL);
+  ASSERT(preorder->is_empty());
+  ASSERT(postorder->is_empty());
+  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);
+
+  // 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);
+  }
+  normal_entry_->DiscoverBlocks(this, preorder, postorder, parent);
+
+  // Assign postorder number.
+  set_postorder_number(postorder->length());
+  postorder->Add(this);
+}
+
+
 void JoinEntryInstr::DiscoverBlocks(
     BlockEntryInstr* current_block,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent) {
-  // The global graph entry is a TargetEntryInstr, so we can assume
-  // current_block is non-null and preorder array is non-empty.
+  // We have already visited the graph entry, so we can assume current_block
+  // is non-null and preorder array is non-empty.
   ASSERT(current_block != NULL);
   ASSERT(!preorder->is_empty());
 
   // 1. Record control-flow-graph basic-block predecessors.
   predecessors_.Add(current_block);
 
   // 2. If the block has already been reached by the traversal, we are done.
   if (preorder_number() >= 0) return;
 
   // 3. The last entry in the preorder array is the spanning-tree parent.
@@ skipping 77 matching lines @@
   // 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);
   true_successor_->DiscoverBlocks(current_block, preorder, postorder, parent);
 }
 
 
 }  // namespace dart