Checking for stack height equality between full codegen and hydrogen.

src/full-codegen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "v8.h"
 
 #include "codegen.h"
 #include "compiler.h"
 #include "debug.h"
 #include "full-codegen.h"
@@ skipping 363 matching lines @@
 void FullCodeGenerator::PopulateDeoptimizationData(Handle<Code> code) {
   // Fill in the deoptimization information.
   ASSERT(info_->HasDeoptimizationSupport() || bailout_entries_.is_empty());
   if (!info_->HasDeoptimizationSupport()) return;
   int length = bailout_entries_.length();
   Handle<DeoptimizationOutputData> data =
       DeoptimizationOutputData::New(isolate(), length, TENURED);
   for (int i = 0; i < length; i++) {
     data->SetAstId(i, bailout_entries_[i].id);
     data->SetPcAndState(i, Smi::FromInt(bailout_entries_[i].pc_and_state));
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+    data->SetStackHeight(i, Smi::FromInt(bailout_entries_[i].stack_height));
+#endif
   }
   code->set_deoptimization_data(*data);
 }
 
 
 void FullCodeGenerator::PopulateTypeFeedbackInfo(Handle<Code> code) {
   Handle<TypeFeedbackInfo> info = isolate()->factory()->NewTypeFeedbackInfo();
   info->set_ic_total_count(ic_total_count_);
   ASSERT(!isolate()->heap()->InNewSpace(*info));
   code->set_type_feedback_info(*info);
@@ skipping 47 matching lines @@
   // was called.
   ASSERT(!call->return_is_recorded_);
   call->return_is_recorded_ = true;
 #endif
 }
 
 
 void FullCodeGenerator::PrepareForBailoutForId(BailoutId id, State state) {
   // There's no need to prepare this code for bailouts from already optimized
   // code or code that can't be optimized.
-  if (!info_->HasDeoptimizationSupport()) return;
+  if (!info_->HasDeoptimizationSupport()) {
+    // We still need to insert the check to make sure that we generate exactly
+    // the same code
+    CheckStackHeight();
+    return;
+  }
   unsigned pc_and_state =
       StateField::encode(state) | PcField::encode(masm_->pc_offset());
   ASSERT(Smi::IsValid(pc_and_state));
 #ifdef DEBUG
   for (int i = 0; i < bailout_entries_.length(); ++i) {
     ASSERT(bailout_entries_[i].id != id);
   }
 #endif
-  BailoutEntry entry = { id, pc_and_state };
+  // If the we store the top of the stack register, pretend it is on the stack
+  int stack_height = stack_height_.get() + (state == TOS_REG ? 1 : 0);
+  BailoutEntry entry = { id, pc_and_state, stack_height };
   bailout_entries_.Add(entry, zone());
+  CheckStackHeight();
 }
 
 
 void FullCodeGenerator::RecordBackEdge(BailoutId ast_id) {
   // The pc offset does not need to be encoded and packed together with a state.
   ASSERT(masm_->pc_offset() > 0);
   ASSERT(loop_depth() > 0);
   uint8_t depth = Min(loop_depth(), Code::kMaxLoopNestingMarker);
   BackEdgeEntry entry =
       { ast_id, static_cast<unsigned>(masm_->pc_offset()), depth };
@@ skipping 13 matching lines @@
 void FullCodeGenerator::EffectContext::Plug(Register reg) const {
 }
 
 
 void FullCodeGenerator::AccumulatorValueContext::Plug(Register reg) const {
   __ Move(result_register(), reg);
 }
 
 
 void FullCodeGenerator::StackValueContext::Plug(Register reg) const {
-  __ Push(reg);
+  codegen()->AsmPush(reg);
 }
 
 
 void FullCodeGenerator::TestContext::Plug(Register reg) const {
   // For simplicity we always test the accumulator register.
   __ Move(result_register(), reg);
   codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);
   codegen()->DoTest(this);
 }
 
 
 void FullCodeGenerator::EffectContext::PlugTOS() const {
-  __ Drop(1);
+  codegen()->AsmDrop(1);
 }
 
 
 void FullCodeGenerator::AccumulatorValueContext::PlugTOS() const {
-  __ Pop(result_register());
+  codegen()->AsmPop(result_register());
 }
 
 
 void FullCodeGenerator::StackValueContext::PlugTOS() const {
 }
 
 
 void FullCodeGenerator::TestContext::PlugTOS() const {
   // For simplicity we always test the accumulator register.
-  __ Pop(result_register());
+  codegen()->AsmPop(result_register());
   codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);
   codegen()->DoTest(this);
 }
 
 
 void FullCodeGenerator::EffectContext::PrepareTest(
     Label* materialize_true,
     Label* materialize_false,
     Label** if_true,
     Label** if_false,
@@ skipping 56 matching lines @@
       if (module != NULL) {
         Comment cmnt(masm_, "[ Link nested modules");
         Scope* scope = module->body()->scope();
         Interface* interface = scope->interface();
         ASSERT(interface->IsModule() && interface->IsFrozen());
 
         interface->Allocate(scope->module_var()->index());
 
         // Set up module context.
         ASSERT(scope->interface()->Index() >= 0);
-        __ Push(Smi::FromInt(scope->interface()->Index()));
-        __ Push(scope->GetScopeInfo());
-        __ CallRuntime(Runtime::kHiddenPushModuleContext, 2);
+        AsmPushSmi(Smi::FromInt(scope->interface()->Index()));
+        AsmPushHandle(scope->GetScopeInfo());
+        AsmCallRuntime(Runtime::kHiddenPushModuleContext, 2);
         StoreToFrameField(StandardFrameConstants::kContextOffset,
                           context_register());
 
         AllocateModules(scope->declarations());
 
         // Pop module context.
         LoadContextField(context_register(), Context::PREVIOUS_INDEX);
         // Update local stack frame context field.
         StoreToFrameField(StandardFrameConstants::kContextOffset,
                           context_register());
@@ skipping 68 matching lines @@
   Handle<FixedArray> saved_modules = modules_;
   int saved_module_index = module_index_;
   ZoneList<Handle<Object> >* saved_globals = globals_;
   ZoneList<Handle<Object> > inner_globals(10, zone());
   globals_ = &inner_globals;
 
   if (scope_->num_modules() != 0) {
     // This is a scope hosting modules. Allocate a descriptor array to pass
     // to the runtime for initialization.
     Comment cmnt(masm_, "[ Allocate modules");
+
     ASSERT(scope_->is_global_scope());
     modules_ =
         isolate()->factory()->NewFixedArray(scope_->num_modules(), TENURED);
     module_index_ = 0;
 
     // Generate code for allocating all modules, including nested ones.
     // The allocated contexts are stored in internal variables in this scope.
     AllocateModules(declarations);
   }
 
@@ skipping 29 matching lines @@
 
   Comment cmnt(masm_, "[ ModuleLiteral");
   SetStatementPosition(block);
 
   ASSERT(!modules_.is_null());
   ASSERT(module_index_ < modules_->length());
   int index = module_index_++;
 
   // Set up module context.
   ASSERT(interface->Index() >= 0);
-  __ Push(Smi::FromInt(interface->Index()));
-  __ Push(Smi::FromInt(0));
-  __ CallRuntime(Runtime::kHiddenPushModuleContext, 2);
+  AsmPushSmi(Smi::FromInt(interface->Index()));
+  AsmPushSmi(Smi::FromInt(0));
+  AsmCallRuntime(Runtime::kHiddenPushModuleContext, 2);
   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
 
   {
     Comment cmnt(masm_, "[ Declarations");
     VisitDeclarations(scope_->declarations());
   }
 
   // Populate the module description.
   Handle<ModuleInfo> description =
       ModuleInfo::Create(isolate(), interface, scope_);
@@ skipping 210 matching lines @@
   Label done;
 
   if (context()->IsTest()) {
     Label eval_right;
     const TestContext* test = TestContext::cast(context());
     if (is_logical_and) {
       VisitForControl(left, &eval_right, test->false_label(), &eval_right);
     } else {
       VisitForControl(left, test->true_label(), &eval_right, &eval_right);
     }
+    __ bind(&eval_right);
     PrepareForBailoutForId(right_id, NO_REGISTERS);
-    __ bind(&eval_right);
-
   } else if (context()->IsAccumulatorValue()) {
     VisitForAccumulatorValue(left);
     // We want the value in the accumulator for the test, and on the stack in
     // case we need it.
-    __ Push(result_register());
+    AsmPush(result_register());
     Label discard, restore;
     if (is_logical_and) {
       DoTest(left, &discard, &restore, &restore);
     } else {
       DoTest(left, &restore, &discard, &restore);
     }
+    StackHeightWrapper branch_stack_height = CurrentStackHeight();
     __ bind(&restore);
-    __ Pop(result_register());
+    AsmPop(result_register());
     __ jmp(&done);
     __ bind(&discard);
-    __ Drop(1);
+    SetStackHeight(branch_stack_height);
+    AsmDrop(1);
     PrepareForBailoutForId(right_id, NO_REGISTERS);
-
   } else if (context()->IsStackValue()) {
     VisitForAccumulatorValue(left);
     // We want the value in the accumulator for the test, and on the stack in
     // case we need it.
-    __ Push(result_register());
+    AsmPush(result_register());
     Label discard;
     if (is_logical_and) {
       DoTest(left, &discard, &done, &discard);
     } else {
       DoTest(left, &done, &discard, &discard);
     }
     __ bind(&discard);
-    __ Drop(1);
+    AsmDrop(1);
     PrepareForBailoutForId(right_id, NO_REGISTERS);
-
   } else {
     ASSERT(context()->IsEffect());
     Label eval_right;
     if (is_logical_and) {
       VisitForControl(left, &eval_right, &done, &eval_right);
     } else {
       VisitForControl(left, &done, &eval_right, &eval_right);
     }
+    __ bind(&eval_right);
     PrepareForBailoutForId(right_id, NO_REGISTERS);
-    __ bind(&eval_right);
   }
 
   VisitInDuplicateContext(right);
   __ bind(&done);
 }
 
 
 void FullCodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
   Token::Value op = expr->op();
   Comment cmnt(masm_, "[ ArithmeticExpression");
@@ skipping 20 matching lines @@
   Comment cmnt(masm_, "[ Block");
   NestedBlock nested_block(this, stmt);
   SetStatementPosition(stmt);
 
   Scope* saved_scope = scope();
   // Push a block context when entering a block with block scoped variables.
   if (stmt->scope() != NULL) {
     scope_ = stmt->scope();
     ASSERT(!scope_->is_module_scope());
     { Comment cmnt(masm_, "[ Extend block context");
-      __ Push(scope_->GetScopeInfo());
+      AsmPushHandle(scope_->GetScopeInfo());
       PushFunctionArgumentForContextAllocation();
-      __ CallRuntime(Runtime::kHiddenPushBlockContext, 2);
+      AsmCallRuntime(Runtime::kHiddenPushBlockContext, 2);
 
       // Replace the context stored in the frame.
       StoreToFrameField(StandardFrameConstants::kContextOffset,
                         context_register());
     }
     { Comment cmnt(masm_, "[ Declarations");
       VisitDeclarations(scope_->declarations());
     }
   }
 
   PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);
   VisitStatements(stmt->statements());
   scope_ = saved_scope;
   __ bind(nested_block.break_label());
   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
 
   // Pop block context if necessary.
   if (stmt->scope() != NULL) {
     LoadContextField(context_register(), Context::PREVIOUS_INDEX);
     // Update local stack frame context field.
     StoreToFrameField(StandardFrameConstants::kContextOffset,
                       context_register());
   }
 }
 
 
 void FullCodeGenerator::VisitModuleStatement(ModuleStatement* stmt) {
   Comment cmnt(masm_, "[ Module context");
 
-  __ Push(Smi::FromInt(stmt->proxy()->interface()->Index()));
-  __ Push(Smi::FromInt(0));
-  __ CallRuntime(Runtime::kHiddenPushModuleContext, 2);
+  AsmPushSmi(Smi::FromInt(stmt->proxy()->interface()->Index()));
+  AsmPushSmi(Smi::FromInt(0));
+  AsmCallRuntime(Runtime::kHiddenPushModuleContext, 2);
   StoreToFrameField(
       StandardFrameConstants::kContextOffset, context_register());
 
   Scope* saved_scope = scope_;
   scope_ = stmt->body()->scope();
   VisitStatements(stmt->body()->statements());
   scope_ = saved_scope;
   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
   // Update local stack frame context field.
   StoreToFrameField(StandardFrameConstants::kContextOffset,
@@ skipping 14 matching lines @@
 }
 
 
 void FullCodeGenerator::VisitIfStatement(IfStatement* stmt) {
   Comment cmnt(masm_, "[ IfStatement");
   SetStatementPosition(stmt);
   Label then_part, else_part, done;
 
   if (stmt->HasElseStatement()) {
     VisitForControl(stmt->condition(), &then_part, &else_part, &then_part);
+    StackHeightWrapper if_stack_height = CurrentStackHeight();
+    __ bind(&then_part);
     PrepareForBailoutForId(stmt->ThenId(), NO_REGISTERS);
-    __ bind(&then_part);
     Visit(stmt->then_statement());
     __ jmp(&done);
 
+    __ bind(&else_part);
+    SetStackHeight(if_stack_height);
     PrepareForBailoutForId(stmt->ElseId(), NO_REGISTERS);
-    __ bind(&else_part);
     Visit(stmt->else_statement());
   } else {
     VisitForControl(stmt->condition(), &then_part, &done, &then_part);
+    __ bind(&then_part);
     PrepareForBailoutForId(stmt->ThenId(), NO_REGISTERS);
-    __ bind(&then_part);
     Visit(stmt->then_statement());
 
     PrepareForBailoutForId(stmt->ElseId(), NO_REGISTERS);
   }
   __ bind(&done);
   PrepareForBailoutForId(stmt->IfId(), NO_REGISTERS);
 }
 
 
 void FullCodeGenerator::VisitContinueStatement(ContinueStatement* stmt) {
   Comment cmnt(masm_,  "[ ContinueStatement");
   SetStatementPosition(stmt);
   NestedStatement* current = nesting_stack_;
+  StackHeightWrapper original_stack_height = CurrentStackHeight();
   int stack_depth = 0;
   int context_length = 0;
   // When continuing, we clobber the unpredictable value in the accumulator
   // with one that's safe for GC.  If we hit an exit from the try block of
   // try...finally on our way out, we will unconditionally preserve the
   // accumulator on the stack.
   ClearAccumulator();
   while (!current->IsContinueTarget(stmt->target())) {
     current = current->Exit(&stack_depth, &context_length);
   }
-  __ Drop(stack_depth);
+  AsmDrop(stack_depth);
   if (context_length > 0) {
     while (context_length > 0) {
       LoadContextField(context_register(), Context::PREVIOUS_INDEX);
       --context_length;
     }
     StoreToFrameField(StandardFrameConstants::kContextOffset,
                       context_register());
   }
 
   __ jmp(current->AsIteration()->continue_label());
+  SetStackHeight(original_stack_height);
 }
 
 
 void FullCodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
   Comment cmnt(masm_,  "[ BreakStatement");
   SetStatementPosition(stmt);
   NestedStatement* current = nesting_stack_;
+  StackHeightWrapper original_stack_height = CurrentStackHeight();
   int stack_depth = 0;
   int context_length = 0;
   // When breaking, we clobber the unpredictable value in the accumulator
   // with one that's safe for GC.  If we hit an exit from the try block of
   // try...finally on our way out, we will unconditionally preserve the
   // accumulator on the stack.
   ClearAccumulator();
   while (!current->IsBreakTarget(stmt->target())) {
     current = current->Exit(&stack_depth, &context_length);
   }
-  __ Drop(stack_depth);
+  AsmDrop(stack_depth);
   if (context_length > 0) {
     while (context_length > 0) {
       LoadContextField(context_register(), Context::PREVIOUS_INDEX);
       --context_length;
     }
     StoreToFrameField(StandardFrameConstants::kContextOffset,
                       context_register());
   }
 
   __ jmp(current->AsBreakable()->break_label());
+  SetStackHeight(original_stack_height);
 }
 
 
 void FullCodeGenerator::EmitUnwindBeforeReturn() {
   NestedStatement* current = nesting_stack_;
   int stack_depth = 0;
   int context_length = 0;
   while (current != NULL) {
     current = current->Exit(&stack_depth, &context_length);
   }
-  __ Drop(stack_depth);
+  AsmDrop(stack_depth);
 }
 
 
 void FullCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   Comment cmnt(masm_, "[ ReturnStatement");
   SetStatementPosition(stmt);
   Expression* expr = stmt->expression();
   VisitForAccumulatorValue(expr);
