[Interpreter] Avoid allocating handles in bytecode-array-writer

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 <set>
 
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 53 matching lines @@
   return true;
 }
 
 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_(zone) {
+    : isolate_(isolate),
+      constants_map_(zone),
+      smi_map_(zone),
+      smi_pairs_(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_);
@@ skipping 21 matching lines @@
   const ConstantArraySlice* slice = IndexToSlice(index);
   if (index < slice->start_index() + slice->size()) {
     return slice->At(index);
   } else {
     DCHECK_LT(index, slice->capacity());
     return isolate_->factory()->the_hole_value();
   }
 }
 
 Handle<FixedArray> ConstantArrayBuilder::ToFixedArray() {
+  // First insert reserved SMI values.
+  for (auto reserved_smi : smi_pairs_) {
+    InsertAllocatedEntry(reserved_smi.second,
+                         handle(reserved_smi.first, isolate_));
+  }
+
   Handle<FixedArray> fixed_array = isolate_->factory()->NewFixedArray(
       static_cast<int>(size()), PretenureFlag::TENURED);
   int array_index = 0;
   for (const ConstantArraySlice* slice : idx_slice_) {
     if (array_index == fixed_array->length()) {
       break;
     }
     DCHECK(array_index == 0 ||
            base::bits::IsPowerOfTwo32(static_cast<uint32_t>(array_index)));
     // Different slices might contain the same element due to reservations, but
@@ skipping 76 matching lines @@
   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::index_t ConstantArrayBuilder::AllocateReservedEntry(
+    Smi* value) {
+  index_t index = static_cast<index_t>(AllocateEntry());
+  smi_map_[value] = index;
+  smi_pairs_.push_back(std::make_pair(value, index));
+  return index;
+}
+
 size_t ConstantArrayBuilder::CommitReservedEntry(OperandSize operand_size,
-                                                 Handle<Object> object) {
+                                                 Smi* value) {
   DiscardReservedEntry(operand_size);
   size_t index;
-  auto entry = constants_map_.find(object.address());
-  if (entry == constants_map_.end()) {
-    index = AllocateEntry(object);
+  auto entry = smi_map_.find(value);
+  if (entry == smi_map_.end()) {
+    index = AllocateReservedEntry(value);
   } else {
     ConstantArraySlice* slice = OperandSizeToSlice(operand_size);
     index = entry->second;
     if (index > 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.
-      index = slice->Allocate(object);
-      constants_map_[object.address()] = static_cast<index_t>(index);
+      index = AllocateReservedEntry(value);
     }
+    DCHECK_LE(index, slice->max_index());
   }
   return index;
 }
 
 void ConstantArrayBuilder::DiscardReservedEntry(OperandSize operand_size) {
   OperandSizeToSlice(operand_size)->Unreserve();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8