Add a global graph entry.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 13 matching lines @@
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 
 
 FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function)
   : parsed_function_(parsed_function),
     preorder_block_entries_(),
     postorder_block_entries_(),
     context_level_(0),
     last_used_try_index_(CatchClauseNode::kInvalidTryIndex),
     try_index_(CatchClauseNode::kInvalidTryIndex),
-    catch_entries_() {}
+    graph_entry_(NULL) {}
 
 
-void FlowGraphBuilder::AddCatchEntry(intptr_t try_index, Instruction* entry) {
-  catch_entries_.Add(entry);
+void FlowGraphBuilder::AddCatchEntry(TargetEntryInstr* entry) {
+  graph_entry_->AddCatchEntry(entry);
 }
 
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
     entry_ = other_fragment.entry();
     exit_ = other_fragment.exit();
   } else {
@@ skipping 1957 matching lines @@
   // We are done generating code for the try block.
   owner()->set_try_index(old_try_index);
 
   CatchClauseNode* catch_block = node->catch_block();
   if (catch_block != NULL) {
     // Set the corresponding try index for this catch block so
     // that we can set the appropriate handler pc when we generate
     // code for this catch block.
     catch_block->set_try_index(try_index);
     EffectGraphVisitor for_catch_block(owner(), temp_index());
-    for_catch_block.AddInstruction(new TargetEntryInstr(try_index));
+    TargetEntryInstr* catch_entry = new TargetEntryInstr(try_index);
+    for_catch_block.AddInstruction(catch_entry);
     catch_block->Visit(&for_catch_block);
-    owner()->AddCatchEntry(try_index, for_catch_block.entry());
+    owner()->AddCatchEntry(catch_entry);
     ASSERT(!for_catch_block.is_open());
     if ((node->end_catch_label() != NULL) &&
         (node->end_catch_label()->join_for_continue() != NULL)) {
       if (is_open()) {
         AddInstruction(node->end_catch_label()->join_for_continue());
       } else {
         exit_ = node->end_catch_label()->join_for_continue();
       }
     }
   }
@@ skipping 65 matching lines @@
 void FlowGraphBuilder::BuildGraph(bool for_optimized) {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
   // Compilation can be nested, preserve the computation-id.
   Isolate* isolate = Isolate::Current();
   const intptr_t prev_cid = isolate->computation_id();
   isolate->set_computation_id(0);
   const Function& function = parsed_function().function();
+  TargetEntryInstr* normal_entry = new TargetEntryInstr();
+  graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
-  for_effect.AddInstruction(new TargetEntryInstr());
+  for_effect.AddInstruction(normal_entry);
   parsed_function().node_sequence()->Visit(&for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   GrowableArray<intptr_t> parent;
-  for (intptr_t i = 0; i < catch_entries_.length(); i++) {
-    Instruction* entry = catch_entries_[i];
-    entry->DiscoverBlocks(NULL,  // Entry block predecessor.
-                          &preorder_block_entries_,
-                          &postorder_block_entries_,
-                          &parent);
-    if (for_optimized) {
-      ComputeDominators(&preorder_block_entries_, &parent);
-    }
-  }
-  if (for_effect.entry() != NULL) {
-    // Perform a depth-first traversal of the graph to build preorder and
-    // postorder block orders.
-    for_effect.entry()->DiscoverBlocks(NULL,  // Entry block predecessor.
-                                       &preorder_block_entries_,
-                                       &postorder_block_entries_,
-                                       &parent);
-    if (for_optimized) {
-      ComputeDominators(&preorder_block_entries_, &parent);
-    }
+  // Perform a depth-first traversal of the graph to build preorder and
+  // postorder block orders.
+  graph_entry_->DiscoverBlocks(NULL,  // Entry block predecessor.
+                               &preorder_block_entries_,
+                               &postorder_block_entries_,
+                               &parent);
+  if (for_optimized) {
+    ComputeDominators(&preorder_block_entries_, &parent);
   }
   isolate->set_computation_id(prev_cid);
   if (FLAG_print_flow_graph) {
     intptr_t length = postorder_block_entries_.length();
     GrowableArray<BlockEntryInstr*> reverse_postorder(length);
     for (intptr_t i = length - 1; i >= 0; --i) {
       reverse_postorder.Add(postorder_block_entries_[i]);
     }
     FlowGraphPrinter printer(function, reverse_postorder);
     printer.VisitBlocks();
@@ skipping 95 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart