Stop attaching try_index to individual instructions put it at block entry instead.

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 131 matching lines @@
   // and a pair of effect graph fragments with zero or one available exits.
   // We want to append the branch and (if necessary) a join node to this
   // graph fragment.
   ASSERT(is_open());
 
   // 1. Connect the test to this graph.
   Append(test_fragment);
 
   // 2. Connect the true and false bodies to the test and record their exits
   // (if any).
-  TargetEntryInstr* true_entry = new TargetEntryInstr();
+  TargetEntryInstr* true_entry = new TargetEntryInstr(owner()->try_index());
   *test_fragment.true_successor_address() = true_entry;
   Instruction* true_exit = AppendFragment(true_entry, true_fragment);
 
-  TargetEntryInstr* false_entry = new TargetEntryInstr();
+  TargetEntryInstr* false_entry = new TargetEntryInstr(owner()->try_index());
   *test_fragment.false_successor_address() = false_entry;
   Instruction* false_exit = AppendFragment(false_entry, false_fragment);
 
   // 3. Add a join or select one (or neither) of the arms as exit.
   if (true_exit == NULL) {
     exit_ = false_exit;  // May be NULL.
     if (false_exit != NULL) temp_index_ = false_fragment.temp_index();
   } else if (false_exit == NULL) {
     exit_ = true_exit;
     temp_index_ = true_fragment.temp_index();
   } else {
-    JoinEntryInstr* join = new JoinEntryInstr();
+    JoinEntryInstr* join = new JoinEntryInstr(owner()->try_index());
     true_exit->Goto(join);
     false_exit->Goto(join);
     exit_ = join;
     ASSERT(true_fragment.temp_index() == false_fragment.temp_index());
     temp_index_ = true_fragment.temp_index();
   }
 }
 
 
 void EffectGraphVisitor::TieLoop(const TestGraphVisitor& test_fragment,
                                  const EffectGraphVisitor& body_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and an effect graph fragment with zero or one available exits.  We want
   // to append the 'while loop' consisting of the test graph fragment as
   // condition and the effect graph fragment as body.
   ASSERT(is_open());
 
   // 1. Connect the body to the test if it is reachable, and if so record
   // its exit (if any).
-  TargetEntryInstr* body_entry = new TargetEntryInstr();
+  TargetEntryInstr* body_entry = new TargetEntryInstr(owner()->try_index());
   *test_fragment.true_successor_address() = body_entry;
   Instruction* body_exit = AppendFragment(body_entry, body_fragment);
 
   // 2. Connect the test to this graph, including the body if reachable and
   // using a fresh join node if the body is reachable and has an open exit.
   if (body_exit == NULL) {
     Append(test_fragment);
   } else {
-    JoinEntryInstr* join = new JoinEntryInstr();
+    JoinEntryInstr* join = new JoinEntryInstr(owner()->try_index());
     join->set_next(test_fragment.entry());
     Goto(join);
     body_exit->Goto(join);
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
-  exit_ = *test_fragment.false_successor_address() = new TargetEntryInstr();
+  exit_ = *test_fragment.false_successor_address() =
+      new TargetEntryInstr(owner()->try_index());
 }
 
 
 PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
   PushArgumentInstr* result = new PushArgumentInstr(value);
   AddInstruction(result);
   return result;
 }
 
 
@@ skipping 47 matching lines @@
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
   Do(new StoreContextComp(load_saved_context));
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
-    value = Bind(new AssertBooleanComp(condition_token_pos(),
-                                       owner()->try_index(),
-                                       value));
+    value = Bind(new AssertBooleanComp(condition_token_pos(), value));
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Value* constant_true = Bind(Constant(bool_true));
   StrictCompareComp* comp =
       new StrictCompareComp(Token::kEQ_STRICT, value, constant_true);
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
@@ skipping 230 matching lines @@
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = String::ZoneHandle(Symbols::New(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
-                                                owner()->try_index(),
                                                 name,
                                                 node->kind(),
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 2);
   ReturnComputation(call);
 }
 
 
 // Special handling for AND/OR.
