Try/catch in graph builder.

runtime/vm/flow_graph_compiler_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 13 matching lines @@
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     const ParsedFunction& parsed_function,
     const GrowableArray<BlockEntryInstr*>& block_order)
     : FlowGraphVisitor(block_order),
       assembler_(assembler),
       parsed_function_(parsed_function),
       block_info_(block_order.length()),
       current_block_(NULL),
-      pc_descriptors_list_(new DescriptorList()) {
+      pc_descriptors_list_(new DescriptorList()),
+      exception_handlers_list_(new ExceptionHandlerList()) {
   for (int i = 0; i < block_order.length(); ++i) {
     block_info_.Add(new BlockInfo());
   }
 }
 
 
 FlowGraphCompiler::~FlowGraphCompiler() {
   // BlockInfos are zone-allocated, so their destructors are not called.
   // Verify the labels explicitly here.
   for (int i = 0; i < block_info_.length(); ++i) {
@@ skipping 87 matching lines @@
 static bool VerifyValues(Value* v1, Value* v2) {
   if (v1->IsTemp() && v2->IsTemp()) {
     return (v1->AsTemp()->index() + 1) == v2->AsTemp()->index();
   }
   return true;
 }
 
 
 void FlowGraphCompiler::EmitInstanceCall(intptr_t node_id,
                                          intptr_t token_index,
+                                         intptr_t try_index,
                                          const String& function_name,
                                          intptr_t argument_count,
                                          const Array& argument_names,
                                          intptr_t checked_argument_count) {
   ICData& ic_data =
       ICData::ZoneHandle(ICData::New(parsed_function_.function(),
                                      function_name,
                                      node_id,
                                      checked_argument_count));
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count, argument_names);
   __ LoadObject(RBX, ic_data);
   __ LoadObject(R10, arguments_descriptor);
 
   uword label_address = 0;
   switch (checked_argument_count) {
     case 1:
       label_address = StubCode::OneArgCheckInlineCacheEntryPoint();
       break;
     case 2:
       label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
       break;
     default:
       UNIMPLEMENTED();
   }
   ExternalLabel target_label("InlineCache", label_address);
   __ call(&target_label);
-  AddCurrentDescriptor(PcDescriptors::kIcCall, node_id, token_index);
+  AddCurrentDescriptor(PcDescriptors::kIcCall, node_id, token_index, try_index);
   __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
 void FlowGraphCompiler::EmitStaticCall(intptr_t token_index,
+                                       intptr_t try_index,
                                        const Function& function,
                                        intptr_t argument_count,
                                        const Array& argument_names) {
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count, argument_names);
   __ LoadObject(RBX, function);
   __ LoadObject(R10, arguments_descriptor);
 
   GenerateCall(token_index,
+               try_index,
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
 void FlowGraphCompiler::VisitCurrentContext(CurrentContextComp* comp) {
   __ movq(RAX, CTX);
 }
 
 
 void FlowGraphCompiler::VisitStoreContext(StoreContextComp* comp) {
   LoadValue(CTX, comp->value());
 }
 
 
 void FlowGraphCompiler::VisitClosureCall(ClosureCallComp* comp) {
   ASSERT(comp->context()->IsTemp());
   ASSERT(VerifyCallComputation(comp));
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   int argument_count = comp->ArgumentCount();
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count - 1,
                                          comp->argument_names());
   __ LoadObject(R10, arguments_descriptor);
 
   GenerateCall(comp->token_index(),
+               comp->try_index(),
                &StubCode::CallClosureFunctionLabel(),
                PcDescriptors::kOther);
   __ addq(RSP, Immediate(argument_count * kWordSize));
   __ popq(CTX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
   ASSERT(VerifyCallComputation(comp));
   EmitInstanceCall(comp->node_id(),
                    comp->token_index(),
+                   comp->try_index(),
                    comp->function_name(),
                    comp->ArgumentCount(),
                    comp->argument_names(),
                    comp->checked_argument_count());
 }
 
 
 void FlowGraphCompiler::VisitStrictCompare(StrictCompareComp* comp) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
@@ skipping 10 matching lines @@
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&load_true);
   __ LoadObject(RAX, bool_true);
   __ Bind(&done);
 }
 
 
 void FlowGraphCompiler::VisitStaticCall(StaticCallComp* comp) {
   ASSERT(VerifyCallComputation(comp));
   EmitStaticCall(comp->token_index(),
+                 comp->try_index(),
                  comp->function(),
                  comp->ArgumentCount(),
                  comp->argument_names());
 }
 
 
 void FlowGraphCompiler::VisitLoadLocal(LoadLocalComp* comp) {
   if (comp->local().is_captured()) {
     // The variable lives in the context.
     intptr_t delta = comp->context_level() -
@@ skipping 43 matching lines @@
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in RAX.
   if (!comp->has_optional_parameters()) {
     __ leaq(RAX, Address(RBP, (1 + comp->argument_count()) * kWordSize));
   } else {
     __ leaq(RAX, Address(RBP, -1 * kWordSize));
   }
   __ movq(RBX, Immediate(reinterpret_cast<uword>(comp->native_c_function())));
   __ movq(R10, Immediate(comp->argument_count()));
   GenerateCall(comp->token_index(),
+               comp->try_index(),
                &StubCode::CallNativeCFunctionLabel(),
                PcDescriptors::kOther);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitLoadInstanceField(LoadInstanceFieldComp* comp) {
   LoadValue(RAX, comp->instance());
   __ movq(RAX, FieldAddress(RAX, comp->field().Offset()));
 }
@@ skipping 28 matching lines @@
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
 
   // Insert a copy of the third (last) argument under the arguments.
   __ popq(RAX);  // Value.
   __ popq(RBX);  // Index.
   __ popq(RCX);  // Receiver.
   __ pushq(RAX);
   __ pushq(RCX);
   __ pushq(RBX);
   __ pushq(RAX);
-  EmitInstanceCall(comp->node_id(), comp->token_index(), function_name, 3,
-                   Array::ZoneHandle(), 1);
+  EmitInstanceCall(comp->node_id(),
+                   comp->token_index(),
+                   comp->try_index(),
+                   function_name,
+                   3,
+                   Array::ZoneHandle(),
+                   1);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceSetter(InstanceSetterComp* comp) {
   // Preserve the second argument under the arguments as the result of the
   // computation, then call the setter.
   const String& function_name =
       String::ZoneHandle(Field::SetterSymbol(comp->field_name()));
 
   // Insert a copy of the second (last) argument under the arguments.
   __ popq(RAX);  // Value.
   __ popq(RBX);  // Receiver.
   __ pushq(RAX);
   __ pushq(RBX);
   __ pushq(RAX);
-  EmitInstanceCall(comp->node_id(), comp->token_index(), function_name, 2,
-                   Array::ZoneHandle(), 1);
+  EmitInstanceCall(comp->node_id(),
+                   comp->token_index(),
+                   comp->try_index(),
+                   function_name,
+                   2,
+                   Array::ZoneHandle(),
+                   1);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitStaticSetter(StaticSetterComp* comp) {
   // Preserve the argument as the result of the computation,
   // then call the setter.
 
   // Duplicate the argument.
   __ movq(RAX, Address(RSP, 0));
   __ pushq(RAX);
-  EmitStaticCall(comp->token_index(), comp->setter_function(), 1,
+  EmitStaticCall(comp->token_index(),
+                 comp->try_index(),
+                 comp->setter_function(),
+                 1,
                  Array::ZoneHandle());
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitBooleanNegate(BooleanNegateComp* comp) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label done;
   LoadValue(RDX, comp->value());
@@ skipping 25 matching lines @@
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // Destroys RCX.
 // Returns:
 // - true or false in RAX.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t node_id,
                                            intptr_t token_index,
+                                           intptr_t try_index,
                                            const AbstractType& type,
                                            bool negate_result) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   // All instances are of a subtype of the Object type.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
   Error& malformed_error = Error::Handle();
@@ skipping 108 matching lines @@
       Immediate(reinterpret_cast<int64_t>(Smi::New(node_id)));
   __ pushq(location);  // Push the source location.
   __ pushq(node_id_as_smi);
   __ pushq(RAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (!type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushq(raw_null);  // Null instantiator.
   }
-  GenerateCallRuntime(node_id, token_index, kInstanceofRuntimeEntry);
+  GenerateCallRuntime(node_id, token_index, try_index, kInstanceofRuntimeEntry);
   // Pop the two parameters supplied to the runtime entry. The result of the
   // instanceof runtime call will be left as the result of the operation.
   __ addq(RSP, Immediate(5 * kWordSize));
   if (negate_result) {
     Label negate_done;
     __ popq(RDX);
     __ LoadObject(RAX, bool_true);
     __ cmpq(RDX, RAX);
     __ j(NOT_EQUAL, &negate_done, Assembler::kNearJump);
     __ LoadObject(RAX, bool_false);
     __ Bind(&negate_done);
     __ pushq(RAX);
   }
   __ Bind(&done);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceOf(InstanceOfComp* comp) {
   __ popq(RAX);
   GenerateInstanceOf(comp->node_id(),
                      comp->token_index(),
+                     comp->try_index(),
                      comp->type(),
                      comp->negate_result());
 }
 
 
 void FlowGraphCompiler::VisitAllocateObject(AllocateObjectComp* comp) {
   const Class& cls = Class::ZoneHandle(comp->constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
-  GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
+  GenerateCall(comp->token_index(), comp->try_index(), &label,
+               PcDescriptors::kOther);
   for (intptr_t i = 0; i < comp->arguments().length(); i++) {
     __ popq(RCX);  // Discard allocation argument
   }
 }
 
 
 void FlowGraphCompiler::VisitCreateArray(CreateArrayComp* comp) {
   // 1. Allocate the array.  R10 = length, RBX = element type.
   __ movq(R10, Immediate(Smi::RawValue(comp->ElementCount())));
   const AbstractTypeArguments& element_type = comp->type_arguments();
   ASSERT(element_type.IsNull() || element_type.IsInstantiated());
   __ LoadObject(RBX, element_type);
   GenerateCall(comp->token_index(),
+               comp->try_index(),
                &StubCode::AllocateArrayLabel(),
                PcDescriptors::kOther);
 
   // 2. Initialize the array in RAX with the element values.
   __ leaq(RCX, FieldAddress(RAX, Array::data_offset()));
   for (int i = comp->ElementCount() - 1; i >= 0; --i) {
     if (comp->ElementAt(i)->IsTemp()) {
       __ popq(Address(RCX, i * kWordSize));
     } else {
       LoadValue(RDX, comp->ElementAt(i));
       __ movq(Address(RCX, i * kWordSize), RDX);
     }
   }
 }
 
 
 void FlowGraphCompiler::VisitCreateClosure(CreateClosureComp* comp) {
   const Function& function = comp->function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(function));
   const ExternalLabel label(function.ToCString(), stub.EntryPoint());
-  GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
+  GenerateCall(comp->token_index(), comp->try_index(), &label,
+               PcDescriptors::kOther);
 
   const Class& cls = Class::Handle(function.signature_class());
   if (cls.HasTypeArguments()) {
     __ popq(RCX);  // Discard type arguments.
   }
   if (function.IsImplicitInstanceClosureFunction()) {
     __ popq(RCX);  // Discard receiver.
   }
 }
 
@@ skipping 37 matching lines @@
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required before
   // calling the factory.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(comp->type_arguments());
   __ pushq(RAX);  // Push instantiator type arguments.
   GenerateCallRuntime(comp->node_id(),
                       comp->token_index(),
+                      comp->try_index(),
                       kInstantiateTypeArgumentsRuntimeEntry);
   __ popq(RAX);  // Pop instantiator type arguments.
   __ popq(RAX);  // Pop uninstantiated type arguments.
   __ popq(RAX);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   // RAX: Instantiated type arguments.
 }
 
 
 void FlowGraphCompiler::VisitExtractConstructorTypeArguments(
@@ skipping 89 matching lines @@
   }
   __ Bind(&done);
   // RAX: instantiator or kNoInstantiator.
 }
 
 
 void FlowGraphCompiler::VisitAllocateContext(AllocateContextComp* comp) {
   __ movq(R10, Immediate(comp->num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
-  GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
+  GenerateCall(comp->token_index(), comp->try_index(), &label,
+               PcDescriptors::kOther);
 }
 
 
 void FlowGraphCompiler::VisitChainContext(ChainContextComp* comp) {
   __ popq(RAX);
   // Chain the new context in RAX to its parent in CTX.
   __ StoreIntoObject(RAX,
                      FieldAddress(RAX, Context::parent_offset()),
                      CTX);
   // Set new context as current context.
   __ movq(CTX, RAX);
 }
 
 
 void FlowGraphCompiler::VisitCloneContext(CloneContextComp* comp) {
   __ popq(RAX);  // Get context value from stack.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(RAX);
   GenerateCallRuntime(comp->node_id(),
                       comp->token_index(),
+                      comp->try_index(),
                       kCloneContextRuntimeEntry);
   __ popq(RAX);  // Remove argument.
   __ popq(RAX);  // Get result (cloned context).
 }
 
 
+// Restore stack and initialize the two exception variables:
+// exception and stack trace variables.
+void FlowGraphCompiler::VisitCatchEntry(CatchEntryComp* comp) {
+  // Restore RSP from RBP as we are coming from a throw and the code for
+  // popping arguments has not been run.
+  const intptr_t locals_space_size = StackSize() * kWordSize;
+  ASSERT(locals_space_size >= 0);
+  __ movq(RSP, RBP);
+  __ subq(RSP, Immediate(locals_space_size));
+
+  ASSERT(!comp->exception_var().is_captured());
+  ASSERT(!comp->stacktrace_var().is_captured());
+  __ movq(Address(RBP, comp->exception_var().index() * kWordSize),
+          kExceptionObjectReg);
+  __ movq(Address(RBP, comp->stacktrace_var().index() * kWordSize),
+          kStackTraceObjectReg);
+}
+
+
 void FlowGraphCompiler::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     // Compile the block entry.
     current_block_ = block_order_[i];
     Instruction* instr = current_block()->Accept(this);
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
 
@@ skipping 11 matching lines @@
 }
 
 
 void FlowGraphCompiler::VisitJoinEntry(JoinEntryInstr* instr) {
   __ Bind(&block_info_[instr->postorder_number()]->label);
 }
 
 
 void FlowGraphCompiler::VisitTargetEntry(TargetEntryInstr* instr) {
   __ Bind(&block_info_[instr->postorder_number()]->label);
+  if (instr->HasTryIndex()) {
+    exception_handlers_list_->AddHandler(instr->try_index(),
+                                         assembler_->CodeSize());
+    // Bailout("Untested CatchEntry");
+  }
 }
 
 
 void FlowGraphCompiler::VisitPickTemp(PickTempInstr* instr) {
   // Semantics is to copy a stack-allocated temporary to the top of stack.
   // Destination index d is assumed the new top of stack after the
   // operation, so d-1 is the current top of stack and so d-s-1 is the
   // offset to source index s.
   intptr_t offset = instr->destination() - instr->source() - 1;
   ASSERT(offset >= 0);
@@ skipping 38 matching lines @@
 #endif  // DEBUG.
 
   if (FLAG_trace_functions) {
     __ pushq(RAX);  // Preserve result.
     const Function& function =
         Function::ZoneHandle(parsed_function_.function().raw());
     __ LoadObject(RBX, function);
     __ pushq(RBX);
     GenerateCallRuntime(AstNode::kNoId,
                         0,
+                        CatchClauseNode::kInvalidTryIndex,
                         kTraceFunctionExitRuntimeEntry);
     __ popq(RAX);  // Remove argument.
     __ popq(RAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 
   // Generate 8 bytes of NOPs so that the debugger can patch the
   // return pattern with a call to the debug stub.
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   AddCurrentDescriptor(PcDescriptors::kReturn,
                        AstNode::kNoId,
-                       instr->token_index());
+                       instr->token_index(),
+                       CatchClauseNode::kInvalidTryIndex);  // try-index.
 }
 
 
 void FlowGraphCompiler::VisitThrow(ThrowInstr* instr) {
   LoadValue(RAX, instr->exception());
   __ pushq(RAX);
   GenerateCallRuntime(instr->node_id(),
                       instr->token_index(),
+                      instr->try_index(),
                       kThrowRuntimeEntry);
   __ int3();
 }
 
 
 void FlowGraphCompiler::VisitReThrow(ReThrowInstr* instr) {
   LoadValue(RBX, instr->stack_trace());
   LoadValue(RAX, instr->exception());
   __ pushq(RAX);
   __ pushq(RBX);
-  GenerateCallRuntime(
-      instr->node_id(), instr->token_index(), kReThrowRuntimeEntry);
+  GenerateCallRuntime(instr->node_id(),
+                      instr->token_index(),
+                      instr->try_index(),
+                      kReThrowRuntimeEntry);
   Bailout("ReThrow Untested");
 }
 
 
 
 void FlowGraphCompiler::VisitBranch(BranchInstr* instr) {
   // Determine if the true branch is fall through (!negated) or the false
   // branch is.  They cannot both be backwards branches.
   intptr_t index = reverse_index(current_block()->postorder_number());
   bool negated = (block_order_[index + 1] == instr->false_successor());
@@ skipping 132 matching lines @@
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label all_arguments_processed;
   __ cmpq(Address(RDI, 0), raw_null);
   __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
 
   __ Bind(&wrong_num_arguments);
   if (function.IsClosureFunction()) {
     GenerateCallRuntime(AstNode::kNoId,
                         0,
+                        CatchClauseNode::kInvalidTryIndex,
                         kClosureArgumentMismatchRuntimeEntry);
   } else {
     // Invoke noSuchMethod function.
     const int kNumArgsChecked = 1;
     ICData& ic_data = ICData::ZoneHandle();
     ic_data = ICData::New(parsed_function_.function(),
                           String::Handle(function.name()),
                           AstNode::kNoId,
                           kNumArgsChecked);
     __ LoadObject(RBX, ic_data);
     // RBP : points to previous frame pointer.
     // RBP + 8 : points to return address.
     // RBP + 16 : address of last argument (arg n-1).
     // RSP + 16 + 8*(n-1) : address of first argument (arg 0).
     // RBX : ic-data.
     // R10 : arguments descriptor array.
     __ call(&StubCode::CallNoSuchMethodFunctionLabel());
   }
 
   if (FLAG_trace_functions) {
     __ pushq(RAX);  // Preserve result.
     __ PushObject(Function::ZoneHandle(function.raw()));
     GenerateCallRuntime(AstNode::kNoId,
                         0,
+                        CatchClauseNode::kInvalidTryIndex,
                         kTraceFunctionExitRuntimeEntry);
     __ popq(RAX);  // Remove argument.
     __ popq(RAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 
   __ Bind(&all_arguments_processed);
   // Nullify originally passed arguments only after they have been copied and
   // checked, otherwise noSuchMethod would not see their original values.
@@ skipping 40 matching lines @@
     if (check_arguments) {
       // Check that num_fixed <= argc <= num_params.
       Label argc_in_range;
       // Total number of args is the first Smi in args descriptor array (R10).
       __ movq(RAX, FieldAddress(R10, Array::data_offset()));
       __ cmpq(RAX, Immediate(Smi::RawValue(parameter_count)));
       __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(AstNode::kNoId,
                             function.token_index(),
+                            CatchClauseNode::kInvalidTryIndex,
                             kClosureArgumentMismatchRuntimeEntry);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
     CopyParameters();
   }
 
   // Initialize locals to null.
   if (local_count > 0) {
     __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(Object::null())));
     const int base = parsed_function_.first_stack_local_index();
     for (int i = 0; i < local_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (base - i) * kWordSize), RAX);
     }
   }
 
   // Generate stack overflow check.
   __ movq(TMP, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(TMP, 0));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow, Assembler::kNearJump);
   GenerateCallRuntime(AstNode::kNoId,
                       function.token_index(),
+                      CatchClauseNode::kInvalidTryIndex,
                       kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 
   if (FLAG_print_scopes) {
     // Print the function scope (again) after generating the prologue in order
     // to see annotations such as allocation indices of locals.
     if (FLAG_print_ast) {
       // Second printing.
       OS::Print("Annotated ");
     }
     AstPrinter::PrintFunctionScope(parsed_function_);
   }
 
   VisitBlocks();
 
   __ int3();
   // Emit function patching code. This will be swapped with the first 13 bytes
   // at entry point.
   pc_descriptors_list_->AddDescriptor(PcDescriptors::kPatchCode,
                                       assembler_->CodeSize(),
                                       AstNode::kNoId,
                                       0,
                                       -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
 // Infrastructure copied from class CodeGenerator.
 void FlowGraphCompiler::GenerateCall(intptr_t token_index,
+                                     intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind) {
   __ call(label);
-  AddCurrentDescriptor(kind, AstNode::kNoId, token_index);
+  AddCurrentDescriptor(kind, AstNode::kNoId, token_index, try_index);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t node_id,
                                             intptr_t token_index,
+                                            intptr_t try_index,
                                             const RuntimeEntry& entry) {
   __ CallRuntimeFromDart(entry);
-  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index, try_index);
 }
 
 
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(PcDescriptors::Kind kind,
                                              intptr_t node_id,
-                                             intptr_t token_index) {
+                                             intptr_t token_index,
+                                             intptr_t try_index) {
   pc_descriptors_list_->AddDescriptor(kind,
                                       assembler_->CodeSize(),
                                       node_id,
                                       token_index,
-                                      CatchClauseNode::kInvalidTryIndex);
+                                      try_index);
 }
 
 
 void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
   ASSERT(pc_descriptors_list_ != NULL);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
   descriptors.Verify(parsed_function_.function().is_optimizable());
   code.set_pc_descriptors(descriptors);
 }
 
 
 void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
   const LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle(
           parsed_function_.node_sequence()->scope()->GetVarDescriptors());
   code.set_var_descriptors(var_descs);
 }
 
 
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
-  // We don't compile exception handlers yet.
-  code.set_exception_handlers(
-      ExceptionHandlers::Handle(ExceptionHandlers::New(0)));
+  ASSERT(exception_handlers_list_ != NULL);
+  const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
+      exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
+  code.set_exception_handlers(handlers);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64