[Interpreter] Save bytecode offset in interpreter stack frames.

src/compiler/interpreter-assembler.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/compiler/interpreter-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 16 matching lines @@
 
 InterpreterAssembler::InterpreterAssembler(Isolate* isolate, Zone* zone,
                                            interpreter::Bytecode bytecode)
     : bytecode_(bytecode),
       raw_assembler_(new RawMachineAssembler(
           isolate, new (zone) Graph(zone),
           Linkage::GetInterpreterDispatchDescriptor(zone), kMachPtr,
           InstructionSelector::SupportedMachineOperatorFlags())),
       accumulator_(
           raw_assembler_->Parameter(Linkage::kInterpreterAccumulatorParameter)),
+      bytecode_offset_(raw_assembler_->Parameter(
+          Linkage::kInterpreterBytecodeOffsetParameter)),
       context_(
           raw_assembler_->Parameter(Linkage::kInterpreterContextParameter)),
       code_generated_(false) {}
 
 
 InterpreterAssembler::~InterpreterAssembler() {}
 
 
 Handle<Code> InterpreterAssembler::GenerateCode() {
   DCHECK(!code_generated_);
@@ skipping 26 matching lines @@
 
 void InterpreterAssembler::SetAccumulator(Node* value) { accumulator_ = value; }
 
 
 Node* InterpreterAssembler::GetContext() { return context_; }
 
 
 void InterpreterAssembler::SetContext(Node* value) { context_ = value; }
 
 
+Node* InterpreterAssembler::BytecodeOffset() { return bytecode_offset_; }
+
+
 Node* InterpreterAssembler::RegisterFileRawPointer() {
   return raw_assembler_->Parameter(Linkage::kInterpreterRegisterFileParameter);
 }
 
 
 Node* InterpreterAssembler::BytecodeArrayTaggedPointer() {
   return raw_assembler_->Parameter(Linkage::kInterpreterBytecodeArrayParameter);
 }
 
 
-Node* InterpreterAssembler::BytecodeOffset() {
-  return raw_assembler_->Parameter(
-      Linkage::kInterpreterBytecodeOffsetParameter);
-}
-
-
 Node* InterpreterAssembler::DispatchTableRawPointer() {
   return raw_assembler_->Parameter(Linkage::kInterpreterDispatchTableParameter);
 }
 
 
+Node* InterpreterAssembler::RegisterLocation(Node* reg_index) {
+  return IntPtrAdd(RegisterFileRawPointer(), RegisterFrameOffset(reg_index));
+}
+
+
+Node* InterpreterAssembler::LoadRegister(int offset) {
+  return raw_assembler_->Load(kMachAnyTagged, RegisterFileRawPointer(),
+                              Int32Constant(offset));
+}
+
+
+Node* InterpreterAssembler::LoadRegister(interpreter::Register reg) {
+  return LoadRegister(reg.ToOperand() << kPointerSizeLog2);
+}
+
+
 Node* InterpreterAssembler::RegisterFrameOffset(Node* index) {
   return WordShl(index, kPointerSizeLog2);
 }
 
 
-Node* InterpreterAssembler::RegisterLocation(Node* reg_index) {
-  return IntPtrAdd(RegisterFileRawPointer(), RegisterFrameOffset(reg_index));
-}
-
-
-Node* InterpreterAssembler::LoadRegister(interpreter::Register reg) {
-  return raw_assembler_->Load(
-      kMachAnyTagged, RegisterFileRawPointer(),
-      RegisterFrameOffset(Int32Constant(reg.ToOperand())));
-}
-
-
 Node* InterpreterAssembler::LoadRegister(Node* reg_index) {
   return raw_assembler_->Load(kMachAnyTagged, RegisterFileRawPointer(),
                               RegisterFrameOffset(reg_index));
 }
 
 
+Node* InterpreterAssembler::StoreRegister(Node* value, int offset) {
+  return raw_assembler_->Store(kMachAnyTagged, RegisterFileRawPointer(),
+                               Int32Constant(offset), value, kNoWriteBarrier);
+}
+
+
+Node* InterpreterAssembler::StoreRegister(Node* value,
+                                          interpreter::Register reg) {
+  return StoreRegister(value, reg.ToOperand() << kPointerSizeLog2);
+}
+
+
 Node* InterpreterAssembler::StoreRegister(Node* value, Node* reg_index) {
   return raw_assembler_->Store(kMachAnyTagged, RegisterFileRawPointer(),
                                RegisterFrameOffset(reg_index), value,
                                kNoWriteBarrier);
 }
 
 
 Node* InterpreterAssembler::BytecodeOperand(int operand_index) {
   DCHECK_LT(operand_index, interpreter::Bytecodes::NumberOfOperands(bytecode_));
   DCHECK_EQ(interpreter::OperandSize::kByte,
@@ skipping 235 matching lines @@
 
   Node* code_target = HeapConstant(callable.code());
 
   Node** args = zone()->NewArray<Node*>(5);
   args[0] = arg_count;
   args[1] = new_target;
   args[2] = constructor;
   args[3] = first_arg;
   args[4] = GetContext();
 
-  return CallN(descriptor, code_target, args);
+  return CallN(descriptor, code_target, args,
+               SaveAccumulatorMode::kClobberAccumulator);
+}
+
+
+void InterpreterAssembler::CallPrologue(
+    SaveAccumulatorMode save_accumulator_mode) {
+  if (save_accumulator_mode == SaveAccumulatorMode::kSaveAccumulator) {
+    StoreRegister(
+        accumulator_,
+        InterpreterFrameConstants::kSavedAccumulatorFromRegisterPointer);
+  } else {
+    DCHECK(save_accumulator_mode == SaveAccumulatorMode::kClobberAccumulator);
+  }
+
+  StoreRegister(SmiTag(bytecode_offset_),
+                InterpreterFrameConstants::kBytecodeOffsetFromRegisterPointer);
+}
+
+
+void InterpreterAssembler::CallEpilogue(
+    SaveAccumulatorMode save_accumulator_mode) {
+  // Restore the bytecode offset from the stack frame.
+  bytecode_offset_ = SmiUntag(LoadRegister(
+      InterpreterFrameConstants::kBytecodeOffsetFromRegisterPointer));
+
+  if (save_accumulator_mode == SaveAccumulatorMode::kSaveAccumulator) {
+    // Restore accumulator from stack frame.
+    accumulator_ = LoadRegister(
+        InterpreterFrameConstants::kSavedAccumulatorFromRegisterPointer);
+  } else {
+    // Clobber the accumulator.
+    DCHECK(save_accumulator_mode == SaveAccumulatorMode::kClobberAccumulator);
+    accumulator_ = nullptr;
+  }
 }
 
 
 Node* InterpreterAssembler::CallN(CallDescriptor* descriptor, Node* code_target,
-                                  Node** args) {
+                                  Node** args,
+                                  SaveAccumulatorMode save_accumulator_mode) {
+  CallPrologue(save_accumulator_mode);
+
   Node* stack_pointer_before_call = nullptr;
   if (FLAG_debug_code) {
     stack_pointer_before_call = raw_assembler_->LoadStackPointer();
   }
   Node* return_val = raw_assembler_->CallN(descriptor, code_target, args);
   if (FLAG_debug_code) {
     Node* stack_pointer_after_call = raw_assembler_->LoadStackPointer();
     AbortIfWordNotEqual(stack_pointer_before_call, stack_pointer_after_call,
                         kUnexpectedStackPointer);
   }
+
+  CallEpilogue(save_accumulator_mode);
   return return_val;
 }
 
 
 Node* InterpreterAssembler::CallJS(Node* function, Node* first_arg,
                                    Node* arg_count) {
   Callable callable = CodeFactory::InterpreterPushArgsAndCall(isolate());
   CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 0, CallDescriptor::kNoFlags);
 
   Node* code_target = HeapConstant(callable.code());
 
   Node** args = zone()->NewArray<Node*>(4);
   args[0] = arg_count;
   args[1] = first_arg;
   args[2] = function;
   args[3] = GetContext();
 
-  return CallN(descriptor, code_target, args);
+  return CallN(descriptor, code_target, args,
+               SaveAccumulatorMode::kClobberAccumulator);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
-                                   Node* target, Node** args) {
+                                   Node* target, Node** args,
+                                   SaveAccumulatorMode save_accumulator_mode) {
   CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), descriptor, 0, CallDescriptor::kNoFlags);
