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

src/ia32/macro-assembler-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 875 matching lines @@
 
 
 void MacroAssembler::JumpToHandlerEntry() {
   // Compute the handler entry address and jump to it.  The handler table is
   // a fixed array of (smi-tagged) code offsets.
   // eax = exception, edi = code object, edx = state.
   mov(ebx, FieldOperand(edi, Code::kHandlerTableOffset));
   shr(edx, StackHandler::kKindWidth);
   mov(edx, FieldOperand(ebx, edx, times_4, FixedArray::kHeaderSize));
   SmiUntag(edx);
-  lea(edi, FieldOperand(edi, edx, times_1, Code::kHeaderSize));
-  jmp(edi);
+  // Preserve code object in edi for the optimizer handler.
+  lea(edx, FieldOperand(edi, edx, times_1, Code::kHeaderSize));
+  jmp(edx);
 }
 
 
 void MacroAssembler::Throw(Register value) {
   // Adjust this code if not the case.
   STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
   STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
   STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
   STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
   STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
 
   // The exception is expected in eax.
   if (!value.is(eax)) {
     mov(eax, value);
   }
-  // Drop the stack pointer to the top of the top handler.
+
+  // Get the handler address.
   ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
-  mov(esp, Operand::StaticVariable(handler_address));
-  // Restore the next handler.
+  mov(ecx, Operand::StaticVariable(handler_address));
+
+  // Drop the stack pointer to the top of the top handler and restore the
+  // next handler.
+  mov(esp, ecx);
   pop(Operand::StaticVariable(handler_address));
 
   // Remove the code object and state, compute the handler address in edi.
   pop(edi);  // Code object.
   pop(edx);  // Index and state.
 
   // Restore the context and frame pointer.
   pop(esi);  // Context.
   pop(ebp);  // Frame pointer.
 
@@ skipping 2043 matching lines @@
   j(not_equal, call_runtime);
 
   mov(ecx, FieldOperand(ebx, Map::kPrototypeOffset));
   cmp(ecx, isolate()->factory()->null_value());
   j(not_equal, &next);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32