Partial ia32 implementation of optimized try/catch (by Kevin Millikin)

src/ia32/lithium-codegen-ia32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 65 matching lines @@
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // MANUAL indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in GeneratePrologue).
   FrameScope frame_scope(masm_, StackFrame::MANUAL);
 
   dynamic_frame_alignment_ = (chunk()->num_double_slots() > 2 &&
                               !chunk()->graph()->is_recursive()) ||
                              !info()->osr_ast_id().IsNone();
 
+  handler_table_ = isolate()->factory()->NewFixedArray(
+      info()->function()->handler_count(), TENURED);
+
+
   return GeneratePrologue() &&
       GenerateBody() &&
       GenerateDeferredCode() &&
       GenerateSafepointTable();
 }
 
 
 void LCodeGen::FinishCode(Handle<Code> code) {
   ASSERT(is_done());
   code->set_stack_slots(GetStackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
+  code->set_handler_table(*handler_table_);
   PopulateDeoptimizationData(code);
   Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(code);
 }
 
 
 void LCodeGen::Abort(const char* reason) {
   info()->set_bailout_reason(reason);
   status_ = ABORTED;
 }
 
@@ skipping 304 matching lines @@
   int translation_size = environment->values()->length();
   // The output frame height does not include the parameters.
   int height = translation_size - environment->parameter_count();
 
   WriteTranslation(environment->outer(), translation);
   int closure_id = *info()->closure() != *environment->closure()
       ? DefineDeoptimizationLiteral(environment->closure())
       : Translation::kSelfLiteralId;
   switch (environment->frame_type()) {
     case JS_FUNCTION:
-      translation->BeginJSFrame(environment->ast_id(), closure_id, height);
+      translation->BeginJSFrame(environment->ast_id(), closure_id, height,
+                                environment->handler_count());
       break;
     case JS_CONSTRUCT:
       translation->BeginConstructStubFrame(closure_id, translation_size);
       break;
     case JS_GETTER:
       ASSERT(translation_size == 1);
       ASSERT(height == 0);
       translation->BeginGetterStubFrame(closure_id);
       break;
     case JS_SETTER:
@@ skipping 258 matching lines @@
   data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id().ToInt()));
   data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_));
 
   // Populate the deoptimization entries.
   for (int i = 0; i < length; i++) {
     LEnvironment* env = deoptimizations_[i];
     data->SetAstId(i, env->ast_id());
     data->SetTranslationIndex(i, Smi::FromInt(env->translation_index()));
     data->SetArgumentsStackHeight(i,
                                   Smi::FromInt(env->arguments_stack_height()));
+    // Write the total handler count to the deoptimization data, used to
+    // determine the stack sizes.
+    int handler_count = 0;
+    LEnvironment* current = env;
+    do {
+      handler_count += current->handler_count();
+      current = current->outer();
+    } while (current != NULL);
+    data->SetHandlerCount(i, Smi::FromInt(handler_count));
+
     data->SetPc(i, Smi::FromInt(env->pc_offset()));
   }
   code->set_deoptimization_data(*data);
 }
 
 
 int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) {
   int result = deoptimization_literals_.length();
   for (int i = 0; i < deoptimization_literals_.length(); ++i) {
     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
@@ skipping 102 matching lines @@
     if (move != NULL) DoParallelMove(move);
   }
 }
 
 
 void LCodeGen::DoInstructionGap(LInstructionGap* instr) {
   DoGap(instr);
 }
 
 
+void LCodeGen::DoEnterTry(LEnterTry* instr) {
+  Label try_entry, handler_entry;
+  __ jmp(&try_entry);
+  __ bind(&handler_entry);
+  handler_table_->set(instr->hydrogen()->index(),
+                      Smi::FromInt(handler_entry.pos()));
+  // Save code object.
+  __ push(edi);
+  // Pass code object as argument.
+  __ push(edi);
+  // Call Runtime_CatchInOptimizedCode which patches the code with the call to
+  // the deopt stub and returns the offset to the address we must jump to.
+  __ CallRuntime(Runtime::kCatchInOptimizedCode, 1);
+  // Get actual offset.
+  __ SmiUntag(eax);
+  // Restore code object.
+  __ pop(edi);
+  // Compute the target PC adding the offset to the code object.
+  __ add(edi, eax);
+  // Jump to target PC.
+  __ jmp(edi);
+  __ Abort("Unreachable (the exception should have been caught).");
+  __ bind(&try_entry);
+  __ PushTryHandler(StackHandler::OPTIMIZED_CATCH, instr->index());
+}
+
+
+void LCodeGen::DoLeaveTry(LLeaveTry* instr) {
+  __ PopTryHandler();
+}
+
+
 void LCodeGen::DoParameter(LParameter* instr) {
   // Nothing to do.
 }
 
 
 void LCodeGen::DoCallStub(LCallStub* instr) {
   ASSERT(ToRegister(instr->context()).is(esi));
   ASSERT(ToRegister(instr->result()).is(eax));
   switch (instr->hydrogen()->major_key()) {
     case CodeStub::RegExpConstructResult: {
@@ skipping 649 matching lines @@
   ASSERT(input->Equals(instr->result()));
   __ not_(ToRegister(input));
 }
 
 
 void LCodeGen::DoThrow(LThrow* instr) {
   __ push(ToOperand(instr->value()));
   ASSERT(ToRegister(instr->context()).is(esi));
   CallRuntime(Runtime::kThrow, 1, instr);
 
+  // Code after a throw now is reachable...
+#if false
   if (FLAG_debug_code) {
-    Comment("Unreachable code.");
+    Comment("Code after a throw should be unreachable.");
     __ int3();
   }
+#endif
 }
 
 
 void LCodeGen::DoAddI(LAddI* instr) {
   LOperand* left = instr->InputAt(0);
   LOperand* right = instr->InputAt(1);
   ASSERT(left->Equals(instr->result()));
 
   if (right->IsConstantOperand()) {
     __ add(ToOperand(left), ToInteger32Immediate(right));
@@ skipping 4008 matching lines @@
                               FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32