[heap] Make CodeObjectRegistry a separate class.

Bug: v8:9093
Change-Id: I02360627776715ae2561f8535dbf97ed0cd3c51a
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1613978
Commit-Queue: Hannes Payer <hpayer@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61587}

src/heap/heap-inl.h

@@ -225,8 +225,9 @@ AllocationResult Heap::AllocateRaw(int size_in_bytes, AllocationType type,
       UnprotectAndRegisterMemoryChunk(object);
       ZapCodeObject(object->address(), size_in_bytes);
       if (!large_object) {
-        MemoryChunk::FromHeapObject(object)->RegisterNewlyAllocatedCodeObject(
-            object);
+        MemoryChunk::FromHeapObject(object)
+            ->GetCodeObjectRegistry()
+            ->RegisterNewlyAllocatedCodeObject(object->address());
       }
     }
     OnAllocationEvent(object, size_in_bytes);

src/heap/heap.cc

@@ -5788,8 +5788,10 @@ Code Heap::GcSafeFindCodeForInnerPointer(Address inner_pointer) {
   // after the inner pointer.
   Page* page = Page::FromAddress(inner_pointer);
 
-  HeapObject object = page->GetCodeObjectFromInnerAddress(inner_pointer);
-  return GcSafeCastToCode(object, inner_pointer);
+  Address start =
+      page->GetCodeObjectRegistry()->GetCodeObjectStartFromInnerAddress(
+          inner_pointer);
+  return GcSafeCastToCode(HeapObject::FromAddress(start), inner_pointer);
 }
 
 void Heap::WriteBarrierForCodeSlow(Code code) {

src/heap/mark-compact.cc

@@ -1279,7 +1279,8 @@ class EvacuateVisitorBase : public HeapObjectVisitor {
       MigrateObject(*target_object, object, size, target_space);
       if (target_space == CODE_SPACE)
         MemoryChunk::FromHeapObject(*target_object)
-            ->RegisterNewlyAllocatedCodeObject(*target_object);
+            ->GetCodeObjectRegistry()
+            ->RegisterNewlyAllocatedCodeObject((*target_object).address());
       return true;
     }
     return false;

src/heap/spaces.cc

@@ -614,63 +614,64 @@ void MemoryChunk::SetReadAndWritable() {
   }
 }
 
