[Interpreter] Fix deopt when accumulator needs to be materialized.

src/deoptimizer.cc

 // Copyright 2013 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 "src/deoptimizer.h"
 
 #include "src/accessors.h"
 #include "src/ast/prettyprinter.h"
 #include "src/codegen.h"
 #include "src/disasm.h"
@@ skipping 1253 matching lines @@
   // The bytecode offset was mentioned explicitly in the BEGIN_FRAME.
   output_offset -= kPointerSize;
   input_offset -= kPointerSize;
   int raw_bytecode_offset =
       BytecodeArray::kHeaderSize - kHeapObjectTag + bytecode_offset;
   Smi* smi_bytecode_offset = Smi::FromInt(raw_bytecode_offset);
   WriteValueToOutput(smi_bytecode_offset, 0, frame_index, output_offset,
                      "bytecode offset ");
 
   // Translate the rest of the interpreter registers in the frame.
-  for (unsigned i = 0; i < height; ++i) {
+  for (unsigned i = 0; i < height - 1; ++i) {
     output_offset -= kPointerSize;
     WriteTranslatedValueToOutput(&value_iterator, &input_index, frame_index,
                                  output_offset);
   }
+
+  // Put the accumulator on the stack. It will be popped by the
+  // InterpreterNotifyDeopt builtin (possibly after materialization).
+  output_offset -= kPointerSize;
+  if (goto_catch_handler) {
+    // If we are lazy deopting to a catch handler, we set the accumulator to
+    // the exception (which lives in the result register).
+    intptr_t accumulator_value =
+        input_->GetRegister(FullCodeGenerator::result_register().code());
+    WriteValueToOutput(reinterpret_cast<Object*>(accumulator_value), 0,
+                       frame_index, output_offset, "accumulator ");
+    value_iterator++;
+  } else {
+    WriteTranslatedValueToOutput(&value_iterator, &input_index, frame_index,
+                                 output_offset);
+  }
   CHECK_EQ(0u, output_offset);
 
-  // Set the accumulator register. If we are lazy deopting to a catch handler,
-  // we set the accumulator to the exception (which lives in the result
-  // register).
-  intptr_t accumulator_value =
-      goto_catch_handler
-          ? input_->GetRegister(FullCodeGenerator::result_register().code())
-          : reinterpret_cast<intptr_t>(value_iterator->GetRawValue());
-  output_frame->SetRegister(kInterpreterAccumulatorRegister.code(),
-                            accumulator_value);
-  value_iterator++;
-
   Builtins* builtins = isolate_->builtins();
   Code* dispatch_builtin =
       builtins->builtin(Builtins::kInterpreterEnterBytecodeDispatch);
   output_frame->SetPc(reinterpret_cast<intptr_t>(dispatch_builtin->entry()));
   output_frame->SetState(0);
 
   // Update constant pool.
   if (FLAG_enable_embedded_constant_pool) {
     intptr_t constant_pool_value =
         reinterpret_cast<intptr_t>(dispatch_builtin->constant_pool());
@@ skipping 1260 matching lines @@
   for (int i = 0; i < skip_count; i++) {
     stack_it++;
   }
 
   // Get the context.
   context_ = GetValueForDebugger(stack_it, isolate);
   stack_it++;
 
   // Get the expression stack.
   int stack_height = frame_it->height();
-  if (frame_it->kind() == TranslatedFrame::kFunction) {
+  if (frame_it->kind() == TranslatedFrame::kFunction ||
+      frame_it->kind() == TranslatedFrame::kInterpretedFunction) {
     // For full-code frames, we should not count the context.
+    // For interpreter frames, we should not count the accumulator.
     // TODO(jarin): Clean up the indexing in translated frames.
     stack_height--;
   }
   expression_stack_.resize(static_cast<size_t>(stack_height));
   for (int i = 0; i < stack_height; i++) {
     Handle<Object> expression = GetValueForDebugger(stack_it, isolate);
     SetExpression(i, expression);
     stack_it++;
   }
 
   // For interpreter frame, skip the accumulator.
-  if (parameter_frame->kind() == TranslatedFrame::kInterpretedFunction) {
+  if (frame_it->kind() == TranslatedFrame::kInterpretedFunction) {
     stack_it++;
   }
   CHECK(stack_it == frame_it->end());
 }
 
 
 const char* Deoptimizer::GetDeoptReason(DeoptReason deopt_reason) {
   DCHECK(deopt_reason < kLastDeoptReason);
 #define DEOPT_MESSAGES_TEXTS(C, T) T,
   static const char* deopt_messages_[] = {
@@ skipping 346 matching lines @@
     case kFunction: {
       int parameter_count =
           raw_shared_info_->internal_formal_parameter_count() + 1;
       // + 1 for function.
       return height_ + parameter_count + 1;
     }
 
     case kInterpretedFunction: {
       int parameter_count =
           raw_shared_info_->internal_formal_parameter_count() + 1;
-      // + 3 for function, context and accumulator.
-      return height_ + parameter_count + 3;
+      // + 2 for function and context.
+      return height_ + parameter_count + 2;
     }
 
     case kGetter:
       return 2;  // Function and receiver.
 
     case kSetter:
       return 3;  // Function, receiver and the value to set.
 
     case kArgumentsAdaptor:
     case kConstructStub:
@@ skipping 779 matching lines @@
       CHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8