[Interpreter] Save bytecode offset in interpreter stack frames.

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include "src/code-factory.h"
 #include "src/compiler.h"
 #include "src/compiler/interpreter-assembler.h"
 #include "src/factory.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 using compiler::Node;
+typedef compiler::InterpreterAssembler::SaveAccumulatorMode SaveAccumulatorMode;

[Michael Starzinger, 2015/12/09 18:16:22]

nit: Would "using compiler::InterpreterAssembler::SaveAccumulatorMode" work?

[rmcilroy, 2015/12/10 14:17:12]

No, that didn't work (can't remember why). Removed anyway.

+
 #define __ assembler->
 
 
 Interpreter::Interpreter(Isolate* isolate)
     : isolate_(isolate) {}
 
 
 // static
 Handle<FixedArray> Interpreter::CreateUninitializedInterpreterTable(
     Isolate* isolate) {
@@ skipping 308 matching lines @@
 
   // Store the global via the StoreIC.
   Node* code_target = __ HeapConstant(ic.code());
   Node* constant_index = __ BytecodeOperandIdx(0);
   Node* name = __ LoadConstantPoolEntry(constant_index);
   Node* value = __ GetAccumulator();
   Node* raw_slot = __ BytecodeOperandIdx(1);
   Node* smi_slot = __ SmiTag(raw_slot);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   __ CallIC(ic.descriptor(), code_target, global, name, value, smi_slot,
-            type_feedback_vector);
+            type_feedback_vector, SaveAccumulatorMode::kSaveAccumulator);
 
   __ Dispatch();
 }
 
 
 // StaGlobalSloppy <name_index> <slot>
 //
 // Store the value in the accumulator into the global with name in constant pool
 // entry <name_index> using FeedBackVector slot <slot> in sloppy mode.
 void Interpreter::DoStaGlobalSloppy(compiler::InterpreterAssembler* assembler) {
@@ skipping 196 matching lines @@
   Node* code_target = __ HeapConstant(ic.code());
   Node* object_reg_index = __ BytecodeOperandReg(0);
   Node* object = __ LoadRegister(object_reg_index);
   Node* constant_index = __ BytecodeOperandIdx(1);
   Node* name = __ LoadConstantPoolEntry(constant_index);
   Node* value = __ GetAccumulator();
   Node* raw_slot = __ BytecodeOperandIdx(2);
   Node* smi_slot = __ SmiTag(raw_slot);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   __ CallIC(ic.descriptor(), code_target, object, name, value, smi_slot,
-            type_feedback_vector);
+            type_feedback_vector, SaveAccumulatorMode::kSaveAccumulator);
   __ Dispatch();
 }
 
 
 // StoreICSloppy <object> <name_index> <slot>
 //
 // Calls the sloppy mode StoreIC at FeedBackVector slot <slot> for <object> and
 // the name in constant pool entry <name_index> with the value in the
 // accumulator.
 void Interpreter::DoStoreICSloppy(compiler::InterpreterAssembler* assembler) {
@@ skipping 46 matching lines @@
   Node* code_target = __ HeapConstant(ic.code());
   Node* object_reg_index = __ BytecodeOperandReg(0);
   Node* object = __ LoadRegister(object_reg_index);
   Node* name_reg_index = __ BytecodeOperandReg(1);
   Node* name = __ LoadRegister(name_reg_index);
   Node* value = __ GetAccumulator();
   Node* raw_slot = __ BytecodeOperandIdx(2);
   Node* smi_slot = __ SmiTag(raw_slot);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   __ CallIC(ic.descriptor(), code_target, object, name, value, smi_slot,
-            type_feedback_vector);
+            type_feedback_vector, SaveAccumulatorMode::kSaveAccumulator);
   __ Dispatch();
 }
 
 
 // KeyedStoreICSloppy <object> <key> <slot>
 //
 // Calls the sloppy mode KeyStoreIC at FeedBackVector slot <slot> for <object>
 // and the key <key> with the value in the accumulator.
 void Interpreter::DoKeyedStoreICSloppy(
     compiler::InterpreterAssembler* assembler) {
@@ skipping 538 matching lines @@
 }
 
 
 // JumpIfToBooleanTrue <imm8>
 //
 // Jump by number of bytes represented by an immediate operand if the object
 // referenced by the accumulator is true when the object is cast to boolean.
 void Interpreter::DoJumpIfToBooleanTrue(
     compiler::InterpreterAssembler* assembler) {
   Node* accumulator = __ GetAccumulator();
+  Node* to_boolean_value =
+      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator,

[Michael Starzinger, 2015/12/09 18:16:22]

We assume that this bytecode is safe with the deoptimizer because
Runtime::kInterpreterToBoolean is assumed to never cause a lazy deopt. In that
case I am not sure whether it is really necessary to spill the accumulator for
this runtime call. Not sure about this one.

[rmcilroy, 2015/12/10 14:17:12]

Removed accumulator spilling (note the accumulator needed to be saved here even
without deopt because it needs to be saved across the call, and without
kSaveAccumulator it would be clobbered (and not spilled by TF automatically
either).

+                     SaveAccumulatorMode::kSaveAccumulator);
   Node* relative_jump = __ BytecodeOperandImm(0);
-  Node* to_boolean_value =
-      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator);
   Node* true_value = __ BooleanConstant(true);
   __ JumpIfWordEqual(to_boolean_value, true_value, relative_jump);
 }
 
 
 // JumpIfToBooleanTrueConstant <idx>
 //
 // Jump by number of bytes in the Smi in the |idx| entry in the constant pool
 // if the object referenced by the accumulator is true when the object is cast
 // to boolean.
 void Interpreter::DoJumpIfToBooleanTrueConstant(
     compiler::InterpreterAssembler* assembler) {
   Node* accumulator = __ GetAccumulator();
   Node* to_boolean_value =
-      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator);
+      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator,
+                     SaveAccumulatorMode::kSaveAccumulator);
   Node* index = __ BytecodeOperandIdx(0);
   Node* constant = __ LoadConstantPoolEntry(index);
   Node* relative_jump = __ SmiUntag(constant);
   Node* true_value = __ BooleanConstant(true);
   __ JumpIfWordEqual(to_boolean_value, true_value, relative_jump);
 }
 
 
 // JumpIfToBooleanFalse <imm8>
 //
 // Jump by number of bytes represented by an immediate operand if the object
 // referenced by the accumulator is false when the object is cast to boolean.
 void Interpreter::DoJumpIfToBooleanFalse(
     compiler::InterpreterAssembler* assembler) {
   Node* accumulator = __ GetAccumulator();
+  Node* to_boolean_value =
+      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator,
+                     SaveAccumulatorMode::kSaveAccumulator);
   Node* relative_jump = __ BytecodeOperandImm(0);
