[heap] Introduce CLIENT_TO_SHARED remembered set

During a shared GC we need to iterate the twice: for marking and later
when updating pointers after evacuation. This CL introduces a new
remembered set to avoid the second heap iteration, the remembered set
is created when iterating the client heaps for marking. When updating
pointers, the GC only needs to visit slots in the remembered set.
CLIENT_TO_SHARED is only used during GC atm.

Bug: v8:11708
Change-Id: Ie7482babb53b5f6ca2115daafe6f208acae98d6e
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3315443
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: Dominik Inführ <dinfuehr@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78332}

src/heap/heap.cc

@@ -2297,6 +2297,10 @@ void Heap::PerformSharedGarbageCollection(Isolate* initiator,
 
   isolate()->global_safepoint()->IterateClientIsolates([](Isolate* client) {
     client->heap()->FreeSharedLinearAllocationAreas();
+
+    // As long as we need to iterate the client heap to find references into the
+    // shared heap, all client heaps need to be iterable.
+    client->heap()->MakeHeapIterable();
   });
 
   PerformGarbageCollection(GarbageCollector::MARK_COMPACTOR);

src/heap/large-spaces.h

@@ -94,8 +94,8 @@ class V8_EXPORT_PRIVATE LargeObjectSpace : public Space {
   virtual void AddPage(LargePage* page, size_t object_size);
   virtual void RemovePage(LargePage* page, size_t object_size);
 
-  LargePage* first_page() {
-    return reinterpret_cast<LargePage*>(Space::first_page());
+  LargePage* first_page() override {
+    return reinterpret_cast<LargePage*>(memory_chunk_list_.front());
   }
 
   iterator begin() { return iterator(first_page()); }

src/heap/mark-compact.cc

@@ -5,6 +5,7 @@
 #include "src/heap/mark-compact.h"
 
 #include <unordered_map>
+#include <unordered_set>
 
 #include "src/base/logging.h"
 #include "src/base/optional.h"
@@ -19,6 +20,7 @@
 #include "src/execution/vm-state-inl.h"
 #include "src/handles/global-handles.h"
 #include "src/heap/array-buffer-sweeper.h"
+#include "src/heap/basic-memory-chunk.h"
 #include "src/heap/code-object-registry.h"
 #include "src/heap/gc-tracer.h"
 #include "src/heap/heap.h"
@@ -1165,17 +1167,18 @@ class MarkCompactCollector::SharedHeapObjectVisitor final
         collector_(collector) {}
 
   void VisitPointer(HeapObject host, ObjectSlot p) final {
-    MarkObject(host, p.load(cage_base()));
+    MarkObject(host, p, p.load(cage_base()));
   }
 
   void VisitPointer(HeapObject host, MaybeObjectSlot p) final {
     MaybeObject object = p.load(cage_base());
     HeapObject heap_object;
-    if (object.GetHeapObject(&heap_object)) MarkObject(host, heap_object);
+    if (object.GetHeapObject(&heap_object))
+      MarkObject(host, ObjectSlot(p), heap_object);
   }
 
   void VisitMapPointer(HeapObject host) final {
-    MarkObject(host, host.map(cage_base()));
+    MarkObject(host, host.map_slot(), host.map(cage_base()));
   }
 
   void VisitPointers(HeapObject host, ObjectSlot start, ObjectSlot end) final {
@@ -1183,13 +1186,13 @@ class MarkCompactCollector::SharedHeapObjectVisitor final
       // The map slot should be handled in VisitMapPointer.
       DCHECK_NE(host.map_slot(), p);
       DCHECK(!HasWeakHeapObjectTag(p.load(cage_base())));
-      MarkObject(host, p.load(cage_base()));
+      MarkObject(host, p, p.load(cage_base()));
     }
   }
 
   void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
     CHECK(V8_EXTERNAL_CODE_SPACE_BOOL);
-    MarkObject(host, slot.load(code_cage_base()));
+    MarkObject(host, ObjectSlot(slot.address()), slot.load(code_cage_base()));
   }
 
   void VisitPointers(HeapObject host, MaybeObjectSlot start,
@@ -1202,19 +1205,27 @@ class MarkCompactCollector::SharedHeapObjectVisitor final
   }
 
   void VisitCodeTarget(Code host, RelocInfo* rinfo) override {
+#if DEBUG
     Code target = Code::GetCodeFromTargetAddress(rinfo->target_address());
-    MarkObject(host, target);
+    DCHECK(!BasicMemoryChunk::FromHeapObject(target)->InSharedHeap());
+#endif  // DEBUG
   }
+
   void VisitEmbeddedPointer(Code host, RelocInfo* rinfo) override {
-    MarkObject(host, rinfo->target_object(cage_base()));
+#if DEBUG
+    HeapObject target = rinfo->target_object(cage_base());
+    DCHECK(!BasicMemoryChunk::FromHeapObject(target)->InSharedHeap());
+#endif  // DEBUG
   }
 
  private:
-  V8_INLINE void MarkObject(HeapObject host, Object object) {
+  V8_INLINE void MarkObject(HeapObject host, ObjectSlot slot, Object object) {
     DCHECK(!BasicMemoryChunk::FromHeapObject(host)->InSharedHeap());
     if (!object.IsHeapObject()) return;
     HeapObject heap_object = HeapObject::cast(object);
     if (!BasicMemoryChunk::FromHeapObject(heap_object)->InSharedHeap()) return;
+    RememberedSet<CLIENT_TO_SHARED>::Insert<AccessMode::NON_ATOMIC>(
+        MemoryChunk::FromHeapObject(host), slot.address());
     collector_->MarkObject(host, heap_object);
   }
 
@@ -3115,11 +3126,8 @@ static inline SlotCallbackResult UpdateStrongCodeSlot(
 
 }  // namespace
 
-static constexpr bool kClientHeap = true;
-
 // Visitor for updating root pointers and to-space pointers.
 // It does not expect to encounter pointers to dead objects.
-template <bool in_client_heap = false>
 class PointersUpdatingVisitor final : public ObjectVisitorWithCageBases,
                                       public RootVisitor {
  public:
@@ -3175,35 +3183,15 @@ class PointersUpdatingVisitor final : public ObjectVisitorWithCageBases,
     }
   }
 
-  void VisitMapPointer(HeapObject object) override {
-    if (in_client_heap) {
-      UpdateStrongSlotInternal(cage_base(), object.map_slot());
-    } else {
-      UNREACHABLE();
-    }
-  }
-
   void VisitCodeTarget(Code host, RelocInfo* rinfo) override {
-    if (in_client_heap) {
-      Code target = Code::GetCodeFromTargetAddress(rinfo->target_address());
-      CHECK_WITH_MSG(!target.InSharedHeap(),
-                     "refs into shared heap not yet supported here.");
-    } else {
     // This visitor nevers visits code objects.
     UNREACHABLE();
   }
-  }
 
   void VisitEmbeddedPointer(Code host, RelocInfo* rinfo) override {
-    if (in_client_heap) {
-      HeapObject target = rinfo->target_object(cage_base());
-      CHECK_WITH_MSG(!target.InSharedHeap(),
-                     "refs into shared heap not yet supported here.");
-    } else {
     // This visitor nevers visits code objects.
     UNREACHABLE();
   }
-  }
 
  private:
   static inline SlotCallbackResult UpdateRootSlotInternal(
@@ -3232,6 +3220,71 @@ class PointersUpdatingVisitor final : public ObjectVisitorWithCageBases,
   }
 };
 