@@ skipping 12 matching lines @@
                               temp_index(),
                               node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanComp(node->right()->token_pos(),
-                                               owner()->try_index(),
                                                right_value));
     }
     Value* constant_true = for_right.Bind(Constant(bool_true));
     Value* compare =
         for_right.Bind(new StrictCompareComp(Token::kEQ_STRICT,
                                              right_value,
                                              constant_true));
     for_right.Do(BuildStoreLocal(
         *owner()->parsed_function().expression_temp_var(),
         compare));
@@ skipping 68 matching lines @@
   Value* instantiator_type_arguments = NULL;
   if (dst_type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(token_pos,
                             &instantiator,
                             &instantiator_type_arguments);
   }
   return new AssertAssignableComp(token_pos,
-                                  owner()->try_index(),
                                   value,
                                   instantiator,
                                   instantiator_type_arguments,
                                   dst_type,
                                   dst_name);
 }
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
@@ skipping 81 matching lines @@
   if (type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(node->token_pos(),
                             &instantiator,
                             &instantiator_type_arguments);
   }
   InstanceOfComp* instance_of =
       new InstanceOfComp(node->token_pos(),
-                         owner()->try_index(),
                          for_left_value.value(),
                          instantiator,
                          instantiator_type_arguments,
                          node->right()->AsTypeNode()->type(),
                          (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
@@ skipping 41 matching lines @@
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     if (FLAG_enable_type_checks) {
       EqualityCompareComp* comp = new EqualityCompareComp(
-          node->token_pos(), owner()->try_index(),
-          Token::kEQ, for_left_value.value(), for_right_value.value());
+          node->token_pos(),
+          Token::kEQ,
+          for_left_value.value(),
+          for_right_value.value());
       if (node->kind() == Token::kEQ) {
         ReturnComputation(comp);
       } else {
         Value* eq_result = Bind(comp);
-        eq_result = Bind(new AssertBooleanComp(node->token_pos(),
-                                               owner()->try_index(),
-                                               eq_result));
+        eq_result = Bind(new AssertBooleanComp(node->token_pos(), eq_result));
         ReturnComputation(new BooleanNegateComp(eq_result));
       }
     } else {
       EqualityCompareComp* comp = new EqualityCompareComp(
-          node->token_pos(), owner()->try_index(),
-          node->kind(), for_left_value.value(), for_right_value.value());
+          node->token_pos(),
+          node->kind(),
+          for_left_value.value(),
+          for_right_value.value());
       ReturnComputation(comp);
     }
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   RelationalOpComp* comp = new RelationalOpComp(node->token_pos(),
-                                                owner()->try_index(),
                                                 node->kind(),
                                                 for_left_value.value(),
                                                 for_right_value.value());
   ReturnComputation(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       value =
-          Bind(new AssertBooleanComp(node->operand()->token_pos(),
-                                     owner()->try_index(),
-                                     value));
+          Bind(new AssertBooleanComp(node->operand()->token_pos(), value));
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   String& name = String::ZoneHandle();
   if (node->kind() == Token::kSUB) {
     name = Symbols::New("unary-");
   } else {
     name = Symbols::New(Token::Str(node->kind()));
   }
   InstanceCallComp* call = new InstanceCallComp(
-      node->token_pos(), owner()->try_index(), name, node->kind(),
+      node->token_pos(), name, node->kind(),
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
@@ skipping 91 matching lines @@
   const intptr_t len = node->case_expressions()->length();
   // Create case statements instructions.
   EffectGraphVisitor for_case_statements(owner(), temp_index());
   // Compute start of statements fragment.
   JoinEntryInstr* statement_start = NULL;
   if ((node->label() != NULL) && node->label()->is_continue_target()) {
     // Since a labeled jump continue statement occur in a different case node,
     // allocate JoinNode here and use it as statement start.
     statement_start = node->label()->join_for_continue();
     if (statement_start == NULL) {
-      statement_start = new JoinEntryInstr();
+      statement_start = new JoinEntryInstr(owner()->try_index());
       node->label()->set_join_for_continue(statement_start);
     }
   } else {
-    statement_start = new JoinEntryInstr();
+    statement_start = new JoinEntryInstr(owner()->try_index());
   }
   node->statements()->Visit(&for_case_statements);
   Instruction* statement_exit =
       AppendFragment(statement_start, for_case_statements);
   if (is_open() && (len == 0)) {
     ASSERT(node->contains_default());
     // Default only case node.
     Goto(statement_start);
     exit_ = statement_exit;
     return;
   }
 
   // Generate instructions for all case expressions.
   TargetEntryInstr** previous_false_address = NULL;
   for (intptr_t i = 0; i < len; i++) {
     AstNode* case_expr = node->case_expressions()->NodeAt(i);
     TestGraphVisitor for_case_expression(owner(),
                                          temp_index(),
                                          case_expr->token_pos());
     case_expr->Visit(&for_case_expression);
     if (i == 0) {
       // Append only the first one, everything else is connected from it.
       Append(for_case_expression);
     } else {
-      TargetEntryInstr* case_entry_target = new TargetEntryInstr();
+      TargetEntryInstr* case_entry_target =
+          new TargetEntryInstr(owner()->try_index());
       AppendFragment(case_entry_target, for_case_expression);
       *previous_false_address = case_entry_target;
     }
-    TargetEntryInstr* true_target = new TargetEntryInstr();
+    TargetEntryInstr* true_target =
+        new TargetEntryInstr(owner()->try_index());
     *for_case_expression.true_successor_address() = true_target;
     true_target->Goto(statement_start);
     previous_false_address = for_case_expression.false_successor_address();
   }
 
   // Once a test fragment has been added, this fragment is closed.
   ASSERT(!is_open());
 
   Instruction* exit_instruction = NULL;
   // Handle last (or only) case: false goes to exit or to statement if this
   // node contains default.
   if (len > 0) {
-    TargetEntryInstr* false_target = new TargetEntryInstr();
+    TargetEntryInstr* false_target =
+        new TargetEntryInstr(owner()->try_index());
     *previous_false_address = false_target;
     if (node->contains_default()) {
       // True and false go to statement start.
       false_target->Goto(statement_start);
       exit_instruction = statement_exit;
     } else {
       if (statement_exit != NULL) {
-        JoinEntryInstr* join = new JoinEntryInstr();
+        JoinEntryInstr* join = new JoinEntryInstr(owner()->try_index());
         statement_exit->Goto(join);
         false_target->Goto(join);
         exit_instruction = join;
       } else {
         exit_instruction = false_target;
       }
     }
   } else {
     // A CaseNode without case expressions must contain default.
     ASSERT(node->contains_default());
@@ skipping 19 matching lines @@
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
-      new CheckStackOverflowComp(node->token_pos(), owner()->try_index()));
+      new CheckStackOverflowComp(node->token_pos()));
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   JoinEntryInstr* join = lbl->join_for_continue();
   if (join != NULL) {
     if (for_body.is_open()) for_body.Goto(join);
     for_body.exit_ = join;
   }
@@ skipping 11 matching lines @@
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
-      new CheckStackOverflowComp(node->token_pos(), owner()->try_index()));
+      new CheckStackOverflowComp(node->token_pos()));
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
   // Tie do-while loop (test is after the body).
