Try/catch in graph builder.

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"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/resolver.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, print_ast);
 
+
+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_() {}
+
+
+void FlowGraphBuilder::AddCatchEntry(intptr_t try_index, Instruction* entry) {
+  catch_entries_.Add(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 {
     exit()->SetSuccessor(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
@@ skipping 76 matching lines @@
     join->SetSuccessor(test_fragment.entry());
     body_exit->SetSuccessor(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();
 }
 
 
+// Stores current context into the 'variable'
+void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable,
+                                           intptr_t start_index) {
+  AddInstruction(new BindInstr(start_index, new CurrentContextComp()));
+  StoreLocalComp* store_context = new StoreLocalComp(
+      variable,
+      new TempVal(start_index),
+      owner()->context_level());
+  AddInstruction(new DoInstr(store_context));
+}
+
+
+// Loads context saved in 'context_variable' into the current context.
+void EffectGraphVisitor::BuildLoadContext(
+    const LocalVariable& context_variable, intptr_t start_index) {

[regis, 2012/04/10 22:58:24]

Should you also call the variable in BuildStoreContext "context_variable" for
symmetry? Or this one just "variable".

[srdjan, 2012/04/10 23:11:58]

-> variable

+  LoadLocalComp* load_saved_context =
+      new LoadLocalComp(context_variable, owner()->context_level());
+  AddInstruction(new BindInstr(start_index, load_saved_context));
+  StoreContextComp* store_context =
+      new StoreContextComp(new TempVal(start_index));
+  AddInstruction(new DoInstr(store_context));
+}
+
+
+
 void TestGraphVisitor::ReturnValue(Value* value) {
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void ArgumentGraphVisitor::ReturnValue(Value* value) {
@@ skipping 41 matching lines @@
           new AssertAssignableComp(return_value, type);
       AddInstruction(new BindInstr(temp_index(), assert));
       return_value = new TempVal(temp_index());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
-    LoadLocalComp* load_comp =
-        new LoadLocalComp(*owner()->parsed_function().saved_context_var(), 0);
-    AddInstruction(new BindInstr(temp_index(), load_comp));
-    TempVal* local_value = new TempVal(temp_index());
-    StoreContextComp* store_context = new StoreContextComp(local_value);
-    AddInstruction(new DoInstr(store_context));
+    BuildLoadContext(*owner()->parsed_function().saved_context_var(), 0);
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
 
   AddInstruction(new ReturnInstr(return_value, node->token_index()));
   CloseFragment();
 }
@@ skipping 54 matching lines @@
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
-  InstanceCallComp* call =
-      new InstanceCallComp(node->id(), node->token_index(), name,
-                           arguments, Array::ZoneHandle(), 2);
+  InstanceCallComp* call = new InstanceCallComp(node->id(),
+                                                node->token_index(),
+                                                owner()->try_index(),
+                                                name,
+                                                arguments,
+                                                Array::ZoneHandle(),
+                                                2);
   ReturnComputation(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
@@ skipping 96 matching lines @@
     CompiletimeStringInterpolation(interpol_func, literals);
     return;
   }
   // Runtime string interpolation.
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
   interpol_arg->Add(node->values());
   TranslateArgumentList(*interpol_arg, temp_index(), values);
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
+                         owner()->try_index(),
                          interpol_func,
                          interpol_arg->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
     ArgumentGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     InstanceOfComp* instance_of = new InstanceOfComp(
         node->id(),
         node->token_index(),
+        owner()->try_index(),
         for_left_value.value(),
         node->right()->AsTypeNode()->type(),
         (node->kind() == Token::kISNOT));
     ReturnComputation(instance_of);
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
@@ skipping 13 matching lines @@
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   // 'kNE' is not overloadable, must implement as kEQ and negation.
   // Boolean negation '!' cannot be overloaded neither.
   if (node->kind() == Token::kNE) {
     const String& name = String::ZoneHandle(String::NewSymbol("=="));
-    InstanceCallComp* call_equal =
-        new InstanceCallComp(node->id(), node->token_index(), name,
-                             arguments, Array::ZoneHandle(), 2);
+    InstanceCallComp* call_equal = new InstanceCallComp(
+        node->id(), node->token_index(), owner()->try_index(), name,
+        arguments, Array::ZoneHandle(), 2);
     AddInstruction(new BindInstr(temp_index(), call_equal));
     Value* eq_result = new TempVal(temp_index());
     if (FLAG_enable_type_checks) {
       Bailout("GenerateConditionTypeCheck in kNE");
     }
     BooleanNegateComp* negate = new BooleanNegateComp(eq_result);
     ReturnComputation(negate);
   } else {
     const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
-    InstanceCallComp* call =
-        new InstanceCallComp(node->id(), node->token_index(), name,
-                             arguments, Array::ZoneHandle(), 2);
+    InstanceCallComp* call = new InstanceCallComp(
+        node->id(), node->token_index(), owner()->try_index(), name,
+        arguments, Array::ZoneHandle(), 2);
     ReturnComputation(call);
   }
 }
 
 
 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);
     if (FLAG_enable_type_checks) {
       Bailout("GenerateConditionTypeCheck in kNOT");
     }
     BooleanNegateComp* negate = new BooleanNegateComp(for_value.value());
     ReturnComputation(negate);
     return;
   }
   ArgumentGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol((node->kind() == Token::kSUB)
                                                ? Token::Str(Token::kNEGATE)
                                                : node->Name()));