+#ifdef VERIFY_HEAP
+// Visitor for updating root pointers and to-space pointers.
+// It does not expect to encounter pointers to dead objects.
+class ClientHeapVerifier final : public ObjectVisitorWithCageBases {
+ public:
+  explicit ClientHeapVerifier(Heap* heap) : ObjectVisitorWithCageBases(heap) {}
+
+  void VisitPointer(HeapObject host, ObjectSlot p) override {
+    VerifySlot(cage_base(), p);
+  }
+
+  void VisitPointer(HeapObject host, MaybeObjectSlot p) override {
+    VerifySlot(cage_base(), p);
+  }
+
+  void VisitPointers(HeapObject host, ObjectSlot start,
+                     ObjectSlot end) override {
+    for (ObjectSlot p = start; p < end; ++p) {
+      VerifySlot(cage_base(), p);
+    }
+  }
+
+  void VisitPointers(HeapObject host, MaybeObjectSlot start,
+                     MaybeObjectSlot end) final {
+    for (MaybeObjectSlot p = start; p < end; ++p) {
+      VerifySlot(cage_base(), p);
+    }
+  }
+
+  void VisitMapPointer(HeapObject host) override {
+    VerifySlot(cage_base(), host.map_slot());
+  }
+
+  void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
+    UNREACHABLE();
+  }
+
+  void VisitCodeTarget(Code host, RelocInfo* rinfo) override {}
+
+  void VisitEmbeddedPointer(Code host, RelocInfo* rinfo) override {}
+
+ private:
+  void VerifySlot(PtrComprCageBase cage_base, ObjectSlot slot) {
+    HeapObject heap_object;
+    if (slot.load(cage_base).GetHeapObject(&heap_object)) {
+      VerifyHeapObject(heap_object);
+    }
+  }
+
+  void VerifySlot(PtrComprCageBase cage_base, MaybeObjectSlot slot) {
+    HeapObject heap_object;
+    if (slot.load(cage_base).GetHeapObject(&heap_object)) {
+      VerifyHeapObject(heap_object);
+    }
+  }
+
+  void VerifyHeapObject(HeapObject heap_object) {
+    if (BasicMemoryChunk::FromHeapObject(heap_object)->InReadOnlySpace())
+      return;
+    if (!heap_object.InSharedHeap()) return;
+    CHECK(!heap_object.map_word(kRelaxedLoad).IsForwardingAddress());
+  }
+};
+#endif  // VERIFY_HEAP
+
 static String UpdateReferenceInExternalStringTableEntry(Heap* heap,
                                                         FullObjectSlot p) {
   MapWord map_word = HeapObject::cast(*p).map_word(kRelaxedLoad);
@@ -3306,6 +3359,7 @@ void MarkCompactCollector::EvacuateEpilogue() {
   // Old-to-old slot sets must be empty after evacuation.
   for (Page* p : *heap()->old_space()) {
     DCHECK_NULL((p->slot_set<OLD_TO_OLD, AccessMode::ATOMIC>()));
+    DCHECK_NULL((p->slot_set<CLIENT_TO_SHARED, AccessMode::NON_ATOMIC>()));
     DCHECK_NULL((p->typed_slot_set<OLD_TO_OLD, AccessMode::ATOMIC>()));
     DCHECK_NULL(p->invalidated_slots<OLD_TO_OLD>());
     DCHECK_NULL(p->invalidated_slots<OLD_TO_NEW>());
@@ -4037,7 +4091,7 @@ class ToSpaceUpdatingItem : public UpdatingItem {
   void ProcessVisitAll() {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.gc"),
                  "ToSpaceUpdatingItem::ProcessVisitAll");
-    PointersUpdatingVisitor<> visitor(heap_);
+    PointersUpdatingVisitor visitor(heap_);
     for (Address cur = start_; cur < end_;) {
       HeapObject object = HeapObject::FromAddress(cur);
       Map map = object.map(visitor.cage_base());
@@ -4052,7 +4106,7 @@ class ToSpaceUpdatingItem : public UpdatingItem {
                  "ToSpaceUpdatingItem::ProcessVisitLive");
     // For young generation evacuations we want to visit grey objects, for
     // full MC, we need to visit black objects.
-    PointersUpdatingVisitor<> visitor(heap_);
+    PointersUpdatingVisitor visitor(heap_);
     for (auto object_and_size : LiveObjectRange<kAllLiveObjects>(
              chunk_, marking_state_->bitmap(chunk_))) {
       object_and_size.first.IterateBodyFast(visitor.cage_base(), &visitor);
@@ -4380,7 +4434,7 @@ void MarkCompactCollector::UpdatePointersAfterEvacuation() {
     TRACE_GC(heap()->tracer(),
              GCTracer::Scope::MC_EVACUATE_UPDATE_POINTERS_TO_NEW_ROOTS);
     // The external string table is updated at the end.
-    PointersUpdatingVisitor<> updating_visitor(heap());
+    PointersUpdatingVisitor updating_visitor(heap());
     heap_->IterateRootsIncludingClients(
         &updating_visitor,
         base::EnumSet<SkipRoot>{SkipRoot::kExternalStringTable});
@@ -4440,18 +4494,38 @@ void MarkCompactCollector::UpdatePointersAfterEvacuation() {
 void MarkCompactCollector::UpdatePointersInClientHeaps() {
   if (!isolate()->is_shared()) return;
 
-  PointersUpdatingVisitor<kClientHeap> visitor(heap());
-
   isolate()->global_safepoint()->IterateClientIsolates(
-      [&visitor](Isolate* client) {
-        Heap* heap = client->heap();
-        HeapObjectIterator iterator(heap, HeapObjectIterator::kNoFiltering);
+      [this](Isolate* client) { UpdatePointersInClientHeap(client); });
+}
+
+void MarkCompactCollector::UpdatePointersInClientHeap(Isolate* client) {
   PtrComprCageBase cage_base(client);
+  MemoryChunkIterator chunk_iterator(client->heap());
+
+  while (chunk_iterator.HasNext()) {
+    MemoryChunk* chunk = chunk_iterator.Next();
+    RememberedSet<CLIENT_TO_SHARED>::Iterate(
+        chunk,
+        [cage_base](MaybeObjectSlot slot) {
+          return UpdateSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
+        },
+        SlotSet::KEEP_EMPTY_BUCKETS);
+
+    chunk->ReleaseSlotSet<CLIENT_TO_SHARED>();
+  }
+
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    ClientHeapVerifier verifier_visitor(client->heap());
+
+    HeapObjectIterator iterator(client->heap(),
+                                HeapObjectIterator::kNoFiltering);
     for (HeapObject obj = iterator.Next(); !obj.is_null();
          obj = iterator.Next()) {
-          obj.IterateFast(cage_base, &visitor);
+      obj.IterateFast(cage_base, &verifier_visitor);
     }
-      });
+  }
+#endif  // VERIFY_HEAP
 }
 
 void MarkCompactCollector::ReportAbortedEvacuationCandidateDueToOOM(
@@ -4962,7 +5036,7 @@ void MinorMarkCompactCollector::UpdatePointersAfterEvacuation() {
   TRACE_GC(heap()->tracer(),
            GCTracer::Scope::MINOR_MC_EVACUATE_UPDATE_POINTERS);
 
-  PointersUpdatingVisitor<> updating_visitor(heap());
+  PointersUpdatingVisitor updating_visitor(heap());
   std::vector<std::unique_ptr<UpdatingItem>> updating_items;
 
   // Create batches of global handles.

src/heap/mark-compact.h

@@ -642,6 +642,7 @@ class MarkCompactCollector final : public MarkCompactCollectorBase {
 
   // Updates pointers to shared objects from client heaps.
   void UpdatePointersInClientHeaps();
+  void UpdatePointersInClientHeap(Isolate* client);
 
   // Marks object reachable from harmony weak maps and wrapper tracing.
   void ProcessEphemeronMarking();

src/heap/memory-chunk-layout.h

@@ -27,7 +27,9 @@ class SlotSet;
 enum RememberedSetType {
   OLD_TO_NEW,
   OLD_TO_OLD,
-  OLD_TO_CODE = V8_EXTERNAL_CODE_SPACE_BOOL ? OLD_TO_OLD + 1 : OLD_TO_OLD,
+  CLIENT_TO_SHARED,
+  OLD_TO_CODE =
+      V8_EXTERNAL_CODE_SPACE_BOOL ? CLIENT_TO_SHARED + 1 : CLIENT_TO_SHARED,
   NUMBER_OF_REMEMBERED_SET_TYPES
 };
 

src/heap/memory-chunk.cc

@@ -122,6 +122,8 @@ MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
 
   base::AsAtomicPointer::Release_Store(&chunk->slot_set_[OLD_TO_NEW], nullptr);
   base::AsAtomicPointer::Release_Store(&chunk->slot_set_[OLD_TO_OLD], nullptr);
+  base::AsAtomicPointer::Release_Store(&chunk->slot_set_[CLIENT_TO_SHARED],
+                                       nullptr);
   if (V8_EXTERNAL_CODE_SPACE_BOOL) {
     base::AsAtomicPointer::Release_Store(&chunk->slot_set_[OLD_TO_CODE],
                                          nullptr);
@@ -259,6 +261,8 @@ void MemoryChunk::ReleaseAllAllocatedMemory() {
 
 template V8_EXPORT_PRIVATE SlotSet* MemoryChunk::AllocateSlotSet<OLD_TO_NEW>();
 template V8_EXPORT_PRIVATE SlotSet* MemoryChunk::AllocateSlotSet<OLD_TO_OLD>();
+template V8_EXPORT_PRIVATE SlotSet*
+MemoryChunk::AllocateSlotSet<CLIENT_TO_SHARED>();
 #ifdef V8_EXTERNAL_CODE_SPACE
 template V8_EXPORT_PRIVATE SlotSet* MemoryChunk::AllocateSlotSet<OLD_TO_CODE>();
 #endif  // V8_EXTERNAL_CODE_SPACE
@@ -286,6 +290,7 @@ SlotSet* MemoryChunk::AllocateSlotSet(SlotSet** slot_set) {
 
 template void MemoryChunk::ReleaseSlotSet<OLD_TO_NEW>();
 template void MemoryChunk::ReleaseSlotSet<OLD_TO_OLD>();
+template void MemoryChunk::ReleaseSlotSet<CLIENT_TO_SHARED>();
 #ifdef V8_EXTERNAL_CODE_SPACE
 template void MemoryChunk::ReleaseSlotSet<OLD_TO_CODE>();
 #endif  // V8_EXTERNAL_CODE_SPACE

src/heap/new-spaces.h

@@ -139,11 +139,18 @@ class SemiSpace : public Space {
 
   size_t Available() override { UNREACHABLE(); }
 
-  Page* first_page() { return reinterpret_cast<Page*>(Space::first_page()); }
-  Page* last_page() { return reinterpret_cast<Page*>(Space::last_page()); }
+  Page* first_page() override {
+    return reinterpret_cast<Page*>(memory_chunk_list_.front());
+  }
+  Page* last_page() override {
+    return reinterpret_cast<Page*>(memory_chunk_list_.back());
+  }
 
-  const Page* first_page() const {
-    return reinterpret_cast<const Page*>(Space::first_page());
+  const Page* first_page() const override {
+    return reinterpret_cast<const Page*>(memory_chunk_list_.front());
+  }
+  const Page* last_page() const override {
+    return reinterpret_cast<const Page*>(memory_chunk_list_.back());
   }
 
   iterator begin() { return iterator(first_page()); }
@@ -447,8 +454,11 @@ class V8_EXPORT_PRIVATE NewSpace
 
   SemiSpace* active_space() { return &to_space_; }
 
-  Page* first_page() { return to_space_.first_page(); }
-  Page* last_page() { return to_space_.last_page(); }
+  Page* first_page() override { return to_space_.first_page(); }
+  Page* last_page() override { return to_space_.last_page(); }
+
+  const Page* first_page() const override { return to_space_.first_page(); }
+  const Page* last_page() const override { return to_space_.last_page(); }
 
   iterator begin() { return to_space_.begin(); }
   iterator end() { return to_space_.end(); }

src/heap/paged-spaces.h

@@ -289,9 +289,11 @@ class V8_EXPORT_PRIVATE PagedSpace
   inline void UnlinkFreeListCategories(Page* page);
   inline size_t RelinkFreeListCategories(Page* page);
 
-  Page* first_page() { return reinterpret_cast<Page*>(Space::first_page()); }
-  const Page* first_page() const {
-    return reinterpret_cast<const Page*>(Space::first_page());
+  Page* first_page() override {
+    return reinterpret_cast<Page*>(memory_chunk_list_.front());
+  }
+  const Page* first_page() const override {
+    return reinterpret_cast<const Page*>(memory_chunk_list_.front());
   }
 
   iterator begin() { return iterator(first_page()); }

src/heap/spaces-inl.h

@@ -175,6 +175,24 @@ bool LocalAllocationBuffer::TryFreeLast(HeapObject object, int object_size) {
   return false;
 }
 
+bool MemoryChunkIterator::HasNext() {
+  if (current_chunk_) return true;
+
+  while (space_iterator_.HasNext()) {
+    Space* space = space_iterator_.Next();
+    current_chunk_ = space->first_page();
+    if (current_chunk_) return true;
+  }
+
+  return false;
+}
+
+MemoryChunk* MemoryChunkIterator::Next() {
+  MemoryChunk* chunk = current_chunk_;
+  current_chunk_ = chunk->list_node().next();
+  return chunk;
+}
+
 }  // namespace internal
 }  // namespace v8
 

src/heap/spaces.h

@@ -170,11 +170,15 @@ class V8_EXPORT_PRIVATE Space : public BaseSpace {
     return external_backing_store_bytes_[type];
   }
 
-  MemoryChunk* first_page() { return memory_chunk_list_.front(); }
-  MemoryChunk* last_page() { return memory_chunk_list_.back(); }
+  virtual MemoryChunk* first_page() { return memory_chunk_list_.front(); }
+  virtual MemoryChunk* last_page() { return memory_chunk_list_.back(); }
 
-  const MemoryChunk* first_page() const { return memory_chunk_list_.front(); }
-  const MemoryChunk* last_page() const { return memory_chunk_list_.back(); }
+  virtual const MemoryChunk* first_page() const {
+    return memory_chunk_list_.front();
+  }
+  virtual const MemoryChunk* last_page() const {
+    return memory_chunk_list_.back();
+  }
 
   heap::List<MemoryChunk>& memory_chunk_list() { return memory_chunk_list_; }
 
@@ -490,6 +494,19 @@ class SpaceWithLinearArea : public Space {
       AllocationOrigin::kNumberOfAllocationOrigins)] = {0};
 };
 
+// Iterates over all memory chunks in the heap (across all spaces).
+class MemoryChunkIterator {
+ public:
+  explicit MemoryChunkIterator(Heap* heap) : space_iterator_(heap) {}
+
+  V8_INLINE bool HasNext();
+  V8_INLINE MemoryChunk* Next();
+
+ private:
+  SpaceIterator space_iterator_;
+  MemoryChunk* current_chunk_ = nullptr;
+};
+
 }  // namespace internal
 }  // namespace v8
 

tools/v8heapconst.py

@@ -262,283 +262,283 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-  ("read_only_space", 0x02119): (245, "MetaMap"),
-  ("read_only_space", 0x02141): (131, "NullMap"),
-  ("read_only_space", 0x02169): (229, "StrongDescriptorArrayMap"),
-  ("read_only_space", 0x02191): (258, "WeakArrayListMap"),
-  ("read_only_space", 0x021d5): (156, "EnumCacheMap"),
-  ("read_only_space", 0x02209): (176, "FixedArrayMap"),
-  ("read_only_space", 0x02255): (8, "OneByteInternalizedStringMap"),
-  ("read_only_space", 0x022a1): (242, "FreeSpaceMap"),
-  ("read_only_space", 0x022c9): (241, "OnePointerFillerMap"),
-  ("read_only_space", 0x022f1): (241, "TwoPointerFillerMap"),
-  ("read_only_space", 0x02319): (131, "UninitializedMap"),
-  ("read_only_space", 0x02391): (131, "UndefinedMap"),
-  ("read_only_space", 0x023d5): (130, "HeapNumberMap"),
-  ("read_only_space", 0x02409): (131, "TheHoleMap"),
-  ("read_only_space", 0x02469): (131, "BooleanMap"),
-  ("read_only_space", 0x0250d): (189, "ByteArrayMap"),
-  ("read_only_space", 0x02535): (176, "FixedCOWArrayMap"),
-  ("read_only_space", 0x0255d): (177, "HashTableMap"),
-  ("read_only_space", 0x02585): (128, "SymbolMap"),
-  ("read_only_space", 0x025ad): (40, "OneByteStringMap"),
-  ("read_only_space", 0x025d5): (251, "ScopeInfoMap"),
-  ("read_only_space", 0x025fd): (252, "SharedFunctionInfoMap"),
-  ("read_only_space", 0x02625): (235, "CodeMap"),
-  ("read_only_space", 0x0264d): (234, "CellMap"),
-  ("read_only_space", 0x02675): (250, "GlobalPropertyCellMap"),
-  ("read_only_space", 0x0269d): (204, "ForeignMap"),
-  ("read_only_space", 0x026c5): (233, "TransitionArrayMap"),
-  ("read_only_space", 0x026ed): (45, "ThinOneByteStringMap"),
-  ("read_only_space", 0x02715): (240, "FeedbackVectorMap"),
-  ("read_only_space", 0x0274d): (131, "ArgumentsMarkerMap"),
-  ("read_only_space", 0x027ad): (131, "ExceptionMap"),
-  ("read_only_space", 0x02809): (131, "TerminationExceptionMap"),
-  ("read_only_space", 0x02871): (131, "OptimizedOutMap"),
-  ("read_only_space", 0x028d1): (131, "StaleRegisterMap"),
-  ("read_only_space", 0x02931): (188, "ScriptContextTableMap"),
-  ("read_only_space", 0x02959): (186, "ClosureFeedbackCellArrayMap"),
-  ("read_only_space", 0x02981): (239, "FeedbackMetadataArrayMap"),
-  ("read_only_space", 0x029a9): (176, "ArrayListMap"),
-  ("read_only_space", 0x029d1): (129, "BigIntMap"),
-  ("read_only_space", 0x029f9): (187, "ObjectBoilerplateDescriptionMap"),
-  ("read_only_space", 0x02a21): (190, "BytecodeArrayMap"),
-  ("read_only_space", 0x02a49): (236, "CodeDataContainerMap"),
-  ("read_only_space", 0x02a71): (237, "CoverageInfoMap"),
-  ("read_only_space", 0x02a99): (191, "FixedDoubleArrayMap"),
-  ("read_only_space", 0x02ac1): (179, "GlobalDictionaryMap"),
-  ("read_only_space", 0x02ae9): (157, "ManyClosuresCellMap"),
-  ("read_only_space", 0x02b11): (246, "MegaDomHandlerMap"),
-  ("read_only_space", 0x02b39): (176, "ModuleInfoMap"),
-  ("read_only_space", 0x02b61): (180, "NameDictionaryMap"),
-  ("read_only_space", 0x02b89): (157, "NoClosuresCellMap"),
-  ("read_only_space", 0x02bb1): (181, "NumberDictionaryMap"),
-  ("read_only_space", 0x02bd9): (157, "OneClosureCellMap"),
-  ("read_only_space", 0x02c01): (182, "OrderedHashMapMap"),
-  ("read_only_space", 0x02c29): (183, "OrderedHashSetMap"),
-  ("read_only_space", 0x02c51): (184, "OrderedNameDictionaryMap"),
-  ("read_only_space", 0x02c79): (248, "PreparseDataMap"),
-  ("read_only_space", 0x02ca1): (249, "PropertyArrayMap"),
-  ("read_only_space", 0x02cc9): (153, "SideEffectCallHandlerInfoMap"),
-  ("read_only_space", 0x02cf1): (153, "SideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x02d19): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x02d41): (185, "SimpleNumberDictionaryMap"),
-  ("read_only_space", 0x02d69): (223, "SmallOrderedHashMapMap"),
-  ("read_only_space", 0x02d91): (224, "SmallOrderedHashSetMap"),
-  ("read_only_space", 0x02db9): (225, "SmallOrderedNameDictionaryMap"),
-  ("read_only_space", 0x02de1): (230, "SourceTextModuleMap"),
-  ("read_only_space", 0x02e09): (256, "SwissNameDictionaryMap"),
-  ("read_only_space", 0x02e31): (231, "SyntheticModuleMap"),
-  ("read_only_space", 0x02e59): (257, "WasmApiFunctionRefMap"),
-  ("read_only_space", 0x02e81): (217, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x02ea9): (218, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x02ed1): (205, "WasmInternalFunctionMap"),
-  ("read_only_space", 0x02ef9): (219, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x02f21): (206, "WasmTypeInfoMap"),
-  ("read_only_space", 0x02f49): (232, "WeakFixedArrayMap"),
-  ("read_only_space", 0x02f71): (178, "EphemeronHashTableMap"),
-  ("read_only_space", 0x02f99): (238, "EmbedderDataArrayMap"),
-  ("read_only_space", 0x02fc1): (259, "WeakCellMap"),
-  ("read_only_space", 0x02fe9): (32, "StringMap"),
-  ("read_only_space", 0x03011): (41, "ConsOneByteStringMap"),
-  ("read_only_space", 0x03039): (33, "ConsStringMap"),
-  ("read_only_space", 0x03061): (37, "ThinStringMap"),
-  ("read_only_space", 0x03089): (35, "SlicedStringMap"),
-  ("read_only_space", 0x030b1): (43, "SlicedOneByteStringMap"),
-  ("read_only_space", 0x030d9): (34, "ExternalStringMap"),
-  ("read_only_space", 0x03101): (42, "ExternalOneByteStringMap"),
-  ("read_only_space", 0x03129): (50, "UncachedExternalStringMap"),
-  ("read_only_space", 0x03151): (0, "InternalizedStringMap"),
-  ("read_only_space", 0x03179): (2, "ExternalInternalizedStringMap"),
-  ("read_only_space", 0x031a1): (10, "ExternalOneByteInternalizedStringMap"),
-  ("read_only_space", 0x031c9): (18, "UncachedExternalInternalizedStringMap"),
-  ("read_only_space", 0x031f1): (26, "UncachedExternalOneByteInternalizedStringMap"),
-  ("read_only_space", 0x03219): (58, "UncachedExternalOneByteStringMap"),
-  ("read_only_space", 0x03241): (104, "SharedOneByteStringMap"),
-  ("read_only_space", 0x03269): (96, "SharedStringMap"),
-  ("read_only_space", 0x03291): (109, "SharedThinOneByteStringMap"),
-  ("read_only_space", 0x032b9): (101, "SharedThinStringMap"),
-  ("read_only_space", 0x032e1): (96, "TwoByteSeqStringMigrationSentinelMap"),
-  ("read_only_space", 0x03309): (104, "OneByteSeqStringMigrationSentinelMap"),
-  ("read_only_space", 0x03331): (131, "SelfReferenceMarkerMap"),
-  ("read_only_space", 0x03359): (131, "BasicBlockCountersMarkerMap"),
-  ("read_only_space", 0x0339d): (147, "ArrayBoilerplateDescriptionMap"),
-  ("read_only_space", 0x0349d): (159, "InterceptorInfoMap"),
-  ("read_only_space", 0x05d11): (132, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x05d39): (133, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x05d61): (134, "CallableTaskMap"),
-  ("read_only_space", 0x05d89): (135, "CallbackTaskMap"),
-  ("read_only_space", 0x05db1): (136, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x05dd9): (139, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x05e01): (140, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x05e29): (141, "AccessCheckInfoMap"),
-  ("read_only_space", 0x05e51): (142, "AccessorInfoMap"),
-  ("read_only_space", 0x05e79): (143, "AccessorPairMap"),
-  ("read_only_space", 0x05ea1): (144, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x05ec9): (145, "AllocationMementoMap"),
-  ("read_only_space", 0x05ef1): (148, "AsmWasmDataMap"),
-  ("read_only_space", 0x05f19): (149, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x05f41): (150, "BreakPointMap"),
-  ("read_only_space", 0x05f69): (151, "BreakPointInfoMap"),
-  ("read_only_space", 0x05f91): (152, "CachedTemplateObjectMap"),
-  ("read_only_space", 0x05fb9): (154, "ClassPositionsMap"),
-  ("read_only_space", 0x05fe1): (155, "DebugInfoMap"),
-  ("read_only_space", 0x06009): (158, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x06031): (160, "InterpreterDataMap"),
-  ("read_only_space", 0x06059): (161, "ModuleRequestMap"),
-  ("read_only_space", 0x06081): (162, "PromiseCapabilityMap"),
-  ("read_only_space", 0x060a9): (163, "PromiseReactionMap"),
-  ("read_only_space", 0x060d1): (164, "PropertyDescriptorObjectMap"),
-  ("read_only_space", 0x060f9): (165, "PrototypeInfoMap"),
-  ("read_only_space", 0x06121): (166, "RegExpBoilerplateDescriptionMap"),
-  ("read_only_space", 0x06149): (167, "ScriptMap"),
-  ("read_only_space", 0x06171): (168, "ScriptOrModuleMap"),
-  ("read_only_space", 0x06199): (169, "SourceTextModuleInfoEntryMap"),
-  ("read_only_space", 0x061c1): (170, "StackFrameInfoMap"),
-  ("read_only_space", 0x061e9): (171, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x06211): (172, "Tuple2Map"),
-  ("read_only_space", 0x06239): (173, "WasmContinuationObjectMap"),
-  ("read_only_space", 0x06261): (174, "WasmExceptionTagMap"),
-  ("read_only_space", 0x06289): (175, "WasmIndirectFunctionTableMap"),
-  ("read_only_space", 0x062b1): (193, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x062d9): (228, "DescriptorArrayMap"),
-  ("read_only_space", 0x06301): (214, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x06329): (212, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x06351): (215, "UncompiledDataWithoutPreparseDataWithJobMap"),
-  ("read_only_space", 0x06379): (213, "UncompiledDataWithPreparseDataAndJobMap"),
-  ("read_only_space", 0x063a1): (247, "OnHeapBasicBlockProfilerDataMap"),
-  ("read_only_space", 0x063c9): (207, "TurbofanBitsetTypeMap"),
-  ("read_only_space", 0x063f1): (211, "TurbofanUnionTypeMap"),
-  ("read_only_space", 0x06419): (210, "TurbofanRangeTypeMap"),
-  ("read_only_space", 0x06441): (208, "TurbofanHeapConstantTypeMap"),
-  ("read_only_space", 0x06469): (209, "TurbofanOtherNumberConstantTypeMap"),
-  ("read_only_space", 0x06491): (243, "InternalClassMap"),
-  ("read_only_space", 0x064b9): (254, "SmiPairMap"),
-  ("read_only_space", 0x064e1): (253, "SmiBoxMap"),
-  ("read_only_space", 0x06509): (220, "ExportedSubClassBaseMap"),
-  ("read_only_space", 0x06531): (221, "ExportedSubClassMap"),
-  ("read_only_space", 0x06559): (226, "AbstractInternalClassSubclass1Map"),
-  ("read_only_space", 0x06581): (227, "AbstractInternalClassSubclass2Map"),
-  ("read_only_space", 0x065a9): (192, "InternalClassWithSmiElementsMap"),
-  ("read_only_space", 0x065d1): (244, "InternalClassWithStructElementsMap"),
-  ("read_only_space", 0x065f9): (222, "ExportedSubClass2Map"),
-  ("read_only_space", 0x06621): (255, "SortStateMap"),
-  ("read_only_space", 0x06649): (146, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x06671): (146, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x06699): (137, "LoadHandler1Map"),
-  ("read_only_space", 0x066c1): (137, "LoadHandler2Map"),
-  ("read_only_space", 0x066e9): (137, "LoadHandler3Map"),
-  ("read_only_space", 0x06711): (138, "StoreHandler0Map"),
-  ("read_only_space", 0x06739): (138, "StoreHandler1Map"),
-  ("read_only_space", 0x06761): (138, "StoreHandler2Map"),
-  ("read_only_space", 0x06789): (138, "StoreHandler3Map"),
-  ("map_space", 0x02119): (1057, "ExternalMap"),
-  ("map_space", 0x02141): (2114, "JSMessageObjectMap"),
+  ("read_only_space", 0x02131): (245, "MetaMap"),
+  ("read_only_space", 0x02159): (131, "NullMap"),
+  ("read_only_space", 0x02181): (229, "StrongDescriptorArrayMap"),
+  ("read_only_space", 0x021a9): (258, "WeakArrayListMap"),
+  ("read_only_space", 0x021ed): (156, "EnumCacheMap"),
+  ("read_only_space", 0x02221): (176, "FixedArrayMap"),
+  ("read_only_space", 0x0226d): (8, "OneByteInternalizedStringMap"),
+  ("read_only_space", 0x022b9): (242, "FreeSpaceMap"),
+  ("read_only_space", 0x022e1): (241, "OnePointerFillerMap"),
+  ("read_only_space", 0x02309): (241, "TwoPointerFillerMap"),
+  ("read_only_space", 0x02331): (131, "UninitializedMap"),
+  ("read_only_space", 0x023a9): (131, "UndefinedMap"),
+  ("read_only_space", 0x023ed): (130, "HeapNumberMap"),
+  ("read_only_space", 0x02421): (131, "TheHoleMap"),
+  ("read_only_space", 0x02481): (131, "BooleanMap"),
+  ("read_only_space", 0x02525): (189, "ByteArrayMap"),
+  ("read_only_space", 0x0254d): (176, "FixedCOWArrayMap"),
+  ("read_only_space", 0x02575): (177, "HashTableMap"),
+  ("read_only_space", 0x0259d): (128, "SymbolMap"),
+  ("read_only_space", 0x025c5): (40, "OneByteStringMap"),
+  ("read_only_space", 0x025ed): (251, "ScopeInfoMap"),
+  ("read_only_space", 0x02615): (252, "SharedFunctionInfoMap"),
+  ("read_only_space", 0x0263d): (235, "CodeMap"),
+  ("read_only_space", 0x02665): (234, "CellMap"),
+  ("read_only_space", 0x0268d): (250, "GlobalPropertyCellMap"),
+  ("read_only_space", 0x026b5): (204, "ForeignMap"),
+  ("read_only_space", 0x026dd): (233, "TransitionArrayMap"),
+  ("read_only_space", 0x02705): (45, "ThinOneByteStringMap"),
+  ("read_only_space", 0x0272d): (240, "FeedbackVectorMap"),
+  ("read_only_space", 0x02765): (131, "ArgumentsMarkerMap"),
+  ("read_only_space", 0x027c5): (131, "ExceptionMap"),
+  ("read_only_space", 0x02821): (131, "TerminationExceptionMap"),
+  ("read_only_space", 0x02889): (131, "OptimizedOutMap"),
+  ("read_only_space", 0x028e9): (131, "StaleRegisterMap"),
+  ("read_only_space", 0x02949): (188, "ScriptContextTableMap"),
+  ("read_only_space", 0x02971): (186, "ClosureFeedbackCellArrayMap"),
+  ("read_only_space", 0x02999): (239, "FeedbackMetadataArrayMap"),
+  ("read_only_space", 0x029c1): (176, "ArrayListMap"),
+  ("read_only_space", 0x029e9): (129, "BigIntMap"),
+  ("read_only_space", 0x02a11): (187, "ObjectBoilerplateDescriptionMap"),
+  ("read_only_space", 0x02a39): (190, "BytecodeArrayMap"),
+  ("read_only_space", 0x02a61): (236, "CodeDataContainerMap"),
+  ("read_only_space", 0x02a89): (237, "CoverageInfoMap"),
+  ("read_only_space", 0x02ab1): (191, "FixedDoubleArrayMap"),
+  ("read_only_space", 0x02ad9): (179, "GlobalDictionaryMap"),
+  ("read_only_space", 0x02b01): (157, "ManyClosuresCellMap"),
+  ("read_only_space", 0x02b29): (246, "MegaDomHandlerMap"),
+  ("read_only_space", 0x02b51): (176, "ModuleInfoMap"),
+  ("read_only_space", 0x02b79): (180, "NameDictionaryMap"),
+  ("read_only_space", 0x02ba1): (157, "NoClosuresCellMap"),
+  ("read_only_space", 0x02bc9): (181, "NumberDictionaryMap"),
+  ("read_only_space", 0x02bf1): (157, "OneClosureCellMap"),
+  ("read_only_space", 0x02c19): (182, "OrderedHashMapMap"),
+  ("read_only_space", 0x02c41): (183, "OrderedHashSetMap"),
+  ("read_only_space", 0x02c69): (184, "OrderedNameDictionaryMap"),
+  ("read_only_space", 0x02c91): (248, "PreparseDataMap"),
+  ("read_only_space", 0x02cb9): (249, "PropertyArrayMap"),
+  ("read_only_space", 0x02ce1): (153, "SideEffectCallHandlerInfoMap"),
+  ("read_only_space", 0x02d09): (153, "SideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x02d31): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x02d59): (185, "SimpleNumberDictionaryMap"),
+  ("read_only_space", 0x02d81): (223, "SmallOrderedHashMapMap"),
+  ("read_only_space", 0x02da9): (224, "SmallOrderedHashSetMap"),
+  ("read_only_space", 0x02dd1): (225, "SmallOrderedNameDictionaryMap"),
+  ("read_only_space", 0x02df9): (230, "SourceTextModuleMap"),
+  ("read_only_space", 0x02e21): (256, "SwissNameDictionaryMap"),
+  ("read_only_space", 0x02e49): (231, "SyntheticModuleMap"),
+  ("read_only_space", 0x02e71): (257, "WasmApiFunctionRefMap"),
+  ("read_only_space", 0x02e99): (217, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x02ec1): (218, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x02ee9): (205, "WasmInternalFunctionMap"),
+  ("read_only_space", 0x02f11): (219, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x02f39): (206, "WasmTypeInfoMap"),
+  ("read_only_space", 0x02f61): (232, "WeakFixedArrayMap"),
+  ("read_only_space", 0x02f89): (178, "EphemeronHashTableMap"),
+  ("read_only_space", 0x02fb1): (238, "EmbedderDataArrayMap"),
+  ("read_only_space", 0x02fd9): (259, "WeakCellMap"),
+  ("read_only_space", 0x03001): (32, "StringMap"),
+  ("read_only_space", 0x03029): (41, "ConsOneByteStringMap"),
+  ("read_only_space", 0x03051): (33, "ConsStringMap"),
+  ("read_only_space", 0x03079): (37, "ThinStringMap"),
+  ("read_only_space", 0x030a1): (35, "SlicedStringMap"),
+  ("read_only_space", 0x030c9): (43, "SlicedOneByteStringMap"),
+  ("read_only_space", 0x030f1): (34, "ExternalStringMap"),
+  ("read_only_space", 0x03119): (42, "ExternalOneByteStringMap"),
+  ("read_only_space", 0x03141): (50, "UncachedExternalStringMap"),
+  ("read_only_space", 0x03169): (0, "InternalizedStringMap"),
+  ("read_only_space", 0x03191): (2, "ExternalInternalizedStringMap"),
+  ("read_only_space", 0x031b9): (10, "ExternalOneByteInternalizedStringMap"),
+  ("read_only_space", 0x031e1): (18, "UncachedExternalInternalizedStringMap"),
+  ("read_only_space", 0x03209): (26, "UncachedExternalOneByteInternalizedStringMap"),
+  ("read_only_space", 0x03231): (58, "UncachedExternalOneByteStringMap"),
+  ("read_only_space", 0x03259): (104, "SharedOneByteStringMap"),
+  ("read_only_space", 0x03281): (96, "SharedStringMap"),
+  ("read_only_space", 0x032a9): (109, "SharedThinOneByteStringMap"),
+  ("read_only_space", 0x032d1): (101, "SharedThinStringMap"),
+  ("read_only_space", 0x032f9): (96, "TwoByteSeqStringMigrationSentinelMap"),
+  ("read_only_space", 0x03321): (104, "OneByteSeqStringMigrationSentinelMap"),
+  ("read_only_space", 0x03349): (131, "SelfReferenceMarkerMap"),
+  ("read_only_space", 0x03371): (131, "BasicBlockCountersMarkerMap"),
+  ("read_only_space", 0x033b5): (147, "ArrayBoilerplateDescriptionMap"),
+  ("read_only_space", 0x034b5): (159, "InterceptorInfoMap"),
+  ("read_only_space", 0x05d29): (132, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x05d51): (133, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x05d79): (134, "CallableTaskMap"),
+  ("read_only_space", 0x05da1): (135, "CallbackTaskMap"),
+  ("read_only_space", 0x05dc9): (136, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x05df1): (139, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x05e19): (140, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x05e41): (141, "AccessCheckInfoMap"),
+  ("read_only_space", 0x05e69): (142, "AccessorInfoMap"),
+  ("read_only_space", 0x05e91): (143, "AccessorPairMap"),
+  ("read_only_space", 0x05eb9): (144, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x05ee1): (145, "AllocationMementoMap"),
+  ("read_only_space", 0x05f09): (148, "AsmWasmDataMap"),
+  ("read_only_space", 0x05f31): (149, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x05f59): (150, "BreakPointMap"),
+  ("read_only_space", 0x05f81): (151, "BreakPointInfoMap"),
+  ("read_only_space", 0x05fa9): (152, "CachedTemplateObjectMap"),
+  ("read_only_space", 0x05fd1): (154, "ClassPositionsMap"),
+  ("read_only_space", 0x05ff9): (155, "DebugInfoMap"),
+  ("read_only_space", 0x06021): (158, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x06049): (160, "InterpreterDataMap"),
+  ("read_only_space", 0x06071): (161, "ModuleRequestMap"),
+  ("read_only_space", 0x06099): (162, "PromiseCapabilityMap"),
+  ("read_only_space", 0x060c1): (163, "PromiseReactionMap"),
+  ("read_only_space", 0x060e9): (164, "PropertyDescriptorObjectMap"),
+  ("read_only_space", 0x06111): (165, "PrototypeInfoMap"),
+  ("read_only_space", 0x06139): (166, "RegExpBoilerplateDescriptionMap"),
+  ("read_only_space", 0x06161): (167, "ScriptMap"),
+  ("read_only_space", 0x06189): (168, "ScriptOrModuleMap"),
+  ("read_only_space", 0x061b1): (169, "SourceTextModuleInfoEntryMap"),
+  ("read_only_space", 0x061d9): (170, "StackFrameInfoMap"),
+  ("read_only_space", 0x06201): (171, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x06229): (172, "Tuple2Map"),
+  ("read_only_space", 0x06251): (173, "WasmContinuationObjectMap"),
+  ("read_only_space", 0x06279): (174, "WasmExceptionTagMap"),
+  ("read_only_space", 0x062a1): (175, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x062c9): (193, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x062f1): (228, "DescriptorArrayMap"),
+  ("read_only_space", 0x06319): (214, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x06341): (212, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x06369): (215, "UncompiledDataWithoutPreparseDataWithJobMap"),
+  ("read_only_space", 0x06391): (213, "UncompiledDataWithPreparseDataAndJobMap"),
+  ("read_only_space", 0x063b9): (247, "OnHeapBasicBlockProfilerDataMap"),
+  ("read_only_space", 0x063e1): (207, "TurbofanBitsetTypeMap"),
+  ("read_only_space", 0x06409): (211, "TurbofanUnionTypeMap"),
+  ("read_only_space", 0x06431): (210, "TurbofanRangeTypeMap"),
+  ("read_only_space", 0x06459): (208, "TurbofanHeapConstantTypeMap"),
+  ("read_only_space", 0x06481): (209, "TurbofanOtherNumberConstantTypeMap"),
+  ("read_only_space", 0x064a9): (243, "InternalClassMap"),
+  ("read_only_space", 0x064d1): (254, "SmiPairMap"),
+  ("read_only_space", 0x064f9): (253, "SmiBoxMap"),
+  ("read_only_space", 0x06521): (220, "ExportedSubClassBaseMap"),
+  ("read_only_space", 0x06549): (221, "ExportedSubClassMap"),
+  ("read_only_space", 0x06571): (226, "AbstractInternalClassSubclass1Map"),
+  ("read_only_space", 0x06599): (227, "AbstractInternalClassSubclass2Map"),
+  ("read_only_space", 0x065c1): (192, "InternalClassWithSmiElementsMap"),
+  ("read_only_space", 0x065e9): (244, "InternalClassWithStructElementsMap"),
+  ("read_only_space", 0x06611): (222, "ExportedSubClass2Map"),
+  ("read_only_space", 0x06639): (255, "SortStateMap"),
+  ("read_only_space", 0x06661): (146, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x06689): (146, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x066b1): (137, "LoadHandler1Map"),
+  ("read_only_space", 0x066d9): (137, "LoadHandler2Map"),
+  ("read_only_space", 0x06701): (137, "LoadHandler3Map"),
+  ("read_only_space", 0x06729): (138, "StoreHandler0Map"),
+  ("read_only_space", 0x06751): (138, "StoreHandler1Map"),
+  ("read_only_space", 0x06779): (138, "StoreHandler2Map"),
+  ("read_only_space", 0x067a1): (138, "StoreHandler3Map"),
+  ("map_space", 0x02131): (1057, "ExternalMap"),
+  ("map_space", 0x02159): (2114, "JSMessageObjectMap"),
 }
 
 # List of known V8 objects.
 KNOWN_OBJECTS = {
-  ("read_only_space", 0x021b9): "EmptyWeakArrayList",
-  ("read_only_space", 0x021c5): "EmptyDescriptorArray",
-  ("read_only_space", 0x021fd): "EmptyEnumCache",
-  ("read_only_space", 0x02231): "EmptyFixedArray",
-  ("read_only_space", 0x02239): "NullValue",
-  ("read_only_space", 0x02341): "UninitializedValue",
-  ("read_only_space", 0x023b9): "UndefinedValue",
-  ("read_only_space", 0x023fd): "NanValue",
-  ("read_only_space", 0x02431): "TheHoleValue",
-  ("read_only_space", 0x0245d): "HoleNanValue",
-  ("read_only_space", 0x02491): "TrueValue",
-  ("read_only_space", 0x024d1): "FalseValue",
-  ("read_only_space", 0x02501): "empty_string",
-  ("read_only_space", 0x0273d): "EmptyScopeInfo",
-  ("read_only_space", 0x02775): "ArgumentsMarker",
-  ("read_only_space", 0x027d5): "Exception",
-  ("read_only_space", 0x02831): "TerminationException",
-  ("read_only_space", 0x02899): "OptimizedOut",
-  ("read_only_space", 0x028f9): "StaleRegister",
-  ("read_only_space", 0x03381): "EmptyPropertyArray",
-  ("read_only_space", 0x03389): "EmptyByteArray",
-  ("read_only_space", 0x03391): "EmptyObjectBoilerplateDescription",
-  ("read_only_space", 0x033c5): "EmptyArrayBoilerplateDescription",
-  ("read_only_space", 0x033d1): "EmptyClosureFeedbackCellArray",
-  ("read_only_space", 0x033d9): "EmptySlowElementDictionary",
-  ("read_only_space", 0x033fd): "EmptyOrderedHashMap",
-  ("read_only_space", 0x03411): "EmptyOrderedHashSet",
-  ("read_only_space", 0x03425): "EmptyFeedbackMetadata",
-  ("read_only_space", 0x03431): "EmptyPropertyDictionary",
-  ("read_only_space", 0x03459): "EmptyOrderedPropertyDictionary",
-  ("read_only_space", 0x03471): "EmptySwissPropertyDictionary",
-  ("read_only_space", 0x034c5): "NoOpInterceptorInfo",
-  ("read_only_space", 0x034ed): "EmptyWeakFixedArray",
-  ("read_only_space", 0x034f5): "InfinityValue",
-  ("read_only_space", 0x03501): "MinusZeroValue",
-  ("read_only_space", 0x0350d): "MinusInfinityValue",
-  ("read_only_space", 0x03519): "SelfReferenceMarker",
-  ("read_only_space", 0x03559): "BasicBlockCountersMarker",
-  ("read_only_space", 0x0359d): "OffHeapTrampolineRelocationInfo",
-  ("read_only_space", 0x035a9): "TrampolineTrivialCodeDataContainer",
-  ("read_only_space", 0x035b5): "TrampolinePromiseRejectionCodeDataContainer",
-  ("read_only_space", 0x035c1): "GlobalThisBindingScopeInfo",
-  ("read_only_space", 0x035f1): "EmptyFunctionScopeInfo",
-  ("read_only_space", 0x03615): "NativeScopeInfo",
-  ("read_only_space", 0x0362d): "HashSeed",
-  ("old_space", 0x04211): "ArgumentsIteratorAccessor",
-  ("old_space", 0x04255): "ArrayLengthAccessor",
-  ("old_space", 0x04299): "BoundFunctionLengthAccessor",
-  ("old_space", 0x042dd): "BoundFunctionNameAccessor",
-  ("old_space", 0x04321): "ErrorStackAccessor",
-  ("old_space", 0x04365): "FunctionArgumentsAccessor",
-  ("old_space", 0x043a9): "FunctionCallerAccessor",
-  ("old_space", 0x043ed): "FunctionNameAccessor",
-  ("old_space", 0x04431): "FunctionLengthAccessor",
-  ("old_space", 0x04475): "FunctionPrototypeAccessor",
-  ("old_space", 0x044b9): "StringLengthAccessor",
-  ("old_space", 0x044fd): "InvalidPrototypeValidityCell",
-  ("old_space", 0x04505): "EmptyScript",
-  ("old_space", 0x04545): "ManyClosuresCell",
-  ("old_space", 0x04551): "ArrayConstructorProtector",
-  ("old_space", 0x04565): "NoElementsProtector",
-  ("old_space", 0x04579): "MegaDOMProtector",
-  ("old_space", 0x0458d): "IsConcatSpreadableProtector",
-  ("old_space", 0x045a1): "ArraySpeciesProtector",
-  ("old_space", 0x045b5): "TypedArraySpeciesProtector",
-  ("old_space", 0x045c9): "PromiseSpeciesProtector",
-  ("old_space", 0x045dd): "RegExpSpeciesProtector",
-  ("old_space", 0x045f1): "StringLengthProtector",
-  ("old_space", 0x04605): "ArrayIteratorProtector",
-  ("old_space", 0x04619): "ArrayBufferDetachingProtector",
-  ("old_space", 0x0462d): "PromiseHookProtector",
-  ("old_space", 0x04641): "PromiseResolveProtector",
-  ("old_space", 0x04655): "MapIteratorProtector",
-  ("old_space", 0x04669): "PromiseThenProtector",
-  ("old_space", 0x0467d): "SetIteratorProtector",
-  ("old_space", 0x04691): "StringIteratorProtector",
-  ("old_space", 0x046a5): "SingleCharacterStringCache",
-  ("old_space", 0x04aad): "StringSplitCache",
-  ("old_space", 0x04eb5): "RegExpMultipleCache",
-  ("old_space", 0x052bd): "BuiltinsConstantsTable",
-  ("old_space", 0x056e5): "AsyncFunctionAwaitRejectSharedFun",
-  ("old_space", 0x05709): "AsyncFunctionAwaitResolveSharedFun",
-  ("old_space", 0x0572d): "AsyncGeneratorAwaitRejectSharedFun",
-  ("old_space", 0x05751): "AsyncGeneratorAwaitResolveSharedFun",
-  ("old_space", 0x05775): "AsyncGeneratorYieldResolveSharedFun",
-  ("old_space", 0x05799): "AsyncGeneratorReturnResolveSharedFun",
-  ("old_space", 0x057bd): "AsyncGeneratorReturnClosedRejectSharedFun",
-  ("old_space", 0x057e1): "AsyncGeneratorReturnClosedResolveSharedFun",
-  ("old_space", 0x05805): "AsyncIteratorValueUnwrapSharedFun",
-  ("old_space", 0x05829): "PromiseAllResolveElementSharedFun",
-  ("old_space", 0x0584d): "PromiseAllSettledResolveElementSharedFun",
-  ("old_space", 0x05871): "PromiseAllSettledRejectElementSharedFun",
-  ("old_space", 0x05895): "PromiseAnyRejectElementSharedFun",
-  ("old_space", 0x058b9): "PromiseCapabilityDefaultRejectSharedFun",
-  ("old_space", 0x058dd): "PromiseCapabilityDefaultResolveSharedFun",
-  ("old_space", 0x05901): "PromiseCatchFinallySharedFun",
-  ("old_space", 0x05925): "PromiseGetCapabilitiesExecutorSharedFun",
-  ("old_space", 0x05949): "PromiseThenFinallySharedFun",
-  ("old_space", 0x0596d): "PromiseThrowerFinallySharedFun",
-  ("old_space", 0x05991): "PromiseValueThunkFinallySharedFun",
-  ("old_space", 0x059b5): "ProxyRevokeSharedFun",
+  ("read_only_space", 0x021d1): "EmptyWeakArrayList",
+  ("read_only_space", 0x021dd): "EmptyDescriptorArray",
+  ("read_only_space", 0x02215): "EmptyEnumCache",
+  ("read_only_space", 0x02249): "EmptyFixedArray",
+  ("read_only_space", 0x02251): "NullValue",
+  ("read_only_space", 0x02359): "UninitializedValue",
+  ("read_only_space", 0x023d1): "UndefinedValue",
+  ("read_only_space", 0x02415): "NanValue",
+  ("read_only_space", 0x02449): "TheHoleValue",
+  ("read_only_space", 0x02475): "HoleNanValue",
+  ("read_only_space", 0x024a9): "TrueValue",
+  ("read_only_space", 0x024e9): "FalseValue",
+  ("read_only_space", 0x02519): "empty_string",
+  ("read_only_space", 0x02755): "EmptyScopeInfo",
+  ("read_only_space", 0x0278d): "ArgumentsMarker",
+  ("read_only_space", 0x027ed): "Exception",
+  ("read_only_space", 0x02849): "TerminationException",
+  ("read_only_space", 0x028b1): "OptimizedOut",
+  ("read_only_space", 0x02911): "StaleRegister",
+  ("read_only_space", 0x03399): "EmptyPropertyArray",
+  ("read_only_space", 0x033a1): "EmptyByteArray",
+  ("read_only_space", 0x033a9): "EmptyObjectBoilerplateDescription",
+  ("read_only_space", 0x033dd): "EmptyArrayBoilerplateDescription",
+  ("read_only_space", 0x033e9): "EmptyClosureFeedbackCellArray",
+  ("read_only_space", 0x033f1): "EmptySlowElementDictionary",
+  ("read_only_space", 0x03415): "EmptyOrderedHashMap",
+  ("read_only_space", 0x03429): "EmptyOrderedHashSet",
+  ("read_only_space", 0x0343d): "EmptyFeedbackMetadata",
+  ("read_only_space", 0x03449): "EmptyPropertyDictionary",
+  ("read_only_space", 0x03471): "EmptyOrderedPropertyDictionary",
+  ("read_only_space", 0x03489): "EmptySwissPropertyDictionary",
+  ("read_only_space", 0x034dd): "NoOpInterceptorInfo",
+  ("read_only_space", 0x03505): "EmptyWeakFixedArray",
+  ("read_only_space", 0x0350d): "InfinityValue",
+  ("read_only_space", 0x03519): "MinusZeroValue",
+  ("read_only_space", 0x03525): "MinusInfinityValue",
+  ("read_only_space", 0x03531): "SelfReferenceMarker",
+  ("read_only_space", 0x03571): "BasicBlockCountersMarker",
+  ("read_only_space", 0x035b5): "OffHeapTrampolineRelocationInfo",
+  ("read_only_space", 0x035c1): "TrampolineTrivialCodeDataContainer",
+  ("read_only_space", 0x035cd): "TrampolinePromiseRejectionCodeDataContainer",
+  ("read_only_space", 0x035d9): "GlobalThisBindingScopeInfo",
+  ("read_only_space", 0x03609): "EmptyFunctionScopeInfo",
+  ("read_only_space", 0x0362d): "NativeScopeInfo",
+  ("read_only_space", 0x03645): "HashSeed",
+  ("old_space", 0x04229): "ArgumentsIteratorAccessor",
+  ("old_space", 0x0426d): "ArrayLengthAccessor",
+  ("old_space", 0x042b1): "BoundFunctionLengthAccessor",
+  ("old_space", 0x042f5): "BoundFunctionNameAccessor",
+  ("old_space", 0x04339): "ErrorStackAccessor",
+  ("old_space", 0x0437d): "FunctionArgumentsAccessor",
+  ("old_space", 0x043c1): "FunctionCallerAccessor",
+  ("old_space", 0x04405): "FunctionNameAccessor",
+  ("old_space", 0x04449): "FunctionLengthAccessor",
+  ("old_space", 0x0448d): "FunctionPrototypeAccessor",
+  ("old_space", 0x044d1): "StringLengthAccessor",
+  ("old_space", 0x04515): "InvalidPrototypeValidityCell",
+  ("old_space", 0x0451d): "EmptyScript",
+  ("old_space", 0x0455d): "ManyClosuresCell",
+  ("old_space", 0x04569): "ArrayConstructorProtector",
+  ("old_space", 0x0457d): "NoElementsProtector",
+  ("old_space", 0x04591): "MegaDOMProtector",
+  ("old_space", 0x045a5): "IsConcatSpreadableProtector",
+  ("old_space", 0x045b9): "ArraySpeciesProtector",
+  ("old_space", 0x045cd): "TypedArraySpeciesProtector",
+  ("old_space", 0x045e1): "PromiseSpeciesProtector",
+  ("old_space", 0x045f5): "RegExpSpeciesProtector",
+  ("old_space", 0x04609): "StringLengthProtector",
+  ("old_space", 0x0461d): "ArrayIteratorProtector",
+  ("old_space", 0x04631): "ArrayBufferDetachingProtector",
+  ("old_space", 0x04645): "PromiseHookProtector",
+  ("old_space", 0x04659): "PromiseResolveProtector",
+  ("old_space", 0x0466d): "MapIteratorProtector",
+  ("old_space", 0x04681): "PromiseThenProtector",
+  ("old_space", 0x04695): "SetIteratorProtector",
+  ("old_space", 0x046a9): "StringIteratorProtector",
+  ("old_space", 0x046bd): "SingleCharacterStringCache",
+  ("old_space", 0x04ac5): "StringSplitCache",
+  ("old_space", 0x04ecd): "RegExpMultipleCache",
+  ("old_space", 0x052d5): "BuiltinsConstantsTable",
+  ("old_space", 0x056fd): "AsyncFunctionAwaitRejectSharedFun",
+  ("old_space", 0x05721): "AsyncFunctionAwaitResolveSharedFun",
+  ("old_space", 0x05745): "AsyncGeneratorAwaitRejectSharedFun",
+  ("old_space", 0x05769): "AsyncGeneratorAwaitResolveSharedFun",
+  ("old_space", 0x0578d): "AsyncGeneratorYieldResolveSharedFun",
+  ("old_space", 0x057b1): "AsyncGeneratorReturnResolveSharedFun",
+  ("old_space", 0x057d5): "AsyncGeneratorReturnClosedRejectSharedFun",
+  ("old_space", 0x057f9): "AsyncGeneratorReturnClosedResolveSharedFun",
+  ("old_space", 0x0581d): "AsyncIteratorValueUnwrapSharedFun",
+  ("old_space", 0x05841): "PromiseAllResolveElementSharedFun",
+  ("old_space", 0x05865): "PromiseAllSettledResolveElementSharedFun",
+  ("old_space", 0x05889): "PromiseAllSettledRejectElementSharedFun",
+  ("old_space", 0x058ad): "PromiseAnyRejectElementSharedFun",
+  ("old_space", 0x058d1): "PromiseCapabilityDefaultRejectSharedFun",
+  ("old_space", 0x058f5): "PromiseCapabilityDefaultResolveSharedFun",
+  ("old_space", 0x05919): "PromiseCatchFinallySharedFun",
+  ("old_space", 0x0593d): "PromiseGetCapabilitiesExecutorSharedFun",
+  ("old_space", 0x05961): "PromiseThenFinallySharedFun",
+  ("old_space", 0x05985): "PromiseThrowerFinallySharedFun",
+  ("old_space", 0x059a9): "PromiseValueThunkFinallySharedFun",
+  ("old_space", 0x059cd): "ProxyRevokeSharedFun",
 }
 
 # Lower 32 bits of first page addresses for various heap spaces.