+  StackHeightWrapper previous_stack_height = CurrentStackHeight();
   EmitUnwindBeforeReturn();
   EmitReturnSequence();
+  // Reset the expected stack height
+  SetStackHeight(previous_stack_height);
 }
 
 
 void FullCodeGenerator::VisitWithStatement(WithStatement* stmt) {
   Comment cmnt(masm_, "[ WithStatement");
   SetStatementPosition(stmt);
 
   VisitForStackValue(stmt->expression());
   PushFunctionArgumentForContextAllocation();
-  __ CallRuntime(Runtime::kHiddenPushWithContext, 2);
+  AsmCallRuntime(Runtime::kHiddenPushWithContext, 2);
   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
 
   Scope* saved_scope = scope();
   scope_ = stmt->scope();
   { WithOrCatch body(this);
     Visit(stmt->statement());
   }
   scope_ = saved_scope;
 
   // Pop context.
@@ skipping 18 matching lines @@
   // possible to break on the condition.
   __ bind(loop_statement.continue_label());
   PrepareForBailoutForId(stmt->ContinueId(), NO_REGISTERS);
   SetExpressionPosition(stmt->cond());
   VisitForControl(stmt->cond(),
                   &book_keeping,
                   loop_statement.break_label(),
                   &book_keeping);
 
   // Check stack before looping.
+  __ bind(&book_keeping);
   PrepareForBailoutForId(stmt->BackEdgeId(), NO_REGISTERS);
-  __ bind(&book_keeping);
   EmitBackEdgeBookkeeping(stmt, &body);
   __ jmp(&body);
 
+  __ bind(loop_statement.break_label());
   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
-  __ bind(loop_statement.break_label());
   decrement_loop_depth();
 }
 
 
 void FullCodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
   Comment cmnt(masm_, "[ WhileStatement");
   Label test, body;
 
   Iteration loop_statement(this, stmt);
   increment_loop_depth();
 
   // Emit the test at the bottom of the loop.
   __ jmp(&test);
 
