Save/restore only live registers in the generator suspend/resume.

src/interpreter/interpreter-generator.cc

 // Copyright 2017 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-generator.h"
 
 #include <array>
 #include <tuple>
 
 #include "src/builtins/builtins-arguments-gen.h"
@@ skipping 3594 matching lines @@
 // Illegal
 //
 // An invalid bytecode aborting execution if dispatched.
 IGNITION_HANDLER(Illegal, InterpreterAssembler) { Abort(kInvalidBytecode); }
 
 // Nop
 //
 // No operation.
 IGNITION_HANDLER(Nop, InterpreterAssembler) { Dispatch(); }
 
-// SuspendGenerator <generator>
+// SuspendGenerator <generator> <first input register> <register count> <flags>
 //
 // Exports the register file and stores it into the generator.  Also stores the
 // current context, the state given in the accumulator, and the current bytecode
 // offset (for debugging purposes) into the generator.
 IGNITION_HANDLER(SuspendGenerator, InterpreterAssembler) {
   Node* generator_reg = BytecodeOperandReg(0);
-  Node* flags = BytecodeOperandFlag(1);
+  Node* flags = BytecodeOperandFlag(3);
+
   Node* generator = LoadRegister(generator_reg);
 
   Label if_stepping(this, Label::kDeferred), ok(this);
   Node* step_action_address = ExternalConstant(
       ExternalReference::debug_last_step_action_address(isolate()));
   Node* step_action = Load(MachineType::Int8(), step_action_address);
   STATIC_ASSERT(StepIn > StepNext);
   STATIC_ASSERT(LastStepAction == StepIn);
   Node* step_next = Int32Constant(StepNext);
   Branch(Int32LessThanOrEqual(step_next, step_action), &if_stepping, &ok);
   BIND(&ok);
 
   Node* array =
       LoadObjectField(generator, JSGeneratorObject::kRegisterFileOffset);
   Node* context = GetContext();
   Node* state = GetAccumulator();
 
-  ExportRegisterFile(array);
+  // Bytecode operand 1 should be always 0 (we are always store registers
+  // from the beginning).
+  CSA_ASSERT(this, WordEqual(BytecodeOperandReg(1),
+                             IntPtrConstant(Register(0).ToOperand())));
+  // Bytecode operand 2 is the number of registers to store to the generator.
+  Node* register_count = ChangeUint32ToWord(BytecodeOperandCount(2));
+  ExportRegisterFile(array, register_count);
   StoreObjectField(generator, JSGeneratorObject::kContextOffset, context);
   StoreObjectField(generator, JSGeneratorObject::kContinuationOffset, state);
 
   Label if_asyncgeneratorawait(this), if_notasyncgeneratorawait(this),
       merge(this);
 
   // Calculate bytecode offset to store in the [input_or_debug_pos] or
   // [await_input_or_debug_pos] fields, to be used by the inspector.
   Node* offset = SmiTag(BytecodeOffset());
 
@@ skipping 28 matching lines @@
   Dispatch();
 
   BIND(&if_stepping);
   {
     Node* context = GetContext();
     CallRuntime(Runtime::kDebugRecordGenerator, context, generator);
     Goto(&ok);
   }
 }
 
-// ResumeGenerator <generator>
+// RestoreGeneratorState <generator>
 //
-// Imports the register file stored in the generator. Also loads the
-// generator's state and stores it in the accumulator, before overwriting it
-// with kGeneratorExecuting.
-IGNITION_HANDLER(ResumeGenerator, InterpreterAssembler) {
+// Loads the generator's state and stores it in the accumulator,
+// before overwriting it with kGeneratorExecuting.
+IGNITION_HANDLER(RestoreGeneratorState, InterpreterAssembler) {
   Node* generator_reg = BytecodeOperandReg(0);
   Node* generator = LoadRegister(generator_reg);
 
-  ImportRegisterFile(
-      LoadObjectField(generator, JSGeneratorObject::kRegisterFileOffset));
-
   Node* old_state =
       LoadObjectField(generator, JSGeneratorObject::kContinuationOffset);
   Node* new_state = Int32Constant(JSGeneratorObject::kGeneratorExecuting);
   StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
                    SmiTag(new_state));
   SetAccumulator(old_state);
 
   Dispatch();
 }
 
+// RestoreGeneratorRegisters <generator> <first output register> <register
+// count>
+//
+// Imports the register file stored in the generator.
+IGNITION_HANDLER(RestoreGeneratorRegisters, InterpreterAssembler) {
+  Node* generator_reg = BytecodeOperandReg(0);
+  // Bytecode operand 1 is the start register. It should always be 0, so let's
+  // ignore it.
+  CSA_ASSERT(this, WordEqual(BytecodeOperandReg(1),
+                             IntPtrConstant(Register(0).ToOperand())));
+  // Bytecode operand 2 is the number of registers to store to the generator.
+  Node* register_count = ChangeUint32ToWord(BytecodeOperandCount(2));
+
+  Node* generator = LoadRegister(generator_reg);
+
+  ImportRegisterFile(
+      LoadObjectField(generator, JSGeneratorObject::kRegisterFileOffset),
+      register_count);
+
+  Dispatch();
+}
+
 }  // namespace
 
 Handle<Code> GenerateBytecodeHandler(Isolate* isolate, Bytecode bytecode,
                                      OperandScale operand_scale) {
   Zone zone(isolate->allocator(), ZONE_NAME);
   InterpreterDispatchDescriptor descriptor(isolate);
   compiler::CodeAssemblerState state(
       isolate, &zone, descriptor, Code::ComputeFlags(Code::BYTECODE_HANDLER),
       Bytecodes::ToString(bytecode), Bytecodes::ReturnCount(bytecode));
 
@@ skipping 17 matching lines @@
     code->Disassemble(Bytecodes::ToString(bytecode), os);
     os << std::flush;
   }
 #endif  // ENABLE_DISASSEMBLER
   return code;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8