[Interpreter] Avoid allocating pairs array in VisitDeclarations.

src/interpreter/constant-array-builder.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/constant-array-builder.h"
 
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
@@ skipping 28 matching lines @@
   return index + start_index();
 }
 
 Handle<Object> ConstantArrayBuilder::ConstantArraySlice::At(
     size_t index) const {
   DCHECK_GE(index, start_index());
   DCHECK_LT(index, start_index() + size());
   return constants_[index - start_index()];
 }
 
+void ConstantArrayBuilder::ConstantArraySlice::Update(size_t index,

[oth, 2016/07/22 10:22:10]

Is this a once only operation?

If so could the code also DCHECK the cell is empty and call the method
InsertAt()/Bind()/Set() or somesuch.

[rmcilroy, 2016/07/25 10:55:29]

InsertAt sounds good. I can't have the DCHECK here since ConstantPoolSlice has
no isolate field, but there was already a similar DCHECK at InsertReservedEntry.

+                                                      Handle<Object> object) {
+  DCHECK_GE(index, start_index());
+  DCHECK_LT(index, start_index() + size());
+  constants_[index - start_index()] = object;
+}
+
 STATIC_CONST_MEMBER_DEFINITION const size_t ConstantArrayBuilder::k8BitCapacity;
 STATIC_CONST_MEMBER_DEFINITION const size_t
     ConstantArrayBuilder::k16BitCapacity;
 STATIC_CONST_MEMBER_DEFINITION const size_t
     ConstantArrayBuilder::k32BitCapacity;
 
 ConstantArrayBuilder::ConstantArrayBuilder(Isolate* isolate, Zone* zone)
     : isolate_(isolate), constants_map_(isolate->heap(), zone) {
   idx_slice_[0] =
       new (zone) ConstantArraySlice(zone, 0, k8BitCapacity, OperandSize::kByte);
   idx_slice_[1] = new (zone) ConstantArraySlice(
       zone, k8BitCapacity, k16BitCapacity, OperandSize::kShort);
   idx_slice_[2] = new (zone) ConstantArraySlice(
       zone, k8BitCapacity + k16BitCapacity, k32BitCapacity, OperandSize::kQuad);
 }
 
 size_t ConstantArrayBuilder::size() const {
   size_t i = arraysize(idx_slice_);
   while (i > 0) {
     ConstantArraySlice* slice = idx_slice_[--i];
     if (slice->size() > 0) {
       return slice->start_index() + slice->size();
     }
   }
   return idx_slice_[0]->size();
 }
 
-const ConstantArrayBuilder::ConstantArraySlice*
-ConstantArrayBuilder::IndexToSlice(size_t index) const {
-  for (const ConstantArraySlice* slice : idx_slice_) {
+ConstantArrayBuilder::ConstantArraySlice* ConstantArrayBuilder::IndexToSlice(
+    size_t index) const {
+  for (ConstantArraySlice* slice : idx_slice_) {
     if (index <= slice->max_index()) {
       return slice;
     }
   }
   UNREACHABLE();
   return nullptr;
 }
 
 Handle<Object> ConstantArrayBuilder::At(size_t index) const {
   const ConstantArraySlice* slice = IndexToSlice(index);
@@ skipping 33 matching lines @@
 }
 
 size_t ConstantArrayBuilder::Insert(Handle<Object> object) {
   index_t* entry = constants_map()->Find(object);
   return (entry == nullptr) ? AllocateEntry(object) : *entry;
 }
 
 ConstantArrayBuilder::index_t ConstantArrayBuilder::AllocateEntry(
     Handle<Object> object) {
   DCHECK(!object->IsOddball());
+  index_t index = AllocateIndex(object);
   index_t* entry = constants_map()->Get(object);
+  *entry = index;
+  return index;
+}
+
+ConstantArrayBuilder::index_t ConstantArrayBuilder::AllocateIndex(
+    Handle<Object> object) {
   for (size_t i = 0; i < arraysize(idx_slice_); ++i) {
     if (idx_slice_[i]->available() > 0) {
-      size_t index = idx_slice_[i]->Allocate(object);
-      *entry = static_cast<index_t>(index);
-      return *entry;
-      break;
+      return static_cast<index_t>(idx_slice_[i]->Allocate(object));
     }
   }
   UNREACHABLE();
   return kMaxUInt32;
 }
 
-OperandSize ConstantArrayBuilder::CreateReservedEntry() {
-  for (size_t i = 0; i < arraysize(idx_slice_); ++i) {
-    if (idx_slice_[i]->available() > 0) {
-      idx_slice_[i]->Reserve();
-      return idx_slice_[i]->operand_size();
-    }
-  }
-  UNREACHABLE();
-  return OperandSize::kNone;
-}
-
 ConstantArrayBuilder::ConstantArraySlice*
 ConstantArrayBuilder::OperandSizeToSlice(OperandSize operand_size) const {
   ConstantArraySlice* slice = nullptr;
   switch (operand_size) {
     case OperandSize::kNone:
       UNREACHABLE();
       break;
     case OperandSize::kByte:
       slice = idx_slice_[0];
       break;
     case OperandSize::kShort:
       slice = idx_slice_[1];
       break;
     case OperandSize::kQuad:
       slice = idx_slice_[2];
       break;
   }
   DCHECK(slice->operand_size() == operand_size);
   return slice;
 }
 
+size_t ConstantArrayBuilder::ReserveEntry() {
+  return AllocateIndex(isolate_->factory()->the_hole_value());
+}
+
+void ConstantArrayBuilder::InsertReservedEntry(size_t index,
+                                               Handle<Object> object) {
+  DCHECK_EQ(isolate_->heap()->the_hole_value(), *At(index));
+  ConstantArraySlice* slice = IndexToSlice(index);
+  slice->Update(index, object);
+}
+
+OperandSize ConstantArrayBuilder::CreateDiscardableReservedEntry() {
+  for (size_t i = 0; i < arraysize(idx_slice_); ++i) {
+    if (idx_slice_[i]->available() > 0) {
+      idx_slice_[i]->Reserve();
+      return idx_slice_[i]->operand_size();
+    }
+  }
+  UNREACHABLE();
+  return OperandSize::kNone;
+}
+
 size_t ConstantArrayBuilder::CommitReservedEntry(OperandSize operand_size,
                                                  Handle<Object> object) {
   DiscardReservedEntry(operand_size);
   size_t index;
   index_t* entry = constants_map()->Find(object);
   if (nullptr == entry) {
     index = AllocateEntry(object);
   } else {
     ConstantArraySlice* slice = OperandSizeToSlice(operand_size);
     if (*entry > slice->max_index()) {
       // The object is already in the constant array, but may have an
       // index too big for the reserved operand_size. So, duplicate
       // entry with the smaller operand size.
       *entry = static_cast<index_t>(slice->Allocate(object));
     }
     index = *entry;
   }
   return index;
 }
 
 void ConstantArrayBuilder::DiscardReservedEntry(OperandSize operand_size) {
   OperandSizeToSlice(operand_size)->Unreserve();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8