-  InstanceCallComp* call =
-      new InstanceCallComp(node->id(), node->token_index(), name,
-                           arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* call = new InstanceCallComp(
+      node->id(), node->token_index(), owner()->try_index(), name,
+      arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
@@ skipping 48 matching lines @@
   const int next_index = for_receiver.temp_index();
   ASSERT(next_index == start_index + 1);
   AddInstruction(new PickTempInstr(next_index, start_index));
 
   // Load the value.
   //   t_n+1 <- InstanceCall(get:name, t_n+1)
   const String& getter_name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(new TempVal(next_index));
-  InstanceCallComp* load =
-      new InstanceCallComp(node->getter_id(), node->token_index(), getter_name,
-                           arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* load = new InstanceCallComp(
+      node->getter_id(), node->token_index(), owner()->try_index(),
+      getter_name, arguments, Array::ZoneHandle(), 1);
   AddInstruction(new BindInstr(next_index, load));
 
   return next_index;
 }
 
 
 void EffectGraphVisitor::BuildIncrOpIncrement(Token::Kind kind,
                                               intptr_t node_id,
                                               intptr_t token_index,
                                               intptr_t start_index) {
   ASSERT((kind == Token::kINCR) || (kind == Token::kDECR));
   // Assumed that t_n-1 (where n is start_index) is the field value.
   //   t_n   <- #1
   //   t_n-1 <- InstanceCall(op, t_n-1, t_n)
   const Smi& one = Smi::ZoneHandle(Smi::New(1));
   AddInstruction(new BindInstr(start_index, new ConstantVal(one)));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(new TempVal(start_index - 1));
   arguments->Add(new TempVal(start_index));
   const String& op_name =
       String::ZoneHandle(String::NewSymbol((kind == Token::kINCR) ? "+" : "-"));
-  InstanceCallComp* add =
-      new InstanceCallComp(node_id, token_index, op_name,
-                           arguments, Array::ZoneHandle(), 2);
+  InstanceCallComp* add = new InstanceCallComp(
+      node_id, token_index, owner()->try_index(), op_name,
+      arguments, Array::ZoneHandle(), 2);
   AddInstruction(new BindInstr(start_index - 1, add));
 }
 
 
 void EffectGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   const int value_index = BuildIncrOpFieldLoad(node, temp_index());
   // 2. Increment.
   BuildIncrOpIncrement(node->kind(), node->operator_id(), node->token_index(),
                        value_index + 1);
   // 3. Perform the store, returning the stored value.
   InstanceSetterComp* store =
-      new InstanceSetterComp(node->setter_id(), node->token_index(),
+      new InstanceSetterComp(node->setter_id(),
+                             node->token_index(),
+                             owner()->try_index(),
                              node->field_name(),
                              new TempVal(value_index - 1),
                              new TempVal(value_index));
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
@@ skipping 14 matching lines @@
   AddInstruction(new TuckTempInstr(temp_index(), value_index));
   // 4. Increment.
   BuildIncrOpIncrement(node->kind(), node->operator_id(), node->token_index(),
                        value_index + 1);
   // 5. Perform the store and return the original value.
   const String& setter_name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(new TempVal(value_index - 1));
   arguments->Add(new TempVal(value_index));
-  InstanceCallComp* store =
-      new InstanceCallComp(node->setter_id(), node->token_index(),
-                           setter_name, arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* store = new InstanceCallComp(
+      node->setter_id(), node->token_index(), owner()->try_index(),
+      setter_name, arguments, Array::ZoneHandle(), 1);
   AddInstruction(new DoInstr(store));
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 int EffectGraphVisitor::BuildIncrOpIndexedLoad(IncrOpIndexedNode* node,
                                                intptr_t start_index) {
   // Evaluate the receiver and index.
   //   t_n   <- ... receiver ...
   //   t_n+1 <- ... index ...
@@ skipping 11 matching lines @@
   //   t_n+3 <- Pick(t_n+1)
   //   t_n+2 <- InstanceCall([], t_n+2, t_n+3)
   const int next_index = start_index + 2;
   AddInstruction(new PickTempInstr(next_index, start_index));
   AddInstruction(new PickTempInstr(next_index + 1, start_index + 1));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(new TempVal(next_index));
   arguments->Add(new TempVal(next_index + 1));
   const String& load_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
-  InstanceCallComp* load =
-      new InstanceCallComp(node->load_id(), node->token_index(), load_name,
-                           arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* load = new InstanceCallComp(
+      node->load_id(), node->token_index(), owner()->try_index(),
+      load_name, arguments, Array::ZoneHandle(), 1);
   AddInstruction(new BindInstr(next_index, load));
   return next_index;
 }
 
 
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   const int value_index = BuildIncrOpIndexedLoad(node, temp_index());
   // 2. Increment.
   BuildIncrOpIncrement(node->kind(), node->operator_id(), node->token_index(),
                        value_index + 1);
   // 3. Perform the store, returning the stored value.
   StoreIndexedComp* store = new StoreIndexedComp(node->store_id(),
                                                  node->token_index(),
+                                                 owner()->try_index(),
                                                  new TempVal(value_index - 2),
                                                  new TempVal(value_index - 1),
                                                  new TempVal(value_index));
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (node->prefix()) {
@@ skipping 14 matching lines @@
   // 4. Increment.
   BuildIncrOpIncrement(node->kind(), node->operator_id(), node->token_index(),
                        value_index + 1);
   // 5. Perform the store and return the original value.
   const String& store_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(3);
   arguments->Add(new TempVal(value_index - 2));
   arguments->Add(new TempVal(value_index - 1));
   arguments->Add(new TempVal(value_index));
-  InstanceCallComp* store =
-      new InstanceCallComp(node->store_id(), node->token_index(), store_name,
-                           arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* store = new InstanceCallComp(
+      node->store_id(), node->token_index(), owner()->try_index(),
+      store_name, arguments, Array::ZoneHandle(), 1);
   AddInstruction(new DoInstr(store));
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
@@ skipping 424 matching lines @@
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(node->length());
   int index = temp_index();
   for (int i = 0; i < node->length(); ++i) {
     ValueGraphVisitor for_value(owner(), index);
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     values->Add(for_value.value());
     index = for_value.temp_index();
   }
-  CreateArrayComp* create = new CreateArrayComp(node, values);
+  CreateArrayComp* create = new CreateArrayComp(node,
+                                                owner()->try_index(),
+                                                values);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
   int next_index = temp_index();
   if (function.IsNonImplicitClosureFunction()) {
     const ContextScope& context_scope = ContextScope::ZoneHandle(
@@ skipping 17 matching lines @@
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     type_arguments =
         BuildInstantiatorTypeArguments(node->token_index(), temp_index());
   }
 
-  CreateClosureComp* create = new CreateClosureComp(node, type_arguments);
+  CreateClosureComp* create =
+      new CreateClosureComp(node, owner()->try_index(), type_arguments);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     intptr_t next_temp_index,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ArgumentGraphVisitor for_argument(owner(), next_temp_index);
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     next_temp_index = for_argument.temp_index();
     values->Add(for_argument.value());
   }
 }
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   ArgumentListNode* arguments = node->arguments();
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   values->Add(for_receiver.value());
 
   TranslateArgumentList(*arguments, for_receiver.temp_index(), values);
-  InstanceCallComp* call =
-      new InstanceCallComp(node->id(), node->token_index(),
-                           node->function_name(), values,
+  InstanceCallComp* call = new InstanceCallComp(
+      node->id(), node->token_index(), owner()->try_index(),
+      node->function_name(), values,
                            arguments->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
   TranslateArgumentList(*node->arguments(), temp_index(), values);
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
+                         owner()->try_index(),
                          node->function(),
                          node->arguments()->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   // Context is saved around the call, it's treated as an extra operand
   // consumed by the call (but not an argument).
   AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
 
   ArgumentGraphVisitor for_closure(owner(), temp_index() + 1);
   node->closure()->Visit(&for_closure);
   Append(for_closure);
 
   ZoneGrowableArray<Value*>* arguments =
       new ZoneGrowableArray<Value*>(node->arguments()->length());
   arguments->Add(for_closure.value());
   TranslateArgumentList(*node->arguments(), temp_index() + 2, arguments);
   // First operand is the saved context, consumed by the call.
-  ClosureCallComp* call =
-      new ClosureCallComp(node, new TempVal(temp_index()), arguments);
+  ClosureCallComp* call =  new ClosureCallComp(node,
+                                               owner()->try_index(),
+                                               new TempVal(temp_index()),
+                                               arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
   TempVal* ctx = new TempVal(temp_index());
   AddInstruction(new BindInstr(temp_index(),
-                 new CloneContextComp(node->id(), node->token_index(), ctx)));
+                 new CloneContextComp(node->id(),
+                                      node->token_index(),
+                                      owner()->try_index(),
+                                      ctx)));
   TempVal* cloned_ctx = new TempVal(temp_index());
   ReturnComputation(new StoreContextComp(cloned_ctx));
 }
 
 
 TempVal* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node,
                                                    int start_index) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   ZoneGrowableArray<Value*>* allocate_arguments =
       new ZoneGrowableArray<Value*>();
   if (requires_type_arguments) {
     BuildConstructorTypeArguments(node, start_index, allocate_arguments);
   }
   AllocateObjectComp* alloc_comp =
-      new AllocateObjectComp(node, allocate_arguments);
+      new AllocateObjectComp(node,
+                             owner()->try_index(),
+                             allocate_arguments);
   AddInstruction(new BindInstr(start_index, alloc_comp));
   return new TempVal(start_index);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(ConstructorCallNode* node,
                                               int start_index,
                                               Value* alloc_value) {
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   values->Add(alloc_value);
   const Smi& ctor_arg = Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll));
   TempVal* ctor_arg_value = new TempVal(start_index);
   AddInstruction(
       new BindInstr(ctor_arg_value->index(), new ConstantVal(ctor_arg)));
   values->Add(ctor_arg_value);
   TranslateArgumentList(*node->arguments(), start_index + 1, values);
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
+                         owner()->try_index(),
                          node->constructor(),
                          node->arguments()->names(),
                          values);
   AddInstruction(new DoInstr(call));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<Value*>* factory_arguments =
         new ZoneGrowableArray<Value*>();
     factory_arguments->Add(BuildFactoryTypeArguments(node, temp_index()));
     ASSERT(factory_arguments->length() == 1);
     TranslateArgumentList(*node->arguments(),
                           temp_index() + 1,
                           factory_arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_index(),
+                           owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            factory_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 55 matching lines @@
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
     AddInstruction(
         new BindInstr(start_index, new ConstantVal(node->type_arguments())));
     return new TempVal(start_index);
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(node->token_index(), start_index);
   ExtractFactoryTypeArgumentsComp* extract =
-      new ExtractFactoryTypeArgumentsComp(node, instantiator_value);
+      new ExtractFactoryTypeArgumentsComp(node,
+                                          owner()->try_index(),
+                                          instantiator_value);
   AddInstruction(new BindInstr(start_index, extract));
   return new TempVal(start_index);
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     intptr_t start_index,
     ZoneGrowableArray<Value*>* args) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
@@ skipping 62 matching lines @@
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
-  InstanceCallComp* call =
-      new InstanceCallComp(node->id(), node->token_index(), name,
-                           arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* call = new InstanceCallComp(
+      node->id(), node->token_index(), owner()->try_index(), name,
+      arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ArgumentGraphVisitor for_value(owner(), for_receiver.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  InstanceSetterComp* setter = new InstanceSetterComp(node->id(),
-                                                      node->token_index(),
-                                                      node->field_name(),
-                                                      for_receiver.value(),
-                                                      for_value.value());
+  InstanceSetterComp* setter =
+      new InstanceSetterComp(node->id(),
+                             node->token_index(),
+                             owner()->try_index(),
+                             node->field_name(),
+                             for_receiver.value(),
+                             for_value.value());
   ReturnComputation(setter);
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   const Function& getter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(getter_name));
   ASSERT(!getter_function.IsNull());
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   StaticCallComp* call = new StaticCallComp(node->token_index(),
+                                            owner()->try_index(),
                                             getter_function,
                                             Array::ZoneHandle(),  // No names.
                                             values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
   const Function& setter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(setter_name));
   ASSERT(!setter_function.IsNull());
   ArgumentGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   StaticSetterComp* call = new StaticSetterComp(node->token_index(),
+                                                owner()->try_index(),
                                                 setter_function,
                                                 for_value.value());
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  NativeCallComp* native_call = new NativeCallComp(node);
+  NativeCallComp* native_call =
+      new NativeCallComp(node, owner()->try_index());
   ReturnComputation(native_call);
 }
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
@@ skipping 98 matching lines @@
   node->array()->Visit(&for_array);
   Append(for_array);
   ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_array.value());
   arguments->Add(for_index.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
-  InstanceCallComp* call =
-      new InstanceCallComp(node->id(), node->token_index(), name,
-                           arguments, Array::ZoneHandle(), 1);
+  InstanceCallComp* call = new InstanceCallComp(
+      node->id(), node->token_index(), owner()->try_index(), name,
+      arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ArgumentGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ArgumentGraphVisitor for_value(owner(), for_index.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   StoreIndexedComp* store = new StoreIndexedComp(node->id(),
                                                  node->token_index(),
+                                                 owner()->try_index(),
                                                  for_array.value(),
                                                  for_index.value(),
                                                  for_value.value());
   ReturnComputation(store);
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
@@ skipping 16 matching lines @@
 //                            label: SourceLabel }
 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)
-    AllocateContextComp* comp = new AllocateContextComp(node->token_index(),
-                                                        num_context_variables);
+    AllocateContextComp* comp = new AllocateContextComp(
+        node->token_index(),
+        owner()->try_index(),
+        num_context_variables);
     AddInstruction(new BindInstr(temp_index(), comp));
     Value* allocated_context_value = new TempVal(temp_index());
 
     // 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)) {
       AddInstruction(new BindInstr(temp_index() + 1, new CurrentContextComp()));
       StoreLocalComp* store_local = new StoreLocalComp(
@@ skipping 68 matching lines @@
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   if (is_open()) {
     if (MustSaveRestoreContext(node)) {
       ASSERT(num_context_variables > 0);
-      LoadLocalComp* load_comp =
-          new LoadLocalComp(*owner()->parsed_function().saved_context_var(), 0);
-      AddInstruction(new BindInstr(temp_index(), load_comp));
-      TempVal* local_value = new TempVal(temp_index());
-      StoreContextComp* store_context = new StoreContextComp(local_value);
-      AddInstruction(new DoInstr(store_context));
+      BuildLoadContext(*owner()->parsed_function().saved_context_var(), 0);
     } else if (num_context_variables > 0) {
       UnchainContext();
     }
   }
 
   // No continue on sequence allowed.
   ASSERT((node->label() == NULL) ||
          (node->label()->join_for_continue() == NULL));
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
   if ((node->label() != NULL) &&
       (node->label()->join_for_break() != NULL)) {
     if (is_open()) {
       AddInstruction(node->label()->join_for_break());
     } else {
       exit_ = node->label()->join_for_break();
     }
   }
 
   // The outermost function sequence cannot contain a label.
   ASSERT((node->label() == NULL) ||
          (node != owner()->parsed_function().node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
-  Bailout("EffectGraphVisitor::VisitCatchClauseNode");
+  // NOTE: The implicit variables ':saved_context', ':exception_var'
+  // and ':stacktrace_var' can never be captured variables.
+  // Restores CTX from local variable ':saved_context'.
+  CatchEntryComp* catch_entry = new CatchEntryComp(node->exception_var(),
+                                                   node->stacktrace_var());
+  AddInstruction(new DoInstr(catch_entry));
+  BuildLoadContext(node->context_var(), temp_index());
+
+  EffectGraphVisitor for_catch(owner(), temp_index());
+  node->VisitChildren(&for_catch);
+  Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
-  Bailout("EffectGraphVisitor::VisitTryCatchNode");
+  intptr_t old_try_index = owner()->try_index();
+  intptr_t try_index = owner()->allocate_try_index();
+  owner()->set_try_index(try_index);
+
+  // Preserve CTX into local variable '%saved_context'.
+  BuildStoreContext(node->context_var(), temp_index());
+
+  EffectGraphVisitor for_try_block(owner(), temp_index());
+  node->try_block()->Visit(&for_try_block);
+  Append(for_try_block);
+
+  // 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));
+    catch_block->Visit(&for_catch_block);
+    owner()->AddCatchEntry(try_index, for_catch_block.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();
+      }
+    }
+  }
+
+  if (node->finally_block() != NULL) {
+    Bailout("EffectGraphVisitor::VisitTryCatchNode finally");
+  }
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
-    instr = new ThrowInstr(
-        node->id(), node->token_index(), for_exception.value());
+    instr = new ThrowInstr(node->id(),
+                           node->token_index(),
+                           owner()->try_index(),
+                           for_exception.value());
   } else {
     ValueGraphVisitor for_stack_trace(owner(), temp_index() + 1);
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     instr = new ReThrowInstr(node->id(),
                              node->token_index(),
+                             owner()->try_index(),
                              for_exception.value(),
                              for_stack_trace.value());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   CloseFragment();
@@ skipping 306 matching lines @@
 }
 
 
 void FlowGraphPrinter::VisitCloneContext(CloneContextComp* comp) {
   OS::Print("CloneContext(");
   comp->context_value()->Accept(this);
   OS::Print(")");
 }
 
 
+void FlowGraphPrinter::VisitCatchEntry(CatchEntryComp* comp) {
+  OS::Print("CatchEntry(%s, %s)", comp->exception_var().name().ToCString(),
+                                  comp->stacktrace_var().name().ToCString());
+}
+
+
 void FlowGraphPrinter::VisitStoreContext(StoreContextComp* comp) {
   OS::Print("StoreContext(");
   comp->value()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", reverse_index(instr->postorder_number()));
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
-  OS::Print("%2d: [target]", reverse_index(instr->postorder_number()));
+  OS::Print("%2d: [target", reverse_index(instr->postorder_number()));
+  if (instr->HasTryIndex()) {
+    OS::Print(" catch %d]", instr->try_index());
+  } else {
+    OS::Print("]");
+  }
 }
 
 
 void FlowGraphPrinter::VisitPickTemp(PickTempInstr* instr) {
   OS::Print("    t%d <- Pick(t%d)", instr->destination(), instr->source());
 }
 
 
 void FlowGraphPrinter::VisitTuckTemp(TuckTempInstr* instr) {
   OS::Print("    t%d := t%d", instr->destination(), instr->source());
@@ skipping 47 matching lines @@
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
   const Function& function = parsed_function().function();
   EffectGraphVisitor for_effect(this, 0);
   for_effect.AddInstruction(new TargetEntryInstr());
   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);
+    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.
-    GrowableArray<intptr_t> parent;
     for_effect.entry()->DiscoverBlocks(NULL,  // Entry block predecessor.
                                        &preorder_block_entries_,
                                        &postorder_block_entries_,
                                        &parent);
     ComputeDominators(&preorder_block_entries_, &parent);
   }
   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) {
@@ skipping 99 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