+  __ bind(&body);
   PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
-  __ bind(&body);
   Visit(stmt->body());
 
   // Emit the statement position here as this is where the while
   // statement code starts.
   __ bind(loop_statement.continue_label());
   SetStatementPosition(stmt);
 
   // Check stack before looping.
   EmitBackEdgeBookkeeping(stmt, &body);
 
   __ bind(&test);
   VisitForControl(stmt->cond(),
                   &body,
                   loop_statement.break_label(),
                   loop_statement.break_label());
 
+  __ bind(loop_statement.break_label());
   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
-  __ bind(loop_statement.break_label());
   decrement_loop_depth();
 }
 
 
 void FullCodeGenerator::VisitForStatement(ForStatement* stmt) {
   Comment cmnt(masm_, "[ ForStatement");
   Label test, body;
 
   Iteration loop_statement(this, stmt);
 
   // Set statement position for a break slot before entering the for-body.
   SetStatementPosition(stmt);
 
   if (stmt->init() != NULL) {
     Visit(stmt->init());
   }
 
   increment_loop_depth();
   // Emit the test at the bottom of the loop (even if empty).
   __ jmp(&test);
 
+  __ bind(&body);
   PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
-  __ bind(&body);
   Visit(stmt->body());
 
+  __ bind(loop_statement.continue_label());
   PrepareForBailoutForId(stmt->ContinueId(), NO_REGISTERS);
-  __ bind(loop_statement.continue_label());
   if (stmt->next() != NULL) {
     Visit(stmt->next());
   }
 
   // Emit the statement position here as this is where the for
   // statement code starts.
   SetStatementPosition(stmt);
 
   // Check stack before looping.
   EmitBackEdgeBookkeeping(stmt, &body);
 
   __ bind(&test);
   if (stmt->cond() != NULL) {
     VisitForControl(stmt->cond(),
                     &body,
                     loop_statement.break_label(),
                     loop_statement.break_label());
   } else {
     __ jmp(&body);
   }
 
+  __ bind(loop_statement.break_label());
   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
-  __ bind(loop_statement.break_label());
   decrement_loop_depth();
 }
 
 
 void FullCodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
   Comment cmnt(masm_, "[ TryCatchStatement");
   SetStatementPosition(stmt);
   // The try block adds a handler to the exception handler chain before
   // entering, and removes it again when exiting normally.  If an exception
   // is thrown during execution of the try block, the handler is consumed
   // and control is passed to the catch block with the exception in the
   // result register.
 
   Label try_entry, handler_entry, exit;
   __ jmp(&try_entry);
   __ bind(&handler_entry);
   handler_table()->set(stmt->index(), Smi::FromInt(handler_entry.pos()));
   // Exception handler code, the exception is in the result register.
   // Extend the context before executing the catch block.
   { Comment cmnt(masm_, "[ Extend catch context");
-    __ Push(stmt->variable()->name());
-    __ Push(result_register());
+    AsmPushHandle(stmt->variable()->name());
+    AsmPush(result_register());
     PushFunctionArgumentForContextAllocation();
-    __ CallRuntime(Runtime::kHiddenPushCatchContext, 3);
+    AsmCallRuntime(Runtime::kHiddenPushCatchContext, 3);
     StoreToFrameField(StandardFrameConstants::kContextOffset,
                       context_register());
   }
 
   Scope* saved_scope = scope();
   scope_ = stmt->scope();
   ASSERT(scope_->declarations()->is_empty());
   { WithOrCatch catch_body(this);
     Visit(stmt->catch_block());
   }
   // Restore the context.
   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
   scope_ = saved_scope;
   __ jmp(&exit);
 
   // Try block code. Sets up the exception handler chain.
   __ bind(&try_entry);
