Introduce bytecodes for assisting generator suspend and resume.

src/interpreter/interpreter-assembler.h

 // 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.
 
 #ifndef V8_INTERPRETER_INTERPRETER_ASSEMBLER_H_
 #define V8_INTERPRETER_INTERPRETER_ASSEMBLER_H_
 
 #include "src/allocation.h"
 #include "src/base/smart-pointers.h"
 #include "src/builtins.h"
@@ skipping 32 matching lines @@
   compiler::Node* BytecodeOperandRuntimeId(int operand_index);
 
   // Accumulator.
   compiler::Node* GetAccumulator();
   void SetAccumulator(compiler::Node* value);
 
   // Context.
   compiler::Node* GetContext();
   void SetContext(compiler::Node* value);
 
+  // Number of registers.
+  compiler::Node* RegisterCount();
+
+  // Backup/restore register file to/from a fixed array.
+  compiler::Node* ExportRegisterFile();
+  compiler::Node* ImportRegisterFile(compiler::Node* array);
+
   // Loads from and stores to the interpreter register file.
   compiler::Node* LoadRegister(Register reg);
   compiler::Node* LoadRegister(compiler::Node* reg_index);
   compiler::Node* StoreRegister(compiler::Node* value, Register reg);
   compiler::Node* StoreRegister(compiler::Node* value,
                                 compiler::Node* reg_index);
 
   // Returns the next consecutive register.
   compiler::Node* NextRegister(compiler::Node* reg_index);
 
   // Returns the location in memory of the register |reg_index| in the
   // interpreter register file.
   compiler::Node* RegisterLocation(compiler::Node* reg_index);
 
   // Load constant at |index| in the constant pool.
   compiler::Node* LoadConstantPoolEntry(compiler::Node* index);
 
   // Load a field from an object on the heap.
   compiler::Node* LoadObjectField(compiler::Node* object, int offset);
+  compiler::Node* LoadObjectFieldInt32(compiler::Node* object, int offset);
+
+  // Store into a field of an object on the heap.
+  compiler::Node* StoreObjectField(compiler::Node* object, int offset,
+                                   compiler::Node* value);

[rmcilroy, 2016/04/21 10:21:32]

Should these live in CodeStubAssembler instead (they seem like the might be
useful to code stubs too). You could also just remove the LoadObjectField from
here too now that it is provided by CodeStubAssembler.

[neis, 2016/04/21 11:30:15]

Agreed, removed them from here.

 
   // Load |slot_index| from |context|.
   compiler::Node* LoadContextSlot(compiler::Node* context, int slot_index);
   compiler::Node* LoadContextSlot(compiler::Node* context,
                                   compiler::Node* slot_index);
   // Stores |value| into |slot_index| of |context|.
   compiler::Node* StoreContextSlot(compiler::Node* context,
                                    compiler::Node* slot_index,
                                    compiler::Node* value);
 
@@ skipping 153 matching lines @@
   compiler::Node* stack_pointer_before_call_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpreterAssembler);
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_INTERPRETER_ASSEMBLER_H_