Introduce bytecodes for assisting generator suspend and resume.

src/interpreter/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/interpreter/interpreter-assembler.h"
 
 #include <limits>
 #include <ostream>
 
 #include "src/code-factory.h"
@@ skipping 358 matching lines @@
       IntPtrAdd(IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
                 WordShl(index, kPointerSizeLog2));
   return Load(MachineType::AnyTagged(), constant_pool, entry_offset);
 }
 
 Node* InterpreterAssembler::LoadObjectField(Node* object, int offset) {
   return Load(MachineType::AnyTagged(), object,
               IntPtrConstant(offset - kHeapObjectTag));
 }
 
+Node* InterpreterAssembler::LoadObjectFieldInt32(Node* object, int offset) {
+  return Load(MachineType::Int32(), object,
+              IntPtrConstant(offset - kHeapObjectTag));
+}
+
+Node* InterpreterAssembler::StoreObjectField(Node* object, int offset,
+                                             Node* value) {
+  return Store(MachineRepresentation::kTagged, object,
+               IntPtrConstant(offset - kHeapObjectTag), value);
+}
+
 Node* InterpreterAssembler::LoadContextSlot(Node* context, int slot_index) {
   return Load(MachineType::AnyTagged(), context,
               IntPtrConstant(Context::SlotOffset(slot_index)));
 }
 
 Node* InterpreterAssembler::LoadContextSlot(Node* context, Node* slot_index) {
   Node* offset =
       IntPtrAdd(WordShl(slot_index, kPointerSizeLog2),
                 IntPtrConstant(Context::kHeaderSize - kHeapObjectTag));
   return Load(MachineType::AnyTagged(), context, offset);
@@ skipping 317 matching lines @@
 #elif V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_PPC
   return CpuFeatures::IsSupported(UNALIGNED_ACCESSES);
 #elif V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_X87 || \
     V8_TARGET_ARCH_S390
   return true;
 #else
 #error "Unknown Architecture"
 #endif
 }
 
+Node* InterpreterAssembler::RegisterCount() {
+  Node* bytecode_array = LoadRegister(Register::bytecode_array());
+  Node* frame_size =
+      LoadObjectFieldInt32(bytecode_array, BytecodeArray::kFrameSizeOffset);
+  return Word32Sar(frame_size, Int32Constant(kPointerSizeLog2));
+}
+
+Node* InterpreterAssembler::ExportRegisterFile() {
+  Node* register_count = RegisterCount();
+  Node* array =
+      AllocateUninitializedFixedArray(ChangeInt32ToWord(register_count));
+
+  Variable var_index(this, MachineRepresentation::kWord32);
+  var_index.Bind(Int32Constant(0));
+
+  // Iterate over register file and write values into array.
+  Label loop(this, &var_index), done_loop(this);
+  Goto(&loop);
+  Bind(&loop);
+  {
+    Node* index = var_index.value();
+    Node* condition = Int32LessThan(index, register_count);
+    GotoUnless(condition, &done_loop);
+
+    Node* reg_index =
+        Int32Sub(Int32Constant(Register::kRegisterFileStartOffset), index);

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

I'd prefer to keep kRegisterFileStartOffset private if possible. Could you
replace var_index with  InterpreterAssembler::RegisterLocation(Register(0))
outside the loop and then just do a raw Load on this location (incremented by
kPointerSize each iteration) instead?

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

I don't want to change var_index because it's also used to access the fixed
array. Instead, I now replaced kRegisterFileStartOffset with
Register(0).ToOperand. Is that fine?

[rmcilroy, 2016/04/21 13:55:02]

Works for me, thanks!

+    Node* value = LoadRegister(ChangeInt32ToWord(reg_index));
+
+    StoreFixedArrayElementNoWriteBarrier(

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

I'm not sure NoWriteBarrier is correct here. The runtime implementation used a
write barrier, and since these values are tagged objects I think we need a write
barrier here too. Am I missing something?

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

I was told that it's not needed since we are writing into a newly allocated
object.

[rmcilroy, 2016/04/21 13:55:02]

That sounds plausible :). Please add a comment to that effect.

+        array, ChangeInt32ToWord(index), value);
+
+    var_index.Bind(Int32Add(index, Int32Constant(1)));
+    Goto(&loop);
+  }
+  Bind(&done_loop);
+
+  return array;
+}
+
+Node* InterpreterAssembler::ImportRegisterFile(Node* array) {
+  Node* register_count = RegisterCount();
+
+  Variable var_index(this, MachineRepresentation::kWord32);
+  var_index.Bind(Int32Constant(0));
+
+  // Iterate over array and write values into register file.
+  Label loop(this, &var_index), done_loop(this);
+  Goto(&loop);
+  Bind(&loop);
+  {
+    Node* index = var_index.value();
+    Node* condition = Int32LessThan(index, register_count);
+    GotoUnless(condition, &done_loop);
+
+    Node* value = LoadFixedArrayElementInt32Index(array, index);
+
+    Node* reg_index =
+        Int32Sub(Int32Constant(Register::kRegisterFileStartOffset), index);
+    StoreRegister(value, ChangeInt32ToWord(reg_index));
+
+    var_index.Bind(Int32Add(index, Int32Constant(1)));
+    Goto(&loop);
+  }
+  Bind(&done_loop);
+
+  return array;
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8