-  JoinEntryInstr* body_entry_join = new JoinEntryInstr();
+  JoinEntryInstr* body_entry_join = new JoinEntryInstr(owner()->try_index());
   Goto(body_entry_join);
   Instruction* body_exit = AppendFragment(body_entry_join, for_body);
 
   JoinEntryInstr* join = node->label()->join_for_continue();
   if ((body_exit != NULL) || (join != NULL)) {
-    if (join == NULL) join = new JoinEntryInstr();
+    if (join == NULL) join = new JoinEntryInstr(owner()->try_index());
     join->set_next(for_test.entry());
     if (body_exit != NULL) {
       body_exit->Goto(join);
     }
   }
 
-  TargetEntryInstr* back_target_entry = new TargetEntryInstr();
+  TargetEntryInstr* back_target_entry =
+      new TargetEntryInstr(owner()->try_index());
   *for_test.true_successor_address() = back_target_entry;
   back_target_entry->Goto(body_entry_join);
-  TargetEntryInstr* loop_exit_target = new TargetEntryInstr();
+  TargetEntryInstr* loop_exit_target =
+      new TargetEntryInstr(owner()->try_index());
   *for_test.false_successor_address() = loop_exit_target;
   if (node->label()->join_for_break() == NULL) {
     exit_ = loop_exit_target;
   } else {
     loop_exit_target->Goto(node->label()->join_for_break());
     exit_ = node->label()->join_for_break();
   }
 }
 
 
