[Interpreter] Avoid accessing Isolate from during bytecode generation.

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 52 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),
+ConstantArrayBuilder::ConstantArrayBuilder(Zone* zone,
+                                           Handle<Object> the_hole_value)
+    : constants_map_(zone),
       smi_map_(zone),
-      smi_pairs_(zone) {
+      smi_pairs_(zone),
+      the_hole_value_(the_hole_value) {
   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 16 matching lines @@
   UNREACHABLE();
   return nullptr;
 }
 
 Handle<Object> ConstantArrayBuilder::At(size_t index) const {
   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();
+    return the_hole_value();
   }
 }
 
-Handle<FixedArray> ConstantArrayBuilder::ToFixedArray() {
+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(reserved_smi.first, isolate));
   }
 
-  Handle<FixedArray> fixed_array = isolate_->factory()->NewFixedArray(
+  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
     // 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++, *isolate_->factory()->the_hole_value());
+      fixed_array->set(array_index++, *the_hole_value());
     }
   }
   DCHECK_EQ(array_index, fixed_array->length());
   return fixed_array;
 }
 
 size_t ConstantArrayBuilder::Insert(Handle<Object> object) {
   auto entry = constants_map_.find(object.address());
   return (entry == constants_map_.end()) ? AllocateEntry(object)
                                          : entry->second;
@@ skipping 32 matching lines @@
       break;
     case OperandSize::kQuad:
       slice = idx_slice_[2];
       break;
   }
   DCHECK(slice->operand_size() == operand_size);
   return slice;
 }
 
 size_t ConstantArrayBuilder::AllocateEntry() {
-  return AllocateIndex(isolate_->factory()->the_hole_value());
+  return AllocateIndex(the_hole_value());
 }
 
 void ConstantArrayBuilder::InsertAllocatedEntry(size_t index,
                                                 Handle<Object> object) {
-  DCHECK_EQ(isolate_->heap()->the_hole_value(), *At(index));
+  DCHECK_EQ(the_hole_value().address(), At(index).address());
   ConstantArraySlice* slice = IndexToSlice(index);
   slice->InsertAt(index, object);
 }
 
 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();
     }
@@ skipping 31 matching lines @@
   return index;
 }
 
 void ConstantArrayBuilder::DiscardReservedEntry(OperandSize operand_size) {
   OperandSizeToSlice(operand_size)->Unreserve();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8