-  Node* to_boolean_value =
-      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator);
   Node* false_value = __ BooleanConstant(false);
   __ JumpIfWordEqual(to_boolean_value, false_value, relative_jump);
 }
 
 
 // JumpIfToBooleanFalseConstant <idx>
 //
 // Jump by number of bytes in the Smi in the |idx| entry in the constant pool
 // if the object referenced by the accumulator is false when the object is cast
 // to boolean.
 void Interpreter::DoJumpIfToBooleanFalseConstant(
     compiler::InterpreterAssembler* assembler) {
   Node* accumulator = __ GetAccumulator();
   Node* to_boolean_value =
-      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator);
+      __ CallRuntime(Runtime::kInterpreterToBoolean, accumulator,
+                     SaveAccumulatorMode::kSaveAccumulator);
   Node* index = __ BytecodeOperandIdx(0);
   Node* constant = __ LoadConstantPoolEntry(index);
   Node* relative_jump = __ SmiUntag(constant);
   Node* false_value = __ BooleanConstant(false);
   __ JumpIfWordEqual(to_boolean_value, false_value, relative_jump);
 }
 
 
 // JumpIfNull <imm8>
 //
@@ skipping 245 matching lines @@
   Node* cache_length = __ LoadFixedArrayElement(for_in_state, 3);
   Node* result = __ CallRuntime(Runtime::kForInDone, index, cache_length);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8