[heap] Reland: Reduce size of possibly empty buckets
Before this CL a byte was used per bucket to store whether the bucket is possibly empty or not. This CL changes this such that each bucket only needs a single bit. PossiblyEmptyBuckets is now a word in the page header. If more bits are needed than fit into a single word, an external bitmap is allocated using AlignedAlloc. Storing this on the page header, allows to remove initial_buckets from the SlotSet. The SlotSet allocation is then again a power-of-2 in release mode. Reland of https://crrev.com/c/1906376: Incorrect DCHECK was removed. WordsForBuckets was simplified and a test was added for it. Bug: chromium:1023139 Change-Id: I9a08e03a9c10e5781a146b9a28dab38824aad91f Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1954391 Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Commit-Queue: Dominik Inführ <dinfuehr@chromium.org> Cr-Commit-Position: refs/heads/master@{#65385}
This commit is contained in:
Dominik Inführ
Commit Bot
parent
efe01b8819
commit
56f56df6bb
@ -41,20 +41,6 @@ class RememberedSetOperations {
|
||||
return slots;
|
||||
}
|
||||
|
||||
template <typename Callback>
|
||||
static int IterateAndTrackEmptyBuckets(
|
||||
SlotSet* slot_set, MemoryChunk* chunk, Callback callback,
|
||||
Worklist<MemoryChunk*, 64>::View empty_chunks) {
|
||||
int slots = 0;
|
||||
if (slot_set != nullptr) {
|
||||
bool found_empty_bucket = false;
|
||||
slots += slot_set->IterateAndTrackEmptyBuckets(
|
||||
chunk->address(), chunk->buckets(), callback, &found_empty_bucket);
|
||||
if (found_empty_bucket) empty_chunks.Push(chunk);
|
||||
}
|
||||
return slots;
|
||||
}
|
||||
|
||||
static void Remove(SlotSet* slot_set, MemoryChunk* chunk, Address slot_addr) {
|
||||
if (slot_set != nullptr) {
|
||||
uintptr_t offset = slot_addr - chunk->address();
|
||||
@ -168,12 +154,16 @@ class RememberedSet : public AllStatic {
|
||||
static int IterateAndTrackEmptyBuckets(
|
||||
MemoryChunk* chunk, Callback callback,
|
||||
Worklist<MemoryChunk*, 64>::View empty_chunks) {
|
||||
SlotSet* slots = chunk->slot_set<type>();
|
||||
bool empty_bucket_found = false;
|
||||
int slot_count = RememberedSetOperations::IterateAndTrackEmptyBuckets(
|
||||
slots, chunk, callback, empty_chunks);
|
||||
if (empty_bucket_found) empty_chunks.Push(chunk);
|
||||
return slot_count;
|
||||
SlotSet* slot_set = chunk->slot_set<type>();
|
||||
int slots = 0;
|
||||
if (slot_set != nullptr) {
|
||||
PossiblyEmptyBuckets* possibly_empty_buckets =
|
||||
chunk->possibly_empty_buckets();
|
||||
slots += slot_set->IterateAndTrackEmptyBuckets(
|
||||
chunk->address(), chunk->buckets(), callback, possibly_empty_buckets);
|
||||
if (!possibly_empty_buckets->IsEmpty()) empty_chunks.Push(chunk);
|
||||
}
|
||||
return slots;
|
||||
}
|
||||
|
||||
static void FreeEmptyBuckets(MemoryChunk* chunk) {
|
||||
@ -188,7 +178,8 @@ class RememberedSet : public AllStatic {
|
||||
DCHECK(type == OLD_TO_NEW);
|
||||
SlotSet* slot_set = chunk->slot_set<type, AccessMode::NON_ATOMIC>();
|
||||
if (slot_set != nullptr &&
|
||||
slot_set->CheckPossiblyEmptyBuckets(chunk->buckets())) {
|
||||
slot_set->CheckPossiblyEmptyBuckets(chunk->buckets(),
|
||||
chunk->possibly_empty_buckets())) {
|
||||
chunk->ReleaseSlotSet<type>();
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -373,9 +373,7 @@ void ScavengerCollector::CollectGarbage() {
|
||||
#ifdef DEBUG
|
||||
RememberedSet<OLD_TO_NEW>::IterateMemoryChunks(
|
||||
heap_, [](MemoryChunk* chunk) {
|
||||
SlotSet* slot_set = chunk->slot_set<OLD_TO_NEW>();
|
||||
DCHECK_IMPLIES(slot_set != nullptr,
|
||||
slot_set->IsPossiblyEmptyCleared());
|
||||
DCHECK(chunk->possibly_empty_buckets()->IsEmpty());
|
||||
});
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -23,6 +23,107 @@ namespace internal {
|
||||
|
||||
enum SlotCallbackResult { KEEP_SLOT, REMOVE_SLOT };
|
||||
|
||||
// Possibly empty buckets (buckets that do not contain any slots) are discovered
|
||||
// by the scavenger. Buckets might become non-empty when promoting objects later
|
||||
// or in another thread, so all those buckets need to be revisited.
|
||||
// Track possibly empty buckets within a SlotSet in this data structure. The
|
||||
// class contains a word-sized bitmap, in case more bits are needed the bitmap
|
||||
// is replaced with a pointer to a malloc-allocated bitmap.
|
||||
class PossiblyEmptyBuckets {
|
||||
public:
|
||||
PossiblyEmptyBuckets() : bitmap_(kNullAddress) {}
|
||||
PossiblyEmptyBuckets(PossiblyEmptyBuckets&& other) V8_NOEXCEPT
|
||||
: bitmap_(other.bitmap_) {
|
||||
other.bitmap_ = kNullAddress;
|
||||
}
|
||||
|
||||
~PossiblyEmptyBuckets() { Release(); }
|
||||
|
||||
void Initialize() {
|
||||
bitmap_ = kNullAddress;
|
||||
DCHECK(!IsAllocated());
|
||||
}
|
||||
|
||||
void Release() {
|
||||
if (IsAllocated()) {
|
||||
AlignedFree(BitmapArray());
|
||||
}
|
||||
bitmap_ = kNullAddress;
|
||||
DCHECK(!IsAllocated());
|
||||
}
|
||||
|
||||
void Insert(size_t bucket_index, size_t buckets) {
|
||||
if (IsAllocated()) {
|
||||
InsertAllocated(bucket_index);
|
||||
} else if (bucket_index + 1 < kBitsPerWord) {
|
||||
bitmap_ |= static_cast<uintptr_t>(1) << (bucket_index + 1);
|
||||
} else {
|
||||
Allocate(buckets);
|
||||
InsertAllocated(bucket_index);
|
||||
}
|
||||
}
|
||||
|
||||
bool Contains(size_t bucket_index) {
|
||||
if (IsAllocated()) {
|
||||
size_t word_idx = bucket_index / kBitsPerWord;
|
||||
uintptr_t* word = BitmapArray() + word_idx;
|
||||
return *word &
|
||||
(static_cast<uintptr_t>(1) << (bucket_index % kBitsPerWord));
|
||||
} else if (bucket_index + 1 < kBitsPerWord) {
|
||||
return bitmap_ & (static_cast<uintptr_t>(1) << (bucket_index + 1));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool IsEmpty() { return bitmap_ == kNullAddress; }
|
||||
|
||||
private:
|
||||
Address bitmap_;
|
||||
static const Address kPointerTag = 1;
|
||||
static const int kWordSize = sizeof(uintptr_t);
|
||||
static const int kBitsPerWord = kWordSize * kBitsPerByte;
|
||||
|
||||
bool IsAllocated() { return bitmap_ & kPointerTag; }
|
||||
|
||||
void Allocate(size_t buckets) {
|
||||
DCHECK(!IsAllocated());
|
||||
size_t words = WordsForBuckets(buckets);
|
||||
uintptr_t* ptr = reinterpret_cast<uintptr_t*>(
|
||||
AlignedAlloc(words * kWordSize, kSystemPointerSize));
|
||||
ptr[0] = bitmap_ >> 1;
|
||||
|
||||
for (size_t word_idx = 1; word_idx < words; word_idx++) {
|
||||
ptr[word_idx] = 0;
|
||||
}
|
||||
bitmap_ = reinterpret_cast<Address>(ptr) + kPointerTag;
|
||||
DCHECK(IsAllocated());
|
||||
}
|
||||
|
||||
void InsertAllocated(size_t bucket_index) {
|
||||
DCHECK(IsAllocated());
|
||||
size_t word_idx = bucket_index / kBitsPerWord;
|
||||
uintptr_t* word = BitmapArray() + word_idx;
|
||||
*word |= static_cast<uintptr_t>(1) << (bucket_index % kBitsPerWord);
|
||||
}
|
||||
|
||||
static size_t WordsForBuckets(size_t buckets) {
|
||||
return (buckets + kBitsPerWord - 1) / kBitsPerWord;
|
||||
}
|
||||
|
||||
uintptr_t* BitmapArray() {
|
||||
DCHECK(IsAllocated());
|
||||
return reinterpret_cast<uintptr_t*>(bitmap_ & ~kPointerTag);
|
||||
}
|
||||
|
||||
FRIEND_TEST(PossiblyEmptyBucketsTest, WordsForBuckets);
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(PossiblyEmptyBuckets);
|
||||
};
|
||||
|
||||
STATIC_ASSERT(std::is_standard_layout<PossiblyEmptyBuckets>::value);
|
||||
STATIC_ASSERT(sizeof(PossiblyEmptyBuckets) == kSystemPointerSize);
|
||||
|
||||
// Data structure for maintaining a set of slots in a standard (non-large)
|
||||
// page.
|
||||
// The data structure assumes that the slots are pointer size aligned and
|
||||
@ -35,42 +136,33 @@ class SlotSet {
|
||||
KEEP_EMPTY_BUCKETS // An empty bucket will be kept.
|
||||
};
|
||||
|
||||
enum class PossiblyEmpty : uint8_t {
|
||||
kYes, // Bucket is non-null but might be empty.
|
||||
kNoOrNull, // Bucket is null or cannot be empty.
|
||||
};
|
||||
|
||||
SlotSet() = delete;
|
||||
|
||||
static SlotSet* Allocate(size_t buckets) {
|
||||
// SlotSet* slot_set ----------------------+
|
||||
// |
|
||||
// v
|
||||
// +----------------------+-----------------+-------------------------+
|
||||
// | possibly empty array | initial buckets | buckets array |
|
||||
// +----------------------+-----------------+-------------------------+
|
||||
// 1 byte * buckets pointer-sized pointer-sized * buckets
|
||||
// SlotSet* slot_set --+
|
||||
// |
|
||||
// v
|
||||
// +-----------------+-------------------------+
|
||||
// | initial buckets | buckets array |
|
||||
// +-----------------+-------------------------+
|
||||
// pointer-sized pointer-sized * buckets
|
||||
//
|
||||
//
|
||||
// The SlotSet pointer points to the beginning of the buckets array for
|
||||
// faster access in the write barrier. The number of buckets is needed for
|
||||
// calculating the size of this data structure.
|
||||
// Since pages can shrink we also store the initial_buckets size.
|
||||
//
|
||||
size_t possibly_empty_array_size = PossiblyEmptyArraySize(buckets);
|
||||
size_t buckets_size = buckets * sizeof(Bucket*);
|
||||
size_t size =
|
||||
possibly_empty_array_size + kInitialBucketsSize + buckets_size;
|
||||
size_t size = kInitialBucketsSize + buckets_size;
|
||||
void* allocation = AlignedAlloc(size, kSystemPointerSize);
|
||||
SlotSet* slot_set = reinterpret_cast<SlotSet*>(
|
||||
reinterpret_cast<uint8_t*>(allocation) + possibly_empty_array_size +
|
||||
kInitialBucketsSize);
|
||||
reinterpret_cast<uint8_t*>(allocation) + kInitialBucketsSize);
|
||||
DCHECK(
|
||||
IsAligned(reinterpret_cast<uintptr_t>(slot_set), kSystemPointerSize));
|
||||
#ifdef DEBUG
|
||||
*slot_set->initial_buckets() = buckets;
|
||||
#endif
|
||||
for (size_t i = 0; i < buckets; i++) {
|
||||
*slot_set->bucket(i) = nullptr;
|
||||
*slot_set->possibly_empty(i) = PossiblyEmpty::kNoOrNull;
|
||||
}
|
||||
return slot_set;
|
||||
}
|
||||
@ -82,17 +174,15 @@ class SlotSet {
|
||||
slot_set->ReleaseBucket(i);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
size_t initial_buckets = *slot_set->initial_buckets();
|
||||
|
||||
#ifdef DEBUG
|
||||
for (size_t i = buckets; i < initial_buckets; i++) {
|
||||
DCHECK_NULL(*slot_set->bucket(i));
|
||||
}
|
||||
#endif
|
||||
|
||||
size_t possibly_empty_array_size = PossiblyEmptyArraySize(initial_buckets);
|
||||
AlignedFree(reinterpret_cast<uint8_t*>(slot_set) - kInitialBucketsSize -
|
||||
possibly_empty_array_size);
|
||||
AlignedFree(reinterpret_cast<uint8_t*>(slot_set) - kInitialBucketsSize);
|
||||
}
|
||||
|
||||
static size_t BucketsForSize(size_t size) {
|
||||
@ -260,13 +350,12 @@ class SlotSet {
|
||||
// Assumes that the possibly empty-array was already cleared by
|
||||
// CheckPossiblyEmptyBuckets.
|
||||
template <typename Callback>
|
||||
size_t IterateAndTrackEmptyBuckets(Address chunk_start, size_t buckets,
|
||||
Callback callback,
|
||||
bool* empty_bucket_found) {
|
||||
size_t IterateAndTrackEmptyBuckets(
|
||||
Address chunk_start, size_t buckets, Callback callback,
|
||||
PossiblyEmptyBuckets* possibly_empty_buckets) {
|
||||
return Iterate(chunk_start, buckets, callback,
|
||||
[this, empty_bucket_found](size_t bucket_index) {
|
||||
*possibly_empty(bucket_index) = PossiblyEmpty::kYes;
|
||||
*empty_bucket_found = true;
|
||||
[possibly_empty_buckets, buckets](size_t bucket_index) {
|
||||
possibly_empty_buckets->Insert(bucket_index, buckets);
|
||||
});
|
||||
}
|
||||
|
||||
@ -283,42 +372,33 @@ class SlotSet {
|
||||
|
||||
// Check whether possibly empty buckets are really empty. Empty buckets are
|
||||
// freed and the possibly empty state is cleared for all buckets.
|
||||
bool CheckPossiblyEmptyBuckets(size_t buckets) {
|
||||
bool CheckPossiblyEmptyBuckets(size_t buckets,
|
||||
PossiblyEmptyBuckets* possibly_empty_buckets) {
|
||||
bool empty = true;
|
||||
for (size_t bucket_index = 0; bucket_index < buckets; bucket_index++) {
|
||||
Bucket* bucket = LoadBucket<AccessMode::NON_ATOMIC>(bucket_index);
|
||||
if (bucket) {
|
||||
if (*possibly_empty(bucket_index) == PossiblyEmpty::kYes) {
|
||||
if (possibly_empty_buckets->Contains(bucket_index)) {
|
||||
if (bucket->IsEmpty()) {
|
||||
ReleaseBucket<AccessMode::NON_ATOMIC>(bucket_index);
|
||||
} else {
|
||||
empty = false;
|
||||
}
|
||||
*possibly_empty(bucket_index) = PossiblyEmpty::kNoOrNull;
|
||||
} else {
|
||||
empty = false;
|
||||
}
|
||||
} else {
|
||||
DCHECK_EQ(*possibly_empty(bucket_index), PossiblyEmpty::kNoOrNull);
|
||||
// Unfortunately we cannot DCHECK here that the corresponding bit in
|
||||
// possibly_empty_buckets is not set. After scavenge, the
|
||||
// MergeOldToNewRememberedSets operation might remove a recorded bucket.
|
||||
}
|
||||
}
|
||||
|
||||
possibly_empty_buckets->Release();
|
||||
|
||||
return empty;
|
||||
}
|
||||
|
||||
// Check wether all possibly empty entries are cleared. Only used
|
||||
// for testing in debug-builds.
|
||||
bool IsPossiblyEmptyCleared() {
|
||||
size_t buckets = *initial_buckets();
|
||||
for (size_t bucket_index = 0; bucket_index < buckets; bucket_index++) {
|
||||
if (*possibly_empty(bucket_index) != PossiblyEmpty::kNoOrNull) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static const int kCellsPerBucket = 32;
|
||||
static const int kCellsPerBucketLog2 = 5;
|
||||
static const int kCellSizeBytesLog2 = 2;
|
||||
@ -500,20 +580,15 @@ class SlotSet {
|
||||
*bit_index = static_cast<int>(slot & (kBitsPerCell - 1));
|
||||
}
|
||||
|
||||
static size_t PossiblyEmptyArraySize(size_t buckets) {
|
||||
return (sizeof(PossiblyEmpty) * buckets + (kSystemPointerSize - 1)) /
|
||||
kSystemPointerSize * kSystemPointerSize;
|
||||
}
|
||||
|
||||
Bucket** buckets() { return reinterpret_cast<Bucket**>(this); }
|
||||
Bucket** bucket(size_t bucket_index) { return buckets() + bucket_index; }
|
||||
PossiblyEmpty* possibly_empty(size_t bucket_index) {
|
||||
return reinterpret_cast<PossiblyEmpty*>(buckets()) - kInitialBucketsSize -
|
||||
1 - bucket_index;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
size_t* initial_buckets() { return reinterpret_cast<size_t*>(this) - 1; }
|
||||
static const int kInitialBucketsSize = sizeof(size_t);
|
||||
#else
|
||||
static const int kInitialBucketsSize = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
STATIC_ASSERT(std::is_standard_layout<SlotSet>::value);
|
||||
|
||||
@ -742,6 +742,8 @@ MemoryChunk* MemoryChunk::Initialize(Heap* heap, Address base, size_t size,
|
||||
chunk->code_object_registry_ = nullptr;
|
||||
}
|
||||
|
||||
chunk->possibly_empty_buckets_.Initialize();
|
||||
|
||||
return chunk;
|
||||
}
|
||||
|
||||
@ -1386,6 +1388,7 @@ void MemoryChunk::ReleaseAllocatedMemoryNeededForWritableChunk() {
|
||||
code_object_registry_ = nullptr;
|
||||
}
|
||||
|
||||
possibly_empty_buckets_.Release();
|
||||
ReleaseSlotSet<OLD_TO_NEW>();
|
||||
ReleaseSweepingSlotSet();
|
||||
ReleaseSlotSet<OLD_TO_OLD>();
|
||||
|
||||
@ -24,6 +24,7 @@
|
||||
#include "src/heap/heap.h"
|
||||
#include "src/heap/invalidated-slots.h"
|
||||
#include "src/heap/marking.h"
|
||||
#include "src/heap/slot-set.h"
|
||||
#include "src/objects/free-space.h"
|
||||
#include "src/objects/heap-object.h"
|
||||
#include "src/objects/map.h"
|
||||
@ -622,7 +623,8 @@ class MemoryChunk : public BasicMemoryChunk {
|
||||
+ kSystemPointerSize // LocalArrayBufferTracker* local_tracker_
|
||||
+ kIntptrSize // std::atomic<intptr_t> young_generation_live_byte_count_
|
||||
+ kSystemPointerSize // Bitmap* young_generation_bitmap_
|
||||
+ kSystemPointerSize; // CodeObjectRegistry* code_object_registry_
|
||||
+ kSystemPointerSize // CodeObjectRegistry* code_object_registry_
|
||||
+ kSystemPointerSize; // PossiblyEmptyBuckets possibly_empty_buckets_
|
||||
|
||||
// Page size in bytes. This must be a multiple of the OS page size.
|
||||
static const int kPageSize = 1 << kPageSizeBits;
|
||||
@ -871,6 +873,10 @@ class MemoryChunk : public BasicMemoryChunk {
|
||||
|
||||
FreeList* free_list() { return owner()->free_list(); }
|
||||
|
||||
PossiblyEmptyBuckets* possibly_empty_buckets() {
|
||||
return &possibly_empty_buckets_;
|
||||
}
|
||||
|
||||
protected:
|
||||
static MemoryChunk* Initialize(Heap* heap, Address base, size_t size,
|
||||
Address area_start, Address area_end,
|
||||
@ -966,6 +972,8 @@ class MemoryChunk : public BasicMemoryChunk {
|
||||
|
||||
CodeObjectRegistry* code_object_registry_;
|
||||
|
||||
PossiblyEmptyBuckets possibly_empty_buckets_;
|
||||
|
||||
private:
|
||||
void InitializeReservedMemory() { reservation_.Reset(); }
|
||||
|
||||
|
||||
@ -14,6 +14,28 @@
|
||||
namespace v8 {
|
||||
namespace internal {
|
||||
|
||||
TEST(PossiblyEmptyBucketsTest, WordsForBuckets) {
|
||||
EXPECT_EQ(
|
||||
PossiblyEmptyBuckets::WordsForBuckets(PossiblyEmptyBuckets::kBitsPerWord),
|
||||
1U);
|
||||
EXPECT_EQ(PossiblyEmptyBuckets::WordsForBuckets(
|
||||
PossiblyEmptyBuckets::kBitsPerWord - 1),
|
||||
1U);
|
||||
EXPECT_EQ(PossiblyEmptyBuckets::WordsForBuckets(
|
||||
PossiblyEmptyBuckets::kBitsPerWord + 1),
|
||||
2U);
|
||||
|
||||
EXPECT_EQ(PossiblyEmptyBuckets::WordsForBuckets(
|
||||
5 * PossiblyEmptyBuckets::kBitsPerWord - 1),
|
||||
5U);
|
||||
EXPECT_EQ(PossiblyEmptyBuckets::WordsForBuckets(
|
||||
5 * PossiblyEmptyBuckets::kBitsPerWord),
|
||||
5U);
|
||||
EXPECT_EQ(PossiblyEmptyBuckets::WordsForBuckets(
|
||||
5 * PossiblyEmptyBuckets::kBitsPerWord + 1),
|
||||
6U);
|
||||
}
|
||||
|
||||
TEST(SlotSet, BucketsForSize) {
|
||||
EXPECT_EQ(static_cast<size_t>(SlotSet::kBucketsRegularPage),
|
||||
SlotSet::BucketsForSize(Page::kPageSize));
|
||||
@ -110,6 +132,20 @@ TEST(SlotSet, Remove) {
|
||||
SlotSet::Delete(set, SlotSet::kBucketsRegularPage);
|
||||
}
|
||||
|
||||
TEST(PossiblyEmptyBuckets, ContainsAndInsert) {
|
||||
static const int kBuckets = 100;
|
||||
PossiblyEmptyBuckets possibly_empty_buckets;
|
||||
possibly_empty_buckets.Insert(0, kBuckets);
|
||||
int last = sizeof(uintptr_t) * kBitsPerByte - 2;
|
||||
possibly_empty_buckets.Insert(last, kBuckets);
|
||||
EXPECT_TRUE(possibly_empty_buckets.Contains(0));
|
||||
EXPECT_TRUE(possibly_empty_buckets.Contains(last));
|
||||
possibly_empty_buckets.Insert(last + 1, kBuckets);
|
||||
EXPECT_TRUE(possibly_empty_buckets.Contains(0));
|
||||
EXPECT_TRUE(possibly_empty_buckets.Contains(last));
|
||||
EXPECT_TRUE(possibly_empty_buckets.Contains(last + 1));
|
||||
}
|
||||
|
||||
void CheckRemoveRangeOn(uint32_t start, uint32_t end) {
|
||||
SlotSet* set = SlotSet::Allocate(SlotSet::kBucketsRegularPage);
|
||||
uint32_t first = start == 0 ? 0 : start - kTaggedSize;
|
||||
|
||||
@ -190,227 +190,227 @@ INSTANCE_TYPES = {
|
||||
|
||||
# List of known V8 maps.
|
||||
KNOWN_MAPS = {
|
||||
("read_only_space", 0x00119): (160, "FreeSpaceMap"),
|
||||
("read_only_space", 0x00141): (161, "MetaMap"),
|
||||
("read_only_space", 0x00185): (67, "NullMap"),
|
||||
("read_only_space", 0x001bd): (155, "DescriptorArrayMap"),
|
||||
("read_only_space", 0x001ed): (150, "WeakFixedArrayMap"),
|
||||
("read_only_space", 0x00215): (159, "OnePointerFillerMap"),
|
||||
("read_only_space", 0x0023d): (159, "TwoPointerFillerMap"),
|
||||
("read_only_space", 0x00281): (67, "UninitializedMap"),
|
||||
("read_only_space", 0x002c5): (8, "OneByteInternalizedStringMap"),
|
||||
("read_only_space", 0x00321): (67, "UndefinedMap"),
|
||||
("read_only_space", 0x00355): (66, "HeapNumberMap"),
|
||||
("read_only_space", 0x00399): (67, "TheHoleMap"),
|
||||
("read_only_space", 0x003f9): (67, "BooleanMap"),
|
||||
("read_only_space", 0x00481): (132, "ByteArrayMap"),
|
||||
("read_only_space", 0x004a9): (117, "FixedArrayMap"),
|
||||
("read_only_space", 0x004d1): (117, "FixedCOWArrayMap"),
|
||||
("read_only_space", 0x004f9): (118, "HashTableMap"),
|
||||
("read_only_space", 0x00521): (64, "SymbolMap"),
|
||||
("read_only_space", 0x00549): (40, "OneByteStringMap"),
|
||||
("read_only_space", 0x00571): (130, "ScopeInfoMap"),
|
||||
("read_only_space", 0x00599): (165, "SharedFunctionInfoMap"),
|
||||
("read_only_space", 0x005c1): (153, "CodeMap"),
|
||||
("read_only_space", 0x005e9): (152, "CellMap"),
|
||||
("read_only_space", 0x00611): (164, "GlobalPropertyCellMap"),
|
||||
("read_only_space", 0x00639): (70, "ForeignMap"),
|
||||
("read_only_space", 0x00661): (151, "TransitionArrayMap"),
|
||||
("read_only_space", 0x00689): (45, "ThinOneByteStringMap"),
|
||||
("read_only_space", 0x006b1): (158, "FeedbackVectorMap"),
|
||||
("read_only_space", 0x00705): (67, "ArgumentsMarkerMap"),
|
||||
("read_only_space", 0x00765): (67, "ExceptionMap"),
|
||||
("read_only_space", 0x007c1): (67, "TerminationExceptionMap"),
|
||||
("read_only_space", 0x00829): (67, "OptimizedOutMap"),
|
||||
("read_only_space", 0x00889): (67, "StaleRegisterMap"),
|
||||
("read_only_space", 0x008cd): (131, "ScriptContextTableMap"),
|
||||
("read_only_space", 0x008f5): (128, "ClosureFeedbackCellArrayMap"),
|
||||
("read_only_space", 0x0091d): (157, "FeedbackMetadataArrayMap"),
|
||||
("read_only_space", 0x00945): (117, "ArrayListMap"),
|
||||
("read_only_space", 0x0096d): (65, "BigIntMap"),
|
||||
("read_only_space", 0x00995): (129, "ObjectBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x009bd): (133, "BytecodeArrayMap"),
|
||||
("read_only_space", 0x009e5): (154, "CodeDataContainerMap"),
|
||||
("read_only_space", 0x00a0d): (134, "FixedDoubleArrayMap"),
|
||||
("read_only_space", 0x00a35): (120, "GlobalDictionaryMap"),
|
||||
("read_only_space", 0x00a5d): (93, "ManyClosuresCellMap"),
|
||||
("read_only_space", 0x00a85): (117, "ModuleInfoMap"),
|
||||
("read_only_space", 0x00aad): (121, "NameDictionaryMap"),
|
||||
("read_only_space", 0x00ad5): (93, "NoClosuresCellMap"),
|
||||
("read_only_space", 0x00afd): (122, "NumberDictionaryMap"),
|
||||
("read_only_space", 0x00b25): (93, "OneClosureCellMap"),
|
||||
("read_only_space", 0x00b4d): (123, "OrderedHashMapMap"),
|
||||
("read_only_space", 0x00b75): (124, "OrderedHashSetMap"),
|
||||
("read_only_space", 0x00b9d): (125, "OrderedNameDictionaryMap"),
|
||||
("read_only_space", 0x00bc5): (162, "PreparseDataMap"),
|
||||
("read_only_space", 0x00bed): (163, "PropertyArrayMap"),
|
||||
("read_only_space", 0x00c15): (89, "SideEffectCallHandlerInfoMap"),
|
||||
("read_only_space", 0x00c3d): (89, "SideEffectFreeCallHandlerInfoMap"),
|
||||
("read_only_space", 0x00c65): (89, "NextCallSideEffectFreeCallHandlerInfoMap"),
|
||||
("read_only_space", 0x00c8d): (126, "SimpleNumberDictionaryMap"),
|
||||
("read_only_space", 0x00cb5): (117, "SloppyArgumentsElementsMap"),
|
||||
("read_only_space", 0x00cdd): (145, "SmallOrderedHashMapMap"),
|
||||
("read_only_space", 0x00d05): (146, "SmallOrderedHashSetMap"),
|
||||
("read_only_space", 0x00d2d): (147, "SmallOrderedNameDictionaryMap"),
|
||||
("read_only_space", 0x00d55): (68, "SourceTextModuleMap"),
|
||||
("read_only_space", 0x00d7d): (127, "StringTableMap"),
|
||||
("read_only_space", 0x00da5): (69, "SyntheticModuleMap"),
|
||||
("read_only_space", 0x00dcd): (149, "UncompiledDataWithoutPreparseDataMap"),
|
||||
("read_only_space", 0x00df5): (148, "UncompiledDataWithPreparseDataMap"),
|
||||
("read_only_space", 0x00e1d): (166, "WeakArrayListMap"),
|
||||
("read_only_space", 0x00e45): (119, "EphemeronHashTableMap"),
|
||||
("read_only_space", 0x00e6d): (156, "EmbedderDataArrayMap"),
|
||||
("read_only_space", 0x00e95): (167, "WeakCellMap"),
|
||||
("read_only_space", 0x00ebd): (32, "StringMap"),
|
||||
("read_only_space", 0x00ee5): (41, "ConsOneByteStringMap"),
|
||||
("read_only_space", 0x00f0d): (33, "ConsStringMap"),
|
||||
("read_only_space", 0x00f35): (37, "ThinStringMap"),
|
||||
("read_only_space", 0x00f5d): (35, "SlicedStringMap"),
|
||||
("read_only_space", 0x00f85): (43, "SlicedOneByteStringMap"),
|
||||
("read_only_space", 0x00fad): (34, "ExternalStringMap"),
|
||||
("read_only_space", 0x00fd5): (42, "ExternalOneByteStringMap"),
|
||||
("read_only_space", 0x00ffd): (50, "UncachedExternalStringMap"),
|
||||
("read_only_space", 0x01025): (0, "InternalizedStringMap"),
|
||||
("read_only_space", 0x0104d): (2, "ExternalInternalizedStringMap"),
|
||||
("read_only_space", 0x01075): (10, "ExternalOneByteInternalizedStringMap"),
|
||||
("read_only_space", 0x0109d): (18, "UncachedExternalInternalizedStringMap"),
|
||||
("read_only_space", 0x010c5): (26, "UncachedExternalOneByteInternalizedStringMap"),
|
||||
("read_only_space", 0x010ed): (58, "UncachedExternalOneByteStringMap"),
|
||||
("read_only_space", 0x01115): (67, "SelfReferenceMarkerMap"),
|
||||
("read_only_space", 0x01149): (92, "EnumCacheMap"),
|
||||
("read_only_space", 0x01199): (86, "ArrayBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x01295): (95, "InterceptorInfoMap"),
|
||||
("read_only_space", 0x032ad): (71, "PromiseFulfillReactionJobTaskMap"),
|
||||
("read_only_space", 0x032d5): (72, "PromiseRejectReactionJobTaskMap"),
|
||||
("read_only_space", 0x032fd): (73, "CallableTaskMap"),
|
||||
("read_only_space", 0x03325): (74, "CallbackTaskMap"),
|
||||
("read_only_space", 0x0334d): (75, "PromiseResolveThenableJobTaskMap"),
|
||||
("read_only_space", 0x03375): (78, "FunctionTemplateInfoMap"),
|
||||
("read_only_space", 0x0339d): (79, "ObjectTemplateInfoMap"),
|
||||
("read_only_space", 0x033c5): (80, "AccessCheckInfoMap"),
|
||||
("read_only_space", 0x033ed): (81, "AccessorInfoMap"),
|
||||
("read_only_space", 0x03415): (82, "AccessorPairMap"),
|
||||
("read_only_space", 0x0343d): (83, "AliasedArgumentsEntryMap"),
|
||||
("read_only_space", 0x03465): (84, "AllocationMementoMap"),
|
||||
("read_only_space", 0x0348d): (87, "AsmWasmDataMap"),
|
||||
("read_only_space", 0x034b5): (88, "AsyncGeneratorRequestMap"),
|
||||
("read_only_space", 0x034dd): (90, "ClassPositionsMap"),
|
||||
("read_only_space", 0x03505): (91, "DebugInfoMap"),
|
||||
("read_only_space", 0x0352d): (94, "FunctionTemplateRareDataMap"),
|
||||
("read_only_space", 0x03555): (97, "InterpreterDataMap"),
|
||||
("read_only_space", 0x0357d): (98, "PromiseCapabilityMap"),
|
||||
("read_only_space", 0x035a5): (99, "PromiseReactionMap"),
|
||||
("read_only_space", 0x035cd): (100, "PrototypeInfoMap"),
|
||||
("read_only_space", 0x035f5): (101, "ScriptMap"),
|
||||
("read_only_space", 0x0361d): (105, "SourceTextModuleInfoEntryMap"),
|
||||
("read_only_space", 0x03645): (106, "StackFrameInfoMap"),
|
||||
("read_only_space", 0x0366d): (107, "StackTraceFrameMap"),
|
||||
("read_only_space", 0x03695): (108, "TemplateObjectDescriptionMap"),
|
||||
("read_only_space", 0x036bd): (109, "Tuple2Map"),
|
||||
("read_only_space", 0x036e5): (110, "Tuple3Map"),
|
||||
("read_only_space", 0x0370d): (111, "WasmCapiFunctionDataMap"),
|
||||
("read_only_space", 0x03735): (112, "WasmDebugInfoMap"),
|
||||
("read_only_space", 0x0375d): (113, "WasmExceptionTagMap"),
|
||||
("read_only_space", 0x03785): (114, "WasmExportedFunctionDataMap"),
|
||||
("read_only_space", 0x037ad): (115, "WasmIndirectFunctionTableMap"),
|
||||
("read_only_space", 0x037d5): (116, "WasmJSFunctionDataMap"),
|
||||
("read_only_space", 0x037fd): (96, "InternalClassMap"),
|
||||
("read_only_space", 0x03825): (103, "SmiPairMap"),
|
||||
("read_only_space", 0x0384d): (102, "SmiBoxMap"),
|
||||
("read_only_space", 0x03875): (104, "SortStateMap"),
|
||||
("read_only_space", 0x0389d): (85, "AllocationSiteWithWeakNextMap"),
|
||||
("read_only_space", 0x038c5): (85, "AllocationSiteWithoutWeakNextMap"),
|
||||
("read_only_space", 0x038ed): (76, "LoadHandler1Map"),
|
||||
("read_only_space", 0x03915): (76, "LoadHandler2Map"),
|
||||
("read_only_space", 0x0393d): (76, "LoadHandler3Map"),
|
||||
("read_only_space", 0x03965): (77, "StoreHandler0Map"),
|
||||
("read_only_space", 0x0398d): (77, "StoreHandler1Map"),
|
||||
("read_only_space", 0x039b5): (77, "StoreHandler2Map"),
|
||||
("read_only_space", 0x039dd): (77, "StoreHandler3Map"),
|
||||
("map_space", 0x00119): (1057, "ExternalMap"),
|
||||
("map_space", 0x00141): (1073, "JSMessageObjectMap"),
|
||||
("read_only_space", 0x00121): (160, "FreeSpaceMap"),
|
||||
("read_only_space", 0x00149): (161, "MetaMap"),
|
||||
("read_only_space", 0x0018d): (67, "NullMap"),
|
||||
("read_only_space", 0x001c5): (155, "DescriptorArrayMap"),
|
||||
("read_only_space", 0x001f5): (150, "WeakFixedArrayMap"),
|
||||
("read_only_space", 0x0021d): (159, "OnePointerFillerMap"),
|
||||
("read_only_space", 0x00245): (159, "TwoPointerFillerMap"),
|
||||
("read_only_space", 0x00289): (67, "UninitializedMap"),
|
||||
("read_only_space", 0x002cd): (8, "OneByteInternalizedStringMap"),
|
||||
("read_only_space", 0x00329): (67, "UndefinedMap"),
|
||||
("read_only_space", 0x0035d): (66, "HeapNumberMap"),
|
||||
("read_only_space", 0x003a1): (67, "TheHoleMap"),
|
||||
("read_only_space", 0x00401): (67, "BooleanMap"),
|
||||
("read_only_space", 0x00489): (132, "ByteArrayMap"),
|
||||
("read_only_space", 0x004b1): (117, "FixedArrayMap"),
|
||||
("read_only_space", 0x004d9): (117, "FixedCOWArrayMap"),
|
||||
("read_only_space", 0x00501): (118, "HashTableMap"),
|
||||
("read_only_space", 0x00529): (64, "SymbolMap"),
|
||||
("read_only_space", 0x00551): (40, "OneByteStringMap"),
|
||||
("read_only_space", 0x00579): (130, "ScopeInfoMap"),
|
||||
("read_only_space", 0x005a1): (165, "SharedFunctionInfoMap"),
|
||||
("read_only_space", 0x005c9): (153, "CodeMap"),
|
||||
("read_only_space", 0x005f1): (152, "CellMap"),
|
||||
("read_only_space", 0x00619): (164, "GlobalPropertyCellMap"),
|
||||
("read_only_space", 0x00641): (70, "ForeignMap"),
|
||||
("read_only_space", 0x00669): (151, "TransitionArrayMap"),
|
||||
("read_only_space", 0x00691): (45, "ThinOneByteStringMap"),
|
||||
("read_only_space", 0x006b9): (158, "FeedbackVectorMap"),
|
||||
("read_only_space", 0x0070d): (67, "ArgumentsMarkerMap"),
|
||||
("read_only_space", 0x0076d): (67, "ExceptionMap"),
|
||||
("read_only_space", 0x007c9): (67, "TerminationExceptionMap"),
|
||||
("read_only_space", 0x00831): (67, "OptimizedOutMap"),
|
||||
("read_only_space", 0x00891): (67, "StaleRegisterMap"),
|
||||
("read_only_space", 0x008d5): (131, "ScriptContextTableMap"),
|
||||
("read_only_space", 0x008fd): (128, "ClosureFeedbackCellArrayMap"),
|
||||
("read_only_space", 0x00925): (157, "FeedbackMetadataArrayMap"),
|
||||
("read_only_space", 0x0094d): (117, "ArrayListMap"),
|
||||
("read_only_space", 0x00975): (65, "BigIntMap"),
|
||||
("read_only_space", 0x0099d): (129, "ObjectBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x009c5): (133, "BytecodeArrayMap"),
|
||||
("read_only_space", 0x009ed): (154, "CodeDataContainerMap"),
|
||||
("read_only_space", 0x00a15): (134, "FixedDoubleArrayMap"),
|
||||
("read_only_space", 0x00a3d): (120, "GlobalDictionaryMap"),
|
||||
("read_only_space", 0x00a65): (93, "ManyClosuresCellMap"),
|
||||
("read_only_space", 0x00a8d): (117, "ModuleInfoMap"),
|
||||
("read_only_space", 0x00ab5): (121, "NameDictionaryMap"),
|
||||
("read_only_space", 0x00add): (93, "NoClosuresCellMap"),
|
||||
("read_only_space", 0x00b05): (122, "NumberDictionaryMap"),
|
||||
("read_only_space", 0x00b2d): (93, "OneClosureCellMap"),
|
||||
("read_only_space", 0x00b55): (123, "OrderedHashMapMap"),
|
||||
("read_only_space", 0x00b7d): (124, "OrderedHashSetMap"),
|
||||
("read_only_space", 0x00ba5): (125, "OrderedNameDictionaryMap"),
|
||||
("read_only_space", 0x00bcd): (162, "PreparseDataMap"),
|
||||
("read_only_space", 0x00bf5): (163, "PropertyArrayMap"),
|
||||
("read_only_space", 0x00c1d): (89, "SideEffectCallHandlerInfoMap"),
|
||||
("read_only_space", 0x00c45): (89, "SideEffectFreeCallHandlerInfoMap"),
|
||||
("read_only_space", 0x00c6d): (89, "NextCallSideEffectFreeCallHandlerInfoMap"),
|
||||
("read_only_space", 0x00c95): (126, "SimpleNumberDictionaryMap"),
|
||||
("read_only_space", 0x00cbd): (117, "SloppyArgumentsElementsMap"),
|
||||
("read_only_space", 0x00ce5): (145, "SmallOrderedHashMapMap"),
|
||||
("read_only_space", 0x00d0d): (146, "SmallOrderedHashSetMap"),
|
||||
("read_only_space", 0x00d35): (147, "SmallOrderedNameDictionaryMap"),
|
||||
("read_only_space", 0x00d5d): (68, "SourceTextModuleMap"),
|
||||
("read_only_space", 0x00d85): (127, "StringTableMap"),
|
||||
("read_only_space", 0x00dad): (69, "SyntheticModuleMap"),
|
||||
("read_only_space", 0x00dd5): (149, "UncompiledDataWithoutPreparseDataMap"),
|
||||
("read_only_space", 0x00dfd): (148, "UncompiledDataWithPreparseDataMap"),
|
||||
("read_only_space", 0x00e25): (166, "WeakArrayListMap"),
|
||||
("read_only_space", 0x00e4d): (119, "EphemeronHashTableMap"),
|
||||
("read_only_space", 0x00e75): (156, "EmbedderDataArrayMap"),
|
||||
("read_only_space", 0x00e9d): (167, "WeakCellMap"),
|
||||
("read_only_space", 0x00ec5): (32, "StringMap"),
|
||||
("read_only_space", 0x00eed): (41, "ConsOneByteStringMap"),
|
||||
("read_only_space", 0x00f15): (33, "ConsStringMap"),
|
||||
("read_only_space", 0x00f3d): (37, "ThinStringMap"),
|
||||
("read_only_space", 0x00f65): (35, "SlicedStringMap"),
|
||||
("read_only_space", 0x00f8d): (43, "SlicedOneByteStringMap"),
|
||||
("read_only_space", 0x00fb5): (34, "ExternalStringMap"),
|
||||
("read_only_space", 0x00fdd): (42, "ExternalOneByteStringMap"),
|
||||
("read_only_space", 0x01005): (50, "UncachedExternalStringMap"),
|
||||
("read_only_space", 0x0102d): (0, "InternalizedStringMap"),
|
||||
("read_only_space", 0x01055): (2, "ExternalInternalizedStringMap"),
|
||||
("read_only_space", 0x0107d): (10, "ExternalOneByteInternalizedStringMap"),
|
||||
("read_only_space", 0x010a5): (18, "UncachedExternalInternalizedStringMap"),
|
||||
("read_only_space", 0x010cd): (26, "UncachedExternalOneByteInternalizedStringMap"),
|
||||
("read_only_space", 0x010f5): (58, "UncachedExternalOneByteStringMap"),
|
||||
("read_only_space", 0x0111d): (67, "SelfReferenceMarkerMap"),
|
||||
("read_only_space", 0x01151): (92, "EnumCacheMap"),
|
||||
("read_only_space", 0x011a1): (86, "ArrayBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x0129d): (95, "InterceptorInfoMap"),
|
||||
("read_only_space", 0x032b5): (71, "PromiseFulfillReactionJobTaskMap"),
|
||||
("read_only_space", 0x032dd): (72, "PromiseRejectReactionJobTaskMap"),
|
||||
("read_only_space", 0x03305): (73, "CallableTaskMap"),
|
||||
("read_only_space", 0x0332d): (74, "CallbackTaskMap"),
|
||||
("read_only_space", 0x03355): (75, "PromiseResolveThenableJobTaskMap"),
|
||||
("read_only_space", 0x0337d): (78, "FunctionTemplateInfoMap"),
|
||||
("read_only_space", 0x033a5): (79, "ObjectTemplateInfoMap"),
|
||||
("read_only_space", 0x033cd): (80, "AccessCheckInfoMap"),
|
||||
("read_only_space", 0x033f5): (81, "AccessorInfoMap"),
|
||||
("read_only_space", 0x0341d): (82, "AccessorPairMap"),
|
||||
("read_only_space", 0x03445): (83, "AliasedArgumentsEntryMap"),
|
||||
("read_only_space", 0x0346d): (84, "AllocationMementoMap"),
|
||||
("read_only_space", 0x03495): (87, "AsmWasmDataMap"),
|
||||
("read_only_space", 0x034bd): (88, "AsyncGeneratorRequestMap"),
|
||||
("read_only_space", 0x034e5): (90, "ClassPositionsMap"),
|
||||
("read_only_space", 0x0350d): (91, "DebugInfoMap"),
|
||||
("read_only_space", 0x03535): (94, "FunctionTemplateRareDataMap"),
|
||||
("read_only_space", 0x0355d): (97, "InterpreterDataMap"),
|
||||
("read_only_space", 0x03585): (98, "PromiseCapabilityMap"),
|
||||
("read_only_space", 0x035ad): (99, "PromiseReactionMap"),
|
||||
("read_only_space", 0x035d5): (100, "PrototypeInfoMap"),
|
||||
("read_only_space", 0x035fd): (101, "ScriptMap"),
|
||||
("read_only_space", 0x03625): (105, "SourceTextModuleInfoEntryMap"),
|
||||
("read_only_space", 0x0364d): (106, "StackFrameInfoMap"),
|
||||
("read_only_space", 0x03675): (107, "StackTraceFrameMap"),
|
||||
("read_only_space", 0x0369d): (108, "TemplateObjectDescriptionMap"),
|
||||
("read_only_space", 0x036c5): (109, "Tuple2Map"),
|
||||
("read_only_space", 0x036ed): (110, "Tuple3Map"),
|
||||
("read_only_space", 0x03715): (111, "WasmCapiFunctionDataMap"),
|
||||
("read_only_space", 0x0373d): (112, "WasmDebugInfoMap"),
|
||||
("read_only_space", 0x03765): (113, "WasmExceptionTagMap"),
|
||||
("read_only_space", 0x0378d): (114, "WasmExportedFunctionDataMap"),
|
||||
("read_only_space", 0x037b5): (115, "WasmIndirectFunctionTableMap"),
|
||||
("read_only_space", 0x037dd): (116, "WasmJSFunctionDataMap"),
|
||||
("read_only_space", 0x03805): (96, "InternalClassMap"),
|
||||
("read_only_space", 0x0382d): (103, "SmiPairMap"),
|
||||
("read_only_space", 0x03855): (102, "SmiBoxMap"),
|
||||
("read_only_space", 0x0387d): (104, "SortStateMap"),
|
||||
("read_only_space", 0x038a5): (85, "AllocationSiteWithWeakNextMap"),
|
||||
("read_only_space", 0x038cd): (85, "AllocationSiteWithoutWeakNextMap"),
|
||||
("read_only_space", 0x038f5): (76, "LoadHandler1Map"),
|
||||
("read_only_space", 0x0391d): (76, "LoadHandler2Map"),
|
||||
("read_only_space", 0x03945): (76, "LoadHandler3Map"),
|
||||
("read_only_space", 0x0396d): (77, "StoreHandler0Map"),
|
||||
("read_only_space", 0x03995): (77, "StoreHandler1Map"),
|
||||
("read_only_space", 0x039bd): (77, "StoreHandler2Map"),
|
||||
("read_only_space", 0x039e5): (77, "StoreHandler3Map"),
|
||||
("map_space", 0x00121): (1057, "ExternalMap"),
|
||||
("map_space", 0x00149): (1073, "JSMessageObjectMap"),
|
||||
}
|
||||
|
||||
# List of known V8 objects.
|
||||
KNOWN_OBJECTS = {
|
||||
("read_only_space", 0x00169): "NullValue",
|
||||
("read_only_space", 0x001ad): "EmptyDescriptorArray",
|
||||
("read_only_space", 0x001e5): "EmptyWeakFixedArray",
|
||||
("read_only_space", 0x00265): "UninitializedValue",
|
||||
("read_only_space", 0x00305): "UndefinedValue",
|
||||
("read_only_space", 0x00349): "NanValue",
|
||||
("read_only_space", 0x0037d): "TheHoleValue",
|
||||
("read_only_space", 0x003d1): "HoleNanValue",
|
||||
("read_only_space", 0x003dd): "TrueValue",
|
||||
("read_only_space", 0x00445): "FalseValue",
|
||||
("read_only_space", 0x00475): "empty_string",
|
||||
("read_only_space", 0x006d9): "EmptyScopeInfo",
|
||||
("read_only_space", 0x006e1): "EmptyFixedArray",
|
||||
("read_only_space", 0x006e9): "ArgumentsMarker",
|
||||
("read_only_space", 0x00749): "Exception",
|
||||
("read_only_space", 0x007a5): "TerminationException",
|
||||
("read_only_space", 0x0080d): "OptimizedOut",
|
||||
("read_only_space", 0x0086d): "StaleRegister",
|
||||
("read_only_space", 0x0113d): "EmptyEnumCache",
|
||||
("read_only_space", 0x01171): "EmptyPropertyArray",
|
||||
("read_only_space", 0x01179): "EmptyByteArray",
|
||||
("read_only_space", 0x01181): "EmptyObjectBoilerplateDescription",
|
||||
("read_only_space", 0x0118d): "EmptyArrayBoilerplateDescription",
|
||||
("read_only_space", 0x011c1): "EmptyClosureFeedbackCellArray",
|
||||
("read_only_space", 0x011c9): "EmptySloppyArgumentsElements",
|
||||
("read_only_space", 0x011d9): "EmptySlowElementDictionary",
|
||||
("read_only_space", 0x011fd): "EmptyOrderedHashMap",
|
||||
("read_only_space", 0x01211): "EmptyOrderedHashSet",
|
||||
("read_only_space", 0x01225): "EmptyFeedbackMetadata",
|
||||
("read_only_space", 0x01231): "EmptyPropertyCell",
|
||||
("read_only_space", 0x01245): "EmptyPropertyDictionary",
|
||||
("read_only_space", 0x0126d): "NoOpInterceptorInfo",
|
||||
("read_only_space", 0x012bd): "EmptyWeakArrayList",
|
||||
("read_only_space", 0x012c9): "InfinityValue",
|
||||
("read_only_space", 0x012d5): "MinusZeroValue",
|
||||
("read_only_space", 0x012e1): "MinusInfinityValue",
|
||||
("read_only_space", 0x012ed): "SelfReferenceMarker",
|
||||
("read_only_space", 0x0132d): "OffHeapTrampolineRelocationInfo",
|
||||
("read_only_space", 0x01339): "TrampolineTrivialCodeDataContainer",
|
||||
("read_only_space", 0x01345): "TrampolinePromiseRejectionCodeDataContainer",
|
||||
("read_only_space", 0x01351): "GlobalThisBindingScopeInfo",
|
||||
("read_only_space", 0x01389): "EmptyFunctionScopeInfo",
|
||||
("read_only_space", 0x013b1): "NativeScopeInfo",
|
||||
("read_only_space", 0x013cd): "HashSeed",
|
||||
("old_space", 0x00119): "ArgumentsIteratorAccessor",
|
||||
("old_space", 0x0015d): "ArrayLengthAccessor",
|
||||
("old_space", 0x001a1): "BoundFunctionLengthAccessor",
|
||||
("old_space", 0x001e5): "BoundFunctionNameAccessor",
|
||||
("old_space", 0x00229): "ErrorStackAccessor",
|
||||
("old_space", 0x0026d): "FunctionArgumentsAccessor",
|
||||
("old_space", 0x002b1): "FunctionCallerAccessor",
|
||||
("old_space", 0x002f5): "FunctionNameAccessor",
|
||||
("old_space", 0x00339): "FunctionLengthAccessor",
|
||||
("old_space", 0x0037d): "FunctionPrototypeAccessor",
|
||||
("old_space", 0x003c1): "RegExpResultIndicesAccessor",
|
||||
("old_space", 0x00405): "StringLengthAccessor",
|
||||
("old_space", 0x00449): "InvalidPrototypeValidityCell",
|
||||
("old_space", 0x00451): "EmptyScript",
|
||||
("old_space", 0x00491): "ManyClosuresCell",
|
||||
("old_space", 0x0049d): "ArrayConstructorProtector",
|
||||
("old_space", 0x004b1): "NoElementsProtector",
|
||||
("old_space", 0x004c5): "IsConcatSpreadableProtector",
|
||||
("old_space", 0x004d9): "ArraySpeciesProtector",
|
||||
("old_space", 0x004ed): "TypedArraySpeciesProtector",
|
||||
("old_space", 0x00501): "PromiseSpeciesProtector",
|
||||
("old_space", 0x00515): "StringLengthProtector",
|
||||
("old_space", 0x00529): "ArrayIteratorProtector",
|
||||
("old_space", 0x0053d): "ArrayBufferDetachingProtector",
|
||||
("old_space", 0x00551): "PromiseHookProtector",
|
||||
("old_space", 0x00565): "PromiseResolveProtector",
|
||||
("old_space", 0x00579): "MapIteratorProtector",
|
||||
("old_space", 0x0058d): "PromiseThenProtector",
|
||||
("old_space", 0x005a1): "SetIteratorProtector",
|
||||
("old_space", 0x005b5): "StringIteratorProtector",
|
||||
("old_space", 0x005c9): "SingleCharacterStringCache",
|
||||
("old_space", 0x009d1): "StringSplitCache",
|
||||
("old_space", 0x00dd9): "RegExpMultipleCache",
|
||||
("old_space", 0x011e1): "BuiltinsConstantsTable",
|
||||
("read_only_space", 0x00171): "NullValue",
|
||||
("read_only_space", 0x001b5): "EmptyDescriptorArray",
|
||||
("read_only_space", 0x001ed): "EmptyWeakFixedArray",
|
||||
("read_only_space", 0x0026d): "UninitializedValue",
|
||||
("read_only_space", 0x0030d): "UndefinedValue",
|
||||
("read_only_space", 0x00351): "NanValue",
|
||||
("read_only_space", 0x00385): "TheHoleValue",
|
||||
("read_only_space", 0x003d9): "HoleNanValue",
|
||||
("read_only_space", 0x003e5): "TrueValue",
|
||||
("read_only_space", 0x0044d): "FalseValue",
|
||||
("read_only_space", 0x0047d): "empty_string",
|
||||
("read_only_space", 0x006e1): "EmptyScopeInfo",
|
||||
("read_only_space", 0x006e9): "EmptyFixedArray",
|
||||
("read_only_space", 0x006f1): "ArgumentsMarker",
|
||||
("read_only_space", 0x00751): "Exception",
|
||||
("read_only_space", 0x007ad): "TerminationException",
|
||||
("read_only_space", 0x00815): "OptimizedOut",
|
||||
("read_only_space", 0x00875): "StaleRegister",
|
||||
("read_only_space", 0x01145): "EmptyEnumCache",
|
||||
("read_only_space", 0x01179): "EmptyPropertyArray",
|
||||
("read_only_space", 0x01181): "EmptyByteArray",
|
||||
("read_only_space", 0x01189): "EmptyObjectBoilerplateDescription",
|
||||
("read_only_space", 0x01195): "EmptyArrayBoilerplateDescription",
|
||||
("read_only_space", 0x011c9): "EmptyClosureFeedbackCellArray",
|
||||
("read_only_space", 0x011d1): "EmptySloppyArgumentsElements",
|
||||
("read_only_space", 0x011e1): "EmptySlowElementDictionary",
|
||||
("read_only_space", 0x01205): "EmptyOrderedHashMap",
|
||||
("read_only_space", 0x01219): "EmptyOrderedHashSet",
|
||||
("read_only_space", 0x0122d): "EmptyFeedbackMetadata",
|
||||
("read_only_space", 0x01239): "EmptyPropertyCell",
|
||||
("read_only_space", 0x0124d): "EmptyPropertyDictionary",
|
||||
("read_only_space", 0x01275): "NoOpInterceptorInfo",
|
||||
("read_only_space", 0x012c5): "EmptyWeakArrayList",
|
||||
("read_only_space", 0x012d1): "InfinityValue",
|
||||
("read_only_space", 0x012dd): "MinusZeroValue",
|
||||
("read_only_space", 0x012e9): "MinusInfinityValue",
|
||||
("read_only_space", 0x012f5): "SelfReferenceMarker",
|
||||
("read_only_space", 0x01335): "OffHeapTrampolineRelocationInfo",
|
||||
("read_only_space", 0x01341): "TrampolineTrivialCodeDataContainer",
|
||||
("read_only_space", 0x0134d): "TrampolinePromiseRejectionCodeDataContainer",
|
||||
("read_only_space", 0x01359): "GlobalThisBindingScopeInfo",
|
||||
("read_only_space", 0x01391): "EmptyFunctionScopeInfo",
|
||||
("read_only_space", 0x013b9): "NativeScopeInfo",
|
||||
("read_only_space", 0x013d5): "HashSeed",
|
||||
("old_space", 0x00121): "ArgumentsIteratorAccessor",
|
||||
("old_space", 0x00165): "ArrayLengthAccessor",
|
||||
("old_space", 0x001a9): "BoundFunctionLengthAccessor",
|
||||
("old_space", 0x001ed): "BoundFunctionNameAccessor",
|
||||
("old_space", 0x00231): "ErrorStackAccessor",
|
||||
("old_space", 0x00275): "FunctionArgumentsAccessor",
|
||||
("old_space", 0x002b9): "FunctionCallerAccessor",
|
||||
("old_space", 0x002fd): "FunctionNameAccessor",
|
||||
("old_space", 0x00341): "FunctionLengthAccessor",
|
||||
("old_space", 0x00385): "FunctionPrototypeAccessor",
|
||||
("old_space", 0x003c9): "RegExpResultIndicesAccessor",
|
||||
("old_space", 0x0040d): "StringLengthAccessor",
|
||||
("old_space", 0x00451): "InvalidPrototypeValidityCell",
|
||||
("old_space", 0x00459): "EmptyScript",
|
||||
("old_space", 0x00499): "ManyClosuresCell",
|
||||
("old_space", 0x004a5): "ArrayConstructorProtector",
|
||||
("old_space", 0x004b9): "NoElementsProtector",
|
||||
("old_space", 0x004cd): "IsConcatSpreadableProtector",
|
||||
("old_space", 0x004e1): "ArraySpeciesProtector",
|
||||
("old_space", 0x004f5): "TypedArraySpeciesProtector",
|
||||
("old_space", 0x00509): "PromiseSpeciesProtector",
|
||||
("old_space", 0x0051d): "StringLengthProtector",
|
||||
("old_space", 0x00531): "ArrayIteratorProtector",
|
||||
("old_space", 0x00545): "ArrayBufferDetachingProtector",
|
||||
("old_space", 0x00559): "PromiseHookProtector",
|
||||
("old_space", 0x0056d): "PromiseResolveProtector",
|
||||
("old_space", 0x00581): "MapIteratorProtector",
|
||||
("old_space", 0x00595): "PromiseThenProtector",
|
||||
("old_space", 0x005a9): "SetIteratorProtector",
|
||||
("old_space", 0x005bd): "StringIteratorProtector",
|
||||
("old_space", 0x005d1): "SingleCharacterStringCache",
|
||||
("old_space", 0x009d9): "StringSplitCache",
|
||||
("old_space", 0x00de1): "RegExpMultipleCache",
|
||||
("old_space", 0x011e9): "BuiltinsConstantsTable",
|
||||
}
|
||||
|
||||
# Lower 32 bits of first page addresses for various heap spaces.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user