Experimental: cleanup the handling of try...catch and try...finally on...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 2636 matching lines @@
   // handler structure.
   if (FLAG_debug_code) {
     __ mov(eax, Operand::StaticVariable(handler_address));
     __ lea(eax, Operand(eax, StackHandlerConstants::kAddressDisplacement));
     __ cmp(esp, Operand(eax));
     __ Assert(equal, "stack pointer should point to top handler");
   }
 
   // If we can fall off the end of the try block, unlink from try chain.
   if (has_valid_frame()) {
+    // The TOS is the next handler address.
     frame_->EmitPop(eax);
-    __ mov(Operand::StaticVariable(handler_address), eax);  // TOS == next_sp
+    __ mov(Operand::StaticVariable(handler_address), eax);
     frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
-    // next_sp popped.
     if (nof_unlinks > 0) {
       exit.Jump();
     }
   }
 
   // Generate unlink code for the (formerly) shadowing targets that have been
   // jumped to.
   for (int i = 0; i <= nof_escapes; i++) {
     if (shadows[i]->is_linked()) {
       // Unlink from try chain; be careful not to destroy the TOS.
-      //
+      shadows[i]->Bind();
       // Because we can be jumping here (to spilled code) from unspilled
       // code, we need to reestablish a spilled frame at this block.
-      shadows[i]->Bind();
       frame_->SpillAll();
 
       // Reload sp from the top handler, because some statements that we
       // break from (eg, for...in) may have left stuff on the stack.
       __ mov(edx, Operand::StaticVariable(handler_address));
       const int kNextOffset = StackHandlerConstants::kNextOffset +
           StackHandlerConstants::kAddressDisplacement;
       __ lea(esp, Operand(edx, kNextOffset));
       frame_->Forget(frame_->height() - handler_height);
 
@@ skipping 27 matching lines @@
   JumpTarget try_block(this);
   JumpTarget finally_block(this);
 
   try_block.Call();
 
   frame_->EmitPush(eax);
   // In case of thrown exceptions, this is where we continue.
   __ Set(ecx, Immediate(Smi::FromInt(THROWING)));
   finally_block.Jump();
 
-
   // --- Try block ---
   try_block.Bind();
 
   frame_->PushTryHandler(TRY_FINALLY_HANDLER);
   int handler_height = frame_->height();
 
   // Shadow the jump targets for all escapes from the try block, including
   // returns.  During shadowing, the original target is hidden as the
   // ShadowTarget and operations on the original actually affect the
   // shadowing target.
@@ skipping 3936 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal