[ignition] Prefill the constant array with holes to avoid needing to write padding holes

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 <functional>
 #include <set>
 
 #include "src/isolate.h"
@@ skipping 108 matching lines @@
   }
 }
 
 Handle<FixedArray> ConstantArrayBuilder::ToFixedArray(Isolate* isolate) {
   // 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(
+  Handle<FixedArray> fixed_array = isolate->factory()->NewFixedArrayWithHoles(
       static_cast<int>(size()), PretenureFlag::TENURED);
   int array_index = 0;
   for (const ConstantArraySlice* slice : idx_slice_) {
-    if (array_index == fixed_array->length()) {
-      break;
-    }
+    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
     // all elements within a slice should be unique. If this DCHECK fails, then
     // the AST nodes are not being internalized within a CanonicalHandleScope.
     DCHECK(slice->AllElementsAreUnique());
     // Copy objects from slice into array.
     for (size_t i = 0; i < slice->size(); ++i) {
       fixed_array->set(array_index++, *slice->At(slice->start_index() + i));
     }
-    // Insert holes where reservations led to unused slots.
-    size_t padding =
-        std::min(static_cast<size_t>(fixed_array->length() - array_index),
-                 slice->capacity() - slice->size());
-    for (size_t i = 0; i < padding; i++) {
-      fixed_array->set(array_index++, *the_hole_value());
-    }
+    // Leave holes where reservations led to unused slots.
+    array_index += slice->capacity() - slice->size();
   }
-  DCHECK_EQ(array_index, fixed_array->length());

[Leszek Swirski, 2016/12/16 16:50:54]

I would keep this check, as a DCHECK_GE

   return fixed_array;
 }
 
 size_t ConstantArrayBuilder::Insert(Handle<Object> object) {
   return constants_map_
       .LookupOrInsert(object.address(), ObjectHash(object.address()),
                       [&]() { return AllocateIndex(object); },
                       ZoneAllocationPolicy(zone_))
       ->value;
 }
@@ skipping 81 matching lines @@
   return index;
 }
 
 void ConstantArrayBuilder::DiscardReservedEntry(OperandSize operand_size) {
   OperandSizeToSlice(operand_size)->Unreserve();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8