Fix issue 86 by keeping track of the fact that finally blocks...

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 3474 matching lines @@
   // In case of thrown exceptions, this is where we continue.
   __ Set(ecx, Immediate(Smi::FromInt(THROWING)));
   __ jmp(&finally_block);
 
 
   // --- Try block ---
   __ bind(&try_block);
 
   __ PushTryHandler(IN_JAVASCRIPT, TRY_FINALLY_HANDLER);
   // TODO(1222589): remove the reliance of PushTryHandler on a cached TOS
-  __ push(eax);  //
+  __ push(eax);
 
   // Introduce shadow labels for all escapes from the try block,
   // including returns. We should probably try to unify the escaping
   // labels and the return label.
   int nof_escapes = node->escaping_labels()->length();
   List<LabelShadow*> shadows(1 + nof_escapes);
   shadows.Add(new LabelShadow(&function_return_));
   for (int i = 0; i < nof_escapes; i++) {
     shadows.Add(new LabelShadow(node->escaping_labels()->at(i)));
   }
@@ skipping 45 matching lines @@
   __ lea(esp, Operand(edx, kNextOffset));
 
   __ pop(Operand::StaticVariable(handler_address));
   __ add(Operand(esp), Immediate(StackHandlerConstants::kSize - kPointerSize));
   // next_sp popped.
   __ push(eax);  // preserve the TOS in a register across stack manipulation
 
   // --- Finally block ---
   __ bind(&finally_block);
 
+  // We keep a single element on the stack - the (possibly faked)
+  // result - while evaluating the finally block. Record it, so that a
+  // break/continue crossing this statement can restore the stack.
+  const int kFinallyStackSize = 1 * kPointerSize;
+  break_stack_height_ += kFinallyStackSize;
+
   // Push the state on the stack. If necessary move the state to a
   // local variable to avoid having extra values on the stack while
   // evaluating the finally block.
   __ push(ecx);
   if (node->finally_var() != NULL) {
     Reference target(this, node->finally_var());
     SetValue(&target);
     ASSERT(target.size() == 0);  // no extra stuff on the stack
     __ pop(edx);  // remove the extra value that was pushed above
   }
 
   // Generate code for the statements in the finally block.
   VisitStatements(node->finally_block()->statements());
 
   // Get the state from the stack - or the local variable - and
   // restore the TOS register.
   if (node->finally_var() != NULL) {
     Reference target(this, node->finally_var());
     GetValue(&target);
   }
   __ pop(ecx);
 
   // Restore return value or faked TOS.
   __ pop(eax);
 
+  // Record the fact that the result has been removed from the stack.
+  break_stack_height_ -= kFinallyStackSize;
+
   // Generate code that jumps to the right destination for all used
   // shadow labels.
   for (int i = 0; i <= nof_escapes; i++) {
     if (shadows[i]->is_bound()) {
       __ cmp(Operand(ecx), Immediate(Smi::FromInt(JUMPING + i)));
       __ j(equal, shadows[i]->shadowed());
     }
   }
 
   // Check if we need to rethrow the exception.
@@ skipping 1884 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = Ia32CodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal