[generators] Create the fixed array holding the registers only once.

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 697 matching lines @@
 #endif
 }
 
 Node* InterpreterAssembler::RegisterCount() {
   Node* bytecode_array = LoadRegister(Register::bytecode_array());
   Node* frame_size = LoadObjectField(
       bytecode_array, BytecodeArray::kFrameSizeOffset, MachineType::Int32());
   return Word32Sar(frame_size, Int32Constant(kPointerSizeLog2));
 }
 
-Node* InterpreterAssembler::ExportRegisterFile() {
-  Node* register_count = RegisterCount();
-  Node* array =
-      AllocateUninitializedFixedArray(ChangeInt32ToIntPtr(register_count));
-
+Node* InterpreterAssembler::ExportRegisterFile(Node* array) {
   Variable var_index(this, MachineRepresentation::kWord32);
   var_index.Bind(Int32Constant(0));
 

[rmcilroy, 2016/04/28 11:40:57]

Maybe we could add if (FLAG_debug_code) which checks that the array is of the
correct size?

[neis, 2016/04/28 11:47:21]

Acknowledged. But why this flag rather than a DCHECK? (I'm not familiar with the
flag.)

[neis, 2016/04/28 12:05:25]

Nevermind, I got it.

   // 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);
+    Node* condition = Int32LessThan(index, RegisterCount());
     GotoUnless(condition, &done_loop);
 
     Node* reg_index =
         Int32Sub(Int32Constant(Register(0).ToOperand()), index);
     Node* value = LoadRegister(ChangeInt32ToIntPtr(reg_index));
 
     // No write barrier needed for writing into freshly allocated object.

[rmcilroy, 2016/04/28 11:40:57]

This is no longer the case, I guess we need a write barrier now?

[neis, 2016/04/28 11:47:21]

Good catch :)

     StoreFixedArrayElementNoWriteBarrier(
         array, ChangeInt32ToIntPtr(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));
 

[rmcilroy, 2016/04/28 11:40:57]

ditto

[neis, 2016/04/28 11:47:21]

Acknowledged.

-  // Iterate over array and write values into register file.
+  // Iterate over array and write values into register file.  Also erase the
+  // array contents to not keep them alive artificially.
   Label loop(this, &var_index), done_loop(this);
   Goto(&loop);
   Bind(&loop);
   {
     Node* index = var_index.value();
-    Node* condition = Int32LessThan(index, register_count);
+    Node* condition = Int32LessThan(index, RegisterCount());
     GotoUnless(condition, &done_loop);
 
     Node* value = LoadFixedArrayElementInt32Index(array, index);
 
     Node* reg_index =
         Int32Sub(Int32Constant(Register(0).ToOperand()), index);
     StoreRegister(value, ChangeInt32ToIntPtr(reg_index));
 
+    StoreFixedArrayElementInt32Index(array, index, StaleRegisterConstant());
+
     var_index.Bind(Int32Add(index, Int32Constant(1)));
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8