[heap] Merge marking states

MinorMC maintained a separate marking state to support interleaved GCs.
Since MinorMC now assumes that interleaving is not possible, MinorMC can
use the same marking state as the full GC.

Bug: v8:12612
Change-Id: Ibeb7df2eb24e448f811b497c9d16b3b132f87ec2
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3735163Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: Omer Katz <omerkatz@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81468}

src/heap/basic-memory-chunk.h

@@ -367,12 +367,10 @@ class BasicMemoryChunk {
 
   friend class BasicMemoryChunkValidator;
   friend class ConcurrentMarkingState;
-  friend class MajorMarkingState;
-  friend class MajorAtomicMarkingState;
-  friend class MajorNonAtomicMarkingState;
+  friend class MarkingState;
+  friend class AtomicMarkingState;
+  friend class NonAtomicMarkingState;
   friend class MemoryAllocator;
-  friend class MinorMarkingState;
-  friend class MinorNonAtomicMarkingState;
   friend class PagedSpace;
 };
 

src/heap/concurrent-marking.cc

@@ -652,7 +652,7 @@ void ConcurrentMarking::FlushNativeContexts(NativeContextStats* main_stats) {
 }
 
 void ConcurrentMarking::FlushMemoryChunkData(
-    MajorNonAtomicMarkingState* marking_state) {
+    NonAtomicMarkingState* marking_state) {
   DCHECK(!job_handle_ || !job_handle_->IsValid());
   for (int i = 1; i <= kMaxTasks; i++) {
     MemoryChunkDataMap& memory_chunk_data = task_state_[i].memory_chunk_data;

src/heap/concurrent-marking.h

@@ -26,7 +26,7 @@ namespace internal {
 
 class Heap;
 class Isolate;
-class MajorNonAtomicMarkingState;
+class NonAtomicMarkingState;
 class MemoryChunk;
 class WeakObjects;
 
@@ -80,7 +80,7 @@ class V8_EXPORT_PRIVATE ConcurrentMarking {
   // Flushes native context sizes to the given table of the main thread.
   void FlushNativeContexts(NativeContextStats* main_stats);
   // Flushes memory chunk data using the given marking state.
-  void FlushMemoryChunkData(MajorNonAtomicMarkingState* marking_state);
+  void FlushMemoryChunkData(NonAtomicMarkingState* marking_state);
   // This function is called for a new space page that was cleared after
   // scavenge and is going to be re-used.
   void ClearMemoryChunkData(MemoryChunk* chunk);

src/heap/cppgc-js/unified-heap-marking-state.h

@@ -28,7 +28,7 @@ class UnifiedHeapMarkingState final {
 
  private:
   Heap* const heap_;
-  MarkCompactCollector::MarkingState* const marking_state_;
+  MarkingState* const marking_state_;
   MarkingWorklists::Local* local_marking_worklist_ = nullptr;
   const bool track_retaining_path_;
 };

src/heap/incremental-marking.cc

@@ -375,7 +375,7 @@ void IncrementalMarking::UpdateMarkingWorklistAfterYoungGenGC() {
 
   Map filler_map = ReadOnlyRoots(heap_).one_pointer_filler_map();
 
-  MinorMarkCompactCollector::MarkingState* minor_marking_state =
+  MarkingState* minor_marking_state =
       heap()->minor_mark_compact_collector()->marking_state();
 
   collector_->local_marking_worklists()->Publish();

src/heap/incremental-marking.h

@@ -39,10 +39,6 @@ class V8_EXPORT_PRIVATE IncrementalMarking final {
   //   is triggered via stack guard.
   enum class CompletionAction { kGcViaStackGuard, kGCViaTask };
 
-  using MarkingState = MarkCompactCollector::MarkingState;
-  using AtomicMarkingState = MarkCompactCollector::AtomicMarkingState;
-  using NonAtomicMarkingState = MarkCompactCollector::NonAtomicMarkingState;
-
   class V8_NODISCARD PauseBlackAllocationScope {
    public:
     explicit PauseBlackAllocationScope(IncrementalMarking* marking)

src/heap/invalidated-slots.h

@@ -23,7 +23,7 @@ namespace internal {
 // change.
 using InvalidatedSlots = std::map<HeapObject, int, Object::Comparer>;
 
-class MajorNonAtomicMarkingState;
+class NonAtomicMarkingState;
 
 // This class provides IsValid predicate that takes into account the set
 // of invalidated objects in the given memory chunk.
@@ -64,7 +64,7 @@ class V8_EXPORT_PRIVATE InvalidatedSlotsFilter {
   Address sentinel_;
   InvalidatedObjectInfo current_{kNullAddress, 0, false};
   InvalidatedObjectInfo next_{kNullAddress, 0, false};
-  MajorNonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
   InvalidatedSlots empty_;
 #ifdef DEBUG
   Address last_slot_;

src/heap/large-spaces.cc

@@ -500,7 +500,6 @@ AllocationResult NewLargeObjectSpace::AllocateRaw(int object_size) {
   page->SetFlag(MemoryChunk::TO_PAGE);
   UpdatePendingObject(result);
   if (FLAG_minor_mc) {
-    page->AllocateYoungGenerationBitmap();
     heap()
         ->minor_mark_compact_collector()
         ->non_atomic_marking_state()

src/heap/mark-compact.cc

@@ -296,7 +296,7 @@ class FullMarkingVerifier : public MarkingVerifier {
     }
   }
 
-  MarkCompactCollector::NonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
 };
 
 class EvacuationVerifier : public ObjectVisitorWithCageBases,
@@ -1446,7 +1446,7 @@ class ExternalStringTableCleaner : public RootVisitor {
   void VisitRootPointers(Root root, const char* description,
                          FullObjectSlot start, FullObjectSlot end) override {
     // Visit all HeapObject pointers in [start, end).
-    MarkCompactCollector::NonAtomicMarkingState* marking_state =
+    NonAtomicMarkingState* marking_state =
         heap_->mark_compact_collector()->non_atomic_marking_state();
     Object the_hole = ReadOnlyRoots(heap_).the_hole_value();
     for (FullObjectSlot p = start; p < end; ++p) {
@@ -1475,8 +1475,7 @@ class ExternalStringTableCleaner : public RootVisitor {
 // are retained.
 class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
  public:
-  explicit MarkCompactWeakObjectRetainer(
-      MarkCompactCollector::MarkingState* marking_state)
+  explicit MarkCompactWeakObjectRetainer(MarkingState* marking_state)
       : marking_state_(marking_state) {}
 
   Object RetainAs(Object object) override {
@@ -1506,7 +1505,7 @@ class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
   }
 
  private:
-  MarkCompactCollector::MarkingState* const marking_state_;
+  MarkingState* const marking_state_;
 };
 
 class RecordMigratedSlotVisitor : public ObjectVisitorWithCageBases {
@@ -2534,8 +2533,7 @@ void MarkCompactCollector::RecordObjectStats() {
 
 namespace {
 
-bool ShouldRetainMap(MarkCompactCollector::MarkingState* marking_state, Map map,
-                     int age) {
+bool ShouldRetainMap(MarkingState* marking_state, Map map, int age) {
   if (age == 0) {
     // The map has aged. Do not retain this map.
     return false;
@@ -4025,8 +4023,7 @@ class FullEvacuator : public Evacuator {
 
 void FullEvacuator::RawEvacuatePage(MemoryChunk* chunk, intptr_t* live_bytes) {
   const EvacuationMode evacuation_mode = ComputeEvacuationMode(chunk);
-  MarkCompactCollector::NonAtomicMarkingState* marking_state =
-      collector_->non_atomic_marking_state();
+  NonAtomicMarkingState* marking_state = collector_->non_atomic_marking_state();
   *live_bytes = marking_state->live_bytes(chunk);
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("v8.gc"),
                "FullEvacuator::RawEvacuatePage", "evacuation_mode",
@@ -5005,10 +5002,9 @@ void MarkCompactCollector::ReportAbortedEvacuationCandidateDueToFlags(
 
 namespace {
 
-void ReRecordPage(
-    Heap* heap,
-    v8::internal::MarkCompactCollector::NonAtomicMarkingState* marking_state,
-    Address failed_start, Page* page) {
+void ReRecordPage(Heap* heap,
+                  v8::internal::NonAtomicMarkingState* marking_state,
+                  Address failed_start, Page* page) {
   page->SetFlag(Page::COMPACTION_WAS_ABORTED);
   // Aborted compaction page. We have to record slots here, since we
   // might not have recorded them in first place.
@@ -5266,7 +5262,7 @@ class YoungGenerationMarkingVerifier : public MarkingVerifier {
     }
   }
 
-  MinorMarkCompactCollector::NonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
 };
 
 class YoungGenerationEvacuationVerifier : public EvacuationVerifier {
@@ -5342,7 +5338,7 @@ class YoungGenerationMarkingVisitor final
     : public NewSpaceVisitor<YoungGenerationMarkingVisitor> {
  public:
   YoungGenerationMarkingVisitor(
-      Isolate* isolate, MinorMarkCompactCollector::MarkingState* marking_state,
+      Isolate* isolate, MarkingState* marking_state,
       MinorMarkCompactCollector::MarkingWorklist::Local* worklist_local)
       : NewSpaceVisitor(isolate),
         worklist_local_(worklist_local),
@@ -5418,7 +5414,7 @@ class YoungGenerationMarkingVisitor final
   }
 
   MinorMarkCompactCollector::MarkingWorklist::Local* worklist_local_;
-  MinorMarkCompactCollector::MarkingState* marking_state_;
+  MarkingState* marking_state_;
 };
 
 void MinorMarkCompactCollector::SetUp() {}
@@ -5624,6 +5620,11 @@ class MinorMarkCompactCollector::RootMarkingVisitor : public RootVisitor {
 
 void MinorMarkCompactCollector::CollectGarbage() {
   DCHECK(!heap()->mark_compact_collector()->in_use());
+#ifdef VERIFY_HEAP
+  for (Page* page : *heap()->new_space()) {
+    CHECK(page->marking_bitmap<AccessMode::NON_ATOMIC>()->IsClean());
+  }
+#endif  // VERIFY_HEAP
   // Minor MC does not support processing the ephemeron remembered set.
   DCHECK(heap()->ephemeron_remembered_set_.empty());
 
@@ -5758,7 +5759,7 @@ class YoungGenerationExternalStringTableCleaner : public RootVisitor {
 
  private:
   Heap* heap_;
-  MinorMarkCompactCollector::NonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
 };
 
 }  // namespace
@@ -5856,7 +5857,7 @@ class YoungGenerationMarkingTask {
 
  private:
   MinorMarkCompactCollector::MarkingWorklist::Local marking_worklist_local_;
-  MinorMarkCompactCollector::MarkingState* marking_state_;
+  MarkingState* marking_state_;
   YoungGenerationMarkingVisitor visitor_;
 };
 
@@ -6212,8 +6213,7 @@ void YoungGenerationEvacuator::RawEvacuatePage(MemoryChunk* chunk,
                                                intptr_t* live_bytes) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.gc"),
                "YoungGenerationEvacuator::RawEvacuatePage");
-  MinorMarkCompactCollector::NonAtomicMarkingState* marking_state =
-      collector_->non_atomic_marking_state();
+  NonAtomicMarkingState* marking_state = collector_->non_atomic_marking_state();
   *live_bytes = marking_state->live_bytes(chunk);
   switch (ComputeEvacuationMode(chunk)) {
     case kObjectsNewToOld:

src/heap/mark-compact.h

@@ -184,65 +184,11 @@ enum class AlwaysPromoteYoung { kYes, kNo };
 enum PageEvacuationMode { NEW_TO_NEW, NEW_TO_OLD };
 enum class RememberedSetUpdatingMode { ALL, OLD_TO_NEW_ONLY };
 
-class MinorMarkingState final
-    : public MarkingStateBase<MinorMarkingState, AccessMode::ATOMIC> {
- public:
-  explicit MinorMarkingState(PtrComprCageBase cage_base)
-      : MarkingStateBase(cage_base) {}
-
-  ConcurrentBitmap<AccessMode::ATOMIC>* bitmap(
-      const BasicMemoryChunk* chunk) const {
-    return MemoryChunk::cast(chunk)
-        ->young_generation_bitmap<AccessMode::ATOMIC>();
-  }
-
-  void IncrementLiveBytes(MemoryChunk* chunk, intptr_t by) {
-    chunk->young_generation_live_byte_count_ += by;
-  }
-
-  intptr_t live_bytes(const MemoryChunk* chunk) const {
-    return chunk->young_generation_live_byte_count_;
-  }
-
-  void SetLiveBytes(MemoryChunk* chunk, intptr_t value) {
-    chunk->young_generation_live_byte_count_ = value;
-  }
-};
-
-class MinorNonAtomicMarkingState final
-    : public MarkingStateBase<MinorNonAtomicMarkingState,
-                              AccessMode::NON_ATOMIC> {
- public:
-  explicit MinorNonAtomicMarkingState(PtrComprCageBase cage_base)
-      : MarkingStateBase(cage_base) {}
-
-  ConcurrentBitmap<AccessMode::NON_ATOMIC>* bitmap(
-      const BasicMemoryChunk* chunk) const {
-    return MemoryChunk::cast(chunk)
-        ->young_generation_bitmap<AccessMode::NON_ATOMIC>();
-  }
-
-  void IncrementLiveBytes(MemoryChunk* chunk, intptr_t by) {
-    chunk->young_generation_live_byte_count_.fetch_add(
-        by, std::memory_order_relaxed);
-  }
-
-  intptr_t live_bytes(const MemoryChunk* chunk) const {
-    return chunk->young_generation_live_byte_count_.load(
-        std::memory_order_relaxed);
-  }
-
-  void SetLiveBytes(MemoryChunk* chunk, intptr_t value) {
-    chunk->young_generation_live_byte_count_.store(value,
-                                                   std::memory_order_relaxed);
-  }
-};
-
 // This is used by marking visitors.
-class MajorMarkingState final
-    : public MarkingStateBase<MajorMarkingState, AccessMode::ATOMIC> {
+class MarkingState final
+    : public MarkingStateBase<MarkingState, AccessMode::ATOMIC> {
  public:
-  explicit MajorMarkingState(PtrComprCageBase cage_base)
+  explicit MarkingState(PtrComprCageBase cage_base)
       : MarkingStateBase(cage_base) {}
 
   ConcurrentBitmap<AccessMode::ATOMIC>* bitmap(
@@ -267,10 +213,10 @@ class MajorMarkingState final
 
 // This is used by Scavenger and Evacuator in TransferColor.
 // Live byte increments have to be atomic.
-class MajorAtomicMarkingState final
-    : public MarkingStateBase<MajorAtomicMarkingState, AccessMode::ATOMIC> {
+class AtomicMarkingState final
+    : public MarkingStateBase<AtomicMarkingState, AccessMode::ATOMIC> {
  public:
-  explicit MajorAtomicMarkingState(PtrComprCageBase cage_base)
+  explicit AtomicMarkingState(PtrComprCageBase cage_base)
       : MarkingStateBase(cage_base) {}
 
   ConcurrentBitmap<AccessMode::ATOMIC>* bitmap(
@@ -283,11 +229,10 @@ class MajorAtomicMarkingState final
   }
 };
 
-class MajorNonAtomicMarkingState final
-    : public MarkingStateBase<MajorNonAtomicMarkingState,
-                              AccessMode::NON_ATOMIC> {
+class NonAtomicMarkingState final
+    : public MarkingStateBase<NonAtomicMarkingState, AccessMode::NON_ATOMIC> {
  public:
-  explicit MajorNonAtomicMarkingState(PtrComprCageBase cage_base)
+  explicit NonAtomicMarkingState(PtrComprCageBase cage_base)
       : MarkingStateBase(cage_base) {}
 
   ConcurrentBitmap<AccessMode::NON_ATOMIC>* bitmap(
@@ -387,10 +332,6 @@ class MainMarkingVisitor final
 // Collector for young and old generation.
 class MarkCompactCollector final {
  public:
-  using MarkingState = MajorMarkingState;
-  using AtomicMarkingState = MajorAtomicMarkingState;
-  using NonAtomicMarkingState = MajorNonAtomicMarkingState;
-
   using MarkingVisitor = MainMarkingVisitor<MarkingState>;
 
   class RootMarkingVisitor;
@@ -816,9 +757,6 @@ class V8_NODISCARD EvacuationScope {
 // Collector for young-generation only.
 class MinorMarkCompactCollector final {
  public:
-  using MarkingState = MinorMarkingState;
-  using NonAtomicMarkingState = MinorNonAtomicMarkingState;
-
   static constexpr size_t kMaxParallelTasks = 8;
 
   explicit MinorMarkCompactCollector(Heap* heap);

src/heap/marking-barrier.h

@@ -44,7 +44,7 @@ class MarkingBarrier {
   inline bool MarkValue(HeapObject host, HeapObject value);
 
  private:
-  using MarkingState = MarkCompactCollector::MarkingState;
+  using MarkingState = MarkingState;
 
   inline bool WhiteToGreyAndPush(HeapObject value);
 

src/heap/memory-chunk-layout.h

@@ -66,8 +66,6 @@ class V8_EXPORT_PRIVATE MemoryChunkLayout {
     FIELD(std::atomic<size_t>[kNumTypes], ExternalBackingStoreBytes),
     FIELD(heap::ListNode<MemoryChunk>, ListNode),
     FIELD(FreeListCategory**, Categories),
-    FIELD(std::atomic<intptr_t>, YoungGenerationLiveByteCount),
-    FIELD(Bitmap*, YoungGenerationBitmap),
     FIELD(CodeObjectRegistry*, CodeObjectRegistry),
     FIELD(PossiblyEmptyBuckets, PossiblyEmptyBuckets),
     FIELD(ActiveSystemPages, ActiveSystemPages),

src/heap/memory-chunk.cc

@@ -157,7 +157,6 @@ MemoryChunk::MemoryChunk(Heap* heap, BaseSpace* space, size_t chunk_size,
   page_protection_change_mutex_ = new base::Mutex();
   write_unprotect_counter_ = 0;
   mutex_ = new base::Mutex();
-  young_generation_bitmap_ = nullptr;
 
   external_backing_store_bytes_[ExternalBackingStoreType::kArrayBuffer] = 0;
   external_backing_store_bytes_[ExternalBackingStoreType::kExternalString] = 0;
@@ -260,8 +259,6 @@ void MemoryChunk::ReleaseAllocatedMemoryNeededForWritableChunk() {
   ReleaseInvalidatedSlots<OLD_TO_OLD>();
   ReleaseInvalidatedSlots<OLD_TO_SHARED>();
 
-  if (young_generation_bitmap_ != nullptr) ReleaseYoungGenerationBitmap();
-
   if (!IsLargePage()) {
     Page* page = static_cast<Page*>(this);
     page->ReleaseFreeListCategories();
@@ -456,18 +453,6 @@ bool MemoryChunk::RegisteredObjectWithInvalidatedSlots(HeapObject object) {
          invalidated_slots<type>()->end();
 }
 
-void MemoryChunk::AllocateYoungGenerationBitmap() {
-  DCHECK_NULL(young_generation_bitmap_);
-  young_generation_bitmap_ =
-      static_cast<Bitmap*>(base::Calloc(1, Bitmap::kSize));
-}
-
-void MemoryChunk::ReleaseYoungGenerationBitmap() {
-  DCHECK_NOT_NULL(young_generation_bitmap_);
-  base::Free(young_generation_bitmap_);
-  young_generation_bitmap_ = nullptr;
-}
-
 #ifdef DEBUG
 void MemoryChunk::ValidateOffsets(MemoryChunk* chunk) {
   // Note that we cannot use offsetof because MemoryChunk is not a POD.
@@ -502,13 +487,6 @@ void MemoryChunk::ValidateOffsets(MemoryChunk* chunk) {
             MemoryChunkLayout::kListNodeOffset);
   DCHECK_EQ(reinterpret_cast<Address>(&chunk->categories_) - chunk->address(),
             MemoryChunkLayout::kCategoriesOffset);
-  DCHECK_EQ(
-      reinterpret_cast<Address>(&chunk->young_generation_live_byte_count_) -
-          chunk->address(),
-      MemoryChunkLayout::kYoungGenerationLiveByteCountOffset);
-  DCHECK_EQ(reinterpret_cast<Address>(&chunk->young_generation_bitmap_) -
-                chunk->address(),
-            MemoryChunkLayout::kYoungGenerationBitmapOffset);
   DCHECK_EQ(reinterpret_cast<Address>(&chunk->code_object_registry_) -
                 chunk->address(),
             MemoryChunkLayout::kCodeObjectRegistryOffset);

src/heap/memory-chunk.h

@@ -152,9 +152,6 @@ class MemoryChunk : public BasicMemoryChunk {
     return invalidated_slots_[type];
   }
 
-  void AllocateYoungGenerationBitmap();
-  void ReleaseYoungGenerationBitmap();
-
   int FreeListsLength();
 
   // Approximate amount of physical memory committed for this chunk.
@@ -233,10 +230,6 @@ class MemoryChunk : public BasicMemoryChunk {
   void DecrementWriteUnprotectCounterAndMaybeSetPermissions(
       PageAllocator::Permission permission);
 
-  template <AccessMode mode>
-  ConcurrentBitmap<mode>* young_generation_bitmap() const {
-    return reinterpret_cast<ConcurrentBitmap<mode>*>(young_generation_bitmap_);
-  }
 #ifdef DEBUG
   static void ValidateOffsets(MemoryChunk* chunk);
 #endif
@@ -284,9 +277,6 @@ class MemoryChunk : public BasicMemoryChunk {
 
   FreeListCategory** categories_;
 
-  std::atomic<intptr_t> young_generation_live_byte_count_;
-  Bitmap* young_generation_bitmap_;
-
   CodeObjectRegistry* code_object_registry_;
 
   PossiblyEmptyBuckets possibly_empty_buckets_;
@@ -299,13 +289,11 @@ class MemoryChunk : public BasicMemoryChunk {
 
  private:
   friend class ConcurrentMarkingState;
-  friend class MajorMarkingState;
-  friend class MajorAtomicMarkingState;
-  friend class MajorNonAtomicMarkingState;
+  friend class MarkingState;
+  friend class AtomicMarkingState;
+  friend class NonAtomicMarkingState;
   friend class MemoryAllocator;
   friend class MemoryChunkValidator;
-  friend class MinorMarkingState;
-  friend class MinorNonAtomicMarkingState;
   friend class PagedSpace;
 };
 

src/heap/new-spaces.cc

@@ -25,7 +25,6 @@ Page* SemiSpace::InitializePage(MemoryChunk* chunk) {
   page->SetYoungGenerationPageFlags(heap()->incremental_marking()->IsMarking());
   page->list_node().Initialize();
   if (FLAG_minor_mc) {
-    page->AllocateYoungGenerationBitmap();
     heap()
         ->minor_mark_compact_collector()
         ->non_atomic_marking_state()
@@ -76,7 +75,7 @@ bool SemiSpace::EnsureCurrentCapacity() {
     }
 
     // Add more pages if we have less than expected_pages.
-    IncrementalMarking::NonAtomicMarkingState* marking_state =
+    NonAtomicMarkingState* marking_state =
         heap()->incremental_marking()->non_atomic_marking_state();
     while (actual_pages < expected_pages) {
       actual_pages++;
@@ -181,7 +180,7 @@ bool SemiSpace::GrowTo(size_t new_capacity) {
   DCHECK(IsAligned(delta, AllocatePageSize()));
   const int delta_pages = static_cast<int>(delta / Page::kPageSize);
   DCHECK(last_page());
-  IncrementalMarking::NonAtomicMarkingState* marking_state =
+  NonAtomicMarkingState* marking_state =
       heap()->incremental_marking()->non_atomic_marking_state();
   for (int pages_added = 0; pages_added < delta_pages; pages_added++) {
     Page* new_page = heap()->memory_allocator()->AllocatePage(
@@ -237,8 +236,6 @@ void SemiSpace::FixPagesFlags(Page::MainThreadFlags flags,
       page->ClearFlag(MemoryChunk::FROM_PAGE);
       page->SetFlag(MemoryChunk::TO_PAGE);
       page->ClearFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
-      heap()->incremental_marking()->non_atomic_marking_state()->SetLiveBytes(
-          page, 0);
     } else {
       page->SetFlag(MemoryChunk::FROM_PAGE);
       page->ClearFlag(MemoryChunk::TO_PAGE);
@@ -682,7 +679,7 @@ void SemiSpaceNewSpace::ResetLinearAllocationArea() {
   to_space_.Reset();
   UpdateLinearAllocationArea();
   // Clear all mark-bits in the to-space.
-  IncrementalMarking::NonAtomicMarkingState* marking_state =
+  NonAtomicMarkingState* marking_state =
       heap()->incremental_marking()->non_atomic_marking_state();
   for (Page* p : to_space_) {
     marking_state->ClearLiveness(p);

src/heap/object-stats.cc

@@ -450,7 +450,7 @@ class ObjectStatsCollectorImpl {
 
   Heap* heap_;
   ObjectStats* stats_;
-  MarkCompactCollector::NonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
   std::unordered_set<HeapObject, Object::Hasher> virtual_objects_;
   std::unordered_set<Address> external_resources_;
   FieldStatsCollector field_stats_collector_;
@@ -1103,7 +1103,7 @@ class ObjectStatsVisitor {
  private:
   ObjectStatsCollectorImpl* live_collector_;
   ObjectStatsCollectorImpl* dead_collector_;
-  MarkCompactCollector::NonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
   ObjectStatsCollectorImpl::Phase phase_;
 };
 

src/heap/paged-spaces.cc

@@ -841,8 +841,7 @@ void PagedSpaceBase::Verify(Isolate* isolate, ObjectVisitor* visitor) const {
 }
 
 void PagedSpaceBase::VerifyLiveBytes() const {
-  IncrementalMarking::MarkingState* marking_state =
-      heap()->incremental_marking()->marking_state();
+  MarkingState* marking_state = heap()->incremental_marking()->marking_state();
   PtrComprCageBase cage_base(heap()->isolate());
   for (const Page* page : *this) {
     CHECK(page->SweepingDone());

src/heap/scavenger.cc

@@ -524,7 +524,7 @@ void ScavengerCollector::SweepArrayBufferExtensions() {
 
 void ScavengerCollector::HandleSurvivingNewLargeObjects() {
   const bool is_compacting = heap_->incremental_marking()->IsCompacting();
-  MajorAtomicMarkingState* marking_state =
+  AtomicMarkingState* marking_state =
       heap_->incremental_marking()->atomic_marking_state();
 
   for (SurvivingNewLargeObjectMapEntry update_info :

src/heap/spaces.cc

@@ -173,8 +173,7 @@ void Page::CreateBlackArea(Address start, Address end) {
   DCHECK_EQ(Page::FromAddress(start), this);
   DCHECK_LT(start, end);
   DCHECK_EQ(Page::FromAddress(end - 1), this);
-  IncrementalMarking::MarkingState* marking_state =
-      heap()->incremental_marking()->marking_state();
+  MarkingState* marking_state = heap()->incremental_marking()->marking_state();
   marking_state->bitmap(this)->SetRange(AddressToMarkbitIndex(start),
                                         AddressToMarkbitIndex(end));
   marking_state->IncrementLiveBytes(this, static_cast<intptr_t>(end - start));
@@ -185,7 +184,7 @@ void Page::CreateBlackAreaBackground(Address start, Address end) {
   DCHECK_EQ(Page::FromAddress(start), this);
   DCHECK_LT(start, end);
   DCHECK_EQ(Page::FromAddress(end - 1), this);
-  IncrementalMarking::AtomicMarkingState* marking_state =
+  AtomicMarkingState* marking_state =
       heap()->incremental_marking()->atomic_marking_state();
   marking_state->bitmap(this)->SetRange(AddressToMarkbitIndex(start),
                                         AddressToMarkbitIndex(end));
@@ -198,8 +197,7 @@ void Page::DestroyBlackArea(Address start, Address end) {
   DCHECK_EQ(Page::FromAddress(start), this);
   DCHECK_LT(start, end);
   DCHECK_EQ(Page::FromAddress(end - 1), this);
-  IncrementalMarking::MarkingState* marking_state =
-      heap()->incremental_marking()->marking_state();
+  MarkingState* marking_state = heap()->incremental_marking()->marking_state();
   marking_state->bitmap(this)->ClearRange(AddressToMarkbitIndex(start),
                                           AddressToMarkbitIndex(end));
   marking_state->IncrementLiveBytes(this, -static_cast<intptr_t>(end - start));
@@ -210,7 +208,7 @@ void Page::DestroyBlackAreaBackground(Address start, Address end) {
   DCHECK_EQ(Page::FromAddress(start), this);
   DCHECK_LT(start, end);
   DCHECK_EQ(Page::FromAddress(end - 1), this);
-  IncrementalMarking::AtomicMarkingState* marking_state =
+  AtomicMarkingState* marking_state =
       heap()->incremental_marking()->atomic_marking_state();
   marking_state->bitmap(this)->ClearRange(AddressToMarkbitIndex(start),
                                           AddressToMarkbitIndex(end));

src/heap/sweeper.cc

@@ -19,7 +19,7 @@
 namespace v8 {
 namespace internal {
 
-Sweeper::Sweeper(Heap* heap, MajorNonAtomicMarkingState* marking_state)
+Sweeper::Sweeper(Heap* heap, NonAtomicMarkingState* marking_state)
     : heap_(heap),
       marking_state_(marking_state),
       sweeping_in_progress_(false),
@@ -115,7 +115,7 @@ void Sweeper::TearDown() {
 void Sweeper::StartSweeping() {
   sweeping_in_progress_ = true;
   should_reduce_memory_ = heap_->ShouldReduceMemory();
-  MajorNonAtomicMarkingState* marking_state =
+  NonAtomicMarkingState* marking_state =
       heap_->mark_compact_collector()->non_atomic_marking_state();
   ForAllSweepingSpaces([this, marking_state](AllocationSpace space) {
     // Sorting is done in order to make compaction more efficient: by sweeping

src/heap/sweeper.h

@@ -18,7 +18,7 @@ namespace v8 {
 namespace internal {
 
 class InvalidatedSlotsCleanup;
-class MajorNonAtomicMarkingState;
+class NonAtomicMarkingState;
 class Page;
 class PagedSpaceBase;
 class Space;
@@ -74,7 +74,7 @@ class Sweeper {
   enum AddPageMode { REGULAR, READD_TEMPORARY_REMOVED_PAGE };
   enum class SweepingMode { kEagerDuringGC, kLazyOrConcurrent };
 
-  Sweeper(Heap* heap, MajorNonAtomicMarkingState* marking_state);
+  Sweeper(Heap* heap, NonAtomicMarkingState* marking_state);
 
   bool sweeping_in_progress() const { return sweeping_in_progress_; }
 
@@ -177,7 +177,7 @@ class Sweeper {
   }
 
   Heap* const heap_;
-  MajorNonAtomicMarkingState* marking_state_;
+  NonAtomicMarkingState* marking_state_;
   std::unique_ptr<JobHandle> job_handle_;
   base::Mutex mutex_;
   base::ConditionVariable cv_page_swept_;

test/cctest/heap/test-heap.cc

@@ -2369,7 +2369,7 @@ TEST(InstanceOfStubWriteBarrier) {
 
   CHECK(f->HasAttachedOptimizedCode());
 
-  IncrementalMarking::MarkingState* marking_state = marking->marking_state();
+  MarkingState* marking_state = marking->marking_state();
 
   const double kStepSizeInMs = 100;
   while (!marking_state->IsBlack(f->code()) && !marking->IsStopped()) {
@@ -5689,7 +5689,7 @@ TEST(Regress598319) {
 
   CHECK(heap->lo_space()->Contains(arr.get()));
   IncrementalMarking* marking = heap->incremental_marking();
-  IncrementalMarking::MarkingState* marking_state = marking->marking_state();
+  MarkingState* marking_state = marking->marking_state();
   CHECK(marking_state->IsWhite(arr.get()));
   for (int i = 0; i < arr.get().length(); i++) {
     HeapObject arr_value = HeapObject::cast(arr.get().get(i));
@@ -5933,7 +5933,7 @@ TEST(LeftTrimFixedArrayInBlackArea) {
   Handle<FixedArray> array =
       isolate->factory()->NewFixedArray(50, AllocationType::kOld);
   CHECK(heap->old_space()->Contains(*array));
-  IncrementalMarking::MarkingState* marking_state = marking->marking_state();
+  MarkingState* marking_state = marking->marking_state();
   CHECK(marking_state->IsBlack(*array));
 
   // Now left trim the allocated black area. A filler has to be installed
@@ -5979,8 +5979,7 @@ TEST(ContinuousLeftTrimFixedArrayInBlackArea) {
   Address start_address = array->address();
   Address end_address = start_address + array->Size();
   Page* page = Page::FromAddress(start_address);
-  IncrementalMarking::NonAtomicMarkingState* marking_state =
-      marking->non_atomic_marking_state();
+  NonAtomicMarkingState* marking_state = marking->non_atomic_marking_state();
   CHECK(marking_state->IsBlack(*array));
   CHECK(marking_state->bitmap(page)->AllBitsSetInRange(
       page->AddressToMarkbitIndex(start_address),
@@ -6049,8 +6048,7 @@ TEST(ContinuousRightTrimFixedArrayInBlackArea) {
   Address start_address = array->address();
   Address end_address = start_address + array->Size();
   Page* page = Page::FromAddress(start_address);
-  IncrementalMarking::NonAtomicMarkingState* marking_state =
-      marking->non_atomic_marking_state();
+  NonAtomicMarkingState* marking_state = marking->non_atomic_marking_state();
   CHECK(marking_state->IsBlack(*array));
 
   CHECK(marking_state->bitmap(page)->AllBitsSetInRange(
@@ -7106,7 +7104,7 @@ TEST(Regress978156) {
         "collector cctest", GCTracer::MarkingType::kIncremental);
     marking->Start(i::GarbageCollectionReason::kTesting);
   }
-  IncrementalMarking::MarkingState* marking_state = marking->marking_state();
+  MarkingState* marking_state = marking->marking_state();
   // 6. Mark the filler black to access its two markbits. This triggers
   // an out-of-bounds access of the marking bitmap in a bad case.
   marking_state->WhiteToGrey(filler);

test/cctest/heap/test-mark-compact.cc

@@ -471,7 +471,7 @@ TEST(Regress5829) {
   heap->CreateFillerObjectAt(old_end - kTaggedSize, kTaggedSize);
   heap->old_space()->FreeLinearAllocationArea();
   Page* page = Page::FromAddress(array->address());
-  IncrementalMarking::MarkingState* marking_state = marking->marking_state();
+  MarkingState* marking_state = marking->marking_state();
   for (auto object_and_size :
        LiveObjectRange<kGreyObjects>(page, marking_state->bitmap(page))) {
     CHECK(!object_and_size.first.IsFreeSpaceOrFiller());

test/unittests/heap/cppgc-js/traced-reference-unittest.cc

@@ -214,7 +214,7 @@ TEST_F(TracedReferenceTest, NoWriteBarrierOnConstruction) {
     v8::Local<v8::Object> local =
         v8::Local<v8::Object>::New(v8_isolate(), v8::Object::New(v8_isolate()));
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     auto ref =
         std::make_unique<v8::TracedReference<v8::Object>>(v8_isolate(), local);
@@ -234,7 +234,7 @@ TEST_F(TracedReferenceTest, WriteBarrierOnHeapReset) {
         v8::Local<v8::Object>::New(v8_isolate(), v8::Object::New(v8_isolate()));
     auto ref = std::make_unique<v8::TracedReference<v8::Object>>();
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     ref->Reset(v8_isolate(), local);
     EXPECT_TRUE(state.IsGrey(HeapObject::cast(*Utils::OpenHandle(*local))));
@@ -254,7 +254,7 @@ TEST_F(TracedReferenceTest, NoWriteBarrierOnStackReset) {
         v8::Local<v8::Object>::New(v8_isolate(), v8::Object::New(v8_isolate()));
     v8::TracedReference<v8::Object> ref;
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     ref.Reset(v8_isolate(), local);
     EXPECT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
@@ -274,7 +274,7 @@ TEST_F(TracedReferenceTest, WriteBarrierOnHeapCopy) {
         std::make_unique<v8::TracedReference<v8::Object>>(v8_isolate(), local);
     auto ref_to = std::make_unique<v8::TracedReference<v8::Object>>();
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     *ref_to = *ref_from;
     EXPECT_TRUE(!ref_from->IsEmpty());
@@ -297,7 +297,7 @@ TEST_F(TracedReferenceTest, NoWriteBarrierOnStackCopy) {
         std::make_unique<v8::TracedReference<v8::Object>>(v8_isolate(), local);
     v8::TracedReference<v8::Object> ref_to;
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     ref_to = *ref_from;
     EXPECT_TRUE(!ref_from->IsEmpty());
@@ -318,7 +318,7 @@ TEST_F(TracedReferenceTest, WriteBarrierOnMove) {
         std::make_unique<v8::TracedReference<v8::Object>>(v8_isolate(), local);
     auto ref_to = std::make_unique<v8::TracedReference<v8::Object>>();
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     *ref_to = std::move(*ref_from);
     ASSERT_TRUE(ref_from->IsEmpty());
@@ -341,7 +341,7 @@ TEST_F(TracedReferenceTest, NoWriteBarrierOnStackMove) {
         std::make_unique<v8::TracedReference<v8::Object>>(v8_isolate(), local);
     v8::TracedReference<v8::Object> ref_to;
     SimulateIncrementalMarking();
-    MarkCompactCollector::MarkingState state(i_isolate());
+    MarkingState state(i_isolate());
     ASSERT_TRUE(state.IsWhite(HeapObject::cast(*Utils::OpenHandle(*local))));
     ref_to = std::move(*ref_from);
     ASSERT_TRUE(ref_from->IsEmpty());

tools/v8heapconst.py

@@ -278,292 +278,292 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-    ("read_only_space", 0x02149): (250, "MetaMap"),
-    ("read_only_space", 0x02171): (131, "NullMap"),
-    ("read_only_space", 0x02199): (232, "StrongDescriptorArrayMap"),
-    ("read_only_space", 0x021c1): (264, "WeakArrayListMap"),
-    ("read_only_space", 0x02205): (155, "EnumCacheMap"),
-    ("read_only_space", 0x02239): (177, "FixedArrayMap"),
-    ("read_only_space", 0x02285): (8, "OneByteInternalizedStringMap"),
-    ("read_only_space", 0x022d1): (247, "FreeSpaceMap"),
-    ("read_only_space", 0x022f9): (246, "OnePointerFillerMap"),
-    ("read_only_space", 0x02321): (246, "TwoPointerFillerMap"),
-    ("read_only_space", 0x02349): (131, "UninitializedMap"),
-    ("read_only_space", 0x023c1): (131, "UndefinedMap"),
-    ("read_only_space", 0x02405): (130, "HeapNumberMap"),
-    ("read_only_space", 0x02439): (131, "TheHoleMap"),
-    ("read_only_space", 0x02499): (131, "BooleanMap"),
-    ("read_only_space", 0x0253d): (192, "ByteArrayMap"),
-    ("read_only_space", 0x02565): (177, "FixedCOWArrayMap"),
-    ("read_only_space", 0x0258d): (178, "HashTableMap"),
-    ("read_only_space", 0x025b5): (128, "SymbolMap"),
-    ("read_only_space", 0x025dd): (40, "OneByteStringMap"),
-    ("read_only_space", 0x02605): (256, "ScopeInfoMap"),
-    ("read_only_space", 0x0262d): (257, "SharedFunctionInfoMap"),
-    ("read_only_space", 0x02655): (240, "CodeMap"),
-    ("read_only_space", 0x0267d): (239, "CellMap"),
-    ("read_only_space", 0x026a5): (255, "GlobalPropertyCellMap"),
-    ("read_only_space", 0x026cd): (204, "ForeignMap"),
-    ("read_only_space", 0x026f5): (236, "TransitionArrayMap"),
-    ("read_only_space", 0x0271d): (45, "ThinOneByteStringMap"),
-    ("read_only_space", 0x02745): (245, "FeedbackVectorMap"),
-    ("read_only_space", 0x0277d): (131, "ArgumentsMarkerMap"),
-    ("read_only_space", 0x027dd): (131, "ExceptionMap"),
-    ("read_only_space", 0x02839): (131, "TerminationExceptionMap"),
-    ("read_only_space", 0x028a1): (131, "OptimizedOutMap"),
-    ("read_only_space", 0x02901): (131, "StaleRegisterMap"),
-    ("read_only_space", 0x02961): (191, "ScriptContextTableMap"),
-    ("read_only_space", 0x02989): (189, "ClosureFeedbackCellArrayMap"),
-    ("read_only_space", 0x029b1): (244, "FeedbackMetadataArrayMap"),
-    ("read_only_space", 0x029d9): (177, "ArrayListMap"),
-    ("read_only_space", 0x02a01): (129, "BigIntMap"),
-    ("read_only_space", 0x02a29): (190, "ObjectBoilerplateDescriptionMap"),
-    ("read_only_space", 0x02a51): (193, "BytecodeArrayMap"),
-    ("read_only_space", 0x02a79): (241, "CodeDataContainerMap"),
-    ("read_only_space", 0x02aa1): (242, "CoverageInfoMap"),
-    ("read_only_space", 0x02ac9): (194, "FixedDoubleArrayMap"),
-    ("read_only_space", 0x02af1): (180, "GlobalDictionaryMap"),
-    ("read_only_space", 0x02b19): (157, "ManyClosuresCellMap"),
-    ("read_only_space", 0x02b41): (251, "MegaDomHandlerMap"),
-    ("read_only_space", 0x02b69): (177, "ModuleInfoMap"),
-    ("read_only_space", 0x02b91): (181, "NameDictionaryMap"),
-    ("read_only_space", 0x02bb9): (157, "NoClosuresCellMap"),
-    ("read_only_space", 0x02be1): (183, "NumberDictionaryMap"),
-    ("read_only_space", 0x02c09): (157, "OneClosureCellMap"),
-    ("read_only_space", 0x02c31): (184, "OrderedHashMapMap"),
-    ("read_only_space", 0x02c59): (185, "OrderedHashSetMap"),
-    ("read_only_space", 0x02c81): (182, "NameToIndexHashTableMap"),
-    ("read_only_space", 0x02ca9): (187, "RegisteredSymbolTableMap"),
-    ("read_only_space", 0x02cd1): (186, "OrderedNameDictionaryMap"),
-    ("read_only_space", 0x02cf9): (253, "PreparseDataMap"),
-    ("read_only_space", 0x02d21): (254, "PropertyArrayMap"),
-    ("read_only_space", 0x02d49): (237, "AccessorInfoMap"),
-    ("read_only_space", 0x02d71): (238, "SideEffectCallHandlerInfoMap"),
-    ("read_only_space", 0x02d99): (238, "SideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02dc1): (238, "NextCallSideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02de9): (188, "SimpleNumberDictionaryMap"),
-    ("read_only_space", 0x02e11): (228, "SmallOrderedHashMapMap"),
-    ("read_only_space", 0x02e39): (229, "SmallOrderedHashSetMap"),
-    ("read_only_space", 0x02e61): (230, "SmallOrderedNameDictionaryMap"),
-    ("read_only_space", 0x02e89): (233, "SourceTextModuleMap"),
-    ("read_only_space", 0x02eb1): (261, "SwissNameDictionaryMap"),
-    ("read_only_space", 0x02ed9): (234, "SyntheticModuleMap"),
-    ("read_only_space", 0x02f01): (262, "WasmApiFunctionRefMap"),
-    ("read_only_space", 0x02f29): (222, "WasmCapiFunctionDataMap"),
-    ("read_only_space", 0x02f51): (223, "WasmExportedFunctionDataMap"),
-    ("read_only_space", 0x02f79): (205, "WasmInternalFunctionMap"),
-    ("read_only_space", 0x02fa1): (224, "WasmJSFunctionDataMap"),
-    ("read_only_space", 0x02fc9): (263, "WasmResumeDataMap"),
-    ("read_only_space", 0x02ff1): (206, "WasmTypeInfoMap"),
-    ("read_only_space", 0x03019): (235, "WeakFixedArrayMap"),
-    ("read_only_space", 0x03041): (179, "EphemeronHashTableMap"),
-    ("read_only_space", 0x03069): (243, "EmbedderDataArrayMap"),
-    ("read_only_space", 0x03091): (265, "WeakCellMap"),
-    ("read_only_space", 0x030b9): (32, "StringMap"),
-    ("read_only_space", 0x030e1): (41, "ConsOneByteStringMap"),
-    ("read_only_space", 0x03109): (33, "ConsStringMap"),
-    ("read_only_space", 0x03131): (37, "ThinStringMap"),
-    ("read_only_space", 0x03159): (35, "SlicedStringMap"),
-    ("read_only_space", 0x03181): (43, "SlicedOneByteStringMap"),
-    ("read_only_space", 0x031a9): (34, "ExternalStringMap"),
-    ("read_only_space", 0x031d1): (42, "ExternalOneByteStringMap"),
-    ("read_only_space", 0x031f9): (50, "UncachedExternalStringMap"),
-    ("read_only_space", 0x03221): (0, "InternalizedStringMap"),
-    ("read_only_space", 0x03249): (2, "ExternalInternalizedStringMap"),
-    ("read_only_space", 0x03271): (10, "ExternalOneByteInternalizedStringMap"),
-    ("read_only_space", 0x03299): (18, "UncachedExternalInternalizedStringMap"),
-    ("read_only_space", 0x032c1): (26, "UncachedExternalOneByteInternalizedStringMap"),
-    ("read_only_space", 0x032e9): (58, "UncachedExternalOneByteStringMap"),
-    ("read_only_space", 0x03311): (104, "SharedOneByteStringMap"),
-    ("read_only_space", 0x03339): (96, "SharedStringMap"),
-    ("read_only_space", 0x03361): (109, "SharedThinOneByteStringMap"),
-    ("read_only_space", 0x03389): (101, "SharedThinStringMap"),
-    ("read_only_space", 0x033b1): (131, "SelfReferenceMarkerMap"),
-    ("read_only_space", 0x033d9): (131, "BasicBlockCountersMarkerMap"),
-    ("read_only_space", 0x0341d): (146, "ArrayBoilerplateDescriptionMap"),
-    ("read_only_space", 0x0351d): (159, "InterceptorInfoMap"),
-    ("read_only_space", 0x05f69): (132, "PromiseFulfillReactionJobTaskMap"),
-    ("read_only_space", 0x05f91): (133, "PromiseRejectReactionJobTaskMap"),
-    ("read_only_space", 0x05fb9): (134, "CallableTaskMap"),
-    ("read_only_space", 0x05fe1): (135, "CallbackTaskMap"),
-    ("read_only_space", 0x06009): (136, "PromiseResolveThenableJobTaskMap"),
-    ("read_only_space", 0x06031): (139, "FunctionTemplateInfoMap"),
-    ("read_only_space", 0x06059): (140, "ObjectTemplateInfoMap"),
-    ("read_only_space", 0x06081): (141, "AccessCheckInfoMap"),
-    ("read_only_space", 0x060a9): (142, "AccessorPairMap"),
-    ("read_only_space", 0x060d1): (143, "AliasedArgumentsEntryMap"),
-    ("read_only_space", 0x060f9): (144, "AllocationMementoMap"),
-    ("read_only_space", 0x06121): (147, "AsmWasmDataMap"),
-    ("read_only_space", 0x06149): (148, "AsyncGeneratorRequestMap"),
-    ("read_only_space", 0x06171): (149, "BreakPointMap"),
-    ("read_only_space", 0x06199): (150, "BreakPointInfoMap"),
-    ("read_only_space", 0x061c1): (151, "CachedTemplateObjectMap"),
-    ("read_only_space", 0x061e9): (152, "CallSiteInfoMap"),
-    ("read_only_space", 0x06211): (153, "ClassPositionsMap"),
-    ("read_only_space", 0x06239): (154, "DebugInfoMap"),
-    ("read_only_space", 0x06261): (156, "ErrorStackDataMap"),
-    ("read_only_space", 0x06289): (158, "FunctionTemplateRareDataMap"),
-    ("read_only_space", 0x062b1): (160, "InterpreterDataMap"),
-    ("read_only_space", 0x062d9): (161, "ModuleRequestMap"),
-    ("read_only_space", 0x06301): (162, "PromiseCapabilityMap"),
-    ("read_only_space", 0x06329): (163, "PromiseOnStackMap"),
-    ("read_only_space", 0x06351): (164, "PromiseReactionMap"),
-    ("read_only_space", 0x06379): (165, "PropertyDescriptorObjectMap"),
-    ("read_only_space", 0x063a1): (166, "PrototypeInfoMap"),
-    ("read_only_space", 0x063c9): (167, "RegExpBoilerplateDescriptionMap"),
-    ("read_only_space", 0x063f1): (168, "ScriptMap"),
-    ("read_only_space", 0x06419): (169, "ScriptOrModuleMap"),
-    ("read_only_space", 0x06441): (170, "SourceTextModuleInfoEntryMap"),
-    ("read_only_space", 0x06469): (171, "StackFrameInfoMap"),
-    ("read_only_space", 0x06491): (172, "TemplateObjectDescriptionMap"),
-    ("read_only_space", 0x064b9): (173, "Tuple2Map"),
-    ("read_only_space", 0x064e1): (174, "WasmContinuationObjectMap"),
-    ("read_only_space", 0x06509): (175, "WasmExceptionTagMap"),
-    ("read_only_space", 0x06531): (176, "WasmIndirectFunctionTableMap"),
-    ("read_only_space", 0x06559): (196, "SloppyArgumentsElementsMap"),
-    ("read_only_space", 0x06581): (231, "DescriptorArrayMap"),
-    ("read_only_space", 0x065a9): (219, "UncompiledDataWithoutPreparseDataMap"),
-    ("read_only_space", 0x065d1): (217, "UncompiledDataWithPreparseDataMap"),
-    ("read_only_space", 0x065f9): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
-    ("read_only_space", 0x06621): (218, "UncompiledDataWithPreparseDataAndJobMap"),
-    ("read_only_space", 0x06649): (252, "OnHeapBasicBlockProfilerDataMap"),
-    ("read_only_space", 0x06671): (197, "TurbofanBitsetTypeMap"),
-    ("read_only_space", 0x06699): (201, "TurbofanUnionTypeMap"),
-    ("read_only_space", 0x066c1): (200, "TurbofanRangeTypeMap"),
-    ("read_only_space", 0x066e9): (198, "TurbofanHeapConstantTypeMap"),
-    ("read_only_space", 0x06711): (199, "TurbofanOtherNumberConstantTypeMap"),
-    ("read_only_space", 0x06739): (248, "InternalClassMap"),
-    ("read_only_space", 0x06761): (259, "SmiPairMap"),
-    ("read_only_space", 0x06789): (258, "SmiBoxMap"),
-    ("read_only_space", 0x067b1): (225, "ExportedSubClassBaseMap"),
-    ("read_only_space", 0x067d9): (226, "ExportedSubClassMap"),
-    ("read_only_space", 0x06801): (202, "AbstractInternalClassSubclass1Map"),
-    ("read_only_space", 0x06829): (203, "AbstractInternalClassSubclass2Map"),
-    ("read_only_space", 0x06851): (195, "InternalClassWithSmiElementsMap"),
-    ("read_only_space", 0x06879): (249, "InternalClassWithStructElementsMap"),
-    ("read_only_space", 0x068a1): (227, "ExportedSubClass2Map"),
-    ("read_only_space", 0x068c9): (260, "SortStateMap"),
-    ("read_only_space", 0x068f1): (145, "AllocationSiteWithWeakNextMap"),
-    ("read_only_space", 0x06919): (145, "AllocationSiteWithoutWeakNextMap"),
-    ("read_only_space", 0x069e5): (137, "LoadHandler1Map"),
-    ("read_only_space", 0x06a0d): (137, "LoadHandler2Map"),
-    ("read_only_space", 0x06a35): (137, "LoadHandler3Map"),
-    ("read_only_space", 0x06a5d): (138, "StoreHandler0Map"),
-    ("read_only_space", 0x06a85): (138, "StoreHandler1Map"),
-    ("read_only_space", 0x06aad): (138, "StoreHandler2Map"),
-    ("read_only_space", 0x06ad5): (138, "StoreHandler3Map"),
-    ("map_space", 0x02149): (2114, "ExternalMap"),
-    ("map_space", 0x02171): (2118, "JSMessageObjectMap"),
+    ("read_only_space", 0x02139): (250, "MetaMap"),
+    ("read_only_space", 0x02161): (131, "NullMap"),
+    ("read_only_space", 0x02189): (232, "StrongDescriptorArrayMap"),
+    ("read_only_space", 0x021b1): (264, "WeakArrayListMap"),
+    ("read_only_space", 0x021f5): (155, "EnumCacheMap"),
+    ("read_only_space", 0x02229): (177, "FixedArrayMap"),
+    ("read_only_space", 0x02275): (8, "OneByteInternalizedStringMap"),
+    ("read_only_space", 0x022c1): (247, "FreeSpaceMap"),
+    ("read_only_space", 0x022e9): (246, "OnePointerFillerMap"),
+    ("read_only_space", 0x02311): (246, "TwoPointerFillerMap"),
+    ("read_only_space", 0x02339): (131, "UninitializedMap"),
+    ("read_only_space", 0x023b1): (131, "UndefinedMap"),
+    ("read_only_space", 0x023f5): (130, "HeapNumberMap"),
+    ("read_only_space", 0x02429): (131, "TheHoleMap"),
+    ("read_only_space", 0x02489): (131, "BooleanMap"),
+    ("read_only_space", 0x0252d): (192, "ByteArrayMap"),
+    ("read_only_space", 0x02555): (177, "FixedCOWArrayMap"),
+    ("read_only_space", 0x0257d): (178, "HashTableMap"),
+    ("read_only_space", 0x025a5): (128, "SymbolMap"),
+    ("read_only_space", 0x025cd): (40, "OneByteStringMap"),
+    ("read_only_space", 0x025f5): (256, "ScopeInfoMap"),
+    ("read_only_space", 0x0261d): (257, "SharedFunctionInfoMap"),
+    ("read_only_space", 0x02645): (240, "CodeMap"),
+    ("read_only_space", 0x0266d): (239, "CellMap"),
+    ("read_only_space", 0x02695): (255, "GlobalPropertyCellMap"),
+    ("read_only_space", 0x026bd): (204, "ForeignMap"),
+    ("read_only_space", 0x026e5): (236, "TransitionArrayMap"),
+    ("read_only_space", 0x0270d): (45, "ThinOneByteStringMap"),
+    ("read_only_space", 0x02735): (245, "FeedbackVectorMap"),
+    ("read_only_space", 0x0276d): (131, "ArgumentsMarkerMap"),
+    ("read_only_space", 0x027cd): (131, "ExceptionMap"),
+    ("read_only_space", 0x02829): (131, "TerminationExceptionMap"),
+    ("read_only_space", 0x02891): (131, "OptimizedOutMap"),
+    ("read_only_space", 0x028f1): (131, "StaleRegisterMap"),
+    ("read_only_space", 0x02951): (191, "ScriptContextTableMap"),
+    ("read_only_space", 0x02979): (189, "ClosureFeedbackCellArrayMap"),
+    ("read_only_space", 0x029a1): (244, "FeedbackMetadataArrayMap"),
+    ("read_only_space", 0x029c9): (177, "ArrayListMap"),
+    ("read_only_space", 0x029f1): (129, "BigIntMap"),
+    ("read_only_space", 0x02a19): (190, "ObjectBoilerplateDescriptionMap"),
+    ("read_only_space", 0x02a41): (193, "BytecodeArrayMap"),
+    ("read_only_space", 0x02a69): (241, "CodeDataContainerMap"),
+    ("read_only_space", 0x02a91): (242, "CoverageInfoMap"),
+    ("read_only_space", 0x02ab9): (194, "FixedDoubleArrayMap"),
+    ("read_only_space", 0x02ae1): (180, "GlobalDictionaryMap"),
+    ("read_only_space", 0x02b09): (157, "ManyClosuresCellMap"),
+    ("read_only_space", 0x02b31): (251, "MegaDomHandlerMap"),
+    ("read_only_space", 0x02b59): (177, "ModuleInfoMap"),
+    ("read_only_space", 0x02b81): (181, "NameDictionaryMap"),
+    ("read_only_space", 0x02ba9): (157, "NoClosuresCellMap"),
+    ("read_only_space", 0x02bd1): (183, "NumberDictionaryMap"),
+    ("read_only_space", 0x02bf9): (157, "OneClosureCellMap"),
+    ("read_only_space", 0x02c21): (184, "OrderedHashMapMap"),
+    ("read_only_space", 0x02c49): (185, "OrderedHashSetMap"),
+    ("read_only_space", 0x02c71): (182, "NameToIndexHashTableMap"),
+    ("read_only_space", 0x02c99): (187, "RegisteredSymbolTableMap"),
+    ("read_only_space", 0x02cc1): (186, "OrderedNameDictionaryMap"),
+    ("read_only_space", 0x02ce9): (253, "PreparseDataMap"),
+    ("read_only_space", 0x02d11): (254, "PropertyArrayMap"),
+    ("read_only_space", 0x02d39): (237, "AccessorInfoMap"),
+    ("read_only_space", 0x02d61): (238, "SideEffectCallHandlerInfoMap"),
+    ("read_only_space", 0x02d89): (238, "SideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02db1): (238, "NextCallSideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02dd9): (188, "SimpleNumberDictionaryMap"),
+    ("read_only_space", 0x02e01): (228, "SmallOrderedHashMapMap"),
+    ("read_only_space", 0x02e29): (229, "SmallOrderedHashSetMap"),
+    ("read_only_space", 0x02e51): (230, "SmallOrderedNameDictionaryMap"),
+    ("read_only_space", 0x02e79): (233, "SourceTextModuleMap"),
+    ("read_only_space", 0x02ea1): (261, "SwissNameDictionaryMap"),
+    ("read_only_space", 0x02ec9): (234, "SyntheticModuleMap"),
+    ("read_only_space", 0x02ef1): (262, "WasmApiFunctionRefMap"),
+    ("read_only_space", 0x02f19): (222, "WasmCapiFunctionDataMap"),
+    ("read_only_space", 0x02f41): (223, "WasmExportedFunctionDataMap"),
+    ("read_only_space", 0x02f69): (205, "WasmInternalFunctionMap"),
+    ("read_only_space", 0x02f91): (224, "WasmJSFunctionDataMap"),
+    ("read_only_space", 0x02fb9): (263, "WasmResumeDataMap"),
+    ("read_only_space", 0x02fe1): (206, "WasmTypeInfoMap"),
+    ("read_only_space", 0x03009): (235, "WeakFixedArrayMap"),
+    ("read_only_space", 0x03031): (179, "EphemeronHashTableMap"),
+    ("read_only_space", 0x03059): (243, "EmbedderDataArrayMap"),
+    ("read_only_space", 0x03081): (265, "WeakCellMap"),
+    ("read_only_space", 0x030a9): (32, "StringMap"),
+    ("read_only_space", 0x030d1): (41, "ConsOneByteStringMap"),
+    ("read_only_space", 0x030f9): (33, "ConsStringMap"),
+    ("read_only_space", 0x03121): (37, "ThinStringMap"),
+    ("read_only_space", 0x03149): (35, "SlicedStringMap"),
+    ("read_only_space", 0x03171): (43, "SlicedOneByteStringMap"),
+    ("read_only_space", 0x03199): (34, "ExternalStringMap"),
+    ("read_only_space", 0x031c1): (42, "ExternalOneByteStringMap"),
+    ("read_only_space", 0x031e9): (50, "UncachedExternalStringMap"),
+    ("read_only_space", 0x03211): (0, "InternalizedStringMap"),
+    ("read_only_space", 0x03239): (2, "ExternalInternalizedStringMap"),
+    ("read_only_space", 0x03261): (10, "ExternalOneByteInternalizedStringMap"),
+    ("read_only_space", 0x03289): (18, "UncachedExternalInternalizedStringMap"),
+    ("read_only_space", 0x032b1): (26, "UncachedExternalOneByteInternalizedStringMap"),
+    ("read_only_space", 0x032d9): (58, "UncachedExternalOneByteStringMap"),
+    ("read_only_space", 0x03301): (104, "SharedOneByteStringMap"),
+    ("read_only_space", 0x03329): (96, "SharedStringMap"),
+    ("read_only_space", 0x03351): (109, "SharedThinOneByteStringMap"),
+    ("read_only_space", 0x03379): (101, "SharedThinStringMap"),
+    ("read_only_space", 0x033a1): (131, "SelfReferenceMarkerMap"),
+    ("read_only_space", 0x033c9): (131, "BasicBlockCountersMarkerMap"),
+    ("read_only_space", 0x0340d): (146, "ArrayBoilerplateDescriptionMap"),
+    ("read_only_space", 0x0350d): (159, "InterceptorInfoMap"),
+    ("read_only_space", 0x05f59): (132, "PromiseFulfillReactionJobTaskMap"),
+    ("read_only_space", 0x05f81): (133, "PromiseRejectReactionJobTaskMap"),
+    ("read_only_space", 0x05fa9): (134, "CallableTaskMap"),
+    ("read_only_space", 0x05fd1): (135, "CallbackTaskMap"),
+    ("read_only_space", 0x05ff9): (136, "PromiseResolveThenableJobTaskMap"),
+    ("read_only_space", 0x06021): (139, "FunctionTemplateInfoMap"),
+    ("read_only_space", 0x06049): (140, "ObjectTemplateInfoMap"),
+    ("read_only_space", 0x06071): (141, "AccessCheckInfoMap"),
+    ("read_only_space", 0x06099): (142, "AccessorPairMap"),
+    ("read_only_space", 0x060c1): (143, "AliasedArgumentsEntryMap"),
+    ("read_only_space", 0x060e9): (144, "AllocationMementoMap"),
+    ("read_only_space", 0x06111): (147, "AsmWasmDataMap"),
+    ("read_only_space", 0x06139): (148, "AsyncGeneratorRequestMap"),
+    ("read_only_space", 0x06161): (149, "BreakPointMap"),
+    ("read_only_space", 0x06189): (150, "BreakPointInfoMap"),
+    ("read_only_space", 0x061b1): (151, "CachedTemplateObjectMap"),
+    ("read_only_space", 0x061d9): (152, "CallSiteInfoMap"),
+    ("read_only_space", 0x06201): (153, "ClassPositionsMap"),
+    ("read_only_space", 0x06229): (154, "DebugInfoMap"),
+    ("read_only_space", 0x06251): (156, "ErrorStackDataMap"),
+    ("read_only_space", 0x06279): (158, "FunctionTemplateRareDataMap"),
+    ("read_only_space", 0x062a1): (160, "InterpreterDataMap"),
+    ("read_only_space", 0x062c9): (161, "ModuleRequestMap"),
+    ("read_only_space", 0x062f1): (162, "PromiseCapabilityMap"),
+    ("read_only_space", 0x06319): (163, "PromiseOnStackMap"),
+    ("read_only_space", 0x06341): (164, "PromiseReactionMap"),
+    ("read_only_space", 0x06369): (165, "PropertyDescriptorObjectMap"),
+    ("read_only_space", 0x06391): (166, "PrototypeInfoMap"),
+    ("read_only_space", 0x063b9): (167, "RegExpBoilerplateDescriptionMap"),
+    ("read_only_space", 0x063e1): (168, "ScriptMap"),
+    ("read_only_space", 0x06409): (169, "ScriptOrModuleMap"),
+    ("read_only_space", 0x06431): (170, "SourceTextModuleInfoEntryMap"),
+    ("read_only_space", 0x06459): (171, "StackFrameInfoMap"),
+    ("read_only_space", 0x06481): (172, "TemplateObjectDescriptionMap"),
+    ("read_only_space", 0x064a9): (173, "Tuple2Map"),
+    ("read_only_space", 0x064d1): (174, "WasmContinuationObjectMap"),
+    ("read_only_space", 0x064f9): (175, "WasmExceptionTagMap"),
+    ("read_only_space", 0x06521): (176, "WasmIndirectFunctionTableMap"),
+    ("read_only_space", 0x06549): (196, "SloppyArgumentsElementsMap"),
+    ("read_only_space", 0x06571): (231, "DescriptorArrayMap"),
+    ("read_only_space", 0x06599): (219, "UncompiledDataWithoutPreparseDataMap"),
+    ("read_only_space", 0x065c1): (217, "UncompiledDataWithPreparseDataMap"),
+    ("read_only_space", 0x065e9): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
+    ("read_only_space", 0x06611): (218, "UncompiledDataWithPreparseDataAndJobMap"),
+    ("read_only_space", 0x06639): (252, "OnHeapBasicBlockProfilerDataMap"),
+    ("read_only_space", 0x06661): (197, "TurbofanBitsetTypeMap"),
+    ("read_only_space", 0x06689): (201, "TurbofanUnionTypeMap"),
+    ("read_only_space", 0x066b1): (200, "TurbofanRangeTypeMap"),
+    ("read_only_space", 0x066d9): (198, "TurbofanHeapConstantTypeMap"),
+    ("read_only_space", 0x06701): (199, "TurbofanOtherNumberConstantTypeMap"),
+    ("read_only_space", 0x06729): (248, "InternalClassMap"),
+    ("read_only_space", 0x06751): (259, "SmiPairMap"),
+    ("read_only_space", 0x06779): (258, "SmiBoxMap"),
+    ("read_only_space", 0x067a1): (225, "ExportedSubClassBaseMap"),
+    ("read_only_space", 0x067c9): (226, "ExportedSubClassMap"),
+    ("read_only_space", 0x067f1): (202, "AbstractInternalClassSubclass1Map"),
+    ("read_only_space", 0x06819): (203, "AbstractInternalClassSubclass2Map"),
+    ("read_only_space", 0x06841): (195, "InternalClassWithSmiElementsMap"),
+    ("read_only_space", 0x06869): (249, "InternalClassWithStructElementsMap"),
+    ("read_only_space", 0x06891): (227, "ExportedSubClass2Map"),
+    ("read_only_space", 0x068b9): (260, "SortStateMap"),
+    ("read_only_space", 0x068e1): (145, "AllocationSiteWithWeakNextMap"),
+    ("read_only_space", 0x06909): (145, "AllocationSiteWithoutWeakNextMap"),
+    ("read_only_space", 0x069d5): (137, "LoadHandler1Map"),
+    ("read_only_space", 0x069fd): (137, "LoadHandler2Map"),
+    ("read_only_space", 0x06a25): (137, "LoadHandler3Map"),
+    ("read_only_space", 0x06a4d): (138, "StoreHandler0Map"),
+    ("read_only_space", 0x06a75): (138, "StoreHandler1Map"),
+    ("read_only_space", 0x06a9d): (138, "StoreHandler2Map"),
+    ("read_only_space", 0x06ac5): (138, "StoreHandler3Map"),
+    ("map_space", 0x02139): (2114, "ExternalMap"),
+    ("map_space", 0x02161): (2118, "JSMessageObjectMap"),
 }
 
 # List of known V8 objects.
 KNOWN_OBJECTS = {
-  ("read_only_space", 0x021e9): "EmptyWeakArrayList",
-  ("read_only_space", 0x021f5): "EmptyDescriptorArray",
-  ("read_only_space", 0x0222d): "EmptyEnumCache",
-  ("read_only_space", 0x02261): "EmptyFixedArray",
-  ("read_only_space", 0x02269): "NullValue",
-  ("read_only_space", 0x02371): "UninitializedValue",
-  ("read_only_space", 0x023e9): "UndefinedValue",
-  ("read_only_space", 0x0242d): "NanValue",
-  ("read_only_space", 0x02461): "TheHoleValue",
-  ("read_only_space", 0x0248d): "HoleNanValue",
-  ("read_only_space", 0x024c1): "TrueValue",
-  ("read_only_space", 0x02501): "FalseValue",
-  ("read_only_space", 0x02531): "empty_string",
-  ("read_only_space", 0x0276d): "EmptyScopeInfo",
-  ("read_only_space", 0x027a5): "ArgumentsMarker",
-  ("read_only_space", 0x02805): "Exception",
-  ("read_only_space", 0x02861): "TerminationException",
-  ("read_only_space", 0x028c9): "OptimizedOut",
-  ("read_only_space", 0x02929): "StaleRegister",
-  ("read_only_space", 0x03401): "EmptyPropertyArray",
-  ("read_only_space", 0x03409): "EmptyByteArray",
-  ("read_only_space", 0x03411): "EmptyObjectBoilerplateDescription",
-  ("read_only_space", 0x03445): "EmptyArrayBoilerplateDescription",
-  ("read_only_space", 0x03451): "EmptyClosureFeedbackCellArray",
-  ("read_only_space", 0x03459): "EmptySlowElementDictionary",
-  ("read_only_space", 0x0347d): "EmptyOrderedHashMap",
-  ("read_only_space", 0x03491): "EmptyOrderedHashSet",
-  ("read_only_space", 0x034a5): "EmptyFeedbackMetadata",
-  ("read_only_space", 0x034b1): "EmptyPropertyDictionary",
-  ("read_only_space", 0x034d9): "EmptyOrderedPropertyDictionary",
-  ("read_only_space", 0x034f1): "EmptySwissPropertyDictionary",
-  ("read_only_space", 0x03545): "NoOpInterceptorInfo",
-  ("read_only_space", 0x0356d): "EmptyArrayList",
-  ("read_only_space", 0x03579): "EmptyWeakFixedArray",
-  ("read_only_space", 0x03581): "InfinityValue",
-  ("read_only_space", 0x0358d): "MinusZeroValue",
-  ("read_only_space", 0x03599): "MinusInfinityValue",
-  ("read_only_space", 0x035a5): "SelfReferenceMarker",
-  ("read_only_space", 0x035e5): "BasicBlockCountersMarker",
-  ("read_only_space", 0x03629): "OffHeapTrampolineRelocationInfo",
-  ("read_only_space", 0x03635): "GlobalThisBindingScopeInfo",
-  ("read_only_space", 0x03665): "EmptyFunctionScopeInfo",
-  ("read_only_space", 0x03689): "NativeScopeInfo",
-  ("read_only_space", 0x036a1): "HashSeed",
-  ("old_space", 0x04241): "ArgumentsIteratorAccessor",
-  ("old_space", 0x04269): "ArrayLengthAccessor",
-  ("old_space", 0x04291): "BoundFunctionLengthAccessor",
-  ("old_space", 0x042b9): "BoundFunctionNameAccessor",
-  ("old_space", 0x042e1): "ErrorStackAccessor",
-  ("old_space", 0x04309): "FunctionArgumentsAccessor",
-  ("old_space", 0x04331): "FunctionCallerAccessor",
-  ("old_space", 0x04359): "FunctionNameAccessor",
-  ("old_space", 0x04381): "FunctionLengthAccessor",
-  ("old_space", 0x043a9): "FunctionPrototypeAccessor",
-  ("old_space", 0x043d1): "SharedArrayLengthAccessor",
-  ("old_space", 0x043f9): "StringLengthAccessor",
-  ("old_space", 0x04421): "WrappedFunctionLengthAccessor",
-  ("old_space", 0x04449): "WrappedFunctionNameAccessor",
-  ("old_space", 0x04471): "InvalidPrototypeValidityCell",
-  ("old_space", 0x04479): "EmptyScript",
-  ("old_space", 0x044bd): "ManyClosuresCell",
-  ("old_space", 0x044c9): "ArrayConstructorProtector",
-  ("old_space", 0x044dd): "NoElementsProtector",
-  ("old_space", 0x044f1): "MegaDOMProtector",
-  ("old_space", 0x04505): "IsConcatSpreadableProtector",
-  ("old_space", 0x04519): "ArraySpeciesProtector",
-  ("old_space", 0x0452d): "TypedArraySpeciesProtector",
-  ("old_space", 0x04541): "PromiseSpeciesProtector",
-  ("old_space", 0x04555): "RegExpSpeciesProtector",
-  ("old_space", 0x04569): "StringLengthProtector",
-  ("old_space", 0x0457d): "ArrayIteratorProtector",
-  ("old_space", 0x04591): "ArrayBufferDetachingProtector",
-  ("old_space", 0x045a5): "PromiseHookProtector",
-  ("old_space", 0x045b9): "PromiseResolveProtector",
-  ("old_space", 0x045cd): "MapIteratorProtector",
-  ("old_space", 0x045e1): "PromiseThenProtector",
-  ("old_space", 0x045f5): "SetIteratorProtector",
-  ("old_space", 0x04609): "StringIteratorProtector",
-  ("old_space", 0x0461d): "SingleCharacterStringCache",
-  ("old_space", 0x04a25): "StringSplitCache",
-  ("old_space", 0x04e2d): "RegExpMultipleCache",
-  ("old_space", 0x05235): "BuiltinsConstantsTable",
-  ("old_space", 0x05675): "AsyncFunctionAwaitRejectSharedFun",
-  ("old_space", 0x05699): "AsyncFunctionAwaitResolveSharedFun",
-  ("old_space", 0x056bd): "AsyncGeneratorAwaitRejectSharedFun",
-  ("old_space", 0x056e1): "AsyncGeneratorAwaitResolveSharedFun",
-  ("old_space", 0x05705): "AsyncGeneratorYieldResolveSharedFun",
-  ("old_space", 0x05729): "AsyncGeneratorReturnResolveSharedFun",
-  ("old_space", 0x0574d): "AsyncGeneratorReturnClosedRejectSharedFun",
-  ("old_space", 0x05771): "AsyncGeneratorReturnClosedResolveSharedFun",
-  ("old_space", 0x05795): "AsyncIteratorValueUnwrapSharedFun",
-  ("old_space", 0x057b9): "PromiseAllResolveElementSharedFun",
-  ("old_space", 0x057dd): "PromiseAllSettledResolveElementSharedFun",
-  ("old_space", 0x05801): "PromiseAllSettledRejectElementSharedFun",
-  ("old_space", 0x05825): "PromiseAnyRejectElementSharedFun",
-  ("old_space", 0x05849): "PromiseCapabilityDefaultRejectSharedFun",
-  ("old_space", 0x0586d): "PromiseCapabilityDefaultResolveSharedFun",
-  ("old_space", 0x05891): "PromiseCatchFinallySharedFun",
-  ("old_space", 0x058b5): "PromiseGetCapabilitiesExecutorSharedFun",
-  ("old_space", 0x058d9): "PromiseThenFinallySharedFun",
-  ("old_space", 0x058fd): "PromiseThrowerFinallySharedFun",
-  ("old_space", 0x05921): "PromiseValueThunkFinallySharedFun",
-  ("old_space", 0x05945): "ProxyRevokeSharedFun",
-  ("old_space", 0x05969): "ShadowRealmImportValueFulfilledSFI",
-  ("old_space", 0x0598d): "SourceTextModuleExecuteAsyncModuleFulfilledSFI",
-  ("old_space", 0x059b1): "SourceTextModuleExecuteAsyncModuleRejectedSFI",
+  ("read_only_space", 0x021d9): "EmptyWeakArrayList",
+  ("read_only_space", 0x021e5): "EmptyDescriptorArray",
+  ("read_only_space", 0x0221d): "EmptyEnumCache",
+  ("read_only_space", 0x02251): "EmptyFixedArray",
+  ("read_only_space", 0x02259): "NullValue",
+  ("read_only_space", 0x02361): "UninitializedValue",
+  ("read_only_space", 0x023d9): "UndefinedValue",
+  ("read_only_space", 0x0241d): "NanValue",
+  ("read_only_space", 0x02451): "TheHoleValue",
+  ("read_only_space", 0x0247d): "HoleNanValue",
+  ("read_only_space", 0x024b1): "TrueValue",
+  ("read_only_space", 0x024f1): "FalseValue",
+  ("read_only_space", 0x02521): "empty_string",
+  ("read_only_space", 0x0275d): "EmptyScopeInfo",
+  ("read_only_space", 0x02795): "ArgumentsMarker",
+  ("read_only_space", 0x027f5): "Exception",
+  ("read_only_space", 0x02851): "TerminationException",
+  ("read_only_space", 0x028b9): "OptimizedOut",
+  ("read_only_space", 0x02919): "StaleRegister",
+  ("read_only_space", 0x033f1): "EmptyPropertyArray",
+  ("read_only_space", 0x033f9): "EmptyByteArray",
+  ("read_only_space", 0x03401): "EmptyObjectBoilerplateDescription",
+  ("read_only_space", 0x03435): "EmptyArrayBoilerplateDescription",
+  ("read_only_space", 0x03441): "EmptyClosureFeedbackCellArray",
+  ("read_only_space", 0x03449): "EmptySlowElementDictionary",
+  ("read_only_space", 0x0346d): "EmptyOrderedHashMap",
+  ("read_only_space", 0x03481): "EmptyOrderedHashSet",
+  ("read_only_space", 0x03495): "EmptyFeedbackMetadata",
+  ("read_only_space", 0x034a1): "EmptyPropertyDictionary",
+  ("read_only_space", 0x034c9): "EmptyOrderedPropertyDictionary",
+  ("read_only_space", 0x034e1): "EmptySwissPropertyDictionary",
+  ("read_only_space", 0x03535): "NoOpInterceptorInfo",
+  ("read_only_space", 0x0355d): "EmptyArrayList",
+  ("read_only_space", 0x03569): "EmptyWeakFixedArray",
+  ("read_only_space", 0x03571): "InfinityValue",
+  ("read_only_space", 0x0357d): "MinusZeroValue",
+  ("read_only_space", 0x03589): "MinusInfinityValue",
+  ("read_only_space", 0x03595): "SelfReferenceMarker",
+  ("read_only_space", 0x035d5): "BasicBlockCountersMarker",
+  ("read_only_space", 0x03619): "OffHeapTrampolineRelocationInfo",
+  ("read_only_space", 0x03625): "GlobalThisBindingScopeInfo",
+  ("read_only_space", 0x03655): "EmptyFunctionScopeInfo",
+  ("read_only_space", 0x03679): "NativeScopeInfo",
+  ("read_only_space", 0x03691): "HashSeed",
+  ("old_space", 0x04231): "ArgumentsIteratorAccessor",
+  ("old_space", 0x04259): "ArrayLengthAccessor",
+  ("old_space", 0x04281): "BoundFunctionLengthAccessor",
+  ("old_space", 0x042a9): "BoundFunctionNameAccessor",
+  ("old_space", 0x042d1): "ErrorStackAccessor",
+  ("old_space", 0x042f9): "FunctionArgumentsAccessor",
+  ("old_space", 0x04321): "FunctionCallerAccessor",
+  ("old_space", 0x04349): "FunctionNameAccessor",
+  ("old_space", 0x04371): "FunctionLengthAccessor",
+  ("old_space", 0x04399): "FunctionPrototypeAccessor",
+  ("old_space", 0x043c1): "SharedArrayLengthAccessor",
+  ("old_space", 0x043e9): "StringLengthAccessor",
+  ("old_space", 0x04411): "WrappedFunctionLengthAccessor",
+  ("old_space", 0x04439): "WrappedFunctionNameAccessor",
+  ("old_space", 0x04461): "InvalidPrototypeValidityCell",
+  ("old_space", 0x04469): "EmptyScript",
+  ("old_space", 0x044ad): "ManyClosuresCell",
+  ("old_space", 0x044b9): "ArrayConstructorProtector",
+  ("old_space", 0x044cd): "NoElementsProtector",
+  ("old_space", 0x044e1): "MegaDOMProtector",
+  ("old_space", 0x044f5): "IsConcatSpreadableProtector",
+  ("old_space", 0x04509): "ArraySpeciesProtector",
+  ("old_space", 0x0451d): "TypedArraySpeciesProtector",
+  ("old_space", 0x04531): "PromiseSpeciesProtector",
+  ("old_space", 0x04545): "RegExpSpeciesProtector",
+  ("old_space", 0x04559): "StringLengthProtector",
+  ("old_space", 0x0456d): "ArrayIteratorProtector",
+  ("old_space", 0x04581): "ArrayBufferDetachingProtector",
+  ("old_space", 0x04595): "PromiseHookProtector",
+  ("old_space", 0x045a9): "PromiseResolveProtector",
+  ("old_space", 0x045bd): "MapIteratorProtector",
+  ("old_space", 0x045d1): "PromiseThenProtector",
+  ("old_space", 0x045e5): "SetIteratorProtector",
+  ("old_space", 0x045f9): "StringIteratorProtector",
+  ("old_space", 0x0460d): "SingleCharacterStringCache",
+  ("old_space", 0x04a15): "StringSplitCache",
+  ("old_space", 0x04e1d): "RegExpMultipleCache",
+  ("old_space", 0x05225): "BuiltinsConstantsTable",
+  ("old_space", 0x05665): "AsyncFunctionAwaitRejectSharedFun",
+  ("old_space", 0x05689): "AsyncFunctionAwaitResolveSharedFun",
+  ("old_space", 0x056ad): "AsyncGeneratorAwaitRejectSharedFun",
+  ("old_space", 0x056d1): "AsyncGeneratorAwaitResolveSharedFun",
+  ("old_space", 0x056f5): "AsyncGeneratorYieldResolveSharedFun",
+  ("old_space", 0x05719): "AsyncGeneratorReturnResolveSharedFun",
+  ("old_space", 0x0573d): "AsyncGeneratorReturnClosedRejectSharedFun",
+  ("old_space", 0x05761): "AsyncGeneratorReturnClosedResolveSharedFun",
+  ("old_space", 0x05785): "AsyncIteratorValueUnwrapSharedFun",
+  ("old_space", 0x057a9): "PromiseAllResolveElementSharedFun",
+  ("old_space", 0x057cd): "PromiseAllSettledResolveElementSharedFun",
+  ("old_space", 0x057f1): "PromiseAllSettledRejectElementSharedFun",
+  ("old_space", 0x05815): "PromiseAnyRejectElementSharedFun",
+  ("old_space", 0x05839): "PromiseCapabilityDefaultRejectSharedFun",
+  ("old_space", 0x0585d): "PromiseCapabilityDefaultResolveSharedFun",
+  ("old_space", 0x05881): "PromiseCatchFinallySharedFun",
+  ("old_space", 0x058a5): "PromiseGetCapabilitiesExecutorSharedFun",
+  ("old_space", 0x058c9): "PromiseThenFinallySharedFun",
+  ("old_space", 0x058ed): "PromiseThrowerFinallySharedFun",
+  ("old_space", 0x05911): "PromiseValueThunkFinallySharedFun",
+  ("old_space", 0x05935): "ProxyRevokeSharedFun",
+  ("old_space", 0x05959): "ShadowRealmImportValueFulfilledSFI",
+  ("old_space", 0x0597d): "SourceTextModuleExecuteAsyncModuleFulfilledSFI",
+  ("old_space", 0x059a1): "SourceTextModuleExecuteAsyncModuleRejectedSFI",
 }
 
 # Lower 32 bits of first page addresses for various heap spaces.