diff --git a/BUILD.bazel b/BUILD.bazel
index 6c14082fc8..6f8bdef7b7 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -1295,6 +1295,8 @@ filegroup(
         "src/handles/maybe-handles.h",
         "src/handles/persistent-handles.cc",
         "src/handles/persistent-handles.h",
+        "src/heap/base/active-system-pages.cc",
+        "src/heap/base/active-system-pages.h",
         "src/heap/allocation-observer.cc",
         "src/heap/allocation-observer.h",
         "src/heap/allocation-result.h",
@@ -2935,6 +2937,8 @@ filegroup(
 filegroup(
     name = "v8_heap_base_files",
     srcs = [
+        "src/heap/base/active-system-pages.cc",
+        "src/heap/base/active-system-pages.h",
         "src/heap/base/stack.cc",
         "src/heap/base/stack.h",
         "src/heap/base/worklist.cc",
diff --git a/BUILD.gn b/BUILD.gn
index 13ffb8fc00..54e60d9c61 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -3852,6 +3852,7 @@ v8_header_set("v8_internal_headers") {
     ":cppgc_headers",
     ":generate_bytecode_builtins_list",
     ":run_torque",
+    ":v8_heap_base_headers",
     ":v8_libbase",
   ]
 }
@@ -5454,12 +5455,23 @@ v8_source_set("v8_bigint") {
   configs = [ ":internal_config" ]
 }
 
+v8_source_set("v8_heap_base_headers") {
+  sources = [
+    "src/heap/base/active-system-pages.h",
+    "src/heap/base/stack.h",
+    "src/heap/base/worklist.h",
+  ]
+
+  configs = [ ":internal_config" ]
+
+  public_deps = [ ":v8_libbase" ]
+}
+
 v8_source_set("v8_heap_base") {
   sources = [
+    "src/heap/base/active-system-pages.cc",
     "src/heap/base/stack.cc",
-    "src/heap/base/stack.h",
     "src/heap/base/worklist.cc",
-    "src/heap/base/worklist.h",
   ]
 
   if (is_clang || !is_win) {
@@ -5496,7 +5508,10 @@ v8_source_set("v8_heap_base") {
 
   configs = [ ":internal_config" ]
 
-  public_deps = [ ":v8_libbase" ]
+  public_deps = [
+    ":v8_heap_base_headers",
+    ":v8_libbase",
+  ]
 }
 
 # This is split out to be a non-code containing target that the Chromium browser
diff --git a/src/common/globals.h b/src/common/globals.h
index 081db50317..050683988b 100644
--- a/src/common/globals.h
+++ b/src/common/globals.h
@@ -918,6 +918,8 @@ enum class CompactionSpaceKind {
 
 enum Executability { NOT_EXECUTABLE, EXECUTABLE };
 
+enum PageSize { kRegular, kLarge };
+
 enum class CodeFlushMode {
   kFlushBytecode,
   kFlushBaselineCode,
diff --git a/src/heap/base/active-system-pages.cc b/src/heap/base/active-system-pages.cc
new file mode 100644
index 0000000000..884ae5c685
--- /dev/null
+++ b/src/heap/base/active-system-pages.cc
@@ -0,0 +1,69 @@
+// Copyright 2022 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/heap/base/active-system-pages.h"
+
+#include "src/base/bits.h"
+#include "src/base/macros.h"
+
+namespace heap {
+namespace base {
+
+size_t ActiveSystemPages::Init(size_t header_size, size_t page_size_bits,
+                               size_t user_page_size) {
+#if DEBUG
+  size_t page_size = 1 << page_size_bits;
+  DCHECK_LE(RoundUp(user_page_size, page_size) >> page_size_bits,
+            ActiveSystemPages::kMaxPages);
+#endif  // DEBUG
+  Clear();
+  return Add(0, header_size, page_size_bits);
+}
+
+size_t ActiveSystemPages::Add(uintptr_t start, uintptr_t end,
+                              size_t page_size_bits) {
+  const size_t page_size = 1 << page_size_bits;
+
+  DCHECK_LE(start, end);
+  DCHECK_LE(end, kMaxPages * page_size);
+
+  // Make sure we actually get the bitcount as argument.
+  DCHECK_LT(page_size_bits, sizeof(uintptr_t) * CHAR_BIT);
+
+  const uintptr_t start_page_bit =
+      RoundDown(start, page_size) >> page_size_bits;
+  const uintptr_t end_page_bit = RoundUp(end, page_size) >> page_size_bits;
+  DCHECK_LE(start_page_bit, end_page_bit);
+
+  const uintptr_t bits = end_page_bit - start_page_bit;
+  DCHECK_LE(bits, kMaxPages);
+  const bitset_t mask = bits == kMaxPages
+                            ? int64_t{-1}
+                            : ((uint64_t{1} << bits) - 1) << start_page_bit;
+  const bitset_t added_pages = ~value_ & mask;
+  value_ |= mask;
+  return added_pages.count();
+}
+
+size_t ActiveSystemPages::Reduce(ActiveSystemPages updated_value) {
+  DCHECK_EQ(~value_ & updated_value.value_, 0);
+  const bitset_t removed_pages(value_ & ~updated_value.value_);
+  value_ = updated_value.value_;
+  return removed_pages.count();
+}
+
+size_t ActiveSystemPages::Clear() {
+  const size_t removed_pages = value_.count();
+  value_ = 0;
+  return removed_pages;
+}
+
+size_t ActiveSystemPages::Size(size_t page_size_bits) const {
+  // Make sure we don't get the full page size as argument.
+  DCHECK_LT(page_size_bits, sizeof(uintptr_t) * CHAR_BIT);
+  return value_.count() * (size_t{1} << page_size_bits);
+}
+
+}  // namespace base
+}  // namespace heap
diff --git a/src/heap/base/active-system-pages.h b/src/heap/base/active-system-pages.h
new file mode 100644
index 0000000000..0c30cb928f
--- /dev/null
+++ b/src/heap/base/active-system-pages.h
@@ -0,0 +1,51 @@
+// Copyright 2022 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_HEAP_BASE_ACTIVE_SYSTEM_PAGES_H_
+#define V8_HEAP_BASE_ACTIVE_SYSTEM_PAGES_H_
+
+#include <bitset>
+#include <cstdint>
+
+#include "src/base/macros.h"
+
+namespace heap {
+namespace base {
+
+// Class implements a bitset of system pages on a heap page.
+class ActiveSystemPages final {
+ public:
+  // Defines the maximum number of system pages that can be tracked in one
+  // instance.
+  static constexpr size_t kMaxPages = 64;
+
+  // Initializes the set of active pages to the system pages for the header.
+  V8_EXPORT_PRIVATE size_t Init(size_t header_size, size_t page_size_bits,
+                                size_t user_page_size);
+
+  // Adds the pages for this memory range. Returns the number of freshly added
+  // pages.
+  V8_EXPORT_PRIVATE size_t Add(size_t start, size_t end, size_t page_size_bits);
+
+  // Replaces the current bitset with the given argument. The new bitset needs
+  // to be a proper subset of the current pages, which means this operation
+  // can't add pages. Returns the number of removed pages.
+  V8_EXPORT_PRIVATE size_t Reduce(ActiveSystemPages updated_value);
+
+  // Removes all pages. Returns the number of removed pages.
+  V8_EXPORT_PRIVATE size_t Clear();
+
+  // Returns the memory used with the given page size.
+  V8_EXPORT_PRIVATE size_t Size(size_t page_size_bits) const;
+
+ private:
+  using bitset_t = std::bitset<kMaxPages>;
+
+  bitset_t value_;
+};
+
+}  // namespace base
+}  // namespace heap
+
+#endif  // V8_HEAP_BASE_ACTIVE_SYSTEM_PAGES_H_
diff --git a/src/heap/heap.cc b/src/heap/heap.cc
index d5722501e9..822dc58174 100644
--- a/src/heap/heap.cc
+++ b/src/heap/heap.cc
@@ -4569,6 +4569,10 @@ void Heap::Verify() {
   code_lo_space_->Verify(isolate());
   if (new_lo_space_) new_lo_space_->Verify(isolate());
   isolate()->string_table()->VerifyIfOwnedBy(isolate());
+
+#if DEBUG
+  VerifyCommittedPhysicalMemory();
+#endif  // DEBUG
 }
 
 void Heap::VerifyReadOnlyHeap() {
@@ -4760,7 +4764,15 @@ void Heap::VerifyCountersBeforeConcurrentSweeping() {
     space->VerifyCountersBeforeConcurrentSweeping();
   }
 }
-#endif
+
+void Heap::VerifyCommittedPhysicalMemory() {
+  PagedSpaceIterator spaces(this);
+  for (PagedSpace* space = spaces.Next(); space != nullptr;
+       space = spaces.Next()) {
+    space->VerifyCommittedPhysicalMemory();
+  }
+}
+#endif  // DEBUG
 
 void Heap::ZapFromSpace() {
   if (!new_space_ || !new_space_->IsFromSpaceCommitted()) return;
diff --git a/src/heap/heap.h b/src/heap/heap.h
index bf9fc5e078..ec1e84323a 100644
--- a/src/heap/heap.h
+++ b/src/heap/heap.h
@@ -1583,13 +1583,14 @@ class Heap {
 #ifdef DEBUG
   void VerifyCountersAfterSweeping();
   void VerifyCountersBeforeConcurrentSweeping();
+  void VerifyCommittedPhysicalMemory();
 
   void Print();
   void PrintHandles();
 
   // Report code statistics.
   void ReportCodeStatistics(const char* title);
-#endif
+#endif  // DEBUG
   void* GetRandomMmapAddr() {
     void* result = v8::internal::GetRandomMmapAddr();
 #if V8_TARGET_ARCH_X64
diff --git a/src/heap/memory-allocator.cc b/src/heap/memory-allocator.cc
index 65f470adee..9f467305bf 100644
--- a/src/heap/memory-allocator.cc
+++ b/src/heap/memory-allocator.cc
@@ -402,14 +402,15 @@ V8_EXPORT_PRIVATE BasicMemoryChunk* MemoryAllocator::AllocateBasicChunk(
 MemoryChunk* MemoryAllocator::AllocateChunk(size_t reserve_area_size,
                                             size_t commit_area_size,
                                             Executability executable,
+                                            PageSize page_size,
                                             BaseSpace* owner) {
   BasicMemoryChunk* basic_chunk = AllocateBasicChunk(
       reserve_area_size, commit_area_size, executable, owner);
 
   if (basic_chunk == nullptr) return nullptr;
 
-  MemoryChunk* chunk =
-      MemoryChunk::Initialize(basic_chunk, isolate_->heap(), executable);
+  MemoryChunk* chunk = MemoryChunk::Initialize(basic_chunk, isolate_->heap(),
+                                               executable, page_size);
 
 #ifdef DEBUG
   if (chunk->executable()) RegisterExecutableMemoryChunk(chunk);
@@ -562,7 +563,7 @@ Page* MemoryAllocator::AllocatePage(MemoryAllocator::AllocationMode alloc_mode,
     chunk = AllocatePagePooled(owner);
   }
   if (chunk == nullptr) {
-    chunk = AllocateChunk(size, size, executable, owner);
+    chunk = AllocateChunk(size, size, executable, PageSize::kRegular, owner);
   }
   if (chunk == nullptr) return nullptr;
   return owner->InitializePage(chunk);
@@ -585,7 +586,8 @@ MemoryAllocator::RemapSharedPage(
 LargePage* MemoryAllocator::AllocateLargePage(size_t size,
                                               LargeObjectSpace* owner,
                                               Executability executable) {
-  MemoryChunk* chunk = AllocateChunk(size, size, executable, owner);
+  MemoryChunk* chunk =
+      AllocateChunk(size, size, executable, PageSize::kLarge, owner);
   if (chunk == nullptr) return nullptr;
   return LargePage::Initialize(isolate_->heap(), chunk, executable);
 }
@@ -609,7 +611,8 @@ MemoryChunk* MemoryAllocator::AllocatePagePooled(Space* owner) {
   BasicMemoryChunk* basic_chunk =
       BasicMemoryChunk::Initialize(isolate_->heap(), start, size, area_start,
                                    area_end, owner, std::move(reservation));
-  MemoryChunk::Initialize(basic_chunk, isolate_->heap(), NOT_EXECUTABLE);
+  MemoryChunk::Initialize(basic_chunk, isolate_->heap(), NOT_EXECUTABLE,
+                          PageSize::kRegular);
   size_ += size;
   return chunk;
 }
diff --git a/src/heap/memory-allocator.h b/src/heap/memory-allocator.h
index a9cd7744b9..f7a5da5c26 100644
--- a/src/heap/memory-allocator.h
+++ b/src/heap/memory-allocator.h
@@ -222,6 +222,7 @@ class MemoryAllocator {
   V8_EXPORT_PRIVATE MemoryChunk* AllocateChunk(size_t reserve_area_size,
                                                size_t commit_area_size,
                                                Executability executable,
+                                               PageSize page_size,
                                                BaseSpace* space);
 
   // Partially release |bytes_to_free| bytes starting at |start_free|. Note that
diff --git a/src/heap/memory-chunk-layout.h b/src/heap/memory-chunk-layout.h
index 78b0f017ee..9a76730e82 100644
--- a/src/heap/memory-chunk-layout.h
+++ b/src/heap/memory-chunk-layout.h
@@ -5,6 +5,7 @@
 #ifndef V8_HEAP_MEMORY_CHUNK_LAYOUT_H_
 #define V8_HEAP_MEMORY_CHUNK_LAYOUT_H_
 
+#include "src/heap/base/active-system-pages.h"
 #include "src/heap/heap.h"
 #include "src/heap/list.h"
 #include "src/heap/progress-bar.h"
@@ -32,6 +33,8 @@ enum RememberedSetType {
   NUMBER_OF_REMEMBERED_SET_TYPES
 };
 
+using ActiveSystemPages = ::heap::base::ActiveSystemPages;
+
 class V8_EXPORT_PRIVATE MemoryChunkLayout {
  public:
   static const int kNumSets = NUMBER_OF_REMEMBERED_SET_TYPES;
@@ -68,6 +71,7 @@ class V8_EXPORT_PRIVATE MemoryChunkLayout {
     FIELD(Bitmap*, YoungGenerationBitmap),
     FIELD(CodeObjectRegistry*, CodeObjectRegistry),
     FIELD(PossiblyEmptyBuckets, PossiblyEmptyBuckets),
+    FIELD(ActiveSystemPages, ActiveSystemPages),
 #ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
     FIELD(ObjectStartBitmap, ObjectStartBitmap),
 #endif
diff --git a/src/heap/memory-chunk.cc b/src/heap/memory-chunk.cc
index 92704a6cee..08baeee8b2 100644
--- a/src/heap/memory-chunk.cc
+++ b/src/heap/memory-chunk.cc
@@ -6,6 +6,7 @@
 
 #include "src/base/platform/platform.h"
 #include "src/base/platform/wrappers.h"
+#include "src/common/globals.h"
 #include "src/heap/code-object-registry.h"
 #include "src/heap/memory-allocator.h"
 #include "src/heap/memory-chunk-inl.h"
@@ -118,7 +119,8 @@ PageAllocator::Permission DefaultWritableCodePermissions() {
 }  // namespace
 
 MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
-                                     Executability executable) {
+                                     Executability executable,
+                                     PageSize page_size) {
   MemoryChunk* chunk = static_cast<MemoryChunk*>(basic_chunk);
 
   base::AsAtomicPointer::Release_Store(&chunk->slot_set_[OLD_TO_NEW], nullptr);
@@ -181,6 +183,15 @@ MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
 
   chunk->possibly_empty_buckets_.Initialize();
 
+  if (page_size == PageSize::kRegular) {
+    chunk->active_system_pages_.Init(MemoryChunkLayout::kMemoryChunkHeaderSize,
+                                     MemoryAllocator::GetCommitPageSizeBits(),
+                                     chunk->size());
+  } else {
+    // We do not track active system pages for large pages.
+    chunk->active_system_pages_.Clear();
+  }
+
   // All pages of a shared heap need to be marked with this flag.
   if (heap->IsShared()) chunk->SetFlag(IN_SHARED_HEAP);
 
@@ -196,9 +207,8 @@ MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
 }
 
 size_t MemoryChunk::CommittedPhysicalMemory() {
-  if (!base::OS::HasLazyCommits() || owner_identity() == LO_SPACE)
-    return size();
-  return high_water_mark_;
+  if (!base::OS::HasLazyCommits() || IsLargePage()) return size();
+  return active_system_pages_.Size(MemoryAllocator::GetCommitPageSizeBits());
 }
 
 void MemoryChunk::SetOldGenerationPageFlags(bool is_marking) {
diff --git a/src/heap/memory-chunk.h b/src/heap/memory-chunk.h
index de6f09234b..8a8f556426 100644
--- a/src/heap/memory-chunk.h
+++ b/src/heap/memory-chunk.h
@@ -10,6 +10,7 @@
 #include "src/base/macros.h"
 #include "src/base/platform/mutex.h"
 #include "src/common/globals.h"
+#include "src/heap/base/active-system-pages.h"
 #include "src/heap/basic-memory-chunk.h"
 #include "src/heap/heap.h"
 #include "src/heap/invalidated-slots.h"
@@ -219,7 +220,7 @@ class MemoryChunk : public BasicMemoryChunk {
 
  protected:
   static MemoryChunk* Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
-                                 Executability executable);
+                                 Executability executable, PageSize page_size);
 
   // Release all memory allocated by the chunk. Should be called when memory
   // chunk is about to be freed.
@@ -291,6 +292,8 @@ class MemoryChunk : public BasicMemoryChunk {
 
   PossiblyEmptyBuckets possibly_empty_buckets_;
 
+  ActiveSystemPages active_system_pages_;
+
 #ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
   ObjectStartBitmap object_start_bitmap_;
 #endif
diff --git a/src/heap/new-spaces.cc b/src/heap/new-spaces.cc
index 78d9d71ca4..306f9c29e5 100644
--- a/src/heap/new-spaces.cc
+++ b/src/heap/new-spaces.cc
@@ -491,6 +491,10 @@ void NewSpace::UpdateLinearAllocationArea(Address known_top) {
     original_limit_.store(limit(), std::memory_order_relaxed);
     original_top_.store(top(), std::memory_order_release);
   }
+  Page* page = to_space_.current_page();
+  page->active_system_pages()->Add(top() - page->address(),
+                                   limit() - page->address(),
+                                   MemoryAllocator::GetCommitPageSizeBits());
   DCHECK_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 
   UpdateInlineAllocationLimit(0);
diff --git a/src/heap/paged-spaces.cc b/src/heap/paged-spaces.cc
index c13a5b8027..c5604254be 100644
--- a/src/heap/paged-spaces.cc
+++ b/src/heap/paged-spaces.cc
@@ -4,6 +4,8 @@
 
 #include "src/heap/paged-spaces.h"
 
+#include <atomic>
+
 #include "src/base/optional.h"
 #include "src/base/platform/mutex.h"
 #include "src/execution/isolate.h"
@@ -13,8 +15,10 @@
 #include "src/heap/incremental-marking.h"
 #include "src/heap/memory-allocator.h"
 #include "src/heap/memory-chunk-inl.h"
+#include "src/heap/memory-chunk-layout.h"
 #include "src/heap/paged-spaces-inl.h"
 #include "src/heap/read-only-heap.h"
+#include "src/heap/safepoint.h"
 #include "src/logging/runtime-call-stats-scope.h"
 #include "src/objects/string.h"
 #include "src/utils/utils.h"
@@ -211,15 +215,42 @@ void PagedSpace::MergeCompactionSpace(CompactionSpace* other) {
 }
 
 size_t PagedSpace::CommittedPhysicalMemory() {
-  if (!base::OS::HasLazyCommits()) return CommittedMemory();
+  if (!base::OS::HasLazyCommits()) {
+    DCHECK_EQ(0, committed_physical_memory());
+    return CommittedMemory();
+  }
   BasicMemoryChunk::UpdateHighWaterMark(allocation_info_->top());
-  base::MutexGuard guard(mutex());
+  return committed_physical_memory();
+}
+
+void PagedSpace::IncrementCommittedPhysicalMemory(size_t increment_value) {
+  if (!base::OS::HasLazyCommits() || increment_value == 0) return;
+  size_t old_value = committed_physical_memory_.fetch_add(
+      increment_value, std::memory_order_relaxed);
+  USE(old_value);
+  DCHECK_LT(old_value, old_value + increment_value);
+}
+
+void PagedSpace::DecrementCommittedPhysicalMemory(size_t decrement_value) {
+  if (!base::OS::HasLazyCommits() || decrement_value == 0) return;
+  size_t old_value = committed_physical_memory_.fetch_sub(
+      decrement_value, std::memory_order_relaxed);
+  USE(old_value);
+  DCHECK_GT(old_value, old_value - decrement_value);
+}
+
+#if DEBUG
+void PagedSpace::VerifyCommittedPhysicalMemory() {
+  heap()->safepoint()->AssertActive();
   size_t size = 0;
   for (Page* page : *this) {
+    DCHECK(page->SweepingDone());
     size += page->CommittedPhysicalMemory();
   }
-  return size;
+  // Ensure that the space's counter matches the sum of all page counters.
+  DCHECK_EQ(size, CommittedPhysicalMemory());
 }
+#endif  // DEBUG
 
 bool PagedSpace::ContainsSlow(Address addr) const {
   Page* p = Page::FromAddress(addr);
@@ -264,6 +295,7 @@ size_t PagedSpace::AddPage(Page* page) {
     ExternalBackingStoreType t = static_cast<ExternalBackingStoreType>(i);
     IncrementExternalBackingStoreBytes(t, page->ExternalBackingStoreBytes(t));
   }
+  IncrementCommittedPhysicalMemory(page->CommittedPhysicalMemory());
   return RelinkFreeListCategories(page);
 }
 
@@ -278,6 +310,7 @@ void PagedSpace::RemovePage(Page* page) {
     ExternalBackingStoreType t = static_cast<ExternalBackingStoreType>(i);
     DecrementExternalBackingStoreBytes(t, page->ExternalBackingStoreBytes(t));
   }
+  DecrementCommittedPhysicalMemory(page->CommittedPhysicalMemory());
 }
 
 void PagedSpace::SetTopAndLimit(Address top, Address limit) {
@@ -346,6 +379,7 @@ base::Optional<std::pair<Address, size_t>> PagedSpace::ExpandBackground(
   CHECK_LE(size_in_bytes, page->area_size());
   Free(page->area_start() + size_in_bytes, page->area_size() - size_in_bytes,
        SpaceAccountingMode::kSpaceAccounted);
+  AddRangeToActiveSystemPages(page, object_start, object_start + size_in_bytes);
   return std::make_pair(object_start, size_in_bytes);
 }
 
@@ -492,6 +526,7 @@ void PagedSpace::ReleasePage(Page* page) {
   }
 
   AccountUncommitted(page->size());
+  DecrementCommittedPhysicalMemory(page->CommittedPhysicalMemory());
   accounting_stats_.DecreaseCapacity(page->area_size());
   heap()->memory_allocator()->Free(MemoryAllocator::kConcurrently, page);
 }
@@ -573,6 +608,7 @@ bool PagedSpace::TryAllocationFromFreeListMain(size_t size_in_bytes,
     Free(limit, end - limit, SpaceAccountingMode::kSpaceAccounted);
   }
   SetLinearAllocationArea(start, limit);
+  AddRangeToActiveSystemPages(page, start, limit);
 
   return true;
 }
@@ -693,6 +729,7 @@ PagedSpace::TryAllocationFromFreeListBackground(size_t min_size_in_bytes,
     }
     Free(limit, end - limit, SpaceAccountingMode::kSpaceAccounted);
   }
+  AddRangeToActiveSystemPages(page, start, limit);
 
   return std::make_pair(start, used_size_in_bytes);
 }
@@ -1006,6 +1043,28 @@ AllocationResult PagedSpace::AllocateRawSlow(int size_in_bytes,
   return result;
 }
 
+void PagedSpace::AddRangeToActiveSystemPages(Page* page, Address start,
+                                             Address end) {
+  DCHECK_LE(page->address(), start);
+  DCHECK_LT(start, end);
+  DCHECK_LE(end, page->address() + Page::kPageSize);
+
+  const size_t added_pages = page->active_system_pages()->Add(
+      start - page->address(), end - page->address(),
+      MemoryAllocator::GetCommitPageSizeBits());
+
+  IncrementCommittedPhysicalMemory(added_pages *
+                                   MemoryAllocator::GetCommitPageSize());
+}
+
+void PagedSpace::ReduceActiveSystemPages(
+    Page* page, ActiveSystemPages active_system_pages) {
+  const size_t reduced_pages =
+      page->active_system_pages()->Reduce(active_system_pages);
+  DecrementCommittedPhysicalMemory(reduced_pages *
+                                   MemoryAllocator::GetCommitPageSize());
+}
+
 // -----------------------------------------------------------------------------
 // MapSpace implementation
 
diff --git a/src/heap/paged-spaces.h b/src/heap/paged-spaces.h
index 8bbe959e3c..2df7083a84 100644
--- a/src/heap/paged-spaces.h
+++ b/src/heap/paged-spaces.h
@@ -5,6 +5,7 @@
 #ifndef V8_HEAP_PAGED_SPACES_H_
 #define V8_HEAP_PAGED_SPACES_H_
 
+#include <atomic>
 #include <memory>
 #include <utility>
 
@@ -15,6 +16,7 @@
 #include "src/common/globals.h"
 #include "src/flags/flags.h"
 #include "src/heap/allocation-stats.h"
+#include "src/heap/memory-chunk-layout.h"
 #include "src/heap/memory-chunk.h"
 #include "src/heap/spaces.h"
 
@@ -108,6 +110,13 @@ class V8_EXPORT_PRIVATE PagedSpace
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory() override;
 
+#if DEBUG
+  void VerifyCommittedPhysicalMemory();
+#endif  // DEBUG
+
+  void IncrementCommittedPhysicalMemory(size_t increment_value);
+  void DecrementCommittedPhysicalMemory(size_t decrement_value);
+
   // Sets the capacity, the available space and the wasted space to zero.
   // The stats are rebuilt during sweeping by adding each page to the
   // capacity and the size when it is encountered.  As free spaces are
@@ -327,6 +336,10 @@ class V8_EXPORT_PRIVATE PagedSpace
     return &pending_allocation_mutex_;
   }
 
+  void AddRangeToActiveSystemPages(Page* page, Address start, Address end);
+  void ReduceActiveSystemPages(Page* page,
+                               ActiveSystemPages active_system_pages);
+
  private:
   class ConcurrentAllocationMutex {
    public:
@@ -423,6 +436,10 @@ class V8_EXPORT_PRIVATE PagedSpace
   V8_WARN_UNUSED_RESULT bool TryExpand(int size_in_bytes,
                                        AllocationOrigin origin);
 
+  size_t committed_physical_memory() const {
+    return committed_physical_memory_.load(std::memory_order_relaxed);
+  }
+
   Executability executable_;
 
   CompactionSpaceKind compaction_space_kind_;
@@ -443,6 +460,8 @@ class V8_EXPORT_PRIVATE PagedSpace
   // Protects original_top_ and original_limit_.
   base::SharedMutex pending_allocation_mutex_;
 
+  std::atomic<size_t> committed_physical_memory_{0};
+
   friend class IncrementalMarking;
   friend class MarkCompactCollector;
 
diff --git a/src/heap/spaces.cc b/src/heap/spaces.cc
index 161f1a7d33..77be40f779 100644
--- a/src/heap/spaces.cc
+++ b/src/heap/spaces.cc
@@ -13,6 +13,7 @@
 #include "src/base/macros.h"
 #include "src/base/sanitizer/msan.h"
 #include "src/common/globals.h"
+#include "src/heap/base/active-system-pages.h"
 #include "src/heap/combined-heap.h"
 #include "src/heap/concurrent-marking.h"
 #include "src/heap/gc-tracer.h"
@@ -22,6 +23,7 @@
 #include "src/heap/invalidated-slots-inl.h"
 #include "src/heap/large-spaces.h"
 #include "src/heap/mark-compact.h"
+#include "src/heap/memory-chunk-layout.h"
 #include "src/heap/memory-chunk.h"
 #include "src/heap/read-only-heap.h"
 #include "src/heap/remembered-set.h"
diff --git a/src/heap/spaces.h b/src/heap/spaces.h
index d7fbeedccc..18b760e1a5 100644
--- a/src/heap/spaces.h
+++ b/src/heap/spaces.h
@@ -13,11 +13,13 @@
 #include "src/common/globals.h"
 #include "src/heap/allocation-observer.h"
 #include "src/heap/base-space.h"
+#include "src/heap/base/active-system-pages.h"
 #include "src/heap/basic-memory-chunk.h"
 #include "src/heap/free-list.h"
 #include "src/heap/heap.h"
 #include "src/heap/linear-allocation-area.h"
 #include "src/heap/list.h"
+#include "src/heap/memory-chunk-layout.h"
 #include "src/heap/memory-chunk.h"
 #include "src/objects/objects.h"
 #include "src/utils/allocation.h"
@@ -307,6 +309,8 @@ class Page : public MemoryChunk {
   void MoveOldToNewRememberedSetForSweeping();
   void MergeOldToNewRememberedSets();
 
+  ActiveSystemPages* active_system_pages() { return &active_system_pages_; }
+
  private:
   friend class MemoryAllocator;
 };
diff --git a/src/heap/sweeper.cc b/src/heap/sweeper.cc
index 0bd5639d92..5695591cea 100644
--- a/src/heap/sweeper.cc
+++ b/src/heap/sweeper.cc
@@ -6,6 +6,7 @@
 
 #include "src/common/globals.h"
 #include "src/execution/vm-state-inl.h"
+#include "src/heap/base/active-system-pages.h"
 #include "src/heap/code-object-registry.h"
 #include "src/heap/free-list-inl.h"
 #include "src/heap/gc-tracer.h"
@@ -335,6 +336,15 @@ int Sweeper::RawSweep(
   CodeObjectRegistry* code_object_registry = p->GetCodeObjectRegistry();
   if (code_object_registry) code_object_registry->Clear();
 
+  base::Optional<ActiveSystemPages> active_system_pages_after_sweeping;
+  if (should_reduce_memory_) {
+    // Only decrement counter when we discard unused system pages.
+    active_system_pages_after_sweeping = ActiveSystemPages();
+    active_system_pages_after_sweeping->Init(
+        MemoryChunkLayout::kMemoryChunkHeaderSize,
+        MemoryAllocator::GetCommitPageSizeBits(), Page::kPageSize);
+  }
+
   // Phase 2: Free the non-live memory and clean-up the regular remembered set
   // entires.
 
@@ -389,6 +399,12 @@ int Sweeper::RawSweep(
     live_bytes += size;
     free_start = free_end + size;
 
+    if (active_system_pages_after_sweeping) {
+      active_system_pages_after_sweeping->Add(
+          free_end - p->address(), free_start - p->address(),
+          MemoryAllocator::GetCommitPageSizeBits());
+    }
+
 #ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
     p->object_start_bitmap()->SetBit(object.address());
 #endif
@@ -411,6 +427,13 @@ int Sweeper::RawSweep(
   CleanupInvalidTypedSlotsOfFreeRanges(p, free_ranges_map);
   ClearMarkBitsAndHandleLivenessStatistics(p, live_bytes, free_list_mode);
 
+  if (active_system_pages_after_sweeping) {
+    // Decrement accounted memory for discarded memory.
+    PagedSpace* paged_space = static_cast<PagedSpace*>(p->owner());
+    paged_space->ReduceActiveSystemPages(p,
+                                         *active_system_pages_after_sweeping);
+  }
+
   if (code_object_registry) code_object_registry->Finalize();
   p->set_concurrent_sweeping_state(Page::ConcurrentSweepingState::kDone);
   if (free_list_mode == IGNORE_FREE_LIST) return 0;
diff --git a/test/cctest/heap/test-spaces.cc b/test/cctest/heap/test-spaces.cc
index b3f5d538a3..9cc24525e2 100644
--- a/test/cctest/heap/test-spaces.cc
+++ b/test/cctest/heap/test-spaces.cc
@@ -114,7 +114,8 @@ class V8_NODISCARD TestCodePageAllocatorScope {
 static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
                               v8::PageAllocator* code_page_allocator,
                               size_t reserve_area_size, size_t commit_area_size,
-                              Executability executable, Space* space) {
+                              Executability executable, PageSize page_size,
+                              Space* space) {
   TestMemoryAllocatorScope test_allocator_scope(isolate, heap->MaxReserved());
   MemoryAllocator* memory_allocator = test_allocator_scope.allocator();
   TestCodePageAllocatorScope test_code_page_allocator_scope(
@@ -129,7 +130,7 @@ static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
       (executable == EXECUTABLE) ? MemoryChunkLayout::CodePageGuardSize() : 0;
 
   MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(
-      reserve_area_size, commit_area_size, executable, space);
+      reserve_area_size, commit_area_size, executable, page_size, space);
   size_t reserved_size =
       ((executable == EXECUTABLE))
           ? allocatable_memory_area_offset +
@@ -179,11 +180,12 @@ TEST(MemoryChunk) {
         base::PageInitializationMode::kAllocatedPagesCanBeUninitialized);
 
     VerifyMemoryChunk(isolate, heap, &code_page_allocator, reserve_area_size,
-                      initial_commit_area_size, EXECUTABLE, heap->code_space());
+                      initial_commit_area_size, EXECUTABLE, PageSize::kLarge,
+                      heap->code_space());
 
     VerifyMemoryChunk(isolate, heap, &code_page_allocator, reserve_area_size,
                       initial_commit_area_size, NOT_EXECUTABLE,
-                      heap->old_space());
+                      PageSize::kLarge, heap->old_space());
   }
 }
 
diff --git a/test/unittests/BUILD.gn b/test/unittests/BUILD.gn
index 1e06ba6628..d20d3bf0df 100644
--- a/test/unittests/BUILD.gn
+++ b/test/unittests/BUILD.gn
@@ -42,7 +42,10 @@ v8_executable("v8_heap_base_unittests") {
 v8_source_set("v8_heap_base_unittests_sources") {
   testonly = true
 
-  sources = [ "heap/base/worklist-unittest.cc" ]
+  sources = [
+    "heap/base/active-system-pages-unittest.cc",
+    "heap/base/worklist-unittest.cc",
+  ]
 
   configs = [
     "../..:external_config",
diff --git a/test/unittests/heap/base/active-system-pages-unittest.cc b/test/unittests/heap/base/active-system-pages-unittest.cc
new file mode 100644
index 0000000000..f04f9a94cc
--- /dev/null
+++ b/test/unittests/heap/base/active-system-pages-unittest.cc
@@ -0,0 +1,81 @@
+// Copyright 2022 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/heap/base/active-system-pages.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace heap {
+namespace base {
+
+TEST(ActiveSystemPagesTest, Add) {
+  ActiveSystemPages pages;
+  const size_t kPageSizeBits = 0;
+  EXPECT_EQ(pages.Add(0, 1, kPageSizeBits), size_t{1});
+  EXPECT_EQ(pages.Add(1, 2, kPageSizeBits), size_t{1});
+  EXPECT_EQ(pages.Add(63, 64, kPageSizeBits), size_t{1});
+  EXPECT_EQ(pages.Size(kPageSizeBits), size_t{3});
+
+  // Try to add page a second time.
+  EXPECT_EQ(pages.Add(0, 2, kPageSizeBits), size_t{0});
+}
+
+TEST(ActiveSystemPagesTest, AddUnalignedRange) {
+  ActiveSystemPages pages;
+  const size_t kPageSizeBits = 12;
+  const size_t kPageSize = size_t{1} << kPageSizeBits;
+  const size_t kWordSize = 8;
+  EXPECT_EQ(pages.Add(0, kPageSize + kWordSize, kPageSizeBits), size_t{2});
+  EXPECT_EQ(pages.Add(3 * kPageSize - kWordSize, 3 * kPageSize, kPageSizeBits),
+            size_t{1});
+  EXPECT_EQ(pages.Add(kPageSize + kWordSize, 3 * kPageSize - kWordSize,
+                      kPageSizeBits),
+            size_t{0});
+  EXPECT_EQ(pages.Size(kPageSizeBits), size_t{3} * kPageSize);
+}
+
+TEST(ActiveSystemPagesTest, AddFullBitset) {
+  ActiveSystemPages pages;
+  const size_t kPageSizeBits = 0;
+  EXPECT_EQ(pages.Add(0, 64, kPageSizeBits), size_t{64});
+  EXPECT_EQ(pages.Add(0, 64, kPageSizeBits), size_t{0});
+  EXPECT_EQ(pages.Size(kPageSizeBits), size_t{64});
+}
+
+TEST(ActiveSystemPagesTest, Reduce) {
+  ActiveSystemPages original;
+  const size_t kPageSizeBits = 0;
+  EXPECT_EQ(original.Add(0, 3, kPageSizeBits), size_t{3});
+
+  ActiveSystemPages updated;
+  EXPECT_EQ(updated.Add(1, 3, kPageSizeBits), size_t{2});
+
+  EXPECT_EQ(original.Reduce(updated), size_t{1});
+}
+
+TEST(ActiveSystemPagesTest, ReduceFullBitset) {
+  ActiveSystemPages original;
+  const size_t kPageSizeBits = 0;
+  EXPECT_EQ(original.Add(0, 64, kPageSizeBits), size_t{64});
+
+  ActiveSystemPages updated;
+  EXPECT_EQ(updated.Add(63, 64, kPageSizeBits), size_t{1});
+
+  EXPECT_EQ(original.Reduce(updated), size_t{63});
+}
+
+TEST(ActiveSystemPagesTest, Clear) {
+  ActiveSystemPages pages;
+  const size_t kPageSizeBits = 0;
+  EXPECT_EQ(pages.Add(0, 64, kPageSizeBits), size_t{64});
+  EXPECT_EQ(pages.Clear(), size_t{64});
+  EXPECT_EQ(pages.Size(kPageSizeBits), size_t{0});
+
+  EXPECT_EQ(pages.Add(0, 2, kPageSizeBits), size_t{2});
+  EXPECT_EQ(pages.Clear(), size_t{2});
+  EXPECT_EQ(pages.Size(kPageSizeBits), size_t{0});
+}
+
+}  // namespace base
+}  // namespace heap
diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py
index 3b132832dc..b0ebe1261c 100644
--- a/tools/v8heapconst.py
+++ b/tools/v8heapconst.py
@@ -272,287 +272,287 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-    ("read_only_space", 0x02149): (249, "MetaMap"),
-    ("read_only_space", 0x02171): (131, "NullMap"),
-    ("read_only_space", 0x02199): (234, "StrongDescriptorArrayMap"),
-    ("read_only_space", 0x021c1): (263, "WeakArrayListMap"),
-    ("read_only_space", 0x02205): (157, "EnumCacheMap"),
-    ("read_only_space", 0x02239): (178, "FixedArrayMap"),
-    ("read_only_space", 0x02285): (8, "OneByteInternalizedStringMap"),
-    ("read_only_space", 0x022d1): (246, "FreeSpaceMap"),
-    ("read_only_space", 0x022f9): (245, "OnePointerFillerMap"),
-    ("read_only_space", 0x02321): (245, "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): (193, "ByteArrayMap"),
-    ("read_only_space", 0x02565): (178, "FixedCOWArrayMap"),
-    ("read_only_space", 0x0258d): (179, "HashTableMap"),
-    ("read_only_space", 0x025b5): (128, "SymbolMap"),
-    ("read_only_space", 0x025dd): (40, "OneByteStringMap"),
-    ("read_only_space", 0x02605): (255, "ScopeInfoMap"),
-    ("read_only_space", 0x0262d): (256, "SharedFunctionInfoMap"),
-    ("read_only_space", 0x02655): (239, "CodeMap"),
-    ("read_only_space", 0x0267d): (203, "CellMap"),
-    ("read_only_space", 0x026a5): (254, "GlobalPropertyCellMap"),
-    ("read_only_space", 0x026cd): (204, "ForeignMap"),
-    ("read_only_space", 0x026f5): (238, "TransitionArrayMap"),
-    ("read_only_space", 0x0271d): (45, "ThinOneByteStringMap"),
-    ("read_only_space", 0x02745): (244, "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): (192, "ScriptContextTableMap"),
-    ("read_only_space", 0x02989): (190, "ClosureFeedbackCellArrayMap"),
-    ("read_only_space", 0x029b1): (243, "FeedbackMetadataArrayMap"),
-    ("read_only_space", 0x029d9): (178, "ArrayListMap"),
-    ("read_only_space", 0x02a01): (129, "BigIntMap"),
-    ("read_only_space", 0x02a29): (191, "ObjectBoilerplateDescriptionMap"),
-    ("read_only_space", 0x02a51): (194, "BytecodeArrayMap"),
-    ("read_only_space", 0x02a79): (240, "CodeDataContainerMap"),
-    ("read_only_space", 0x02aa1): (241, "CoverageInfoMap"),
-    ("read_only_space", 0x02ac9): (195, "FixedDoubleArrayMap"),
-    ("read_only_space", 0x02af1): (181, "GlobalDictionaryMap"),
-    ("read_only_space", 0x02b19): (159, "ManyClosuresCellMap"),
-    ("read_only_space", 0x02b41): (250, "MegaDomHandlerMap"),
-    ("read_only_space", 0x02b69): (178, "ModuleInfoMap"),
-    ("read_only_space", 0x02b91): (182, "NameDictionaryMap"),
-    ("read_only_space", 0x02bb9): (159, "NoClosuresCellMap"),
-    ("read_only_space", 0x02be1): (184, "NumberDictionaryMap"),
-    ("read_only_space", 0x02c09): (159, "OneClosureCellMap"),
-    ("read_only_space", 0x02c31): (185, "OrderedHashMapMap"),
-    ("read_only_space", 0x02c59): (186, "OrderedHashSetMap"),
-    ("read_only_space", 0x02c81): (183, "NameToIndexHashTableMap"),
-    ("read_only_space", 0x02ca9): (188, "RegisteredSymbolTableMap"),
-    ("read_only_space", 0x02cd1): (187, "OrderedNameDictionaryMap"),
-    ("read_only_space", 0x02cf9): (252, "PreparseDataMap"),
-    ("read_only_space", 0x02d21): (253, "PropertyArrayMap"),
-    ("read_only_space", 0x02d49): (153, "SideEffectCallHandlerInfoMap"),
-    ("read_only_space", 0x02d71): (153, "SideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02d99): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02dc1): (189, "SimpleNumberDictionaryMap"),
-    ("read_only_space", 0x02de9): (228, "SmallOrderedHashMapMap"),
-    ("read_only_space", 0x02e11): (229, "SmallOrderedHashSetMap"),
-    ("read_only_space", 0x02e39): (230, "SmallOrderedNameDictionaryMap"),
-    ("read_only_space", 0x02e61): (235, "SourceTextModuleMap"),
-    ("read_only_space", 0x02e89): (260, "SwissNameDictionaryMap"),
-    ("read_only_space", 0x02eb1): (236, "SyntheticModuleMap"),
-    ("read_only_space", 0x02ed9): (261, "WasmApiFunctionRefMap"),
-    ("read_only_space", 0x02f01): (222, "WasmCapiFunctionDataMap"),
-    ("read_only_space", 0x02f29): (223, "WasmExportedFunctionDataMap"),
-    ("read_only_space", 0x02f51): (205, "WasmInternalFunctionMap"),
-    ("read_only_space", 0x02f79): (224, "WasmJSFunctionDataMap"),
-    ("read_only_space", 0x02fa1): (262, "WasmOnFulfilledDataMap"),
-    ("read_only_space", 0x02fc9): (206, "WasmTypeInfoMap"),
-    ("read_only_space", 0x02ff1): (237, "WeakFixedArrayMap"),
-    ("read_only_space", 0x03019): (180, "EphemeronHashTableMap"),
-    ("read_only_space", 0x03041): (242, "EmbedderDataArrayMap"),
-    ("read_only_space", 0x03069): (264, "WeakCellMap"),
-    ("read_only_space", 0x03091): (32, "StringMap"),
-    ("read_only_space", 0x030b9): (41, "ConsOneByteStringMap"),
-    ("read_only_space", 0x030e1): (33, "ConsStringMap"),
-    ("read_only_space", 0x03109): (37, "ThinStringMap"),
-    ("read_only_space", 0x03131): (35, "SlicedStringMap"),
-    ("read_only_space", 0x03159): (43, "SlicedOneByteStringMap"),
-    ("read_only_space", 0x03181): (34, "ExternalStringMap"),
-    ("read_only_space", 0x031a9): (42, "ExternalOneByteStringMap"),
-    ("read_only_space", 0x031d1): (50, "UncachedExternalStringMap"),
-    ("read_only_space", 0x031f9): (0, "InternalizedStringMap"),
-    ("read_only_space", 0x03221): (2, "ExternalInternalizedStringMap"),
-    ("read_only_space", 0x03249): (10, "ExternalOneByteInternalizedStringMap"),
-    ("read_only_space", 0x03271): (18, "UncachedExternalInternalizedStringMap"),
-    ("read_only_space", 0x03299): (26, "UncachedExternalOneByteInternalizedStringMap"),
-    ("read_only_space", 0x032c1): (58, "UncachedExternalOneByteStringMap"),
-    ("read_only_space", 0x032e9): (104, "SharedOneByteStringMap"),
-    ("read_only_space", 0x03311): (96, "SharedStringMap"),
-    ("read_only_space", 0x03339): (109, "SharedThinOneByteStringMap"),
-    ("read_only_space", 0x03361): (101, "SharedThinStringMap"),
-    ("read_only_space", 0x03389): (96, "TwoByteSeqStringMigrationSentinelMap"),
-    ("read_only_space", 0x033b1): (104, "OneByteSeqStringMigrationSentinelMap"),
-    ("read_only_space", 0x033d9): (131, "SelfReferenceMarkerMap"),
-    ("read_only_space", 0x03401): (131, "BasicBlockCountersMarkerMap"),
-    ("read_only_space", 0x03445): (147, "ArrayBoilerplateDescriptionMap"),
-    ("read_only_space", 0x03545): (161, "InterceptorInfoMap"),
-    ("read_only_space", 0x06015): (132, "PromiseFulfillReactionJobTaskMap"),
-    ("read_only_space", 0x0603d): (133, "PromiseRejectReactionJobTaskMap"),
-    ("read_only_space", 0x06065): (134, "CallableTaskMap"),
-    ("read_only_space", 0x0608d): (135, "CallbackTaskMap"),
-    ("read_only_space", 0x060b5): (136, "PromiseResolveThenableJobTaskMap"),
-    ("read_only_space", 0x060dd): (139, "FunctionTemplateInfoMap"),
-    ("read_only_space", 0x06105): (140, "ObjectTemplateInfoMap"),
-    ("read_only_space", 0x0612d): (141, "AccessCheckInfoMap"),
-    ("read_only_space", 0x06155): (142, "AccessorInfoMap"),
-    ("read_only_space", 0x0617d): (143, "AccessorPairMap"),
-    ("read_only_space", 0x061a5): (144, "AliasedArgumentsEntryMap"),
-    ("read_only_space", 0x061cd): (145, "AllocationMementoMap"),
-    ("read_only_space", 0x061f5): (148, "AsmWasmDataMap"),
-    ("read_only_space", 0x0621d): (149, "AsyncGeneratorRequestMap"),
-    ("read_only_space", 0x06245): (150, "BreakPointMap"),
-    ("read_only_space", 0x0626d): (151, "BreakPointInfoMap"),
-    ("read_only_space", 0x06295): (152, "CachedTemplateObjectMap"),
-    ("read_only_space", 0x062bd): (154, "CallSiteInfoMap"),
-    ("read_only_space", 0x062e5): (155, "ClassPositionsMap"),
-    ("read_only_space", 0x0630d): (156, "DebugInfoMap"),
-    ("read_only_space", 0x06335): (158, "ErrorStackDataMap"),
-    ("read_only_space", 0x0635d): (160, "FunctionTemplateRareDataMap"),
-    ("read_only_space", 0x06385): (162, "InterpreterDataMap"),
-    ("read_only_space", 0x063ad): (163, "ModuleRequestMap"),
-    ("read_only_space", 0x063d5): (164, "PromiseCapabilityMap"),
-    ("read_only_space", 0x063fd): (165, "PromiseReactionMap"),
-    ("read_only_space", 0x06425): (166, "PropertyDescriptorObjectMap"),
-    ("read_only_space", 0x0644d): (167, "PrototypeInfoMap"),
-    ("read_only_space", 0x06475): (168, "RegExpBoilerplateDescriptionMap"),
-    ("read_only_space", 0x0649d): (169, "ScriptMap"),
-    ("read_only_space", 0x064c5): (170, "ScriptOrModuleMap"),
-    ("read_only_space", 0x064ed): (171, "SourceTextModuleInfoEntryMap"),
-    ("read_only_space", 0x06515): (172, "StackFrameInfoMap"),
-    ("read_only_space", 0x0653d): (173, "TemplateObjectDescriptionMap"),
-    ("read_only_space", 0x06565): (174, "Tuple2Map"),
-    ("read_only_space", 0x0658d): (175, "WasmContinuationObjectMap"),
-    ("read_only_space", 0x065b5): (176, "WasmExceptionTagMap"),
-    ("read_only_space", 0x065dd): (177, "WasmIndirectFunctionTableMap"),
-    ("read_only_space", 0x06605): (197, "SloppyArgumentsElementsMap"),
-    ("read_only_space", 0x0662d): (233, "DescriptorArrayMap"),
-    ("read_only_space", 0x06655): (219, "UncompiledDataWithoutPreparseDataMap"),
-    ("read_only_space", 0x0667d): (217, "UncompiledDataWithPreparseDataMap"),
-    ("read_only_space", 0x066a5): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
-    ("read_only_space", 0x066cd): (218, "UncompiledDataWithPreparseDataAndJobMap"),
-    ("read_only_space", 0x066f5): (251, "OnHeapBasicBlockProfilerDataMap"),
-    ("read_only_space", 0x0671d): (198, "TurbofanBitsetTypeMap"),
-    ("read_only_space", 0x06745): (202, "TurbofanUnionTypeMap"),
-    ("read_only_space", 0x0676d): (201, "TurbofanRangeTypeMap"),
-    ("read_only_space", 0x06795): (199, "TurbofanHeapConstantTypeMap"),
-    ("read_only_space", 0x067bd): (200, "TurbofanOtherNumberConstantTypeMap"),
-    ("read_only_space", 0x067e5): (247, "InternalClassMap"),
-    ("read_only_space", 0x0680d): (258, "SmiPairMap"),
-    ("read_only_space", 0x06835): (257, "SmiBoxMap"),
-    ("read_only_space", 0x0685d): (225, "ExportedSubClassBaseMap"),
-    ("read_only_space", 0x06885): (226, "ExportedSubClassMap"),
-    ("read_only_space", 0x068ad): (231, "AbstractInternalClassSubclass1Map"),
-    ("read_only_space", 0x068d5): (232, "AbstractInternalClassSubclass2Map"),
-    ("read_only_space", 0x068fd): (196, "InternalClassWithSmiElementsMap"),
-    ("read_only_space", 0x06925): (248, "InternalClassWithStructElementsMap"),
-    ("read_only_space", 0x0694d): (227, "ExportedSubClass2Map"),
-    ("read_only_space", 0x06975): (259, "SortStateMap"),
-    ("read_only_space", 0x0699d): (146, "AllocationSiteWithWeakNextMap"),
-    ("read_only_space", 0x069c5): (146, "AllocationSiteWithoutWeakNextMap"),
-    ("read_only_space", 0x069ed): (137, "LoadHandler1Map"),
-    ("read_only_space", 0x06a15): (137, "LoadHandler2Map"),
-    ("read_only_space", 0x06a3d): (137, "LoadHandler3Map"),
-    ("read_only_space", 0x06a65): (138, "StoreHandler0Map"),
-    ("read_only_space", 0x06a8d): (138, "StoreHandler1Map"),
-    ("read_only_space", 0x06ab5): (138, "StoreHandler2Map"),
-    ("read_only_space", 0x06add): (138, "StoreHandler3Map"),
-    ("map_space", 0x02149): (1057, "ExternalMap"),
-    ("map_space", 0x02171): (2115, "JSMessageObjectMap"),
+    ("read_only_space", 0x02151): (249, "MetaMap"),
+    ("read_only_space", 0x02179): (131, "NullMap"),
+    ("read_only_space", 0x021a1): (234, "StrongDescriptorArrayMap"),
+    ("read_only_space", 0x021c9): (263, "WeakArrayListMap"),
+    ("read_only_space", 0x0220d): (157, "EnumCacheMap"),
+    ("read_only_space", 0x02241): (178, "FixedArrayMap"),
+    ("read_only_space", 0x0228d): (8, "OneByteInternalizedStringMap"),
+    ("read_only_space", 0x022d9): (246, "FreeSpaceMap"),
+    ("read_only_space", 0x02301): (245, "OnePointerFillerMap"),
+    ("read_only_space", 0x02329): (245, "TwoPointerFillerMap"),
+    ("read_only_space", 0x02351): (131, "UninitializedMap"),
+    ("read_only_space", 0x023c9): (131, "UndefinedMap"),
+    ("read_only_space", 0x0240d): (130, "HeapNumberMap"),
+    ("read_only_space", 0x02441): (131, "TheHoleMap"),
+    ("read_only_space", 0x024a1): (131, "BooleanMap"),
+    ("read_only_space", 0x02545): (193, "ByteArrayMap"),
+    ("read_only_space", 0x0256d): (178, "FixedCOWArrayMap"),
+    ("read_only_space", 0x02595): (179, "HashTableMap"),
+    ("read_only_space", 0x025bd): (128, "SymbolMap"),
+    ("read_only_space", 0x025e5): (40, "OneByteStringMap"),
+    ("read_only_space", 0x0260d): (255, "ScopeInfoMap"),
+    ("read_only_space", 0x02635): (256, "SharedFunctionInfoMap"),
+    ("read_only_space", 0x0265d): (239, "CodeMap"),
+    ("read_only_space", 0x02685): (203, "CellMap"),
+    ("read_only_space", 0x026ad): (254, "GlobalPropertyCellMap"),
+    ("read_only_space", 0x026d5): (204, "ForeignMap"),
+    ("read_only_space", 0x026fd): (238, "TransitionArrayMap"),
+    ("read_only_space", 0x02725): (45, "ThinOneByteStringMap"),
+    ("read_only_space", 0x0274d): (244, "FeedbackVectorMap"),
+    ("read_only_space", 0x02785): (131, "ArgumentsMarkerMap"),
+    ("read_only_space", 0x027e5): (131, "ExceptionMap"),
+    ("read_only_space", 0x02841): (131, "TerminationExceptionMap"),
+    ("read_only_space", 0x028a9): (131, "OptimizedOutMap"),
+    ("read_only_space", 0x02909): (131, "StaleRegisterMap"),
+    ("read_only_space", 0x02969): (192, "ScriptContextTableMap"),
+    ("read_only_space", 0x02991): (190, "ClosureFeedbackCellArrayMap"),
+    ("read_only_space", 0x029b9): (243, "FeedbackMetadataArrayMap"),
+    ("read_only_space", 0x029e1): (178, "ArrayListMap"),
+    ("read_only_space", 0x02a09): (129, "BigIntMap"),
+    ("read_only_space", 0x02a31): (191, "ObjectBoilerplateDescriptionMap"),
+    ("read_only_space", 0x02a59): (194, "BytecodeArrayMap"),
+    ("read_only_space", 0x02a81): (240, "CodeDataContainerMap"),
+    ("read_only_space", 0x02aa9): (241, "CoverageInfoMap"),
+    ("read_only_space", 0x02ad1): (195, "FixedDoubleArrayMap"),
+    ("read_only_space", 0x02af9): (181, "GlobalDictionaryMap"),
+    ("read_only_space", 0x02b21): (159, "ManyClosuresCellMap"),
+    ("read_only_space", 0x02b49): (250, "MegaDomHandlerMap"),
+    ("read_only_space", 0x02b71): (178, "ModuleInfoMap"),
+    ("read_only_space", 0x02b99): (182, "NameDictionaryMap"),
+    ("read_only_space", 0x02bc1): (159, "NoClosuresCellMap"),
+    ("read_only_space", 0x02be9): (184, "NumberDictionaryMap"),
+    ("read_only_space", 0x02c11): (159, "OneClosureCellMap"),
+    ("read_only_space", 0x02c39): (185, "OrderedHashMapMap"),
+    ("read_only_space", 0x02c61): (186, "OrderedHashSetMap"),
+    ("read_only_space", 0x02c89): (183, "NameToIndexHashTableMap"),
+    ("read_only_space", 0x02cb1): (188, "RegisteredSymbolTableMap"),
+    ("read_only_space", 0x02cd9): (187, "OrderedNameDictionaryMap"),
+    ("read_only_space", 0x02d01): (252, "PreparseDataMap"),
+    ("read_only_space", 0x02d29): (253, "PropertyArrayMap"),
+    ("read_only_space", 0x02d51): (153, "SideEffectCallHandlerInfoMap"),
+    ("read_only_space", 0x02d79): (153, "SideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02da1): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02dc9): (189, "SimpleNumberDictionaryMap"),
+    ("read_only_space", 0x02df1): (228, "SmallOrderedHashMapMap"),
+    ("read_only_space", 0x02e19): (229, "SmallOrderedHashSetMap"),
+    ("read_only_space", 0x02e41): (230, "SmallOrderedNameDictionaryMap"),
+    ("read_only_space", 0x02e69): (235, "SourceTextModuleMap"),
+    ("read_only_space", 0x02e91): (260, "SwissNameDictionaryMap"),
+    ("read_only_space", 0x02eb9): (236, "SyntheticModuleMap"),
+    ("read_only_space", 0x02ee1): (261, "WasmApiFunctionRefMap"),
+    ("read_only_space", 0x02f09): (222, "WasmCapiFunctionDataMap"),
+    ("read_only_space", 0x02f31): (223, "WasmExportedFunctionDataMap"),
+    ("read_only_space", 0x02f59): (205, "WasmInternalFunctionMap"),
+    ("read_only_space", 0x02f81): (224, "WasmJSFunctionDataMap"),
+    ("read_only_space", 0x02fa9): (262, "WasmOnFulfilledDataMap"),
+    ("read_only_space", 0x02fd1): (206, "WasmTypeInfoMap"),
+    ("read_only_space", 0x02ff9): (237, "WeakFixedArrayMap"),
+    ("read_only_space", 0x03021): (180, "EphemeronHashTableMap"),
+    ("read_only_space", 0x03049): (242, "EmbedderDataArrayMap"),
+    ("read_only_space", 0x03071): (264, "WeakCellMap"),
+    ("read_only_space", 0x03099): (32, "StringMap"),
+    ("read_only_space", 0x030c1): (41, "ConsOneByteStringMap"),
+    ("read_only_space", 0x030e9): (33, "ConsStringMap"),
+    ("read_only_space", 0x03111): (37, "ThinStringMap"),
+    ("read_only_space", 0x03139): (35, "SlicedStringMap"),
+    ("read_only_space", 0x03161): (43, "SlicedOneByteStringMap"),
+    ("read_only_space", 0x03189): (34, "ExternalStringMap"),
+    ("read_only_space", 0x031b1): (42, "ExternalOneByteStringMap"),
+    ("read_only_space", 0x031d9): (50, "UncachedExternalStringMap"),
+    ("read_only_space", 0x03201): (0, "InternalizedStringMap"),
+    ("read_only_space", 0x03229): (2, "ExternalInternalizedStringMap"),
+    ("read_only_space", 0x03251): (10, "ExternalOneByteInternalizedStringMap"),
+    ("read_only_space", 0x03279): (18, "UncachedExternalInternalizedStringMap"),
+    ("read_only_space", 0x032a1): (26, "UncachedExternalOneByteInternalizedStringMap"),
+    ("read_only_space", 0x032c9): (58, "UncachedExternalOneByteStringMap"),
+    ("read_only_space", 0x032f1): (104, "SharedOneByteStringMap"),
+    ("read_only_space", 0x03319): (96, "SharedStringMap"),
+    ("read_only_space", 0x03341): (109, "SharedThinOneByteStringMap"),
+    ("read_only_space", 0x03369): (101, "SharedThinStringMap"),
+    ("read_only_space", 0x03391): (96, "TwoByteSeqStringMigrationSentinelMap"),
+    ("read_only_space", 0x033b9): (104, "OneByteSeqStringMigrationSentinelMap"),
+    ("read_only_space", 0x033e1): (131, "SelfReferenceMarkerMap"),
+    ("read_only_space", 0x03409): (131, "BasicBlockCountersMarkerMap"),
+    ("read_only_space", 0x0344d): (147, "ArrayBoilerplateDescriptionMap"),
+    ("read_only_space", 0x0354d): (161, "InterceptorInfoMap"),
+    ("read_only_space", 0x0601d): (132, "PromiseFulfillReactionJobTaskMap"),
+    ("read_only_space", 0x06045): (133, "PromiseRejectReactionJobTaskMap"),
+    ("read_only_space", 0x0606d): (134, "CallableTaskMap"),
+    ("read_only_space", 0x06095): (135, "CallbackTaskMap"),
+    ("read_only_space", 0x060bd): (136, "PromiseResolveThenableJobTaskMap"),
+    ("read_only_space", 0x060e5): (139, "FunctionTemplateInfoMap"),
+    ("read_only_space", 0x0610d): (140, "ObjectTemplateInfoMap"),
+    ("read_only_space", 0x06135): (141, "AccessCheckInfoMap"),
+    ("read_only_space", 0x0615d): (142, "AccessorInfoMap"),
+    ("read_only_space", 0x06185): (143, "AccessorPairMap"),
+    ("read_only_space", 0x061ad): (144, "AliasedArgumentsEntryMap"),
+    ("read_only_space", 0x061d5): (145, "AllocationMementoMap"),
+    ("read_only_space", 0x061fd): (148, "AsmWasmDataMap"),
+    ("read_only_space", 0x06225): (149, "AsyncGeneratorRequestMap"),
+    ("read_only_space", 0x0624d): (150, "BreakPointMap"),
+    ("read_only_space", 0x06275): (151, "BreakPointInfoMap"),
+    ("read_only_space", 0x0629d): (152, "CachedTemplateObjectMap"),
+    ("read_only_space", 0x062c5): (154, "CallSiteInfoMap"),
+    ("read_only_space", 0x062ed): (155, "ClassPositionsMap"),
+    ("read_only_space", 0x06315): (156, "DebugInfoMap"),
+    ("read_only_space", 0x0633d): (158, "ErrorStackDataMap"),
+    ("read_only_space", 0x06365): (160, "FunctionTemplateRareDataMap"),
+    ("read_only_space", 0x0638d): (162, "InterpreterDataMap"),
+    ("read_only_space", 0x063b5): (163, "ModuleRequestMap"),
+    ("read_only_space", 0x063dd): (164, "PromiseCapabilityMap"),
+    ("read_only_space", 0x06405): (165, "PromiseReactionMap"),
+    ("read_only_space", 0x0642d): (166, "PropertyDescriptorObjectMap"),
+    ("read_only_space", 0x06455): (167, "PrototypeInfoMap"),
+    ("read_only_space", 0x0647d): (168, "RegExpBoilerplateDescriptionMap"),
+    ("read_only_space", 0x064a5): (169, "ScriptMap"),
+    ("read_only_space", 0x064cd): (170, "ScriptOrModuleMap"),
+    ("read_only_space", 0x064f5): (171, "SourceTextModuleInfoEntryMap"),
+    ("read_only_space", 0x0651d): (172, "StackFrameInfoMap"),
+    ("read_only_space", 0x06545): (173, "TemplateObjectDescriptionMap"),
+    ("read_only_space", 0x0656d): (174, "Tuple2Map"),
+    ("read_only_space", 0x06595): (175, "WasmContinuationObjectMap"),
+    ("read_only_space", 0x065bd): (176, "WasmExceptionTagMap"),
+    ("read_only_space", 0x065e5): (177, "WasmIndirectFunctionTableMap"),
+    ("read_only_space", 0x0660d): (197, "SloppyArgumentsElementsMap"),
+    ("read_only_space", 0x06635): (233, "DescriptorArrayMap"),
+    ("read_only_space", 0x0665d): (219, "UncompiledDataWithoutPreparseDataMap"),
+    ("read_only_space", 0x06685): (217, "UncompiledDataWithPreparseDataMap"),
+    ("read_only_space", 0x066ad): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
+    ("read_only_space", 0x066d5): (218, "UncompiledDataWithPreparseDataAndJobMap"),
+    ("read_only_space", 0x066fd): (251, "OnHeapBasicBlockProfilerDataMap"),
+    ("read_only_space", 0x06725): (198, "TurbofanBitsetTypeMap"),
+    ("read_only_space", 0x0674d): (202, "TurbofanUnionTypeMap"),
+    ("read_only_space", 0x06775): (201, "TurbofanRangeTypeMap"),
+    ("read_only_space", 0x0679d): (199, "TurbofanHeapConstantTypeMap"),
+    ("read_only_space", 0x067c5): (200, "TurbofanOtherNumberConstantTypeMap"),
+    ("read_only_space", 0x067ed): (247, "InternalClassMap"),
+    ("read_only_space", 0x06815): (258, "SmiPairMap"),
+    ("read_only_space", 0x0683d): (257, "SmiBoxMap"),
+    ("read_only_space", 0x06865): (225, "ExportedSubClassBaseMap"),
+    ("read_only_space", 0x0688d): (226, "ExportedSubClassMap"),
+    ("read_only_space", 0x068b5): (231, "AbstractInternalClassSubclass1Map"),
+    ("read_only_space", 0x068dd): (232, "AbstractInternalClassSubclass2Map"),
+    ("read_only_space", 0x06905): (196, "InternalClassWithSmiElementsMap"),
+    ("read_only_space", 0x0692d): (248, "InternalClassWithStructElementsMap"),
+    ("read_only_space", 0x06955): (227, "ExportedSubClass2Map"),
+    ("read_only_space", 0x0697d): (259, "SortStateMap"),
+    ("read_only_space", 0x069a5): (146, "AllocationSiteWithWeakNextMap"),
+    ("read_only_space", 0x069cd): (146, "AllocationSiteWithoutWeakNextMap"),
+    ("read_only_space", 0x069f5): (137, "LoadHandler1Map"),
+    ("read_only_space", 0x06a1d): (137, "LoadHandler2Map"),
+    ("read_only_space", 0x06a45): (137, "LoadHandler3Map"),
+    ("read_only_space", 0x06a6d): (138, "StoreHandler0Map"),
+    ("read_only_space", 0x06a95): (138, "StoreHandler1Map"),
+    ("read_only_space", 0x06abd): (138, "StoreHandler2Map"),
+    ("read_only_space", 0x06ae5): (138, "StoreHandler3Map"),
+    ("map_space", 0x02151): (1057, "ExternalMap"),
+    ("map_space", 0x02179): (2115, "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", 0x03429): "EmptyPropertyArray",
-  ("read_only_space", 0x03431): "EmptyByteArray",
-  ("read_only_space", 0x03439): "EmptyObjectBoilerplateDescription",
-  ("read_only_space", 0x0346d): "EmptyArrayBoilerplateDescription",
-  ("read_only_space", 0x03479): "EmptyClosureFeedbackCellArray",
-  ("read_only_space", 0x03481): "EmptySlowElementDictionary",
-  ("read_only_space", 0x034a5): "EmptyOrderedHashMap",
-  ("read_only_space", 0x034b9): "EmptyOrderedHashSet",
-  ("read_only_space", 0x034cd): "EmptyFeedbackMetadata",
-  ("read_only_space", 0x034d9): "EmptyPropertyDictionary",
-  ("read_only_space", 0x03501): "EmptyOrderedPropertyDictionary",
-  ("read_only_space", 0x03519): "EmptySwissPropertyDictionary",
-  ("read_only_space", 0x0356d): "NoOpInterceptorInfo",
-  ("read_only_space", 0x03595): "EmptyArrayList",
-  ("read_only_space", 0x035a1): "EmptyWeakFixedArray",
-  ("read_only_space", 0x035a9): "InfinityValue",
-  ("read_only_space", 0x035b5): "MinusZeroValue",
-  ("read_only_space", 0x035c1): "MinusInfinityValue",
-  ("read_only_space", 0x035cd): "SelfReferenceMarker",
-  ("read_only_space", 0x0360d): "BasicBlockCountersMarker",
-  ("read_only_space", 0x03651): "OffHeapTrampolineRelocationInfo",
-  ("read_only_space", 0x0365d): "GlobalThisBindingScopeInfo",
-  ("read_only_space", 0x0368d): "EmptyFunctionScopeInfo",
-  ("read_only_space", 0x036b1): "NativeScopeInfo",
-  ("read_only_space", 0x036c9): "HashSeed",
-  ("old_space", 0x04215): "ArgumentsIteratorAccessor",
-  ("old_space", 0x04259): "ArrayLengthAccessor",
-  ("old_space", 0x0429d): "BoundFunctionLengthAccessor",
-  ("old_space", 0x042e1): "BoundFunctionNameAccessor",
-  ("old_space", 0x04325): "ErrorStackAccessor",
-  ("old_space", 0x04369): "FunctionArgumentsAccessor",
-  ("old_space", 0x043ad): "FunctionCallerAccessor",
-  ("old_space", 0x043f1): "FunctionNameAccessor",
-  ("old_space", 0x04435): "FunctionLengthAccessor",
-  ("old_space", 0x04479): "FunctionPrototypeAccessor",
-  ("old_space", 0x044bd): "StringLengthAccessor",
-  ("old_space", 0x04501): "InvalidPrototypeValidityCell",
-  ("old_space", 0x04509): "EmptyScript",
-  ("old_space", 0x04549): "ManyClosuresCell",
-  ("old_space", 0x04555): "ArrayConstructorProtector",
-  ("old_space", 0x04569): "NoElementsProtector",
-  ("old_space", 0x0457d): "MegaDOMProtector",
-  ("old_space", 0x04591): "IsConcatSpreadableProtector",
-  ("old_space", 0x045a5): "ArraySpeciesProtector",
-  ("old_space", 0x045b9): "TypedArraySpeciesProtector",
-  ("old_space", 0x045cd): "PromiseSpeciesProtector",
-  ("old_space", 0x045e1): "RegExpSpeciesProtector",
-  ("old_space", 0x045f5): "StringLengthProtector",
-  ("old_space", 0x04609): "ArrayIteratorProtector",
-  ("old_space", 0x0461d): "ArrayBufferDetachingProtector",
-  ("old_space", 0x04631): "PromiseHookProtector",
-  ("old_space", 0x04645): "PromiseResolveProtector",
-  ("old_space", 0x04659): "MapIteratorProtector",
-  ("old_space", 0x0466d): "PromiseThenProtector",
-  ("old_space", 0x04681): "SetIteratorProtector",
-  ("old_space", 0x04695): "StringIteratorProtector",
-  ("old_space", 0x046a9): "SingleCharacterStringCache",
-  ("old_space", 0x04ab1): "StringSplitCache",
-  ("old_space", 0x04eb9): "RegExpMultipleCache",
-  ("old_space", 0x052c1): "BuiltinsConstantsTable",
-  ("old_space", 0x056ed): "AsyncFunctionAwaitRejectSharedFun",
-  ("old_space", 0x05711): "AsyncFunctionAwaitResolveSharedFun",
-  ("old_space", 0x05735): "AsyncGeneratorAwaitRejectSharedFun",
-  ("old_space", 0x05759): "AsyncGeneratorAwaitResolveSharedFun",
-  ("old_space", 0x0577d): "AsyncGeneratorYieldResolveSharedFun",
-  ("old_space", 0x057a1): "AsyncGeneratorReturnResolveSharedFun",
-  ("old_space", 0x057c5): "AsyncGeneratorReturnClosedRejectSharedFun",
-  ("old_space", 0x057e9): "AsyncGeneratorReturnClosedResolveSharedFun",
-  ("old_space", 0x0580d): "AsyncIteratorValueUnwrapSharedFun",
-  ("old_space", 0x05831): "PromiseAllResolveElementSharedFun",
-  ("old_space", 0x05855): "PromiseAllSettledResolveElementSharedFun",
-  ("old_space", 0x05879): "PromiseAllSettledRejectElementSharedFun",
-  ("old_space", 0x0589d): "PromiseAnyRejectElementSharedFun",
-  ("old_space", 0x058c1): "PromiseCapabilityDefaultRejectSharedFun",
-  ("old_space", 0x058e5): "PromiseCapabilityDefaultResolveSharedFun",
-  ("old_space", 0x05909): "PromiseCatchFinallySharedFun",
-  ("old_space", 0x0592d): "PromiseGetCapabilitiesExecutorSharedFun",
-  ("old_space", 0x05951): "PromiseThenFinallySharedFun",
-  ("old_space", 0x05975): "PromiseThrowerFinallySharedFun",
-  ("old_space", 0x05999): "PromiseValueThunkFinallySharedFun",
-  ("old_space", 0x059bd): "ProxyRevokeSharedFun",
+  ("read_only_space", 0x021f1): "EmptyWeakArrayList",
+  ("read_only_space", 0x021fd): "EmptyDescriptorArray",
+  ("read_only_space", 0x02235): "EmptyEnumCache",
+  ("read_only_space", 0x02269): "EmptyFixedArray",
+  ("read_only_space", 0x02271): "NullValue",
+  ("read_only_space", 0x02379): "UninitializedValue",
+  ("read_only_space", 0x023f1): "UndefinedValue",
+  ("read_only_space", 0x02435): "NanValue",
+  ("read_only_space", 0x02469): "TheHoleValue",
+  ("read_only_space", 0x02495): "HoleNanValue",
+  ("read_only_space", 0x024c9): "TrueValue",
+  ("read_only_space", 0x02509): "FalseValue",
+  ("read_only_space", 0x02539): "empty_string",
+  ("read_only_space", 0x02775): "EmptyScopeInfo",
+  ("read_only_space", 0x027ad): "ArgumentsMarker",
+  ("read_only_space", 0x0280d): "Exception",
+  ("read_only_space", 0x02869): "TerminationException",
+  ("read_only_space", 0x028d1): "OptimizedOut",
+  ("read_only_space", 0x02931): "StaleRegister",
+  ("read_only_space", 0x03431): "EmptyPropertyArray",
+  ("read_only_space", 0x03439): "EmptyByteArray",
+  ("read_only_space", 0x03441): "EmptyObjectBoilerplateDescription",
+  ("read_only_space", 0x03475): "EmptyArrayBoilerplateDescription",
+  ("read_only_space", 0x03481): "EmptyClosureFeedbackCellArray",
+  ("read_only_space", 0x03489): "EmptySlowElementDictionary",
+  ("read_only_space", 0x034ad): "EmptyOrderedHashMap",
+  ("read_only_space", 0x034c1): "EmptyOrderedHashSet",
+  ("read_only_space", 0x034d5): "EmptyFeedbackMetadata",
+  ("read_only_space", 0x034e1): "EmptyPropertyDictionary",
+  ("read_only_space", 0x03509): "EmptyOrderedPropertyDictionary",
+  ("read_only_space", 0x03521): "EmptySwissPropertyDictionary",
+  ("read_only_space", 0x03575): "NoOpInterceptorInfo",
+  ("read_only_space", 0x0359d): "EmptyArrayList",
+  ("read_only_space", 0x035a9): "EmptyWeakFixedArray",
+  ("read_only_space", 0x035b1): "InfinityValue",
+  ("read_only_space", 0x035bd): "MinusZeroValue",
+  ("read_only_space", 0x035c9): "MinusInfinityValue",
+  ("read_only_space", 0x035d5): "SelfReferenceMarker",
+  ("read_only_space", 0x03615): "BasicBlockCountersMarker",
+  ("read_only_space", 0x03659): "OffHeapTrampolineRelocationInfo",
+  ("read_only_space", 0x03665): "GlobalThisBindingScopeInfo",
+  ("read_only_space", 0x03695): "EmptyFunctionScopeInfo",
+  ("read_only_space", 0x036b9): "NativeScopeInfo",
+  ("read_only_space", 0x036d1): "HashSeed",
+  ("old_space", 0x0421d): "ArgumentsIteratorAccessor",
+  ("old_space", 0x04261): "ArrayLengthAccessor",
+  ("old_space", 0x042a5): "BoundFunctionLengthAccessor",
+  ("old_space", 0x042e9): "BoundFunctionNameAccessor",
+  ("old_space", 0x0432d): "ErrorStackAccessor",
+  ("old_space", 0x04371): "FunctionArgumentsAccessor",
+  ("old_space", 0x043b5): "FunctionCallerAccessor",
+  ("old_space", 0x043f9): "FunctionNameAccessor",
+  ("old_space", 0x0443d): "FunctionLengthAccessor",
+  ("old_space", 0x04481): "FunctionPrototypeAccessor",
+  ("old_space", 0x044c5): "StringLengthAccessor",
+  ("old_space", 0x04509): "InvalidPrototypeValidityCell",
+  ("old_space", 0x04511): "EmptyScript",
+  ("old_space", 0x04551): "ManyClosuresCell",
+  ("old_space", 0x0455d): "ArrayConstructorProtector",
+  ("old_space", 0x04571): "NoElementsProtector",
+  ("old_space", 0x04585): "MegaDOMProtector",
+  ("old_space", 0x04599): "IsConcatSpreadableProtector",
+  ("old_space", 0x045ad): "ArraySpeciesProtector",
+  ("old_space", 0x045c1): "TypedArraySpeciesProtector",
+  ("old_space", 0x045d5): "PromiseSpeciesProtector",
+  ("old_space", 0x045e9): "RegExpSpeciesProtector",
+  ("old_space", 0x045fd): "StringLengthProtector",
+  ("old_space", 0x04611): "ArrayIteratorProtector",
+  ("old_space", 0x04625): "ArrayBufferDetachingProtector",
+  ("old_space", 0x04639): "PromiseHookProtector",
+  ("old_space", 0x0464d): "PromiseResolveProtector",
+  ("old_space", 0x04661): "MapIteratorProtector",
+  ("old_space", 0x04675): "PromiseThenProtector",
+  ("old_space", 0x04689): "SetIteratorProtector",
+  ("old_space", 0x0469d): "StringIteratorProtector",
+  ("old_space", 0x046b1): "SingleCharacterStringCache",
+  ("old_space", 0x04ab9): "StringSplitCache",
+  ("old_space", 0x04ec1): "RegExpMultipleCache",
+  ("old_space", 0x052c9): "BuiltinsConstantsTable",
+  ("old_space", 0x056f5): "AsyncFunctionAwaitRejectSharedFun",
+  ("old_space", 0x05719): "AsyncFunctionAwaitResolveSharedFun",
+  ("old_space", 0x0573d): "AsyncGeneratorAwaitRejectSharedFun",
+  ("old_space", 0x05761): "AsyncGeneratorAwaitResolveSharedFun",
+  ("old_space", 0x05785): "AsyncGeneratorYieldResolveSharedFun",
+  ("old_space", 0x057a9): "AsyncGeneratorReturnResolveSharedFun",
+  ("old_space", 0x057cd): "AsyncGeneratorReturnClosedRejectSharedFun",
+  ("old_space", 0x057f1): "AsyncGeneratorReturnClosedResolveSharedFun",
+  ("old_space", 0x05815): "AsyncIteratorValueUnwrapSharedFun",
+  ("old_space", 0x05839): "PromiseAllResolveElementSharedFun",
+  ("old_space", 0x0585d): "PromiseAllSettledResolveElementSharedFun",
+  ("old_space", 0x05881): "PromiseAllSettledRejectElementSharedFun",
+  ("old_space", 0x058a5): "PromiseAnyRejectElementSharedFun",
+  ("old_space", 0x058c9): "PromiseCapabilityDefaultRejectSharedFun",
+  ("old_space", 0x058ed): "PromiseCapabilityDefaultResolveSharedFun",
+  ("old_space", 0x05911): "PromiseCatchFinallySharedFun",
+  ("old_space", 0x05935): "PromiseGetCapabilitiesExecutorSharedFun",
+  ("old_space", 0x05959): "PromiseThenFinallySharedFun",
+  ("old_space", 0x0597d): "PromiseThrowerFinallySharedFun",
+  ("old_space", 0x059a1): "PromiseValueThunkFinallySharedFun",
+  ("old_space", 0x059c5): "ProxyRevokeSharedFun",
 }
 
 # Lower 32 bits of first page addresses for various heap spaces.