-  return CallN(call_descriptor, target, args);
+  return CallN(call_descriptor, target, args, save_accumulator_mode);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
                                    Node* target, Node* arg1, Node* arg2,
-                                   Node* arg3) {
+                                   Node* arg3,
+                                   SaveAccumulatorMode save_accumulator_mode) {
   Node** args = zone()->NewArray<Node*>(4);
   args[0] = arg1;
   args[1] = arg2;
   args[2] = arg3;
   args[3] = GetContext();
-  return CallIC(descriptor, target, args);
+  return CallIC(descriptor, target, args, save_accumulator_mode);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
                                    Node* target, Node* arg1, Node* arg2,
-                                   Node* arg3, Node* arg4) {
+                                   Node* arg3, Node* arg4,
+                                   SaveAccumulatorMode save_accumulator_mode) {
   Node** args = zone()->NewArray<Node*>(5);
   args[0] = arg1;
   args[1] = arg2;
   args[2] = arg3;
   args[3] = arg4;
   args[4] = GetContext();
-  return CallIC(descriptor, target, args);
+  return CallIC(descriptor, target, args, save_accumulator_mode);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
                                    Node* target, Node* arg1, Node* arg2,
-                                   Node* arg3, Node* arg4, Node* arg5) {
+                                   Node* arg3, Node* arg4, Node* arg5,
+                                   SaveAccumulatorMode save_accumulator_mode) {
   Node** args = zone()->NewArray<Node*>(6);
   args[0] = arg1;
   args[1] = arg2;
   args[2] = arg3;
   args[3] = arg4;
   args[4] = arg5;
   args[5] = GetContext();
-  return CallIC(descriptor, target, args);
+  return CallIC(descriptor, target, args, save_accumulator_mode);
 }
 
 