-  __ PushTryHandler(StackHandler::CATCH, stmt->index());
+  AsmPushTryHandler(StackHandler::CATCH, stmt->index());
   { TryCatch try_body(this);
     Visit(stmt->try_block());
   }
-  __ PopTryHandler();
+  AsmPopTryHandler();
   __ bind(&exit);
 }
 
 
 void FullCodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   Comment cmnt(masm_, "[ TryFinallyStatement");
   SetStatementPosition(stmt);
   // Try finally is compiled by setting up a try-handler on the stack while
   // executing the try body, and removing it again afterwards.
   //
@@ skipping 19 matching lines @@
 
   // Jump to try-handler setup and try-block code.
   __ jmp(&try_entry);
   __ bind(&handler_entry);
   handler_table()->set(stmt->index(), Smi::FromInt(handler_entry.pos()));
   // Exception handler code.  This code is only executed when an exception
   // is thrown.  The exception is in the result register, and must be
   // preserved by the finally block.  Call the finally block and then
   // rethrow the exception if it returns.
   __ Call(&finally_entry);
-  __ Push(result_register());
-  __ CallRuntime(Runtime::kHiddenReThrow, 1);
+  AsmPush(result_register());
+  AsmCallRuntime(Runtime::kHiddenReThrow, 1);
 
   // Finally block implementation.
   __ bind(&finally_entry);