@@ skipping 11 matching lines @@
 // i) break-join
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
   EffectGraphVisitor for_initializer(owner(), temp_index());
   node->initializer()->Visit(&for_initializer);
   Append(for_initializer);
   ASSERT(is_open());
 
   // Compose body to set any jump labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   for_body.Do(
-      new CheckStackOverflowComp(node->token_pos(), owner()->try_index()));
+      new CheckStackOverflowComp(node->token_pos()));
   node->body()->Visit(&for_body);
 
   // Join loop body, increment and compute their end instruction.
   ASSERT(!for_body.is_empty());
   Instruction* loop_increment_end = NULL;
   EffectGraphVisitor for_increment(owner(), temp_index());
   node->increment()->Visit(&for_increment);
   JoinEntryInstr* join = node->label()->join_for_continue();
   if (join != NULL) {
     // Insert the join between the body and increment.
     if (for_body.is_open()) for_body.Goto(join);
     loop_increment_end = AppendFragment(join, for_increment);
     ASSERT(loop_increment_end != NULL);
   } else if (for_body.is_open()) {
     // Do not insert an extra basic block.
     for_body.Append(for_increment);
     loop_increment_end = for_body.exit();
     // 'for_body' contains at least the stack check.
     ASSERT(loop_increment_end != NULL);
   } else {
     loop_increment_end = NULL;
   }
 
   // 'loop_increment_end' is NULL only if there is no join for continue and the
   // body is not open, i.e., no backward branch exists.
   if (loop_increment_end != NULL) {
-    JoinEntryInstr* loop_start = new JoinEntryInstr();
+    JoinEntryInstr* loop_start = new JoinEntryInstr(owner()->try_index());
     Goto(loop_start);
     loop_increment_end->Goto(loop_start);
     exit_ = loop_start;
   }
 
   if (node->condition() == NULL) {
     // Endless loop, no test.
-    JoinEntryInstr* body_entry = new JoinEntryInstr();
+    JoinEntryInstr* body_entry = new JoinEntryInstr(owner()->try_index());
     AppendFragment(body_entry, for_body);
     Goto(body_entry);
     if (node->label()->join_for_break() != NULL) {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
-    TargetEntryInstr* loop_exit = new TargetEntryInstr();
+    TargetEntryInstr* loop_exit = new TargetEntryInstr(owner()->try_index());
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               node->condition()->token_pos());
     node->condition()->Visit(&for_test);
     Append(for_test);
-    TargetEntryInstr* body_entry = new TargetEntryInstr();
+    TargetEntryInstr* body_entry = new TargetEntryInstr(owner()->try_index());
     AppendFragment(body_entry, for_body);
     *for_test.true_successor_address() = body_entry;
     *for_test.false_successor_address() = loop_exit;
     if (node->label()->join_for_break() == NULL) {
       exit_ = loop_exit;
     } else {
       loop_exit->Goto(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
@@ skipping 32 matching lines @@
   ASSERT(target_context_level >= 0);
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= target_context_level);
   while (current_context_level-- > target_context_level) {
     UnchainContext();
   }
 
   JoinEntryInstr* jump_target = NULL;
   if (node->kind() == Token::kBREAK) {
     if (node->label()->join_for_break() == NULL) {
-      node->label()->set_join_for_break(new JoinEntryInstr());
+      node->label()->set_join_for_break(
+          new JoinEntryInstr(owner()->try_index()));
     }
     jump_target = node->label()->join_for_break();
   } else {
     if (node->label()->join_for_continue() == NULL) {
-      node->label()->set_join_for_continue(new JoinEntryInstr());
+      node->label()->set_join_for_continue(
+          new JoinEntryInstr(owner()->try_index()));
     }
     jump_target = node->label()->join_for_continue();
   }
   Goto(jump_target);
 }
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   // Translate the array elements and collect their values.
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->length());
   for (int i = 0; i < node->length(); ++i) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     arguments->Add(PushArgument(for_value.value()));
   }
   const AbstractTypeArguments& type_args =
       AbstractTypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   CreateArrayComp* create = new CreateArrayComp(node->token_pos(),
-                                                owner()->try_index(),
                                                 arguments,
                                                 node->type(),
                                                 element_type);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
