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

[in-place weak refs] Use in-place weak refs in DependentCode

Browse Source 
BUG=V8:7308

Change-Id: I4836aaca1474f08098120e6c17cc2b3bd65c70eb
Reviewed-on: https://chromium-review.googlesource.com/1166914
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#54975}
This commit is contained in:
Marja Hölttä 2018-08-08 14:00:48 +02:00 committed by Commit Bot
parent ff4fa92e88
commit e2fb86f804
10 changed files with 197 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/code-stub-assembler.cc
View File

@ -9645,7 +9645,7 @@ TNode<AllocationSite> CodeStubAssembler::CreateAllocationSiteInFeedbackVector(
// Store an empty fixed array for the code dependency. // Store an empty fixed array for the code dependency.
StoreObjectFieldRoot(site, AllocationSite::kDependentCodeOffset, StoreObjectFieldRoot(site, AllocationSite::kDependentCodeOffset,
Heap::kEmptyFixedArrayRootIndex); Heap::kEmptyWeakFixedArrayRootIndex);
// Link the object to the allocation site list // Link the object to the allocation site list
TNode<ExternalReference> site_list = ExternalConstant( TNode<ExternalReference> site_list = ExternalConstant(

21
src/compiler/compilation-dependencies.cc
View File

@ -17,7 +17,7 @@ CompilationDependencies::CompilationDependencies(Isolate* isolate, Zone* zone)
class CompilationDependencies::Dependency : public ZoneObject { class CompilationDependencies::Dependency : public ZoneObject {
public: public:
virtual bool IsValid() const = 0; virtual bool IsValid() const = 0;
virtual void Install(Isolate* isolate, Handle<WeakCell> code) = 0; virtual void Install(Isolate* isolate, MaybeObjectHandle code) = 0;
}; };
class InitialMapDependency final : public CompilationDependencies::Dependency { class InitialMapDependency final : public CompilationDependencies::Dependency {
@ -36,7 +36,7 @@ class InitialMapDependency final : public CompilationDependencies::Dependency {
function->initial_map() == *initial_map_.object<Map>(); function->initial_map() == *initial_map_.object<Map>();
} }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency(isolate, code, initial_map_.object<Map>(), DependentCode::InstallDependency(isolate, code, initial_map_.object<Map>(),
DependentCode::kInitialMapChangedGroup); DependentCode::kInitialMapChangedGroup);
@ -55,7 +55,7 @@ class StableMapDependency final : public CompilationDependencies::Dependency {
bool IsValid() const override { return map_.object<Map>()->is_stable(); } bool IsValid() const override { return map_.object<Map>()->is_stable(); }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency(isolate, code, map_.object<Map>(), DependentCode::InstallDependency(isolate, code, map_.object<Map>(),
DependentCode::kPrototypeCheckGroup); DependentCode::kPrototypeCheckGroup);
@ -73,7 +73,7 @@ class TransitionDependency final : public CompilationDependencies::Dependency {
bool IsValid() const override { return !map_.object<Map>()->is_deprecated(); } bool IsValid() const override { return !map_.object<Map>()->is_deprecated(); }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency(isolate, code, map_.object<Map>(), DependentCode::InstallDependency(isolate, code, map_.object<Map>(),
DependentCode::kTransitionGroup); DependentCode::kTransitionGroup);
@ -97,7 +97,7 @@ class PretenureModeDependency final
return mode_ == site_.object<AllocationSite>()->GetPretenureMode(); return mode_ == site_.object<AllocationSite>()->GetPretenureMode();
} }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency( DependentCode::InstallDependency(
isolate, code, site_.object<AllocationSite>(), isolate, code, site_.object<AllocationSite>(),
@ -127,7 +127,7 @@ class FieldTypeDependency final : public CompilationDependencies::Dependency {
return *type == owner->instance_descriptors()->GetFieldType(descriptor_); return *type == owner->instance_descriptors()->GetFieldType(descriptor_);
} }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency(isolate, code, owner_.object<Map>(), DependentCode::InstallDependency(isolate, code, owner_.object<Map>(),
DependentCode::kFieldOwnerGroup); DependentCode::kFieldOwnerGroup);
@ -157,7 +157,7 @@ class GlobalPropertyDependency final
read_only_ == cell->property_details().IsReadOnly(); read_only_ == cell->property_details().IsReadOnly();
} }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency(isolate, code, DependentCode::InstallDependency(isolate, code,
cell_.object<PropertyCell>(), cell_.object<PropertyCell>(),
@ -181,7 +181,7 @@ class ProtectorDependency final : public CompilationDependencies::Dependency {
return cell->value() == Smi::FromInt(Isolate::kProtectorValid); return cell->value() == Smi::FromInt(Isolate::kProtectorValid);
} }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency(isolate, code, DependentCode::InstallDependency(isolate, code,
cell_.object<PropertyCell>(), cell_.object<PropertyCell>(),
@ -213,7 +213,7 @@ class ElementsKindDependency final
return kind_ == kind; return kind_ == kind;
} }
void Install(Isolate* isolate, Handle<WeakCell> code) override { void Install(Isolate* isolate, MaybeObjectHandle code) override {
SLOW_DCHECK(IsValid()); SLOW_DCHECK(IsValid());
DependentCode::InstallDependency( DependentCode::InstallDependency(
isolate, code, site_.object<AllocationSite>(), isolate, code, site_.object<AllocationSite>(),
@ -304,7 +304,6 @@ bool CompilationDependencies::Commit(Handle<Code> code) {
return false; return false;
} }
Handle<WeakCell> cell = Code::WeakCellFor(code);
for (auto dep : dependencies_) { for (auto dep : dependencies_) {
// Check each dependency's validity again right before installing it, // Check each dependency's validity again right before installing it,
// because a GC can trigger invalidation for some dependency kinds. // because a GC can trigger invalidation for some dependency kinds.
@ -312,7 +311,7 @@ bool CompilationDependencies::Commit(Handle<Code> code) {
dependencies_.clear(); dependencies_.clear();
return false; return false;
} }
dep->Install(isolate, cell); dep->Install(isolate, MaybeObjectHandle::Weak(code));
} }
dependencies_.clear(); dependencies_.clear();
return true; return true;

4
src/heap/factory.cc
View File

@ -1768,7 +1768,7 @@ Handle<PropertyCell> Factory::NewPropertyCell(Handle<Name> name,
HeapObject* result = AllocateRawWithImmortalMap( HeapObject* result = AllocateRawWithImmortalMap(
PropertyCell::kSize, pretenure, *global_property_cell_map()); PropertyCell::kSize, pretenure, *global_property_cell_map());
Handle<PropertyCell> cell(PropertyCell::cast(result), isolate()); Handle<PropertyCell> cell(PropertyCell::cast(result), isolate());
cell->set_dependent_code(DependentCode::cast(*empty_fixed_array()), cell->set_dependent_code(DependentCode::cast(*empty_weak_fixed_array()),
SKIP_WRITE_BARRIER); SKIP_WRITE_BARRIER);
cell->set_property_details(PropertyDetails(Smi::kZero)); cell->set_property_details(PropertyDetails(Smi::kZero));
cell->set_name(*name); cell->set_name(*name);
@ -1857,7 +1857,7 @@ Map* Factory::InitializeMap(Map* map, InstanceType type, int instance_size,
map->set_inobject_properties_start_or_constructor_function_index(0); map->set_inobject_properties_start_or_constructor_function_index(0);
map->set_prototype_validity_cell(Smi::FromInt(Map::kPrototypeChainValid)); map->set_prototype_validity_cell(Smi::FromInt(Map::kPrototypeChainValid));
} }
map->set_dependent_code(DependentCode::cast(*empty_fixed_array()), map->set_dependent_code(DependentCode::cast(*empty_weak_fixed_array()),
SKIP_WRITE_BARRIER); SKIP_WRITE_BARRIER);
map->set_raw_transitions(MaybeObject::FromSmi(Smi::kZero)); map->set_raw_transitions(MaybeObject::FromSmi(Smi::kZero));
map->SetInObjectUnusedPropertyFields(inobject_properties); map->SetInObjectUnusedPropertyFields(inobject_properties);

2
src/heap/setup-heap-internal.cc
View File

@ -145,7 +145,7 @@ AllocationResult Heap::AllocatePartialMap(InstanceType instance_type,
void Heap::FinalizePartialMap(Map* map) { void Heap::FinalizePartialMap(Map* map) {
ReadOnlyRoots roots(this); ReadOnlyRoots roots(this);
map->set_dependent_code(DependentCode::cast(roots.empty_fixed_array())); map->set_dependent_code(DependentCode::cast(roots.empty_weak_fixed_array()));
map->set_raw_transitions(MaybeObject::FromSmi(Smi::kZero)); map->set_raw_transitions(MaybeObject::FromSmi(Smi::kZero));
map->set_instance_descriptors(roots.empty_descriptor_array()); map->set_instance_descriptors(roots.empty_descriptor_array());
if (FLAG_unbox_double_fields) { if (FLAG_unbox_double_fields) {

8
src/objects-inl.h
View File

@ -347,9 +347,9 @@ bool HeapObject::IsTemplateList() const {
} }
bool HeapObject::IsDependentCode() const { bool HeapObject::IsDependentCode() const {
if (!IsFixedArrayExact()) return false; if (!IsWeakFixedArray()) return false;
// There's actually no way to see the difference between a fixed array and // There's actually no way to see the difference between a weak fixed array
// a dependent codes array. // and a dependent codes array.
return true; return true;
} }
@ -1014,7 +1014,7 @@ void AllocationSite::Initialize() {
set_pretenure_data(0); set_pretenure_data(0);
set_pretenure_create_count(0); set_pretenure_create_count(0);
set_dependent_code( set_dependent_code(
DependentCode::cast(GetReadOnlyRoots().empty_fixed_array()), DependentCode::cast(GetReadOnlyRoots().empty_weak_fixed_array()),
SKIP_WRITE_BARRIER); SKIP_WRITE_BARRIER);
} }

49
src/objects.cc
View File

@ -15167,7 +15167,7 @@ void JSArray::SetLength(Handle<JSArray> array, uint32_t new_length) {
array->GetElementsAccessor()->SetLength(array, new_length); array->GetElementsAccessor()->SetLength(array, new_length);
} }
DependentCode* DependentCode::Get(Handle<HeapObject> object) { DependentCode* DependentCode::GetDependentCode(Handle<HeapObject> object) {
if (object->IsMap()) { if (object->IsMap()) {
return Handle<Map>::cast(object)->dependent_code(); return Handle<Map>::cast(object)->dependent_code();
} else if (object->IsPropertyCell()) { } else if (object->IsPropertyCell()) {
@ -15178,7 +15178,8 @@ DependentCode* DependentCode::Get(Handle<HeapObject> object) {
UNREACHABLE(); UNREACHABLE();
} }
void DependentCode::Set(Handle<HeapObject> object, Handle<DependentCode> dep) { void DependentCode::SetDependentCode(Handle<HeapObject> object,
Handle<DependentCode> dep) {
if (object->IsMap()) { if (object->IsMap()) {
Handle<Map>::cast(object)->set_dependent_code(*dep); Handle<Map>::cast(object)->set_dependent_code(*dep);
} else if (object->IsPropertyCell()) { } else if (object->IsPropertyCell()) {
@ -15190,28 +15191,30 @@ void DependentCode::Set(Handle<HeapObject> object, Handle<DependentCode> dep) {
} }
} }
void DependentCode::InstallDependency(Isolate* isolate, Handle<WeakCell> cell, void DependentCode::InstallDependency(Isolate* isolate, MaybeObjectHandle code,
Handle<HeapObject> object, Handle<HeapObject> object,
DependencyGroup group) { DependencyGroup group) {
Handle<DependentCode> old_deps(DependentCode::Get(object), isolate); Handle<DependentCode> old_deps(DependentCode::GetDependentCode(object),
isolate);
Handle<DependentCode> new_deps = Handle<DependentCode> new_deps =
InsertWeakCode(isolate, old_deps, group, cell); InsertWeakCode(isolate, old_deps, group, code);
// Update the list head if necessary. // Update the list head if necessary.
if (!new_deps.is_identical_to(old_deps)) DependentCode::Set(object, new_deps); if (!new_deps.is_identical_to(old_deps))
DependentCode::SetDependentCode(object, new_deps);
} }
Handle<DependentCode> DependentCode::InsertWeakCode( Handle<DependentCode> DependentCode::InsertWeakCode(
Isolate* isolate, Handle<DependentCode> entries, DependencyGroup group, Isolate* isolate, Handle<DependentCode> entries, DependencyGroup group,
Handle<WeakCell> code_cell) { MaybeObjectHandle code) {
if (entries->length() == 0 || entries->group() > group) { if (entries->length() == 0 || entries->group() > group) {
// There is no such group. // There is no such group.
return DependentCode::New(isolate, group, code_cell, entries); return DependentCode::New(isolate, group, code, entries);
} }
if (entries->group() < group) { if (entries->group() < group) {
// The group comes later in the list. // The group comes later in the list.
Handle<DependentCode> old_next(entries->next_link(), isolate); Handle<DependentCode> old_next(entries->next_link(), isolate);
Handle<DependentCode> new_next = Handle<DependentCode> new_next =
InsertWeakCode(isolate, old_next, group, code_cell); InsertWeakCode(isolate, old_next, group, code);
if (!old_next.is_identical_to(new_next)) { if (!old_next.is_identical_to(new_next)) {
entries->set_next_link(*new_next); entries->set_next_link(*new_next);
} }
@ -15221,24 +15224,24 @@ Handle<DependentCode> DependentCode::InsertWeakCode(
int count = entries->count(); int count = entries->count();
// Check for existing entry to avoid duplicates. // Check for existing entry to avoid duplicates.
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
if (entries->object_at(i) == *code_cell) return entries; if (entries->object_at(i) == *code) return entries;
} }
if (entries->length() < kCodesStartIndex + count + 1) { if (entries->length() < kCodesStartIndex + count + 1) {
entries = EnsureSpace(isolate, entries); entries = EnsureSpace(isolate, entries);
// Count could have changed, reload it. // Count could have changed, reload it.
count = entries->count(); count = entries->count();
} }
entries->set_object_at(count, *code_cell); entries->set_object_at(count, *code);
entries->set_count(count + 1); entries->set_count(count + 1);
return entries; return entries;
} }
Handle<DependentCode> DependentCode::New(Isolate* isolate, Handle<DependentCode> DependentCode::New(Isolate* isolate,
DependencyGroup group, DependencyGroup group,
Handle<Object> object, MaybeObjectHandle object,
Handle<DependentCode> next) { Handle<DependentCode> next) {
Handle<DependentCode> result = Handle<DependentCode>::cast( Handle<DependentCode> result = Handle<DependentCode>::cast(
isolate->factory()->NewFixedArray(kCodesStartIndex + 1, TENURED)); isolate->factory()->NewWeakFixedArray(kCodesStartIndex + 1, TENURED));
result->set_next_link(*next); result->set_next_link(*next);
result->set_flags(GroupField::encode(group) | CountField::encode(1)); result->set_flags(GroupField::encode(group) | CountField::encode(1));
result->set_object_at(0, *object); result->set_object_at(0, *object);
@ -15251,7 +15254,7 @@ Handle<DependentCode> DependentCode::EnsureSpace(
int capacity = kCodesStartIndex + DependentCode::Grow(entries->count()); int capacity = kCodesStartIndex + DependentCode::Grow(entries->count());
int grow_by = capacity - entries->length(); int grow_by = capacity - entries->length();
return Handle<DependentCode>::cast( return Handle<DependentCode>::cast(
isolate->factory()->CopyFixedArrayAndGrow(entries, grow_by, TENURED)); isolate->factory()->CopyWeakFixedArrayAndGrow(entries, grow_by, TENURED));
} }
@ -15259,8 +15262,8 @@ bool DependentCode::Compact() {
int old_count = count(); int old_count = count();
int new_count = 0; int new_count = 0;
for (int i = 0; i < old_count; i++) { for (int i = 0; i < old_count; i++) {
Object* obj = object_at(i); MaybeObject* obj = object_at(i);
if (!obj->IsWeakCell() || !WeakCell::cast(obj)->cleared()) { if (!obj->IsClearedWeakHeapObject()) {
if (i != new_count) { if (i != new_count) {
copy(i, new_count); copy(i, new_count);
} }
@ -15274,20 +15277,19 @@ bool DependentCode::Compact() {
return new_count < old_count; return new_count < old_count;
} }
bool DependentCode::Contains(DependencyGroup group, MaybeObject* code) {
bool DependentCode::Contains(DependencyGroup group, WeakCell* code_cell) {
if (this->length() == 0 || this->group() > group) { if (this->length() == 0 || this->group() > group) {
// There is no such group. // There is no such group.
return false; return false;
} }
if (this->group() < group) { if (this->group() < group) {
// The group comes later in the list. // The group comes later in the list.
return next_link()->Contains(group, code_cell); return next_link()->Contains(group, code);
} }
DCHECK_EQ(group, this->group()); DCHECK_EQ(group, this->group());
int count = this->count(); int count = this->count();
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
if (object_at(i) == code_cell) return true; if (object_at(i) == code) return true;
} }
return false; return false;
} }
@ -15324,10 +15326,9 @@ bool DependentCode::MarkCodeForDeoptimization(
bool marked = false; bool marked = false;
int count = this->count(); int count = this->count();
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Object* obj = object_at(i); MaybeObject* obj = object_at(i);
WeakCell* cell = WeakCell::cast(obj); if (obj->IsClearedWeakHeapObject()) continue;
if (cell->cleared()) continue; Code* code = Code::cast(obj->ToWeakHeapObject());
Code* code = Code::cast(cell->value());
if (!code->marked_for_deoptimization()) { if (!code->marked_for_deoptimization()) {
code->SetMarkedForDeoptimization(DependencyGroupName(group)); code->SetMarkedForDeoptimization(DependencyGroupName(group));
marked = true; marked = true;

24
src/objects/code-inl.h
View File

@ -11,6 +11,7 @@
#include "src/isolate.h" #include "src/isolate.h"
#include "src/objects/dictionary.h" #include "src/objects/dictionary.h"
#include "src/objects/map-inl.h" #include "src/objects/map-inl.h"
#include "src/objects/maybe-object-inl.h"
#include "src/v8memory.h" #include "src/v8memory.h"
// Has to be the last include (doesn't have include guards): // Has to be the last include (doesn't have include guards):
@ -132,17 +133,17 @@ BytecodeArray* AbstractCode::GetBytecodeArray() {
} }
DependentCode* DependentCode::next_link() { DependentCode* DependentCode::next_link() {
return DependentCode::cast(get(kNextLinkIndex)); return DependentCode::cast(Get(kNextLinkIndex)->ToStrongHeapObject());
} }
void DependentCode::set_next_link(DependentCode* next) { void DependentCode::set_next_link(DependentCode* next) {
set(kNextLinkIndex, next); Set(kNextLinkIndex, HeapObjectReference::Strong(next));
} }
int DependentCode::flags() { return Smi::ToInt(get(kFlagsIndex)); } int DependentCode::flags() { return Smi::ToInt(Get(kFlagsIndex)->ToSmi()); }
void DependentCode::set_flags(int flags) { void DependentCode::set_flags(int flags) {
set(kFlagsIndex, Smi::FromInt(flags)); Set(kFlagsIndex, MaybeObject::FromObject(Smi::FromInt(flags)));
} }
int DependentCode::count() { return CountField::decode(flags()); } int DependentCode::count() { return CountField::decode(flags()); }
@ -155,16 +156,21 @@ DependentCode::DependencyGroup DependentCode::group() {
return static_cast<DependencyGroup>(GroupField::decode(flags())); return static_cast<DependencyGroup>(GroupField::decode(flags()));
} }
void DependentCode::set_object_at(int i, Object* object) { void DependentCode::set_object_at(int i, MaybeObject* object) {
set(kCodesStartIndex + i, object); Set(kCodesStartIndex + i, object);
} }
Object* DependentCode::object_at(int i) { return get(kCodesStartIndex + i); } MaybeObject* DependentCode::object_at(int i) {
return Get(kCodesStartIndex + i);
}
void DependentCode::clear_at(int i) { set_undefined(kCodesStartIndex + i); } void DependentCode::clear_at(int i) {
Set(kCodesStartIndex + i,
HeapObjectReference::Strong(GetReadOnlyRoots().undefined_value()));
}
void DependentCode::copy(int from, int to) { void DependentCode::copy(int from, int to) {
set(kCodesStartIndex + to, get(kCodesStartIndex + from)); Set(kCodesStartIndex + to, Get(kCodesStartIndex + from));
} }
INT_ACCESSORS(Code, raw_instruction_size, kInstructionSizeOffset) INT_ACCESSORS(Code, raw_instruction_size, kInstructionSizeOffset)

31
src/objects/code.h
View File

@ -577,10 +577,10 @@ class AbstractCode : public HeapObject, public NeverReadOnlySpaceObject {
static const int kMaxLoopNestingMarker = 6; static const int kMaxLoopNestingMarker = 6;
}; };
// Dependent code is a singly linked list of fixed arrays. Each array contains // Dependent code is a singly linked list of weak fixed arrays. Each array
// code objects in weak cells for one dependent group. The suffix of the array // contains weak pointers to code objects for one dependent group. The suffix of
// can be filled with the undefined value if the number of codes is less than // the array can be filled with the undefined value if the number of codes is
// the length of the array. // less than the length of the array.
// //
// +------+-----------------+--------+--------+-----+--------+-----------+-----+ // +------+-----------------+--------+--------+-----+--------+-----------+-----+
// | next | count & group 1 | code 1 | code 2 | ... | code n | undefined | ... | // | next | count & group 1 | code 1 | code 2 | ... | code n | undefined | ... |
@ -592,11 +592,11 @@ class AbstractCode : public HeapObject, public NeverReadOnlySpaceObject {
// +------+-----------------+--------+--------+-----+--------+-----------+-----+ // +------+-----------------+--------+--------+-----+--------+-----------+-----+
// | // |
// V // V
// empty_fixed_array() // empty_weak_fixed_array()
// //
// The list of fixed arrays is ordered by dependency groups. // The list of weak fixed arrays is ordered by dependency groups.
class DependentCode : public FixedArray { class DependentCode : public WeakFixedArray {
public: public:
DECL_CAST(DependentCode) DECL_CAST(DependentCode)
@ -627,11 +627,11 @@ class DependentCode : public FixedArray {
}; };
// Register a code dependency of {cell} on {object}. // Register a code dependency of {cell} on {object}.
static void InstallDependency(Isolate* isolate, Handle<WeakCell> cell, static void InstallDependency(Isolate* isolate, MaybeObjectHandle code,
Handle<HeapObject> object, Handle<HeapObject> object,
DependencyGroup group); DependencyGroup group);
bool Contains(DependencyGroup group, WeakCell* code_cell); bool Contains(DependencyGroup group, MaybeObject* code);
bool IsEmpty(DependencyGroup group); bool IsEmpty(DependencyGroup group);
void DeoptimizeDependentCodeGroup(Isolate* isolate, DependencyGroup group); void DeoptimizeDependentCodeGroup(Isolate* isolate, DependencyGroup group);
@ -640,7 +640,7 @@ class DependentCode : public FixedArray {
// The following low-level accessors are exposed only for tests. // The following low-level accessors are exposed only for tests.
inline DependencyGroup group(); inline DependencyGroup group();
inline Object* object_at(int i); inline MaybeObject* object_at(int i);
inline int count(); inline int count();
inline DependentCode* next_link(); inline DependentCode* next_link();
@ -648,18 +648,19 @@ class DependentCode : public FixedArray {
static const char* DependencyGroupName(DependencyGroup group); static const char* DependencyGroupName(DependencyGroup group);
// Get/Set {object}'s {DependentCode}. // Get/Set {object}'s {DependentCode}.
static DependentCode* Get(Handle<HeapObject> object); static DependentCode* GetDependentCode(Handle<HeapObject> object);
static void Set(Handle<HeapObject> object, Handle<DependentCode> dep); static void SetDependentCode(Handle<HeapObject> object,
Handle<DependentCode> dep);
static Handle<DependentCode> New(Isolate* isolate, DependencyGroup group, static Handle<DependentCode> New(Isolate* isolate, DependencyGroup group,
Handle<Object> object, MaybeObjectHandle object,
Handle<DependentCode> next); Handle<DependentCode> next);
static Handle<DependentCode> EnsureSpace(Isolate* isolate, static Handle<DependentCode> EnsureSpace(Isolate* isolate,
Handle<DependentCode> entries); Handle<DependentCode> entries);
static Handle<DependentCode> InsertWeakCode(Isolate* isolate, static Handle<DependentCode> InsertWeakCode(Isolate* isolate,
Handle<DependentCode> entries, Handle<DependentCode> entries,
DependencyGroup group, DependencyGroup group,
Handle<WeakCell> code_cell); MaybeObjectHandle code);
// Compact by removing cleared weak cells and return true if there was // Compact by removing cleared weak cells and return true if there was
// any cleared weak cell. // any cleared weak cell.
@ -677,7 +678,7 @@ class DependentCode : public FixedArray {
inline void set_next_link(DependentCode* next); inline void set_next_link(DependentCode* next);
inline void set_count(int value); inline void set_count(int value);
inline void set_object_at(int i, Object* object); inline void set_object_at(int i, MaybeObject* object);
inline void clear_at(int i); inline void clear_at(int i);
inline void copy(int from, int to); inline void copy(int from, int to);

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

@ -3628,15 +3628,15 @@ TEST(EnsureAllocationSiteDependentCodesProcessed) {
int dependency_group_count = 0; int dependency_group_count = 0;
DependentCode* dependency = site->dependent_code(); DependentCode* dependency = site->dependent_code();
while (dependency != ReadOnlyRoots(heap).empty_fixed_array()) { while (dependency != ReadOnlyRoots(heap).empty_weak_fixed_array()) {
CHECK(dependency->group() == CHECK(dependency->group() ==
DependentCode::kAllocationSiteTransitionChangedGroup || DependentCode::kAllocationSiteTransitionChangedGroup ||
dependency->group() == dependency->group() ==
DependentCode::kAllocationSiteTenuringChangedGroup); DependentCode::kAllocationSiteTenuringChangedGroup);
CHECK_EQ(1, dependency->count()); CHECK_EQ(1, dependency->count());
CHECK(dependency->object_at(0)->IsWeakCell()); CHECK(dependency->object_at(0)->IsWeakHeapObject());
Code* function_bar = Code* function_bar =
Code::cast(WeakCell::cast(dependency->object_at(0))->value()); Code::cast(dependency->object_at(0)->ToWeakHeapObject());
CHECK_EQ(bar_handle->code(), function_bar); CHECK_EQ(bar_handle->code(), function_bar);
dependency = dependency->next_link(); dependency = dependency->next_link();
dependency_group_count++; dependency_group_count++;
@ -3653,8 +3653,7 @@ TEST(EnsureAllocationSiteDependentCodesProcessed) {
// The site still exists because of our global handle, but the code is no // The site still exists because of our global handle, but the code is no
// longer referred to by dependent_code(). // longer referred to by dependent_code().
CHECK(site->dependent_code()->object_at(0)->IsWeakCell() && CHECK(site->dependent_code()->object_at(0)->IsClearedWeakHeapObject());
WeakCell::cast(site->dependent_code()->object_at(0))->cleared());
} }
void CheckNumberOfAllocations(Heap* heap, const char* source, void CheckNumberOfAllocations(Heap* heap, const char* source,

238
tools/v8heapconst.py
View File

@ -179,7 +179,7 @@ KNOWN_MAPS = {
("RO_SPACE", 0x02251): (132, "MetaMap"), ("RO_SPACE", 0x02251): (132, "MetaMap"),
("RO_SPACE", 0x022d1): (131, "NullMap"), ("RO_SPACE", 0x022d1): (131, "NullMap"),
("RO_SPACE", 0x02341): (205, "DescriptorArrayMap"), ("RO_SPACE", 0x02341): (205, "DescriptorArrayMap"),
("RO_SPACE", 0x023a1): (182, "FixedArrayMap"), ("RO_SPACE", 0x023a1): (204, "WeakFixedArrayMap"),
("RO_SPACE", 0x023f1): (152, "OnePointerFillerMap"), ("RO_SPACE", 0x023f1): (152, "OnePointerFillerMap"),
("RO_SPACE", 0x02441): (152, "TwoPointerFillerMap"), ("RO_SPACE", 0x02441): (152, "TwoPointerFillerMap"),
("RO_SPACE", 0x024c1): (131, "UninitializedMap"), ("RO_SPACE", 0x024c1): (131, "UninitializedMap"),
@ -189,101 +189,101 @@ KNOWN_MAPS = {
("RO_SPACE", 0x026c1): (131, "TheHoleMap"), ("RO_SPACE", 0x026c1): (131, "TheHoleMap"),
("RO_SPACE", 0x02771): (131, "BooleanMap"), ("RO_SPACE", 0x02771): (131, "BooleanMap"),
("RO_SPACE", 0x02869): (136, "ByteArrayMap"), ("RO_SPACE", 0x02869): (136, "ByteArrayMap"),
("RO_SPACE", 0x028b9): (182, "FixedCOWArrayMap"), ("RO_SPACE", 0x028b9): (182, "FixedArrayMap"),
("RO_SPACE", 0x02909): (184, "HashTableMap"), ("RO_SPACE", 0x02909): (182, "FixedCOWArrayMap"),
("RO_SPACE", 0x02959): (128, "SymbolMap"), ("RO_SPACE", 0x02959): (184, "HashTableMap"),
("RO_SPACE", 0x029a9): (72, "OneByteStringMap"), ("RO_SPACE", 0x029a9): (128, "SymbolMap"),
("RO_SPACE", 0x029f9): (193, "ScopeInfoMap"), ("RO_SPACE", 0x029f9): (72, "OneByteStringMap"),
("RO_SPACE", 0x02a49): (216, "SharedFunctionInfoMap"), ("RO_SPACE", 0x02a49): (193, "ScopeInfoMap"),
("RO_SPACE", 0x02a99): (133, "CodeMap"), ("RO_SPACE", 0x02a99): (216, "SharedFunctionInfoMap"),
("RO_SPACE", 0x02ae9): (199, "FunctionContextMap"), ("RO_SPACE", 0x02ae9): (133, "CodeMap"),
("RO_SPACE", 0x02b39): (208, "CellMap"), ("RO_SPACE", 0x02b39): (199, "FunctionContextMap"),
("RO_SPACE", 0x02b89): (222, "WeakCellMap"), ("RO_SPACE", 0x02b89): (208, "CellMap"),
("RO_SPACE", 0x02bd9): (215, "GlobalPropertyCellMap"), ("RO_SPACE", 0x02bd9): (222, "WeakCellMap"),
("RO_SPACE", 0x02c29): (135, "ForeignMap"), ("RO_SPACE", 0x02c29): (215, "GlobalPropertyCellMap"),
("RO_SPACE", 0x02c79): (206, "TransitionArrayMap"), ("RO_SPACE", 0x02c79): (135, "ForeignMap"),
("RO_SPACE", 0x02cc9): (211, "FeedbackVectorMap"), ("RO_SPACE", 0x02cc9): (206, "TransitionArrayMap"),
("RO_SPACE", 0x02d59): (131, "ArgumentsMarkerMap"), ("RO_SPACE", 0x02d19): (211, "FeedbackVectorMap"),
("RO_SPACE", 0x02e01): (131, "ExceptionMap"), ("RO_SPACE", 0x02db9): (131, "ArgumentsMarkerMap"),
("RO_SPACE", 0x02ea9): (131, "TerminationExceptionMap"), ("RO_SPACE", 0x02e61): (131, "ExceptionMap"),
("RO_SPACE", 0x02f59): (131, "OptimizedOutMap"), ("RO_SPACE", 0x02f09): (131, "TerminationExceptionMap"),
("RO_SPACE", 0x03001): (131, "StaleRegisterMap"), ("RO_SPACE", 0x02fb9): (131, "OptimizedOutMap"),
("RO_SPACE", 0x03079): (201, "NativeContextMap"), ("RO_SPACE", 0x03061): (131, "StaleRegisterMap"),
("RO_SPACE", 0x030c9): (200, "ModuleContextMap"), ("RO_SPACE", 0x030d9): (201, "NativeContextMap"),
("RO_SPACE", 0x03119): (198, "EvalContextMap"), ("RO_SPACE", 0x03129): (200, "ModuleContextMap"),
("RO_SPACE", 0x03169): (202, "ScriptContextMap"), ("RO_SPACE", 0x03179): (198, "EvalContextMap"),
("RO_SPACE", 0x031b9): (195, "BlockContextMap"), ("RO_SPACE", 0x031c9): (202, "ScriptContextMap"),
("RO_SPACE", 0x03209): (196, "CatchContextMap"), ("RO_SPACE", 0x03219): (195, "BlockContextMap"),
("RO_SPACE", 0x03259): (203, "WithContextMap"), ("RO_SPACE", 0x03269): (196, "CatchContextMap"),
("RO_SPACE", 0x032a9): (197, "DebugEvaluateContextMap"), ("RO_SPACE", 0x032b9): (203, "WithContextMap"),
("RO_SPACE", 0x032f9): (194, "ScriptContextTableMap"), ("RO_SPACE", 0x03309): (197, "DebugEvaluateContextMap"),
("RO_SPACE", 0x03349): (151, "FeedbackMetadataArrayMap"), ("RO_SPACE", 0x03359): (194, "ScriptContextTableMap"),
("RO_SPACE", 0x03399): (182, "ArrayListMap"), ("RO_SPACE", 0x033a9): (151, "FeedbackMetadataArrayMap"),
("RO_SPACE", 0x033e9): (130, "BigIntMap"), ("RO_SPACE", 0x033f9): (182, "ArrayListMap"),
("RO_SPACE", 0x03439): (183, "ObjectBoilerplateDescriptionMap"), ("RO_SPACE", 0x03449): (130, "BigIntMap"),
("RO_SPACE", 0x03489): (137, "BytecodeArrayMap"), ("RO_SPACE", 0x03499): (183, "ObjectBoilerplateDescriptionMap"),
("RO_SPACE", 0x034d9): (209, "CodeDataContainerMap"), ("RO_SPACE", 0x034e9): (137, "BytecodeArrayMap"),
("RO_SPACE", 0x03529): (150, "FixedDoubleArrayMap"), ("RO_SPACE", 0x03539): (209, "CodeDataContainerMap"),
("RO_SPACE", 0x03579): (188, "GlobalDictionaryMap"), ("RO_SPACE", 0x03589): (150, "FixedDoubleArrayMap"),
("RO_SPACE", 0x035c9): (210, "ManyClosuresCellMap"), ("RO_SPACE", 0x035d9): (188, "GlobalDictionaryMap"),
("RO_SPACE", 0x03619): (182, "ModuleInfoMap"), ("RO_SPACE", 0x03629): (210, "ManyClosuresCellMap"),
("RO_SPACE", 0x03669): (134, "MutableHeapNumberMap"), ("RO_SPACE", 0x03679): (182, "ModuleInfoMap"),
("RO_SPACE", 0x036b9): (187, "NameDictionaryMap"), ("RO_SPACE", 0x036c9): (134, "MutableHeapNumberMap"),
("RO_SPACE", 0x03709): (210, "NoClosuresCellMap"), ("RO_SPACE", 0x03719): (187, "NameDictionaryMap"),
("RO_SPACE", 0x03759): (189, "NumberDictionaryMap"), ("RO_SPACE", 0x03769): (210, "NoClosuresCellMap"),
("RO_SPACE", 0x037a9): (210, "OneClosureCellMap"), ("RO_SPACE", 0x037b9): (189, "NumberDictionaryMap"),
("RO_SPACE", 0x037f9): (185, "OrderedHashMapMap"), ("RO_SPACE", 0x03809): (210, "OneClosureCellMap"),
("RO_SPACE", 0x03849): (186, "OrderedHashSetMap"), ("RO_SPACE", 0x03859): (185, "OrderedHashMapMap"),
("RO_SPACE", 0x03899): (213, "PreParsedScopeDataMap"), ("RO_SPACE", 0x038a9): (186, "OrderedHashSetMap"),
("RO_SPACE", 0x038e9): (214, "PropertyArrayMap"), ("RO_SPACE", 0x038f9): (213, "PreParsedScopeDataMap"),
("RO_SPACE", 0x03939): (207, "SideEffectCallHandlerInfoMap"), ("RO_SPACE", 0x03949): (214, "PropertyArrayMap"),
("RO_SPACE", 0x03989): (207, "SideEffectFreeCallHandlerInfoMap"), ("RO_SPACE", 0x03999): (207, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x039d9): (207, "NextCallSideEffectFreeCallHandlerInfoMap"), ("RO_SPACE", 0x039e9): (207, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x03a29): (190, "SimpleNumberDictionaryMap"), ("RO_SPACE", 0x03a39): (207, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x03a79): (182, "SloppyArgumentsElementsMap"), ("RO_SPACE", 0x03a89): (190, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x03ac9): (217, "SmallOrderedHashMapMap"), ("RO_SPACE", 0x03ad9): (182, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x03b19): (218, "SmallOrderedHashSetMap"), ("RO_SPACE", 0x03b29): (217, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x03b69): (191, "StringTableMap"), ("RO_SPACE", 0x03b79): (218, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x03bb9): (220, "UncompiledDataWithoutPreParsedScopeMap"), ("RO_SPACE", 0x03bc9): (191, "StringTableMap"),
("RO_SPACE", 0x03c09): (221, "UncompiledDataWithPreParsedScopeMap"), ("RO_SPACE", 0x03c19): (220, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x03c59): (204, "WeakFixedArrayMap"), ("RO_SPACE", 0x03c69): (221, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x03ca9): (223, "WeakArrayListMap"), ("RO_SPACE", 0x03cb9): (223, "WeakArrayListMap"),
("RO_SPACE", 0x03cf9): (192, "EphemeronHashTableMap"), ("RO_SPACE", 0x03d09): (192, "EphemeronHashTableMap"),
("RO_SPACE", 0x03d49): (106, "NativeSourceStringMap"), ("RO_SPACE", 0x03d59): (106, "NativeSourceStringMap"),
("RO_SPACE", 0x03d99): (64, "StringMap"), ("RO_SPACE", 0x03da9): (64, "StringMap"),
("RO_SPACE", 0x03de9): (73, "ConsOneByteStringMap"), ("RO_SPACE", 0x03df9): (73, "ConsOneByteStringMap"),
("RO_SPACE", 0x03e39): (65, "ConsStringMap"), ("RO_SPACE", 0x03e49): (65, "ConsStringMap"),
("RO_SPACE", 0x03e89): (77, "ThinOneByteStringMap"), ("RO_SPACE", 0x03e99): (77, "ThinOneByteStringMap"),
("RO_SPACE", 0x03ed9): (69, "ThinStringMap"), ("RO_SPACE", 0x03ee9): (69, "ThinStringMap"),
("RO_SPACE", 0x03f29): (67, "SlicedStringMap"), ("RO_SPACE", 0x03f39): (67, "SlicedStringMap"),
("RO_SPACE", 0x03f79): (75, "SlicedOneByteStringMap"), ("RO_SPACE", 0x03f89): (75, "SlicedOneByteStringMap"),
("RO_SPACE", 0x03fc9): (66, "ExternalStringMap"), ("RO_SPACE", 0x03fd9): (66, "ExternalStringMap"),
("RO_SPACE", 0x04019): (82, "ExternalStringWithOneByteDataMap"), ("RO_SPACE", 0x04029): (82, "ExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x04069): (74, "ExternalOneByteStringMap"), ("RO_SPACE", 0x04079): (74, "ExternalOneByteStringMap"),
("RO_SPACE", 0x040b9): (98, "ShortExternalStringMap"), ("RO_SPACE", 0x040c9): (98, "ShortExternalStringMap"),
("RO_SPACE", 0x04109): (114, "ShortExternalStringWithOneByteDataMap"), ("RO_SPACE", 0x04119): (114, "ShortExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x04159): (0, "InternalizedStringMap"), ("RO_SPACE", 0x04169): (0, "InternalizedStringMap"),
("RO_SPACE", 0x041a9): (2, "ExternalInternalizedStringMap"), ("RO_SPACE", 0x041b9): (2, "ExternalInternalizedStringMap"),
("RO_SPACE", 0x041f9): (18, "ExternalInternalizedStringWithOneByteDataMap"), ("RO_SPACE", 0x04209): (18, "ExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x04249): (10, "ExternalOneByteInternalizedStringMap"), ("RO_SPACE", 0x04259): (10, "ExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x04299): (34, "ShortExternalInternalizedStringMap"), ("RO_SPACE", 0x042a9): (34, "ShortExternalInternalizedStringMap"),
("RO_SPACE", 0x042e9): (50, "ShortExternalInternalizedStringWithOneByteDataMap"), ("RO_SPACE", 0x042f9): (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x04339): (42, "ShortExternalOneByteInternalizedStringMap"), ("RO_SPACE", 0x04349): (42, "ShortExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x04389): (106, "ShortExternalOneByteStringMap"), ("RO_SPACE", 0x04399): (106, "ShortExternalOneByteStringMap"),
("RO_SPACE", 0x043d9): (140, "FixedUint8ArrayMap"), ("RO_SPACE", 0x043e9): (140, "FixedUint8ArrayMap"),
("RO_SPACE", 0x04429): (139, "FixedInt8ArrayMap"), ("RO_SPACE", 0x04439): (139, "FixedInt8ArrayMap"),
("RO_SPACE", 0x04479): (142, "FixedUint16ArrayMap"), ("RO_SPACE", 0x04489): (142, "FixedUint16ArrayMap"),
("RO_SPACE", 0x044c9): (141, "FixedInt16ArrayMap"), ("RO_SPACE", 0x044d9): (141, "FixedInt16ArrayMap"),
("RO_SPACE", 0x04519): (144, "FixedUint32ArrayMap"), ("RO_SPACE", 0x04529): (144, "FixedUint32ArrayMap"),
("RO_SPACE", 0x04569): (143, "FixedInt32ArrayMap"), ("RO_SPACE", 0x04579): (143, "FixedInt32ArrayMap"),
("RO_SPACE", 0x045b9): (145, "FixedFloat32ArrayMap"), ("RO_SPACE", 0x045c9): (145, "FixedFloat32ArrayMap"),
("RO_SPACE", 0x04609): (146, "FixedFloat64ArrayMap"), ("RO_SPACE", 0x04619): (146, "FixedFloat64ArrayMap"),
("RO_SPACE", 0x04659): (147, "FixedUint8ClampedArrayMap"), ("RO_SPACE", 0x04669): (147, "FixedUint8ClampedArrayMap"),
("RO_SPACE", 0x046a9): (149, "FixedBigUint64ArrayMap"), ("RO_SPACE", 0x046b9): (149, "FixedBigUint64ArrayMap"),
("RO_SPACE", 0x046f9): (148, "FixedBigInt64ArrayMap"), ("RO_SPACE", 0x04709): (148, "FixedBigInt64ArrayMap"),
("RO_SPACE", 0x04749): (131, "SelfReferenceMarkerMap"), ("RO_SPACE", 0x04759): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x047b1): (171, "Tuple2Map"), ("RO_SPACE", 0x047c1): (171, "Tuple2Map"),
("RO_SPACE", 0x04ae9): (161, "InterceptorInfoMap"), ("RO_SPACE", 0x04af9): (161, "InterceptorInfoMap"),
("RO_SPACE", 0x04bf1): (169, "ScriptMap"), ("RO_SPACE", 0x04bf1): (169, "ScriptMap"),
("RO_SPACE", 0x09ae1): (154, "AccessorInfoMap"), ("RO_SPACE", 0x09ae1): (154, "AccessorInfoMap"),
("RO_SPACE", 0x09b31): (153, "AccessCheckInfoMap"), ("RO_SPACE", 0x09b31): (153, "AccessCheckInfoMap"),
@ -320,7 +320,6 @@ KNOWN_MAPS = {
KNOWN_OBJECTS = { KNOWN_OBJECTS = {
("RO_SPACE", 0x022a1): "NullValue", ("RO_SPACE", 0x022a1): "NullValue",
("RO_SPACE", 0x02321): "EmptyDescriptorArray", ("RO_SPACE", 0x02321): "EmptyDescriptorArray",
("RO_SPACE", 0x02391): "EmptyFixedArray",
("RO_SPACE", 0x02491): "UninitializedValue", ("RO_SPACE", 0x02491): "UninitializedValue",
("RO_SPACE", 0x025b1): "UndefinedValue", ("RO_SPACE", 0x025b1): "UndefinedValue",
("RO_SPACE", 0x02631): "NanValue", ("RO_SPACE", 0x02631): "NanValue",
@ -329,28 +328,29 @@ KNOWN_OBJECTS = {
("RO_SPACE", 0x02741): "TrueValue", ("RO_SPACE", 0x02741): "TrueValue",
("RO_SPACE", 0x02801): "FalseValue", ("RO_SPACE", 0x02801): "FalseValue",
("RO_SPACE", 0x02851): "empty_string", ("RO_SPACE", 0x02851): "empty_string",
("RO_SPACE", 0x02d19): "EmptyScopeInfo", ("RO_SPACE", 0x02d69): "EmptyScopeInfo",
("RO_SPACE", 0x02d29): "ArgumentsMarker", ("RO_SPACE", 0x02d79): "EmptyFixedArray",
("RO_SPACE", 0x02dd1): "Exception", ("RO_SPACE", 0x02d89): "ArgumentsMarker",
("RO_SPACE", 0x02e79): "TerminationException", ("RO_SPACE", 0x02e31): "Exception",
("RO_SPACE", 0x02f29): "OptimizedOut", ("RO_SPACE", 0x02ed9): "TerminationException",
("RO_SPACE", 0x02fd1): "StaleRegister", ("RO_SPACE", 0x02f89): "OptimizedOut",
("RO_SPACE", 0x04811): "EmptyByteArray", ("RO_SPACE", 0x03031): "StaleRegister",
("RO_SPACE", 0x04839): "EmptyFixedUint8Array", ("RO_SPACE", 0x04821): "EmptyByteArray",
("RO_SPACE", 0x04859): "EmptyFixedInt8Array", ("RO_SPACE", 0x04849): "EmptyFixedUint8Array",
("RO_SPACE", 0x04879): "EmptyFixedUint16Array", ("RO_SPACE", 0x04869): "EmptyFixedInt8Array",
("RO_SPACE", 0x04899): "EmptyFixedInt16Array", ("RO_SPACE", 0x04889): "EmptyFixedUint16Array",
("RO_SPACE", 0x048b9): "EmptyFixedUint32Array", ("RO_SPACE", 0x048a9): "EmptyFixedInt16Array",
("RO_SPACE", 0x048d9): "EmptyFixedInt32Array", ("RO_SPACE", 0x048c9): "EmptyFixedUint32Array",
("RO_SPACE", 0x048f9): "EmptyFixedFloat32Array", ("RO_SPACE", 0x048e9): "EmptyFixedInt32Array",
("RO_SPACE", 0x04919): "EmptyFixedFloat64Array", ("RO_SPACE", 0x04909): "EmptyFixedFloat32Array",
("RO_SPACE", 0x04939): "EmptyFixedUint8ClampedArray", ("RO_SPACE", 0x04929): "EmptyFixedFloat64Array",
("RO_SPACE", 0x04999): "EmptySloppyArgumentsElements", ("RO_SPACE", 0x04949): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x049b9): "EmptySlowElementDictionary", ("RO_SPACE", 0x049a9): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x04a01): "EmptyOrderedHashMap", ("RO_SPACE", 0x049c9): "EmptySlowElementDictionary",
("RO_SPACE", 0x04a29): "EmptyOrderedHashSet", ("RO_SPACE", 0x04a11): "EmptyOrderedHashMap",
("RO_SPACE", 0x04a61): "EmptyPropertyCell", ("RO_SPACE", 0x04a39): "EmptyOrderedHashSet",
("RO_SPACE", 0x04a89): "EmptyWeakCell", ("RO_SPACE", 0x04a71): "EmptyPropertyCell",
("RO_SPACE", 0x04a99): "EmptyWeakCell",
("RO_SPACE", 0x04b61): "InfinityValue", ("RO_SPACE", 0x04b61): "InfinityValue",
("RO_SPACE", 0x04b71): "MinusZeroValue", ("RO_SPACE", 0x04b71): "MinusZeroValue",
("RO_SPACE", 0x04b81): "MinusInfinityValue", ("RO_SPACE", 0x04b81): "MinusInfinityValue",