+  // The return address is on the stack -> update the height
+  UpdateStackHeight(1);
   EnterFinallyBlock();
   { Finally finally_body(this);
     Visit(stmt->finally_block());
   }
   ExitFinallyBlock();  // Return to the calling code.
 
   // Set up try handler.
   __ bind(&try_entry);
-  __ PushTryHandler(StackHandler::FINALLY, stmt->index());
+  AsmPushTryHandler(StackHandler::FINALLY, stmt->index());
   { TryFinally try_body(this, &finally_entry);
     Visit(stmt->try_block());
   }
-  __ PopTryHandler();
+  AsmPopTryHandler();
   // Execute the finally block on the way out.  Clobber the unpredictable
   // value in the result register with one that's safe for GC because the
   // finally block will unconditionally preserve the result register on the
   // stack.
   ClearAccumulator();
   __ Call(&finally_entry);
 }
 
 
 void FullCodeGenerator::VisitDebuggerStatement(DebuggerStatement* stmt) {
   Comment cmnt(masm_, "[ DebuggerStatement");
   SetStatementPosition(stmt);
 
   __ DebugBreak();
   // Ignore the return value.
 }
 
 
 void FullCodeGenerator::VisitCaseClause(CaseClause* clause) {
   UNREACHABLE();
 }
 
 
 void FullCodeGenerator::VisitConditional(Conditional* expr) {
   Comment cmnt(masm_, "[ Conditional");
   Label true_case, false_case, done;
   VisitForControl(expr->condition(), &true_case, &false_case, &true_case);
+  StackHeightWrapper if_stack_height = CurrentStackHeight();
 
+  __ bind(&true_case);
   PrepareForBailoutForId(expr->ThenId(), NO_REGISTERS);
-  __ bind(&true_case);
   SetExpressionPosition(expr->then_expression());
   if (context()->IsTest()) {
     const TestContext* for_test = TestContext::cast(context());
     VisitForControl(expr->then_expression(),
                     for_test->true_label(),
                     for_test->false_label(),
                     NULL);
   } else {
     VisitInDuplicateContext(expr->then_expression());
     __ jmp(&done);
   }
 
+  __ bind(&false_case);
+  SetStackHeight(if_stack_height);
   PrepareForBailoutForId(expr->ElseId(), NO_REGISTERS);
-  __ bind(&false_case);
   SetExpressionPosition(expr->else_expression());
   VisitInDuplicateContext(expr->else_expression());
   // If control flow falls through Visit, merge it with true case here.
   if (!context()->IsTest()) {
     __ bind(&done);
   }
 }
 
 
 void FullCodeGenerator::VisitLiteral(Literal* expr) {
@@ skipping 45 matching lines @@
   int parameters = fun->shared()->formal_parameter_count();
   shared->set_formal_parameter_count(parameters);
 
   EmitNewClosure(shared, false);
 }
 
 
 void FullCodeGenerator::VisitThrow(Throw* expr) {
   Comment cmnt(masm_, "[ Throw");
   VisitForStackValue(expr->exception());
-  __ CallRuntime(Runtime::kHiddenThrow, 1);
-  // Never returns here.
+  AsmCallRuntime(Runtime::kHiddenThrow, 1);
+  // Never returns here. Update stack height so that we do not confuse the
+  // stack height checker.
+  if (context() != NULL && !context()->IsEffect()) {
+    UpdateStackHeight(1);
+  }
 }
 
 
 FullCodeGenerator::NestedStatement* FullCodeGenerator::TryCatch::Exit(
     int* stack_depth,
     int* context_length) {
   // The macros used here must preserve the result register.
-  __ Drop(*stack_depth);
-  __ PopTryHandler();
+  codegen()->AsmDrop(*stack_depth);
+  codegen()->AsmPopTryHandler();
   *stack_depth = 0;
   return previous_;
 }
 
 
 bool FullCodeGenerator::TryLiteralCompare(CompareOperation* expr) {
   Expression* sub_expr;
   Handle<String> check;
   if (expr->IsLiteralCompareTypeof(&sub_expr, &check)) {
     EmitLiteralCompareTypeof(expr, sub_expr, check);
@@ skipping 101 matching lines @@
   }
   return true;
 }
 #endif  // DEBUG
 
 
 #undef __
 
 
 } }  // namespace v8::internal