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

src/interpreter/interpreter-generator.cc

Index: src/interpreter/interpreter-generator.cc
diff --git a/src/interpreter/interpreter-generator.cc b/src/interpreter/interpreter-generator.cc
index 85a15b2389b9cff57452cd0957b7e6be093fdd1a..90f384982362366fc3b94216150ce6f84d7275f3 100644
--- a/src/interpreter/interpreter-generator.cc
+++ b/src/interpreter/interpreter-generator.cc
@@ -3612,14 +3612,15 @@ IGNITION_HANDLER(Illegal, InterpreterAssembler) { Abort(kInvalidBytecode); }
 // 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);
@@ -3637,7 +3638,13 @@ IGNITION_HANDLER(SuspendGenerator, InterpreterAssembler) {
   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);
 
@@ -3688,16 +3695,12 @@ IGNITION_HANDLER(SuspendGenerator, InterpreterAssembler) {
 
 // ResumeGenerator <generator>
 //

[neis, 2017/06/01 13:34:37]

Maybe we can rename this to RestoreGeneratorState.

[rmcilroy, 2017/06/01 14:04:20]

SGTM

[Jarin, 2017/06/02 09:35:49]

Done.

We could also get completely rid of the bytecode and just expand this to the
load of the state into generator_state_ and then store of the kExecuting state
into the generator (in BuildGeneratorPrologue). WDYT? (But not in this CL.)

[rmcilroy, 2017/06/02 09:42:06]

I'm not quite sure what you mean here - do you mean emit bytecode to do the heap
object field loads directly? We don't currently have any bytecodes for getting a
field off of a heap object (although given that  3 generator intrinsics do
exactly that, I think we should think about adding one). 

-// 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.
+// Loads the generator's state and stores it in the accumulator,
+// before overwriting it with kGeneratorExecuting.
 IGNITION_HANDLER(ResumeGenerator, 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);
@@ -3708,6 +3711,29 @@ IGNITION_HANDLER(ResumeGenerator, InterpreterAssembler) {
   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);
+  SetAccumulator(generator);
+

[neis, 2017/06/01 13:34:37]

You're still writing the generator into the accumulator here.

[rmcilroy, 2017/06/01 14:05:00]

Also update AcumulatorUse to kNone in bytecodes.h

[Jarin, 2017/06/02 09:35:49]

Done.

[Jarin, 2017/06/02 09:35:49]

Done.

+  Dispatch();
+}
+
 }  // namespace
 
 Handle<Code> GenerateBytecodeHandler(Isolate* isolate, Bytecode bytecode,