@@ skipping 30 matching lines @@
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     type_arguments = BuildInstantiatorTypeArguments(node->token_pos(), NULL);
   } else {
     type_arguments = BuildNullValue();
   }
   PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
   arguments->Add(push_type_arguments);
-  ReturnComputation(
-      new CreateClosureComp(node, owner()->try_index(), arguments));
+  ReturnComputation(new CreateClosureComp(node, arguments));
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
@@ skipping 20 matching lines @@
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->length() + 1);
   arguments->Add(push_receiver);
 
   BuildPushArguments(*node->arguments(), arguments);
   InstanceCallComp* call = new InstanceCallComp(
-      node->token_pos(), owner()->try_index(),
+      node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
       node->arguments()->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallComp* call =
       new StaticCallComp(node->token_pos(),
-                         owner()->try_index(),
                          node->function(),
                          node->arguments()->names(),
                          arguments);
   ReturnComputation(call);
 }
 
 
 ClosureCallComp* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
   ValueGraphVisitor for_closure(owner(), temp_index());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
   PushArgumentInstr* push_closure = PushArgument(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   // Save context around the call.
   BuildStoreContext(*owner()->parsed_function().expression_temp_var());
-  return new ClosureCallComp(node, owner()->try_index(), arguments);
+  return new ClosureCallComp(node, arguments);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Do(BuildClosureCall(node));
   // Restore context from saved location.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Value* result = Bind(BuildClosureCall(node));
   // Restore context from temp.
   BuildLoadContext(*owner()->parsed_function().expression_temp_var());
   ReturnValue(result);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Value* context = Bind(new CurrentContextComp());
-  Value* clone = Bind(new CloneContextComp(node->token_pos(),
-                                           owner()->try_index(),
-                                           context));
+  Value* clone = Bind(new CloneContextComp(node->token_pos(), context));
   ReturnComputation(new StoreContextComp(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
   Computation* allocate_comp = NULL;
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
       !node->type_arguments().IsWithinBoundsOf(cls,
                                                node->type_arguments(),
                                                NULL)) {
     Value* type_arguments = NULL;
     Value* instantiator = NULL;
     BuildConstructorTypeArguments(node, &type_arguments, &instantiator, NULL);
 
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     // Although the type arguments may be uninstantiated at compile time, they
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
     allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
-                                                          owner()->try_index(),
                                                           type_arguments,
                                                           instantiator);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
 
     if (requires_type_arguments) {
       BuildConstructorTypeArguments(node, NULL, NULL, allocate_arguments);
     }
 
-    allocate_comp = new AllocateObjectComp(node,
-                                           owner()->try_index(),
-                                           allocate_arguments);
+    allocate_comp = new AllocateObjectComp(node, allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
       Constant(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
   Do(new StaticCallComp(node->token_pos(),
-                        owner()->try_index(),
                         node->constructor(),
                         node->arguments()->names(),
                         arguments));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments = PushArgument(
         BuildInstantiatedTypeArguments(node->token_pos(),
                                        node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_pos(),
-                           owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            arguments);
     ReturnComputation(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
@@ skipping 82 matching lines @@
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(Constant(type_arguments));
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, NULL);
   return Bind(new InstantiateTypeArgumentsComp(token_pos,
-                                               owner()->try_index(),
                                                type_arguments,
                                                instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     Value** type_arguments,
     Value** instantiator,
     ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {
@@ skipping 36 matching lines @@
   Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
       node->token_pos(), NULL);
   ASSERT(instantiator_type_arguments->IsUse());
   Value* stored_instantiator =
       Bind(BuildStoreLocal(t1, instantiator_type_arguments));
   // t1: instantiator type arguments.
 
   Value* extract_type_arguments = Bind(
       new ExtractConstructorTypeArgumentsComp(
           node->token_pos(),
-          owner()->try_index(),
           node->type_arguments(),
           stored_instantiator));
 
   Do(BuildStoreLocal(t2, extract_type_arguments));
   // t2: extracted constructor type arguments.
   Value* load_instantiator = Bind(BuildLoadLocal(t1));
 
   Value* extract_instantiator =
       Bind(new ExtractConstructorInstantiatorComp(node, load_instantiator));
   Do(BuildStoreLocal(t1, extract_instantiator));
@@ skipping 51 matching lines @@
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_receiver);
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(
-      node->token_pos(), owner()->try_index(), name, Token::kGET,
+      node->token_pos(), name, Token::kGET,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
@@ skipping 17 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, false);  // Value not used.
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
-                                                owner()->try_index(),
                                                 name,
                                                 Token::kSET,
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 1);  // Checked argument count.
   ReturnComputation(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, true);  // Value used.
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   Do(new InstanceCallComp(node->token_pos(),
-                          owner()->try_index(),
                           name,
                           Token::kSET,
                           arguments,
                           Array::ZoneHandle(),
                           1));  // Checked argument count.
   ReturnComputation(
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
@@ skipping 11 matching lines @@
     ASSERT(node->receiver() != NULL);
     ValueGraphVisitor receiver_value(owner(), temp_index());
     node->receiver()->Visit(&receiver_value);
     Append(receiver_value);
     arguments->Add(PushArgument(receiver_value.value()));
   } else {
     getter_function = node->cls().LookupStaticFunction(getter_name);
     ASSERT(!getter_function.IsNull());
   }
   StaticCallComp* call = new StaticCallComp(node->token_pos(),
-                                            owner()->try_index(),
                                             getter_function,
                                             Array::ZoneHandle(),  // No names.
                                             arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
@@ skipping 24 matching lines @@
   if (result_is_needed) {
     value = Bind(
         BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
                         for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   StaticCallComp* call = new StaticCallComp(node->token_pos(),
-                                            owner()->try_index(),
                                             setter_function,
                                             Array::ZoneHandle(),  // No names.
                                             arguments);
   if (result_is_needed) {
     Do(call);
     ReturnComputation(
          BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
   } else {
     ReturnComputation(call);
   }
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   BuildStaticSetter(node, false);  // Result not needed.
 }
 
 
 void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   BuildStaticSetter(node, true);  // Result needed.
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  NativeCallComp* native_call =
-      new NativeCallComp(node, owner()->try_index());
+  NativeCallComp* native_call = new NativeCallComp(node);
   ReturnComputation(native_call);
 }
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
@@ skipping 108 matching lines @@
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
   InstanceCallComp* load = new InstanceCallComp(node->token_pos(),
-                                                owner()->try_index(),
                                                 name,
                                                 Token::kINDEX,
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 checked_argument_count);
   ReturnComputation(load);
 }
 
 
 Computation* EffectGraphVisitor::BuildStoreIndexedValues(
@@ skipping 21 matching lines @@
                         for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
   InstanceCallComp* store = new InstanceCallComp(node->token_pos(),
-                                                 owner()->try_index(),
                                                  name,
                                                  Token::kASSIGN_INDEX,
                                                  arguments,
                                                  Array::ZoneHandle(),
                                                  checked_argument_count);
   if (result_is_needed) {
     Do(store);
     return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
   } else {
     return store;
@@ skipping 35 matching lines @@
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
     Value* allocated_context =
-        Bind(new AllocateContextComp(node->token_pos(),
-                                     owner()->try_index(),
-                                     num_context_variables));
+        Bind(new AllocateContextComp(node->token_pos(), num_context_variables));
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
       Value* current_context = Bind(new CurrentContextComp());
       Do(BuildStoreLocal(*owner()->parsed_function().saved_context_var(),
                          current_context));
       Value* null_context = Bind(Constant(Object::ZoneHandle()));
@@ skipping 127 matching lines @@
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   intptr_t old_try_index = owner()->try_index();
   intptr_t try_index = owner()->AllocateTryIndex();
   owner()->set_try_index(try_index);
 
   // Preserve CTX into local variable '%saved_context'.
   BuildStoreContext(node->context_var());
 
   EffectGraphVisitor for_try_block(owner(), temp_index());
   node->try_block()->Visit(&for_try_block);
-  Append(for_try_block);
+
+  if (for_try_block.is_open()) {
+    JoinEntryInstr* after_try = new JoinEntryInstr(old_try_index);
+    for_try_block.Goto(after_try);
+    for_try_block.exit_ = after_try;
+  }
+
+  JoinEntryInstr* try_entry = new JoinEntryInstr(try_index);
+
+  Goto(try_entry);
+  AppendFragment(try_entry, for_try_block);
+  exit_ = for_try_block.exit_;
 
   // 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());
     catch_block->Visit(&for_catch_block);
-    TargetEntryInstr* catch_entry = new TargetEntryInstr(try_index);
+    TargetEntryInstr* catch_entry = new TargetEntryInstr(old_try_index,
+                                                         try_index);
     owner()->AddCatchEntry(catch_entry);
     ASSERT(!for_catch_block.is_open());
     AppendFragment(catch_entry, for_catch_block);
     if (node->end_catch_label() != NULL) {
       JoinEntryInstr* join = node->end_catch_label()->join_for_continue();
       if (join != NULL) {
         if (is_open()) Goto(join);
         exit_ = join;
       }
     }
   }
 
   // Generate code for the finally block if one exists.
   if ((node->finally_block() != NULL) && is_open()) {
     EffectGraphVisitor for_finally_block(owner(), temp_index());
     node->finally_block()->Visit(&for_finally_block);
     Append(for_finally_block);
   }
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
-    instr = new ThrowInstr(node->token_pos(), owner()->try_index());
+    instr = new ThrowInstr(node->token_pos());
   } else {
     ValueGraphVisitor for_stack_trace(owner(), temp_index());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     PushArgument(for_stack_trace.value());
-    instr = new ReThrowInstr(node->token_pos(), owner()->try_index());
+    instr = new ReThrowInstr(node->token_pos());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   CloseFragment();
 }
 
 
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   ReturnComputation(Constant(Instance::ZoneHandle()));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
   }
   BuildLoadContext(node->context_var());
+
+  JoinEntryInstr* finally_entry = new JoinEntryInstr(owner()->try_index());
   EffectGraphVisitor for_finally_block(owner(), temp_index());
   node->finally_block()->Visit(&for_finally_block);
-  Append(for_finally_block);
+
   if (try_index >= 0) {
     owner()->set_try_index(try_index);
   }
+
+  if (for_finally_block.is_open()) {
+    JoinEntryInstr* after_finally = new JoinEntryInstr(owner()->try_index());
+    for_finally_block.Goto(after_finally);
+    for_finally_block.exit_ = after_finally;
+  }
+
+  Goto(finally_entry);
+  AppendFragment(finally_entry, for_finally_block);
+  exit_ = for_finally_block.exit_;
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
   // Compilation can be nested, preserve the computation-id.
   const Function& function = parsed_function().function();
-  TargetEntryInstr* normal_entry = new TargetEntryInstr();
+  TargetEntryInstr* normal_entry = new TargetEntryInstr(
+      CatchClauseNode::kInvalidTryIndex);
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   // TODO(kmillikin): We can eliminate stack checks in some cases (e.g., the
   // stack check on entry for leaf routines).
-  for_effect.Do(new CheckStackOverflowComp(function.token_pos(),
-                                           CatchClauseNode::kInvalidTryIndex));
+  for_effect.Do(new CheckStackOverflowComp(function.token_pos()));
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   return new FlowGraph(*this, graph_entry_);
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder Bailout: %s %s";
   const char* function_name = parsed_function_.function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(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