AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[heap] Merge marking states

Browse Source 
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/+/3735163
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: Omer Katz <omerkatz@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81468}
This commit is contained in:
Omer Katz 2022-06-30 16:13:22 +02:00 committed by V8 LUCI CQ
parent b9af74c80a
commit 7626202118
25 changed files with 355 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/heap/basic-memory-chunk.h
View File

@ -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;
};

2
src/heap/concurrent-marking.cc
View File

@ -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;

4
src/heap/concurrent-marking.h
View File

@ -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);

2
src/heap/cppgc-js/unified-heap-marking-state.h
View File

@ -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_;
};

2
src/heap/incremental-marking.cc
View File

@ -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();

4
src/heap/incremental-marking.h
View File

@ -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)

4
src/heap/invalidated-slots.h
View File

@ -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_;

1
src/heap/large-spaces.cc
View File

@ -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()

40
src/heap/mark-compact.cc
View File

@ -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:

80
src/heap/mark-compact.h
View File

@ -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);

2
src/heap/marking-barrier.h
View File

@ -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);

2
src/heap/memory-chunk-layout.h
View File

@ -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),

22
src/heap/memory-chunk.cc
View File

@ -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);

18
src/heap/memory-chunk.h
View File

@ -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;
};

9
src/heap/new-spaces.cc
View File

@ -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);

4
src/heap/object-stats.cc
View File

@ -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_;
};

3
src/heap/paged-spaces.cc
View File

@ -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());

2
src/heap/scavenger.cc
View File

@ -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 :

10
src/heap/spaces.cc
View File

@ -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));

4
src/heap/sweeper.cc
View File

@ -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

6
src/heap/sweeper.h
View File

@ -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_;

14
test/cctest/heap/test-heap.cc
View File

@ -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);

2
test/cctest/heap/test-mark-compact.cc
View File

@ -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());

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

@ -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());

564
tools/v8heapconst.py
View File

@ -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.