-void MemoryChunk::RegisterNewlyAllocatedCodeObject(HeapObject code) {
-  DCHECK(Contains(code->address()));
-  DCHECK(MemoryChunk::FromHeapObject(code)->owner()->identity() == CODE_SPACE);
-  auto result = code_object_registry_newly_allocated_->insert(code->address());
+void CodeObjectRegistry::RegisterNewlyAllocatedCodeObject(Address code) {
+  auto result = code_object_registry_newly_allocated_.insert(code);
   USE(result);
   DCHECK(result.second);
 }
 
-void MemoryChunk::RegisterAlreadyExistingCodeObject(HeapObject code) {
-  DCHECK(MemoryChunk::FromHeapObject(code)->owner()->identity() == CODE_SPACE);
-  code_object_registry_already_existing_->push_back(code->address());
+void CodeObjectRegistry::RegisterAlreadyExistingCodeObject(Address code) {
+  code_object_registry_already_existing_.push_back(code);
 }
 
-void MemoryChunk::ClearCodeObjectRegistries() {
-  DCHECK(code_object_registry_already_existing_);
-  DCHECK(code_object_registry_newly_allocated_);
-  code_object_registry_already_existing_->clear();
-  code_object_registry_newly_allocated_->clear();
+void CodeObjectRegistry::Clear() {
+  code_object_registry_already_existing_.clear();
+  code_object_registry_newly_allocated_.clear();
 }
 
-void MemoryChunk::FinalizeCodeObjectRegistries() {
-  DCHECK(code_object_registry_already_existing_);
-  DCHECK(code_object_registry_newly_allocated_);
-  code_object_registry_already_existing_->shrink_to_fit();
+void CodeObjectRegistry::Finalize() {
+  code_object_registry_already_existing_.shrink_to_fit();
 }
 
-bool MemoryChunk::CodeObjectRegistryContains(HeapObject object) {
-  return (code_object_registry_newly_allocated_->find(object->address()) !=
-          code_object_registry_newly_allocated_->end()) ||
-         (std::binary_search(code_object_registry_already_existing_->begin(),
-                             code_object_registry_already_existing_->end(),
-                             object->address()));
+bool CodeObjectRegistry::Contains(Address object) const {
+  return (code_object_registry_newly_allocated_.find(object) !=
+          code_object_registry_newly_allocated_.end()) ||
+         (std::binary_search(code_object_registry_already_existing_.begin(),
+                             code_object_registry_already_existing_.end(),
+                             object));
 }
 
-Code MemoryChunk::GetCodeObjectFromInnerAddress(Address address) {
-  DCHECK(Contains(address));
+Address CodeObjectRegistry::GetCodeObjectStartFromInnerAddress(
+    Address address) const {
+  // Let's first find the object which comes right before address in the vector
+  // of already existing code objects.
+  Address already_existing_set_ = 0;
+  Address newly_allocated_set_ = 0;
+  if (!code_object_registry_already_existing_.empty()) {
+    auto it =
+        std::upper_bound(code_object_registry_already_existing_.begin(),
+                         code_object_registry_already_existing_.end(), address);
+    if (it != code_object_registry_already_existing_.begin()) {
+      already_existing_set_ = *(--it);
+    }
+  }
 
-  // Let's first try the std::vector which holds object that already existed
-  // since the last GC cycle.
-  if (!code_object_registry_already_existing_->empty()) {
-    auto it = std::upper_bound(code_object_registry_already_existing_->begin(),
-                               code_object_registry_already_existing_->end(),
-                               address);
-    if (it != code_object_registry_already_existing_->begin()) {
-      Code code = Code::unchecked_cast(HeapObject::FromAddress(*(--it)));
-      if (heap_->GcSafeCodeContains(code, address)) {
-        return code;
-      }
+  // Next, let's find the object which comes right before address in the set
+  // of newly allocated code objects.
+  if (!code_object_registry_newly_allocated_.empty()) {
+    auto it = code_object_registry_newly_allocated_.upper_bound(address);
+    if (it != code_object_registry_newly_allocated_.begin()) {
+      newly_allocated_set_ = *(--it);
     }
   }
 
-  // If the address was not found, it has to be in the newly allocated code
-  // objects registry.
-  DCHECK(!code_object_registry_newly_allocated_->empty());
-  auto it = code_object_registry_newly_allocated_->upper_bound(address);
-  HeapObject obj = HeapObject::FromAddress(*(--it));
-  return heap_->GcSafeCastToCode(obj, address);
+  // The code objects which contains address has to be in one of the two
+  // data structures.
+  DCHECK(already_existing_set_ != 0 || newly_allocated_set_ != 0);
+
+  // The address which is closest to the given address is the code object.
+  return already_existing_set_ > newly_allocated_set_ ? already_existing_set_
+                                                      : newly_allocated_set_;
 }
 
 namespace {
@@ -759,11 +760,9 @@ MemoryChunk* MemoryChunk::Initialize(Heap* heap, Address base, size_t size,
   chunk->reservation_ = std::move(reservation);
 
   if (owner->identity() == CODE_SPACE) {
-    chunk->code_object_registry_newly_allocated_ = new std::set<Address>();
-    chunk->code_object_registry_already_existing_ = new std::vector<Address>();
+    chunk->code_object_registry_ = new CodeObjectRegistry();
   } else {
-    chunk->code_object_registry_newly_allocated_ = nullptr;
-    chunk->code_object_registry_already_existing_ = nullptr;
+    chunk->code_object_registry_ = nullptr;
   }
 
   return chunk;
@@ -1386,10 +1385,7 @@ void MemoryChunk::ReleaseAllocatedMemory() {
   if (local_tracker_ != nullptr) ReleaseLocalTracker();
   if (young_generation_bitmap_ != nullptr) ReleaseYoungGenerationBitmap();
   if (marking_bitmap_ != nullptr) ReleaseMarkingBitmap();
-  if (code_object_registry_newly_allocated_ != nullptr)
-    delete code_object_registry_newly_allocated_;
-  if (code_object_registry_already_existing_ != nullptr)
-    delete code_object_registry_already_existing_;
+  if (code_object_registry_ != nullptr) delete code_object_registry_;
 
   if (!IsLargePage()) {
     Page* page = static_cast<Page*>(this);

src/heap/spaces.h

@@ -230,6 +230,24 @@ class FreeListCategory {
   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeListCategory);
 };
 
+// The CodeObjectRegistry holds all start addresses of code objects of a given
+// MemoryChunk. Each MemoryChunk owns a separate CodeObjectRegistry. The
+// CodeObjectRegistry allows fast lookup from an inner pointer of a code object
+// to the actual code object.
+class V8_EXPORT_PRIVATE CodeObjectRegistry {
+ public:
+  void RegisterNewlyAllocatedCodeObject(Address code);
+  void RegisterAlreadyExistingCodeObject(Address code);
+  void Clear();
+  void Finalize();
+  bool Contains(Address code) const;
+  Address GetCodeObjectStartFromInnerAddress(Address address) const;
+
+ private:
+  std::vector<Address> code_object_registry_already_existing_;
+  std::set<Address> code_object_registry_newly_allocated_;
+};
+
 class V8_EXPORT_PRIVATE MemoryChunkLayout {
  public:
   static size_t CodePageGuardStartOffset();
@@ -401,10 +419,8 @@ class MemoryChunk {
       // FreeListCategory categories_[kNumberOfCategories]
       + kSystemPointerSize  // LocalArrayBufferTracker* local_tracker_
       + kIntptrSize  // std::atomic<intptr_t> young_generation_live_byte_count_
-      + kSystemPointerSize  // Bitmap* young_generation_bitmap_
-      +
-      kSystemPointerSize  // std::vector code_object_registry_already_existing_
-      + kSystemPointerSize;  // std::set code_object_registry_newly_allocated_
+      + kSystemPointerSize   // Bitmap* young_generation_bitmap_
+      + kSystemPointerSize;  // CodeObjectRegistry* code_object_registry_
 
   // Page size in bytes.  This must be a multiple of the OS page size.
   static const int kPageSize = 1 << kPageSizeBits;
@@ -675,12 +691,7 @@ class MemoryChunk {
 
   base::ListNode<MemoryChunk>& list_node() { return list_node_; }
 
-  V8_EXPORT_PRIVATE void RegisterNewlyAllocatedCodeObject(HeapObject code);
-  V8_EXPORT_PRIVATE void RegisterAlreadyExistingCodeObject(HeapObject code);
-  V8_EXPORT_PRIVATE void ClearCodeObjectRegistries();
-  V8_EXPORT_PRIVATE void FinalizeCodeObjectRegistries();
-  V8_EXPORT_PRIVATE bool CodeObjectRegistryContains(HeapObject code);
-  V8_EXPORT_PRIVATE Code GetCodeObjectFromInnerAddress(Address address);
+  CodeObjectRegistry* GetCodeObjectRegistry() { return code_object_registry_; }
 
  protected:
   static MemoryChunk* Initialize(Heap* heap, Address base, size_t size,
@@ -788,8 +799,7 @@ class MemoryChunk {
   std::atomic<intptr_t> young_generation_live_byte_count_;
   Bitmap* young_generation_bitmap_;
 
-  std::vector<Address>* code_object_registry_already_existing_;
-  std::set<Address>* code_object_registry_newly_allocated_;
+  CodeObjectRegistry* code_object_registry_;
 
  private:
   void InitializeReservedMemory() { reservation_.Reset(); }

src/heap/sweeper.cc

@@ -249,7 +249,7 @@ int Sweeper::RawSweep(Page* p, FreeListRebuildingMode free_list_mode,
          space->identity() == CODE_SPACE || space->identity() == MAP_SPACE);
   DCHECK(!p->IsEvacuationCandidate() && !p->SweepingDone());
 
-  bool is_code_page = space->identity() == CODE_SPACE;
+  CodeObjectRegistry* code_object_registry = p->GetCodeObjectRegistry();
 
   // TODO(ulan): we don't have to clear type old-to-old slots in code space
   // because the concurrent marker doesn't mark code objects. This requires
@@ -275,12 +275,14 @@ int Sweeper::RawSweep(Page* p, FreeListRebuildingMode free_list_mode,
   // live bytes and keep track of wasted_memory_.
   p->ResetAllocationStatistics();
 
-  if (is_code_page) p->ClearCodeObjectRegistries();
+  if (code_object_registry) code_object_registry->Clear();
 
   for (auto object_and_size :
        LiveObjectRange<kBlackObjects>(p, marking_state_->bitmap(p))) {
     HeapObject const object = object_and_size.first;
-    if (is_code_page) p->RegisterAlreadyExistingCodeObject(object);
+    if (code_object_registry)
+      code_object_registry->RegisterAlreadyExistingCodeObject(
+          object->address());
     DCHECK(marking_state_->IsBlack(object));
     Address free_end = object->address();
     if (free_end != free_start) {
@@ -367,7 +369,7 @@ int Sweeper::RawSweep(Page* p, FreeListRebuildingMode free_list_mode,
     DCHECK_EQ(live_bytes, p->allocated_bytes());
   }
   p->set_concurrent_sweeping_state(Page::kSweepingDone);
-  if (is_code_page) p->FinalizeCodeObjectRegistries();
+  if (code_object_registry) code_object_registry->Finalize();
   if (free_list_mode == IGNORE_FREE_LIST) return 0;
   return static_cast<int>(FreeList::GuaranteedAllocatable(max_freed_bytes));
 }

src/snapshot/deserializer-allocator.cc

@@ -45,8 +45,9 @@ Address DeserializerAllocator::AllocateRaw(AllocationSpace space, int size) {
     DCHECK_LE(high_water_[space], reservation[chunk_index].end);
 #endif
     if (space == CODE_SPACE)
-      MemoryChunk::FromAddress(address)->RegisterNewlyAllocatedCodeObject(
-          HeapObject::FromAddress(address));
+      MemoryChunk::FromAddress(address)
+          ->GetCodeObjectRegistry()
+          ->RegisterNewlyAllocatedCodeObject(address);
     return address;
   }
 }

test/cctest/heap/test-heap.cc

@@ -6678,17 +6678,12 @@ TEST(CodeObjectRegistry) {
     // objects are on the same page.
     CHECK_EQ(MemoryChunk::FromHeapObject(*code1),
              MemoryChunk::FromHeapObject(*code2));
-    CHECK(MemoryChunk::FromHeapObject(*code1)->CodeObjectRegistryContains(
-        *code1));
-    CHECK(MemoryChunk::FromHeapObject(*code2)->CodeObjectRegistryContains(
-        *code2));
+    CHECK(MemoryChunk::FromHeapObject(*code1)->Contains(code1->address()));
+    CHECK(MemoryChunk::FromHeapObject(*code2)->Contains(code2->address()));
   }
   CcTest::CollectAllAvailableGarbage();
-  CHECK(
-      MemoryChunk::FromHeapObject(*code1)->CodeObjectRegistryContains(*code1));
-  CHECK(
-      MemoryChunk::FromAddress(code2_address)
-          ->CodeObjectRegistryContains(HeapObject::FromAddress(code2_address)));
+  CHECK(MemoryChunk::FromHeapObject(*code1)->Contains(code1->address()));
+  CHECK(MemoryChunk::FromAddress(code2_address)->Contains(code2_address));
 }
 
 }  // namespace heap

test/unittests/BUILD.gn

@@ -154,6 +154,7 @@ v8_source_set("unittests_sources") {
     "heap/barrier-unittest.cc",
     "heap/bitmap-test-utils.h",
     "heap/bitmap-unittest.cc",
+    "heap/code-object-registry-unittest.cc",
     "heap/embedder-tracing-unittest.cc",
     "heap/gc-idle-time-handler-unittest.cc",
     "heap/gc-tracer-unittest.cc",

test/unittests/heap/code-object-registry-unittest.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/heap/spaces.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+
+TEST(CodeObjectRegistry, RegisterAlreadyExistingObjectsAndContains) {
+  CodeObjectRegistry registry;
+  const int elements = 10;
+  const int offset = 100;
+  for (int i = 0; i < elements; i++) {
+    registry.RegisterAlreadyExistingCodeObject(i * offset);
+  }
+
+  for (int i = 0; i < elements; i++) {
+    CHECK(registry.Contains(i * offset));
+  }
+}
+
+TEST(CodeObjectRegistry, RegisterNewlyAllocatedObjectsAndContains) {
+  CodeObjectRegistry registry;
+  const int elements = 10;
+  const int offset = 100;
+  for (int i = 0; i < elements; i++) {
+    registry.RegisterNewlyAllocatedCodeObject(i * offset);
+  }
+
+  for (int i = 0; i < elements; i++) {
+    CHECK(registry.Contains(i * offset));
+  }
+}
+
+TEST(CodeObjectRegistry, FindAlreadyExistingObjects) {
+  CodeObjectRegistry registry;
+  const int elements = 10;
+  const int offset = 100;
+  const int inner = 2;
+  for (int i = 1; i <= elements; i++) {
+    registry.RegisterAlreadyExistingCodeObject(i * offset);
+  }
+
+  for (int i = 1; i <= elements; i++) {
+    for (int j = 0; j < inner; j++) {
+      CHECK_EQ(registry.GetCodeObjectStartFromInnerAddress(i * offset + j),
+               i * offset);
+    }
+  }
+}
+
+TEST(CodeObjectRegistry, FindNewlyAllocatedObjects) {
+  CodeObjectRegistry registry;
+  const int elements = 10;
+  const int offset = 100;
+  const int inner = 2;
+  for (int i = 1; i <= elements; i++) {
+    registry.RegisterNewlyAllocatedCodeObject(i * offset);
+  }
+
+  for (int i = 1; i <= elements; i++) {
+    for (int j = 0; j < inner; j++) {
+      CHECK_EQ(registry.GetCodeObjectStartFromInnerAddress(i * offset + j),
+               i * offset);
+    }
+  }
+}
+
+TEST(CodeObjectRegistry, FindAlternatingObjects) {
+  CodeObjectRegistry registry;
+  const int elements = 10;
+  const int offset = 100;
+  const int inner = 2;
+  for (int i = 1; i <= elements; i++) {
+    if (i % 2 == 0) {
+      registry.RegisterAlreadyExistingCodeObject(i * offset);
+    } else {
+      registry.RegisterNewlyAllocatedCodeObject(i * offset);
+    }
+  }
+
+  for (int i = 1; i <= elements; i++) {
+    for (int j = 0; j < inner; j++) {
+      CHECK_EQ(registry.GetCodeObjectStartFromInnerAddress(i * offset + j),
+               i * offset);
+    }
+  }
+}
+}  // namespace internal
+}  // namespace v8

tools/v8heapconst.py

@@ -195,252 +195,252 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-  ("read_only_space", 0x00141): (74, "FreeSpaceMap"),
-  ("read_only_space", 0x00169): (68, "MetaMap"),
-  ("read_only_space", 0x001ad): (67, "NullMap"),
-  ("read_only_space", 0x001e5): (158, "DescriptorArrayMap"),
-  ("read_only_space", 0x00215): (153, "WeakFixedArrayMap"),
-  ("read_only_space", 0x0023d): (88, "OnePointerFillerMap"),
-  ("read_only_space", 0x00265): (88, "TwoPointerFillerMap"),
-  ("read_only_space", 0x002a9): (67, "UninitializedMap"),
-  ("read_only_space", 0x002ed): (8, "OneByteInternalizedStringMap"),
-  ("read_only_space", 0x00349): (67, "UndefinedMap"),
-  ("read_only_space", 0x0037d): (65, "HeapNumberMap"),
-  ("read_only_space", 0x003c1): (67, "TheHoleMap"),
-  ("read_only_space", 0x00421): (67, "BooleanMap"),
-  ("read_only_space", 0x004a9): (72, "ByteArrayMap"),
-  ("read_only_space", 0x004d1): (128, "FixedArrayMap"),
-  ("read_only_space", 0x004f9): (128, "FixedCOWArrayMap"),
-  ("read_only_space", 0x00521): (131, "HashTableMap"),
-  ("read_only_space", 0x00549): (64, "SymbolMap"),
-  ("read_only_space", 0x00571): (40, "OneByteStringMap"),
-  ("read_only_space", 0x00599): (141, "ScopeInfoMap"),
-  ("read_only_space", 0x005c1): (165, "SharedFunctionInfoMap"),
-  ("read_only_space", 0x005e9): (69, "CodeMap"),
-  ("read_only_space", 0x00611): (148, "FunctionContextMap"),
-  ("read_only_space", 0x00639): (156, "CellMap"),
-  ("read_only_space", 0x00661): (164, "GlobalPropertyCellMap"),
-  ("read_only_space", 0x00689): (71, "ForeignMap"),
-  ("read_only_space", 0x006b1): (154, "TransitionArrayMap"),
-  ("read_only_space", 0x006d9): (160, "FeedbackVectorMap"),
-  ("read_only_space", 0x0072d): (67, "ArgumentsMarkerMap"),
-  ("read_only_space", 0x0078d): (67, "ExceptionMap"),
-  ("read_only_space", 0x007e9): (67, "TerminationExceptionMap"),
-  ("read_only_space", 0x00851): (67, "OptimizedOutMap"),
-  ("read_only_space", 0x008b1): (67, "StaleRegisterMap"),
-  ("read_only_space", 0x008f5): (150, "NativeContextMap"),
-  ("read_only_space", 0x0091d): (149, "ModuleContextMap"),
-  ("read_only_space", 0x00945): (147, "EvalContextMap"),
-  ("read_only_space", 0x0096d): (151, "ScriptContextMap"),
-  ("read_only_space", 0x00995): (143, "AwaitContextMap"),
-  ("read_only_space", 0x009bd): (144, "BlockContextMap"),
-  ("read_only_space", 0x009e5): (145, "CatchContextMap"),
-  ("read_only_space", 0x00a0d): (152, "WithContextMap"),
-  ("read_only_space", 0x00a35): (146, "DebugEvaluateContextMap"),
-  ("read_only_space", 0x00a5d): (142, "ScriptContextTableMap"),
-  ("read_only_space", 0x00a85): (130, "ClosureFeedbackCellArrayMap"),
-  ("read_only_space", 0x00aad): (87, "FeedbackMetadataArrayMap"),
-  ("read_only_space", 0x00ad5): (128, "ArrayListMap"),
-  ("read_only_space", 0x00afd): (66, "BigIntMap"),
-  ("read_only_space", 0x00b25): (129, "ObjectBoilerplateDescriptionMap"),
-  ("read_only_space", 0x00b4d): (73, "BytecodeArrayMap"),
-  ("read_only_space", 0x00b75): (157, "CodeDataContainerMap"),
-  ("read_only_space", 0x00b9d): (86, "FixedDoubleArrayMap"),
-  ("read_only_space", 0x00bc5): (136, "GlobalDictionaryMap"),
-  ("read_only_space", 0x00bed): (159, "ManyClosuresCellMap"),
-  ("read_only_space", 0x00c15): (128, "ModuleInfoMap"),
-  ("read_only_space", 0x00c3d): (70, "MutableHeapNumberMap"),
-  ("read_only_space", 0x00c65): (135, "NameDictionaryMap"),
-  ("read_only_space", 0x00c8d): (159, "NoClosuresCellMap"),
-  ("read_only_space", 0x00cb5): (137, "NumberDictionaryMap"),
-  ("read_only_space", 0x00cdd): (159, "OneClosureCellMap"),
-  ("read_only_space", 0x00d05): (132, "OrderedHashMapMap"),
-  ("read_only_space", 0x00d2d): (133, "OrderedHashSetMap"),
-  ("read_only_space", 0x00d55): (134, "OrderedNameDictionaryMap"),
-  ("read_only_space", 0x00d7d): (162, "PreparseDataMap"),
-  ("read_only_space", 0x00da5): (163, "PropertyArrayMap"),
-  ("read_only_space", 0x00dcd): (155, "SideEffectCallHandlerInfoMap"),
-  ("read_only_space", 0x00df5): (155, "SideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x00e1d): (155, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x00e45): (138, "SimpleNumberDictionaryMap"),
-  ("read_only_space", 0x00e6d): (128, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x00e95): (166, "SmallOrderedHashMapMap"),
-  ("read_only_space", 0x00ebd): (167, "SmallOrderedHashSetMap"),
-  ("read_only_space", 0x00ee5): (168, "SmallOrderedNameDictionaryMap"),
-  ("read_only_space", 0x00f0d): (139, "StringTableMap"),
-  ("read_only_space", 0x00f35): (170, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x00f5d): (171, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x00f85): (172, "WeakArrayListMap"),
-  ("read_only_space", 0x00fad): (140, "EphemeronHashTableMap"),
-  ("read_only_space", 0x00fd5): (127, "EmbedderDataArrayMap"),
-  ("read_only_space", 0x00ffd): (173, "WeakCellMap"),
-  ("read_only_space", 0x01025): (58, "NativeSourceStringMap"),
-  ("read_only_space", 0x0104d): (32, "StringMap"),
-  ("read_only_space", 0x01075): (41, "ConsOneByteStringMap"),
-  ("read_only_space", 0x0109d): (33, "ConsStringMap"),
-  ("read_only_space", 0x010c5): (45, "ThinOneByteStringMap"),
-  ("read_only_space", 0x010ed): (37, "ThinStringMap"),
-  ("read_only_space", 0x01115): (35, "SlicedStringMap"),
-  ("read_only_space", 0x0113d): (43, "SlicedOneByteStringMap"),
-  ("read_only_space", 0x01165): (34, "ExternalStringMap"),
-  ("read_only_space", 0x0118d): (42, "ExternalOneByteStringMap"),
-  ("read_only_space", 0x011b5): (50, "UncachedExternalStringMap"),
-  ("read_only_space", 0x011dd): (0, "InternalizedStringMap"),
-  ("read_only_space", 0x01205): (2, "ExternalInternalizedStringMap"),
-  ("read_only_space", 0x0122d): (10, "ExternalOneByteInternalizedStringMap"),
-  ("read_only_space", 0x01255): (18, "UncachedExternalInternalizedStringMap"),
-  ("read_only_space", 0x0127d): (26, "UncachedExternalOneByteInternalizedStringMap"),
-  ("read_only_space", 0x012a5): (58, "UncachedExternalOneByteStringMap"),
-  ("read_only_space", 0x012cd): (76, "FixedUint8ArrayMap"),
-  ("read_only_space", 0x012f5): (75, "FixedInt8ArrayMap"),
-  ("read_only_space", 0x0131d): (78, "FixedUint16ArrayMap"),
-  ("read_only_space", 0x01345): (77, "FixedInt16ArrayMap"),
-  ("read_only_space", 0x0136d): (80, "FixedUint32ArrayMap"),
-  ("read_only_space", 0x01395): (79, "FixedInt32ArrayMap"),
-  ("read_only_space", 0x013bd): (81, "FixedFloat32ArrayMap"),
-  ("read_only_space", 0x013e5): (82, "FixedFloat64ArrayMap"),
-  ("read_only_space", 0x0140d): (83, "FixedUint8ClampedArrayMap"),
-  ("read_only_space", 0x01435): (85, "FixedBigUint64ArrayMap"),
-  ("read_only_space", 0x0145d): (84, "FixedBigInt64ArrayMap"),
-  ("read_only_space", 0x01485): (67, "SelfReferenceMarkerMap"),
-  ("read_only_space", 0x014b9): (98, "EnumCacheMap"),
-  ("read_only_space", 0x01509): (115, "ArrayBoilerplateDescriptionMap"),
-  ("read_only_space", 0x016e1): (101, "InterceptorInfoMap"),
-  ("read_only_space", 0x03585): (89, "AccessCheckInfoMap"),
-  ("read_only_space", 0x035ad): (90, "AccessorInfoMap"),
-  ("read_only_space", 0x035d5): (91, "AccessorPairMap"),
-  ("read_only_space", 0x035fd): (92, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x03625): (93, "AllocationMementoMap"),
-  ("read_only_space", 0x0364d): (94, "AsmWasmDataMap"),
-  ("read_only_space", 0x03675): (95, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x0369d): (96, "ClassPositionsMap"),
-  ("read_only_space", 0x036c5): (97, "DebugInfoMap"),
-  ("read_only_space", 0x036ed): (99, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x03715): (100, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x0373d): (102, "InterpreterDataMap"),
-  ("read_only_space", 0x03765): (103, "ModuleInfoEntryMap"),
-  ("read_only_space", 0x0378d): (104, "ModuleMap"),
-  ("read_only_space", 0x037b5): (105, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x037dd): (106, "PromiseCapabilityMap"),
-  ("read_only_space", 0x03805): (107, "PromiseReactionMap"),
-  ("read_only_space", 0x0382d): (108, "PrototypeInfoMap"),
-  ("read_only_space", 0x03855): (109, "ScriptMap"),
-  ("read_only_space", 0x0387d): (110, "SourcePositionTableWithFrameCacheMap"),
-  ("read_only_space", 0x038a5): (111, "StackFrameInfoMap"),
-  ("read_only_space", 0x038cd): (112, "StackTraceFrameMap"),
-  ("read_only_space", 0x038f5): (113, "Tuple2Map"),
-  ("read_only_space", 0x0391d): (114, "Tuple3Map"),
-  ("read_only_space", 0x03945): (116, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x0396d): (117, "WasmDebugInfoMap"),
-  ("read_only_space", 0x03995): (118, "WasmExceptionTagMap"),
-  ("read_only_space", 0x039bd): (119, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x039e5): (120, "CallableTaskMap"),
-  ("read_only_space", 0x03a0d): (121, "CallbackTaskMap"),
-  ("read_only_space", 0x03a35): (122, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x03a5d): (123, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x03a85): (124, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x03aad): (125, "FinalizationGroupCleanupJobTaskMap"),
-  ("read_only_space", 0x03ad5): (126, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x03afd): (126, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x03b25): (161, "LoadHandler1Map"),
-  ("read_only_space", 0x03b4d): (161, "LoadHandler2Map"),
-  ("read_only_space", 0x03b75): (161, "LoadHandler3Map"),
-  ("read_only_space", 0x03b9d): (169, "StoreHandler0Map"),
-  ("read_only_space", 0x03bc5): (169, "StoreHandler1Map"),
-  ("read_only_space", 0x03bed): (169, "StoreHandler2Map"),
-  ("read_only_space", 0x03c15): (169, "StoreHandler3Map"),
-  ("map_space", 0x00141): (1057, "ExternalMap"),
-  ("map_space", 0x00169): (1073, "JSMessageObjectMap"),
+  ("read_only_space", 0x00139): (74, "FreeSpaceMap"),
+  ("read_only_space", 0x00161): (68, "MetaMap"),
+  ("read_only_space", 0x001a5): (67, "NullMap"),
+  ("read_only_space", 0x001dd): (158, "DescriptorArrayMap"),
+  ("read_only_space", 0x0020d): (153, "WeakFixedArrayMap"),
+  ("read_only_space", 0x00235): (88, "OnePointerFillerMap"),
+  ("read_only_space", 0x0025d): (88, "TwoPointerFillerMap"),
+  ("read_only_space", 0x002a1): (67, "UninitializedMap"),
+  ("read_only_space", 0x002e5): (8, "OneByteInternalizedStringMap"),
+  ("read_only_space", 0x00341): (67, "UndefinedMap"),
+  ("read_only_space", 0x00375): (65, "HeapNumberMap"),
+  ("read_only_space", 0x003b9): (67, "TheHoleMap"),
+  ("read_only_space", 0x00419): (67, "BooleanMap"),
+  ("read_only_space", 0x004a1): (72, "ByteArrayMap"),
+  ("read_only_space", 0x004c9): (128, "FixedArrayMap"),
+  ("read_only_space", 0x004f1): (128, "FixedCOWArrayMap"),
+  ("read_only_space", 0x00519): (131, "HashTableMap"),
+  ("read_only_space", 0x00541): (64, "SymbolMap"),
+  ("read_only_space", 0x00569): (40, "OneByteStringMap"),
+  ("read_only_space", 0x00591): (141, "ScopeInfoMap"),
+  ("read_only_space", 0x005b9): (165, "SharedFunctionInfoMap"),
+  ("read_only_space", 0x005e1): (69, "CodeMap"),
+  ("read_only_space", 0x00609): (148, "FunctionContextMap"),
+  ("read_only_space", 0x00631): (156, "CellMap"),
+  ("read_only_space", 0x00659): (164, "GlobalPropertyCellMap"),
+  ("read_only_space", 0x00681): (71, "ForeignMap"),
+  ("read_only_space", 0x006a9): (154, "TransitionArrayMap"),
+  ("read_only_space", 0x006d1): (160, "FeedbackVectorMap"),
+  ("read_only_space", 0x00725): (67, "ArgumentsMarkerMap"),
+  ("read_only_space", 0x00785): (67, "ExceptionMap"),
+  ("read_only_space", 0x007e1): (67, "TerminationExceptionMap"),
+  ("read_only_space", 0x00849): (67, "OptimizedOutMap"),
+  ("read_only_space", 0x008a9): (67, "StaleRegisterMap"),
+  ("read_only_space", 0x008ed): (150, "NativeContextMap"),
+  ("read_only_space", 0x00915): (149, "ModuleContextMap"),
+  ("read_only_space", 0x0093d): (147, "EvalContextMap"),
+  ("read_only_space", 0x00965): (151, "ScriptContextMap"),
+  ("read_only_space", 0x0098d): (143, "AwaitContextMap"),
+  ("read_only_space", 0x009b5): (144, "BlockContextMap"),
+  ("read_only_space", 0x009dd): (145, "CatchContextMap"),
+  ("read_only_space", 0x00a05): (152, "WithContextMap"),
+  ("read_only_space", 0x00a2d): (146, "DebugEvaluateContextMap"),
+  ("read_only_space", 0x00a55): (142, "ScriptContextTableMap"),
+  ("read_only_space", 0x00a7d): (130, "ClosureFeedbackCellArrayMap"),
+  ("read_only_space", 0x00aa5): (87, "FeedbackMetadataArrayMap"),
+  ("read_only_space", 0x00acd): (128, "ArrayListMap"),
+  ("read_only_space", 0x00af5): (66, "BigIntMap"),
+  ("read_only_space", 0x00b1d): (129, "ObjectBoilerplateDescriptionMap"),
+  ("read_only_space", 0x00b45): (73, "BytecodeArrayMap"),
+  ("read_only_space", 0x00b6d): (157, "CodeDataContainerMap"),
+  ("read_only_space", 0x00b95): (86, "FixedDoubleArrayMap"),
+  ("read_only_space", 0x00bbd): (136, "GlobalDictionaryMap"),
+  ("read_only_space", 0x00be5): (159, "ManyClosuresCellMap"),
+  ("read_only_space", 0x00c0d): (128, "ModuleInfoMap"),
+  ("read_only_space", 0x00c35): (70, "MutableHeapNumberMap"),
+  ("read_only_space", 0x00c5d): (135, "NameDictionaryMap"),
+  ("read_only_space", 0x00c85): (159, "NoClosuresCellMap"),
+  ("read_only_space", 0x00cad): (137, "NumberDictionaryMap"),
+  ("read_only_space", 0x00cd5): (159, "OneClosureCellMap"),
+  ("read_only_space", 0x00cfd): (132, "OrderedHashMapMap"),
+  ("read_only_space", 0x00d25): (133, "OrderedHashSetMap"),
+  ("read_only_space", 0x00d4d): (134, "OrderedNameDictionaryMap"),
+  ("read_only_space", 0x00d75): (162, "PreparseDataMap"),
+  ("read_only_space", 0x00d9d): (163, "PropertyArrayMap"),
+  ("read_only_space", 0x00dc5): (155, "SideEffectCallHandlerInfoMap"),
+  ("read_only_space", 0x00ded): (155, "SideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x00e15): (155, "NextCallSideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x00e3d): (138, "SimpleNumberDictionaryMap"),
+  ("read_only_space", 0x00e65): (128, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x00e8d): (166, "SmallOrderedHashMapMap"),
+  ("read_only_space", 0x00eb5): (167, "SmallOrderedHashSetMap"),
+  ("read_only_space", 0x00edd): (168, "SmallOrderedNameDictionaryMap"),
+  ("read_only_space", 0x00f05): (139, "StringTableMap"),
+  ("read_only_space", 0x00f2d): (170, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x00f55): (171, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x00f7d): (172, "WeakArrayListMap"),
+  ("read_only_space", 0x00fa5): (140, "EphemeronHashTableMap"),
+  ("read_only_space", 0x00fcd): (127, "EmbedderDataArrayMap"),
+  ("read_only_space", 0x00ff5): (173, "WeakCellMap"),
+  ("read_only_space", 0x0101d): (58, "NativeSourceStringMap"),
+  ("read_only_space", 0x01045): (32, "StringMap"),
+  ("read_only_space", 0x0106d): (41, "ConsOneByteStringMap"),
+  ("read_only_space", 0x01095): (33, "ConsStringMap"),
+  ("read_only_space", 0x010bd): (45, "ThinOneByteStringMap"),
+  ("read_only_space", 0x010e5): (37, "ThinStringMap"),
+  ("read_only_space", 0x0110d): (35, "SlicedStringMap"),
+  ("read_only_space", 0x01135): (43, "SlicedOneByteStringMap"),
+  ("read_only_space", 0x0115d): (34, "ExternalStringMap"),
+  ("read_only_space", 0x01185): (42, "ExternalOneByteStringMap"),
+  ("read_only_space", 0x011ad): (50, "UncachedExternalStringMap"),
+  ("read_only_space", 0x011d5): (0, "InternalizedStringMap"),
+  ("read_only_space", 0x011fd): (2, "ExternalInternalizedStringMap"),
+  ("read_only_space", 0x01225): (10, "ExternalOneByteInternalizedStringMap"),
+  ("read_only_space", 0x0124d): (18, "UncachedExternalInternalizedStringMap"),
+  ("read_only_space", 0x01275): (26, "UncachedExternalOneByteInternalizedStringMap"),
+  ("read_only_space", 0x0129d): (58, "UncachedExternalOneByteStringMap"),
+  ("read_only_space", 0x012c5): (76, "FixedUint8ArrayMap"),
+  ("read_only_space", 0x012ed): (75, "FixedInt8ArrayMap"),
+  ("read_only_space", 0x01315): (78, "FixedUint16ArrayMap"),
+  ("read_only_space", 0x0133d): (77, "FixedInt16ArrayMap"),
+  ("read_only_space", 0x01365): (80, "FixedUint32ArrayMap"),
+  ("read_only_space", 0x0138d): (79, "FixedInt32ArrayMap"),
+  ("read_only_space", 0x013b5): (81, "FixedFloat32ArrayMap"),
+  ("read_only_space", 0x013dd): (82, "FixedFloat64ArrayMap"),
+  ("read_only_space", 0x01405): (83, "FixedUint8ClampedArrayMap"),
+  ("read_only_space", 0x0142d): (85, "FixedBigUint64ArrayMap"),
+  ("read_only_space", 0x01455): (84, "FixedBigInt64ArrayMap"),
+  ("read_only_space", 0x0147d): (67, "SelfReferenceMarkerMap"),
+  ("read_only_space", 0x014b1): (98, "EnumCacheMap"),
+  ("read_only_space", 0x01501): (115, "ArrayBoilerplateDescriptionMap"),
+  ("read_only_space", 0x016d9): (101, "InterceptorInfoMap"),
+  ("read_only_space", 0x0357d): (89, "AccessCheckInfoMap"),
+  ("read_only_space", 0x035a5): (90, "AccessorInfoMap"),
+  ("read_only_space", 0x035cd): (91, "AccessorPairMap"),
+  ("read_only_space", 0x035f5): (92, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x0361d): (93, "AllocationMementoMap"),
+  ("read_only_space", 0x03645): (94, "AsmWasmDataMap"),
+  ("read_only_space", 0x0366d): (95, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x03695): (96, "ClassPositionsMap"),
+  ("read_only_space", 0x036bd): (97, "DebugInfoMap"),
+  ("read_only_space", 0x036e5): (99, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x0370d): (100, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x03735): (102, "InterpreterDataMap"),
+  ("read_only_space", 0x0375d): (103, "ModuleInfoEntryMap"),
+  ("read_only_space", 0x03785): (104, "ModuleMap"),
+  ("read_only_space", 0x037ad): (105, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x037d5): (106, "PromiseCapabilityMap"),
+  ("read_only_space", 0x037fd): (107, "PromiseReactionMap"),
+  ("read_only_space", 0x03825): (108, "PrototypeInfoMap"),
+  ("read_only_space", 0x0384d): (109, "ScriptMap"),
+  ("read_only_space", 0x03875): (110, "SourcePositionTableWithFrameCacheMap"),
+  ("read_only_space", 0x0389d): (111, "StackFrameInfoMap"),
+  ("read_only_space", 0x038c5): (112, "StackTraceFrameMap"),
+  ("read_only_space", 0x038ed): (113, "Tuple2Map"),
+  ("read_only_space", 0x03915): (114, "Tuple3Map"),
+  ("read_only_space", 0x0393d): (116, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x03965): (117, "WasmDebugInfoMap"),
+  ("read_only_space", 0x0398d): (118, "WasmExceptionTagMap"),
+  ("read_only_space", 0x039b5): (119, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x039dd): (120, "CallableTaskMap"),
+  ("read_only_space", 0x03a05): (121, "CallbackTaskMap"),
+  ("read_only_space", 0x03a2d): (122, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x03a55): (123, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x03a7d): (124, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x03aa5): (125, "FinalizationGroupCleanupJobTaskMap"),
+  ("read_only_space", 0x03acd): (126, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x03af5): (126, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x03b1d): (161, "LoadHandler1Map"),
+  ("read_only_space", 0x03b45): (161, "LoadHandler2Map"),
+  ("read_only_space", 0x03b6d): (161, "LoadHandler3Map"),
+  ("read_only_space", 0x03b95): (169, "StoreHandler0Map"),
+  ("read_only_space", 0x03bbd): (169, "StoreHandler1Map"),
+  ("read_only_space", 0x03be5): (169, "StoreHandler2Map"),
+  ("read_only_space", 0x03c0d): (169, "StoreHandler3Map"),
+  ("map_space", 0x00139): (1057, "ExternalMap"),
+  ("map_space", 0x00161): (1073, "JSMessageObjectMap"),
 }
 
 # List of known V8 objects.
 KNOWN_OBJECTS = {
-  ("read_only_space", 0x00191): "NullValue",
-  ("read_only_space", 0x001d5): "EmptyDescriptorArray",
-  ("read_only_space", 0x0020d): "EmptyWeakFixedArray",
-  ("read_only_space", 0x0028d): "UninitializedValue",
-  ("read_only_space", 0x0032d): "UndefinedValue",
-  ("read_only_space", 0x00371): "NanValue",
-  ("read_only_space", 0x003a5): "TheHoleValue",
-  ("read_only_space", 0x003f9): "HoleNanValue",
-  ("read_only_space", 0x00405): "TrueValue",
-  ("read_only_space", 0x0046d): "FalseValue",
-  ("read_only_space", 0x0049d): "empty_string",
-  ("read_only_space", 0x00701): "EmptyScopeInfo",
-  ("read_only_space", 0x00709): "EmptyFixedArray",
-  ("read_only_space", 0x00711): "ArgumentsMarker",
-  ("read_only_space", 0x00771): "Exception",
-  ("read_only_space", 0x007cd): "TerminationException",
-  ("read_only_space", 0x00835): "OptimizedOut",
-  ("read_only_space", 0x00895): "StaleRegister",
-  ("read_only_space", 0x014ad): "EmptyEnumCache",
-  ("read_only_space", 0x014e1): "EmptyPropertyArray",
-  ("read_only_space", 0x014e9): "EmptyByteArray",
-  ("read_only_space", 0x014f1): "EmptyObjectBoilerplateDescription",
-  ("read_only_space", 0x014fd): "EmptyArrayBoilerplateDescription",
-  ("read_only_space", 0x01531): "EmptyClosureFeedbackCellArray",
-  ("read_only_space", 0x01539): "EmptyFixedUint8Array",
-  ("read_only_space", 0x0154d): "EmptyFixedInt8Array",
-  ("read_only_space", 0x01561): "EmptyFixedUint16Array",
-  ("read_only_space", 0x01575): "EmptyFixedInt16Array",
-  ("read_only_space", 0x01589): "EmptyFixedUint32Array",
-  ("read_only_space", 0x0159d): "EmptyFixedInt32Array",
-  ("read_only_space", 0x015b1): "EmptyFixedFloat32Array",
-  ("read_only_space", 0x015c5): "EmptyFixedFloat64Array",
-  ("read_only_space", 0x015d9): "EmptyFixedUint8ClampedArray",
-  ("read_only_space", 0x015ed): "EmptyFixedBigUint64Array",
-  ("read_only_space", 0x01601): "EmptyFixedBigInt64Array",
-  ("read_only_space", 0x01615): "EmptySloppyArgumentsElements",
-  ("read_only_space", 0x01625): "EmptySlowElementDictionary",
-  ("read_only_space", 0x01649): "EmptyOrderedHashMap",
-  ("read_only_space", 0x0165d): "EmptyOrderedHashSet",
-  ("read_only_space", 0x01671): "EmptyFeedbackMetadata",
-  ("read_only_space", 0x0167d): "EmptyPropertyCell",
-  ("read_only_space", 0x01691): "EmptyPropertyDictionary",
-  ("read_only_space", 0x016b9): "NoOpInterceptorInfo",
-  ("read_only_space", 0x01709): "EmptyWeakArrayList",
-  ("read_only_space", 0x01715): "InfinityValue",
-  ("read_only_space", 0x01721): "MinusZeroValue",
-  ("read_only_space", 0x0172d): "MinusInfinityValue",
-  ("read_only_space", 0x01739): "SelfReferenceMarker",
-  ("read_only_space", 0x01779): "OffHeapTrampolineRelocationInfo",
-  ("read_only_space", 0x01785): "TrampolineTrivialCodeDataContainer",
-  ("read_only_space", 0x01791): "TrampolinePromiseRejectionCodeDataContainer",
-  ("read_only_space", 0x0179d): "HashSeed",
-  ("old_space", 0x00141): "ArgumentsIteratorAccessor",
-  ("old_space", 0x00185): "ArrayLengthAccessor",
-  ("old_space", 0x001c9): "BoundFunctionLengthAccessor",
-  ("old_space", 0x0020d): "BoundFunctionNameAccessor",
-  ("old_space", 0x00251): "ErrorStackAccessor",
-  ("old_space", 0x00295): "FunctionArgumentsAccessor",
-  ("old_space", 0x002d9): "FunctionCallerAccessor",
-  ("old_space", 0x0031d): "FunctionNameAccessor",
-  ("old_space", 0x00361): "FunctionLengthAccessor",
-  ("old_space", 0x003a5): "FunctionPrototypeAccessor",
-  ("old_space", 0x003e9): "StringLengthAccessor",
-  ("old_space", 0x0042d): "InvalidPrototypeValidityCell",
-  ("old_space", 0x00435): "EmptyScript",
-  ("old_space", 0x00475): "ManyClosuresCell",
-  ("old_space", 0x00481): "ArrayConstructorProtector",
-  ("old_space", 0x00489): "NoElementsProtector",
-  ("old_space", 0x0049d): "IsConcatSpreadableProtector",
-  ("old_space", 0x004a5): "ArraySpeciesProtector",
-  ("old_space", 0x004b9): "TypedArraySpeciesProtector",
-  ("old_space", 0x004cd): "RegExpSpeciesProtector",
-  ("old_space", 0x004e1): "PromiseSpeciesProtector",
-  ("old_space", 0x004f5): "StringLengthProtector",
-  ("old_space", 0x004fd): "ArrayIteratorProtector",
-  ("old_space", 0x00511): "ArrayBufferDetachingProtector",
-  ("old_space", 0x00525): "PromiseHookProtector",
-  ("old_space", 0x00539): "PromiseResolveProtector",
-  ("old_space", 0x00541): "MapIteratorProtector",
-  ("old_space", 0x00555): "PromiseThenProtector",
-  ("old_space", 0x00569): "SetIteratorProtector",
-  ("old_space", 0x0057d): "StringIteratorProtector",
-  ("old_space", 0x00591): "SingleCharacterStringCache",
-  ("old_space", 0x00999): "StringSplitCache",
-  ("old_space", 0x00da1): "RegExpMultipleCache",
-  ("old_space", 0x011a9): "BuiltinsConstantsTable",
+  ("read_only_space", 0x00189): "NullValue",
+  ("read_only_space", 0x001cd): "EmptyDescriptorArray",
+  ("read_only_space", 0x00205): "EmptyWeakFixedArray",
+  ("read_only_space", 0x00285): "UninitializedValue",
+  ("read_only_space", 0x00325): "UndefinedValue",
+  ("read_only_space", 0x00369): "NanValue",
+  ("read_only_space", 0x0039d): "TheHoleValue",
+  ("read_only_space", 0x003f1): "HoleNanValue",
+  ("read_only_space", 0x003fd): "TrueValue",
+  ("read_only_space", 0x00465): "FalseValue",
+  ("read_only_space", 0x00495): "empty_string",
+  ("read_only_space", 0x006f9): "EmptyScopeInfo",
+  ("read_only_space", 0x00701): "EmptyFixedArray",
+  ("read_only_space", 0x00709): "ArgumentsMarker",
+  ("read_only_space", 0x00769): "Exception",
+  ("read_only_space", 0x007c5): "TerminationException",
+  ("read_only_space", 0x0082d): "OptimizedOut",
+  ("read_only_space", 0x0088d): "StaleRegister",
+  ("read_only_space", 0x014a5): "EmptyEnumCache",
+  ("read_only_space", 0x014d9): "EmptyPropertyArray",
+  ("read_only_space", 0x014e1): "EmptyByteArray",
+  ("read_only_space", 0x014e9): "EmptyObjectBoilerplateDescription",
+  ("read_only_space", 0x014f5): "EmptyArrayBoilerplateDescription",
+  ("read_only_space", 0x01529): "EmptyClosureFeedbackCellArray",
+  ("read_only_space", 0x01531): "EmptyFixedUint8Array",
+  ("read_only_space", 0x01545): "EmptyFixedInt8Array",
+  ("read_only_space", 0x01559): "EmptyFixedUint16Array",
+  ("read_only_space", 0x0156d): "EmptyFixedInt16Array",
+  ("read_only_space", 0x01581): "EmptyFixedUint32Array",
+  ("read_only_space", 0x01595): "EmptyFixedInt32Array",
+  ("read_only_space", 0x015a9): "EmptyFixedFloat32Array",
+  ("read_only_space", 0x015bd): "EmptyFixedFloat64Array",
+  ("read_only_space", 0x015d1): "EmptyFixedUint8ClampedArray",
+  ("read_only_space", 0x015e5): "EmptyFixedBigUint64Array",
+  ("read_only_space", 0x015f9): "EmptyFixedBigInt64Array",
+  ("read_only_space", 0x0160d): "EmptySloppyArgumentsElements",
+  ("read_only_space", 0x0161d): "EmptySlowElementDictionary",
+  ("read_only_space", 0x01641): "EmptyOrderedHashMap",
+  ("read_only_space", 0x01655): "EmptyOrderedHashSet",
+  ("read_only_space", 0x01669): "EmptyFeedbackMetadata",
+  ("read_only_space", 0x01675): "EmptyPropertyCell",
+  ("read_only_space", 0x01689): "EmptyPropertyDictionary",
+  ("read_only_space", 0x016b1): "NoOpInterceptorInfo",
+  ("read_only_space", 0x01701): "EmptyWeakArrayList",
+  ("read_only_space", 0x0170d): "InfinityValue",
+  ("read_only_space", 0x01719): "MinusZeroValue",
+  ("read_only_space", 0x01725): "MinusInfinityValue",
+  ("read_only_space", 0x01731): "SelfReferenceMarker",
+  ("read_only_space", 0x01771): "OffHeapTrampolineRelocationInfo",
+  ("read_only_space", 0x0177d): "TrampolineTrivialCodeDataContainer",
+  ("read_only_space", 0x01789): "TrampolinePromiseRejectionCodeDataContainer",
+  ("read_only_space", 0x01795): "HashSeed",
+  ("old_space", 0x00139): "ArgumentsIteratorAccessor",
+  ("old_space", 0x0017d): "ArrayLengthAccessor",
+  ("old_space", 0x001c1): "BoundFunctionLengthAccessor",
+  ("old_space", 0x00205): "BoundFunctionNameAccessor",
+  ("old_space", 0x00249): "ErrorStackAccessor",
+  ("old_space", 0x0028d): "FunctionArgumentsAccessor",
+  ("old_space", 0x002d1): "FunctionCallerAccessor",
+  ("old_space", 0x00315): "FunctionNameAccessor",
+  ("old_space", 0x00359): "FunctionLengthAccessor",
+  ("old_space", 0x0039d): "FunctionPrototypeAccessor",
+  ("old_space", 0x003e1): "StringLengthAccessor",
+  ("old_space", 0x00425): "InvalidPrototypeValidityCell",
+  ("old_space", 0x0042d): "EmptyScript",
+  ("old_space", 0x0046d): "ManyClosuresCell",
+  ("old_space", 0x00479): "ArrayConstructorProtector",
+  ("old_space", 0x00481): "NoElementsProtector",
+  ("old_space", 0x00495): "IsConcatSpreadableProtector",
+  ("old_space", 0x0049d): "ArraySpeciesProtector",
+  ("old_space", 0x004b1): "TypedArraySpeciesProtector",
+  ("old_space", 0x004c5): "RegExpSpeciesProtector",
+  ("old_space", 0x004d9): "PromiseSpeciesProtector",
+  ("old_space", 0x004ed): "StringLengthProtector",
+  ("old_space", 0x004f5): "ArrayIteratorProtector",
+  ("old_space", 0x00509): "ArrayBufferDetachingProtector",
+  ("old_space", 0x0051d): "PromiseHookProtector",
+  ("old_space", 0x00531): "PromiseResolveProtector",
+  ("old_space", 0x00539): "MapIteratorProtector",
+  ("old_space", 0x0054d): "PromiseThenProtector",
+  ("old_space", 0x00561): "SetIteratorProtector",
+  ("old_space", 0x00575): "StringIteratorProtector",
+  ("old_space", 0x00589): "SingleCharacterStringCache",
+  ("old_space", 0x00991): "StringSplitCache",
+  ("old_space", 0x00d99): "RegExpMultipleCache",
+  ("old_space", 0x011a1): "BuiltinsConstantsTable",
 }
 
 # List of known V8 Frame Markers.