-Node* InterpreterAssembler::CallRuntime(Node* function_id, Node* first_arg,
-                                        Node* arg_count) {
+Node* InterpreterAssembler::CallRuntime(
+    Node* function_id, Node* first_arg, Node* arg_count,
+    SaveAccumulatorMode save_accumulator_mode) {
   Callable callable = CodeFactory::InterpreterCEntry(isolate());
   CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 0, CallDescriptor::kNoFlags);
 
   Node* code_target = HeapConstant(callable.code());
 
   // Get the function entry from the function id.
   Node* function_table = raw_assembler_->ExternalConstant(
       ExternalReference::runtime_function_table_address(isolate()));
   Node* function_offset = raw_assembler_->Int32Mul(
       function_id, Int32Constant(sizeof(Runtime::Function)));
   Node* function = IntPtrAdd(function_table, function_offset);
   Node* function_entry = raw_assembler_->Load(
       kMachPtr, function, Int32Constant(offsetof(Runtime::Function, entry)));
 
   Node** args = zone()->NewArray<Node*>(4);
   args[0] = arg_count;
   args[1] = first_arg;
   args[2] = function_entry;
   args[3] = GetContext();
 
-  return CallN(descriptor, code_target, args);
+  return CallN(descriptor, code_target, args, save_accumulator_mode);
 }
 
 
-Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id,
-                                        Node* arg1) {
-  return raw_assembler_->CallRuntime1(function_id, arg1, GetContext());
+Node* InterpreterAssembler::CallRuntime(
+    Runtime::FunctionId function_id, Node* arg1,
+    SaveAccumulatorMode save_accumulator_mode) {
+  CallPrologue(save_accumulator_mode);
+  Node* return_val =
+      raw_assembler_->CallRuntime1(function_id, arg1, GetContext());
+  CallEpilogue(save_accumulator_mode);
+  return return_val;
 }
 
 
-Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id,
-                                        Node* arg1, Node* arg2) {
-  return raw_assembler_->CallRuntime2(function_id, arg1, arg2, GetContext());
+Node* InterpreterAssembler::CallRuntime(
+    Runtime::FunctionId function_id, Node* arg1, Node* arg2,
+    SaveAccumulatorMode save_accumulator_mode) {
+  CallPrologue(save_accumulator_mode);
+  Node* return_val =
+      raw_assembler_->CallRuntime2(function_id, arg1, arg2, GetContext());
+  CallEpilogue(save_accumulator_mode);
+  return return_val;
 }
 
 
-Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id,
-                                        Node* arg1, Node* arg2, Node* arg3,
-                                        Node* arg4) {
-  return raw_assembler_->CallRuntime4(function_id, arg1, arg2, arg3, arg4,
-                                      GetContext());
+Node* InterpreterAssembler::CallRuntime(
+    Runtime::FunctionId function_id, Node* arg1, Node* arg2, Node* arg3,
+    Node* arg4, SaveAccumulatorMode save_accumulator_mode) {
+  CallPrologue(save_accumulator_mode);
+  Node* return_val = raw_assembler_->CallRuntime4(function_id, arg1, arg2, arg3,
+                                                  arg4, GetContext());
+  CallEpilogue(save_accumulator_mode);
+  return return_val;
 }
 
 
 void InterpreterAssembler::Return() {
   Node* exit_trampoline_code_object =
       HeapConstant(isolate()->builtins()->InterpreterExitTrampoline());
   // If the order of the parameters you need to change the call signature below.
   STATIC_ASSERT(0 == Linkage::kInterpreterAccumulatorParameter);
   STATIC_ASSERT(1 == Linkage::kInterpreterRegisterFileParameter);
   STATIC_ASSERT(2 == Linkage::kInterpreterBytecodeOffsetParameter);
@@ skipping 63 matching lines @@
                    new_bytecode_offset,
                    BytecodeArrayTaggedPointer(),
                    DispatchTableRawPointer(),
                    GetContext() };
   raw_assembler_->TailCallN(call_descriptor(), target_code_object, args);
 }
 
 
 void InterpreterAssembler::Abort(BailoutReason bailout_reason) {
   Node* abort_id = SmiTag(Int32Constant(bailout_reason));
-  CallRuntime(Runtime::kAbort, abort_id);
-  Return();
+  Node* ret_value = CallRuntime(Runtime::kAbort, abort_id);
+  // Unreached, but keeps turbofan happy.
+  raw_assembler_->Return(ret_value);
 }
 
 
 void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
                                                BailoutReason bailout_reason) {
   RawMachineLabel match, no_match;
   Node* condition = raw_assembler_->WordEqual(lhs, rhs);
   raw_assembler_->Branch(condition, &match, &no_match);
   raw_assembler_->Bind(&no_match);
   Abort(bailout_reason);
@@ skipping 26 matching lines @@
   return raw_assembler_->call_descriptor();
 }
 
 
 Zone* InterpreterAssembler::zone() { return raw_assembler_->zone(); }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8